--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/browserui/browser/FavouritesSrc/BrowserBookmarksView.cpp Wed Sep 01 12:31:04 2010 +0100
@@ -0,0 +1,2997 @@
+/*
+* Copyright (c) 2002-2008 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the License "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: Implementation of CBrowserBookmarksView.
+*
+*/
+
+// INCLUDE FILES
+#include <cdownloadmgruidownloadslist.h>
+#include <cdownloadmgruidownloadmenu.h>
+#include <eikmenup.h>
+#include <aknsfld.h>
+#include <smut.h>
+#include <IrcMTM.h>
+
+#ifndef AVERELL2_BLUETOOTH_MISSING
+ #include <btmsgtypeuid.h>
+#endif
+
+#include <irmsgtypeuid.h>
+#include <favouritesdb.h>
+
+#include <BrowserNG.rsg>
+
+#include <favouritesitem.h>
+#include <favouritesitemlist.h>
+#include <ApEngineConsts.h>
+#include <ApListItem.h>
+#include <ApListItemList.h>
+#include <StringLoader.h>
+#include <FeatMgr.h>
+#include <Uri16.h>
+#include <akntoolbar.h>
+#ifdef RD_SCALABLE_UI_V2
+#include <akntoolbarextension.h>
+#endif
+
+
+#include "BrowserDialogs.h"
+#include "BrowserBookmarksView.h"
+#include "BrowserBookmarksContainer.h"
+#include "BrowserBookmarksModel.h"
+#include "BrowserFavouritesListbox.h"
+#include "BrowserBookmarksEditDialog.h"
+#include "BrowserBookmarksGotoPane.h"
+#include "CommonConstants.h"
+#include "BrowserUtil.h"
+#include "BrowserAppUi.h"
+#include "Browser.hrh"
+#include "CommandVisibility.h"
+#include "BrowserBmOTABinSender.h"
+#include "CommsModel.h"
+#include <mconnection.h>
+#include "BrowserUiVariant.hrh"
+#include "BrowserWindowManager.h"
+#include "BrowserWindow.h"
+#include "BrowserDownloadUtil.h"
+#include "Display.h"
+#include "logger.h"
+
+#include "eikon.hrh"
+
+
+// CONSTANTS
+const TInt KAdaptiveBookmarksFirstPositionInBMView = 0;
+const TInt KAdaptiveBookmarksSecondPositionInBMView = 1;
+
+const TInt KBrowserDesCArrayGranularity = 8;
+
+// ================= MEMBER FUNCTIONS =======================
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::NewLC
+// ----------------------------------------------------------------------------
+//
+CBrowserBookmarksView* CBrowserBookmarksView::NewLC(
+ MApiProvider& aApiProvider,
+ CRecentUrlStore& aRecentUrlStore,
+ TInt aInitialFolderUid )
+ {
+ CBrowserBookmarksView* view = new (ELeave) CBrowserBookmarksView( aApiProvider,
+ aRecentUrlStore,
+ aInitialFolderUid );
+ CleanupStack::PushL( view );
+
+ view->ConstructL( R_BROWSER_BOOKMARKS_VIEW );
+
+ return view;
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::~CBrowserBookmarksView
+// ----------------------------------------------------------------------------
+//
+CBrowserBookmarksView::~CBrowserBookmarksView()
+ {
+LOG_ENTERFN("CBrowserBookmarksView::~CBrowserBookmarksView");
+ delete iDownloadsListExecuter;
+ iDownloadsListExecuter = 0;
+
+ if ( !ApiProvider().ExitInProgress() )
+ {
+ // Remove observers only in destructor. See comment in ConstructL why.
+ ApiProvider().Preferences().RemoveObserver( this );
+ ApiProvider().Connection().UnsetApChangeObserver();
+ }
+ CBrowserBookmarksContainer* container = TheContainer();
+ if ( container )
+ {
+ container->GotoPane()->SetGPObserver( NULL );
+ if( ApiProvider().Preferences().SearchFeature() )
+ container->SearchPane()->SetGPObserver( NULL );
+ }
+ delete iDomainFolderName;
+ delete iItemsToMove;
+ delete iCurrentOrder;
+ delete iEnteredURL;
+ delete iAsyncComplete;
+BROWSER_LOG( ( _L("delete iEnteredUrl 1") ) );
+ iCursorPos = -1;
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::UpdateGotoPaneL
+// ----------------------------------------------------------------------------
+//
+void CBrowserBookmarksView::UpdateGotoPaneL()
+ {
+LOG_ENTERFN("BookmarksView::UpdateGotoPaneL");
+ // Simulate cursor movement; that will cancel editing (if editing)
+ // and refresh Goto Pane.
+ if ( Container() )
+ {
+ if ( iEnteredURL )
+ {
+ BROWSER_LOG( ( _L("iEnteredUrl exists") ) );
+ if ( iCursorPos >=0 ) // update pane only once!
+ {
+ TheContainer()->GotoPane()->SetTextL( iEnteredURL->Des(),
+ EFalse,
+ EFalse );
+
+ CEikEdwin* editor = STATIC_CAST( CEikEdwin*,
+ TheContainer()->GotoPane()->ComponentControl( 1 ) );
+ editor->SetCursorPosL( iCursorPos, EFalse );
+ iCursorPos = -1;
+ TheContainer()->GotoPane()->SetFocus( ETrue );
+ }
+ }
+ else
+ {
+ Container()->HandleCursorChangedL( Container()->Listbox() );
+ }
+ }
+ }
+
+// --------------------------------------------------------------------------------
+// CBrowserBookmarksView::DeleteItems
+// --------------------------------------------------------------------------------
+//
+void CBrowserBookmarksView::DeleteItems( TInt aCommand )
+ {
+
+ if (iHandleDeleteInProgress)
+ return;
+
+ iHandleDeleteInProgress = ETrue;
+
+ const CFavouritesItem* item = Container()->Listbox()->CurrentItem();
+
+ if (!item)
+ {
+ return;
+ }
+
+ if ( item->ParentFolder() == KFavouritesAdaptiveItemsFolderUid )
+ {
+ TBool confirm;
+ CArrayPtr<const CFavouritesItem>* items = Container()->Listbox()->SelectedItemsLC();
+
+ if ( items->Count() == 1 )
+ {
+ confirm = TBrowserDialogs::ConfirmQueryYesNoL( R_BROWSER_FAVOURITES_TEXT_QUERY_COMMON_CONF_DELETE, (*items)[0]->Name());
+ }
+ else if (items->Count() > 1)
+ {
+ confirm = TBrowserDialogs::ConfirmQueryYesNoL( R_BROWSER_FAVOURITES_TEXT_DEL_ITEMS_QUERY, items->Count());
+ }
+ else
+ {
+ confirm = EFalse;
+ }
+
+ if (confirm)
+ {
+ for ( TInt i = 0; i < items->Count(); i++ )
+ {
+ iRecentUrlStore.DeleteData(items->At( i )->Url());
+ }
+ Container()->Listbox()->View()->ClearSelection();
+ iSaveBMOrder = ETrue;
+ RefreshL();
+ }
+
+ CleanupStack::PopAndDestroy();//items
+ }
+ else
+ {
+ iSaveBMOrder = ETrue;
+ CBrowserFavouritesView::HandleCommandL( aCommand );
+ }
+
+ iHandleDeleteInProgress = EFalse;
+
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::HandleCommandL
+// ----------------------------------------------------------------------------
+//
+void CBrowserBookmarksView::HandleCommandL( TInt aCommand )
+ {
+LOG_ENTERFN("BookmarksView::HandleCommandL");
+ //
+ // FIRST SWITCH Generic CBA commands to original commands
+ // use ProcessCommandL to route through akn to make sure
+ // command gets routed to the right place
+ //
+ //
+
+ // Assume generic command unless default case, below.
+ TBool genericCmdHandled = ETrue;
+
+ switch ( aCommand )
+ {
+ case EBrowserBookmarksCmdCancel:
+ {
+ if ( iManualItemMovingGoingOn )
+ {
+ ProcessCommandL(EWmlCmdMoveCancel);
+ }
+ else if( TheContainer()
+ && ( TheContainer()->GotoPane()->IsEditing()
+ || TheContainer()->SearchPane()->IsEditing()))
+ {
+ ProcessCommandL(EWmlCmdGotoPaneCancel);
+ }
+ break;
+ }
+ case EBrowserBookmarksCmdOpen:
+ {
+ const CFavouritesItem* item = NULL;
+ if (Container())
+ {
+ item = Container()->Listbox()->CurrentItem();
+ }
+
+ if ( item && item->IsFolder() )
+ {
+ ProcessCommandL(EWmlCmdOpenFolder);
+ }
+ else
+ {
+ ProcessCommandL(EWmlCmdDownload);
+ }
+
+ break;
+ }
+ case EBrowserBookmarksCmdBack:
+ {
+ // default remap is to say back from folder
+ TInt cmd = EWmlCmdBackFromFolder;
+
+ // unless we have these conditions
+ if ( !iInAdaptiveBookmarksFolder )
+ {
+ if ( iCurrentFolder == KFavouritesRootUid )
+ {
+ if ( ApiProvider().IsPageLoaded() || ApiProvider().Fetching() )
+ {
+ cmd = EWmlCmdBackToPage;
+ }
+ }
+ }
+ ProcessCommandL(cmd);
+ break;
+ }
+ default:
+ {
+ genericCmdHandled = EFalse;
+ break;
+ }
+ }
+
+ if (genericCmdHandled)
+ {
+ return;
+ }
+
+ //
+ // EXISTING (regular) command set
+ //
+ if ( TheContainer() )
+ {
+ switch ( aCommand )
+ {
+ // CBA commands.
+ case EWmlCmdGotoPaneGoTo:
+ {
+ if( TheContainer()->GotoPaneActive() )
+ {
+ if (TheContainer()->GotoPane()->Editor()->TextLength()!= 0)
+ {
+ // Cancel editing and sets Goto Pane text back.
+ if (TheContainer()->GotoPane()->PopupList() != NULL)
+ {
+ TheContainer()->GotoPane()->PopupList()->SetDirectoryModeL( ETrue );
+ TheContainer()->GotoPane()->PopupList()->HidePopupL();
+ }
+ GotoUrlInGotoPaneL();
+ }
+ }
+ else // it was from searchpane
+ {
+ if (TheContainer()->SearchPane()->Editor()->TextLength()!= 0)
+ {
+ // Launch Search application with search parameters
+ // and cancel editing of search and goto.
+ // Dim Toolbar buttons
+ DimToolbarButtons(EFalse);
+ HBufC* searchString = TheContainer()->SearchPane()->GetTextL();
+ CleanupStack::PushL( searchString );
+ if( searchString )
+ {
+ UpdateCbaL();
+ // Set GoTo/Search Inactive
+ TheContainer()->SetGotoInactiveL();
+ LaunchSearchApplicationL( *searchString );
+ }
+ CleanupStack::PopAndDestroy( searchString );
+ }
+ // set LSK to GOTO now
+ UpdateCbaL();
+ }
+ break;
+ }
+ case EWmlCmdGotoPaneSelect:
+ {
+ if (TheContainer()->GotoPane()->Editor()->TextLength()!= 0)
+ {
+ // Cancel editing and sets Goto Pane text back.
+ if (TheContainer()->GotoPane()->PopupList() != NULL)
+ {
+ TheContainer()->GotoPane()->PopupList()->SetDirectoryModeL( ETrue );
+ TheContainer()->GotoPane()->PopupList()->HidePopupL();
+ }
+ // set LSK to GOTO now
+ UpdateCbaL();
+ }
+ break;
+ }
+
+
+ case EWmlCmdNewFolder:
+ {
+ TInt uid = CBrowserFavouritesView::AddNewFolderL( );
+
+ AddUidToLastPlaceToCurrentListL(uid);
+ iRefresh = EFalse;
+ Model().Database().SetData( CurrentFolder() , *iCurrentOrder );
+ break;
+ }
+ case EWmlCmdMove:
+ {
+ StartMoveItemsL();
+ break;
+ }
+ case EWmlCmdMoveOk:
+ {
+ MoveItemsL();
+ break;
+ }
+ case EWmlCmdMoveCancel:
+ {
+ CancelMoveItemsL();
+ break;
+ }
+
+ case EWmlCmdMoveToFolder:
+ {
+ iSaveBMOrder = ETrue;
+ CBrowserFavouritesView::HandleCommandL(aCommand);
+ break;
+ }
+
+ case EWmlCmdGotoPaneCancel:
+ {
+ // Cancel editing and sets Goto Pane text back.
+ if (TheContainer()->GotoPane()->PopupList() != NULL)
+ {
+ TheContainer()->GotoPane()->PopupList()->SetDirectoryModeL( ETrue );
+ TheContainer()->GotoPane()->PopupList()->HidePopupL();
+ }
+ delete iEnteredURL;
+ iEnteredURL = NULL;
+ BROWSER_LOG( ( _L("delete iEnteredUrl 2") ) );
+ iCursorPos = -1;
+
+ TheContainer()->SetGotoInactiveL();
+
+ DimToolbarButtons(EFalse);
+
+ break;
+ }
+
+ // Menu commands.
+ case EWmlCmdFavourites:
+ {
+ if ( iInAdaptiveBookmarksFolder )
+ {
+ ExitAdaptiveBookmarks();
+ }
+ ApiProvider().SetViewToBeActivatedIfNeededL( KUidBrowserBookmarksViewId );
+ break;
+ }
+
+ case EWmlCmdBackToPage:
+ {
+ ApiProvider().SetViewToReturnOnClose( KUidBrowserBookmarksViewId );
+ ApiProvider().SetViewToBeActivatedIfNeededL( KUidBrowserContentViewId );
+ break;
+ }
+
+ case EWmlCmdDownload:
+ case EWmlCmdDownloadPage:
+ {
+ ActivateCurrentBookmarkL();
+ break;
+ }
+
+#ifdef __RSS_FEEDS
+ case EWmlCmdOpenFeedsFolder:
+ {
+ //complete remaining startup in Browser and then proceed
+ if ( !ApiProvider().StartedUp() )
+ ApiProvider().CompleteDelayedInit();
+ ApiProvider().FeedsClientUtilities().ShowFolderViewL();
+ break;
+ }
+#endif // __RSS_FEEDS
+
+
+ case EWmlCmdLaunchHomePage:
+ {
+ AppUi()->HandleCommandL( aCommand );
+ break;
+ }
+
+ case EWmlCmdOpenItem:
+ {
+ // re-handle the open item command depending on whether a folder or an
+ // item is selected.
+ if ( Container() && Container()->Listbox() )
+ {
+ const CFavouritesItem* item = Container()->Listbox()->CurrentItem();
+ if ( item && item->IsFolder() )
+ {
+ HandleCommandL(EWmlCmdOpenFolder);
+ }
+ else
+ {
+ HandleCommandL(EWmlCmdDownload);
+ }
+ }
+ break;
+ }
+
+ case EWmlCmdAddBookmark:
+ {
+ AddNewBookmarkL();
+ break;
+ }
+
+ case EWmlCmdGoToAddressAndSearch:
+ case EWmlCmdGoToAddress: // MSK for Recent Url page
+ case EWmlCmdSwitchToGotoActive:
+ {
+ DimToolbarButtons(ETrue);
+#ifdef BRDO_SINGLE_CLICK_ENABLED_FF
+ CEikButtonGroupContainer* cba = Cba()->Current();
+ CEikCba* eikCba = static_cast<CEikCba*>( cba->ButtonGroup() );
+ if( eikCba )
+ {
+ eikCba->EnableItemSpecificSoftkey( EFalse );
+ }
+#endif
+ TheContainer()->SetGotoActiveL();
+ break;
+ }
+
+ case EIsCmdSearchWeb:
+ {
+ DimToolbarButtons(ETrue);
+#ifdef BRDO_SINGLE_CLICK_ENABLED_FF
+ CEikButtonGroupContainer* cba = Cba()->Current();
+ CEikCba* eikCba = static_cast<CEikCba*>( cba->ButtonGroup() );
+ if( eikCba )
+ {
+ eikCba->EnableItemSpecificSoftkey( EFalse );
+ }
+#endif
+ TheContainer()->SetSearchActiveL();
+ break;
+ }
+
+ case EWmlCmdEditBookmark:
+ {
+ EditCurrentBookmarkL();
+ break;
+ }
+
+ case EWmlCmdSetAsHomePage:
+ {
+ if ( Container() && Container()->Listbox() )
+ {
+ const CFavouritesItem* item =
+ Container()->Listbox()->CurrentItem();
+ if ( item && item->IsItem() &&
+ TBrowserDialogs::ConfirmQueryYesNoL(
+ R_QTN_BROWSERBM_QUERY_SET_AS_HOME_PAGE ) )
+ {
+ ApiProvider().Preferences().SetHomePageUrlL( item->Url() );
+ ApiProvider().Preferences().SetHomePageTypeL( EWmlSettingsHomePageAddress );
+ }
+ }
+ break;
+ }
+
+ case EWmlCmdPreferences:
+ {
+ CBrowserFavouritesView::HandleCommandL( aCommand );
+ break;
+ }
+
+ case EWmlCmdCopyToBookmarks:
+ {
+ CArrayPtr<const CFavouritesItem>* items =
+ Container()->Listbox()->SelectedItemsLC();
+ if (items->Count())
+ {
+ // Set WAP AP.
+ CFavouritesItem* item;
+ for (TInt i=0;i<items->Count();i++)
+ {
+ item = CFavouritesItem::NewL();
+ *item = *( items->At( i ) );
+ CleanupStack::PushL( item );
+ item->SetParentFolder( KFavouritesRootUid );
+ Model().AddL( *item, EFalse, CBrowserFavouritesModel::EAutoRename );
+ AddUidToLastPlaceToCurrentListL( item->Uid() );
+ CleanupStack::PopAndDestroy();//item
+ }
+ iRefresh = EFalse;
+ Model().Database().SetData( CurrentFolder() , *iCurrentOrder );
+ Container()->Listbox()->View()->ClearSelection();
+ if (items->Count()==1)
+ {
+ TBrowserDialogs::InfoNoteL
+ (
+ R_BROWSER_INFO_NOTE,
+ R_BROWSER_ADAPTIVE_BOOKMARKS_ADAPTIVE_BOOKMARK_COPIED
+ );
+ }
+ else
+ {
+ TBrowserDialogs::InfoNoteL(
+ R_BROWSER_INFO_NOTE,
+ R_BROWSER_ADAPTIVE_BOOKMARKS_ADAPTIVE_BOOKMARKS_COPIED,
+ items->Count() );
+ }
+ }
+ CleanupStack::PopAndDestroy();//items
+ break;
+ }
+
+ case EWmlCmdRename:
+ {
+ // NO rename on menu
+ {
+ CBrowserFavouritesView::HandleCommandL( aCommand );
+ }
+ break;
+ }
+
+ case EWmlCmdDelete:
+ {
+ DeleteItems( aCommand );
+ break;
+ } // case
+
+
+ case EWmlCmdClearAdaptiveBookmarks:
+ {
+ if ( TBrowserDialogs::ConfirmQueryYesNoL(
+ R_BROWSER_ADAPTIVE_BOOKMARKS_DELETE_ALL_ADAPTIVE_BOOKMARKS) )
+ {
+ ClearAdaptiveBookmarksL();
+ }
+ break;
+ }
+
+ case EWmlCmdClearAdaptiveBookmarksNoPrompt:
+ {
+ ClearAdaptiveBookmarksL();
+ break;
+ }
+
+ case EWmlCmdOpenFolder:
+ {
+ if ( TheContainer()->GotoPane()->PopupList() )
+ {
+ if ( TheContainer()->GotoPane()->PopupList()->IsPoppedUp() )
+ {
+ TheContainer()->GotoPane()->PopupList()->SetDirectoryModeL(
+ EFalse );
+ break; // This case is supposed to fall through into the next case in certain
+ // conditions.
+ }
+ }
+ }
+
+ case EWmlCmdOpenMarkedFolder:
+ {
+ SetEmptyTextL();
+ if (Container()->Listbox()->CurrentItem()->Uid() ==
+ KFavouritesAdaptiveItemsFolderUid )
+ {
+ iAdaptiveBookmarksFolderSelected = ETrue;
+ iInAdaptiveBookmarksFolder = ETrue;
+ SetEmptyTextL();
+ RefreshL();
+ }
+ else
+ {
+ CBrowserFavouritesView::HandleCommandL( aCommand );
+ UpdateToolbarButtonsState();
+ }
+ break;
+ }
+
+ case EWmlCmdBackFromFolder:
+ {
+ Container()->Listbox()->ClearSelection();
+ if ( iDomainFolderName )
+ {
+ HBufC* domainFolderNameToHighlight;
+ domainFolderNameToHighlight = HBufC::NewL(
+ iDomainFolderName->Length() );
+ CleanupStack::PushL( domainFolderNameToHighlight );
+
+ domainFolderNameToHighlight->Des().Append( *iDomainFolderName );
+ delete iDomainFolderName;
+ iDomainFolderName = NULL;
+
+ CFavouritesItemList* items =
+ GetItemsLC( KFavouritesAdaptiveItemsFolderUid );
+ TInt indexToHighlight = 0;
+
+ for ( TInt i = 0; i < items->Count(); i++ )
+ {
+ if ( (*items)[i]->Name() == (*domainFolderNameToHighlight) )
+ {
+ indexToHighlight = i;
+ }
+ }
+
+ CleanupStack::PopAndDestroy(); // items
+ CleanupStack::PopAndDestroy(); // domainFolderNameToHighlight
+
+ HBufC* title;
+ title=iCoeEnv->AllocReadResourceLC(
+ R_BROWSER_ADAPTIVE_BOOKMARKS_TITLE );
+ ApiProvider().Display().SetTitleL( *title );
+ CleanupStack::PopAndDestroy(); // title
+ RefreshL();
+ Container()->Listbox()->SetCurrentItemIndexAndDraw(
+ indexToHighlight );
+ }
+ else
+ {
+ if ( iInAdaptiveBookmarksFolder )
+ {
+ iAdaptiveBookmarksFolderSelected = EFalse;
+ iInAdaptiveBookmarksFolder=EFalse;
+ SetEmptyTextL();
+ HBufC* title;
+ title=iCoeEnv->AllocReadResourceLC(
+ TheContainer()->TitleResourceId() );
+ UpdateNaviPaneL();
+ ApiProvider().Display().SetTitleL( *title );
+ iPreferredHighlightUid=KFavouritesAdaptiveItemsFolderUid;
+ CleanupStack::PopAndDestroy(); // title
+ RefreshL();
+ }
+ else
+ {
+ CBrowserFavouritesView::HandleCommandL( aCommand );
+ }
+ }
+ // Back from a folder may require change in toolbar button state
+ UpdateToolbarButtonsState();
+ break;
+ }
+
+ case EWmlCmdSendBookmarkViaUnifiedMessage:
+ {
+ // Both case can be handled alike - SendBookmarksL
+ // uses SelectedItemsLC - this always what we want (if there is
+ // something marked, those; if no marked, the highlighted one).
+ SendBookmarksL( );
+ break;
+ }
+
+
+#ifdef __SERIES60_HELP
+ case EAknCmdHelp:
+ {
+ STATIC_CAST(CBrowserAppUi*, AppUi())->HandleCommandL(EAknCmdHelp);
+ break;
+ }
+#endif //__SERIES60_HELP
+
+ case EWmlCmdDownloads:
+ {
+ ApiProvider().BrCtlInterface().HandleCommandL(
+ (TInt)TBrCtlDefs::ECommandShowDownloads +
+ (TInt)TBrCtlDefs::ECommandIdBase );
+ break;
+ }
+
+ case EWmlCmdDownloadPageNewWindow:
+ {
+ const CFavouritesItem* item = Container()->Listbox()->CurrentItem();
+ if ( item )
+ {
+ CBrowserAppUi::Static()->OpenLinkInNewWindowL( *item );
+ }
+ break;
+ }
+
+ default:
+ {
+ if (aCommand == EWmlCmdDelete &&
+ (Container()->Listbox()->CurrentItem()->ParentFolder()==KFavouritesAdaptiveItemsFolderUid))
+ {
+ DeleteItems( aCommand );
+ break;
+ }
+ CBrowserFavouritesView::HandleCommandL( aCommand );
+ break;
+ }
+ }
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::SetEmptyTextL
+// ----------------------------------------------------------------------------
+//
+void CBrowserBookmarksView::SetEmptyTextL()
+ {
+ HBufC* buf;
+ if (iInAdaptiveBookmarksFolder)
+ {
+ HBufC* title;
+ if (iDomainFolderName != NULL)
+ {
+ ApiProvider().Display().SetTitleL( *iDomainFolderName );
+ }
+ else
+ {
+ title=iCoeEnv->AllocReadResourceLC( R_BROWSER_ADAPTIVE_BOOKMARKS_TITLE );
+ ApiProvider().Display().SetTitleL( *title );
+ CleanupStack::PopAndDestroy(); // title
+ }
+ buf = iCoeEnv->AllocReadResourceLC( R_BROWSER_ADAPTIVE_BOOKMARKS_NO_ADAPTIVE_BOOKMARKS );
+ }
+ else
+ {
+ buf = iCoeEnv->AllocReadResourceLC( TheContainer()->ListboxEmptyTextResourceId() );
+ }
+ TheContainer()->Listbox()->View()->SetListEmptyTextL( *buf );
+ CleanupStack::PopAndDestroy(); // buf
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::Id
+// ----------------------------------------------------------------------------
+//
+TUid CBrowserBookmarksView::Id() const
+ {
+ return KUidBrowserBookmarksViewId;
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::CommandSetResourceIdL
+// ----------------------------------------------------------------------------
+//
+TInt CBrowserBookmarksView::CommandSetResourceIdL()
+ {
+ // massive re-work for 5.0, to dynamically assign CBA
+ return(R_BROWSER_BUTTONS_CBA_DYNAMIC);
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::CommandSetResourceDynL
+// ----------------------------------------------------------------------------
+//
+
+void CBrowserBookmarksView::CommandSetResourceDynL(TSKPair& aLsk, TSKPair& aRsk, TSKPair& aMsk)
+{
+ //
+ // Get gotoPane pointer and appropriate Container pointer.
+ //
+ // These are passed in to the LSK, RSK, MSK dynamic setting functions
+ // and used to help chose the appropriate softkeys
+ //
+ CBrowserBookmarksGotoPane* gotoPanePtr = NULL;
+ CBrowserBookmarksContainer* theContainer = TheContainer();
+
+ // if the container doesn't exist, leave gotoPanePtr at NULL
+ if (theContainer)
+ {
+ gotoPanePtr = theContainer->GotoPane();
+ }
+
+ // set LSK, RSK, MSK respectively
+ SetLSKDynL(aLsk, gotoPanePtr);
+ SetRSKDynL(aRsk, gotoPanePtr);
+ SetMSKDynL(aMsk, aLsk, theContainer, gotoPanePtr);
+
+ //
+ // Finally, if the contextual menu command was assigned to the MSK,
+ // we need to set up the menu now
+ //
+ if ( aMsk.id() == EAknSoftkeyContextOptions )
+ {
+ ConfigContextMenu();
+ }
+}
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::SetLSKDynL
+// ----------------------------------------------------------------------------
+//
+
+void CBrowserBookmarksView::SetLSKDynL(TSKPair& aLsk,
+ CBrowserBookmarksGotoPane* aGotoPane)
+{
+ CBrowserBookmarksContainer* theContainer = TheContainer();
+ CBrowserBookmarksGotoPane* searchPane = NULL;
+ if( theContainer )
+ {
+ searchPane = theContainer->SearchPane();
+ }
+ // Default lsk is option
+ aLsk.setPair(EAknSoftkeyOptions, R_BROWSER_BOOKMARKS_DYN_SK_TEXT_SOFTKEY_OPTION);
+
+ if ( iManualItemMovingGoingOn )
+ {
+ aLsk.setPair(EWmlCmdMoveOk, R_BROWSER_BOOKMARKS_DYN_SK_TEXT_SOFTKEY_OK);
+ }
+ else if ( aGotoPane && aGotoPane->IsEditing() )
+ {
+ // default for goto is go
+ aLsk.setPair(EWmlCmdGotoPaneGoTo, R_BROWSER_BOOKMARKS_DYN_SK_QTN_WML_SOFTK_GO);
+
+ if (aGotoPane->PopupList() &&
+ aGotoPane->PopupList()->IsOpenDirToShow() )
+ {
+ aLsk.setPair(EBrowserBookmarksCmdOpen, R_BROWSER_BOOKMARKS_DYN_SK_TEXT_SOFTKEY_OPEN);
+ }
+ else if (aGotoPane->PopupList() &&
+ aGotoPane->PopupList()->IsPoppedUp() &&
+ !iPenEnabled)
+ {
+ // LSK Select is only for non-touch devices
+ aLsk.setPair(EWmlCmdGotoPaneSelect, R_BROWSER_BOOKMARKS_DYN_SK_TEXT_SOFTKEY_SELECT);
+ }
+ }
+ else if( searchPane && searchPane->IsEditing() )
+ {
+ aLsk.setPair(EWmlCmdGotoPaneGoTo, R_BROWSER_BOOKMARKS_DYN_SK_QTN_IS_SOFTK_SEARCH);
+ }
+}
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::SetRSKDynL
+// ----------------------------------------------------------------------------
+//
+
+void CBrowserBookmarksView::SetRSKDynL(TSKPair& aRsk,
+ CBrowserBookmarksGotoPane* aGotoPane)
+{
+ CBrowserBookmarksContainer* theContainer = TheContainer();
+ CBrowserBookmarksGotoPane* searchPane = NULL;
+ if( theContainer )
+ {
+ searchPane = theContainer->SearchPane();
+ }
+ if ( iManualItemMovingGoingOn )
+ {
+ aRsk.setPair(EBrowserBookmarksCmdCancel, R_BROWSER_BOOKMARKS_DYN_SK_TEXT_SOFTKEY_CANCEL);
+ }
+ else if( (aGotoPane && aGotoPane->IsEditing()) || (searchPane && searchPane->IsEditing()) )
+ {
+ // default for goto is cancel
+ aRsk.setPair(EBrowserBookmarksCmdCancel, R_BROWSER_BOOKMARKS_DYN_SK_TEXT_SOFTKEY_CANCEL);
+ }
+ else
+ {
+ // default case for everything else is Back
+ aRsk.setPair(EBrowserBookmarksCmdBack, R_BROWSER_BOOKMARKS_DYN_SK_TEXT_SOFTKEY_BACK);
+
+ // OR, it could be exit under these conditions
+ if ( (!iInAdaptiveBookmarksFolder && !ApiProvider().IsPageLoaded() && !ApiProvider().Fetching()) )
+ {
+ if ( iCurrentFolder == KFavouritesRootUid )
+ {
+ aRsk.setPair(EAknSoftkeyExit, R_BROWSER_BOOKMARKS_DYN_SK_TEXT_SOFTKEY_EXIT);
+ }
+ }
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::SetMSKDynL
+// ----------------------------------------------------------------------------
+//
+
+void CBrowserBookmarksView::SetMSKDynL(TSKPair& aMsk, const TSKPair aLsk,
+ CBrowserFavouritesContainer* aContainer,
+ CBrowserBookmarksGotoPane* aGotoPane)
+ {
+ // setup any marked items flag for convenience
+ // also verify that container is defined
+ TBool anyMarkedItems = EFalse;
+ if ( aContainer)
+ {
+ anyMarkedItems = aContainer->Listbox()->SelectionStateL().AnyMarked();
+ }
+ else
+ {
+ return;
+ }
+
+ //
+ // Usually, MSK is context menu if marked items.
+ // The exception is if moving is in progress (and marked items).. then its the dot (in place of OK).
+ // Otherwise, the Open Command is thrown.
+ //
+ if ( anyMarkedItems )
+ {
+ if ( iManualItemMovingGoingOn )
+ {
+ aMsk.setPair(EWmlCmdMoveOk, R_BROWSER_BOOKMARKS_DYN_SK_TEXT_SOFTKEY_OK);
+ }
+ else
+ {
+ aMsk.setPair(EAknSoftkeyContextOptions, R_BROWSER_BOOKMARKS_DYN_SK_TEXT_SOFTKEY_OPTION);
+ }
+ }
+ else
+ {
+ aMsk.setPair(EBrowserBookmarksCmdOpen, R_BROWSER_BOOKMARKS_DYN_SK_TEXT_SOFTKEY_OPEN);
+ }
+
+ CBrowserBookmarksContainer* theContainer = TheContainer();
+ CBrowserBookmarksGotoPane* searchPane = NULL;
+ if( theContainer )
+ {
+ searchPane = theContainer->SearchPane();
+ }
+ //
+ // UNDER these special conditions, the msk is set differently:
+ //
+ if ( aGotoPane && aGotoPane->IsEditing() )
+ {
+ // follow whatever the lsk is set to
+ aMsk = aLsk;
+ }
+ else if( searchPane && searchPane->IsEditing() )
+ {
+ // follow whatever the lsk is set to
+ aMsk = aLsk;
+ }
+ else
+ {
+ if ( iInAdaptiveBookmarksFolder )
+ {
+ if ( aContainer->Listbox()->UnfilteredNumberOfItems() <= 0 )
+ {
+ aMsk.setPair( EWmlCmdGoToAddress, R_BROWSER_BOOKMARKS_DYN_SK_QTN_BROWSER_MSK_GOTO );
+ }
+ }
+ else
+ {
+ if ( (reinterpret_cast <CBrowserAppUi*>(AppUi())->IsEmbeddedModeOn()) ||
+ iCurrentFolder == KFavouritesRootUid )
+ {
+ if ( aContainer->Listbox()->UnfilteredNumberOfItems() <= 0 )
+ {
+ aMsk.setPair( EWmlCmdAddBookmark, R_BROWSER_BOOKMARKS_DYN_SK_QTN_MSK_ADD );
+ }
+ }
+ else
+ {
+ if ( aContainer->Listbox()->UnfilteredNumberOfItems() <= 0 )
+ {
+ aMsk.setPair( EWmlCmdAddBookmark, R_BROWSER_BOOKMARKS_DYN_SK_QTN_MSK_ADD );
+ }
+ }
+ }
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::HandleBookmarksGotoPaneEventL
+// ----------------------------------------------------------------------------
+//
+void CBrowserBookmarksView::HandleBookmarksGotoPaneEventL
+ (
+ CBrowserBookmarksGotoPane*
+#ifdef _DEBUG
+ aGotoPane // used only for debugging purposes
+#endif
+ ,
+ MBookmarksGotoPaneObserver::TEvent aEvent
+ )
+ {
+#ifdef _DEBUG
+ __ASSERT_DEBUG( aGotoPane == TheContainer()->GotoPane() ||
+ aGotoPane == TheContainer()->SearchPane(), \
+ Util::Panic( Util::EFavouritesInternal ) );
+#endif
+
+ switch ( aEvent )
+ {
+ case MBookmarksGotoPaneObserver::EEventEnterKeyPressed:
+ {
+ HandleCommandL( EWmlCmdGotoPaneGoTo );
+ break;
+ }
+
+ case MBookmarksGotoPaneObserver::EEventEditingModeChanged:
+ {
+ UpdateCbaL();
+ break;
+ }
+
+ default:
+ {
+ break;
+ }
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::CBrowserBookmarksView
+// ----------------------------------------------------------------------------
+//
+CBrowserBookmarksView::CBrowserBookmarksView ( MApiProvider& aApiProvider,
+ CRecentUrlStore& aRecentUrlStore,
+ TInt aInitialFolderUid )
+ : CBrowserFavouritesView( aApiProvider, aInitialFolderUid ),
+ iFetchInit( EFalse ),
+
+ iRecentUrlStore (aRecentUrlStore)
+
+
+
+ {
+ // Initially start with default AP as Start Page AP.
+ iCurrentDefaultAp = iStartPageApUid =
+ ApiProvider().Preferences().DefaultAccessPoint();
+ iPenEnabled = AknLayoutUtils::PenEnabled();
+ iHandleDeleteInProgress = EFalse;
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::ConstructL
+// ----------------------------------------------------------------------------
+//
+void CBrowserBookmarksView::ConstructL( TInt aViewResourceId )
+ {
+LOG_ENTERFN("BookmarksView::ConstructL");
+ CBrowserFavouritesView::ConstructL( aViewResourceId );
+ // Begin observing changes in active AP and default AP. Note that we
+ // set/unset observers here, not in DoActivateL/DoDeactivate: we do the
+ // observing even if the view is not active. This is needed, because
+ // preferences and the active AP can be changed from other views also.
+ // If notification kicks in when the view is not active, display RefreshL
+ // is, of course, suppressed (in base class).
+ ApiProvider().Preferences().AddObserverL( this );
+ ApiProvider().Connection().SetApChangeObserver( *this );
+ iOpenAdaptiveBookmarksWhenActivated = EFalse;
+ iAdaptiveBookmarksFolderSelected = EFalse;
+ iInAdaptiveBookmarksFolder=EFalse;
+ iAdaptiveBookmarksCurrentSetting =
+ ApiProvider().Preferences().AdaptiveBookmarks();
+ iEnteredURL = NULL;
+BROWSER_LOG( ( _L("delete iEnteredUrl 3") ) );
+ iCursorPos = -1;
+
+ //Since the webcore will be reading the bookmark information in background
+ //thread, its important to refresh when the thread notifies the fresh data.
+ //Call to GetItemsLC above, which inturn calls ManualBMSortL will set iRefresh to false
+ //Make it true so that latest FavIcon db info is shown
+ iRefresh = ETrue;
+
+#ifdef BRDO_PERF_IMPROVEMENTS_ENABLED_FF
+ if ( ApiProvider().Preferences().SearchFeature() ) // hide the button which is not needed
+ Toolbar()->HideItem( EWmlCmdGoToAddress, ETrue , EFalse);
+ else
+ Toolbar()->HideItem( EWmlCmdGoToAddressAndSearch, ETrue , EFalse);
+#else
+ Toolbar()->HideItem( EWmlCmdAddBookmark, ETrue , EFalse);
+
+ //disable both the goto items and activate one of them depending on availability of search feature during bookmarks activation
+ Toolbar()->HideItem( EWmlCmdGoToAddress, ETrue , EFalse);
+ Toolbar()->HideItem( EWmlCmdGoToAddressAndSearch, ETrue , EFalse );
+
+#ifndef BRDO_SINGLE_CLICK_ENABLED_FF
+ Toolbar()->HideItem( EWmlCmdDelete, ETrue , EFalse);
+#else
+ Toolbar()->HideItem( EWmlCmdPreferences, ETrue , EFalse);
+#endif
+
+ Cba()->MakeVisible( EFalse);
+ StatusPane()->MakeVisible( EFalse );
+#endif
+
+ if (iPenEnabled)
+ {
+ Toolbar()->SetToolbarObserver(this);
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::HandleListBoxEventL
+// ----------------------------------------------------------------------------
+//
+void CBrowserBookmarksView::HandleListBoxEventL(
+ CEikListBox* aListBox,
+ MEikListBoxObserver::TListBoxEvent aEventType )
+ {
+ if ( aListBox == Container()->Listbox() )
+ {
+ switch ( aEventType )
+ {
+#ifdef BRDO_SINGLE_CLICK_ENABLED_FF
+ case MEikListBoxObserver::EEventEmptyListClicked:
+ return;
+#endif
+ case MEikListBoxObserver::EEventEnterKeyPressed:
+ case MEikListBoxObserver::EEventItemDoubleClicked:
+#ifdef BRDO_SINGLE_CLICK_ENABLED_FF
+ case MEikListBoxObserver::EEventItemSingleClicked:
+#endif
+ {
+ if ( iManualItemMovingGoingOn )
+ {
+ MoveItemsL();
+ return;
+ }
+ else if ( Container()->Listbox()->CurrentItem() )
+ {
+ //complete remaining startup in Browser and then proceed
+ if ( !ApiProvider().StartedUp() )
+ ApiProvider().CompleteDelayedInit();
+
+ if ( Container()->Listbox()->CurrentItem()->IsItem())
+ {
+ ActivateCurrentBookmarkL();
+ return;
+ }
+ else
+ {
+ if (Container()->Listbox()->CurrentItem()->Uid()==KFavouritesAdaptiveItemsFolderUid)
+ {
+ iAdaptiveBookmarksFolderSelected = ETrue;
+ iInAdaptiveBookmarksFolder=ETrue;
+ SetEmptyTextL();
+ RefreshL();
+
+ iPreviousViewID = KUidBrowserBookmarksViewId;
+ return;
+ }
+ }
+ }
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
+ }
+
+ if ( TheContainer()->Listbox()->CurrentItem() && TheContainer()->Listbox()->CurrentItem()->IsFolder() )
+ {
+ SetEmptyTextL();
+ }
+
+ CBrowserFavouritesView::HandleListBoxEventL( aListBox, aEventType );
+ UpdateToolbarButtonsState();
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::DynInitMenuPaneL
+// ----------------------------------------------------------------------------
+//
+void CBrowserBookmarksView::DynInitMenuPaneL
+ (
+ TInt aResourceId,
+ CEikMenuPane* aMenuPane,
+ TCommandVisibility::TIndex /*aIndex */,
+ const TBrowserFavouritesSelectionState& aState
+ )
+ {
+ LOG_ENTERFN("CBrowserBookmarksView::DynInitMenuPaneL");
+
+ __ASSERT_DEBUG( (aMenuPane != NULL), Util::Panic( Util::EUninitializedData ));
+
+ const CFavouritesItem* item = TheContainer()->Listbox()->CurrentItem();
+
+ switch ( aResourceId )
+ {
+ case R_BROWSER_BOOKMARKS_MENU_PANE:
+ {
+#ifdef BRDO_SINGLE_CLICK_ENABLED_FF
+ if(iItemsToMove )
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdMove, ETrue );
+ aMenuPane->SetItemDimmed( EWmlCmdMoveToFolder, ETrue );
+ aMenuPane->SetItemDimmed( EWmlCmdDelete, ETrue );
+ aMenuPane->SetItemDimmed( EWmlCmdSendAddressViaUnifiedMessage, ETrue );
+ aMenuPane->SetItemDimmed( EWmlCmdSendBookmarkViaUnifiedMessage, ETrue );
+ aMenuPane->SetItemDimmed( EWmlCmdSetAsHomePage, ETrue );
+ }
+ else
+ {
+ if ( ApiProvider().Preferences().UiLocalFeatureSupported( KBrowserUiHomePageSetting ) )
+ {
+ TBool dimSaveAsHomePage = EFalse;
+
+ if ( (item && (item->IsFolder() ||
+ item->Uid() == KFavouritesAdaptiveItemsFolderUid ||
+ item->ContextId())))
+ {
+ dimSaveAsHomePage = ETrue;
+ }
+ else
+ {
+ dimSaveAsHomePage = ApiProvider().IsEmbeddedModeOn() || !aState.CurrentIsItem()
+ || ( aState.MarkedCount() > 1 );
+ }
+
+ aMenuPane->SetItemDimmed( EWmlCmdSetAsHomePage, dimSaveAsHomePage );
+ }
+ if (!item)
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdSendBookmarkViaUnifiedMessage, ETrue );
+ }
+ else if ( (item && (item->IsFolder() ||
+ item->Uid() == KFavouritesAdaptiveItemsFolderUid ||
+ item->ContextId())))
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdSendBookmarkViaUnifiedMessage, ETrue );
+ }
+ }
+
+ aMenuPane->SetItemDimmed( EWmlCmdSendAddressViaUnifiedMessage, ETrue );
+
+ if(iInAdaptiveBookmarksFolder)
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdMove, ETrue );
+ aMenuPane->SetItemDimmed( EWmlCmdMoveToFolder, ETrue );
+ }
+ if ( ( item ) &&
+ ( ( item->Uid() == KFavouritesAdaptiveItemsFolderUid ) ||
+ ( item->ContextId() != NULL ) ||
+ (item->IsReadOnly()) ) //If the bookmarks are the default provided by operator
+ )
+ {
+ // We can't delete adaptive bookmarks folder,
+ // or seamless folders
+ aMenuPane->SetItemDimmed( EWmlCmdDelete, ETrue );
+ aMenuPane->SetItemDimmed( EWmlCmdMoveToFolder, ETrue );
+ }
+ if( item && item->IsFolder())
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdMoveToFolder, ETrue );
+ }
+
+#endif
+ // downloads
+ if(ApiProvider().StartedUp())
+ aMenuPane->SetItemDimmed( EWmlCmdDownloads, !ApiProvider().BrCtlInterface().BrowserSettingL( TBrCtlDefs::ESettingsNumOfDownloads ) );
+
+ // edit
+ if ( !item || (iInAdaptiveBookmarksFolder && aState.IsEmpty() ))
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdManageBookmarks, ETrue );
+ }
+#ifdef BRDO_SINGLE_CLICK_ENABLED_FF
+ // add bookmark
+ if ( iInAdaptiveBookmarksFolder )
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdAddBookmark, ETrue );
+ }
+
+ // create folder
+ if ( iCurrentFolder != KFavouritesRootUid || iInAdaptiveBookmarksFolder )
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdNewFolder, ETrue );
+ }
+#endif
+
+ if ( iInAdaptiveBookmarksFolder && aState.IsEmpty() )
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdBmActions, ETrue );
+ }
+#ifndef BRDO_SINGLE_CLICK_ENABLED_FF
+ if (!item)
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdMarkUnmark, ETrue );
+ }
+#endif
+/*
+ if (BRDO_BROWSER_UPDATE_UI_FF)
+ {
+ aMenuPane->SetItemDimmed( EAknCmdHelp, ETrue );
+ }
+ else
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdHelpMenu, ETrue );
+ }
+*/
+ break;
+ }
+ case R_GOTO_SUBMENU:
+ {
+ // back to page
+ if ( !ApiProvider().IsPageLoaded() && !ApiProvider().Fetching())
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdBackToPage, ETrue );
+ }
+
+ // bookmarks
+ aMenuPane->SetItemDimmed( EWmlCmdFavourites, ETrue );
+
+ // web feeds
+ if (ApiProvider().IsEmbeddedModeOn())
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdOpenFeedsFolder, ETrue );
+ }
+
+ // history
+ aMenuPane->SetItemDimmed( EWmlCmdHistory, ETrue );
+
+ // home
+ aMenuPane->SetItemDimmed( EWmlCmdLaunchHomePage, ETrue );
+ //search
+ if ( ! ApiProvider().Preferences().SearchFeature() )
+ {
+ aMenuPane->SetItemDimmed( EIsCmdSearchWeb, ETrue );
+ }
+ break;
+ }
+ case R_BMACTIONS_SUBMENU:
+ {
+#ifndef BRDO_SINGLE_CLICK_ENABLED_FF
+ // send
+ aMenuPane->SetItemDimmed( EWmlCmdSendAddressViaUnifiedMessage, ETrue );
+
+ if (!item)
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdSendBookmarkViaUnifiedMessage, ETrue );
+ }
+ else if ( (item && (item->IsFolder() ||
+ item->Uid() == KFavouritesAdaptiveItemsFolderUid ||
+ item->ContextId())))
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdSendBookmarkViaUnifiedMessage, ETrue );
+ }
+#endif
+ // copy to bookmarks
+ if ( !iInAdaptiveBookmarksFolder )
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdCopyToBookmarks, ETrue );
+ }
+#ifndef BRDO_SINGLE_CLICK_ENABLED_FF
+ // set as homepage
+ if ( ApiProvider().Preferences().UiLocalFeatureSupported( KBrowserUiHomePageSetting ) )
+ {
+ TBool dimSaveAsHomePage = EFalse;
+
+ if ( (item && (item->IsFolder() ||
+ item->Uid() == KFavouritesAdaptiveItemsFolderUid ||
+ item->ContextId())))
+ {
+ dimSaveAsHomePage = ETrue;
+ }
+ else
+ {
+ dimSaveAsHomePage = ApiProvider().IsEmbeddedModeOn() || !aState.CurrentIsItem()
+ || ( aState.MarkedCount() > 1 );
+ }
+
+ aMenuPane->SetItemDimmed( EWmlCmdSetAsHomePage, dimSaveAsHomePage );
+ }
+ // add bookmark
+ if ( iInAdaptiveBookmarksFolder )
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdAddBookmark, ETrue );
+ }
+#endif
+ // set preferred/unpreferred
+ if ( !iContainer->Listbox()->CurrentItem() )
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdSetPreferredBookmark, ETrue );
+ aMenuPane->SetItemDimmed( EWmlCmdSetUnPreferredBookmark, ETrue );
+ }
+ else
+ {
+ if ( ( iCurrentFolder == KFavouritesRootUid )||
+ !iContainer->Listbox()->GetDefaultData().iInSeamlessFolder ||
+ ( iContainer->Listbox()->GetDefaultData().iPreferedId ==
+ iContainer->Listbox()->CurrentItem()->Uid() )
+ )
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdSetPreferredBookmark, ETrue );
+ }
+
+ if ( ( iCurrentFolder == KFavouritesRootUid ) ||
+ !iContainer->Listbox()->GetDefaultData().iInSeamlessFolder ||
+ !( iContainer->Listbox()->GetDefaultData().iPreferedId ==
+ iContainer->Listbox()->CurrentItem()->Uid() )
+ )
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdSetUnPreferredBookmark,
+ ETrue );
+ }
+ }
+
+ break;
+ }
+ case R_BOOKMARKS_EDIT_SUBMENU:
+ {
+ // edit bookmark
+ if (!item || aState.MarkedCount() > 0)
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdEditBookmark, ETrue );
+ }
+ else if (( (item && (item->IsFolder() ||
+ item->Uid() == KFavouritesAdaptiveItemsFolderUid ||
+ item->ContextId() || aState.CurrentIsSpecial() || iInAdaptiveBookmarksFolder)))
+#ifdef BRDO_SINGLE_CLICK_ENABLED_FF
+ ||(item->IsReadOnly())//If the bookmarks are readonly(set by the operator)
+#endif
+ )
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdEditBookmark, ETrue );
+ }
+
+ // rename
+
+ // Can't rename recent urls and seamless folders - can only rename basic folders
+ if ( item->IsFolder() &&
+ (item->Uid() != KFavouritesAdaptiveItemsFolderUid) &&
+ (item->ContextId() == NULL) )
+ {
+ // more item is marked -> dim rename
+ if ( aState.MarkedCount() > 0 )
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdRename, ETrue );
+ }
+ }
+ else
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdRename, ETrue );
+ }
+
+#ifndef BRDO_SINGLE_CLICK_ENABLED_FF
+ // delete
+ if (!item)
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdDelete, ETrue );
+ }
+ else if ( item->Uid() == KFavouritesAdaptiveItemsFolderUid ||
+ item->ContextId() ||
+ !aState.AnyDeletable() )
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdDelete, ETrue );
+ }
+
+ // move
+ if ( iInAdaptiveBookmarksFolder || (TheContainer()->Listbox()->UnfilteredNumberOfItems() < 2 ) )
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdMove, ETrue );
+ }
+
+ // move to folder
+ if ( !aState.AnyPlainItem() || (iCurrentFolder == KFavouritesRootUid &&
+ iContainer && iContainer->Listbox() && !iContainer->Listbox()->AnyFoldersL()) )
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdMoveToFolder, ETrue );
+ }
+ // create folder
+ if ( iCurrentFolder != KFavouritesRootUid || iInAdaptiveBookmarksFolder )
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdNewFolder, ETrue );
+ }
+#endif
+
+ break;
+ }
+ case R_BROWSER_FAVOURITES_MENU_PANE_MARK_UNMARK:
+ {
+ // For items and folders, show "Mark" or "Unmark".
+ aMenuPane->SetItemDimmed ( aState.CurrentIsMarked() ? EWmlCmdMark : EWmlCmdUnmark, ETrue );
+ #ifndef SHOW_UNMARK_ALL_ALWAYS
+
+ // We must show "Unmark all", even if nothing is marked.
+ //
+ // The case when there are no items at all, is not handled here:
+ // in that case we don't have "Edit list" menu.
+ if ( aState.NoneIsMarked() )
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdUnmarkAll, ETrue );
+ }
+ #endif // SHOW_UNMARK_ALL_ALWAYS
+
+ #ifndef SHOW_MARK_ALL_ALWAYS
+ // As for "mark all", consider items only.
+ if ( (aState.iVisibleItemCount == aState.iMarkedItemCount) && (aState.iVisibleFolderCount == aState.iMarkedFolderCount) )
+ {
+ //Checking for both items and folders
+ aMenuPane->SetItemDimmed( EWmlCmdMarkAll, ETrue );
+ }
+ else if( (aState.iVisibleItemCount == 0) && (aState.iVisibleFolderCount < 2))//Only one folder is present and no items
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdMarkAll, ETrue );
+ }
+ #endif // SHOW_MARK_ALL_ALWAYS
+ break;
+ }
+ case R_BROWSER_BOOKMARKS_MENU_PANE_OK:
+ {
+ // Bookmark-specific handling.
+ if ( aState.IsEmpty() || (TheContainer()->Listbox()->UnfilteredNumberOfItems() < 2)||iInAdaptiveBookmarksFolder)
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdMove, ETrue );
+ }
+ else
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdMove, EFalse );
+ }
+
+ //Disable MoveToFolder option if you are in RecentlyVisitedUrl folder
+ if( iInAdaptiveBookmarksFolder )
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdMoveToFolder, ETrue );
+ // These options are not required when user press MSK
+ aMenuPane->SetItemDimmed( EWmlCmdAddBookmark, ETrue );
+ aMenuPane->SetItemDimmed( EWmlCmdCopyToBookmarks, ETrue );
+ aMenuPane->SetItemDimmed( EWmlCmdSwitchToGotoActive, ETrue );
+ aMenuPane->SetItemDimmed( EWmlCmdNewFolder, ETrue );
+ }
+
+ if( iContainer && iContainer->Listbox() && !iContainer->Listbox()->AnyFoldersL() )
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdMoveToFolder, ETrue );
+ }
+ const CFavouritesItem* item = NULL;
+ if(TheContainer() && TheContainer()->Listbox())
+ item = TheContainer()->Listbox()->CurrentItem();
+
+ if ( ( item ) &&
+ ( ( item->Uid() == KFavouritesAdaptiveItemsFolderUid ) ||
+ ( item->ContextId() != NULL ) )
+ )
+ {
+ // We can't delete adaptive bookmarks folder,
+ // or seamless folders
+ aMenuPane->SetItemDimmed( EWmlCmdDelete, ETrue );
+ aMenuPane->SetItemDimmed( EWmlCmdMoveToFolder, ETrue );
+ }
+
+ //Enable CopyToBookmarks option if you are in RecentlyVisitedUrl folder
+ if( iInAdaptiveBookmarksFolder )
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdCopyToBookmarks, EFalse );
+ }
+ //judge the selected items include RecentlyVisitedUrl folder or not, if include set "copy to bookmarks" dim
+ CArrayPtr<const CFavouritesItem>* items = Container()->Listbox()->SelectedItemsLC();
+ if (items->Count())
+ {
+ for (TInt i=0;i<items->Count();i++)
+ {
+ if((*items)[i]->Uid() == KFavouritesAdaptiveItemsFolderUid )
+ {
+ aMenuPane->SetItemDimmed( EWmlCmdCopyToBookmarks, ETrue );
+ }
+ }
+ }
+ CleanupStack::PopAndDestroy();//items
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::RootTitleResourceId
+// ----------------------------------------------------------------------------
+//
+TInt CBrowserBookmarksView::RootTitleResourceId() const
+ {
+ if ( iOpenAdaptiveBookmarksWhenActivated )
+ {
+ return R_BROWSER_ADAPTIVE_BOOKMARKS_TITLE;
+ }
+ else
+ {
+ return R_BROWSER_OPTION_BOOKMARKS;
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::OptionsMenuResourceId
+// ----------------------------------------------------------------------------
+//
+TInt CBrowserBookmarksView::OptionsMenuResourceId() const
+ {
+ return ( R_BROWSER_BOOKMARKS_MENU_BAR );
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::OkOptionsMenuResourceId
+// ----------------------------------------------------------------------------
+//
+TInt CBrowserBookmarksView::OkOptionsMenuResourceId() const
+ {
+ return R_BROWSER_BOOKMARKS_MENU_BAR_OK;
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::CreateModelL
+// ----------------------------------------------------------------------------
+//
+CBrowserFavouritesModel* CBrowserBookmarksView::CreateModelL()
+ {
+ return CBrowserBookmarksModel::NewL(ApiProvider());
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::CreateContainerL
+// ----------------------------------------------------------------------------
+
+CBrowserFavouritesContainer* CBrowserBookmarksView::CreateContainerL()
+ {
+ CBrowserBookmarksContainer* container =
+ CBrowserBookmarksContainer::NewL( ClientRect(), *this );
+ container->GotoPane()->SetGPObserver( this );
+ if( ApiProvider().Preferences().SearchFeature() )
+ container->SearchPane()->SetGPObserver( this );
+ return container;
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::MoveItemsL
+// ----------------------------------------------------------------------------
+void CBrowserBookmarksView::MoveItemsL()
+ {
+
+ // Get the Uid of currently highlighted bookmark item from listbox.
+ // NOTE: Listbox indexes is based on "visible" items in list box, our order
+ // array has visible and invisible items, we have to use Uid to find items.
+ const CFavouritesItem* toItem = Container()->Listbox()->CurrentItem();
+ TInt toUid(NULL);
+ if ( toItem ) {
+ toUid = toItem->Uid();
+ if (toUid == (*iItemsToMove)[0])
+ { // Moving to same location so change nothing, cleanup, & exit
+ CancelMoveItemsL();
+ return;
+ }
+ }
+
+ // Get a copy of the ordered array, it may contain visible and hidden items.
+ CArrayFixFlat<TInt>* orderArray =
+ new (ELeave) CArrayFixFlat<TInt>(KGranularityHigh);
+ CleanupStack::PushL( orderArray );
+
+ orderArray->AppendL( & ( iCurrentOrder->GetBookMarksOrder()[0] ),
+ iCurrentOrder->GetBookMarksOrder().Count() );
+
+ if ( toUid == NULL ) {
+ toUid = (*orderArray)[orderArray->Count()-1] ;
+ }
+
+
+ // Create a sorted "bookmarks to be moved" array
+ CArrayFixFlat<TInt>* sortedItemsToMove =
+ new (ELeave) CArrayFixFlat<TInt>(KGranularityHigh);
+ CleanupStack::PushL( sortedItemsToMove );
+
+
+ // Walk our copy of the ordered bookmark array and
+ // 1. Delete the bookmark items to be moved from the ordered array
+ // 2. Sort the bookmark items to be moved to match the visible order of the list
+ TInt i( 0 ); // index into order bookmark list
+ TInt j( 0 ); // index into sorted iItemsToMove
+ for ( i=0; i < orderArray->Count(); i++ ) {
+ TInt orderArrayUid = (*orderArray)[i];
+
+ // Find bookmark to be moved, sort and remove
+ for ( j=0; j < iItemsToMove->Count(); j++ ) {
+ if ( (*iItemsToMove)[j] == orderArrayUid ) {
+ sortedItemsToMove->AppendL( (*iItemsToMove)[j] );
+ orderArray->Delete( i );
+ i--;
+ break;
+ }
+ }
+
+ // Stop sorting, if we're done
+ if ( iItemsToMove->Count() == sortedItemsToMove->Count() ) {
+ break;
+ }
+ }
+
+ // Find the highlighted bookmark item and insert the newly ordered
+ // "bookmark items to be moved" in there
+ for ( i=0; i < orderArray->Count(); i++ ) {
+ if ( toUid == (*orderArray)[ i ] ) {
+ for ( j=0; j < sortedItemsToMove->Count(); j++ ) {
+ orderArray->InsertL( i+j, (*sortedItemsToMove)[j] );
+ }
+ break;
+ }
+ }
+
+ iCurrentOrder->SetBookMarksOrderL( *orderArray );
+ Model().Database().SetData( CurrentFolder(), *iCurrentOrder );
+
+ iManualItemMovingGoingOn = EFalse;
+ Container()->Listbox()->ClearSelection();
+ iPreferredHighlightUid = (*sortedItemsToMove)[0];
+
+ // Delete our arrays sortedItemsToMove, orderArray
+ CleanupStack::PopAndDestroy( 2 );
+ delete iItemsToMove;
+ iItemsToMove = NULL;
+
+ UpdateCbaL();
+ // UnDim Toolbar buttons
+ DimToolbarButtons(EFalse);
+
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::CancelMoveItems
+// ----------------------------------------------------------------------------
+//
+void CBrowserBookmarksView::CancelMoveItemsL()
+ {
+ iManualItemMovingGoingOn = EFalse;
+ HandleCommandL(EWmlCmdUnmarkAll);
+ UpdateCbaL();
+ // UnDim Toolbar buttons
+ DimToolbarButtons(EFalse);
+ iPreferredHighlightUid = ( *iItemsToMove )[0];
+ delete iItemsToMove;
+ iItemsToMove = NULL;
+ RefreshL();
+ }
+
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::StartMoveItems
+// ----------------------------------------------------------------------------
+//
+void CBrowserBookmarksView::StartMoveItemsL()
+ {
+ iManualItemMovingGoingOn = ETrue;
+
+ TInt moveFrom = ( *Container()->Listbox()->SelectedRealIndexesLC() )[0];
+ CleanupStack::PopAndDestroy(); //SelectedRealIndexesLC
+ TInt count = Container()->Listbox()->SelectedRealIndexesLC()->Count();
+ CleanupStack::PopAndDestroy(); //SelectedRealIndexesLC
+ if ( ( count == 1 )
+ && ( Container()->Listbox()->CurrentItemRealIndex() == moveFrom ) )
+ {
+ HandleCommandL(EWmlCmdMark);
+ }
+
+
+ if (iItemsToMove)
+ {
+ delete iItemsToMove;
+ iItemsToMove = NULL;
+ }
+ iItemsToMove = new (ELeave) CArrayFixFlat<TInt>( KGranularityHigh );
+
+ CArrayPtr<const CFavouritesItem>* items =
+ Container()->Listbox()->SelectedItemsLC();
+
+ for ( TInt i = 0; i < items->Count(); i++ )
+ {
+ iItemsToMove->AppendL( (*(*items)[i]).Uid() );
+ }
+ CleanupStack::PopAndDestroy(items);
+ UpdateCbaL();
+ // Dim Toolbar buttons
+ DimToolbarButtons(ETrue);
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::ManualBMSortL
+// ----------------------------------------------------------------------------
+//
+TBool CBrowserBookmarksView::ManualBMSortL( TInt aFolder,
+ CFavouritesItemList* aItems )
+ {
+ __ASSERT_DEBUG( (aItems != NULL), Util::Panic( Util::EUninitializedData ));
+
+ delete iCurrentOrder;
+ iCurrentOrder = NULL;
+ iCurrentOrder = CBrowserBookmarksOrder::NewLC();
+ CleanupStack::Pop();
+ if ( aItems->Count() )
+ {
+ CArrayFixFlat<TInt>* orderArray = new (ELeave) CArrayFixFlat<TInt>(KGranularityHigh);
+ CleanupStack::PushL(orderArray);
+
+ if ( !Model().Database().GetData( aFolder ,*iCurrentOrder ) )
+ {
+ if ( iCurrentOrder->GetBookMarksOrder().Count() > 0 )
+ {
+ orderArray->AppendL( & ( iCurrentOrder->GetBookMarksOrder()[0] ),
+ iCurrentOrder->GetBookMarksOrder().Count());
+
+ if ( aFolder == KFavouritesRootUid )
+ {
+ TInt i = 0;
+
+ while ( i < orderArray->Count() &&
+ !( (*orderArray)[i] == KFavouritesStartPageUid ))
+ {
+ i++;
+ }
+
+ if ( i == orderArray->Count() )
+ {
+ if ( iStartPagePresent )
+ {
+ orderArray->InsertL( 0, KFavouritesStartPageUid );
+ iSaveBMOrder = ETrue;
+ }
+ }
+ else
+ {
+ if ( !iStartPagePresent )
+ {
+ orderArray->Delete(i);
+ iSaveBMOrder = ETrue;
+ }
+ }
+ if ( iInsertAdaptiveBookmarksFolder )
+ {
+ iInsertAdaptiveBookmarksFolder = EFalse;
+ i = 0;
+
+ while ( i < orderArray->Count() &&
+ !( (*orderArray)[i] ==
+ KFavouritesAdaptiveItemsFolderUid ))
+ {
+ i++;
+ }
+
+ if ( i < orderArray->Count() )
+ {
+ orderArray->Delete(i);
+ }
+ if ( orderArray->Count() )
+ {
+ if ( (*orderArray)[0] == KFavouritesStartPageUid )
+ {
+ orderArray->InsertL( 1,
+ KFavouritesAdaptiveItemsFolderUid );
+ }
+ else
+ {
+ orderArray->InsertL( 0,
+ KFavouritesAdaptiveItemsFolderUid );
+ }
+ }
+ }
+ else
+ if ( (ADAPTIVEBOOKMARKS) &&
+ ( ApiProvider().Preferences().AdaptiveBookmarks() ==
+ EWmlSettingsAdaptiveBookmarksOn ) )
+ {
+ i = 0;
+
+ while ( i < orderArray->Count() &&
+ !( (*orderArray)[i] ==
+ KFavouritesAdaptiveItemsFolderUid ))
+ {
+ i++;
+ }
+
+ if ( i == orderArray->Count() != 0 )
+ {
+ if ( (*orderArray)[0] == KFavouritesStartPageUid )
+ {
+ orderArray->InsertL( 1,
+ KFavouritesAdaptiveItemsFolderUid );
+ }
+ else
+ {
+ orderArray->InsertL( 0,
+ KFavouritesAdaptiveItemsFolderUid );
+ }
+ }
+ }
+
+ //add new items to the beginning of the list, if there is any
+ for ( TInt j = 0; j < aItems->Count(); j++ )
+ {
+ i = 0;
+ while ( i < orderArray->Count() &&
+ !( (*orderArray)[i] == aItems->At(j)->Uid() ))
+ {
+ i++;
+ }
+
+ if ( i == orderArray->Count() &&
+ !(aItems->At(j)->IsFactoryItem() ) &&
+ !(aItems->At(j)->Uid() ==
+ KFavouritesAdaptiveItemsFolderUid) &&
+ !(aItems->At(j)->Uid() == KFavouritesStartPageUid) )
+ {
+ Model().AddUidToLastPlaceL( aItems->At(j)->Uid(),
+ orderArray, iCurrentOrder );
+ }
+ }
+ }
+ Model().ManualSortL(aFolder, iCurrentOrder, orderArray, aItems);
+ orderArray->Reset();
+ }
+ }
+
+ orderArray->Reset();
+
+ if ( aItems->Count() )
+ {
+ for ( TInt i = 0; i < aItems->Count(); i++ )
+ {
+ orderArray->AppendL( (*aItems)[i]->Uid() );
+ }
+ iCurrentOrder->SetBookMarksOrderL( *orderArray );
+ }
+ if ( iSaveBMOrder )
+ {
+ iSaveBMOrder = EFalse;
+ Model().Database().SetData( aFolder, *iCurrentOrder );
+ }
+ CleanupStack::PopAndDestroy( orderArray );
+ }
+ return ETrue;
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::GetItemsL
+// ----------------------------------------------------------------------------
+//
+CFavouritesItemList* CBrowserBookmarksView::GetItemsLC( TInt aFolder )
+ {
+PERFLOG_LOCAL_INIT
+PERFLOG_STOPWATCH_START
+ CFavouritesItemList* items;
+ if ( iInAdaptiveBookmarksFolder )
+ {
+ items= new (ELeave) CFavouritesItemList();
+ CleanupStack::PushL(items);//1
+ CDesCArrayFlat* aditems = new ( ELeave )
+ CDesCArrayFlat( KBrowserDesCArrayGranularity );
+ aditems->Reset();
+ CleanupStack::PushL(aditems);//2
+
+ CDesCArrayFlat* adnames = new ( ELeave )
+ CDesCArrayFlat( KBrowserDesCArrayGranularity );
+ adnames->Reset();
+ CleanupStack::PushL(adnames);//3
+
+ CFavouritesItem* adaptiveItem;
+
+ if ( !iRecentUrlStore.GetData( *aditems, *adnames) )
+ {
+ for (TInt i=0;i<aditems->MdcaCount(); i++)
+ {
+ adaptiveItem= CFavouritesItem::NewL();
+ CleanupStack::PushL(adaptiveItem);//4
+ adaptiveItem->SetUrlL( aditems->MdcaPoint(i) );
+ adaptiveItem->SetNameL(adnames->MdcaPoint(i).Left(KFavouritesMaxName));
+ adaptiveItem->SetType(CFavouritesItem::EItem);
+ adaptiveItem->SetParentFolder(KFavouritesAdaptiveItemsFolderUid);
+ items->AppendL(adaptiveItem);
+ CleanupStack::Pop(); // adaptiveItem
+ }
+ }
+ CleanupStack::PopAndDestroy( 2 );// aditems, adnames
+ }
+ else
+ {
+ items = new (ELeave) CFavouritesItemList();
+ CleanupStack::PushL( items );
+ Model().Database().GetAll( *items, aFolder );
+ TInt aBMPosition = KAdaptiveBookmarksFirstPositionInBMView; // Adaptive BM folder is first if there is no startpage
+ if ( aFolder == KFavouritesRootUid )
+ {
+ // Create Start Page item to be displayed in root folder (if exist).
+ // (Start Page does not really exist in the database.)
+ CFavouritesItem* startPage = CreateStartPageBookmarkL();
+ if ( startPage )
+ {
+ if (!iStartPagePresent)
+ {
+ iStartPagePresent = ETrue;
+ iSaveBMOrder = ETrue;
+ }
+ CleanupStack::PushL( startPage ); // ownersip is here.
+ items->InsertL( 0, startPage );
+ CleanupStack::Pop(); // startPage: owner is the list now.
+ aBMPosition=KAdaptiveBookmarksSecondPositionInBMView; // Adaptive BM folder is second if there is a startpage item
+ }
+ else
+ {
+ if (iStartPagePresent)
+ {
+ iStartPagePresent = EFalse;
+ iSaveBMOrder = ETrue;
+ }
+ }
+ }
+
+ if ( aFolder == KFavouritesRootUid )
+ {
+ // Create Adaptive Items Folder item to be displayed in root folder (if exist).
+ // (Start Page does not really exist in the database.)
+ if ( ( ADAPTIVEBOOKMARKS ) &&
+ ( ApiProvider().Preferences().AdaptiveBookmarks() ==
+ EWmlSettingsAdaptiveBookmarksOn ))
+ {
+ CFavouritesItem* adaptiveItemsFolder =
+ Model().Database().CreateAdaptiveItemsFolderL();
+ CleanupStack::PushL(adaptiveItemsFolder);
+ HBufC* folderName=StringLoader::LoadLC(
+ R_BROWSER_ADAPTIVE_BOOKMARKS_FOLDER);
+ adaptiveItemsFolder->SetNameL(*folderName);
+
+ CleanupStack::PopAndDestroy();//folderName
+ items->InsertL( aBMPosition , adaptiveItemsFolder );
+ CleanupStack::Pop(); // adaptiveItemsFolder: owner is the list now.
+ }
+ }
+ ManualBMSortL( aFolder, items );
+ }
+PERFLOG_STOP_WRITE("\t\t\t\t BM View GetItemsLC" );
+ return items;
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::RefreshL
+// ----------------------------------------------------------------------------
+//
+void CBrowserBookmarksView::RefreshL( TBool aDbErrorNote )
+ {
+ // Same as base class method, except that refreshing Goto Pane is
+ // disallowed when fetching is in progress.
+ // Base class call is TRAP-ped to make sure that frozen state of the Goto
+ // Pane does not stay in due to a leave; but after removing the frozen
+ // state, we trow up the catched leave again (if any).
+ TBool fetching = ApiProvider().Fetching();
+
+ if ( (fetching && TheContainer() && TheContainer()->GotoPane() )
+ || ( TheContainer() && TheContainer()->GotoPane() && TheContainer()->GotoPane()->IsEditing() ))
+ {
+ TheContainer()->GotoPane()->Freeze( ETrue );
+ }
+
+ TRAPD( err, CBrowserFavouritesView::RefreshL( aDbErrorNote ) );
+
+
+ if ( TheContainer() && TheContainer()->GotoPane() )
+ {
+ TheContainer()->GotoPane()->Freeze( EFalse );
+ }
+ User::LeaveIfError( err );
+ // Refresh (i.e. bookmark creation in an empty folder) may cause the need
+ // for toolbar button state to change.
+ UpdateToolbarButtonsState();
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::DoActivateL
+// ----------------------------------------------------------------------------
+//
+void CBrowserBookmarksView::DoActivateL (
+ const TVwsViewId& aPrevViewId,
+ TUid aCustomMessageId,
+ const TDesC8& aCustomMessage
+ )
+ {
+PERFLOG_LOCAL_INIT
+PERFLOG_STOPWATCH_START
+ LOG_ENTERFN("CBrowserBookmarksView::DoActivateL");
+ LOG_WRITE_FORMAT(" aCustomMessageId: %d", aCustomMessageId);
+
+#ifdef BRDO_PERF_IMPROVEMENTS_ENABLED_FF
+ // Quick activation for first time only to show bookmarks view fast
+ if(!ApiProvider().StartedUp())
+ {
+ CBrowserFavouritesView::DoActivateL( aPrevViewId, aCustomMessageId, aCustomMessage );
+ if ( aCustomMessageId == KUidCustomMsgDownloadsList )
+ {
+ iShowDownlods = ETrue;
+ // Show the downloads later since contentview has not initialized yet
+ }
+
+ // complete remaining application launch process, aynchronously
+ // complete remaining init as soon as possible, otherwise it can be dangerous (crash)
+ // since UI code (views) are interdependent
+ iAsyncComplete = CIdle::NewL( CActive::EPriorityHigh );
+ iAsyncComplete->Start( TCallBack( CompleteAppInitCallback, &iApiProvider ) );
+ return;
+ }
+#endif
+
+ Toolbar()->HideItem( EWmlCmdAddBookmark, EFalse , ETrue);
+
+#ifndef BRDO_SINGLE_CLICK_ENABLED_FF
+ Toolbar()->HideItem( EWmlCmdDelete, EFalse , ETrue);
+#else
+ Toolbar()->HideItem( EWmlCmdPreferences, EFalse , ETrue);
+#endif
+
+ if ( ApiProvider().Preferences().SearchFeature() )
+ {
+ Toolbar()->HideItem( EWmlCmdGoToAddressAndSearch, EFalse, ETrue);
+ }
+ else
+ {
+ Toolbar()->HideItem( EWmlCmdGoToAddress, EFalse, ETrue);
+ }
+
+ Cba()->MakeVisible( ETrue);
+
+ StatusPane()->SwitchLayoutL( R_AVKON_STATUS_PANE_LAYOUT_USUAL );
+ StatusPane()->MakeVisible( ETrue );
+ ApiProvider().Display().ClearMessageInfo();
+
+ iAdaptiveBookmarksFolderWasActive = EFalse;
+
+ if ( iOpenAdaptiveBookmarksWhenActivated )
+ {
+ iInAdaptiveBookmarksFolder = ETrue;
+ }
+ CBrowserFavouritesView::DoActivateL
+ ( aPrevViewId, aCustomMessageId, aCustomMessage );
+ ApiProvider().BrCtlInterface().AddLoadEventObserverL( this );
+
+ if ( iPreferencesChanged )
+ {
+ iPreferencesChanged=EFalse;
+ if ( iInAdaptiveBookmarksFolder )
+ {
+ SetEmptyTextL();
+ RefreshL();
+ }
+ }
+
+ if ( aCustomMessageId == KUidCustomMsgDownloadsList )
+ {
+ LOG_WRITE(" KUidCustomMsgDownloadsList");
+ // open the downloads list asynchronously not to block DoActivateL!
+ if ( iDownloadsListExecuter == 0 )
+ {
+ iDownloadsListExecuter = new (ELeave) CAsyncDownloadsListExecuter( ApiProvider() );
+ }
+ iDownloadsListExecuter->Start();
+ }
+ if ( iOpenAdaptiveBookmarksWhenActivated )
+ {
+ iInAdaptiveBookmarksFolder = ETrue;
+ SetEmptyTextL();
+ RefreshL();
+ iOpenAdaptiveBookmarksWhenActivated = EFalse;
+ }
+
+ UpdateToolbarButtonsState();
+
+PERFLOG_STOP_WRITE("BMView DoActivate")
+// LOG_LEAVEFN("CBrowserBookmarksView::DoActivateL");
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::CompleteAppInitCallback
+// ----------------------------------------------------------------------------
+//
+TInt CBrowserBookmarksView::CompleteAppInitCallback( TAny* aProvider )
+ {
+ MApiProvider *apiProvider = STATIC_CAST(MApiProvider*, aProvider);
+ TBool result = apiProvider->CompleteDelayedInit();
+ return result;
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::UpdateFavIcons
+// ----------------------------------------------------------------------------
+//
+void CBrowserBookmarksView::UpdateFavIconsL()
+ {
+ if ( Container() && Container()->Listbox() )
+ Container()->Listbox()->UpdateFavIconsL();
+ }
+
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::CheckForDownloads
+// ----------------------------------------------------------------------------
+//
+void CBrowserBookmarksView::CheckForDownloads()
+ {
+ if(iShowDownlods)
+ {
+ if ( iDownloadsListExecuter == 0 )
+ iDownloadsListExecuter = new (ELeave) CAsyncDownloadsListExecuter( ApiProvider() );
+ iDownloadsListExecuter->Start();
+ }
+ }
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::DoDeactivate
+// ----------------------------------------------------------------------------
+//
+void CBrowserBookmarksView::DoDeactivate()
+ {
+ if ( !iSaveStateOnDeactivate )
+ {
+ ExitAdaptiveBookmarks();
+ }
+ if ( !ApiProvider().ExitInProgress() )
+ {
+ if ( ApiProvider().StartedUp() )
+ ApiProvider().BrCtlInterface().RemoveLoadEventObserver( this );
+ }
+ CBrowserFavouritesView::DoDeactivate();
+ iManualItemMovingGoingOn = EFalse;
+ // UnDim Toolbar buttons
+ DimToolbarButtons(EFalse);
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::GotoUrlInGotoPaneL
+// ----------------------------------------------------------------------------
+//
+void CBrowserBookmarksView::GotoUrlInGotoPaneL()
+ {
+LOG_ENTERFN("BookmarksView::GotoUrlInGotoPaneL");
+ CBrowserBookmarksContainer* container = TheContainer();
+ if ( container->GotoPane()->IsEditing() )
+ {
+ // Dim Toolbar buttons
+ DimToolbarButtons(EFalse);
+
+ delete iEnteredURL;
+ iEnteredURL = NULL;
+ BROWSER_LOG( ( _L("delete iEnteredUrl 4") ) );
+
+ iEnteredURL = container->GotoPane()->GetTextL();
+ if ( iEnteredURL )
+ {
+ iTrId = 0;
+ CEikEdwin* editor = STATIC_CAST(CEikEdwin*, container->GotoPane()->ComponentControl(1));
+ iCursorPos = editor->CursorPos();
+
+ UpdateCbaL();
+ // Cancel editing, but leave entered text in place.
+ container->GotoPane()->CancelEditingL();
+
+ ApiProvider().FetchL( iEnteredURL->Des(), CBrowserLoadObserver::ELoadUrlTypeOther );
+ if ( !ApiProvider().Fetching() )
+ {
+ container->SetGotoInactiveL();
+ }
+ }
+ }
+ }
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::ExitAdaptiveBookmarks()
+// ----------------------------------------------------------------------------
+//
+void CBrowserBookmarksView::ExitAdaptiveBookmarks()
+ {
+ if (iInAdaptiveBookmarksFolder)
+ {
+ iAdaptiveBookmarksFolderWasActive = ETrue;
+ iInAdaptiveBookmarksFolder=EFalse;
+ delete iDomainFolderName;
+ iDomainFolderName=NULL;
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::DimToolbarButtons()
+// ----------------------------------------------------------------------------
+//
+void CBrowserBookmarksView::DimToolbarButtons(TBool aDimButtons)
+ {
+ Toolbar()->SetItemDimmed( EWmlCmdAddBookmark, aDimButtons , ETrue );
+ Toolbar()->SetItemDimmed( EWmlCmdGoToAddress, aDimButtons , ETrue );
+ Toolbar()->SetItemDimmed( EWmlCmdGoToAddressAndSearch, aDimButtons , ETrue );
+#ifndef BRDO_SINGLE_CLICK_ENABLED_FF
+ Toolbar()->SetItemDimmed( EWmlCmdDelete, aDimButtons , ETrue );
+#else
+ Toolbar()->SetItemDimmed( EWmlCmdPreferences, aDimButtons , ETrue );
+#endif
+ if (!aDimButtons)
+ {
+ // when undimming buttons we may not want them all back on
+ UpdateToolbarButtonsState();
+ }
+ Toolbar()->DrawNow();
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::ActivateCurrentBookmarkL
+// ----------------------------------------------------------------------------
+//
+void CBrowserBookmarksView::ActivateCurrentBookmarkL()
+ {
+ if ( Container() && Container()->Listbox() )
+ {
+ const CFavouritesItem* item = Container()->Listbox()->CurrentItem();
+ if ( item && item->IsItem() )
+ {
+ ApiProvider().FetchBookmarkL( *item );
+ }
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::AddNewBookmarkL
+// ----------------------------------------------------------------------------
+//
+void CBrowserBookmarksView::AddNewBookmarkL()
+ {
+ // Make an item and fill it with default values.
+ CFavouritesItem* item = CFavouritesItem::NewLC();
+ item->SetType( CFavouritesItem::EItem );
+ item->SetParentFolder( CurrentFolder() );
+ item->SetUrlL( KHttpString );
+ Model().SetNameToDefaultL( *item );
+ TInt err = Model().MakeUniqueNameL( *item );
+ if ( !err )
+ {
+ // to prevent faded statuspane at the begining of dialog activation
+ CEikStatusPane* sp = STATIC_CAST( CAknAppUi*,
+ CEikonEnv::Static()->EikAppUi() )
+ ->StatusPane();
+ sp->DrawNow();
+
+ // Dim Toolbar buttons
+ DimToolbarButtons(ETrue);
+
+ // We have the item with a default unique name. Let the user edit it.
+ CBrowserBookmarkEditDialog* dialog =
+ CBrowserBookmarkEditDialog::NewL
+ (
+ *item,
+ Model(),
+ //ApiProvider().CommsModel()
+ ApiProvider()
+ );
+ dialog->ExecuteLD( R_BROWSER_BOOKMARKS_DIALOG_EDIT );
+
+ // Un-Dim Toolbar buttons
+ DimToolbarButtons(EFalse);
+
+ // If the bookmark was added to the database, highlight it.
+ // Unlike in AddNewFolderL, adding the item to the database
+ // and setting highlight uid (next line of code) runs in the RunL
+ // method of different active objects. So the database notification
+ // may have came in or may not by now.
+ // This way of doing the highlight (setting a preferred and calling
+ // HighlightPreferred works in both cases.
+ iPreferredHighlightUid = item->Uid();
+ // If not added, iPreferredHighlightUid is now KFavouritesNullUid,
+ // so the following does nothing.
+ if ( iPreferredHighlightUid != KFavouritesNullUid )
+ {
+ // Highlight newly added item.
+ HighlightPreferredL();
+ }
+ }
+ AddUidToLastPlaceToCurrentListL( item->Uid() );
+ iRefresh = EFalse;
+ Model().Database().SetData( CurrentFolder() , *iCurrentOrder );
+ CleanupStack::PopAndDestroy(); // item
+ Container()->Listbox()->ClearSelection();
+ }
+
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::AddUidToLastPlaceToCurrentListL
+// ----------------------------------------------------------------------------
+//
+void CBrowserBookmarksView::AddUidToLastPlaceToCurrentListL( TInt aUid )
+ {
+ if ( iCurrentOrder )
+ {
+ CArrayFixFlat<TInt>* orderArray = new (ELeave) CArrayFixFlat<TInt>(KGranularityHigh);
+ CleanupStack::PushL( orderArray );
+
+ if (iCurrentOrder->GetBookMarksOrder().Count())
+ {
+ orderArray->AppendL( &( iCurrentOrder->GetBookMarksOrder()[0] ),
+ iCurrentOrder->GetBookMarksOrder().Count());
+ }
+
+ Model().AddUidToLastPlaceL(aUid, orderArray, iCurrentOrder);
+
+ iCurrentOrder->SetBookMarksOrderL( *orderArray );
+ CleanupStack::PopAndDestroy( orderArray );
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarks::EditCurrentBookmarkL
+// ----------------------------------------------------------------------------
+//
+void CBrowserBookmarksView::EditCurrentBookmarkL()
+ {
+ if ( Container() && Container()->Listbox() )
+ {
+ const CFavouritesItem* listboxItem =
+ Container()->Listbox()->CurrentItem();
+ if ( listboxItem && listboxItem->IsItem() )
+ {
+ // to prevent faded statuspane at the begining of dialog activation
+ CEikStatusPane* sp = STATIC_CAST( CAknAppUi*,
+ CEikonEnv::Static()->EikAppUi() )
+ ->StatusPane();
+ sp->DrawNow();
+
+ // Dim Toolbar buttons
+ DimToolbarButtons(ETrue);
+
+ CFavouritesItem* item = CFavouritesItem::NewLC();
+ *item = *listboxItem;
+ CBrowserBookmarkEditDialog* dialog =
+ CBrowserBookmarkEditDialog::NewL
+ (
+ *item,
+ Model(),
+ ApiProvider(),
+ listboxItem->Uid()
+ );
+ dialog->ExecuteLD( R_BROWSER_BOOKMARKS_DIALOG_EDIT );
+ CleanupStack::PopAndDestroy(); // item
+
+ // unDim Toolbar buttons
+ DimToolbarButtons(EFalse);
+
+ iPreferredHighlightUid = item->Uid();
+
+ // Force a refresh of database changes.
+ iRefresh = ETrue;
+ }
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::SendBookmarksL
+// ----------------------------------------------------------------------------
+//
+void CBrowserBookmarksView::SendBookmarksL( )
+ {
+ CArrayPtr<const CFavouritesItem>* items =
+ Container()->Listbox()->SelectedItemsLC();
+
+ MBmOTABinSender& sender = ApiProvider().BmOTABinSenderL();
+
+ sender.ResetAndDestroy();
+
+ TBool result( ETrue );
+ TInt index( 0 );
+ TInt count( items->Count() );
+
+#ifndef _BOOKMARK_SENT_ASCII
+ for ( index = 0; index < count; ++index )
+ {
+ if ( ( *items )[ index ]->Url().Length() > KMaxUrlLenghtInOTA )
+ {
+#pragma message ( __FILE__ ": TODO: Length of bookmark address cannot exceed 255bytes!")
+ result = EFalse;
+ }
+ }
+#endif // _BOOKMARK_SENT_ASCII
+
+ if ( result )
+ {
+ for ( index = 0; index < count; ++index )
+ {
+ sender.AppendL( ( *items )[ index ]->Url(),
+ ( *items )[ index ]->Name() );
+ }
+ }
+
+ // to save memory
+ CleanupStack::PopAndDestroy(); // items;
+
+ if ( result )
+ {
+ sender.SendAddressL( );
+ }
+
+ Container()->Listbox()->SetCurrentItemIndexAndDraw( Container()->Listbox()->CurrentItemIndex());
+ }
+
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::TheContainer
+// ----------------------------------------------------------------------------
+//
+CBrowserBookmarksContainer* CBrowserBookmarksView::TheContainer()
+ {
+ return STATIC_CAST( CBrowserBookmarksContainer*, Container() );
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::ApChangedL
+// ----------------------------------------------------------------------------
+//
+void CBrowserBookmarksView::ApChangedL( TUint32 aNewAPId )
+ {
+ if ( aNewAPId != iStartPageApUid )
+ {
+ // New AP has been taken into use. Set Start Page to that.
+ iStartPageApUid = aNewAPId;
+ // Redraw view. Note that this does nothing if view is not activated.
+ RefreshL( EFalse );
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::HandlePreferencesChangeL
+// ----------------------------------------------------------------------------
+//
+void CBrowserBookmarksView::HandlePreferencesChangeL(
+ const TPreferencesEvent /*aEvent*/,
+ TPreferencesValues& /*aValues*/,
+ TBrCtlDefs::TBrCtlSettings /*aSettingType*/ )
+ {
+ // adaptive bookmarks setting changed
+ if ( iAdaptiveBookmarksCurrentSetting !=
+ ApiProvider().Preferences().AdaptiveBookmarks() )
+ {
+ iAdaptiveBookmarksCurrentSetting =
+ ApiProvider().Preferences().AdaptiveBookmarks();
+
+ if ( iAdaptiveBookmarksCurrentSetting !=
+ EWmlSettingsAdaptiveBookmarksOn )
+ {
+ if ( iPreferredHighlightUid == KFavouritesAdaptiveItemsFolderUid )
+ {
+ Container()->Listbox()->View()->SetCurrentItemIndex( 0 );
+ }
+
+ ExitAdaptiveBookmarks();
+
+ if ( iAdaptiveBookmarksCurrentSetting ==
+ EWmlSettingsAdaptiveBookmarksOff )
+ {
+ if ( TBrowserDialogs::ConfirmQueryYesNoL(
+ R_BROWSER_ADAPTIVE_BOOKMARKS_DELETE_ALL_ADAPTIVE_BOOKMARKS ) )
+ {
+ iRecentUrlStore.ClearData();
+ }
+ }
+ }
+ else
+ {
+ iInsertAdaptiveBookmarksFolder = ETrue;
+ iSaveBMOrder = ETrue;
+ }
+ }
+
+ TUint32 defaultAp = ApiProvider().Preferences().DefaultAccessPoint();
+
+ if ( defaultAp != iCurrentDefaultAp )
+ {
+ // Default AP changed. Set Start Page bookmark to that.
+ iCurrentDefaultAp = iStartPageApUid = defaultAp;
+ // Redraw view. Note that this does nothing if view is not activated.
+ RefreshL( EFalse );
+ }
+
+ iPreferencesChanged=ETrue;
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::CreateStartPageBookmarkL
+// ----------------------------------------------------------------------------
+//
+CFavouritesItem* CBrowserBookmarksView::CreateStartPageBookmarkL()
+ {
+LOG_ENTERFN("CBrowserBookmarksView::CreateStartPageBookmarkL");
+ // no HomePage if Type is Bookmarks
+ // or 'Always ask' feature is selected
+ TWmlSettingsHomePage pgtype = ApiProvider().Preferences().HomePageType();
+ TBool accessPointSelectionMode(
+ (ApiProvider().Preferences().AccessPointSelectionMode() == EAlwaysAsk) &&
+ ( EWmlSettingsHomePageAccessPoint == pgtype ) );
+LOG_WRITE_FORMAT(" pgType: %d", pgtype );
+LOG_WRITE_FORMAT(" selection mode: %d", accessPointSelectionMode );
+ if ( accessPointSelectionMode || (pgtype == EWmlSettingsHomePageBookmarks) )
+ {
+ return NULL;
+ }
+
+ CFavouritesItem* startPage = NULL;
+ TUint defaultAp = ApiProvider().Preferences().DefaultAccessPoint();
+LOG_WRITE_FORMAT(" defaultAp: %d", defaultAp );
+ if ( defaultAp != KWmlNoDefaultAccessPoint ) // There is an access point defined
+ {
+ // Get pointer to Start Page AP (or NULL if no such);
+ /*
+ Modified by MOG
+ --------------------- Performance Changes ----------------------
+ remove dependency from CommsModel becasue the cached list may not be pre
+ CApListItem* apItem =
+ ApiProvider().CommsModel().AccessPoints()->ItemForUid( defaultAp );
+ ---------------------- Performance Changes ----------------------
+ */
+ CApAccessPointItem* apItem = iApiProvider.Preferences().AllPreferencesL().iDefaultAPDetails;
+ if ( apItem )
+ {
+ const HBufC* defaultHP = apItem->ReadConstLongTextL( EApWapStartPage );
+ if ( defaultHP->Length() )
+ {
+ // Have AP and the AP has Start Page address. Hurray.
+ startPage = Model().Database().CreateStartPageItemL();
+ CleanupStack::PushL( startPage );
+ TBuf<KFavouritesMaxName> name;
+ apItem->ReadTextL(EApWapAccessPointName, name);
+ startPage->SetNameL( name );
+ startPage->SetUrlL( *defaultHP );
+ TFavouritesWapAp ap;
+ ap.SetApId( defaultAp );
+ startPage->SetWapAp( ap );
+ CleanupStack::Pop(); // startPage: owner is the caller.
+ }
+ }
+ }
+//LOG_LEAVEFN("CBrowserBookmarksView::CreateStartPageBookmarkL");
+ return startPage;
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::OfferKeyEventL
+// ----------------------------------------------------------------------------
+//
+TKeyResponse CBrowserBookmarksView::OfferKeyEventL(
+ const TKeyEvent& aKeyEvent, TEventCode aType )
+ {
+ // This method is called back from the container, to process the keypresses
+ // that cannot be handled by the container. Those are (currently) the
+ // left/right arrow keypresses, since the container does not know anything
+ // about what folder is open, which knowledge is required to process
+ // arrow presses. So we do that here.
+ // Any other key processing is still in the container.
+ TKeyResponse result = EKeyWasNotConsumed;
+ switch ( aKeyEvent.iCode )
+ {
+
+ case EKeyLeftArrow: // West
+ {
+ if ( ( CurrentFolder() != KFavouritesRootUid ) || ( iInAdaptiveBookmarksFolder ) )
+ {
+ // We are in some folder. Move between subfolders in the leftwards direction.
+ if ( !ApiProvider().IsEmbeddedModeOn() && !iManualItemMovingGoingOn )
+ {
+ OpenNextFolderL( /*aForward=*/EFalse );
+ }
+ result = EKeyWasConsumed;
+ }
+ break;
+ }
+
+ case EKeyRightArrow: // East
+ {
+ if ( ( CurrentFolder() != KFavouritesRootUid ) || ( iInAdaptiveBookmarksFolder ) )
+ {
+ // We are in some folder. Move between subfolders in the rightwards direction.
+ if ( !ApiProvider().IsEmbeddedModeOn() && !iManualItemMovingGoingOn )
+ {
+ OpenNextFolderL( /*aForward=*/ETrue );
+ }
+ result = EKeyWasConsumed;
+ }
+ break;
+ }
+
+ case EKeyRightUpArrow: // Northeast
+ case EStdKeyDevice11: // : Extra KeyEvent supports diagonal event simulator wedge
+ case EKeyRightDownArrow: // Southeast
+ case EStdKeyDevice12: // : Extra KeyEvent supports diagonal event simulator wedge
+ case EKeyLeftDownArrow: // Southwest
+ case EStdKeyDevice13: // : Extra KeyEvent supports diagonal event simulator wedge
+ case EKeyLeftUpArrow: // Northwest
+ case EStdKeyDevice10: // : Extra KeyEvent supports diagonal event simulator wedge
+ { // Here, "eat" all of the diagonals so they have no effect
+ result = EKeyWasConsumed;
+ break;
+ }
+
+ case EKeyBackspace:
+ case EKeyDelete:
+ {
+ TBrowserFavouritesSelectionState state =
+ iContainer->Listbox()->SelectionStateL();
+ const CFavouritesItem* item = Container()->Listbox()->CurrentItem();
+
+ if ( ( state.AnyDeletable() ) &&
+ // We can't delete adaptive bookmarks folder or seamless folders'
+ ( item ) &&
+ ( item->Uid() != KFavouritesAdaptiveItemsFolderUid ) &&
+ ( item->ContextId() == NULL )
+ )
+ {
+ // Clear key deletes the selection (or highlighted items).
+ if (iInAdaptiveBookmarksFolder)
+ {
+ HandleCommandL(EWmlCmdDelete);
+ result = EKeyWasConsumed;
+ }
+ else if (iManualItemMovingGoingOn)
+ // Manual Move in progress -- disable delete key
+ {
+ result = EKeyWasConsumed;
+ }
+ else
+ {
+ result =CBrowserFavouritesView::OfferKeyEventL(aKeyEvent,aType);
+ }
+
+ }
+ break;
+ }
+
+ case EKeyOK:
+ // OK key is handled through MSK handling
+ result = EKeyWasConsumed;
+ break;
+
+ case EKeyEnter:
+ {
+ if ( iManualItemMovingGoingOn )
+ {
+ MoveItemsL();
+ result = EKeyWasConsumed;
+ }
+ else
+ {
+ result = CBrowserFavouritesView::OfferKeyEventL(aKeyEvent,aType);
+ }
+ break;
+ }
+
+ default:
+ {
+ result =CBrowserFavouritesView::OfferKeyEventL(aKeyEvent,aType);
+ break;
+ }
+ }
+
+ return result;
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::OpenNextFolderL
+// ----------------------------------------------------------------------------
+//
+void CBrowserBookmarksView::OpenNextFolderL( TBool aForward )
+ {
+ if ( !Model().BeginL( EFalse, ETrue ) )
+ {
+ TInt nextFolder;
+ if ( iInAdaptiveBookmarksFolder )
+ {
+ // If in domain then forget about it
+ if (iDomainFolderName)
+ {
+ delete iDomainFolderName;
+ iDomainFolderName = NULL;
+ }
+
+ nextFolder = Model().NextFolderL( KFavouritesAdaptiveItemsFolderUid,
+ aForward );
+ if ( nextFolder != KFavouritesNullUid )
+ {
+ iInAdaptiveBookmarksFolder = EFalse;
+ }
+ }
+ else
+ {
+ nextFolder = Model().NextFolderL( CurrentFolder(), aForward );
+ }
+
+ if ( nextFolder != KFavouritesNullUid )
+ {
+ if ( nextFolder != KFavouritesAdaptiveItemsFolderUid )
+ {
+ SetEmptyTextL();
+ OpenFolderL( nextFolder );
+ }
+ }
+ Model().CommitL();
+ if ( nextFolder == KFavouritesAdaptiveItemsFolderUid )
+ {
+ iInAdaptiveBookmarksFolder=ETrue;
+ SetEmptyTextL();
+ SetRootFolderForAdaptiveBookmarks();
+ SetEmptyTextL();
+ RefreshL();
+ }
+ }
+ // Changing folder may require change in toolbar button state
+ UpdateToolbarButtonsState();
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserBookmarksView::UpdateNaviPaneL
+// ----------------------------------------------------------------------------
+//
+void CBrowserBookmarksView::UpdateNaviPaneL()
+ {
+ if (iInAdaptiveBookmarksFolder)
+ {
+ // In other folder, show "1/4" style text.
+ TInt folderIndex;
+ TInt folderCount;
+ TInt err;
+ err = Model().FolderInfoL( KFavouritesAdaptiveItemsFolderUid,
+ folderCount, folderIndex );
+ if ( !err )
+ {
+ TheContainer()->ShowFolderNaviPaneL( folderIndex, folderCount );
+ }
+ }
+ else
+ {
+ CBrowserFavouritesView::UpdateNaviPaneL();
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CBrowserBookmarksView::HandleBrowserLoadEventL
+// ---------------------------------------------------------------------------
+//
+void CBrowserBookmarksView::HandleBrowserLoadEventL(
+ TBrCtlDefs::TBrCtlLoadEvent aLoadEvent,
+ TUint /* aSize */,
+ TUint16 aTransactionId )
+ {
+LOG_ENTERFN("BookmarksView::HandleBrowserLoadEventL");
+ // only GotoPane is interested in LoadEvents!
+ if ( Container() )
+ {
+ if ( aLoadEvent != TBrCtlDefs::EEventThumbnailAvailable)
+ {
+ // If in bookmarks view, a background page load is in
+ // progress, just update the soft keys when page load is finished.
+ // (ie. RSK would be "Stop" while page loading but change to "Exit"
+ // when page load finished)
+ if ( aLoadEvent == TBrCtlDefs::EEventLoadFinished )
+ {
+ UpdateCbaL();
+ }
+ }
+ // save transaction id
+ if ( aLoadEvent == TBrCtlDefs::EEventUrlLoadingStart && iTrId == 0 )
+ {
+ iTrId = aTransactionId;
+ }
+ // first content chunk arrived
+ else if ( aLoadEvent == TBrCtlDefs::EEventNewUrlContentArrived &&
+ iTrId == aTransactionId )
+ {
+ if ( iEnteredURL )
+ {
+ delete iEnteredURL;
+ iEnteredURL = NULL;
+ BROWSER_LOG( ( _L("delete iEnteredUrl 5") ) );
+ }
+ iCursorPos = -1;
+ }
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// CBrowserBookmarksView::ClearAdaptiveBookmarksL
+// ---------------------------------------------------------------------------
+//
+void CBrowserBookmarksView::ClearAdaptiveBookmarksL()
+ {
+ iRecentUrlStore.ClearData();
+ Container()->Listbox()->View()->ClearSelection();
+ RefreshL();
+ }
+
+// ---------------------------------------------------------------------------
+// CBrowserBookmarksView::UpdateToolbarButtonsState
+// ---------------------------------------------------------------------------
+//
+void CBrowserBookmarksView::UpdateToolbarButtonsState()
+ {
+ if ( Container() && Container()->Listbox() )
+ {
+ const CFavouritesItem* item = Container()->Listbox()->CurrentItem();
+
+ // Button: EWmlCmdDelete
+ // Default case: un-dim the delete Button
+ // Case: Not an item so dim delete button
+ // Special Case: dim button for adaptive folder and
+ // seamless links
+ TBrowserFavouritesSelectionState state = iContainer->Listbox()->SelectionStateL();
+
+ TBool needToDimDeleteBtn = !item
+ || ( item->Uid() == KFavouritesAdaptiveItemsFolderUid )
+ || ( item->ContextId() != NULL )
+ || (!state.AnyDeletable());
+
+ Toolbar()->SetItemDimmed( EWmlCmdDelete, needToDimDeleteBtn, ETrue );
+ //set EWmlCmdAddBookmark dim in RecentlyVisitedUrl Folder
+ Toolbar()->SetItemDimmed( EWmlCmdAddBookmark, iInAdaptiveBookmarksFolder, ETrue);
+ if(iManualItemMovingGoingOn)
+ {
+ DimToolbarButtons(ETrue);
+ }
+ }
+ }
+
+void CBrowserBookmarksView::HandleForegroundEventL( TBool aForeground )
+ {
+ // make sure we call base class function before proceeding
+ CBrowserFavouritesView::HandleForegroundEventL(aForeground);
+ if ( aForeground )
+ {
+ if ( TheContainer()->GotoPaneActive() && TheContainer()->GotoPane()->PopupList()->IsPoppedUp() )
+ {
+ // The pop up messes the screen when changing layouts
+ // So make sure to redraw the pane while coming to foreground
+ TheContainer()->GotoPane()->PopupList()->HandleResourceChange(KEikDynamicLayoutVariantSwitch);
+ }
+ }
+ }
+// End of File