--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/browserui/browser/BrowserAppSrc/BrowserWindowManager.cpp Mon Mar 30 12:49:49 2009 +0300
@@ -0,0 +1,813 @@
+/*
+* Copyright (c) 2002 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:
+* Multiple Windows' WindowManager.
+*
+*
+*/
+
+
+// INCLUDE FILES
+#include "BrowserWindowManager.h"
+#include "BrowserWindow.h"
+#include "BrowserWindowQueue.h"
+#include "BrowserContentView.h"
+#include "WindowInfoProvider.h"
+#include "Logger.h"
+#include "Preferences.h"
+#include "Display.h"
+#include "ApiProvider.h"
+#include <BrCtlDefs.h>
+#include "BrowserUtil.h"
+#include <BrowserNG.rsg>
+#include <StringLoader.h>
+#include <AknQueryDialog.h>
+
+
+// -----------------------------------------------------------------------------
+// CBrowserWindowQue::LastItem()
+// -----------------------------------------------------------------------------
+//
+CBrowserWindowQue* CBrowserWindowQue::LastItem() const
+ {
+ // remove 'const' modifier from 'this' in a const member function
+ CBrowserWindowQue* a = CONST_CAST( CBrowserWindowQue*, this );
+ for( ; a->iNext; a=a->iNext)
+ ;
+ return a;
+ }
+
+// -----------------------------------------------------------------------------
+// CBrowserWindowQue::~CBrowserWindowQue()
+// -----------------------------------------------------------------------------
+//
+CBrowserWindowQue::~CBrowserWindowQue()
+ {
+LOG_ENTERFN("WindowQue::~WindowQue");
+ if( this->iPrev )
+ {
+ BROWSER_LOG( ( _L( "iPrev" ) ) );
+ this->iPrev->iNext = this->iNext;
+ }
+ if( this->iNext )
+ {
+ BROWSER_LOG( ( _L( "iNext" ) ) );
+ this->iNext->iPrev = this->iPrev;
+ }
+ delete iWindow;
+ iWindow = NULL;
+ }
+
+// -----------------------------------------------------------------------------
+// CBrowserWindowQue::AppendL()
+// -----------------------------------------------------------------------------
+//
+void CBrowserWindowQue::AppendL( CBrowserWindowQue* aItem )
+ {
+ __ASSERT_DEBUG( (aItem != NULL), Util::Panic( Util::EUninitializedData ));
+ aItem->iPrev = LastItem();
+ aItem->iPrev->iNext = aItem;
+ }
+
+// -----------------------------------------------------------------------------
+// CBrowserWindowQue::Next()
+// -----------------------------------------------------------------------------
+//
+CBrowserWindowQue* CBrowserWindowQue::Next() const
+ {
+ CBrowserWindowQue* b = this->iNext;
+ while( b && (b->iStatus & CBrowserWindowQue::EWindowDeleted ) )
+ {
+ b = b->iNext;
+ }
+ return b;
+ }
+
+// -----------------------------------------------------------------------------
+// CBrowserWindowQue::Prev()
+// -----------------------------------------------------------------------------
+//
+CBrowserWindowQue* CBrowserWindowQue::Prev() const
+ {
+ CBrowserWindowQue* b = this->iPrev;
+ while( b && (b->iStatus & CBrowserWindowQue::EWindowDeleted ) )
+ {
+ b = b->iPrev;
+ }
+ return b;
+ }
+
+// -----------------------------------------------------------------------------
+// CBrowserWindowManager::
+// -----------------------------------------------------------------------------
+// initialization of static member variable
+TInt CBrowserWindowManager::iWindowIdGenerator( 0 );
+
+// -----------------------------------------------------------------------------
+// CBrowserWindowManager::NewLC()
+// -----------------------------------------------------------------------------
+//
+CBrowserWindowManager* CBrowserWindowManager::NewLC(
+ MApiProvider& aApiProvider,
+ CBrowserContentView& aContentView,
+ TInt aMaxWindowCount )
+ {
+ CBrowserWindowManager* self = new (ELeave)
+ CBrowserWindowManager( aApiProvider, aContentView, aMaxWindowCount );
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ return self;
+ }
+
+// -----------------------------------------------------------------------------
+// CBrowserWindowManager::NewL()
+// -----------------------------------------------------------------------------
+//
+CBrowserWindowManager* CBrowserWindowManager::NewL(
+ MApiProvider& aApiProvider,
+ CBrowserContentView& aContentView,
+ TInt aMaxWindowCount )
+ {
+ CBrowserWindowManager* self = CBrowserWindowManager::NewLC(
+ aApiProvider, aContentView, aMaxWindowCount );
+ CleanupStack::Pop( self );
+ return self;
+ }
+
+// -----------------------------------------------------------------------------
+// CBrowserWindowManager::~CBrowserWindowManager()
+// -----------------------------------------------------------------------------
+//
+CBrowserWindowManager::~CBrowserWindowManager( )
+ {
+LOG_ENTERFN("WindowManager::~WindowManager");
+ // Preferences must exist!
+ if(iApiProvider!=NULL)
+ {
+ iApiProvider->Preferences().RemoveObserver( this );
+ }
+ RemoveObserver(iContentView);
+ CBrowserWindowQue *window = iWindowQueue;
+ CBrowserWindowQue *temp = NULL;
+
+
+ TBool isStandAlone( !iApiProvider->IsEmbeddedModeOn() );
+ if ( ( isStandAlone && !iUserExit ) || ( !isStandAlone ) )
+ {
+ TRAP_IGNORE( window->iWindow->BrCtlInterface().HandleCommandL(
+ (TInt)TBrCtlDefs::ECommandSaveLaunchParams + (TInt)TBrCtlDefs::ECommandIdBase ) );
+ }
+
+ for(; window; )
+ {
+ temp = window;
+ window = window->iNext;
+ DeleteOneWindowL( temp->iWindow->WindowId() );
+ /*delete temp;
+ temp = NULL;*/
+ }
+ RemoveDeletedWindowsL();
+ delete iObservers;
+ iObservers = NULL;
+ }
+
+// -----------------------------------------------------------------------------
+// CBrowserWindowManager::WindowCount()
+// -----------------------------------------------------------------------------
+//
+TInt CBrowserWindowManager::WindowCount() const
+ {
+ return iWindowCount - iDeletedWindowCount;
+ }
+
+// -----------------------------------------------------------------------------
+// CBrowserWindowManager::CBrowserWindowManager()
+// -----------------------------------------------------------------------------
+//
+CBrowserWindowManager::CBrowserWindowManager(
+ MApiProvider& aApiProvider,
+ CBrowserContentView& aContentView,
+ TInt aMaxWindowCount ) :
+ iApiProvider( &aApiProvider ),
+ iContentView( &aContentView),
+ iMaxWindowCount( aMaxWindowCount ),
+ iWindowCount( 0 ),
+ iDeletedWindowCount( 0 ),
+ iWindowQueue( NULL ),
+ iCurrentWindow( NULL ),
+ iUserExit( EFalse ),
+ iIsContentExist( EFalse )
+ {
+ }
+
+// -----------------------------------------------------------------------------
+// CBrowserWindowManager::ConstructL()
+// -----------------------------------------------------------------------------
+//
+void CBrowserWindowManager::ConstructL( )
+ {
+ iApiProvider->Preferences().AddObserverL( this );
+ CreateWindowL( 0, &KNullDesC );
+ iCurrentWindow = iWindowQueue;
+ // don't draw anything, just activate it
+ iCurrentWindow->iWindow->ActivateL( EFalse );
+ iObservers = new ( ELeave ) CArrayPtrFlat< MWindowObserver >( 1 );
+ AddObserverL(iContentView);
+ }
+
+// -----------------------------------------------------------------------------
+// CBrowserWindowManager::Window()
+// -----------------------------------------------------------------------------
+//
+TInt CBrowserWindowManager::Window(
+ TInt aWindowId,
+ CBrowserWindow*& aWindow )
+ {
+ RemoveDeletedWindowsL();
+ CBrowserWindowQue *windowQue = NULL;
+ TInt error( Window( aWindowId, windowQue, iWindowQueue ) );
+ if( windowQue )
+ {
+ aWindow = windowQue->iWindow;
+ }
+ return error;
+ }
+
+// -----------------------------------------------------------------------------
+// CBrowserWindowManager::FindWindowL()
+// -----------------------------------------------------------------------------
+//
+CBrowserWindow* CBrowserWindowManager::FindWindowL(
+ const TDesC& aTargetName )
+ {
+LOG_ENTERFN("WindowManager::FindWindowL( Target )");
+ RemoveDeletedWindowsL();
+ CBrowserWindow* result = NULL;
+ CBrowserWindow* window = NULL;
+ CBrowserWindowQue *windowQue = iWindowQueue;
+ for( ; windowQue; windowQue = windowQue->Next() )
+ {
+ window = windowQue->iWindow;
+ if( window->TargetName()->Compare( aTargetName ) == 0 )
+ {
+ result = window;
+ }
+ }
+ return result;
+ }
+
+// -----------------------------------------------------------------------------
+// CBrowserWindowManager::CurrentWindow()
+// -----------------------------------------------------------------------------
+//
+CBrowserWindow* CBrowserWindowManager::CurrentWindow() const
+ {
+ if( iCurrentWindow )
+ {
+ return iCurrentWindow->iWindow;
+ }
+ else
+ {
+ return NULL;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CBrowserWindowManager::GetWindowInfoL()
+// -----------------------------------------------------------------------------
+//
+CArrayFixFlat<CWindowInfo*>* CBrowserWindowManager::GetWindowInfoL(
+ MWindowInfoProvider* aWindowInfo )
+ {
+ __ASSERT_DEBUG( (aWindowInfo != NULL), Util::Panic( Util::EUninitializedData ));
+
+ RemoveDeletedWindowsL();
+ CBrowserWindowQue* window = iWindowQueue;
+ CArrayFixFlat<CWindowInfo*>* windowInfoList = new (ELeave)
+ CArrayFixFlat<CWindowInfo*>( 3 /* KGranularityMedium */ );
+ CleanupStack::PushL( windowInfoList );
+ for( ; window; window = window->Next() )
+ {
+ // create window info text by client
+ HBufC* buf = aWindowInfo->CreateWindowInfoLC( *( window->iWindow ) );
+
+ if (!buf)
+ {
+ CleanupStack::PopAndDestroy( buf );
+ buf = KNullDesC().AllocLC();
+ }
+
+ // create window info( text, id, current )
+ CWindowInfo* windowInfo = new ( ELeave ) CWindowInfo(
+ buf, window->iWindow->WindowId(), iCurrentWindow == window );
+
+ CleanupStack::Pop( buf );
+
+ // append to list
+ windowInfoList->AppendL( windowInfo );
+
+ }
+
+ CleanupStack::Pop( windowInfoList );
+ return windowInfoList;
+ }
+
+// -----------------------------------------------------------------------------
+// CBrowserWindowManager::AddObserver()
+// -----------------------------------------------------------------------------
+//
+void CBrowserWindowManager::AddObserverL( MWindowObserver* aObserver )
+ {
+ LOG_ENTERFN("CBrowserWindowManager::AddObserver");
+ if ( iObservers )
+ {
+ iObservers->AppendL( aObserver );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CBrowserWindowManager::RemoveObserver()
+// -----------------------------------------------------------------------------
+//
+void CBrowserWindowManager::RemoveObserver( MWindowObserver* aObserver )
+ {
+ LOG_ENTERFN("CBrowserWindowManager::RemoveObserver");
+ TInt i( 0 );
+ TInt count = iObservers->Count();
+ for ( i = 0; i < count; i++ )
+ {
+ if ( iObservers->At( i ) == aObserver )
+ {
+ iObservers->Delete( i );
+ break;
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CBrowserWindowManager::NotifyObservers()
+// -----------------------------------------------------------------------------
+//
+void CBrowserWindowManager::NotifyObserversL( TWindowEvent aEvent, TInt aWindowId )
+ {
+ LOG_ENTERFN("CBrowserWindowManager::NotifyObservers");
+ if ( iObservers )
+ {
+ TInt i;
+ TInt count = iObservers->Count();
+
+ if ( count )
+ {
+ for ( i = 0; i < count; i++ )
+ {
+ iObservers->At( i )->WindowEventHandlerL( aEvent, aWindowId );
+ }
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CBrowserWindowManager::CreateWindowL()
+// -----------------------------------------------------------------------------
+//
+CBrowserWindow* CBrowserWindowManager::CreateWindowL(
+ TInt aParentId,
+ const TDesC* aTargetName )
+ {
+PERFLOG_LOCAL_INIT
+PERFLOG_STOPWATCH_START
+LOG_ENTERFN("WindowManager::CreateWindowL");
+ RemoveDeletedWindowsL();
+ if( WindowCount() >= iMaxWindowCount )
+ {
+ HBufC* maxWinsReached = StringLoader::LoadLC(R_BROWSER_NOTE_MAX_WINDOWS);
+ ApiProvider()->DialogsProvider().DialogNoteL( *maxWinsReached );
+ CleanupStack::PopAndDestroy( maxWinsReached );
+ return NULL;
+ }
+ CBrowserWindow* window = NULL;
+ // search for already existing window
+ Window( aParentId, aTargetName, window, iWindowQueue ); // error is ignored
+ if( window )
+ {
+
+ return window;
+ }
+ window = CBrowserWindow::NewLC( ++iWindowIdGenerator, aTargetName, this );
+BROWSER_LOG( ( _L( "Window is created, ID: %d, windowCount: %d" ),
+ window->WindowId(), WindowCount ) );
+ // create a WindowQue instance initiated by the new window
+ CBrowserWindowQue *windowQue = new (ELeave) CBrowserWindowQue( window );
+ CleanupStack::PushL( windowQue );
+ // and set window's parent
+ TInt error2( Window( aParentId, windowQue->iParent, iWindowQueue ) );
+BROWSER_LOG( ( _L( "error2: %d" ), error2 ) );
+ // append window to the list
+ if( iWindowQueue )
+ {
+ BROWSER_LOG( ( _L( "window queue not empty" ) ) );
+ iWindowQueue->AppendL( windowQue );
+ }
+ else
+ {
+ BROWSER_LOG( ( _L( "window queue empty" ) ) );
+ iWindowQueue = windowQue;
+ }
+ CleanupStack::Pop( windowQue );
+
+ // window is created and append to the list successfully
+ ++iWindowCount;
+
+ CleanupStack::Pop( window );
+ NotifyObserversL( EWindowOpen, window->WindowId() );
+
+ // window is activated by the client
+PERFLOG_STOP_WRITE("****CreateWindowL***")
+ return window;
+ }
+
+// -----------------------------------------------------------------------------
+// CBrowserWindowManager::DeleteWindowL()
+// -----------------------------------------------------------------------------
+//
+TInt CBrowserWindowManager::DeleteWindowL(
+ TInt aWindowId,
+ TBool aUserInitiated )
+ {
+LOG_ENTERFN("WindowManager::DeleteWindowL");
+ TInt windowToBeActivated( KErrNotFound );
+ // find the window
+ CBrowserWindowQue* windowQue = NULL;
+ Window( aWindowId, windowQue, iWindowQueue );
+ if( windowQue )
+ {
+ // make the old window absolutely inactive
+ windowQue->iWindow->BrCtlInterface().HandleCommandL(
+ (TInt)TBrCtlDefs::ECommandClearHistory + (TInt)TBrCtlDefs::ECommandIdBase );
+ // Changes were made to ClearHistory that cause it to keep one (current) page
+ // In order to reuse a window we need to clear the history again after the first new page
+ // is loaded.
+ windowQue->iWindow->SetFirstPage(ETrue);
+
+
+ windowQue->iWindow->BrCtlInterface().HandleCommandL(
+ (TInt)TBrCtlDefs::ECommandLoseFocus + (TInt)TBrCtlDefs::ECommandIdBase );
+
+ if(windowQue->iWindow->HasWMLContent(EFalse))
+ {
+ windowQue->iWindow->BrCtlInterface().HandleCommandL(
+ (TInt)TBrCtlDefs::ECommandUnloadWMLEngine + (TInt)TBrCtlDefs::ECommandIdBase );
+ }
+
+ // On 3.1 CancelFetch activates the content view for some reason
+ // this section is temporarily flagged out until further
+ // investigation.
+ windowQue->iWindow->BrCtlInterface().HandleCommandL(
+ (TInt)TBrCtlDefs::ECommandCancelFetch + (TInt)TBrCtlDefs::ECommandIdBase );
+
+ // if the topmost window is deleted
+ // try to find a new one to be activated
+ if( iCurrentWindow == windowQue )
+ {
+ CBrowserWindowQue* next = windowQue->Next();
+ CBrowserWindowQue* prev = windowQue->Prev();
+ if( next )
+ {
+ windowToBeActivated = next->iWindow->WindowId();
+ iCurrentWindow = next;
+ }
+ else if( prev )
+ {
+ windowToBeActivated = prev->iWindow->WindowId();
+ iCurrentWindow = prev;
+ }
+ else
+ {
+ windowToBeActivated = 0;
+ }
+ }
+ // else a background window was deleted
+
+ // last window handling
+ if( WindowCount() == 1 )
+ {
+ // here we already set the windowToBeActivated to 0
+ // means CloseContentView or Exit in AppUi
+
+ // clear all content of Window (images, scripts)
+
+// windowQue->iWindow->BrCtlInterface().HandleCommandL(
+// (TInt)TBrCtlDefs::ECommand + (TInt)TBrCtlDefs::ECommandIdBase );
+ windowQue->iWindow->BrCtlInterface().HandleCommandL(
+ (TInt)TBrCtlDefs::ECommandUnloadWMLEngine + (TInt)TBrCtlDefs::ECommandIdBase );
+
+ //Remove the plugins windows. This is a fix for plugins still plays in the background
+ //while the page is closed.
+ windowQue->iWindow->BrCtlInterface().HandleCommandL(
+ (TInt)TBrCtlDefs::ECommandUnLoadPluginWindows + (TInt)TBrCtlDefs::ECommandIdBase );
+
+ iIsContentExist = EFalse;
+ windowQue->iWindow->SetHasWMLContent(EFalse);
+ windowQue->iWindow->SetCurrWinHasWMLContent(EFalse);
+
+
+ }
+ // Update MW Indicator
+ else if ( WindowCount() == 2 )
+ {
+ // sets the window status
+ windowQue->iStatus |= CBrowserWindowQue::EWindowDeleted;
+ windowQue->iWindow->DeactivateL();
+ // maintain deleted windows' count
+ ++iDeletedWindowCount;
+
+ if( aUserInitiated )
+ {
+ DeleteOneWindowL( aWindowId );
+ }
+ }
+ else
+ {
+ // sets the window status
+ windowQue->iStatus |= CBrowserWindowQue::EWindowDeleted;
+ windowQue->iWindow->DeactivateL();
+ // maintain deleted windows' count
+ ++iDeletedWindowCount;
+
+ if( aUserInitiated )
+ {
+ DeleteOneWindowL( aWindowId );
+ }
+ }
+ }
+ NotifyObserversL( EWindowClose, aWindowId );
+
+ return windowToBeActivated;
+ }
+
+// -----------------------------------------------------------------------------
+// CBrowserWindowManager::SwitchWindowL()
+// -----------------------------------------------------------------------------
+//
+TInt CBrowserWindowManager::SwitchWindowL( TInt aWindowId, TBool aDraw )
+ {
+LOG_ENTERFN("WindowManager::SwitchWindowL");
+ CBrowserWindowQue* windowQue = NULL;
+ TBool wdnSwitching = EFalse;
+ TInt error( Window( aWindowId, windowQue, iWindowQueue ) );
+BROWSER_LOG( ( _L( "error: %d" ), error ) );
+ if( windowQue )
+ {
+ BROWSER_LOG( ( _L( "Switching..." ) ) );
+ if( windowQue != iCurrentWindow )
+ {
+ wdnSwitching = ETrue;
+ iCurrentWindow->iWindow->DeactivateL();
+ iCurrentWindow = windowQue;
+ }
+ //If the history view is up, don't activate the content view unless it is switching the window. Otherwise,
+ //it will overdraw the history view and it will cause serious problems when there
+ //is a background redirection
+ if(!iCurrentWindow->iWindow->IsWindowActive() && (!iContentView->IsHistoryViewUp() || wdnSwitching))
+ {
+ iCurrentWindow->iWindow->ActivateL( aDraw );
+ iContentView->UpdateCbaL();
+ }
+ }
+ return error;
+ }
+
+// -----------------------------------------------------------------------------
+// CBrowserWindowManager::Window()
+// -----------------------------------------------------------------------------
+// search for a window identified by its Id
+TInt CBrowserWindowManager::Window(
+ TInt aWindowId,
+ CBrowserWindowQue*& aWindowQue,
+ CBrowserWindowQue* aStartingItem ) const
+ {
+LOG_ENTERFN("WindowManager::Window( Id )");
+ TInt error( KErrNotFound );
+ CBrowserWindowQue *windowQue = aStartingItem;
+ for( ; (error != KErrNone) && (windowQue); windowQue = windowQue->iNext )
+ {
+ if( windowQue->iWindow->WindowId() == aWindowId )
+ {
+ error = KErrNone;
+ aWindowQue = windowQue;
+ }
+ }
+ return error;
+ }
+
+// -----------------------------------------------------------------------------
+// CBrowserWindowManager::Window()
+// -----------------------------------------------------------------------------
+// search for a window identified by TargetName and its Parent
+TInt CBrowserWindowManager::Window(
+ TInt aParentId,
+ const TDesC* aTargetName,
+ CBrowserWindow*& aWindow,
+ CBrowserWindowQue* aStartingItem ) const
+ {
+LOG_ENTERFN("WindowManager::Window( Parent, Target )");
+ TInt error( KErrNotFound );
+ if( aTargetName && aTargetName->Length() ) // sanity check
+ {
+ CBrowserWindow* window = NULL;
+ CBrowserWindowQue *windowQue = aStartingItem;
+ CBrowserWindowQue* parent = NULL;
+ for( ; (error != KErrNone) && (windowQue); windowQue = windowQue->iNext )
+ {
+ window = windowQue->iWindow;
+ parent = windowQue->iParent;
+ if( parent &&
+ ( parent->iWindow->WindowId() == aParentId ) &&
+ ( window->TargetName()->Compare( *aTargetName ) == 0 ) )
+ {
+ error = KErrNone;
+ aWindow = window;
+ }
+ }
+ }
+ return error;
+ }
+
+// -----------------------------------------------------------------------------
+// CBrowserWindowManager::DeleteOneWindowL()
+// -----------------------------------------------------------------------------
+//
+TInt CBrowserWindowManager::DeleteOneWindowL( TInt aWindowId )
+ {
+ // Last window cannot be deleted, this is not called then.
+LOG_ENTERFN("WindowManager::DeleteOneWindowL");
+ CBrowserWindowQue* windowQue = NULL;
+ // find window, error ignored
+ Window( aWindowId, windowQue, iWindowQueue );
+ if( windowQue )
+ {
+ // set WindowQueue's first item if required
+ if( iWindowQueue == windowQue )
+ {
+ iWindowQueue = windowQue->iNext;
+ }
+
+ // clear children's parent pointer
+ CBrowserWindowQue* queue = iWindowQueue;
+ for( ; queue; queue = queue->iNext )
+ {
+ if( queue->iParent == windowQue )
+ {
+ queue->iParent = NULL;
+ }
+ }
+
+ // decrease WindowCount
+ --iWindowCount;
+
+ // maintain deleted status
+ if ( windowQue->iStatus & CBrowserWindowQue::EWindowDeleted )
+ {
+ __ASSERT_DEBUG( iDeletedWindowCount,
+ Util::Panic( Util::EUnExpected ));
+ --iDeletedWindowCount;
+ }
+ // delete window via its windowQue container
+ delete windowQue;
+ }
+ return KErrNone;
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserWindowManager::RemoveDeletedWindowsL()
+// ----------------------------------------------------------------------------
+//
+void CBrowserWindowManager::RemoveDeletedWindowsL()
+ {
+ CBrowserWindowQue *window = iWindowQueue;
+ CBrowserWindowQue *temp = NULL;
+ // walk through all the windows
+ for( ; window; )
+ {
+ temp = window;
+ window = window->iNext;
+ // if it is set as deleted
+ if( temp->iStatus & CBrowserWindowQue::EWindowDeleted )
+ {
+ DeleteOneWindowL( temp->iWindow->WindowId() );
+ }
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserWindowManager::HandlePreferencesChangeL()
+// ----------------------------------------------------------------------------
+//
+void CBrowserWindowManager::HandlePreferencesChangeL(
+ const TPreferencesEvent aEvent,
+ TPreferencesValues& aValues,
+ TBrCtlDefs::TBrCtlSettings aSettingType )
+ {
+LOG_ENTERFN("WindowManager::HandlePreferencesChangeL");
+BROWSER_LOG( ( _L( "Preferences event: %d" ), aEvent ) );
+ switch( aEvent )
+ {
+ case EPreferencesActivate:
+ {
+ // Topmost Window ONLY
+ if ( iCurrentWindow )
+ {
+ iCurrentWindow->iWindow->HandlePreferencesChangeL(
+ aEvent, aValues, aSettingType );
+ }
+ break;
+ }
+ case EPreferencesDeactivate:
+ case EPreferencesItemChange:
+ {
+ // All windows
+ CBrowserWindowQue *windowQue = iWindowQueue;
+ for( ; windowQue; windowQue = windowQue->Next() )
+ {
+ windowQue->iWindow->HandlePreferencesChangeL(
+ aEvent, aValues, aSettingType );
+ }
+ break;
+ }
+ default:
+ // don't do anything
+ break;
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserWindowManager::SendCommandToAllWindowsL()
+// ----------------------------------------------------------------------------
+//
+void CBrowserWindowManager::SendCommandToAllWindowsL(
+ TInt aCommand )
+ {
+LOG_ENTERFN("WindowManager::SendCommandToAllWindowsL");
+BROWSER_LOG( ( _L( "Command: %d" ), aCommand ) );
+
+ CBrowserWindowQue *windowQue = iWindowQueue;
+ for( ; windowQue; windowQue = windowQue->Next() )
+ {
+ windowQue->iWindow->BrCtlInterface().HandleCommandL(aCommand);
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserWindowManager::SetCurrentWindowViewState()
+// ----------------------------------------------------------------------------
+//
+void CBrowserWindowManager::SetCurrentWindowViewState(TBrCtlDefs::TBrCtlState aViewState, TInt aValue)
+ {
+LOG_ENTERFN("WindowManager::SetCurrentWindowViewState");
+BROWSER_LOG( ( _L( "State: %d" ), aViewState ) );
+
+ TBool val(aValue > 0);
+ if (aViewState == TBrCtlDefs::EStateWmlView)
+ {
+ CurrentWindow()->SetWMLMode(val); // set current page has wml (true or false)
+ if (val)
+ {
+ CurrentWindow()->SetHasWMLContent(ETrue); // at least 1 page in window has/had wml
+ CurrentWindow()->SetCurrWinHasWMLContent(ETrue); // current page has wml content
+
+ }
+ else
+ {
+ CurrentWindow()->SetCurrWinHasWMLContent(EFalse);// current page isn't wml
+ }
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CBrowserWindowManager::CloseAllWindowsExceptCurrent()
+// ----------------------------------------------------------------------------
+//
+void CBrowserWindowManager::CloseAllWindowsExceptCurrent()
+ {
+ LOG_ENTERFN("WindowManager::CloseAllWindowsExceptCurrent");
+ CBrowserWindowQue* window = iWindowQueue;
+ for( ; window; window = window->Next() )
+ {
+ if(iCurrentWindow != window)
+ {
+ DeleteWindowL(window->iWindow->WindowId(), EFalse);
+ }
+ }
+ }
+// End of file