/*

* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:   Implementation of the Browser Control

*

*/

// INCLUDE FILES

#include <browser_platform_variant.hrh>

#include <../bidi.h>

#include <avkon.hrh>

#include <apmrec.h>

#include <apgcli.h>

#include <badesca.h>

#include <bautils.h>

#include <StringLoader.h>

#include <AknUtils.h>

#if defined(__BROWSER_SDK)

#include <webkit_sdk.rsg>

#else

#include <Webkit.rsg>

#endif

#include <GULICON.h>

#include <e32uid.h>

#include <browserdialogsprovider.h>

//tot:fixme

//#include "oom.h"

#include "config.h"

#include "BrCtl.h"

#include "WebView.h"

#include "WebFrame.h"

#include "WebFrameView.h"

#include "WebDataLoadConsumer.h"

#include "WebFormFillPopup.h"

#include "WebPageFullScreenHandler.h"

#include "PageScaler.h"

#include "HistoryController.h"

#include "HistoryEntry.h"

#include "HistoryInterface.h"

#include "HistoryView.h"

#include "FormData.h"

#include "data_caging_path_literals.hrh"

#include "StaticObjectsContainer.h"

#include "WebIconDatabase.h"

#include "ResourceRequest.h"

#include "FormFillController.h"

#include "SettingsContainer.h"

#include "Frame.h"

#include "FrameTree.h"

#include "FrameLoader.h"

#include "DocumentLoader.h"

#include "HTMLInputElement.h"

#include "Document.h"

#include "DocLoader.h"

#include "Node.h"

#include "Element.h"

#include "WebCursor.h"

#include "WebUtil.h"

#include "WebCharsetData.h"

#include "httpcachemanager.h"

#include "ResourceLoaderDelegate.h"

#include "EventHandler.h"

#include "timer.h"

#include "page.h"

#include "range.h"

#include "focusController.h"

#include "IconDatabase.h"

#include "httpDownload.h"

#include "BrCtlSoftkeysObserverImpl.h"

#include "BrCtlSpecialLoadObserverImpl.h"

#include "BrCtlLayoutObserverImpl.h"

#include "BrCtlWindowObserverImpl.h"

#include "WidgetExtension.h"

#include "PluginSkin.h"

#include "HttpUiCallbacks.h"

#include "PluginWin.h"

#include <BrowserVersion.h>

#include <cuseragent.h>

#ifndef BRDO_WML_DISABLED_FF

#include "wmlinterface.h"

#include "WmlInterfaceImpl.h"

#include "WmlEngineInterface.h"

#endif

#include "WmlDispatcher.h"

#ifndef BRDO_WML_DISABLED_FF

class CWmlContentInterface;

#endif

class TBrCtlWmlServiceOption;

const TUint KMinimumHeight = 20;

const TUint KMinimumWidth  = 20;

const TRgb KGray = TRgb(150, 150, 180);

const TRgb KDarkGray = TRgb(90, 90, 150);

const TRgb KBlack = TRgb(0x00, 0x00, 0x00);

const TRgb KWhite = TRgb(0xff, 0xff, 0xff);

const TInt KForward = 1;

const TInt KBack = -1;

_LIT( KDriveZ, "Z:");

typedef struct

{

    TBrCtlDefs::TBrCtlElementType iFocusedElementType;

    TInt iCommandId;

    TInt iResourceId;

} TCommandsArray;

static const TCommandsArray commandsArray[] =

    {

    {TBrCtlDefs::EElementFileSelectionBoxWithContent, TBrCtlDefs::ECommandRemoveFileName, R_TEXT_WML_LIST_REMOVE_FILE}

    };

using namespace WebCore;

void BrCtlPanic(TInt aError = KErrGeneral)

{

    User::Panic(_L("BrowserControl Panic"), aError);

}

TBrCtlWmlServiceOption::TBrCtlWmlServiceOption(HBufC* aText, TUint aElemID, TUint aActualElemID)

        : iText(aText), iElemID(aElemID), iActualElemID(aActualElemID)

{

}

TBrCtlWmlServiceOption::~TBrCtlWmlServiceOption()

{

    delete iText;

}

CCoeControl* HistoryHandler::parent()

{

    return m_brctl;

}

HistoryHandler* HistoryHandler::initWithHandle(CBrCtl* brctl)

{

    HistoryHandler* self = new HistoryHandler(brctl);

    if (self) {

        self->m_historyController = HistoryController::initWithCallback( self,

            self->m_brctl->capabilities() & TBrCtlDefs::ECapabilityGraphicalHistory, false);

    }

    return self;

}

