/*

* 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: 

*     Browser content view

*     

*

*/

// INCLUDE FILES

#include <brctldefs.h>

#include <brctlinterface.h>

#include "BrowserWindow.h"

#include "BrowserContentView.h"

#include "BrowserContentViewContainer.h"

#include <browserdialogsprovider.h>

#include "BrowserDialogsProviderProxy.h"

#include "BrowserSoftkeysObserver.h"

#include "BrowserSpecialLoadObserver.h"

#include "BrowserWindowManager.h"

#include "ApiProvider.h"

#include "BrowserAppUi.h"

#include "BrowserUIVariant.hrh"

#include "Logger.h"

#include "BrowserDisplay.h"

#include "BrowserPopupEngine.h"

#include <cdownloadmgruidownloadslist.h>

#include <downloadmgrclient.h>

// for instantiating BrCtlInterface

#include "CommonConstants.h"

#include "BrowserApplication.h"

#include "BrowserAppDocument.h"

#include "Preferences.h"

// for dialog notes

#include <StringLoader.h>

#include <BrowserNG.rsg>

#include "BrowserDialogs.h"

#define CALL_ORIG iWindowManager->ApiProvider()->

TBool CBrowserWindow::iIsPageOverviewSupportQueried = EFalse;

TBool CBrowserWindow::iIsPageOverviewSupported = EFalse;

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

// CBrowserWindow::NewLC()

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

//

