1 /*

     2 * Copyright (c) 2002-2008 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:  Implementation of CBrowserBookmarksView.

    15 *

    16 */

    17 

    18 // INCLUDE FILES

    19 #include <cdownloadmgruidownloadslist.h>

    20 #include <cdownloadmgruidownloadmenu.h>

    21 #include <eikmenup.h>

    22 #include <aknsfld.h>

    23 #include <smut.h>

    24 #include <IrcMTM.h>

    25 

    26 #ifndef AVERELL2_BLUETOOTH_MISSING

    27     #include <btmsgtypeuid.h>

    28 #endif

    29 

    30 #include <irmsgtypeuid.h>

    31 #include <favouritesdb.h>

    32 

    33 #include <BrowserNG.rsg>

    34 

    35 #include <favouritesitem.h>

    36 #include <favouritesitemlist.h>

    37 #include <ApEngineConsts.h>

    38 #include <ApListItem.h>

    39 #include <ApListItemList.h>

    40 #include <StringLoader.h>

    41 #include <FeatMgr.h>

    42 #include <Uri16.h>

    43 #include <akntoolbar.h>

    44 #ifdef RD_SCALABLE_UI_V2

    45 #include <akntoolbarextension.h>

    46 #endif

    47 

    48 

    49 #include "BrowserDialogs.h"

    50 #include "BrowserBookmarksView.h"

    51 #include "BrowserBookmarksContainer.h"

    52 #include "BrowserBookmarksModel.h"

    53 #include "BrowserFavouritesListbox.h"

    54 #include "BrowserBookmarksEditDialog.h"

    55 #include "BrowserBookmarksGotoPane.h"

    56 #include "CommonConstants.h"

    57 #include "BrowserUtil.h"

    58 #include "BrowserAppUi.h"

    59 #include "Browser.hrh"

    60 #include "CommandVisibility.h"

    61 #include "BrowserBmOTABinSender.h"

    62 #include "CommsModel.h"

    63 #include <mconnection.h>

    64 #include "BrowserUiVariant.hrh"

    65 #include "BrowserWindowManager.h"

    66 #include "BrowserWindow.h"

    67 #include "BrowserDownloadUtil.h"

    68 #include "Display.h"

    69 #include "logger.h"

    70 

    71 #include "eikon.hrh"

    72 

    73 

    74 // CONSTANTS

    75 const TInt KAdaptiveBookmarksFirstPositionInBMView = 0;

    76 const TInt KAdaptiveBookmarksSecondPositionInBMView = 1;

    77 

    78 const TInt KBrowserDesCArrayGranularity = 8;

    79 

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

    81 

    82 // ----------------------------------------------------------------------------

    83 // CBrowserBookmarksView::NewLC

    84 // ----------------------------------------------------------------------------

    85 //

    86 CBrowserBookmarksView* CBrowserBookmarksView::NewLC(

    87         MApiProvider& aApiProvider,

    88         CRecentUrlStore& aRecentUrlStore,

    89         TInt aInitialFolderUid )

    90     {

    91     CBrowserBookmarksView* view = new (ELeave) CBrowserBookmarksView( aApiProvider,

    92                         aRecentUrlStore,

    93                         aInitialFolderUid );

    94     CleanupStack::PushL( view );

    95 

    96     view->ConstructL( R_BROWSER_BOOKMARKS_VIEW );

    97 

    98     return view;

    99     }

   100 

   101 // ----------------------------------------------------------------------------

   102 // CBrowserBookmarksView::~CBrowserBookmarksView

   103 // ----------------------------------------------------------------------------

   104 //

   105 CBrowserBookmarksView::~CBrowserBookmarksView()

   106     {

   107 LOG_ENTERFN("CBrowserBookmarksView::~CBrowserBookmarksView");

   108     delete iDownloadsListExecuter;

   109     iDownloadsListExecuter = 0;

   110 

   111     if ( !ApiProvider().ExitInProgress() )

   112         {

   113         // Remove observers only in destructor. See comment in ConstructL why.

   114         ApiProvider().Preferences().RemoveObserver( this );

   115         ApiProvider().Connection().UnsetApChangeObserver();

   116         }

   117     CBrowserBookmarksContainer* container = TheContainer();

   118     if ( container )

   119         {

   120         container->GotoPane()->SetGPObserver( NULL );

   121         if( ApiProvider().Preferences().SearchFeature() )

   122             container->SearchPane()->SetGPObserver( NULL );

   123         }

   124     delete iDomainFolderName;

   125     delete iItemsToMove;

   126     delete iCurrentOrder;

   127     delete iEnteredURL;

   128     iEnteredURL = NULL;

   129 BROWSER_LOG( ( _L("delete iEnteredUrl 1") ) );

   130     iCursorPos = -1;

   131     }

   132 

   133 // ----------------------------------------------------------------------------

   134 // CBrowserBookmarksView::UpdateGotoPaneL

   135 // ----------------------------------------------------------------------------

   136 //

   137 void CBrowserBookmarksView::UpdateGotoPaneL()

   138     {

   139 LOG_ENTERFN("BookmarksView::UpdateGotoPaneL");

   140     // Simulate cursor movement; that will cancel editing (if editing)

   141     // and refresh Goto Pane.

   142     if ( Container() )

   143         {

   144         if ( iEnteredURL )

   145             {

   146             BROWSER_LOG( ( _L("iEnteredUrl exists") ) );

   147             if ( iCursorPos >=0 )  // update pane only once!

   148                 {

   149                 TheContainer()->GotoPane()->SetTextL(   iEnteredURL->Des(),

   150                                                         EFalse,

   151                                                         EFalse );

   152 

   153                 CEikEdwin* editor = STATIC_CAST( CEikEdwin*,

   154                         TheContainer()->GotoPane()->ComponentControl( 1 ) );

   155                 editor->SetCursorPosL( iCursorPos, EFalse );

   156                 iCursorPos = -1;

   157                 TheContainer()->GotoPane()->SetFocus( ETrue );

   158                 }

   159             }

   160         else

   161             {

   162             Container()->HandleCursorChangedL( Container()->Listbox() );

   163             }

   164         }

   165     }

   166 

   167 // --------------------------------------------------------------------------------

   168 // CBrowserBookmarksView::DeleteItems

   169 // --------------------------------------------------------------------------------

   170 //

   171 void CBrowserBookmarksView::DeleteItems( TInt aCommand )

   172     {

   173 

   174     if (iHandleDeleteInProgress)

   175         return;

   176 

   177     iHandleDeleteInProgress = ETrue;

   178 

   179     const CFavouritesItem* item = Container()->Listbox()->CurrentItem();

   180 

   181     if (!item)

   182         {

   183         return;

   184         }

   185 

   186     if ( item->ParentFolder() == KFavouritesAdaptiveItemsFolderUid )

   187         {

   188         TBool confirm;

   189         CArrayPtr<const CFavouritesItem>* items =  Container()->Listbox()->SelectedItemsLC();

   190 

   191         if ( items->Count() == 1 )

   192             {

   193             confirm = TBrowserDialogs::ConfirmQueryYesNoL( R_BROWSER_FAVOURITES_TEXT_QUERY_COMMON_CONF_DELETE, (*items)[0]->Name());

   194             }

   195         else if (items->Count() > 1)

   196             {

   197             confirm = TBrowserDialogs::ConfirmQueryYesNoL( R_BROWSER_FAVOURITES_TEXT_DEL_ITEMS_QUERY, items->Count());

   198             }

   199         else

   200             {

   201             confirm = EFalse;

   202             }

   203 

   204         if (confirm)

   205             {

   206             for ( TInt i = 0; i < items->Count(); i++ )

   207                 {

   208                 iRecentUrlStore.DeleteData(items->At( i )->Url());

   209                 }

   210             Container()->Listbox()->View()->ClearSelection();

   211             iSaveBMOrder = ETrue;

   212             RefreshL();

   213             }

   214 

   215         CleanupStack::PopAndDestroy();//items

   216         }

   217     else

   218         {

   219         iSaveBMOrder = ETrue;

   220         CBrowserFavouritesView::HandleCommandL( aCommand );

   221         }

   222 

   223     iHandleDeleteInProgress = EFalse;

   224 

   225     }

   226 

   227 // ----------------------------------------------------------------------------

   228 // CBrowserBookmarksView::HandleCommandL

   229 // ----------------------------------------------------------------------------

   230 //

   231 void CBrowserBookmarksView::HandleCommandL( TInt aCommand )

   232     {

   233 LOG_ENTERFN("BookmarksView::HandleCommandL");

   234     //

   235     // FIRST SWITCH Generic CBA commands to original commands

   236     // use ProcessCommandL to route through akn to make sure

   237     // command gets routed to the right place

   238     //

   239     //

   240 

   241     // Assume generic command unless default case, below.

   242     TBool genericCmdHandled = ETrue;

   243 

   244     switch ( aCommand )

   245         {

   246         case EBrowserBookmarksCmdCancel:

   247             {

   248             if ( iManualItemMovingGoingOn )

   249                 {

   250                 ProcessCommandL(EWmlCmdMoveCancel);

   251                 }

   252 			else if( TheContainer() 

   253 			        && ( TheContainer()->GotoPane()->IsEditing() 

   254 			        || TheContainer()->SearchPane()->IsEditing()))

   255                 {

   256                 ProcessCommandL(EWmlCmdGotoPaneCancel);

   257                 }

   258             break;

   259             }

   260         case EBrowserBookmarksCmdOpen:

   261             {

   262             const CFavouritesItem* item = NULL;

   263             if (Container())

   264             {

   265                 item = Container()->Listbox()->CurrentItem();

   266             }

   267 

   268             if ( item && item->IsFolder() )

   269                 {

   270                 ProcessCommandL(EWmlCmdOpenFolder);

   271                 }

   272             else

   273                 {

   274                 ProcessCommandL(EWmlCmdDownload);

   275                 }

   276 

   277             break;

   278             }

   279         case EBrowserBookmarksCmdBack:

   280             {

   281             // default remap is to say back from folder

   282             TInt cmd = EWmlCmdBackFromFolder;

   283 

   284             // unless we have these conditions

   285             if ( !iInAdaptiveBookmarksFolder )

   286                 {

   287                 if ( iCurrentFolder == KFavouritesRootUid )

   288                     {

   289                     if ( ApiProvider().IsPageLoaded() || ApiProvider().Fetching() )

   290                         {

   291                         cmd = EWmlCmdBackToPage;

   292                         }

   293                     }

   294                 }

   295         ProcessCommandL(cmd);

   296         break;

   297             }

   298         default:

   299             {

   300             genericCmdHandled = EFalse;

   301             break;

   302             }

   303         }

   304 

   305     if (genericCmdHandled)

   306         {

   307         return;

   308         }

   309 

   310     //

   311     // EXISTING (regular) command set

   312     //

   313     if ( TheContainer() )

   314     {

   315         switch ( aCommand )

   316         {

   317         // CBA commands.

   318         case EWmlCmdGotoPaneGoTo:

   319             {

   320             if( TheContainer()->GotoPaneActive() )

   321                 {

   322                 if (TheContainer()->GotoPane()->Editor()->TextLength()!= 0)

   323                     {

   324                     // Cancel editing and sets Goto Pane text back.

   325                     if (TheContainer()->GotoPane()->PopupList() != NULL)

   326                         {

   327                         TheContainer()->GotoPane()->PopupList()->SetDirectoryModeL( ETrue );

   328                         TheContainer()->GotoPane()->PopupList()->HidePopupL();

   329                         }

   330                     GotoUrlInGotoPaneL();

   331                     }

   332                 }

   333             else // it was from searchpane 

   334                 {

   335                 if (TheContainer()->SearchPane()->Editor()->TextLength()!= 0)

   336                     {

   337                     // Launch Search application with search parameters

   338                     // and cancel editing of search and goto.

   339                     // Dim Toolbar buttons

   340                     DimToolbarButtons(EFalse);

   341                     HBufC* searchString = TheContainer()->SearchPane()->GetTextL();

   342                     CleanupStack::PushL( searchString );

   343                     if( searchString )

   344                         {

   345                         UpdateCbaL();

   346                         // Set GoTo/Search Inactive

   347                         TheContainer()->SetGotoInactiveL();

   348                         LaunchSearchApplicationL( *searchString );

   349                         }

   350                     CleanupStack::PopAndDestroy( searchString );

   351                     }

   352                 // set LSK to GOTO now

   353                 UpdateCbaL();

   354                 }

   355             break;

   356             }

   357         case EWmlCmdGotoPaneSelect:

   358             {

   359             if (TheContainer()->GotoPane()->Editor()->TextLength()!= 0)

   360                 {

   361                 // Cancel editing and sets Goto Pane text back.

   362                 if (TheContainer()->GotoPane()->PopupList() != NULL)

   363                     {

   364                     TheContainer()->GotoPane()->PopupList()->SetDirectoryModeL( ETrue );

   365                     TheContainer()->GotoPane()->PopupList()->HidePopupL();

   366                     }

   367                 // set LSK to GOTO now

   368                 UpdateCbaL();

   369                 }

   370             break;

   371             }

   372 

   373 

   374         case EWmlCmdNewFolder:

   375             {

   376             TInt uid = CBrowserFavouritesView::AddNewFolderL( );

   377 

   378             AddUidToLastPlaceToCurrentListL(uid);

   379             iRefresh = EFalse;

   380             Model().Database().SetData( CurrentFolder() , *iCurrentOrder );

   381             break;

   382             }

   383         case EWmlCmdMove:

   384             {

   385             StartMoveItemsL();

   386             break;

   387             }

   388         case EWmlCmdMoveOk:

   389             {

   390             MoveItemsL();

   391             break;

   392             }

   393         case EWmlCmdMoveCancel:

   394             {

   395             CancelMoveItemsL();

   396             break;

   397             }

   398 

   399         case EWmlCmdMoveToFolder:

   400             {

   401             iSaveBMOrder = ETrue;

   402             CBrowserFavouritesView::HandleCommandL(aCommand);

   403             break;

   404             }

   405 

   406         case EWmlCmdGotoPaneCancel:

   407             {

   408             // Cancel editing and sets Goto Pane text back.

   409             if (TheContainer()->GotoPane()->PopupList() != NULL)

   410                 {

   411                 TheContainer()->GotoPane()->PopupList()->SetDirectoryModeL( ETrue );

   412                 TheContainer()->GotoPane()->PopupList()->HidePopupL();

   413                 }

   414             delete iEnteredURL;

   415             iEnteredURL = NULL;

   416             BROWSER_LOG( ( _L("delete iEnteredUrl 2") ) );

   417             iCursorPos = -1;

   418 

   419             TheContainer()->SetGotoInactiveL();

   420 

   421             DimToolbarButtons(EFalse);

   422 

   423             break;

   424             }

   425 

   426         // Menu commands.

   427         case EWmlCmdFavourites:

   428             {

   429             if ( iInAdaptiveBookmarksFolder )

   430                 {

   431                 ExitAdaptiveBookmarks();

   432                 }

   433             ApiProvider().SetViewToBeActivatedIfNeededL( KUidBrowserBookmarksViewId );

   434             break;

   435             }

   436 

   437         case EWmlCmdBackToPage:

   438             {

   439             ApiProvider().SetViewToReturnOnClose( KUidBrowserBookmarksViewId );

   440             ApiProvider().SetViewToBeActivatedIfNeededL( KUidBrowserContentViewId );

   441             break;

   442             }

   443 

   444         case EWmlCmdDownload:

   445         case EWmlCmdDownloadPage:

   446             {

   447             ActivateCurrentBookmarkL();

   448             break;

   449             }

   450 

   451 #ifdef __RSS_FEEDS

   452         case EWmlCmdOpenFeedsFolder:

   453             {

   454             ApiProvider().FeedsClientUtilities().ShowFolderViewL();

   455             break;

   456             }

   457 #endif  // __RSS_FEEDS

   458 

   459 

   460         case EWmlCmdLaunchHomePage:

   461             {

   462             AppUi()->HandleCommandL( aCommand );

   463             break;

   464             }

   465 

   466         case EWmlCmdOpenItem:

   467             {

   468             // re-handle the open item command depending on whether a folder or an

   469             // item is selected.

   470             if ( Container() && Container()->Listbox() )

   471                 {

   472                 const CFavouritesItem* item = Container()->Listbox()->CurrentItem();

   473                 if ( item && item->IsFolder() )

   474                     {

   475                     HandleCommandL(EWmlCmdOpenFolder);

   476                     }

   477                 else

   478                     {

   479                     HandleCommandL(EWmlCmdDownload);

   480                     }

   481                 }

   482             break;

   483             }

   484 

   485         case EWmlCmdAddBookmark:

   486             {

   487             AddNewBookmarkL();

   488             break;

   489             }

   490 

   491         case EWmlCmdGoToAddressAndSearch:    

   492         case EWmlCmdGoToAddress: // MSK for Recent Url page

   493         case EWmlCmdSwitchToGotoActive:

   494             {

   495             iSoftKeyUpdate = EFalse;

   496             DimToolbarButtons(ETrue);

   497 #ifdef BRDO_SINGLE_CLICK_ENABLED_FF            

   498             CEikButtonGroupContainer* cba = Cba()->Current();

   499             CEikCba* eikCba = static_cast<CEikCba*>( cba->ButtonGroup() );

   500             if( eikCba )

   501                 {

   502                 eikCba->EnableItemSpecificSoftkey( EFalse );

   503                 }

   504 #endif            

   505             TheContainer()->SetGotoActiveL();

   506             break;

   507             }

   508 

   509         case EIsCmdSearchWeb:

   510         	{

   511         	DimToolbarButtons(ETrue);

   512         	TheContainer()->SetSearchActiveL();

   513         	break;

   514         	}

   515 

   516         case EWmlCmdEditBookmark:

   517             {

   518             EditCurrentBookmarkL();

   519             break;

   520             }

   521 

   522         case EWmlCmdSetAsHomePage:

   523             {

   524             if ( Container() && Container()->Listbox() )

   525                 {

   526                 const CFavouritesItem* item =

   527                                         Container()->Listbox()->CurrentItem();

   528                 if ( item && item->IsItem() &&

   529                     TBrowserDialogs::ConfirmQueryYesNoL(

   530                                     R_QTN_BROWSERBM_QUERY_SET_AS_HOME_PAGE ) )

   531                     {

   532                     ApiProvider().Preferences().SetHomePageUrlL( item->Url() );

   533                     ApiProvider().Preferences().SetHomePageTypeL( EWmlSettingsHomePageAddress );

   534                     }

   535                 }

   536             break;

   537             }

   538 

   539         case EWmlCmdPreferences:

   540             {

   541             CBrowserFavouritesView::HandleCommandL( aCommand );

   542             break;

   543             }

   544 

   545         case EWmlCmdCopyToBookmarks:

   546             {

   547             CArrayPtr<const CFavouritesItem>* items =

   548             Container()->Listbox()->SelectedItemsLC();

   549             if (items->Count())

   550                 {

   551                 // Set WAP AP.

   552                 CFavouritesItem* item;

   553                 for (TInt i=0;i<items->Count();i++)

   554                     {

   555                     item = CFavouritesItem::NewL();

   556                     *item = *( items->At( i ) );

   557                     CleanupStack::PushL( item );

   558                     item->SetParentFolder( KFavouritesRootUid );

   559                     Model().AddL( *item, EFalse, CBrowserFavouritesModel::EAutoRename );

   560                     AddUidToLastPlaceToCurrentListL( item->Uid() );

   561                     CleanupStack::PopAndDestroy();//item

   562                     }

   563                 iRefresh = EFalse;

   564                 Model().Database().SetData( CurrentFolder() , *iCurrentOrder );

   565                 Container()->Listbox()->View()->ClearSelection();

   566                 if (items->Count()==1)

   567                     {

   568                     TBrowserDialogs::InfoNoteL

   569                         (

   570                         R_BROWSER_INFO_NOTE,

   571                         R_BROWSER_ADAPTIVE_BOOKMARKS_ADAPTIVE_BOOKMARK_COPIED

   572                         );

   573                     }

   574                  else

   575                     {

   576                     TBrowserDialogs::InfoNoteL(

   577                         R_BROWSER_INFO_NOTE,

   578                         R_BROWSER_ADAPTIVE_BOOKMARKS_ADAPTIVE_BOOKMARKS_COPIED,

   579                         items->Count() );

   580                     }

   581                 }

   582             CleanupStack::PopAndDestroy();//items

   583             break;

   584             }

   585 

   586         case EWmlCmdRename:

   587             {

   588             // NO rename on menu

   589                 {

   590                 CBrowserFavouritesView::HandleCommandL( aCommand );

   591                 }

   592             break;

   593             }

   594 

   595         case EWmlCmdDelete:

   596             {

   597       DeleteItems( aCommand );

   598       break;

   599       } // case

   600 

   601 

   602         case EWmlCmdClearAdaptiveBookmarks:

   603             {

   604             if ( TBrowserDialogs::ConfirmQueryYesNoL(

   605                     R_BROWSER_ADAPTIVE_BOOKMARKS_DELETE_ALL_ADAPTIVE_BOOKMARKS) )

   606                 {

   607                 ClearAdaptiveBookmarksL();

   608                 }

   609             break;

   610             }

   611 

   612         case EWmlCmdClearAdaptiveBookmarksNoPrompt:

   613             {

   614             ClearAdaptiveBookmarksL();

   615             break;

   616             }

   617 

   618         case EWmlCmdOpenFolder:

   619             {

   620             if ( TheContainer()->GotoPane()->PopupList() )

   621                 {

   622                 if ( TheContainer()->GotoPane()->PopupList()->IsPoppedUp() )

   623                     {

   624                     TheContainer()->GotoPane()->PopupList()->SetDirectoryModeL(

   625                                                                     EFalse );

   626                     break; // This case is supposed to fall through into the next case in certain

   627                            // conditions.

   628                     }

   629                 }

   630             }

   631 

   632         case EWmlCmdOpenMarkedFolder:

   633             {

   634             SetEmptyTextL();

   635             if (Container()->Listbox()->CurrentItem()->Uid() ==

   636                                             KFavouritesAdaptiveItemsFolderUid )

   637                 {

   638                 iAdaptiveBookmarksFolderSelected = ETrue;

   639                 iInAdaptiveBookmarksFolder = ETrue;

   640                 SetEmptyTextL();

   641                 RefreshL();

   642                 }

   643             else

   644                 {

   645                 CBrowserFavouritesView::HandleCommandL( aCommand );

   646                 UpdateToolbarButtonsState();

   647                 }

   648             break;

   649             }

   650 

   651         case EWmlCmdBackFromFolder:

   652             {

   653             Container()->Listbox()->ClearSelection();

   654             if ( iDomainFolderName )

   655                 {

   656                 HBufC* domainFolderNameToHighlight;

   657                 domainFolderNameToHighlight = HBufC::NewL(

   658                                             iDomainFolderName->Length() );

   659                 CleanupStack::PushL( domainFolderNameToHighlight );

   660 

   661                 domainFolderNameToHighlight->Des().Append( *iDomainFolderName );

   662                 delete iDomainFolderName;

   663                 iDomainFolderName = NULL;

   664 

   665                 CFavouritesItemList* items =

   666                             GetItemsLC( KFavouritesAdaptiveItemsFolderUid );

   667                 TInt indexToHighlight = 0;

   668 

   669                 for ( TInt i = 0; i < items->Count(); i++ )

   670                     {

   671                     if ( (*items)[i]->Name() == (*domainFolderNameToHighlight) )

   672                         {

   673                         indexToHighlight = i;

   674                         }

   675                     }

   676 

   677                 CleanupStack::PopAndDestroy();  // items

   678                 CleanupStack::PopAndDestroy();  // domainFolderNameToHighlight

   679 

   680                 HBufC* title;

   681                 title=iCoeEnv->AllocReadResourceLC(

   682                                         R_BROWSER_ADAPTIVE_BOOKMARKS_TITLE );

   683                 ApiProvider().Display().SetTitleL( *title );

   684                 CleanupStack::PopAndDestroy();  // title

   685                 RefreshL();

   686                 Container()->Listbox()->SetCurrentItemIndexAndDraw(

   687                                                             indexToHighlight );

   688                 }

   689             else

   690                 {

   691                 if ( iInAdaptiveBookmarksFolder )

   692                     {

   693                     iAdaptiveBookmarksFolderSelected = EFalse;

   694                     iInAdaptiveBookmarksFolder=EFalse;

   695                     SetEmptyTextL();

   696                     HBufC* title;

   697                     title=iCoeEnv->AllocReadResourceLC(

   698                                         TheContainer()->TitleResourceId() );

   699                     UpdateNaviPaneL();

   700                     ApiProvider().Display().SetTitleL( *title );

   701                     iPreferredHighlightUid=KFavouritesAdaptiveItemsFolderUid;

   702                     CleanupStack::PopAndDestroy();  // title

   703                     RefreshL();

   704                     }

   705                 else

   706                     {

   707                     CBrowserFavouritesView::HandleCommandL( aCommand );

   708                     }

   709                 }

   710             // Back from a folder may require change in toolbar button state

   711             UpdateToolbarButtonsState();

   712             break;

   713             }

   714 

   715         case EWmlCmdSendBookmarkViaUnifiedMessage:

   716             {

   717             // Both case can be handled alike - SendBookmarksL

   718             // uses SelectedItemsLC - this always what we want (if there is

   719             // something marked, those; if no marked, the highlighted one).

   720             SendBookmarksL( );

   721             break;

   722             }

   723 

   724 

   725 #ifdef __SERIES60_HELP

   726         case EAknCmdHelp:

   727             {

   728             STATIC_CAST(CBrowserAppUi*, AppUi())->HandleCommandL(EAknCmdHelp);

   729             break;

   730             }

   731 #endif //__SERIES60_HELP

   732 

   733         case EWmlCmdDownloads:

   734             {

   735             ApiProvider().BrCtlInterface().HandleCommandL(

   736                                             (TInt)TBrCtlDefs::ECommandShowDownloads +

   737                                             (TInt)TBrCtlDefs::ECommandIdBase );

   738             break;

   739             }

   740 

   741         case EWmlCmdDownloadPageNewWindow:

   742             {

   743             const CFavouritesItem* item = Container()->Listbox()->CurrentItem();

   744             if ( item )

   745                 {

   746                 CBrowserAppUi::Static()->OpenLinkInNewWindowL( *item );

   747                 }

   748             break;

   749             }

   750 

   751         default:

   752             {

   753             if (aCommand == EWmlCmdDelete &&

   754                   (Container()->Listbox()->CurrentItem()->ParentFolder()==KFavouritesAdaptiveItemsFolderUid))

   755                {

   756                DeleteItems( aCommand );

   757                break;

   758                }

   759             CBrowserFavouritesView::HandleCommandL( aCommand );

   760             break;

   761             }

   762         }

   763     }

   764     }

   765 

   766 // ----------------------------------------------------------------------------

   767 // CBrowserBookmarksView::SetEmptyTextL

   768 // ----------------------------------------------------------------------------

   769 //

   770 void CBrowserBookmarksView::SetEmptyTextL()

   771     {

   772     HBufC* buf;

   773     if (iInAdaptiveBookmarksFolder)

   774         {

   775         HBufC* title;

   776         if (iDomainFolderName != NULL)

   777             {

   778             ApiProvider().Display().SetTitleL( *iDomainFolderName );

   779             }

   780         else

   781             {

   782             title=iCoeEnv->AllocReadResourceLC( R_BROWSER_ADAPTIVE_BOOKMARKS_TITLE );

   783             ApiProvider().Display().SetTitleL( *title );

   784             CleanupStack::PopAndDestroy();  // title

   785             }

   786         buf = iCoeEnv->AllocReadResourceLC( R_BROWSER_ADAPTIVE_BOOKMARKS_NO_ADAPTIVE_BOOKMARKS );

   787         }

   788     else

   789         {

   790         buf = iCoeEnv->AllocReadResourceLC( TheContainer()->ListboxEmptyTextResourceId() );

   791         }

   792     TheContainer()->Listbox()->View()->SetListEmptyTextL( *buf );

   793     CleanupStack::PopAndDestroy();  // buf

   794     }

   795 

   796 // ----------------------------------------------------------------------------

   797 // CBrowserBookmarksView::Id

   798 // ----------------------------------------------------------------------------

   799 //

   800 TUid CBrowserBookmarksView::Id() const

   801     {

   802     return KUidBrowserBookmarksViewId;

   803     }

   804 

   805 // ----------------------------------------------------------------------------

   806 // CBrowserBookmarksView::CommandSetResourceIdL

   807 // ----------------------------------------------------------------------------

   808 //

   809 TInt CBrowserBookmarksView::CommandSetResourceIdL()

   810     {

   811     // massive re-work for 5.0, to dynamically assign CBA

   812     return(R_BROWSER_BUTTONS_CBA_DYNAMIC);

   813     }

   814 

   815 // ----------------------------------------------------------------------------

   816 // CBrowserBookmarksView::CommandSetResourceDynL

   817 // ----------------------------------------------------------------------------

   818 //

   819 

   820 void CBrowserBookmarksView::CommandSetResourceDynL(TSKPair& aLsk, TSKPair& aRsk, TSKPair& aMsk)

   821 {

   822     //

   823     // Get gotoPane pointer and appropriate Container pointer.

   824     //

   825     // These are passed in to the LSK, RSK, MSK dynamic setting functions

   826     // and used to help chose the appropriate softkeys

   827     //

   828     CBrowserBookmarksGotoPane* gotoPanePtr = NULL;

   829     CBrowserBookmarksContainer* theContainer = TheContainer();

   830 

   831     // if the container doesn't exist, leave gotoPanePtr at NULL

   832     if (theContainer && !iSoftKeyUpdate)

   833         {

   834         gotoPanePtr = theContainer->GotoPane();

   835         }

   836 

   837     // set LSK, RSK, MSK respectively

   838     SetLSKDynL(aLsk, gotoPanePtr);

   839     SetRSKDynL(aRsk, gotoPanePtr);

   840     SetMSKDynL(aMsk, aLsk, theContainer, gotoPanePtr);

   841 

   842     //

   843     // Finally, if the contextual menu command was assigned to the MSK,

   844     // we need to set up the menu now

   845     //

   846     if ( aMsk.id() == EAknSoftkeyContextOptions )

   847     {

   848         ConfigContextMenu();

   849     }

   850 }

   851 

   852 // ----------------------------------------------------------------------------

   853 // CBrowserBookmarksView::SetLSKDynL

   854 // ----------------------------------------------------------------------------

   855 //

   856 

   857 void CBrowserBookmarksView::SetLSKDynL(TSKPair& aLsk,

   858     CBrowserBookmarksGotoPane* aGotoPane)

   859 {

   860     CBrowserBookmarksContainer* theContainer = TheContainer();

   861     CBrowserBookmarksGotoPane* searchPane = NULL;

   862     if( theContainer )

   863         {

   864         searchPane = theContainer->SearchPane();

   865         }

   866     // Default lsk is option

   867     aLsk.setPair(EAknSoftkeyOptions, R_BROWSER_BOOKMARKS_DYN_SK_TEXT_SOFTKEY_OPTION);

   868 

   869     if ( iManualItemMovingGoingOn )

   870         {

   871         aLsk.setPair(EWmlCmdMoveOk, R_BROWSER_BOOKMARKS_DYN_SK_TEXT_SOFTKEY_OK);

   872         }

   873     else if ( aGotoPane && aGotoPane->IsEditing() )

   874         {

   875         // default for goto is go

   876         aLsk.setPair(EWmlCmdGotoPaneGoTo, R_BROWSER_BOOKMARKS_DYN_SK_QTN_WML_SOFTK_GO);

   877 

   878         // special goto cases

   879         if ( ApiProvider().Fetching() )

   880             {

   881             // No assignment. Set as default

   882             aLsk.setPair(EBrowserBookmarksCmdSoftkeyEmpty, R_BROWSER_BOOKMARKS_DYN_SK_TEXT_SOFTKEY_EMPTY);

   883             }

   884         else if (aGotoPane->PopupList() &&

   885                 aGotoPane->PopupList()->IsOpenDirToShow() )

   886             {

   887             aLsk.setPair(EBrowserBookmarksCmdOpen, R_BROWSER_BOOKMARKS_DYN_SK_TEXT_SOFTKEY_OPEN);

   888             }

   889         else if (aGotoPane->PopupList() &&

   890                 aGotoPane->PopupList()->IsPoppedUp() &&

   891                 !iPenEnabled)

   892             {

   893             // LSK Select is only for non-touch devices

   894             aLsk.setPair(EWmlCmdGotoPaneSelect, R_BROWSER_BOOKMARKS_DYN_SK_TEXT_SOFTKEY_SELECT);

   895             }

   896 		}

   897 	else if(  searchPane && searchPane->IsEditing()  )

   898 		{

   899         aLsk.setPair(EWmlCmdGotoPaneGoTo, R_BROWSER_BOOKMARKS_DYN_SK_QTN_IS_SOFTK_SEARCH);

   900 	    }

   901 }

   902 

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

   904 // CBrowserBookmarksView::SetRSKDynL

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

   906 //

   907 

   908 void CBrowserBookmarksView::SetRSKDynL(TSKPair& aRsk,

   909     CBrowserBookmarksGotoPane* aGotoPane)

   910 {

   911     CBrowserBookmarksContainer* theContainer = TheContainer();

   912     CBrowserBookmarksGotoPane* searchPane = NULL;

   913     if( theContainer )

   914         {

   915         searchPane = theContainer->SearchPane();

   916         }

   917     if ( iManualItemMovingGoingOn )

   918         {

   919         aRsk.setPair(EBrowserBookmarksCmdCancel, R_BROWSER_BOOKMARKS_DYN_SK_TEXT_SOFTKEY_CANCEL);

   920         }

   921 	else if( (aGotoPane && aGotoPane->IsEditing()) || (searchPane && searchPane->IsEditing()) )

   922         {

   923         // default for goto is cancel

   924         aRsk.setPair(EBrowserBookmarksCmdCancel, R_BROWSER_BOOKMARKS_DYN_SK_TEXT_SOFTKEY_CANCEL);

   925         }

   926     else

   927         {

   928         // default case for everything else is Back

   929         aRsk.setPair(EBrowserBookmarksCmdBack, R_BROWSER_BOOKMARKS_DYN_SK_TEXT_SOFTKEY_BACK);

   930 

   931         // OR, it could be exit under these conditions

   932         if ( !iInAdaptiveBookmarksFolder && !ApiProvider().IsPageLoaded() && !ApiProvider().Fetching() )

   933             {

   934             if ( iCurrentFolder == KFavouritesRootUid )

   935                 {

   936                 aRsk.setPair(EAknSoftkeyExit, R_BROWSER_BOOKMARKS_DYN_SK_TEXT_SOFTKEY_EXIT);

   937                 }

   938             }

   939         }

   940     }

   941 

   942 // ----------------------------------------------------------------------------

   943 // CBrowserBookmarksView::SetMSKDynL

   944 // ----------------------------------------------------------------------------

   945 //

   946 

   947 void CBrowserBookmarksView::SetMSKDynL(TSKPair& aMsk, const TSKPair aLsk,

   948     CBrowserFavouritesContainer* aContainer,

   949     CBrowserBookmarksGotoPane* aGotoPane)

   950     {

   951     // setup any marked items flag for convenience

   952     // also verify that container is defined

   953     TBool anyMarkedItems = EFalse;

   954     if ( aContainer)

   955         {

   956         anyMarkedItems = aContainer->Listbox()->SelectionStateL().AnyMarked();

   957         }

   958     else

   959         {

   960         return;

   961         }

   962 

   963     //

   964     // Usually, MSK is context menu if marked items.

   965     // The exception is if moving is in progress (and marked items).. then its the dot (in place of OK).

   966     // Otherwise, the Open Command is thrown.

   967     //

   968     if ( anyMarkedItems )

   969         {

   970         if ( iManualItemMovingGoingOn )

   971             {

   972             aMsk.setPair(EWmlCmdMoveOk, R_BROWSER_BOOKMARKS_DYN_SK_TEXT_SOFTKEY_OK);

   973             }

   974         else

   975             {

   976             aMsk.setPair(EAknSoftkeyContextOptions, R_BROWSER_BOOKMARKS_DYN_SK_TEXT_SOFTKEY_OPTION);

   977             }

   978         }

   979     else

   980         {

   981         aMsk.setPair(EBrowserBookmarksCmdOpen, R_BROWSER_BOOKMARKS_DYN_SK_TEXT_SOFTKEY_OPEN);

   982         }

   983 

   984 	CBrowserBookmarksContainer* theContainer = TheContainer();

   985     CBrowserBookmarksGotoPane* searchPane = NULL;

   986 	if( theContainer )

   987 	    {

   988 	    searchPane = theContainer->SearchPane();

   989 	    }

   990     //

   991     // UNDER these special conditions, the msk is set differently:

   992     //

   993     if ( aGotoPane && aGotoPane->IsEditing() )

   994 	    {

   995 		// follow whatever the lsk is set to

   996 		aMsk = aLsk;

   997 	    }

   998 	else if(  searchPane && searchPane->IsEditing() )

   999         {

  1000         // follow whatever the lsk is set to

  1001         aMsk = aLsk;

  1002         }

  1003     else

  1004         {

  1005         if ( iInAdaptiveBookmarksFolder )

  1006             {

  1007             if ( aContainer->Listbox()->UnfilteredNumberOfItems() <= 0 )

  1008                 {

  1009                 aMsk.setPair( EWmlCmdGoToAddress, R_BROWSER_BOOKMARKS_DYN_SK_QTN_BROWSER_MSK_GOTO );

  1010                 }

  1011             }

  1012         else

  1013             {

  1014             if ( (reinterpret_cast <CBrowserAppUi*>(AppUi())->IsEmbeddedModeOn()) ||

  1015                 iCurrentFolder == KFavouritesRootUid )

  1016                 {

  1017                 if ( aContainer->Listbox()->UnfilteredNumberOfItems() <= 0 )

  1018                     {

  1019                     aMsk.setPair( EWmlCmdAddBookmark, R_BROWSER_BOOKMARKS_DYN_SK_QTN_MSK_ADD );

  1020                     }

  1021                 }

  1022             else

  1023                 {

  1024                 if ( aContainer->Listbox()->UnfilteredNumberOfItems() <= 0 )

  1025                     {

  1026                     aMsk.setPair( EWmlCmdAddBookmark, R_BROWSER_BOOKMARKS_DYN_SK_QTN_MSK_ADD );

  1027                     }

  1028                 }

  1029             }

  1030         }

  1031     }

  1032 

  1033 // ----------------------------------------------------------------------------

  1034 // CBrowserBookmarksView::HandleBookmarksGotoPaneEventL

  1035 // ----------------------------------------------------------------------------

  1036 //

  1037 void CBrowserBookmarksView::HandleBookmarksGotoPaneEventL

  1038         (

  1039         CBrowserBookmarksGotoPane*

  1040 #ifdef _DEBUG

  1041         aGotoPane  // used only for debugging purposes

  1042 #endif

  1043         ,

  1044         MBookmarksGotoPaneObserver::TEvent aEvent

  1045         )

  1046     {

  1047 #ifdef _DEBUG

  1048     __ASSERT_DEBUG( aGotoPane == TheContainer()->GotoPane() ||

  1049             aGotoPane == TheContainer()->SearchPane(), \

  1050         Util::Panic( Util::EFavouritesInternal ) );

  1051 #endif

  1052 

  1053     switch ( aEvent )

  1054         {

  1055         case MBookmarksGotoPaneObserver::EEventEnterKeyPressed:

  1056             {

  1057             HandleCommandL( EWmlCmdGotoPaneGoTo );

  1058             break;

  1059             }

  1060 

  1061         case MBookmarksGotoPaneObserver::EEventEditingModeChanged:

  1062             {

  1063             UpdateCbaL();

  1064             break;

  1065             }

  1066 

  1067         default:

  1068             {

  1069             break;

  1070             }

  1071         }

  1072     }

  1073 

  1074 // ----------------------------------------------------------------------------

  1075 // CBrowserBookmarksView::CBrowserBookmarksView

  1076 // ----------------------------------------------------------------------------

  1077 //

  1078 CBrowserBookmarksView::CBrowserBookmarksView (  MApiProvider& aApiProvider,

  1079                                                 CRecentUrlStore& aRecentUrlStore,

  1080                                                 TInt aInitialFolderUid )

  1081     : CBrowserFavouritesView( aApiProvider, aInitialFolderUid ),

  1082         iFetchInit( EFalse ),

  1083 

  1084         iRecentUrlStore (aRecentUrlStore)

  1085 

  1086 

  1087 

  1088     {

  1089     // Initially start with default AP as Start Page AP.

  1090     iCurrentDefaultAp = iStartPageApUid =

  1091                         ApiProvider().Preferences().DefaultAccessPoint();

  1092     iPenEnabled = AknLayoutUtils::PenEnabled();

  1093     iHandleDeleteInProgress = EFalse;

  1094     }

  1095 

  1096 // ----------------------------------------------------------------------------

  1097 // CBrowserBookmarksView::ConstructL

  1098 // ----------------------------------------------------------------------------

  1099 //

  1100 void CBrowserBookmarksView::ConstructL( TInt aViewResourceId )

  1101     {

  1102 LOG_ENTERFN("BookmarksView::ConstructL");

  1103     CBrowserFavouritesView::ConstructL( aViewResourceId );

  1104     // Begin observing changes in active AP and default AP. Note that we

  1105     // set/unset observers here, not in DoActivateL/DoDeactivate: we do the

  1106     // observing even if the view is not active. This is needed, because

  1107     // preferences and the active AP can be changed from other views also.

  1108     // If notification kicks in when the view is not active, display RefreshL

  1109     // is, of course, suppressed (in base class).

  1110     ApiProvider().Preferences().AddObserverL( this );

  1111     ApiProvider().Connection().SetApChangeObserver( *this );

  1112     iOpenAdaptiveBookmarksWhenActivated = EFalse;

  1113     iAdaptiveBookmarksFolderSelected = EFalse;

  1114     iInAdaptiveBookmarksFolder=EFalse;

  1115     iAdaptiveBookmarksCurrentSetting =

  1116                             ApiProvider().Preferences().AdaptiveBookmarks();

  1117     iEnteredURL = NULL;

  1118 BROWSER_LOG( ( _L("delete iEnteredUrl 3") ) );

  1119     iCursorPos = -1;

  1120 

  1121     // The following code gets all bookmarks and saves them back in the correct

  1122     // order in Favourites db. It was important to add this piece of code here

  1123     // in the constructor so that the first time when a bookmark is added

  1124     // through content view the correct index is used to insert the bookmark.

  1125     // TSW Error report id# MLEN-6Z8HMM

  1126 

  1127     iSaveBMOrder = ETrue;

  1128 

  1129     if ( Model().BeginL( /*aWrite=*/ETrue, /*aDbErrorNote*/ EFalse ) ==

  1130             KErrNone )

  1131         {

  1132         CFavouritesItemList* items = GetItemsLC( KFavouritesRootUid );

  1133         CleanupStack::PopAndDestroy();

  1134         Model().CommitL();