HistoryHandler::~HistoryHandler()

{

    delete m_historyController;

}

void HistoryHandler::updateGlobalHistoryForStandardLoad(const TPtrC8& url, const TPtrC8& requestUrl,

        TPtrC& formContentType, WebCore::FormData* formData)

{

    m_historyController->insert(url, requestUrl, formContentType, formData);

}

void HistoryHandler::setCurrentEntryTitle(TPtrC title)

{

    m_historyController->setCurrentEntryTitle(title);

}

void HistoryHandler::updateGlobalHistoryForReload ()

{

    m_historyController->updateGlobalHistoryForReload();

}

TPoint HistoryHandler::currentPosition()

{

    return m_brctl->webView()->mainFrame()->frameView()->contentPos();

}

int HistoryHandler::currentZoomLevel()

{

    return m_brctl->webView()->scalingFactor();

}

int HistoryHandler::minZoomLevel()

{

    return m_brctl->webView()->minZoomLevel();

}

bool HistoryHandler::wmlMode()

{

    return m_brctl->wmlMode();

}

void HistoryHandler::setWmlMode(bool aWml)

{

    m_brctl->setWmlMode(aWml);

}

void HistoryHandler::doHistoryGet(TPtrC8 url, TBrCtlDefs::TBrCtlCacheMode cacheMode)

{

    m_brctl->webView()->setHistoryLoad(true);

    m_brctl->webView()->mainFrame()->loadURL(url, cacheMode, String());

}

int HistoryHandler::doHistoryPost(TPtrC8 url, TBrCtlDefs::TBrCtlCacheMode cacheMode,

                                   TPtrC contentType, WebCore::FormData* formData)

{

    ResourceRequestCachePolicy cachePolicy = ReturnCacheDataElseLoad;

    if (cacheMode == TBrCtlDefs::ECacheModeNoCache) {

        cachePolicy = ReloadIgnoringCacheData;

    }

    int ret = StaticObjectsContainer::instance()->resourceLoaderDelegate()->httpSessionManager()->uiCallback()->aboutToLoadPage(m_brctl, HttpUiCallbacks::ERepostConfirmation);

    if (ret == KErrNone) {

        ResourceRequest request = (KURL(url));

        request.setMainLoad(true);

        request.setCachePolicy(cachePolicy);

        request.setHTTPMethod("POST");

        request.setHTTPContentType(contentType);

        request.setHTTPBody(formData);

        m_brctl->webView()->setHistoryLoad(true);

        m_brctl->webView()->mainFrame()->loadRequest(request);

    }

    return ret;

}

void HistoryHandler::stateChanged(bool enter)

{

    m_brctl->reportStateChanged(TBrCtlDefs::EStateHistoryView, enter);

}

void HistoryHandler::navigationStateChanged(TBrCtlDefs::TBrCtlState state, bool value)

{

    m_brctl->reportStateChanged(state, value);

}

CFbsBitmap* HistoryHandler::scaledPage()

{   

    CFbsBitmap* scaledPage = NULL;   

    if ( m_brctl->wmlMode() && &m_brctl->wmlPageScaler() ) {

        scaledPage = m_brctl->wmlPageScaler().ScaledPage();

    }

    else if( !m_brctl->wmlMode() && m_brctl->webView()->pageScaler() ) {

        scaledPage = m_brctl->webView()->pageScaler()->ScaledPage();

    }

    return scaledPage;    

}

void HistoryHandler::makeVisible(bool visible)

{

    if(wmlMode()) {

#ifndef BRDO_WML_DISABLED_FF

        m_brctl->wmlEngineInterface()->MakeVisible( visible );

#endif

    }

    else {

        m_brctl->webView()->MakeVisible( visible );

    }

}

void CBrCtl::updateScrollbars(int documentHeight, int displayHeight, int displayPosY,

                int documentWidth, int displayWidth, int displayPosX)

{

  if (!AknLayoutUtils::PenEnabled()) {

    m_documentHeight = documentHeight;

    m_displayHeight = displayHeight;

    m_displayPosY = displayPosY;

    m_documentWidth = documentWidth;

    m_displayWidth = displayWidth;

    m_displayPosX = displayPosX;

    if (displayWidth < documentWidth) {

        // add scrollbar if needed

        if (!m_hasHorizontalScrollbar) {

            m_hasHorizontalScrollbar = true;

            showHorizontalScrollbar(true);

        }

    }

    else {

        // remove scrollbar if not needed

        if (m_hasHorizontalScrollbar) {

            m_hasHorizontalScrollbar = false;

            showHorizontalScrollbar(false);

        }

    }

  }

}

