/*

* 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::CurrentWindowQue()

// -----------------------------------------------------------------------------

//

CBrowserWindowQue* CBrowserWindowManager::CurrentWindowQue() const

    {

    if( iCurrentWindow )

        {

        return iCurrentWindow;

        }

    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 );