/*

* 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 "BrCtlLayoutObserverImpl.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 = m_brctl->wmlMode() ? m_brctl->wmlPageScaler().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

{

    if (m_webView->isPluginFullscreen()) return; //don't draw if in plugin fullscreen mode

    if (!(m_capabilities & TBrCtlDefs::ECapabilityDisplayScrollBar) ||

        AknLayoutUtils::PenEnabled()) { //touch screen scrollbar is drawn

        return;                         //by WebScrollbarDrawer

    }

    CWindowGc& gc = SystemGc();

    TRect rect(Rect());

    int documentHeight = (m_displayHeight > m_documentHeight) ? m_displayHeight : m_documentHeight;

    int documentWidth = (m_displayWidth > m_documentWidth) ? m_displayWidth : m_documentWidth;

    gc.SetDrawMode(CGraphicsContext::EDrawModePEN);

    if (AknLayoutUtils::LayoutMirrored()) {

        // rtl

        if (m_hasHorizontalScrollbar) {

            TRect vertical(0, 0, KMainScrollbarWidth, rect.Height() - KMainScrollbarWidth);

            TRect horizontal(KMainScrollbarWidth, rect.Height() - KMainScrollbarWidth, rect.Width(), rect.Height());

            TRect verticalThumb(0, (m_displayPosY * m_displayHeight) / documentHeight,

                KMainScrollbarWidth, (m_displayPosY * m_displayHeight + m_displayHeight * m_displayHeight) / documentHeight);

            TRect horizontalThumb(KMainScrollbarWidth + (m_displayPosX * m_displayWidth) / documentWidth, rect.Height() - KMainScrollbarWidth,

                KMainScrollbarWidth + (m_displayPosX * m_displayWidth + m_displayWidth * m_displayWidth) / documentWidth, rect.Height());

            TRect corner(0, rect.Height() - KMainScrollbarWidth, KMainScrollbarWidth, rect.Height());

            vertical.Intersection(aRect);

            horizontal.Intersection(aRect);

            if (!(vertical.IsEmpty() || horizontal.IsEmpty())) {

                gc.SetBrushStyle(CGraphicsContext::ESolidBrush);

                gc.SetBrushColor(KGray);

                gc.SetPenStyle(CGraphicsContext::ESolidPen);

                gc.SetPenSize(TSize(1, 1));

                gc.SetPenColor(KBlack);

                gc.DrawRect(vertical);

                gc.DrawRect(horizontal);

                gc.SetBrushColor(KDarkGray);

                gc.DrawRect(verticalThumb);

                gc.DrawRect(horizontalThumb);

                gc.SetBrushColor(KWhite);

                gc.SetPenColor(KWhite);

                gc.DrawRect(corner);

            }

        }

        else {

            TRect vertical(0, 0, KMainScrollbarWidth, rect.Height());

            TRect verticalThumb(0, (m_displayPosY * m_displayHeight) / documentHeight,

                KMainScrollbarWidth, (m_displayPosY * m_displayHeight + m_displayHeight * m_displayHeight) / documentHeight);

            vertical.Intersection(aRect);

            if (!vertical.IsEmpty()) {

                gc.SetBrushStyle(CGraphicsContext::ESolidBrush);

                gc.SetBrushColor(KGray);

                gc.SetPenStyle(CGraphicsContext::ESolidPen);

                gc.SetPenSize(TSize(1, 1));

                gc.SetPenColor(KBlack);

                gc.DrawRect(vertical);

                gc.SetBrushColor(KDarkGray);

                gc.DrawRect(verticalThumb);

            }

        }

    }

    else {

        // ltr

        if (m_hasHorizontalScrollbar) {

            TRect vertical(rect.Width() - KMainScrollbarWidth, 0, rect.Width(), rect.Height() - KMainScrollbarWidth);

            TRect horizontal(0, rect.Height() - KMainScrollbarWidth, rect.Width() - KMainScrollbarWidth, rect.Height());

            TRect verticalThumb(rect.Width() - KMainScrollbarWidth, (m_displayPosY * m_displayHeight) / documentHeight,

                rect.Width(), (m_displayPosY * m_displayHeight + m_displayHeight * m_displayHeight) / documentHeight);

            TRect horizontalThumb((m_displayPosX * m_displayWidth) / documentWidth, rect.Height() - KMainScrollbarWidth,

                (m_displayPosX * m_displayWidth + m_displayWidth * m_displayWidth) / documentWidth, rect.Height());

            TRect corner(rect.Width() - KMainScrollbarWidth, rect.Height() - KMainScrollbarWidth, rect.Width(), rect.Height());

            vertical.Intersection(aRect);

            horizontal.Intersection(aRect);

            if (!(vertical.IsEmpty() || horizontal.IsEmpty())) {

                gc.SetBrushStyle(CGraphicsContext::ESolidBrush);

                gc.SetBrushColor(KGray);

                gc.SetPenStyle(CGraphicsContext::ESolidPen);

                gc.SetPenSize(TSize(1, 1));

                gc.SetPenColor(KBlack);

                gc.DrawRect(vertical);

                gc.DrawRect(horizontal);

                gc.SetBrushColor(KDarkGray);

                gc.DrawRect(verticalThumb);

                gc.DrawRect(horizontalThumb);

                gc.SetBrushColor(KWhite);

                gc.SetPenColor(KWhite);

                gc.DrawRect(corner);

            }

        }

        else

        {

            TRect vertical(rect.Width() - KMainScrollbarWidth, 0, rect.Width(), rect.Height());

            TRect verticalThumb(rect.Width() - KMainScrollbarWidth, (m_displayPosY * m_displayHeight) / documentHeight,

                rect.Width(), (m_displayPosY * m_displayHeight + m_displayHeight * m_displayHeight) / documentHeight);

            vertical.Intersection(aRect);

            if (!vertical.IsEmpty()) {

                gc.SetBrushStyle(CGraphicsContext::ESolidBrush);

                gc.SetBrushColor(KGray);

                gc.SetPenStyle(CGraphicsContext::ESolidPen);

                gc.SetPenSize(TSize(1, 1));

                gc.SetPenColor(KBlack);

                gc.DrawRect(vertical);

                gc.SetBrushColor(KDarkGray);

                gc.DrawRect(verticalThumb);

            }

        }

    }

}

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_wmlEngineInterface(NULL)

   , m_brCtlDownloadObserver(aBrCtlDownloadObserver)

{

    m_documentHeight = 0;

    m_displayHeight = 0;

    m_displayPosY = 0;

    m_documentWidth = 0;

    m_displayWidth = 0;

    m_displayPosX = 0;

    m_hasHorizontalScrollbar = false;

    m_ownsLayoutObserver = false;

    m_ownsDialogsProvider = false;

}

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