void CBrCtl::Draw(const TRect& aRect) const

{

}

WebSurface* HistoryHandler::surface()

{

    return StaticObjectsContainer::instance()->webSurface();

}

void HistoryHandler::handleWmlBackL()

{

#ifndef BRDO_WML_DISABLED_FF

    // tot:fixme

  // First check if back should be handled by a DO element

  if ( m_brctl->firstPrevDoElement() )

    {

    m_brctl->wmlEngineInterface()->HandleDo( m_brctl->firstPrevDoElement()->ActualElemID() );

    }

  else

    {

    m_brctl->wmlEngineInterface()->ProcessBack();

    }

#endif

}

bool HistoryHandler::dialogSelectOption(SelectArray* historyList)

{

    HBufC* title = StringLoader::LoadLC( R_HISTORY_POPUP_HEADING_PANE );

    // Display history dialog

    TBool ret( m_brctl->brCtlDialogsProvider()->DialogSelectOptionL(*title, ESelectTypeNone, *historyList));

    CleanupStack::PopAndDestroy(); // title

    return ret;

}

void HistoryHandler::setUse(bool use, WebCore::FormData* formData)

{

    if (use) {

        formData->ref();

    }

    else {

        formData->deref();

    }

}

void HistoryHandler::deferTimers(bool option)

{

    setDeferringTimers(option);

}

TBrCtlSubscribeTo::TBrCtlSubscribeTo(const TPtrC& aTitle, const TPtrC& aUrl,

        TUint aCommandID)

        : iTitle(aTitle), iUrl(aUrl), iCommandID(aCommandID)

    {

    }

TBrCtlSubscribeTo::TBrCtlSubscribeTo()

: iTitle(KNullDesC()), iUrl(KNullDesC()), iCommandID(0)

    {

    }

// ============================ MEMBER FUNCTIONS ===============================

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

// CBrCtl::NewL

// Two-phased constructor.

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

//

CBrCtlInterface* CBrCtl::NewL(

  CCoeControl* aParent,

    TRect aRect,

    TUint aBrCtlCapabilities,

    TUint aCommandIdBase,

    MBrCtlSoftkeysObserver* aBrCtlSoftkeysObserver,

    MBrCtlLinkResolver* aBrCtlLinkResolver,

    MBrCtlSpecialLoadObserver* aBrCtlSpecialLoadObserver,

    MBrCtlLayoutObserver* aBrCtlLayoutObserver,

    MBrCtlDialogsProvider* aBrCtlDialogsProvider,

    MBrCtlWindowObserver* aBrCtlWindowObserver,

    MBrCtlDownloadObserver* aBrCtlDownloadObserver )

{

    CBrCtl* self = new (ELeave) CBrCtl(aParent,

                                       aBrCtlCapabilities,

                                       aCommandIdBase,

                                       aBrCtlSoftkeysObserver,

                                       aBrCtlLinkResolver,

                                       aBrCtlSpecialLoadObserver,

                                       aBrCtlLayoutObserver,

                                       aBrCtlDialogsProvider,

                                       aBrCtlWindowObserver,

                                       aBrCtlDownloadObserver );

    CleanupStack::PushL(self);

    self->ConstructL(aParent, aRect);

    CleanupStack::Pop(); //self

    return self;

}

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

// CBrCtl::CBrCtl

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CBrCtl::CBrCtl(

  CCoeControl* aParent,

  TUint aBrCtlCapabilities,

  TUint aCommandIdBase,

  MBrCtlSoftkeysObserver* aBrCtlSoftkeysObserver,

  MBrCtlLinkResolver* aBrCtlLinkResolver,

  MBrCtlSpecialLoadObserver* aBrCtlSpecialLoadObserver,

  MBrCtlLayoutObserver* aBrCtlLayoutObserver,

    MBrCtlDialogsProvider* aBrCtlDialogsProvider,

    MBrCtlWindowObserver* aBrCtlWindowObserver,

    MBrCtlDownloadObserver* aBrCtlDownloadObserver )

   : m_coectrlparent(aParent)

   , m_brCtlSpecialLoadObserver(aBrCtlSpecialLoadObserver)

   , m_brCtlLinkResolver(aBrCtlLinkResolver)

   , m_brCtlDialogsProvider(aBrCtlDialogsProvider)

   , m_brCtlWindowObserver(aBrCtlWindowObserver)

   , m_brCtlSoftkeysObserver(aBrCtlSoftkeysObserver)

   , m_brCtlLayoutObserver(aBrCtlLayoutObserver)

   , m_commandIdBase(aCommandIdBase)

   , m_capabilities(aBrCtlCapabilities)

   , m_suspendTimers(false)

   , m_pageLoadFinished(false)

   , m_wmlEngineInterface(NULL)

   , m_brCtlDownloadObserver(aBrCtlDownloadObserver)

   , m_windoCloseTimer(NULL)