CBrowserWindow* CBrowserWindow::NewLC(

        TInt aWindowId,

        const TDesC* aTargetName,

        CBrowserWindowManager* aWindowMgr )

    {

    CBrowserWindow* self = new (ELeave) 

        CBrowserWindow( aWindowId, aTargetName, aWindowMgr );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CBrowserWindow::NewL()

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

//

CBrowserWindow* CBrowserWindow::NewL(

        TInt aWindowId,

        const TDesC* aTargetName,

        CBrowserWindowManager* aWindowMgr )

    {

    CBrowserWindow* self = 

        CBrowserWindow::NewLC( aWindowId, aTargetName, aWindowMgr );

    CleanupStack::Pop( self );

    return self;

    }

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

// CBrowserWindow::~CBrowserWindow()

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

//

CBrowserWindow::~CBrowserWindow()

    {

    iClosing = ETrue;

LOG_ENTERFN("CBrowserWindow::~CBrowserWindow");

BROWSER_LOG( ( _L( "window id: %d" ), WindowId() ) );

    if( iBrCtlInterface )

        {

        iBrCtlInterface->RemoveLoadEventObserver( iLoadObserver );

        BROWSER_LOG( ( _L( " RemoveLoadEventObserver" ) ) );

        CBrowserContentView* cv = iWindowManager->ContentView();    

        iBrCtlInterface->RemoveStateChangeObserver( cv );

        BROWSER_LOG( ( _L( " RemoveStateChangeObserver" ) ) );

        iBrCtlInterface->RemoveCommandObserver( cv );

        BROWSER_LOG( ( _L( " RemoveCommandObserver" ) ) );

        // TRAP_IGNORE( iBrCtlInterface->HandleCommandL(

        //    (TInt)TBrCtlDefs::ECommandCancelFetch + (TInt)TBrCtlDefs::ECommandIdBase ) );

        BROWSER_LOG( ( _L( " HandleCommandL" ) ) );

        }

    // security indicator must be set off.

    if( iDisplay && !iWindowManager->ApiProvider()->

        Preferences().HttpSecurityWarningsStatSupressed() )

        {

        BROWSER_LOG( ( _L( " UpdateSecureIndicatorL 1" ) ) );

        TRAP_IGNORE( iDisplay->UpdateSecureIndicatorL( EAknIndicatorStateOff ) );

        BROWSER_LOG( ( _L( " UpdateSecureIndicatorL 2" ) ) );

        // we cannot do much here if error occurs... application is closing anyway

        }

    delete iDisplay;

    BROWSER_LOG( ( _L( " Display deleted.") ) );

    //Delete iBrCtlInterface before observers. If this is not

    //done then browser crashes on exit when page is being loaded.

    delete iBrCtlInterface;

    BROWSER_LOG( ( _L( " BrCtlInterface deleted.") ) );

    delete iLoadObserver;

    BROWSER_LOG( ( _L( " LoadObserver deleted.") ) );

    delete iDialogsProviderProxy;

    BROWSER_LOG( ( _L( " DialogsProviderProxy deleted.") ) );

    delete iSpecialLoadObserver;

    BROWSER_LOG( ( _L( " SpecialLoadObserver deleted.") ) );

    delete iSoftkeysObserver;

    BROWSER_LOG( ( _L( " SoftkeysObserver deleted.") ) );

    //

    delete iTargetName;

    }

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

// CBrowserWindow::CBrowserWindow()

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

//

CBrowserWindow::CBrowserWindow(

        TInt aWindowId,

        const TDesC* aTargetName, 

        CBrowserWindowManager* aWindowMgr ) :

    iWindowId( aWindowId ),

    iActive( EFalse ),

    iFirstPage(ETrue),

    iBrCtlInterface( NULL ),

    iDialogsProviderProxy( NULL ),

    iDisplay( NULL ),

    iLoadObserver( NULL ),

    iSoftkeysObserver( NULL ),

    iSpecialLoadObserver( NULL ),

    iWindowManager( aWindowMgr )

    {

    	__ASSERT_DEBUG( (aTargetName != NULL), Util::Panic( Util::EUninitializedData ));

    	iTargetName = aTargetName->Alloc();

    }

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

// CBrowserWindow::ConstructL()

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

//

void CBrowserWindow::ConstructL()

    {

PERFLOG_LOCAL_INIT

LOG_ENTERFN("CBrowserWindow::ConstructL");

    MApiProvider* api = iWindowManager->ApiProvider();

    CleanupStack::PushL( api );

PERFLOG_STOPWATCH_START

    iDisplay = CBrowserDisplay::NewL( *this, *this );

PERFLOG_STOP_WRITE("*BrowserDisplay*")

    BROWSER_LOG( ( _L( "  Multiple Display up" ) ) );

    CBrowserContentView* cv = iWindowManager->ContentView();

    TRect rect = cv->Container()->Rect();

PERFLOG_STOPWATCH_START

    iLoadObserver = CBrowserLoadObserver::NewL( *this, *cv, *this );

    BROWSER_LOG( ( _L( "  Multiple LoadObserver up" ) ) );

PERFLOG_STOP_WRITE("*LoadObs*")

PERFLOG_STOPWATCH_START

    iDialogsProviderProxy = CBrowserDialogsProviderProxy::NewL( 

        api->DialogsProvider(), iLoadObserver, *this );

PERFLOG_STOP_WRITE("*DlgProxy*")

    BROWSER_LOG( ( _L( "  Multiple CBrowserDialogsProviderProxy UP" ) ) );

PERFLOG_STOPWATCH_START

    iSoftkeysObserver = CBrowserSoftkeysObserver::NewL( *this );

    BROWSER_LOG( ( _L( "  Multiple SoftkeyObserver up" ) ) );

PERFLOG_STOP_WRITE("*SoftKeyObs*")

PERFLOG_STOPWATCH_START    

    iSpecialLoadObserver = CBrowserSpecialLoadObserver::NewL( 

        *this, this, CBrowserAppUi::Static()->Document(), cv );

PERFLOG_STOP_WRITE("*SoftKeyObs*")

    BROWSER_LOG( ( _L( "  Multiple SpecialLoadObserver up" ) ) );

    TInt autoLaunch( TBrCtlDefs::ECapabilityLaunchViewer );

    CBrowserAppDocument* doc = STATIC_CAST( CBrowserAppDocument*,

        CBrowserAppUi::Static()->Document() );

    if( doc->IsContentHandlerRegistered() )

        {

        autoLaunch = 0;

        }                                                                  

PERFLOG_STOPWATCH_START

	TUint capabilityFlags = ( TBrCtlDefs::ECapabilityLoadHttpFw |

        TBrCtlDefs::ECapabilityDisplayScrollBar |

        TBrCtlDefs::ECapabilityConfirmDownloads | 

        TBrCtlDefs::ECapabilitySavedPage |

        TBrCtlDefs::ECapabilityUseDlMgr |

        TBrCtlDefs::ECapabilityCursorNavigation |

		TBrCtlDefs::ECapabilityFavicon |

        TBrCtlDefs::ECapabilityToolBar |

        TBrCtlDefs::ECapabilityFitToScreen |

        TBrCtlDefs::ECapabilityPinchZoom |  

        autoLaunch );

	if ( Preferences().UiLocalFeatureSupported( KBrowserGraphicalPage ))

		{

		capabilityFlags = capabilityFlags | TBrCtlDefs::ECapabilityGraphicalPage;

		}

		capabilityFlags = capabilityFlags | TBrCtlDefs::ECapabilityGraphicalHistory;

		}

	if ( Preferences().UiLocalFeatureSupported( KBrowserAutoFormFill ) )

		{

		capabilityFlags = capabilityFlags | TBrCtlDefs::ECapabilityAutoFormFill;

		}

    if (Preferences().AccessKeys())

		{

		capabilityFlags = capabilityFlags | TBrCtlDefs::ECapabilityAccessKeys;

		}

    iBrCtlInterface = CreateBrowserControlL(

        (CCoeControl*)cv->Container(),      // parent control

        rect,                               // client rect

        capabilityFlags,                    // capabilities

        (TUint)TBrCtlDefs::ECommandIdBase,    // command base

        iSoftkeysObserver,

        (MBrCtlLinkResolver*)NULL,            // LinkResolver

        iSpecialLoadObserver,

        (MBrCtlLayoutObserver*)NULL,          // Layout Observer

        iDialogsProviderProxy,

        this                                  // Window Observer

        );

    BROWSER_LOG( ( _L( "  Multiple Plugin Br Control up, Kimono." ) ) );

    iBrCtlInterface->SetBrowserSettingL(TBrCtlDefs::ESettingsLaunchAppUid, KUidBrowserApplication.iUid);

    iBrCtlInterface->SetBrowserSettingL(TBrCtlDefs::ESettingsLaunchViewId, KUidBrowserBookmarksViewId.iUid);

    iBrCtlInterface->SetBrowserSettingL(TBrCtlDefs::ESettingsLaunchCustomMessageId, KUidCustomMsgDownloadsList.iUid );

    BROWSER_LOG( ( _L( "  LaunchSettings are passed." ) ) );

#if defined( __RSS_FEEDS )

    TPtrC rssMimeTypes = api->FeedsClientUtilities().SupportedMimeTypesL();

    BROWSER_LOG( ( _L( "  rss SupportedMimeTypes OK" ) ) );

    TPtrC selfDownloadContentTypes = api->Preferences().SelfDownloadContentTypesL();

    BROWSER_LOG( ( _L( "  SelfDownloadContentTypesL OK" ) ) );

    HBufC* buf = HBufC::NewLC(

        rssMimeTypes.Length() + selfDownloadContentTypes.Length() + 2 );

    TPtr ptr( buf->Des() );

    ptr.Append( rssMimeTypes );

    ptr.Append( TChar(';') );

    ptr.Append( selfDownloadContentTypes );

    ptr.ZeroTerminate();

    iBrCtlInterface->SetSelfDownloadContentTypesL( ptr );

    CleanupStack::PopAndDestroy();  // buf

#else  // __RSS_FEEDS

    TPtrC selfDownloadContentTypes = api->Preferences().SelfDownloadContentTypesL();

    BROWSER_LOG( ( _L( "  SelfDownloadContentTypesL OK" ) ) );

    iBrCtlInterface->SetSelfDownloadContentTypesL( selfDownloadContentTypes );

#endif  // __RSS_FEEDS

    BROWSER_LOG( ( _L( "  SetSelfDownloadContentTypesL") ) );

    iBrCtlInterface->AddLoadEventObserverL( iLoadObserver );

    BROWSER_LOG( ( _L( "  AddLoadEventObserverL") ) );

    iBrCtlInterface->AddStateChangeObserverL( cv );

    BROWSER_LOG( ( _L( "  AddStateChangeObserverL") ) );

    iBrCtlInterface->AddCommandObserverL( cv );

    BROWSER_LOG( ( _L( "  AddCommandObserverL") ) );

    // Window is not added as PreferencesObserver,

    // this message flow is controlled by the WindowManager.

    // Each window needs to notify its Browser Control of the settings

PERFLOG_STOP_WRITE("***BctlItem creation***")

PERFLOG_STOPWATCH_START    

    InitialiseLocalPreferencesL();

    UpdateBrCtlSettingsL();

PERFLOG_STOP_WRITE("***BrowserCtl Settings update***")

    CleanupStack::Pop( api );

    iIsPageOverviewOn = iWindowManager->ApiProvider()->Preferences().PageOverview();

    }

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

