/*
* 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:
* Browser content view
*
*
*/
// INCLUDE FILES
#include <cdownloadmgruidownloadslist.h>
#include <cdownloadmgruidownloadmenu.h>
#include <FeatMgr.h>
#include <irmsgtypeuid.h>
#include <SenduiMtmUids.h>
#include <IrcMTM.h>
#include <EikMenuP.h>
#include <internetconnectionmanager.h>
#include <DocumentHandler.h>
#include <apmstd.h>
#include <aknnavi.h>
#include <EIKSPANE.H>
#include <aknnavide.h>
#include <bldvariant.hrh>
#include <LayoutMetaData.cdl.h> // For Layout_Meta_Data landscape/portrait status
#include <BrowserNG.rsg>
#include <StringLoader.h>
#include <aknviewappui.h>
#include <aknlists.h>
#include <akntitle.h>
#include <aknPopup.h>
#include <StringLoader.h>
#include <uri16.h>
#include <ApUtils.h>
#include <btmsgtypeuid.h>
#include "CommsModel.h"
#include <AknNaviLabel.h>
#include <FindItemMenu.h>
#include <EIKMENUB.H>
#include <avkon.hrh>
#include <AknInfoPopupNoteController.h>
#include <aknutils.h>
#include <AknStylusPopUpMenu.h>
#include <s32mem.h>
#include <Uri16.h>
#include "Browser.hrh"
#include "BrowserContentView.h"
#include "BrowserContentViewToolbar.h"
#include "BrowserContentViewContainer.h"
#include "BrowserContentViewZoomModeTimer.h"
#include "BrowserBookmarksView.h"
#include "CommonConstants.h"
#include "BrowserAppUi.h"
#include "BrowserGotoPane.h"
#include "Preferences.h"
#include "BrowserPreferences.h"
#include "Display.h"
#include <favouriteswapap.h>
#include "BrowserBookmarksModel.h"
#include "BrowserDialogs.h"
#include "BrowserUtil.h"
#include "BrowserBmOTABinSender.h"
#include <FINDITEMMENU.RSG>
#include "BrowserUiVariant.hrh"
#include "BrowserAdaptiveListPopup.h"
#include "BrowserApplication.h"
#include "logger.h"
#include <favouritesfile.h>
#include "BrowserWindowManager.h"
#include "BrowserWindow.h"
#include "BrowserPopupEngine.h"
#include <brctldialogsprovider.h>
#include <browserdialogsprovider.h>
#include <brctldefs.h>
#include <akntoolbar.h>
#ifdef RD_SCALABLE_UI_V2
#include <akntoolbarextension.h>
#endif
#include <akntouchpane.h>
#include "BrowserShortcutKeyMap.h"
_LIT( KSchemaIdentifier, "://" );
const TInt KSchemaIdentifierLength = 3;
// Time interval in milliseconds that status pane stays visible after download in fullscreen mode
const TInt KFullScreenStatusPaneTimeout( 3 * 1000000 ); // 3 seconds
const TInt KAutoFullScreenTimeout( 5 * 1000000 ); // 5 seconds
const TInt KAutoFullScreenIdleTimeout( 10 * 1000000 ); // 10 seconds
// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CBrowserContentView::NewLC
// -----------------------------------------------------------------------------
//
CBrowserContentView* CBrowserContentView::NewLC( MApiProvider& aApiProvider,
TRect& aRect )
{
CBrowserContentView* view =
new (ELeave) CBrowserContentView( aApiProvider );
CleanupStack::PushL(view);
view->ConstructL( aRect );
return view;
}
// -----------------------------------------------------------------------------
// CBrowserContentView::CBrowserContentView
// -----------------------------------------------------------------------------
//
// Scroll indicators may become deprecated
CBrowserContentView::CBrowserContentView( MApiProvider& aApiProvider ) :
CBrowserViewBase( aApiProvider ),
iZoomMode(EFalse),
iContentFullScreenMode( EFalse ),
iIsPluginFullScreenMode( EFalse),
iWasContentFullScreenMode( EFalse )
{
iFindItemIsInProgress = EFalse;
iWasInFeedsView = EFalse;
iPenEnabled = AknLayoutUtils::PenEnabled();
iFullScreenBeforeEditModeEntry = EFalse;
}
// -----------------------------------------------------------------------------
// CBrowserContentView::Id
// -----------------------------------------------------------------------------
//
TUid CBrowserContentView::Id() const
{
return KUidBrowserContentViewId;
}
// -----------------------------------------------------------------------------
// CBrowserContentView::~CBrowserContentView
// -----------------------------------------------------------------------------
//
CBrowserContentView::~CBrowserContentView()
{
delete iBrowserContentViewToolbar;
delete iNaviDecorator;
delete iBookmarksModel;
delete iContainer;
delete iEnteredURL;
delete iEnteredKeyword;
delete iTextZoomLevelArray;
delete iFontSizeArray;
delete iZoomModeTimer;
iNaviPane = NULL;
if ( iToolBarInfoNote )
{
iToolBarInfoNote->HideInfoPopupNote();
}
delete iToolBarInfoNote;
delete iStylusPopupMenu;
delete iPeriodic;
delete iAutoFSPeriodic;
delete iIdlePeriodic;
}
// -----------------------------------------------------------------------------
// CBrowserContentView::ConstructL
// -----------------------------------------------------------------------------
//
void CBrowserContentView::ConstructL( TRect& aRect )
{
BaseConstructL( R_BROWSER_CONTENT_VIEW );
ConstructMenuAndCbaEarlyL();
iContainer = CBrowserContentViewContainer::NewL( this, ApiProvider() );
iContainer->SetRect( aRect );
iContainer->GotoPane()->SetGPObserver(this);
iContainer->FindKeywordPane()->SetGPObserver(this);
iEnteredKeyword = NULL;
iEnteredURL = NULL;
// get the StatusPane pointer
if ( !iNaviPane )
{
CEikStatusPane *sp = ((CAknAppUi*)iEikonEnv->EikAppUi())->StatusPane();
// Fetch pointer to the default navi pane control
iNaviPane =
(CAknNavigationControlContainer*)sp->ControlL(
TUid::Uid(EEikStatusPaneUidNavi) );
}
// Array for zoom levels (..., 70%, 80%, 90%, 100%,... )
iTextZoomLevelArray = new( ELeave )CArrayFixFlat<TInt> ( 1 );
// Array for zoom font sizes ( 1, 2, ... )
iFontSizeArray = new( ELeave )CArrayFixFlat<TInt> ( 1 );
// Get the possibile zoom levels
GetTextZoomLevelsL();
iZoomModeTimer = CBrowserContentViewZoomModeTimer::NewL( this );
iToolBarInfoNote = CAknInfoPopupNoteController::NewL();
HBufC* str = StringLoader::LoadLC(R_BROWSER_TOOLTIP_TOOLBAR);
iToolBarInfoNote->SetTextL(*str);
CleanupStack::PopAndDestroy();
iBrowserContentViewToolbar = CBrowserContentViewToolbar::NewL(this);
if (iPenEnabled)
{
Toolbar()->SetToolbarObserver(this);
Toolbar()->SetFocusing(EFalse);
ShowToolbarOnViewActivation(ETrue);
}
iShortcutKeyMap = NULL;
iHistoryAtBeginning = EFalse;
iHistoryAtEnd = EFalse;
iZoomSliderVisible = EFalse;
iPeriodic = CPeriodic::NewL(CActive::EPriorityIdle);
iAutoFSPeriodic = CPeriodic::NewL(CActive::EPriorityIdle);
iIdlePeriodic = CPeriodic::NewL(CActive::EPriorityIdle);
}
// -----------------------------------------------------------------------------
// CBrowserContentView::HandleCommandL
// -----------------------------------------------------------------------------
//
void CBrowserContentView::HandleCommandL( TInt aCommand )
{
// Disabling FullScreen for non-touch devices, before processing some dialog-based shortcut and toolbar actions
if ( !iPenEnabled && iContentFullScreenMode && ( ( aCommand == EWmlCmdFindKeyword ) ||
( aCommand == EWmlCmdHistory ) ||
( aCommand == EWmlCmdGoToAddress ) ||
( aCommand == EWmlCmdShowShortcutKeymap ) ||
( aCommand == EWmlCmdShowMiniature )||
( aCommand == EWmlCmdShowToolBar)) )
{
iWasContentFullScreenMode = iContentFullScreenMode;
EnableFullScreenModeL( EFalse );
}
#ifdef RD_SCALABLE_UI_V2
// Close the extended toolbar whenever any item on it is selected
if ( iPenEnabled && Toolbar()->ToolbarExtension()->IsShown() )
{
Toolbar()->ToolbarExtension()->SetShown( EFalse );
StartAutoFullScreenTimer();
}
#endif
#ifdef __RSS_FEEDS
// Handle the subscribe to submenu.
TInt cmd = aCommand - TBrCtlDefs::ECommandIdBase;
if ((cmd >= TBrCtlDefs::ECommandIdSubscribeToBase) &&
(cmd < TBrCtlDefs::ECommandIdPluginBase))
{
HandleSubscribeToL(cmd);
return;
}
#endif // __RSS_FEEDS
if ( ( aCommand != EWmlCmdZoomSliderShow ) && ZoomSliderVisible() )
{
MakeZoomSliderVisibleL( EFalse );
}
switch ( aCommand )
{
case EWmlCmdFavourites:
{
ApiProvider().SetViewToBeActivatedIfNeededL(
KUidBrowserBookmarksViewId );
break;
}
case EWmlCmdHistory:
{
ViewHistoryL();
break;
}
case EWmlCmdHistoryBack:
{
ApiProvider().BrCtlInterface().HandleCommandL(
(TInt)TBrCtlDefs::ECommandHistoryNavigateBack +
(TInt)TBrCtlDefs::ECommandIdBase );
UpdateTitleL( iApiProvider );
break;
}
case EWmlCmdHistoryForward:
{
ApiProvider().BrCtlInterface().HandleCommandL(
(TInt)TBrCtlDefs::ECommandHistoryNavigateForward +
(TInt)TBrCtlDefs::ECommandIdBase );
UpdateTitleL( iApiProvider );
break;
}
// Set search pane active and then launch editor.
case EIsCmdSearchWeb:
{
iContainer->GotoPane()->SetSearchPaneActiveL();
LaunchGotoAddressEditorL();
break;
}
case EWmlCmdGoToAddress:
case EWmlCmdGoToAddressAndSearch:
{
iContainer->GotoPane()->SetGotoPaneActiveL();
LaunchGotoAddressEditorL();
break;
}
case EWmlCmdGotoPaneCancel:
{
CCoeEnv::Static()->AppUi()->RemoveFromStack( iContainer->GotoPane() );
// Cancel editing and sets Goto Pane text back.
if (iContainer->GotoPane()->PopupList() != NULL)
{
iContainer->GotoPane()->PopupList()->SetDirectoryModeL( ETrue );
iContainer->GotoPane()->PopupList()->HidePopupL();
}
iContainer->ShutDownGotoURLEditorL();
UpdateCbaL();
if (iPenEnabled)
{
Toolbar()->SetDimmed(EFalse);
Toolbar()->DrawNow();
iBrowserContentViewToolbar->UpdateButtonsStateL();
}
if ( ApiProvider().Preferences().FullScreen() == EWmlSettingsFullScreenFullScreen )
{
MakeCbaVisible( EFalse );
}
if (iPenEnabled)
{
StartAutoFullScreenTimer();
}
break;
}
case EWmlCmdGotoPaneGoTo:
{
HBufC* input = iContainer->GotoPane()->GetTextL();
CleanupStack::PushL( input );
if( iContainer->GotoPane()->GotoPaneActive() )
{
if ((input) && (input->CompareF(KWWWString)) && input->Length() )
{
if (iPenEnabled)
{
Toolbar()->SetDimmed(EFalse);
Toolbar()->DrawNow();
}
CCoeEnv::Static()->AppUi()->RemoveFromStack( iContainer->GotoPane() );
// Cancel editing and sets Goto Pane text back.
if (iContainer->GotoPane()->PopupList() != NULL)
{
iContainer->GotoPane()->PopupList()->SetDirectoryModeL( ETrue );
iContainer->GotoPane()->PopupList()->HidePopupL();
}
GotoUrlInGotoPaneL();
if ( ApiProvider().Preferences().FullScreen() == EWmlSettingsFullScreenFullScreen )
{
MakeCbaVisible( EFalse );
}
}
}
else
{
// Search Editor was active, So launch Search application with
// search parameters and cancel editing of search and goto.
if ( (input) && input->Length() )
{
if (iPenEnabled)
{
Toolbar()->SetDimmed(EFalse);
Toolbar()->DrawNow();
}
CCoeEnv::Static()->AppUi()->RemoveFromStack( iContainer->GotoPane() );
if ( iContainer->GotoPane() )
{
iContainer->ShutDownGotoURLEditorL();
LaunchSearchApplicationL( *input );
}
UpdateCbaL();
UpdateFullScreenL();
}
}
CleanupStack::PopAndDestroy( input );
if (iPenEnabled)
{
StartAutoFullScreenTimer();
}
break;
}
case EWmlCmdGotoPaneSelect:
{
// Cancel editing and sets Goto Pane text back.
if (iContainer->GotoPane()->PopupList() != NULL)
{
iContainer->GotoPane()->PopupList()->SetDirectoryModeL( ETrue );
iContainer->GotoPane()->PopupList()->HidePopupL();
}
// set LSK to GOTO now
UpdateCbaL();
break;
}
//adaptive popuplist
case EWmlCmdOpenFolder:
{
if (iContainer->GotoPane()->PopupList() != NULL)
{
iContainer->GotoPane()->PopupList()->SetDirectoryModeL( EFalse );
}
break;
}
case EAknSoftkeyCancel:
{
if ( isZoomMode() )
{
SaveCurrentZoomLevel(EFalse);
//reset the zooming to the original settings
SetZoomModeL( EFalse );
//Exit in zooming, enable the cursor
ApiProvider().BrCtlInterface().HandleCommandL(
(TInt)TBrCtlDefs::ECommandZoomSliderHide +
(TInt)TBrCtlDefs::ECommandIdBase );
}
if (iSynchRequestViewIsUp)
{
ApiProvider().BrCtlInterface().HandleCommandL( (TInt)TBrCtlDefs::ECommandCancelFetch + (TInt)TBrCtlDefs::ECommandIdBase );
}
else
{
ApiProvider().BrCtlInterface().HandleCommandL( (TInt)TBrCtlDefs::ECommandCancel + (TInt)TBrCtlDefs::ECommandIdBase );
}
break;
}
case EWmlCmdSaveAsBookmark:
{
AddNewBookmarkL(EFalse);
break;
}
// UI notifies the BrCtl which calls the DialogsProvider with a list of images
case EWmlCmdShowImages:
{
ApiProvider().BrCtlInterface().HandleCommandL(
(TInt)TBrCtlDefs::ECommandShowImages +
(TInt)TBrCtlDefs::ECommandIdBase );
break;
}
case EWmlCmdShowMiniature:
{
if (ApiProvider().Preferences().UiLocalFeatureSupported( KBrowserGraphicalPage ) &&
!ApiProvider().WindowMgr().CurrentWindow()->HasWMLContent(ETrue))
{
ApiProvider().BrCtlInterface().HandleCommandL(
(TInt)TBrCtlDefs::ECommandShowThumbnailView + (TInt)TBrCtlDefs::ECommandIdBase );
}
break;
}
// Download Manager UI Library shows a list of ongoing downloads
case EWmlCmdDownloads:
{
ApiProvider().BrCtlInterface().HandleCommandL(
(TInt)TBrCtlDefs::ECommandShowDownloads +
(TInt)TBrCtlDefs::ECommandIdBase );
break;
}
// Loads images on a page
case EWmlCmdLoadImages:
{
ApiProvider().BrCtlInterface().HandleCommandL(
(TInt)TBrCtlDefs::ECommandLoadImages +
(TInt)TBrCtlDefs::ECommandIdBase );
ApiProvider().WindowMgr().CurrentWindow()->SetImagesLoaded(ETrue);
break;
}
// UI notifies the BrCtl which calls the DialogsProvider to show the toolbar
case EWmlCmdShowToolBar:
{
if ( !PenEnabled() && iApiProvider.Preferences().ShowToolbarOnOff() &&
!iApiProvider.WindowMgr().CurrentWindow()->WMLMode() )
{
iToolBarInfoNote->ShowInfoPopupNote();
ApiProvider().BrCtlInterface().HandleCommandL(
(TInt)TBrCtlDefs::ECommandShowToolBar +
(TInt)TBrCtlDefs::ECommandIdBase );
}
break;
}
//zoom in and set the cursor's position for non-touch
case EWmlCmdZoomIn:
{
if ( ApiProvider().ContentDisplayed() && !ApiProvider().WindowMgr().CurrentWindow()->WMLMode() )
{
ApiProvider().BrCtlInterface().HandleCommandL(
(TInt)TBrCtlDefs::ECommandZoomIn +
(TInt)TBrCtlDefs::ECommandIdBase );
ZoomImagesInL();
}
break;
}
//zoom out and set the cursor's position for non-touch
case EWmlCmdZoomOut:
{
if ( ApiProvider().ContentDisplayed() && !ApiProvider().WindowMgr().CurrentWindow()->WMLMode() )
{
ApiProvider().BrCtlInterface().HandleCommandL(
(TInt)TBrCtlDefs::ECommandZoomOut +
(TInt)TBrCtlDefs::ECommandIdBase );
ZoomImagesOutL();
}
break;
}
/* Zoom Mode currently disabled
case EWmlCmdZoomMode:
{
// Disable the cursor: by using the zoom slider show cmd (temp)
ApiProvider().BrCtlInterface().HandleCommandL(
(TInt)TBrCtlDefs::ECommandZoomSliderShow +
(TInt)TBrCtlDefs::ECommandIdBase );
// Disable any activated objects (i.e. plugins, input boxes)
ApiProvider().BrCtlInterface().HandleCommandL(
(TInt)TBrCtlDefs::ECommandCancel +
(TInt)TBrCtlDefs::ECommandIdBase );
// Display softkeys if in full screen mode. i.e. go to normal screen
if ( !iPenEnabled && iContentFullScreenMode )
{
iWasContentFullScreenMode = iContentFullScreenMode;
EnableFullScreenModeL( EFalse );
}
// Enter zoom mode
ZoomModeImagesL();
break;
}
*/
case EWmlCmdZoomSliderShow:
{
// Toggle displaying the zoom slider, when the zoom button
// on toolbar is selected
MakeZoomSliderVisibleL( !iZoomSliderVisible );
break;
}
case EWmlCmdZoomSliderHide:
{
// Currently not used
MakeZoomSliderVisibleL( EFalse );
break;
}
// Find keyword commands
case EWmlCmdFindKeyword:
{
LaunchFindKeywordEditorL();
break;
}
case EWmlCmdFindKeywordPaneFind :
{
break;
}
case EWmlCmdFindKeywordPaneClose :
{
CCoeEnv::Static()->AppUi()->RemoveFromStack( iContainer->FindKeywordPane() );
// Cancel editing and sets Goto Pane text back.
iContainer->ShutDownFindKeywordEditorL();
UpdateCbaL();
if (iPenEnabled)
{
iBrowserContentViewToolbar->UpdateButtonsStateL();
}
ApiProvider().BrCtlInterface().HandleCommandL(
(TInt)TBrCtlDefs::ECommandClearFind +
(TInt)TBrCtlDefs::ECommandIdBase );
if ( ApiProvider().Preferences().FullScreen() == EWmlSettingsFullScreenFullScreen )
{
MakeCbaVisible( EFalse );
}
if (iPenEnabled)
{
StartAutoFullScreenTimer();
}
break;
}
case EWmlCmdFindNext :
{
// Find next keyword
FindKeywordL( NULL, ETrue );
break;
}
case EWmlCmdFindPrevious :
{
// Find previous keyword
FindKeywordL( NULL, EFalse );
break;
}
case EAknSoftkeySelect:
{
if( iHistoryViewIsUp )
{
if ( !iPenEnabled && iWasContentFullScreenMode && !iContentFullScreenMode )
{
EnableFullScreenModeL( ETrue );
iWasContentFullScreenMode = EFalse;
}
ApiProvider().BrCtlInterface().HandleCommandL(
(TInt)TBrCtlDefs::ECommandOpen + (TInt)TBrCtlDefs::ECommandIdBase );
}
// Save zoom factor and quit the zoom mode
if ( isZoomMode() )
{
SaveCurrentZoomLevel(ETrue);
// Disable the zoom mode
SetZoomModeL( EFalse );
// Return to full screen, if we were in full screen before
if ( !iPenEnabled && iWasContentFullScreenMode && !iContentFullScreenMode )
{
EnableFullScreenModeL( ETrue );
iWasContentFullScreenMode = EFalse;
}
// Exiting zoom mode, enable the cursor
ApiProvider().BrCtlInterface().HandleCommandL(
(TInt)TBrCtlDefs::ECommandZoomSliderHide +
(TInt)TBrCtlDefs::ECommandIdBase );
}
break;
}
case EAknSoftkeyOk:
{
if( iThumbnailViewIsUp )
{
if ( !iPenEnabled && iWasContentFullScreenMode && !iContentFullScreenMode )
{
EnableFullScreenModeL( ETrue );
iWasContentFullScreenMode = EFalse;
}
ApiProvider().BrCtlInterface().HandleCommandL(
(TInt)TBrCtlDefs::ECommandOpen + (TInt)TBrCtlDefs::ECommandIdBase );
}
break;
}
case EAknSoftkeyClose:
{
if( iWasInFeedsView)
{
// FeedsView library
}
else
{
if ( isZoomMode() )
{
SetZoomModeL( EFalse );
}
AppUi()->HandleCommandL( EWmlCmdCloseWindow );
}
break;
}
case EWmlCmdSendAddressViaUnifiedMessage:
{
SendAddressL( );
}
break;
case EWmlCmdBack:
{
if( iWasInFeedsView)
{
// FeedsView library
}
else if( iImageMapActive )
{
ApiProvider().BrCtlInterface().HandleCommandL(
(TInt)TBrCtlDefs::ECommandBack +
(TInt)TBrCtlDefs::ECommandIdBase );
}
else if( ApiProvider().BrCtlInterface().NavigationAvailable(
TBrCtlDefs::ENavigationBack ) )
{
AppUi()->HandleCommandL( aCommand );
}
else
{
AppUi()->HandleCommandL( EWmlCmdCloseWindow );
}
break;
}
case EWmlCmdOneStepBack:
{
if( ApiProvider().BrCtlInterface().NavigationAvailable(TBrCtlDefs::ENavigationBack ) )
{
AppUi()->HandleCommandL( aCommand );
}
break;
}
case EAknCmdHelp:
{
if ( HELP )
{
AppUi()->HandleCommandL( EAknCmdHelp );
}
break;
}
case EWmlCmdCancelFetch:
{
// give it to AppUi
AppUi()->HandleCommandL( aCommand );
break;
}
case EWmlCmdOpenLinkInNewWindow:
{
iApiProvider.BrCtlInterface().HandleCommandL(
(TInt)TBrCtlDefs::ECommandOpenNewWindow + (TInt)TBrCtlDefs::ECommandIdBase );
break;
}
case EWmlCmdOpenLink:
{
iApiProvider.BrCtlInterface().HandleCommandL(
(TInt)TBrCtlDefs::ECommandOpen + (TInt)TBrCtlDefs::ECommandIdBase );
break;
}
case EWmlCmdShowSubscribeList:
{
const RPointerArray<TBrCtlSubscribeTo>& subscribeToList = iApiProvider.BrCtlInterface().SubscribeToMenuItemsL();
TInt len(subscribeToList.Count());
if (len > 0)
{
CArrayFixFlat<TBrCtlSelectOptionData>* optList = new( ELeave ) CArrayFixFlat<TBrCtlSelectOptionData>(10);
CleanupStack::PushL( optList );
HBufC* title = StringLoader::LoadLC(R_BROWSER_SUBSCRIBE_LIST);
TInt i;
for(i = 0; i < len; i++)
{
if(subscribeToList[i]->Title().Length())
{
TBrCtlSelectOptionData t(subscribeToList[i]->Title(), EFalse, EFalse, EFalse);
optList->AppendL(t);
}
else
{
TBrCtlSelectOptionData t(subscribeToList[i]->Url(), EFalse, EFalse, EFalse);
optList->AppendL(t);
}
}
TBool ret(ApiProvider().DialogsProvider().DialogSelectOptionL( *title, ESelectTypeNone, *optList));
if( ret )
{
TInt i;
for (i = 0; i < optList->Count(); i++)
{
if ((*optList)[i].IsSelected())
{
HandleSubscribeToL(subscribeToList[i]->CommandID() - TBrCtlDefs::ECommandIdBase);
break;
}
}
}
optList->Reset();
CleanupStack::PopAndDestroy( 2 ); // optList, title
}
break;
}
case EWmlCmdHome:
if (ApiProvider().Preferences().HomePageType() == EWmlSettingsHomePageAddress )
{
HBufC* url = HBufC::NewLC( KMaxHomePgUrlLength );
TPtr ptr( url->Des() );
User::LeaveIfError(ApiProvider().Preferences().HomePageUrlL( ptr ));
ApiProvider().FetchL( ptr );
CleanupStack::PopAndDestroy(); // url
}
else
{
HBufC* url = ApiProvider().BrCtlInterface().PageInfoLC(TBrCtlDefs::EPageInfoUrl);
if ( url && url->Length() && TBrowserDialogs::ConfirmQueryYesNoL(R_BROWSER_QUERY_SET_AS_HOME_PAGE))
{
ApiProvider().Preferences().SetHomePageUrlL(url->Des());
ApiProvider().Preferences().SetHomePageTypeL( EWmlSettingsHomePageAddress );
}
CleanupStack::PopAndDestroy(); // url
}
break;
case EWmlCmdGo:
break;
case EWmlCmdConfigureShortcutKeymap:
{
ApiProvider().SetViewToBeActivatedIfNeededL( KUidBrowserSettingsViewId, KUidSettingsGotoShortcutsGroup.iUid );
break;
}
case EWmlCmdShowShortcutKeymap:
{
ShowKeymap();
break;
}
case EWmlCmdHideShortcutKeymap:
{
HideKeymap();
break;
}
case EWmlCmdOpenFeedsFolder:
// Launch into feeds view, telling it that we came from content view
ApiProvider().FeedsClientUtilities().ShowFolderViewL(KUidBrowserContentViewId);
break;
case EWmlCmdEnterFullScreenBrowsing:
{
if ( iPenEnabled )
{
EnableFullScreenModeL( ETrue );
}
else
{
if ( iContentFullScreenMode )
{
EnableFullScreenModeL( EFalse );
}
else
{
EnableFullScreenModeL( ETrue );
}
}
break;
}
case EWmlCmdExitFullScreenBrowsing:
EnableFullScreenModeL( EFalse );
break;
default:
{
// DO element and toolbar commands are passed to BrCtl via AppUi
AppUi()->HandleCommandL( aCommand );
break;
}
} // end of switch (aCommand)
// Enabling FullScreen for non-touch devices, after processing some dialog-based shortcut and toolbar actions
if ( !iPenEnabled && iWasContentFullScreenMode && !iContentFullScreenMode &&
( ( aCommand == EWmlCmdFindKeywordPaneClose ) ||
( aCommand == EWmlCmdHideShortcutKeymap ) ||
( aCommand == EWmlCmdGotoPaneGoTo ) ||
( aCommand == EWmlCmdGotoPaneCancel ) ||
( aCommand == EAknSoftkeyCancel ) ) )
{
EnableFullScreenModeL( ETrue );
iWasContentFullScreenMode = EFalse;
}
}
// -----------------------------------------------------------------------------
// CBrowserContentView::ViewHistoryL
// -----------------------------------------------------------------------------
//
void CBrowserContentView::ViewHistoryL()
{
ApiProvider().BrCtlInterface().HandleCommandL(
(TInt)TBrCtlDefs::ECommandShowHistory +
(TInt)TBrCtlDefs::ECommandIdBase );
}
// -----------------------------------------------------------------------------
// CBrowserContentView::DoActivateL
// -----------------------------------------------------------------------------
//
void CBrowserContentView::DoActivateL(
const TVwsViewId& /*aPrevViewId*/,
TUid /*aCustomMessageId*/,
const TDesC8& /*aCustomMessage*/ )
{
PERFLOG_LOCAL_INIT
PERFLOG_STOPWATCH_START
CBrowserAppUi* ui;
ui = STATIC_CAST( CBrowserAppUi*, AppUi() );
iPreviousViewID = ApiProvider().LastActiveViewId();
if ( ui->LastActiveViewId() == KUidBrowserNullViewId )
{
//No view has been yet set as startup view -> use bookmarks view
ui->SetLastActiveViewId ( KUidBrowserBookmarksViewId );
ui->SetViewToBeActivatedIfNeededL( ui->LastActiveViewId() );
ApiProvider().SetLastActiveViewId ( ui->LastActiveViewId() );
}
else
{
UpdateFullScreenL();
ApiProvider().SetLastActiveViewId(Id());
}
iContainer->ActivateL();
AppUi()->AddToViewStackL( *this, iContainer );
UpdateTitleL( ApiProvider() );
ApiProvider().BrCtlInterface().MakeVisible(ETrue);
ApiProvider().BrCtlInterface().HandleCommandL( (TInt)TBrCtlDefs::ECommandGainFocus +
(TInt)TBrCtlDefs::ECommandIdBase);
if( ui->Connection().Connected() &&
!ui->Preferences().HttpSecurityWarningsStatSupressed() )
{
// Update security indicators
if ( ui->SomeItemsNotSecure() )
{
ui->Display().UpdateSecureIndicatorL( EAknIndicatorStateOff );
}
else
{
ui->Display().UpdateSecureIndicatorL(
ui->LoadObserver().LoadStatus(
CBrowserLoadObserver::ELoadStatusSecurePage ) ?
EAknIndicatorStateOn : EAknIndicatorStateOff );
}
}
UpdateCbaL();
if(KeymapIsUp())
{
RedrawKeymap();
}
if (iPenEnabled)
{
StartAutoFullScreenTimer();
}
iContainer->SetRect(ClientRect());
PERFLOG_STOP_WRITE("ContentView::DoActivate")
}
// -----------------------------------------------------------------------------
// CBrowserContentView::UpdateFullScreenL
// -----------------------------------------------------------------------------
//
void CBrowserContentView::UpdateFullScreenL()
{
TVwsViewId activeViewId;
if ( AppUi()->GetActiveViewId( activeViewId ) == KErrNone )
{
if ( activeViewId.iViewUid == KUidBrowserContentViewId )
{
TBool sizeChangedCba = EFalse;
TBool sizeChangedSP = EFalse;
TBool resIdChanged = EFalse;
TInt resId = StatusPane()->CurrentLayoutResId();
if ( Layout_Meta_Data::IsLandscapeOrientation() )
{
resIdChanged = resId != R_AVKON_STATUS_PANE_LAYOUT_USUAL;
StatusPane()->SwitchLayoutL(R_AVKON_STATUS_PANE_LAYOUT_USUAL);
}
else //Portrait
{
resIdChanged = resId != R_AVKON_STATUS_PANE_LAYOUT_SMALL;
StatusPane()->SwitchLayoutL(R_AVKON_STATUS_PANE_LAYOUT_SMALL);
}
if ( iContentFullScreenMode )
{
sizeChangedCba = Cba()->IsVisible();
Cba()->MakeVisible( EFalse );
UpdateCbaL();
if (!ApiProvider().Fetching())
{
sizeChangedSP = StatusPane()->IsVisible();
StatusPane()->MakeVisible( EFalse );
}
else
{
sizeChangedSP = !StatusPane()->IsVisible();
ShowFsStatusPane(ETrue);
}
}
else
{
sizeChangedCba = !Cba()->IsVisible();
Cba()->MakeVisible( ETrue );
sizeChangedSP = !StatusPane()->IsVisible();
StatusPane()->MakeVisible( ETrue );
}
ApiProvider().Display().FSPaneOnL( );
ApiProvider().Display().SetGPRSIndicatorOnL();
UpdateTitleL(ApiProvider());
ApiProvider().Display().RestoreTitleL();
StatusPane()->ApplyCurrentSettingsL();
if ( resIdChanged || sizeChangedCba || sizeChangedSP )
{
iContainer->SetRect( ClientRect() );
}
}
}
}
// -----------------------------------------------------------------------------
// CBrowserContentView::SetFullScreenOffL
// -----------------------------------------------------------------------------
//
void CBrowserContentView::SetFullScreenOffL()
{
TVwsViewId activeViewId;
if ( AppUi()->GetActiveViewId( activeViewId ) == KErrNone )
{
if ( activeViewId.iViewUid == KUidBrowserContentViewId )
{
Cba()->MakeVisible( ETrue );
UpdateCbaL();
if ( Layout_Meta_Data::IsLandscapeOrientation() )
StatusPane()->SwitchLayoutL(R_AVKON_STATUS_PANE_LAYOUT_USUAL);
StatusPane()->ApplyCurrentSettingsL();
StatusPane()->MakeVisible( ETrue );
iContainer->SetRect( ClientRect() );
}
}
}
// -----------------------------------------------------------------------------
// CBrowserContentView::SetZoomLevelL
// -----------------------------------------------------------------------------
//
void CBrowserContentView::SetZoomLevelL()
{
// Get the current index of the array.
iCurrentZoomLevel = ApiProvider().BrCtlInterface().
BrowserSettingL(TBrCtlDefs::ESettingsCurrentZoomLevelIndex);
}
// -----------------------------------------------------------------------------
// CBrowserContentView::DoDeactivate
// -----------------------------------------------------------------------------
//
void CBrowserContentView::DoDeactivate()
{
if ( !ApiProvider().ExitInProgress() )
{
TBrCtlDefs::TBrCtlElementType focusedElementType =
ApiProvider().BrCtlInterface().FocusedElementType();
if (focusedElementType == TBrCtlDefs::EElementActivatedInputBox)
{
ApiProvider().BrCtlInterface().HandleCommandL( (TInt)TBrCtlDefs::ECommandAccept +
(TInt)TBrCtlDefs::ECommandIdBase );
}
TRAP_IGNORE( ApiProvider().Display().UpdateSecureIndicatorL(
EAknIndicatorStateOff ));
iContainer->SetFocus( EFalse );
TRAP_IGNORE( ApiProvider().BrCtlInterface().HandleCommandL(
(TInt)TBrCtlDefs::ECommandLoseFocus +
(TInt)TBrCtlDefs::ECommandIdBase ) );
ApiProvider().BrCtlInterface().MakeVisible(EFalse);
}
AppUi()->RemoveFromViewStack( *this, iContainer );
}
// ----------------------------------------------------------------------------
// CBrowserContentView::CommandSetResourceIdL
// ----------------------------------------------------------------------------
//
TInt CBrowserContentView::CommandSetResourceIdL()
{
LOG_ENTERFN("ContentView::CommandSetResourceIdL");
// default case for normal screen
TInt result( R_BROWSER_DEFAULT_BUTTONS );
// default case for full screen
if ( iContentFullScreenMode )
{
result = R_BROWSER_SOFTKEYS_EXIT_FULL_SCREEN;
}
if ( isZoomMode() )
{
return R_BROWSER_DEFAULT_BUTTONS_AT_ZOOM_MODE_ON;
}
if( KeymapIsUp() )
{
return R_BROWSER_SOFTKEYS_CONFIGURE_HIDE;
}
if( iHistoryViewIsUp )
{
return R_BROWSER_SOFTKEYS_SELECT_CANCEL_SELECT;
}
if( iPluginPlayerIsUp )
{
return R_BROWSER_SOFTKEYS_CANCEL;
}
if( iSmartTextViewIsUp )
{
return R_INPUT_ELEMENT_BUTTONS;
}
if( iThumbnailViewIsUp )
{
return R_BROWSER_DEFAULT_BUTTONS_AT_THUMBNAIL_VIEW_ON;
}
if( iImageMapActive )
{
return R_BROWSER_DEFAULT_BUTTONS;
}
if( iSynchRequestViewIsUp )
{
if ( !iContentFullScreenMode )
{
result = R_BROWSER_SOFTKEYS_CANCEL;
}
return result;
}
if( iContainer->GotoPane()->IsVisible() )
// when goto pane is up there is no focusable element or active fetching
// process in place
{
if( iContainer->GotoPane()->SearchPaneActive() )
{
result = R_BROWSER_BOOKMARKS_CBA_SEARCH_PANE_SEARCH_CANCEL;
}
else
{
//check wheter there is an active popuplist
if( (iContainer->GotoPane()->PopupList() != NULL) &&
( iContainer->GotoPane()->PopupList()->IsOpenDirToShow() ))
{
result = R_BROWSER_BOOKMARKS_CBA_GOTO_PANE_OPENDIR_CANCEL;
}
else if(iContainer->GotoPane()->PopupList() &&
iContainer->GotoPane()->PopupList()->IsPoppedUp() &&
!iPenEnabled)
{
// LSK Select is only for non-touch devices
result = R_BROWSER_BOOKMARKS_CBA_GOTO_PANE_SELECT_CANCEL;
}
else
{
result = R_BROWSER_BOOKMARKS_CBA_GOTO_PANE_GOTO_CANCEL;
}
}
}
else if ( iContainer->FindKeywordPane()->IsVisible() )
{
result = R_BROWSER_CBA_FIND_KEYWORD_PANE_OPTION_CLOSE;
}
else if ( ApiProvider().Fetching() )
{
if ( !iContentFullScreenMode )
{
// Enable Options menu during download can be done here
// otherwise use defualt Full Screen buttons
result = R_BROWSER_OPTIONS_MENU_DURING_DOWNLOAD;
}
}
else
{
TBrCtlDefs::TBrCtlElementType elementtype =
ApiProvider().BrCtlInterface().FocusedElementType();
if( elementtype == TBrCtlDefs::EElementActivatedObjectBox )
{
if ( !iContentFullScreenMode )
{
result = R_INPUT_ELEMENT_BUTTONS;
}
}
else if ( !ApiProvider().BrCtlInterface().NavigationAvailable(
TBrCtlDefs::ENavigationBack ) )
// at the beginning of the history list
{
if ( !iContentFullScreenMode )
{
// Options + Close
result = R_BROWSER_DEFAULT_BUTTONS_AT_BEGINNING_OF_HISTORY;
}
}
}
BROWSER_LOG( ( _L(" ContentView's buttons:%d"), result ) );
return result;
}
// -----------------------------------------------------------------------------
// CBrowserContentView::ProcessCommandL
// -----------------------------------------------------------------------------
//
void CBrowserContentView::ProcessCommandL(TInt aCommand)
{
CBrowserViewBase::ProcessCommandL( aCommand );
}
// -----------------------------------------------------------------------------
// CBrowserContentView::DynInitMenuPaneL
// -----------------------------------------------------------------------------
void CBrowserContentView::DynInitMenuPaneL( TInt aResourceId,
CEikMenuPane* aMenuPane )
{
LOG_ENTERFN("CBrowserContentView::DynInitMenuPaneL");
__ASSERT_DEBUG(aMenuPane, Util::Panic(Util::EUninitializedData));
if ( aResourceId == R_MENU_PANE )
{
// web feeds
#ifndef __RSS_FEEDS
aMenuPane->SetItemDimmed( EWmlCmdShowSubscribeList, ETrue );
#else
const RPointerArray<TBrCtlSubscribeTo>& items = ApiProvider().BrCtlInterface().SubscribeToMenuItemsL();
if ( items.Count() == 0 )
{
aMenuPane->SetItemDimmed( EWmlCmdShowSubscribeList, ETrue );
}
#endif // __RSS_FEEDS
// downloads
aMenuPane->SetItemDimmed( EWmlCmdDownloads,
!ApiProvider().BrCtlInterface().BrowserSettingL( TBrCtlDefs::ESettingsNumOfDownloads ) );
// If we have a touch device, check to see if the zoom slider is up, if so disable
if ( PenEnabled() && ZoomSliderVisible() )
{
MakeZoomSliderVisibleL( EFalse );
}
// find
aMenuPane->SetItemDimmed( EWmlCmdFindNext, ETrue );
aMenuPane->SetItemDimmed( EWmlCmdFindPrevious, ETrue );
/*
// help menu sub-menu - depending if Independent Application Update is available
if (BRDO_BROWSER_UPDATE_UI_FF)
{
aMenuPane->SetItemDimmed( EAknCmdHelp, ETrue );
}
else
{
aMenuPane->SetItemDimmed( EWmlCmdHelpMenu, ETrue );
}
*/
if ( iContainer->FindKeywordPane()->IsVisible() )
{
CEikMenuPaneItem::SData menuFindNext =
aMenuPane->ItemData( EWmlCmdFindNext );
CEikMenuPaneItem::SData menuFindPrevious =
aMenuPane->ItemData( EWmlCmdFindPrevious );
// Delete all menu items
aMenuPane->DeleteBetweenMenuItems( 0,
aMenuPane->NumberOfItemsInPane() - 1 );
aMenuPane->AddMenuItemL( menuFindNext );
aMenuPane->AddMenuItemL( menuFindPrevious );
aMenuPane->SetItemDimmed( EWmlCmdFindNext, EFalse );
aMenuPane->SetItemDimmed( EWmlCmdFindPrevious, EFalse );
return;
}
// wml option menu items
if ( ApiProvider().BrCtlInterface().WMLOptionMenuItemsL()->Count() < 1 )
{
// there isn't DO element, or only the first one with PREV exist
aMenuPane->SetItemDimmed( EWmlCmdServiceOptions, ETrue );
}
// find window
if (ApiProvider().WindowMgr().CurrentWindow()->WMLMode())
{
aMenuPane->SetItemDimmed(EWmlCmdFindKeyword, ETrue);
}
// shortcut key map
if (PenEnabled() || ApiProvider().IsEmbeddedModeOn())
{
aMenuPane->SetItemDimmed( EWmlCmdShowShortcutKeymap, ETrue);
}
// BrCtl adds menu items to UI options menu list
ApiProvider().BrCtlInterface().AddOptionMenuItemsL( *aMenuPane, aResourceId );
}
else if ( aResourceId == R_DO_ELEMENTS )
{
RPointerArray<TBrCtlWmlServiceOption>* wmlElements;
wmlElements = ApiProvider().BrCtlInterface().WMLOptionMenuItemsL();
for ( TInt i=0; i<wmlElements->Count(); i++ )
{
TBrCtlWmlServiceOption* option = (*wmlElements)[i];
if ( option != NULL)
{
CEikMenuPaneItem::SData item;
item.iText.Copy( option->Text() );
item.iCommandId = option->ElemID();
item.iFlags = 0;
item.iCascadeId = 0;
aMenuPane->InsertMenuItemL(item, 0);
}
}
}
else if ( aResourceId == R_GOTO_SUBMENU )
{
// back to page
aMenuPane->SetItemDimmed( EWmlCmdBackToPage, ETrue );
// bookmarks/webfeeds
if( ApiProvider().IsEmbeddedModeOn() )
{
aMenuPane->SetItemDimmed( EWmlCmdFavourites, ETrue );
aMenuPane->SetItemDimmed( EWmlCmdOpenFeedsFolder, ETrue );
}
// home
aMenuPane->SetItemDimmed( EWmlCmdLaunchHomePage, ApiProvider().IsLaunchHomePageDimmedL() );
//search
if ( ! ApiProvider().Preferences().SearchFeature() )
{
aMenuPane->SetItemDimmed( EIsCmdSearchWeb, ETrue );
}
}
else if ( aResourceId == R_PAGEACTIONS_SUBMENU )
{
// bookmark
if ( ApiProvider().IsEmbeddedModeOn() && CBrowserAppUi::Static()->IsEmbeddedInOperatorMenu() )
{
aMenuPane->SetItemDimmed( EWmlCmdSaveAsBookmark, ETrue );
}
HBufC *pageUrl = ApiProvider().BrCtlInterface().PageInfoLC( TBrCtlDefs::EPageInfoUrl );
if( ( pageUrl == NULL ) || ( pageUrl->Length() == 0 ) )
{
aMenuPane->SetItemDimmed( EWmlCmdSaveAsBookmark, ETrue );
}
CleanupStack::PopAndDestroy( pageUrl );
// send
aMenuPane->SetItemDimmed( EWmlCmdSendBookmarkViaUnifiedMessage, ETrue );
if (ApiProvider().IsEmbeddedModeOn())
{
aMenuPane->SetItemDimmed( EWmlCmdSendAddressViaUnifiedMessage, ETrue );
}
// set as home page
aMenuPane->SetItemDimmed( EWmlCmdSetAsHomePage, ETrue);
// pop-up blocking
if ( ApiProvider().IsEmbeddedModeOn() || ApiProvider().WindowMgr().CurrentWindow()->WMLMode())
{
aMenuPane->SetItemDimmed( EWmlCmdBlockPopups, ETrue );
aMenuPane->SetItemDimmed( EWmlCmdAllowPopups, ETrue );
}
else
{
aMenuPane->SetItemDimmed( EWmlCmdBlockPopups, EFalse );
aMenuPane->SetItemDimmed( EWmlCmdAllowPopups, EFalse );
if ( ApiProvider().Preferences().PopupBlocking())
{
HBufC* url = ApiProvider().WindowMgr().CurrentWindow()->BrCtlInterface().PageInfoLC( TBrCtlDefs::EPageInfoUrl );
TBool dimAllow = EFalse;
if( url )
{
// 'Allow Popups' needed if the current URL is not on the whitelist
TRAPD( errWhite, dimAllow = ApiProvider().PopupEngine().IsUrlOnWhiteListL( *url ););
// Error handling
if ( !errWhite )
{
aMenuPane->SetItemDimmed( EWmlCmdBlockPopups, !dimAllow );
aMenuPane->SetItemDimmed( EWmlCmdAllowPopups, dimAllow );
}
}
// else no url (strange case), so no popup specific menuitem
CleanupStack::PopAndDestroy( url );
}
else
{
//not shown any popupblocks related menu items when it's setting noblock
aMenuPane->SetItemDimmed( EWmlCmdBlockPopups, ETrue );
aMenuPane->SetItemDimmed( EWmlCmdAllowPopups, ETrue );
}
}
}
else if ( aResourceId == R_VIEW_SUBMENU )
{
// toolbar
if ( !PenEnabled() && iApiProvider.Preferences().ShowToolbarOnOff() )
{
aMenuPane->SetItemDimmed( EWmlCmdShowToolBar, ApiProvider().WindowMgr().CurrentWindow()->WMLMode() );
}
else
{
aMenuPane->SetItemDimmed( EWmlCmdShowToolBar, ETrue);
}
// disable fullscreen mode for touch only -- which has auto fullscreen now
if (iPenEnabled)
{
aMenuPane->SetItemDimmed(EWmlCmdEnterFullScreenBrowsing, ETrue);
}
// rotate
if (!ApiProvider().Preferences().RotateDisplay() )
{
aMenuPane->SetItemDimmed( EWmlCmdRotateDisplay, ETrue );
}
// page overview
if ( !ApiProvider().Preferences().UiLocalFeatureSupported( KBrowserGraphicalPage ) ||
ApiProvider().WindowMgr().CurrentWindow()->WMLMode() )
{
aMenuPane->SetItemDimmed( EWmlCmdShowMiniature, ETrue);
}
// show images
if( !ApiProvider().BrCtlInterface().ImageCountL() )
{
aMenuPane->SetItemDimmed( EWmlCmdShowImages, ETrue );
}
// load images
if (( ApiProvider().Preferences().AutoLoadContent() == EWmlSettingsAutoloadImagesNoFlash) ||
(ApiProvider().Preferences().AutoLoadContent() == EWmlSettingsAutoloadAll) ||
ApiProvider().WindowMgr().CurrentWindow()->HasLoadedImages() )
{
aMenuPane->SetItemDimmed( EWmlCmdLoadImages, ETrue );
}
// window
if ( !ApiProvider().Preferences().UiLocalFeatureSupported( KBrowserMultipleWindows ) ||
ApiProvider().IsEmbeddedModeOn() ||
ApiProvider().WindowMgr().WindowCount() < 2)
{
aMenuPane->SetItemDimmed( EWmlCmdSwitchWindow, ETrue );
}
}
}
// -----------------------------------------------------------------------------
// CBrowserContentView::CheckForEmptyWindowsMenuL
// Checks for the existence of Windows Submenu Items return true if no submenu items exist
// -----------------------------------------------------------------------------
//
TBool CBrowserContentView::CheckForEmptyWindowsMenuL(TWindowsMenuItemsDimCheck* aWindowMenuItems)
{
__ASSERT_DEBUG( (aWindowMenuItems != NULL), Util::Panic( Util::EUninitializedData ));
// 'OpenLinkInNewWindow is not available for 'non-anchor' elements or
// if current page has wml content.
//TBrCtlDefs::TBrCtlElementType elementtype =
// ApiProvider().BrCtlInterface().FocusedElementType();
// The commented part below enables the "Open link in new window" option.
// Currently the option is permanently dimmed
// UI change request AHUN-6U3NT4, S60 bug AHUN-6UYT6N
aWindowMenuItems->dimOpenInNewWin = ETrue; /*( (elementtype != TBrCtlDefs::EElementAnchor) ||
(ApiProvider().WindowMgr().CurrentWindow()->HasWMLContent(EFalse)) ); */
// Multiple Windows Supported
if ( ApiProvider().Preferences().UiLocalFeatureSupported(
KBrowserMultipleWindows ) )
{
TInt winCount = ApiProvider().WindowMgr().WindowCount();
// 'Close Window' & Switch Window needed if are 2+ open windows
if ( winCount > 1 )
{
aWindowMenuItems->dimCloseWin = EFalse;
// don't allow window switching if current window has wml. must close this window first
aWindowMenuItems->dimSwitchWin = ApiProvider().WindowMgr().CurrentWindow()->HasWMLContent(EFalse /*is any page wml?*/);//EFalse;
}
// Pop-up blocking is enabled
if ( ApiProvider().Preferences().PopupBlocking() )
{
//---------------------------------------------------------------------
// Popup Blocking Menu items
HBufC* url = ApiProvider().WindowMgr().CurrentWindow()->
BrCtlInterface().PageInfoLC( TBrCtlDefs::EPageInfoUrl );
if( url )
{
// 'Allow Popups' needed if the current URL is not on the whitelist
TRAPD( errWhite,
aWindowMenuItems->dimAllowPopups = ApiProvider().PopupEngine().IsUrlOnWhiteListL( *url );
);
// Error handling
if ( errWhite )
{
// Better to have the menu item than not
aWindowMenuItems->dimAllowPopups = aWindowMenuItems->dimBlockPopups = EFalse;
}
else
{
aWindowMenuItems->dimBlockPopups = !aWindowMenuItems->dimAllowPopups;
}
}
// else no url (strange case), so no popup specific menuitem
CleanupStack::PopAndDestroy( url );
}
//=========================================================================
}
return (aWindowMenuItems->dimOpenInNewWin &&
aWindowMenuItems->dimSwitchWin &&
aWindowMenuItems->dimCloseWin &&
aWindowMenuItems->dimAllowPopups &&
aWindowMenuItems->dimBlockPopups);
}
// -----------------------------------------------------------------------------
// CBrowserContentView::DimMultipleWindowsMenuItems
// Dims the items of the windows submenu according to aWindowMenuItems
// -----------------------------------------------------------------------------
//
void CBrowserContentView::DimMultipleWindowsMenuItems( CEikMenuPane& aMenuPane, TWindowsMenuItemsDimCheck aWindowMenuItems )
{
aMenuPane.SetItemDimmed( EWmlCmdOpenLinkInNewWindow, aWindowMenuItems.dimOpenInNewWin );
aMenuPane.SetItemDimmed( EWmlCmdSwitchWindow, aWindowMenuItems.dimSwitchWin );
aMenuPane.SetItemDimmed( EWmlCmdCloseWindow, aWindowMenuItems.dimCloseWin );
aMenuPane.SetItemDimmed( EWmlCmdAllowPopups, aWindowMenuItems.dimAllowPopups );
aMenuPane.SetItemDimmed( EWmlCmdBlockPopups, aWindowMenuItems.dimBlockPopups );
}
// -----------------------------------------------------------------------------
// CBrowserContentView::OptionListInit
// Callback - we should initialize the list of DO elements
// -----------------------------------------------------------------------------
//
void CBrowserContentView::OptionListInitL()
{
}
// -----------------------------------------------------------------------------
// CBrowserContentView::HandleGotoPaneEventL
// -----------------------------------------------------------------------------
//
void CBrowserContentView::HandleGotoPaneEventL(
CBrowserGotoPane* /*aGotoPane*/,
MGotoPaneObserver::TEvent aEvent )
{
switch ( aEvent )
{
case MGotoPaneObserver::EEventEnterKeyPressed:
{
if( !MenuBar()->MenuPane()->IsVisible() )
{
if (iContainer->GotoPane()->PopupList() != NULL)
{
if ( iContainer->GotoPane()->PopupList()->IsOpenDirToShow() )
{
HandleCommandL( EWmlCmdOpenFolder );
}
else
{
HandleCommandL( EWmlCmdGotoPaneGoTo );
}
}
}
break;
}
default:
{
break;
}
}
}
// -----------------------------------------------------------------------------
// CBrowserContentView::OnScreenPosition
// -----------------------------------------------------------------------------
//
TPoint CBrowserContentView::OnScreenPosition()
{
TRect rect = AppUi()->ApplicationRect();
TPoint point (rect.iTl);
if (iPenEnabled)
{
if (AppUi()->TouchPane())
{
TRect touchRect = AppUi()->TouchPane()->Rect();
if (touchRect.iTl == rect.iTl)
{
if (touchRect.Width() > touchRect.Height()) // Horizontal, on top
{
point = TPoint(rect.iTl.iX, touchRect.iBr.iY);
}
else // Vertical, on the left
{
point = TPoint(touchRect.iBr.iX, rect.iTl.iY);
}
}
}
}
return point;
}
// -----------------------------------------------------------------------------
// CBrowserContentView::GotoUrlInGotoPaneL
// -----------------------------------------------------------------------------
//
void CBrowserContentView::GotoUrlInGotoPaneL()
{
if ( iContainer->GotoPane() )
{
delete iEnteredURL;
iEnteredURL = NULL;
iEnteredURL = iContainer->GotoPane()->GetTextL(); // the url
if( iEnteredURL )
{
iContainer->ShutDownGotoURLEditorL();
TFavouritesWapAp accessPoint;
// if current ap exists then use it. other ways use default ap.
if( ApiProvider().Connection().CurrentAPId() )
{
TUint apId = ApiProvider().Connection().CurrentAPId();
apId = Util::WapIdFromIapIdL( ApiProvider(), apId );
accessPoint.SetApId( apId );
}
else
{
accessPoint.SetApId(
ApiProvider().Preferences().DefaultAccessPoint() );
}
UpdateCbaL();
UpdateFullScreenL();
ApiProvider().FetchL( iEnteredURL->Des(),
KNullDesC,
KNullDesC,
accessPoint,
CBrowserLoadObserver::ELoadUrlTypeOther );
}
else // no URL entered
{
iContainer->ShutDownGotoURLEditorL();
UpdateCbaL();
UpdateFullScreenL();
}
}
}
// -----------------------------------------------------------------------------
// CBrowserContentView::UpdateGotoPaneL
// -----------------------------------------------------------------------------
//
void CBrowserContentView::UpdateGotoPaneL()
{
// Reset goto pane content
if( AUTOCOMP ) //ask the feature manager
{
//2.1 does not put http:// there
iContainer->GotoPane()->SetTextL( KNullDesC );
}
else
{
//2.0 does need http://
iContainer->GotoPane()->SetTextL( KHttpString );
}
}
// -----------------------------------------------------------------------------
// CBrowserContentView::LaunchGotoAddressEditorL
// -----------------------------------------------------------------------------
//
void CBrowserContentView::LaunchGotoAddressEditorL()
{
// Cancel editing and sets Goto Pane text back.
if (iContainer->GotoPane()->PopupList() != NULL)
{
iContainer->GotoPane()->PopupList()->SetDirectoryModeL( ETrue );
iContainer->GotoPane()->PopupList()->HidePopupL();
}
if ( ApiProvider().Preferences().FullScreen() == EWmlSettingsFullScreenFullScreen )
{
MakeCbaVisible( ETrue );
}
CCoeEnv::Static()->AppUi()->RemoveFromStack( iContainer->GotoPane() );
CCoeEnv::Static()->AppUi()->AddToStackL( iContainer->GotoPane(), ECoeStackPriorityMenu );
iContainer->GotoPane()->MakeVisible( ETrue );
if ( iEnteredURL && iEnteredURL->Length() )
{
iContainer->GotoPane()->SetTextL(*iEnteredURL);
iContainer->GotoPane()->SelectAllL();
}
else
{
// nor iEnteredURL; use default name.
// set "http://www." per Browser UI spec
iContainer->GotoPane()->SetTextL(KWWWString );
}
iContainer->GotoPane()->SetFocus( ETrue );
UpdateCbaL();
if (iPenEnabled)
{
Toolbar()->SetDimmed(ETrue);
Toolbar()->DrawNow();
}
}
// -----------------------------------------------------------------------------
// CBrowserContentView::LaunchFindKeywordEditorL
// -----------------------------------------------------------------------------
//
void CBrowserContentView::LaunchFindKeywordEditorL()
{
// Cancel editing and sets Goto Pane text back.
if (iContainer->FindKeywordPane()->PopupList() != NULL)
{
iContainer->FindKeywordPane()->PopupList()->SetDirectoryModeL( ETrue );
iContainer->FindKeywordPane()->PopupList()->HidePopupL();
}
if ( ApiProvider().Preferences().FullScreen() == EWmlSettingsFullScreenFullScreen )
{
MakeCbaVisible( ETrue );
}
CCoeEnv::Static()->AppUi()->RemoveFromStack( iContainer->FindKeywordPane() );
CCoeEnv::Static()->AppUi()->AddToStackL( iContainer->FindKeywordPane(), ECoeStackPriorityMenu );
iContainer->FindKeywordPane()->MakeVisible( ETrue );
iContainer->FindKeywordPane()->SetFocus( ETrue );
UpdateCbaL();
if (iPenEnabled)
{
#ifdef RD_SCALABLE_UI_V2
Toolbar()->ToolbarExtension()->SetShown(EFalse);
#endif
iBrowserContentViewToolbar->UpdateButtonsStateL();
}
}
// -----------------------------------------------------------------------------
// CBrowserContentView::UpdateTitleL
// -----------------------------------------------------------------------------
//
void CBrowserContentView::UpdateTitleL( MApiProvider& aApiProvider )
{
HBufC* title = aApiProvider.BrCtlInterface().PageInfoLC(
TBrCtlDefs::EPageInfoTitle );
if ( title && title->Length() )
{
aApiProvider.Display().SetTitleL( title->Des() );
}
else
{
TInt offset = 0;
HBufC* titleUrl = aApiProvider.BrCtlInterface().PageInfoLC(
TBrCtlDefs::EPageInfoUrl );
if( titleUrl == NULL ) // is this really possible?
{
CleanupStack::PopAndDestroy( titleUrl );
titleUrl = KNullDesC().AllocLC();
}
offset = titleUrl->Find( KSchemaIdentifier );
if(offset != KErrNotFound )
{
titleUrl->Des().Delete(0,offset + KSchemaIdentifierLength);
}
aApiProvider.Display().SetTitleL( titleUrl->Des() );
CleanupStack::PopAndDestroy( ); // titleUrl
}
CleanupStack::PopAndDestroy(); // title
}
// -----------------------------------------------------------------------------
// CBrowserContentView::AddNewBookmarkL
// -----------------------------------------------------------------------------
//
void CBrowserContentView::AddNewBookmarkL( TBool aAsLastVisited, HBufC* aUrl )
{
TInt pop = 0;
HBufC* cardTitle = NULL;
TPtrC cardTitlePtr( KNullDesC );
// Make a bookmark model.
iBookmarksModel = CBrowserBookmarksModel::NewL(ApiProvider());
// Create a bookmark item.
CFavouritesItem* item = CFavouritesItem::NewLC();
HBufC* theUrl = NULL;
if (aUrl == NULL)
{
// Set URL.
theUrl = ApiProvider().BrCtlInterface().PageInfoLC( TBrCtlDefs::EPageInfoUrl );
if( !theUrl || !theUrl->Length() )
{
CleanupStack::PopAndDestroy( theUrl );
theUrl = KNullDesC().AllocLC();
}
pop++;
// Get the title
cardTitle = ApiProvider().BrCtlInterface().PageInfoLC(TBrCtlDefs::EPageInfoTitle );
pop++;
}
else
{
theUrl = aUrl;
}
if ( cardTitle )
{
cardTitle->Des().Trim();
cardTitlePtr.Set( cardTitle->Des() );
}
if ( cardTitlePtr.Length() )
{
// Current card has non-empty title, use that as bookmark name.
item->SetNameL( cardTitlePtr.Left(KFavouritesMaxName) );
}
else
{
// Get the URL
HBufC* url = theUrl->AllocLC();
pop++;
if ( url && url->Length() )
{
TUriParser16 urlParser;
urlParser.Parse(*url);
url->Des().SetLength( 0 );
url->Des().Append( urlParser.Extract( EUriHost) );
url->Des().Append( urlParser.Extract( EUriPath ) );
item->SetNameL( url->Left(KFavouritesMaxName) );
}
else
{
// No title, nor url; use default name.
iBookmarksModel->SetNameToDefaultL( *item );
}
}
// set url, username, password
Util::RetreiveUsernameAndPasswordFromUrlL( *theUrl, *item );
CleanupStack::PopAndDestroy(pop); // url, cardTitle, theUrl
item->SetParentFolder( KFavouritesRootUid );
// Set WAP AP.
TFavouritesWapAp ap; // default AP
item->SetWapAp( ap );
if ( aAsLastVisited )
{
iBookmarksModel->SetLastVisitedL( *item, EFalse,
CBrowserFavouritesModel::EAutoRename );
}
else
{
HBufC* prompt = StringLoader::LoadLC( R_WML_ENTER_BOOKMARK_NAME );
TBuf<KBrowserMaxPrompt+1> retString;
retString.Copy( item->Name() );
TBool queryName = ETrue;
while( queryName )
{
TInt result = TBrowserDialogs::DialogPromptReqL(
prompt->Des(),
&retString,
EFalse,
KFavouritesMaxBookmarkNameDefine );
if( result )
{
item->SetNameL(retString.Left(KFavouritesMaxName));
TInt err = iBookmarksModel->AddL(
*item,
ETrue,
CBrowserFavouritesModel::EDontRename );
if ( !err )
{
TBrowserDialogs::InfoNoteL(
R_BROWSER_OK_NOTE,
iBookmarksModel->StringResourceId
( *item, CBrowserFavouritesModel::ESaved ) );
queryName = EFalse;
AddBMUidToLastPlaceToCurrentListL( item->Uid() );
}
else if( KErrAlreadyExists == err )
{
TBrowserDialogs::InfoNoteL(
R_BROWSER_INFO_NOTE, R_WML_NAME_ALREADY_IN_USE );
}
else
{
TBrowserDialogs::ErrorNoteL(
iBookmarksModel->StringResourceId(
*item,
CBrowserFavouritesModel::ENotSaved ) );
}
}
else
queryName = EFalse;
}
CleanupStack::PopAndDestroy(); // prompt
}
CleanupStack::PopAndDestroy(); // item
delete iBookmarksModel;
iBookmarksModel = NULL;
}
// -----------------------------------------------------------------------------
// CBrowserContentView::AddBMUidToLastPlaceToCurrentListL
// -----------------------------------------------------------------------------
//
void CBrowserContentView::AddBMUidToLastPlaceToCurrentListL(const TInt aUid )
{
CArrayFixFlat<TInt>* orderArray = new (ELeave) CArrayFixFlat<TInt>(KGranularityHigh);
CleanupStack::PushL( orderArray );
CBrowserBookmarksOrder* currentOrder = CBrowserBookmarksOrder::NewLC();
if ( iBookmarksModel->Database().GetData( KFavouritesRootUid ,*currentOrder ) == KErrNone)
{
if ( currentOrder->GetBookMarksOrder().Count() > 0 )
{
orderArray->AppendL( &( currentOrder->GetBookMarksOrder()[0] ),
currentOrder->GetBookMarksOrder().Count() );
}
}
iBookmarksModel->AddUidToLastPlaceL(aUid, orderArray, currentOrder );
currentOrder->SetBookMarksOrderL( *orderArray );
iBookmarksModel->Database().SetData( KFavouritesRootUid ,*currentOrder );
CleanupStack::PopAndDestroy( 2 );// currentOrder, orderArray
}
// -----------------------------------------------------------------------------
// CBrowserContentView::SendAddressL
// -----------------------------------------------------------------------------
//
void CBrowserContentView::SendAddressL( )
{
HBufC* url = ApiProvider().BrCtlInterface().PageInfoLC( TBrCtlDefs::EPageInfoUrl );
if( url == NULL )
{
CleanupStack::PopAndDestroy( url ); // remove previous
url = KNullDesC().AllocLC();
}
#ifndef _BOOKMARK_SENT_ASCII
if( url->Length() <= KMaxUrlLenghtInOTA )
#endif // _BOOKMARK_SENT_ASCII
{
HBufC* title = ApiProvider().BrCtlInterface().PageInfoLC( TBrCtlDefs::EPageInfoTitle );
if( title == NULL )
{
CleanupStack::PopAndDestroy( title ); // remove previous
title = KNullDesC().AllocLC();
}
//CBrowserAppUi* ui = reinterpret_cast<CBrowserAppUi*>(AppUi());
MBmOTABinSender& sender = ApiProvider().BmOTABinSenderL();
sender.ResetAndDestroy();
sender.AppendL( url->Des(), title->Des() );
sender.SendAddressL( );
CleanupStack::PopAndDestroy( title ); // title
}
#ifndef _BOOKMARK_SENT_ASCII
else
{
#pragma message ( __FILE__ ": Length of bookmark addr cannot exceed 255bytes!")
_LIT( KErrMsg, "URL address of bookmark is too long. It cannot be sent.");
TBrowserDialogs::ErrorNoteL( KErrMsg );
}
#endif // _BOOKMARK_SENT_ASCII
CleanupStack::PopAndDestroy( url ); // url
}
// -----------------------------------------------------------------------------
// CBrowserContentView::UpdateOptionMenuItemLabelL
// -----------------------------------------------------------------------------
//
void CBrowserContentView::UpdateOptionMenuItemLabelL(CEikMenuPane* aMenuPane, const TInt aCommandId, const TInt aResourceId)
{
__ASSERT_DEBUG( (aMenuPane != NULL), Util::Panic( Util::EUninitializedData ));
HBufC* browserLabel = CCoeEnv::Static()->AllocReadResourceLC(aResourceId);
aMenuPane->SetItemTextL(aCommandId, *browserLabel);
CleanupStack::PopAndDestroy();
}
// -----------------------------------------------------------------------------
// CBrowserContentView::DoSearchL
// Do search for specified items in current page
// -----------------------------------------------------------------------------
//
void CBrowserContentView::DoSearchL(
CFindItemEngine::TFindItemSearchCase aSearchCase )
{
HBufC* findText = NULL;
findText = ApiProvider().BrCtlInterface().PageInfoLC(
TBrCtlDefs::EPageInfoContent );
if( findText == NULL )
{
CleanupStack::PopAndDestroy( findText );
return;
}
if( findText->Length() != 0 )
{
TPtr findTextDes = findText->Des();
for( int i = 0; i < findText->Length(); ++i )
{
if( (*findText)[i] == TUint16( 0x0a ) )
{
findTextDes[i] = TUint16( CEditableText::EParagraphDelimiter );
}
else if( (*findText)[i] == TUint16( CEditableText::ETabCharacter ) )
{
findTextDes[i] = TUint16( CEditableText::ESpace );
}
else if( (*findText)[i] == TUint16( CEditableText::ELineBreak ) )
{
findTextDes[i] = TUint16( CEditableText::EParagraphDelimiter );
}
}
}
SetFullScreenOffL();
CFindItemDialog* dialog = CFindItemDialog::NewL( *findText, aSearchCase );
dialog->ExecuteLD();
UpdateFullScreenL();
UpdateTitleL( ApiProvider() );
CleanupStack::PopAndDestroy( findText );
}
// -----------------------------------------------------------------------------
// CBrowserContentView::SetLastVisitedBookmarkL
// -----------------------------------------------------------------------------
//
void CBrowserContentView::SetLastVisitedBookmarkL()
{
AddNewBookmarkL( ETrue );
}
// -----------------------------------------------------------------------------
// CBrowserContentView::UpdateNaviPaneL
// -----------------------------------------------------------------------------
//
void CBrowserContentView::UpdateNaviPaneL( TDesC& aStatusMsg )
{
//Set text that will be shown in navipane
iStatusMsg.Des().Copy(aStatusMsg.Left(KStatusMessageMaxLength));//Might be longer than iStatusMsg
SetNavipaneViewL();
}
// -----------------------------------------------------------------------------
// CBrowserContentView::SetNavipaneViewL
// -----------------------------------------------------------------------------
//
void CBrowserContentView::SetNavipaneViewL()
{
TVwsViewId activeViewId;
if ( AppUi()->GetActiveViewId( activeViewId ) == KErrNone )
{
if ( (activeViewId.iViewUid == KUidBrowserContentViewId) )
{
if (!iNaviDecorator)
{
delete iNaviDecorator;
iNaviDecorator = NULL;
if( iNaviPane )
{
if (iStatusMsg.Length())
{
iNaviDecorator = iNaviPane->CreateNavigationLabelL(
iStatusMsg );
}
else
{
iNaviDecorator = iNaviPane->CreateNavigationLabelL(_L(""));
}
}
iNaviPane->PushL( *iNaviDecorator );
}
else
{
CAknNaviLabel* naviLabel = STATIC_CAST( CAknNaviLabel*,
iNaviDecorator->DecoratedControl());
naviLabel->SetTextL(iStatusMsg);
// make sure at top and redraw
iNaviPane->PushL( *iNaviDecorator );
}
iNaviDecorator->MakeScrollButtonVisible(ETrue);
}
}
}
// -----------------------------------------------------------------------------
// CBrowserContentView::FindItemIsInProgress
// -----------------------------------------------------------------------------
//
TBool CBrowserContentView::FindItemIsInProgress()
{
return iFindItemIsInProgress;
}
// ---------------------------------------------------------------------------
// CBrowserContentView::HandleStatusPaneSizeChange
// ---------------------------------------------------------------------------
//
void CBrowserContentView::HandleStatusPaneSizeChange()
{
iContainer->SetRect(ClientRect());
}
// ---------------------------------------------------------------------------
// CBrowserContentView::StateChanged
// ---------------------------------------------------------------------------
//
void CBrowserContentView::StateChanged(
TBrCtlDefs::TBrCtlState aState,
TInt aValue )
{
LOG_ENTERFN(" CBrowserContentView::StateChanged" );
LOG_WRITE_FORMAT(" state: %d", aState );
LOG_WRITE_FORMAT(" value: %d", aValue );
switch(aState)
{
case TBrCtlDefs::EStateImageMapView:
{
iImageMapActive = (TBool) aValue;
TRAP_IGNORE( UpdateCbaL() );
break;
}
case TBrCtlDefs::EStateHistoryView:
{
iHistoryViewIsUp = (TBool) aValue;
iHistoryAtBeginning = EFalse;
iHistoryAtEnd = EFalse;
if ( iPenEnabled )
{
TRAP_IGNORE( iBrowserContentViewToolbar->UpdateButtonsStateL() );
}
TRAP_IGNORE( UpdateCbaL() );
TRAP_IGNORE( UpdateTitleL( ApiProvider() ) );
if (iPenEnabled)
{
StartAutoFullScreenTimer();
}
break;
}
case TBrCtlDefs::EStateThumbnailView:
{
iThumbnailViewIsUp = (TBool) aValue;
if ( iPenEnabled )
{
TRAP_IGNORE( iBrowserContentViewToolbar->UpdateButtonsStateL() );
}
TRAP_IGNORE( UpdateCbaL() );
TRAP_IGNORE( UpdateTitleL( ApiProvider() ) );
if (iPenEnabled)
{
StartAutoFullScreenTimer();
}
break;
}
case TBrCtlDefs::EStatePluginPlayer:
{
iPluginPlayerIsUp = (TBool) aValue;
TRAP_IGNORE( UpdateCbaL() );
TRAP_IGNORE( UpdateTitleL( ApiProvider() ) );
break;
}
case TBrCtlDefs::EStateSmartTextView:
{
iSmartTextViewIsUp = (TBool) aValue;
TRAP_IGNORE( UpdateCbaL() );
TRAP_IGNORE( UpdateTitleL( ApiProvider() ) );
break;
}
case TBrCtlDefs::EStateToolBarMode:
{
if(!aValue)
{
TRAP_IGNORE( UpdateCbaL() );
}
break;
}
case TBrCtlDefs::EStateScriptLog:
{
TRAP_IGNORE( ApiProvider().Preferences().SetScriptLogL( aValue ) );
break;
}
case TBrCtlDefs::EStateZoomSliderMode:
{
if ( aValue )
{
iZoomSliderVisible = ETrue;
}
else
{
iZoomSliderVisible = EFalse;
if (iPenEnabled)
{
StartAutoFullScreenTimer();
}
}
// Inform Toolbar of this fact
if ( iPenEnabled )
{
TRAP_IGNORE( iBrowserContentViewToolbar->UpdateButtonsStateL() );
}
break;
}
case TBrCtlDefs::EStateFullscreenBrowsing:
{
if (!iPenEnabled && IsEditMode())
{
if (!aValue)
{ // exit fullscreen so remember what to go back to after edit mode is exited
iFullScreenBeforeEditModeEntry = iContentFullScreenMode;
TRAP_IGNORE( EnableFullScreenModeL( EFalse ) );
}
else if (aValue && iFullScreenBeforeEditModeEntry)
{
TRAP_IGNORE( EnableFullScreenModeL( ETrue ) );
}
}
else if (!aValue)
{
TRAP_IGNORE( EnableFullScreenModeL( EFalse ) );
}
break;
}
case TBrCtlDefs::EStateHistoryBeginning:
{
if(aValue)
{
iHistoryAtBeginning = ETrue;
}
else
{
iHistoryAtBeginning = EFalse;
}
if (iPenEnabled)
{
TRAP_IGNORE( iBrowserContentViewToolbar->UpdateButtonsStateL() );
}
TRAP_IGNORE( UpdateTitleL( ApiProvider() ) );
break;
}
case TBrCtlDefs::EStateHistoryEnd:
{
if(aValue)
{
iHistoryAtEnd = ETrue;
}
else
{
iHistoryAtEnd = EFalse;
}
if (iPenEnabled)
{
TRAP_IGNORE( iBrowserContentViewToolbar->UpdateButtonsStateL() );
}
TRAP_IGNORE( UpdateTitleL( ApiProvider() ) );
break;
}
case TBrCtlDefs::EStateSynchRequestMode:
{
iSynchRequestViewIsUp = (TBool) aValue;
if (iPenEnabled)
{
TRAP_IGNORE( iBrowserContentViewToolbar->UpdateButtonsStateL() );
}
TRAP_IGNORE( UpdateCbaL() );
TRAP_IGNORE( UpdateTitleL( ApiProvider() ) );
break;
}
case TBrCtlDefs::EStatePluginFullScreen:
HandlePluginFullScreen((TBool) aValue);
break;
default:
break;
}
ApiProvider().WindowMgr().SetCurrentWindowViewState(aState, aValue);
if (iPenEnabled && ApiProvider().WindowMgr().CurrentWindow()->WMLMode())
{
EnableFullScreenModeL( EFalse );
}
}
// -------------------------------------------------------------------
// CBrowserContentView::HandleCommandL
// ---------------------------------------------------------------------------
//
void CBrowserContentView::HandleCommandL(
TBrCtlDefs::TBrCtlClientCommands aCommand,
const CArrayFix<TPtrC>& /*aAttributesNames*/,
const CArrayFix<TPtrC>& aAttributeValues)
{
switch(aCommand)
{
case TBrCtlDefs::EClientCommandLaunchFindKeyword:
{
// Find Keyword not initiated from options menu so don't set menupane to visible.
LaunchFindKeywordEditorL();
MenuBar()->MenuPane()->MakeVisible(EFalse);
break;
}
case TBrCtlDefs::EClientCommandGotoWebAddress:
{
HandleCommandL(EWmlCmdGoToAddress);
break;
}
case TBrCtlDefs::EClientCommandSaveAsBookmark:
{
HandleCommandL(EWmlCmdSaveAsBookmark);
break;
}
case TBrCtlDefs::EClientCommandManageBookmarks:
{
HandleCommandL(EWmlCmdFavourites);
break;
}
case TBrCtlDefs::EClientCommandZoomIn:
{
ZoomImagesInL();
break;
}
case TBrCtlDefs::EClientCommandZoomOut:
{
ZoomImagesOutL();
break;
}
case TBrCtlDefs::EClientCommandZoomMode:
{
ZoomModeImagesL();
break;
}
case TBrCtlDefs::EClientCommandGoToHompage:
{
HandleCommandL(EWmlCmdLaunchHomePage);
break;
}
case TBrCtlDefs::EClientCommandRotateScreen:
{
HandleCommandL(EWmlCmdRotateDisplay);
break;
}
case TBrCtlDefs::EClientCommandSavePage:
{
HandleCommandL(EWmlCmdSavePage);
break;
}
case TBrCtlDefs::EClientCommandSwitchWindow:
{
HandleCommandL(EWmlCmdSwitchWindow);
break;
}
case TBrCtlDefs::EClientCommandShowHelp:
{
HandleCommandL(EAknCmdHelp);
break;
}
case TBrCtlDefs::EClientCommandToolbarConfigure:
{
// open settings view in toolbar group
AppUi()->HandleCommandL( EWmlCmdPreferencesToolbar );
break;
}
case TBrCtlDefs::EClientCommandToolbarShowKeymap:
{
ShowKeymap();
break;
}
case TBrCtlDefs::EClientCommandSubscribeToFeeds:
{
#ifdef __RSS_FEEDS
const TPtrC16 name(aAttributeValues.At(0));
const TPtrC16 url(aAttributeValues.At(1));
ApiProvider().SetLastActiveViewId( KUidBrowserFeedsFolderViewId );
ApiProvider().FeedsClientUtilities().SubscribeToL( name, url );
// switch back to FeedsView, so change layout
SetFullScreenOffL();
#endif
break;
}
case TBrCtlDefs::EClientCommandShowContextMenu:
{
// Get ElementType
const TPtrC elTypePtr(aAttributeValues.At(0));
TLex lex(elTypePtr);
TInt elType;
TInt resourceId = 0;
if (lex.Val(elType) == KErrNone)
{
switch (elType)
{
case TBrCtlDefs::EElementNone:
resourceId = R_BROWSER_EMPTY_SPACE_STYLUS_POPUP_MENU;
break;
case TBrCtlDefs::EElementAnchor:
case TBrCtlDefs::EElementTelAnchor:
case TBrCtlDefs::EElementMailtoAnchor:
resourceId = R_BROWSER_ANCHOR_STYLUS_POPUP_MENU;
break;
case TBrCtlDefs::EElementSmartLinkTel:
resourceId = R_BROWSER_PHONE_NUMBER_STYLUS_POPUP_MENU;
break;
case TBrCtlDefs::EElementSmartLinkEmail:
resourceId = R_BROWSER_EMAIL_ADDRESS_STYLUS_POPUP_MENU;
break;
case TBrCtlDefs::EElementImageBox:
resourceId = R_BROWSER_IMAGE_STYLUS_POPUP_MENU;
break;
case TBrCtlDefs::EElementBrokenImage:
if (ApiProvider().Preferences().AutoLoadContent() == EWmlSettingsAutoloadText)
{
if (ApiProvider().FlashPresent())
{
resourceId = R_BROWSER_IMAGE_PLACEHOLDER_STYLUS_POPUP_MENU_WITH_FLASH;
}
else
{
resourceId = R_BROWSER_IMAGE_PLACEHOLDER_STYLUS_POPUP_MENU_NO_FLASH;
}
}
break;
case TBrCtlDefs::EElementAreaBox:
resourceId = R_BROWSER_IMAGEMAP_STYLUS_POPUP_MENU;
break;
default:
break;
}
if (resourceId != 0)
{
TPoint point;
// Get point X
const TPtrC xPtr(aAttributeValues.At(1));
lex.Assign(xPtr);
lex.Val(point.iX);
// Get point Y
const TPtrC yPtr(aAttributeValues.At(2));
lex.Assign(yPtr);
lex.Val(point.iY);
delete iStylusPopupMenu;
iStylusPopupMenu = NULL;
iStylusPopupMenu = CAknStylusPopUpMenu::NewL( this, point);
TResourceReader rr;
CCoeEnv::Static()->CreateResourceReaderLC(rr, resourceId);
iStylusPopupMenu->ConstructFromResourceL( rr );
CleanupStack::PopAndDestroy(); // resource reader
iStylusPopupMenu->SetPosition( point);
iStylusPopupMenu->ShowMenu();
}
}
break;
}
case TBrCtlDefs::EClientCommandToolbarSettings:
{
// Launch Settings View
HandleCommandL(EWmlCmdPreferences);
break;
}
case TBrCtlDefs::EClientCommandFullScreen:
{
HandleCommandL(EWmlCmdEnterFullScreenBrowsing);
break;
}
default:
break;
}
}
// -----------------------------------------------------------------------------
// CBrowserContentView::HandleSubscribeToL
// Handles a selection from the subscribe to sub-menu.
// -----------------------------------------------------------------------------
//
void CBrowserContentView::HandleSubscribeToL( TInt aCommand )
{
#ifndef __RSS_FEEDS
(void) aCommand;
#else // __RSS_FEEDS
TInt index;
// Get the corresponding feed info.
const RPointerArray<TBrCtlSubscribeTo>& items = ApiProvider().
BrCtlInterface().SubscribeToMenuItemsL();
index = aCommand - TBrCtlDefs::ECommandIdSubscribeToBase;
if ((index >= 0) && (index < items.Count()))
{
const TPtrC16 name(items[index]->Title());
const TPtrC16 url(items[index]->Url());
ApiProvider().SetLastActiveViewId( KUidBrowserFeedsFolderViewId );
ApiProvider().FeedsClientUtilities().SubscribeToL( name, url );
// switch back to FeedsView, so change layout
SetFullScreenOffL();
}
#endif // __RSS_FEEDS
}
// -----------------------------------------------------------------------------
// CBrowserContentView::HandleSubscribeToUrlL
// Handles subscribing to a feed from a ur
// -----------------------------------------------------------------------------
//
void CBrowserContentView::HandleSubscribeToWithUrlL( TPtrC aUrl )
{
#ifndef __RSS_FEEDS
(void) aUrl;
#else // __RSS_FEEDS
ApiProvider().SetLastActiveViewId( KUidBrowserFeedsFolderViewId );
//Get the 'Title' info by comparing aUrl with the url's populated in array 'items'
const RPointerArray<TBrCtlSubscribeTo>& items = ApiProvider().BrCtlInterface().SubscribeToMenuItemsL();
TInt index = 0;
TInt itemCount = items.Count();
while (itemCount != 0 && index < itemCount)
{
if (!(aUrl.Compare(items[index]->Url())))
{
break;
}
else
{
index++;
}
}
if (itemCount == 0 || index >= itemCount )
{
ApiProvider().FeedsClientUtilities().SubscribeToL( KNullDesC, aUrl );
}
else
{
const TPtrC16 name(items[index]->Title());
ApiProvider().FeedsClientUtilities().SubscribeToL(name , aUrl );
}
#endif // __RSS_FEEDS
}
// ---------------------------------------------------------------------------
// CBrowserContentView::DynInitToolbarL
// ---------------------------------------------------------------------------
//
void CBrowserContentView::DynInitToolbarL( TInt /*aResourceId*/, CAknToolbar* /*aToolbar*/ )
{
// If we have a touch device, check to see if the zoom slider is up,
// if displayed, close it, so the extended toolbar shows without the
// zoomslider displaying on top of it.
if ( PenEnabled() && ZoomSliderVisible() )
{
MakeZoomSliderVisibleL( EFalse );
}
if ( iPenEnabled )
{
iBrowserContentViewToolbar->UpdateButtonsStateL() ;
}
}
// ---------------------------------------------------------------------------
// CBrowserContentView::WindowEventHandlerL
// ---------------------------------------------------------------------------
//
void CBrowserContentView::WindowEventHandlerL( TWindowEvent /*aEvent*/, TInt aWindowId )
{
if ( aWindowId == ApiProvider().WindowMgr().CurrentWindow()->WindowId() )
{
if ( iPenEnabled )
{
iBrowserContentViewToolbar->UpdateButtonsStateL();
}
}
}
// ---------------------------------------------------------------------------
// CBrowserContentView::IsHistoryViewUp
// ---------------------------------------------------------------------------
//
TBool CBrowserContentView::IsHistoryViewUp()
{
return iHistoryViewIsUp;
}
// ---------------------------------------------------------------------------
// CBrowserContentView::IsHistoryAtBeginning
// ---------------------------------------------------------------------------
//
TBool CBrowserContentView::IsHistoryAtBeginning()
{
return iHistoryAtBeginning;
}
// ---------------------------------------------------------------------------
// CBrowserContentView::IsHistoryAtEnd
// ---------------------------------------------------------------------------
//
TBool CBrowserContentView::IsHistoryAtEnd()
{
return iHistoryAtEnd;
}
// ---------------------------------------------------------------------------
// CBrowserContentView::FindKeywordL
// ---------------------------------------------------------------------------
//
void CBrowserContentView::FindKeywordL( HBufC* aFindString, TBool aFindDirection )
{
TInt findResponse = 0;
if ( aFindString )
{
// Find string
delete iEnteredKeyword;
iEnteredKeyword = NULL;
iEnteredKeyword = aFindString;
findResponse = ApiProvider().BrCtlInterface().FindKeyword( iEnteredKeyword->Des() );
}
else
{
// Search next/previous
findResponse = ApiProvider().BrCtlInterface().FindKeywordAgain( aFindDirection );
}
HBufC* toolTipText = NULL;
switch ( findResponse )
{
case TBrCtlDefs::EFindNoMatches:
toolTipText = StringLoader::LoadLC( R_QTN_BROWSER_KEYWORD_FIND_NO_MATCHES );
break;
case TBrCtlDefs::EFindWrapAround:
toolTipText = StringLoader::LoadLC( R_QTN_BROWSER_KEYWORD_FIND_WRAPAROUND );
break;
case TBrCtlDefs::EFindAllMatches:
toolTipText = StringLoader::LoadLC( R_QTN_BROWSER_KEYWORD_FIND_ALL_CONTENT_SEARCHED );
break;
}
// Show the result of the search.
if ( toolTipText )
{
ApiProvider().DialogsProvider().ShowTooltipL( *toolTipText );
CleanupStack::PopAndDestroy( toolTipText );
}
}
// ---------------------------------------------------------------------------
// CBrowserContentView::HandleClientRectChange
// ---------------------------------------------------------------------------
//
void CBrowserContentView::HandleClientRectChange()
{
if( iContainer )
{
iContainer->HandleResourceChange(KEikDynamicLayoutVariantSwitch);
UpdateFullScreenL();
if(KeymapIsUp())
{
RedrawKeymap();
}
}
}
// ---------------------------------------------------------------------------
// CBrowserContentView::SetZoomModeL
// ---------------------------------------------------------------------------
//
void CBrowserContentView::SetZoomModeL( TBool aZoomMode )
{
// if ( !ApiProvider().Fetching() )
if (ApiProvider().ContentDisplayed())
{
iZoomMode = aZoomMode;
TRAP_IGNORE( UpdateCbaL() );
if ( aZoomMode )
{
// Show the current zoom level in tooltip
SetZoomLevelTitleTextL( R_BROWSER_ZOOM_LEVEL);
//MakeZoomSliderVisibleL( ETrue );
}
}
}
// ---------------------------------------------------------------------------
// CBrowserContentView::MakeZoomSliderVisibleL
// Informs Browser Control if the Zoom Slider should be visible or not.
// ---------------------------------------------------------------------------
//
void CBrowserContentView::MakeZoomSliderVisibleL( TBool aVisible )
{
if ( aVisible && !iZoomSliderVisible )
{
// If the page is being fetched then don't show the zoom slider
if ( ApiProvider().ContentDisplayed())
{
ApiProvider().BrCtlInterface().HandleCommandL(
(TInt)TBrCtlDefs::ECommandZoomSliderShow +
(TInt)TBrCtlDefs::ECommandIdBase );
iZoomSliderVisible = ETrue;
}
}
// Set the zoom slider to invisible only if the toggle is false,
// and the zoom slider used to be visible
else if (!aVisible && iZoomSliderVisible )
{
ApiProvider().BrCtlInterface().HandleCommandL(
(TInt)TBrCtlDefs::ECommandZoomSliderHide +
(TInt)TBrCtlDefs::ECommandIdBase );
iZoomSliderVisible = EFalse;
}
if ( iPenEnabled )
{
iBrowserContentViewToolbar->UpdateButtonsStateL();
}
}
// ---------------------------------------------------------------------------
// CBrowserContentView::ZoomImagesInL
// ---------------------------------------------------------------------------
//
void CBrowserContentView::ZoomImagesInL( TInt aDuration )
{
if ( ApiProvider().ContentDisplayed() && !ApiProvider().WindowMgr().CurrentWindow()->WMLMode() )
{
iZoomLevelArray = ApiProvider().BrCtlInterface().ZoomLevels();
// Change zoom level
ZoomImagesL( 1, 0, iZoomLevelArray->Count()-2, aDuration );
}
}
// ---------------------------------------------------------------------------
// CBrowserContentView::ZoomImagesOutL
// ---------------------------------------------------------------------------
//
void CBrowserContentView::ZoomImagesOutL( TInt aDuration )
{
if ( ApiProvider().ContentDisplayed() && !ApiProvider().WindowMgr().CurrentWindow()->WMLMode() )
{
iZoomLevelArray = ApiProvider().BrCtlInterface().ZoomLevels();
// Change zoom level
ZoomImagesL( -1, 1, iZoomLevelArray->Count()-1, aDuration );
}
}
// ---------------------------------------------------------------------------
// CBrowserContentView::ZoomModeImagesL
// ---------------------------------------------------------------------------
//
void CBrowserContentView::ZoomModeImagesL()
{
if ( ApiProvider().ContentDisplayed() && !ApiProvider().WindowMgr().CurrentWindow()->WMLMode() )
{
// Retrieve the current zooming index value
iCurrentZoomLevel = ApiProvider().BrCtlInterface().BrowserSettingL(
TBrCtlDefs::ESettingsCurrentZoomLevelIndex );
iSavedZoomLevel = iCurrentZoomLevel;
// Toggle current zoom mode. Zoom Mode allows the user to change
// the zoom level using the navikey or HW zoom key
SetZoomModeL( ETrue );
}
}
// ---------------------------------------------------------------------------
// CBrowserContentView::ZoomImagesL
// ---------------------------------------------------------------------------
//
void CBrowserContentView::ZoomImagesL( TInt aDirection, TUint aLow,
TUint aHigh, TInt aDuration )
{
// Retrieve the current zooming index value, it takes effect right away
iCurrentZoomLevel = ApiProvider().BrCtlInterface().BrowserSettingL(
TBrCtlDefs::ESettingsCurrentZoomLevelIndex );
TInt currentZoomIndex = FindCurrentZoomIndex(iCurrentZoomLevel);
// Zoom can be increment, decrement or a direct change to a specific value.
if ( currentZoomIndex >= aLow && currentZoomIndex <= aHigh )
{
// Set current zoom level.
currentZoomIndex += aDirection;
iCurrentZoomLevel = (*iZoomLevelArray)[currentZoomIndex];
// Set actual zoom level.
ApiProvider().BrCtlInterface().SetBrowserSettingL(
TBrCtlDefs::ESettingsCurrentZoomLevelIndex, iCurrentZoomLevel );
// Retrieve the current zooming index value, because each page has its
// minimum zoom level, if smaller than it, engine will ignore
// so we have to retrieve the correct zoom level
iCurrentZoomLevel = ApiProvider().BrCtlInterface().BrowserSettingL(
TBrCtlDefs::ESettingsCurrentZoomLevelIndex );
}
// Display the zoom indicator
if ( currentZoomIndex <= 0 )
{
// Display minimum zoom indicator, it will dismiss after aDuration
SetZoomLevelTitleTextL( R_BROWSER_ZOOM_LEVEL_MIN, aDuration );
}
else if ( currentZoomIndex >= iZoomLevelArray->Count()-1 )
{
TInt arrayCount = iZoomLevelArray->Count()-1;
// Display maximum zoom indicator, it will dismiss after aDuration
SetZoomLevelTitleTextL( R_BROWSER_ZOOM_LEVEL_MAX, aDuration );
}
else
{
// Display zoom percentage indicator, it will dismiss after aDuration
// We turned off displaying zoom indicator for each level
// SetZoomLevelTitleTextL( R_BROWSER_ZOOM_LEVEL, aDuration );
}
}
// ---------------------------------------------------------------------------
// SaveCurrentZoomLevel
// ---------------------------------------------------------------------------
void CBrowserContentView::SaveCurrentZoomLevel(TBool saveZoom)
{
if (saveZoom)
{
//save the current zoom level by clicking softkey to confirm
ApiProvider().BrCtlInterface().SetBrowserSettingL(
TBrCtlDefs::ESettingsCurrentZoomLevelIndex, iCurrentZoomLevel );
}
else
{
iCurrentZoomLevel = iSavedZoomLevel;
ApiProvider().BrCtlInterface().SetBrowserSettingL(
TBrCtlDefs::ESettingsCurrentZoomLevelIndex, iCurrentZoomLevel );
}
}
// ---------------------------------------------------------------------------
// FindCurrentZoomIndex
// ---------------------------------------------------------------------------
TInt CBrowserContentView::FindCurrentZoomIndex(TInt aCurrentZoomLevel)
{
TInt index = -1;
for ( index = 0; index<iZoomLevelArray->Count()-1; index++)
{
if (aCurrentZoomLevel <=(*iZoomLevelArray)[index] )
{
break;
}
}
return index;
}
// ---------------------------------------------------------------------------
// CBrowserContentView::SetZoomLevelTitleTextL
// ---------------------------------------------------------------------------
//
void CBrowserContentView::SetZoomLevelTitleTextL( TInt aResourceId, TInt aDuration )
{
HBufC* zoomLevelFormat = NULL;
if ( aResourceId == R_BROWSER_ZOOM_LEVEL_MIN ||
aResourceId == R_BROWSER_ZOOM_LEVEL_MAX )
{
// Display the zoom max or min string
zoomLevelFormat = StringLoader::LoadLC( aResourceId );
// Show zoom indicator for aDuration seconds
ApiProvider().WindowMgr().CurrentWindow()->ChangeTitlePaneTextUntilL( zoomLevelFormat->Des(), aDuration );
CleanupStack::PopAndDestroy( ); // zoomLevelFormat
}
}
// ---------------------------------------------------------------------------
// CBrowserContentView::GetTextZoomLevelsL
// ---------------------------------------------------------------------------
//
void CBrowserContentView::GetTextZoomLevelsL( )
{
// Creating the text level
// Levels must be equal to TFontSize, with step percent 25% or 50%
// depending on chinese build.
// This is a temporary solution until make sure if engine
// provides text zoom levels. So it is currently hardcoded.
//------
// China build has only three font sizes:
// 0, 2, 4 (all small, normal, all large)
TInt fontSize = 0;
if ( !AVKONAPAC )
{
// font sizes 0,1,2,3,4
for ( TInt level = 50; level <= 150; level = level + 25 )
{
iTextZoomLevelArray->AppendL( level );
iFontSizeArray->AppendL( fontSize );
fontSize++;
}
}
else
{
// font sizes 0,2,4
for ( TInt level = 50; level <= 150; level = level + 50 )
{
iTextZoomLevelArray->AppendL( level );
iFontSizeArray->AppendL( fontSize );
fontSize = fontSize + 2;
}
}
// Get initial text zoom level index, bt comparing
// the preferences value, with the one in iFontSizeArray,
// and get the index (i)
TBool found = EFalse;
for ( TInt i = 0; i < iFontSizeArray->Count(); i++ )
{
if ( ApiProvider().Preferences().FontSize() == (*iFontSizeArray)[i] )
{
iCurrentTextZoomLevelIndex = i;
found = ETrue;
}
}
// If the initial font size value is not found, then the cenrep
// default is not right, by default initial cenrep font size value
// should be 0,2,4. So general, and chinese values are the same.
// Because if for example default cenrep value of font size is 1,
// then that is not supported in chinese build.
// General font size values are: 0,1,2,3,4
// Chinese font size values are: 0,2,4
if ( !found )
{
User::Leave( KErrGeneral );
}
}
// ---------------------------------------------------------------------------
// CBrowserContentView::KeymapIsUp
// ---------------------------------------------------------------------------
//
TBool CBrowserContentView::KeymapIsUp()
{
return (iShortcutKeyMap != NULL);
}
// ---------------------------------------------------------------------------
// CBrowserContentView::isZoomMode
// ---------------------------------------------------------------------------
//
TBool CBrowserContentView::isZoomMode()
{
// Zoom Mode currently disabled
// return iZoomMode;
return EFalse;
}
// ---------------------------------------------------------------------------
// CBrowserContentView::ShowKeymap
// ---------------------------------------------------------------------------
//
void CBrowserContentView::ShowKeymap()
{
iShortcutKeyMap = CBrowserShortcutKeyMap::NewL(iContainer, iApiProvider);
UpdateCbaL();
}
// ---------------------------------------------------------------------------
// CBrowserContentView::HideKeymap
// ---------------------------------------------------------------------------
//
void CBrowserContentView::HideKeymap()
{
delete(iShortcutKeyMap);
iShortcutKeyMap = NULL;
TRAP_IGNORE(UpdateCbaL());
TRAP_IGNORE(UpdateFullScreenL());
}
// ---------------------------------------------------------------------------
// CBrowserContentView::RedrawKeymap
// ---------------------------------------------------------------------------
//
void CBrowserContentView::RedrawKeymap()
{
HideKeymap();
ShowKeymap();
}
// -----------------------------------------------------------------------------
// CBrowserContentView::EnableFullScreenModeL
// -----------------------------------------------------------------------------
//
void CBrowserContentView::EnableFullScreenModeL( TBool aEnableFullScreen )
{
TInt command( KErrNotFound );
if ( aEnableFullScreen )
{
if (iPenEnabled)
{
Toolbar()->SetToolbarVisibility( EFalse, EFalse );
Toolbar()->MakeVisible( EFalse );
}
iContentFullScreenMode = ETrue;
UpdateFullScreenL();
command = TBrCtlDefs::ECommandEnterFullscreenBrowsing;
}
else
{
if (iPenEnabled)
{
Toolbar()->SetToolbarVisibility( ETrue, EFalse );
}
iContentFullScreenMode = EFalse;
SetFullScreenOffL();
command = TBrCtlDefs::ECommandLeaveFullscreenBrowsing;
if (iPenEnabled)
{
StartAutoFullScreenIdleTimer();
}
}
ApiProvider().BrCtlInterface().HandleCommandL(
command + (TInt)TBrCtlDefs::ECommandIdBase );
}
// -----------------------------------------------------------------------------
// CBrowserContentView::HandlePluginFullScreen
// -----------------------------------------------------------------------------
//
void CBrowserContentView::HandlePluginFullScreen(TBool aFullScreen)
{
iIsPluginFullScreenMode = aFullScreen;
if (aFullScreen) {
if (AppUi()->Orientation() != CAknAppUiBase::EAppUiOrientationLandscape) {
iOrientation = AppUi()->Orientation();
TRAP_IGNORE(AppUi()->SetOrientationL(CAknAppUiBase::EAppUiOrientationLandscape));
}
if (iPenEnabled) {
Toolbar()->SetToolbarVisibility( EFalse, EFalse );
}
iContentFullScreenMode = ETrue;
UpdateFullScreenL();
}
else {
TRAP_IGNORE(AppUi()->SetOrientationL(iOrientation));
if (iPenEnabled) {
Toolbar()->SetToolbarVisibility( ETrue, EFalse );
}
iContentFullScreenMode = EFalse;
SetFullScreenOffL();
}
}
// -----------------------------------------------------------------------------
// CBrowserContentView::ShowFsStatusPane
// -----------------------------------------------------------------------------
//
void CBrowserContentView::ShowFsStatusPane(TBool aShow)
{
if (aShow)
{
#ifdef RD_SCALABLE_UI_V2
if ( Layout_Meta_Data::IsLandscapeOrientation() )
StatusPane()->SwitchLayoutL(R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL_FLAT_NO_SOFTKEYS);
#endif
StatusPane()->MakeVisible( ETrue );
iContainer->SetRect(ClientRect());
// Remove any timer that has already been set
if ( iPeriodic )
{
iPeriodic->Cancel();
}
}
else
{
// Kick off timer for 3 seconds before hiding status pane again
if ( iPeriodic )
{
iPeriodic->Cancel();
}
iPeriodic->Start(KFullScreenStatusPaneTimeout, 0,TCallBack(CallHideFsStatusPane,this));
}
}
// -----------------------------------------------------------------------------
// CBrowserContentView::CallHideFsStatusPane
// -----------------------------------------------------------------------------
TInt CBrowserContentView::CallHideFsStatusPane(TAny* aCBrowserContentView)
{
__ASSERT_DEBUG(aCBrowserContentView, Util::Panic( Util::EUninitializedData ));
TRAP_IGNORE(
((CBrowserContentView*)aCBrowserContentView)->HideFsStatusPane();
);
return KErrNone;
}
// -----------------------------------------------------------------------------
// CBrowserContentView::HideFsStatusPane
// -----------------------------------------------------------------------------
void CBrowserContentView::HideFsStatusPane()
{
iPeriodic->Cancel();
if (iContentFullScreenMode && ApiProvider().LastActiveViewId() == KUidBrowserContentViewId )
{
StatusPane()->MakeVisible( EFalse );
iContainer->SetRect(ClientRect());
}
}
// -----------------------------------------------------------------------------
// CBrowserContentView::StartAutoFullScreenTimer
// -----------------------------------------------------------------------------
//
void CBrowserContentView::StartAutoFullScreenTimer()
{
SuspendAutoFullScreenIdleTimer();
if ( iAutoFSPeriodic )
{
iAutoFSPeriodic->Cancel();
}
iAutoFSPeriodic->Start(KAutoFullScreenTimeout, 0,TCallBack(CallActivateAutoFullScreen,this));
}
// -----------------------------------------------------------------------------
// CBrowserContentView::StartAutoFullScreenIdleTimer
// -----------------------------------------------------------------------------
//
void CBrowserContentView::StartAutoFullScreenIdleTimer()
{
if ( iIdlePeriodic )
{
iIdlePeriodic->Cancel();
}
iIdlePeriodic->Start(KAutoFullScreenIdleTimeout, 0,TCallBack(CallActivateAutoFullScreen,this));
}
// -----------------------------------------------------------------------------
// CBrowserContentView::SuspendAutoFullScreenTimer
// -----------------------------------------------------------------------------
//
void CBrowserContentView::SuspendAutoFullScreenTimer()
{
if ( iAutoFSPeriodic )
{
iAutoFSPeriodic->Cancel();
}
}
// -----------------------------------------------------------------------------
// CBrowserContentView::SuspendAutoFullScreenIdleTimer
// -----------------------------------------------------------------------------
//
void CBrowserContentView::SuspendAutoFullScreenIdleTimer()
{
if ( iIdlePeriodic )
{
iIdlePeriodic->Cancel();
}
}
// -----------------------------------------------------------------------------
// CBrowserContentView::CallSwitchToAutoFullScreen
// -----------------------------------------------------------------------------
//
TInt CBrowserContentView::CallActivateAutoFullScreen(TAny* aCBrowserContentView)
{
__ASSERT_DEBUG(aCBrowserContentView, Util::Panic( Util::EUninitializedData ));
TRAP_IGNORE(
((CBrowserContentView*)aCBrowserContentView)->ActivateAutoFullScreenMode();
);
return KErrNone;
}
// -----------------------------------------------------------------------------
// CBrowserContentView::ActivateAutoFullScreen
// -----------------------------------------------------------------------------
void CBrowserContentView::ActivateAutoFullScreenMode()
{
if ( iAutoFSPeriodic )
{
iAutoFSPeriodic->Cancel();
}
if ( iIdlePeriodic )
{
iIdlePeriodic->Cancel();
}
if ( ApiProvider().LastActiveViewId() == KUidBrowserContentViewId )
{
if( IsForeground()
&& ApiProvider().LoadObserver().ContentDisplayed()
&& !iZoomSliderVisible
&& !iHistoryViewIsUp
&& !iContainer->GotoPane()->IsVisible()
&& !iContainer->FindKeywordPane()->IsVisible()
#ifdef RD_SCALABLE_UI_V2
&& !Toolbar()->ToolbarExtension()->IsShown()
#endif
&& !iThumbnailViewIsUp
&& !iOptionsMenuActive
&& !ApiProvider().IsDisplayingMenuOrDialog()
&& !ApiProvider().WindowMgr().CurrentWindow()->WMLMode()
&& !iIsPluginFullScreenMode)
{
EnableFullScreenModeL( ETrue);
}
else
{
if (iIsPluginFullScreenMode || !IsForeground())
{
//Hide the FullscreenExit Button
ApiProvider().BrCtlInterface().HandleCommandL(
TBrCtlDefs::ECommandLeaveFullscreenBrowsing
+ (TInt)TBrCtlDefs::ECommandIdBase );
}
StartAutoFullScreenTimer();
}
}
}
// -----------------------------------------------------------------------------
// CBrowserContentView::SetEmphasis
// -----------------------------------------------------------------------------
void CBrowserContentView::SetEmphasis(CCoeControl* aMenuControl, TBool aEmphasis)
{
if (iPenEnabled)
{
if(aEmphasis)
{
iOptionsMenuActive = ETrue;
SuspendAutoFullScreenTimer();
}
else
{
iOptionsMenuActive = EFalse;
StartAutoFullScreenTimer();
}
}
CAknView::SetEmphasis(aMenuControl, aEmphasis);
}
// -----------------------------------------------------------------------------
// CBrowserContentView::IsEditMode
// -----------------------------------------------------------------------------
TBool CBrowserContentView::IsEditMode()
{
TBrCtlDefs::TBrCtlElementType focusedElementType =
ApiProvider().BrCtlInterface().FocusedElementType();
TBool retVal = ((focusedElementType == TBrCtlDefs:: EElementActivatedInputBox) ||
(focusedElementType == TBrCtlDefs:: EElementInputBox) ||
(focusedElementType == TBrCtlDefs:: EElementTextAreaBox));
return (retVal);
}
// End of File