{

    m_documentHeight = 0;

    m_displayHeight = 0;

    m_displayPosY = 0;

    m_documentWidth = 0;

    m_displayWidth = 0;

    m_displayPosX = 0;

    m_hasHorizontalScrollbar = false;

    m_ownsSpecialLoadObserver = false;

    m_ownsSoftkeysObserver = false;    

    m_ownsLayoutObserver = false;

    m_ownsDialogsProvider = false;

    m_ownsWindowObserver = false;

}

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

// CBrCtl::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CBrCtl::ConstructL(

    CCoeControl* aParent,

    TRect& aRect)

{

    IconDatabase::delayDatabaseCleanup();

    // and enable cleanup

    m_timer = CPeriodic::NewL(CActive::EPriorityIdle);

    m_timer->Start(20000, 0, TCallBack(&doEnableFaviconCb,this));

    //

    StaticObjectsContainer::instance()->ref(*this);

    StaticObjectsContainer::instance()->setCapabilities(m_capabilities);

    StaticObjectsContainer::instance()->sharedIconDatabase();

    SetContainerWindowL( *aParent );

    m_rect = aRect;

    m_webView = WebView::NewL(*aParent, this);

    m_historyHandler = HistoryHandler::initWithHandle(this);

    m_settingsContainer = new (ELeave) SettingsContainer(m_webView, m_historyHandler->historyController());

    m_settingsContainer->setNavigationType((capabilities()&TBrCtlDefs::ECapabilityCursorNavigation) ? SettingsContainer::NavigationTypeCursor : SettingsContainer::NavigationTypeTabbed);

    m_usrAgnt = CUserAgent::NewL();

    // Create and initialize the Special Load Observer

    if (m_brCtlSpecialLoadObserver == NULL)

        {

        m_brCtlSpecialLoadObserver = new (ELeave) CBrCtlSpecialLoadObserver();

        m_ownsSpecialLoadObserver = true;

        }

    // Setup default support, if it wasn't passed into the constructor...

    // Create and initialize the Softkey Observer

    if (m_brCtlSoftkeysObserver == NULL)

        {

        m_brCtlSoftkeysObserver = new (ELeave) CBrCtlSoftkeysObserver();

        m_ownsSoftkeysObserver = true;

        }

    // Create and initialize the Layout Observer

    if (m_brCtlLayoutObserver == NULL)

        {

        m_brCtlLayoutObserver = new (ELeave) CBrCtlLayoutObserver();

        m_ownsLayoutObserver = true;

        }

    // Create and initialize the Dialog Provider

    if (m_brCtlDialogsProvider == NULL)

        {

        m_brCtlDialogsProvider = CBrowserDialogsProvider::NewL(NULL);

        m_ownsDialogsProvider = true;

        }

  // window observer

    if(m_brCtlWindowObserver == NULL)

        {

        m_brCtlWindowObserver = new (ELeave) CBrCtlWindowObserver();

        m_ownsWindowObserver = true;

        }

    LoadResourceFileL();

    MemoryManager::InitOOMDialog();

    // Set the rect for BrowserControl (a CCoeControl).

    SetRect(aRect);

    CCoeEnv::Static()->DisableExitChecks(true);

    Window().AllocPointerMoveBuffer(256, 0);

    Window().DisablePointerMoveBuffer();

    Window().PointerFilter(EPointerFilterMove | EPointerFilterDrag | EPointerFilterEnterExit, 0);

    ActivateL();

}

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

// CBrCtl::~CBrCtl

// Destructor

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

//

EXPORT_C CBrCtl::~CBrCtl()

{

    iLoadEventObserversArray.Close();

    iLoadEventObserversArray.Close();

    m_stateChangeObserverArray.Close();

    m_commandObserverArray.Close();

    m_subscribeToItems.ResetAndDestroy();