// CBrowserWindow::OpenWindowL()

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

//

CBrCtlInterface* CBrowserWindow::OpenWindowL(

        TDesC& /* aUrl */, TDesC* aTargetName,

        TBool aUserInitiated, TAny* /* aReserved */ )

    {

    // do not create new window when the browser is being closed

    if( iClosing )

        {

        return NULL;

        }

LOG_ENTERFN("CBrowserWindow::OpenWindowL, OSS");

	// Do not exceed the maximum number of windows allowed

	if ( iWindowManager->WindowCount() == 

	     iWindowManager->MaxWindowCount() )

	    {

	    // Show warning to user

	  	TBrowserDialogs::ErrorNoteL( R_BROWSER_NOTE_MAX_WINDOWS );

        return NULL;

	    }

	CBrCtlInterface* retVal( NULL );

	TBool loadUrl( EFalse );    // allow fetching of url

	CBrowserPopupEngine* popup = &( iWindowManager->ApiProvider()->PopupEngine() );

	// embedded mode doesn't allow multiple windows feature, hence popup object is NULL

	if (!popup) {

		return retVal;

	}

    HBufC* url = BrCtlInterface().PageInfoLC( TBrCtlDefs::EPageInfoUrl );

	if(!url)

	{

		//The url is already pushed on to the cleanup stack and we have the ownership of it. Pop it.

		CleanupStack::Pop(url);

		return NULL;

	}

	TPtrC ptr( url->Des() );

	// Check if on the whitelist, if not a user initiated open

	// or if pop-up blocking has been disabled

	if ( !( iWindowManager->ApiProvider()->Preferences().PopupBlocking() ) ||

            popup->IsUrlOnWhiteListL( ptr ) || 

            aUserInitiated )

		{		

	   	loadUrl = ETrue;    // OK to fetch the URL

	   	}	   	

    else

        {

        // Notify user that popup was blocked        

        HBufC* popupBlocked = StringLoader::LoadLC( 

                                            R_BROWSER_NOTE_POPUP_BLOCKED );

	  	iWindowManager->ApiProvider()->

	  	            DialogsProvider().ShowTooltipL( *popupBlocked );

	  	CleanupStack::PopAndDestroy( popupBlocked );

        }

    CleanupStack::PopAndDestroy( url );

	if ( loadUrl )

		{

	    // Open a new popup window

	    CBrowserWindow* window = iWindowManager->CreateWindowL( 

	        WindowId(), aTargetName );

	    if (window == NULL)

    	    {

            return retVal;

    	    }

        retVal = & ( window->BrCtlInterface() );

        // do not initiate load, it does by the engine automatically

        // aUrl is empty / NULL

	    // Indicate to the user that a new window is being opened

	    HBufC* newWindow = StringLoader::LoadLC( R_BROWSER_NEW_WINDOW_OPENED );

	  	iWindowManager->ApiProvider()->DialogsProvider().

            ShowTooltipL( *newWindow );

	  	CleanupStack::PopAndDestroy( newWindow );

	    }

    return retVal;

    }

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

// CBrowserWindow::FindWindowL()

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

//

CBrCtlInterface* CBrowserWindow::FindWindowL( const TDesC& aTargetName ) const

    {

    CBrowserWindow* window = iWindowManager->FindWindowL( aTargetName );

    if( window )

        return & ( window->BrCtlInterface() );

    else

        return NULL;

    }

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

// CBrowserWindow::HandleWindowCommandL()

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

//

void CBrowserWindow::HandleWindowCommandL(

        const TDesC& aTargetName,

        TBrCtlWindowCommand aCommand )

    {

LOG_ENTERFN("CBrowserWindow::HandleWindowCommandL");

BROWSER_LOG( ( _L( "window Id: %d, aCommand: %d" ), WindowId(), aCommand ) );

    // KNullDesC() refers to the current window

    // I am NOT that targetwindow

    if( aTargetName != KNullDesC() &&  iTargetName->Compare( aTargetName ) != 0 )

        {

        // try to find that window 

        CBrowserWindow* window = iWindowManager->FindWindowL( aTargetName );

        if( window )

            {

            window->HandleWindowCommandL( aTargetName, aCommand );

            }

        else

            {

            // no window with that name

            }

        }

    else  // I am that targetwindow

        {

        switch( aCommand )

            {

            case EShowWindow:  // to activate a window after creating it

            case EFocusWindow:  // window.focus or reload

                // focusing this window

                {

                // 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

                if (iFirstPage)

	            	{

	            	BrCtlInterface().HandleCommandL((TInt)TBrCtlDefs::ECommandClearHistory + (TInt)TBrCtlDefs::ECommandIdBase);

	            	iFirstPage = EFalse;

	            	}

				iWindowManager->SwitchWindowL( WindowId() );

                break;

                }

            case EUnfocusWindow:  // focusing the last active window

                {

                // iWindowManager->SwitchWindowL( );

                break;

                }

            case ECloseWindow:

                {

                CBrowserAppUi::Static()->CloseWindowL( WindowId() );

                break;

                }

//            case EDisableScriptLog:

//                iWindowManager->ApiProvider()->Preferences().SetScriptLogL( TBrCtlDefs::EScriptLogDisable );

//                break;

            default:

                {

                break;

                }

            }

        }

    }

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

// CBrowserWindow::IsPageOverviewSupported

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

// 

TBool CBrowserWindow::IsPageOverviewSupportedL() 

    {

    if(!iIsPageOverviewSupportQueried)

        {

        iIsPageOverviewSupported = iBrCtlInterface->BrowserSettingL(

            TBrCtlDefs::ESettingsPageOverview );

        iIsPageOverviewSupportQueried = ETrue;                

        }

    return iIsPageOverviewSupported;    

    }

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

// CBrowserWindow::ResetPageOverviewLocalSettingL()

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

//	

void CBrowserWindow::ResetPageOverviewLocalSettingL()

    {

    iIsPageOverviewOn = 

        iWindowManager->ApiProvider()->Preferences().PageOverview();

    BrCtlInterface().SetBrowserSettingL(TBrCtlDefs::ESettingsPageOverview,

                                        iIsPageOverviewOn );

    }        

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

// CBrowserWindow::ChangeTitlePaneTextUntilL()

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

//	

void CBrowserWindow::ChangeTitlePaneTextUntilL(

        const TDesC& aTitle, TInt /* aInterval */ )

    {