/*

* Copyright (C) 2005, 2006, 2007 Apple Inc. All rights reserved.

* Copyright (C) 2006 David Smith (catfish.man@gmail.com)

* Copyright (C) 2007 Nokia

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions

* are met:

*

* 1.  Redistributions of source code must retain the above copyright

*     notice, this list of conditions and the following disclaimer.

* 2.  Redistributions in binary form must reproduce the above copyright

*     notice, this list of conditions and the following disclaimer in the

*     documentation and/or other materials provided with the distribution.

* 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of

*     its contributors may be used to endorse or promote products derived

*     from this software without specific prior written permission.

*

* THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY

* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

* DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY

* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

#include <browser_platform_variant.hrh>

#include "config.h"

#include "../../bidi.h"

#include "brctl.h"

#include "HistoryController.h"

#include "PageView.h"

#include "SettingsContainer.h"

#include "WebFrame.h"

#include "WebFrameBridge.h"

#include "WebFrameView.h"

#include "WebView.h"

#include "WebTabbedNavigation.h"

#include "WebChromeClient.h"

#include "WebCoreGraphicsContext.h"

#include "WebContextMenuClient.h"

#include "WebEditorClient.h"

#include "WebDragClient.h"

#include "WebFrameLoaderClient.h"

#include "WebInspectorClient.h"

#include "WebFepTextEditor.h"

#include "WebSurface.h"

#include "WebCursor.h"

#include "WebFormFill.h"

#include "WebFormFillPopup.h"

#include "WebToolBarInterface.h"

#include "WebPointerEventHandler.h"

#include "WebPageScrollHandler.h"

#include "WebPopupDrawer.h"

#include "PluginSkin.h"

#include "PluginWin.h"

#include "PluginPlayer.h"

#include "WebKitLogger.h"

#include "Page.h"

#include "Settings.h"

#include "Frame.h"

#include "FrameView.h"

#include "FrameTree.h"

#include "FrameLoader.h"

#include "HistoryItem.h"

#include "EventHandler.h"

#include "ResourceRequest.h"

#include "PlatformString.h"

#include "SelectionController.h"

#include "PlatformKeyboardEvent.h"

#include "PlatformScrollbar.h"

#include "DocumentLoader.h"

#include "StaticObjectsContainer.h"

#include "ToolBar.h"

#include "Document.h"

#include "FocusController.h"

#include "WebUtil.h"

#include "WidgetExtension.h"

#include "Cache.h"

#include "RenderWidget.h"

#include "HTMLNames.h"

#include "HTMLInputElement.h"

using namespace HTMLNames;

#include <AknUtils.h>

#include <cuseragent.h>

#include "WebPageZoomHandler.h"

#include "PlatformFontCache.h"

#include "WebPageFullScreenHandler.h"

#include "eikon.hrh"

#include "WebScrollbarDrawer.h"

#include "EventNames.h"

#include "Editor.h"

using namespace WebCore;

using namespace EventNames;

const int KRepaintDelayLoading = 500*1000; // dont do repaints more often than this during loading (0.5s)

const int KRepaintDelayComplete = 100*1000; // faster updates after load so dynamic scripts etc have better frame rate (0.1s)

const int KRepaintDelayNavNone = 70*1000;

const int KNormalScrollRange = 60;

const int KPanningStartSpeed = 30;

const int KPanningStartTime = 900;

const int KPanningPageScalerStart = 1300;

const int KPanningMaxSpeed = 90;

const int KPanningMaxTime = 3000;

const int KAllowSelection = 1;

const int KScalerVisibilityTime = 1100*1000; //1.1s

const int KCursorUpdateFrquency = 20*1000; // 20ms

const int KCursorInitialDelay = 200*1000;  // 200ms

const TKeyEvent KNullKeyEvent = {0,0,0,0};

const int KSmallPageScale = 13*13;    // if the area of page is less than 169% (130%*130%) of the viewport area, it's considered to be a small page

const int KZoomLevelDelta = 10; //set 10% for each increasment

const int KZoomLevelDefaultValue = 100;

const int KZoomLevelMaxValue = 200;

const int KZoomLevelMinValue = 10;

const int KZoomBgRectColor = 209;

const int KZoomDefaultLevel = 8; //100%

const int defaultCacheCapacity = 256 * 1024;

// LOCAL FUNCTION PROTOTYPES

TInt doRepaintCb( TAny* ptr );

TInt doFepCb( TAny* ptr );

static WebFrame* incrementFrame(WebFrame* curr, bool forward, bool wrapFlag)

{

    Frame* coreFrame = core(curr);

    return kit(forward

        ? coreFrame->tree()->traverseNextWithWrap(wrapFlag)

        : coreFrame->tree()->traversePreviousWithWrap(wrapFlag));

}

#define IS_UP_KEY(keyevent) ((keyevent.iCode == EKeyUpArrow) || (keyevent.iCode == EStdKeyUpArrow))

#define IS_DOWN_KEY(keyevent) ((keyevent.iCode == EStdKeyDevice12) || (keyevent.iCode == EKeyDownArrow) || (keyevent.iCode == EStdKeyDownArrow))

#define IS_RIGHT_KEY(keyevent) ((keyevent.iCode == EStdKeyDevice11) || (keyevent.iCode == EKeyRightArrow) || (keyevent.iCode == EStdKeyRightArrow))

#define IS_LEFT_KEY(keyevent) ((keyevent.iCode == EStdKeyDevice13) || (keyevent.iCode == EKeyLeftArrow) || (keyevent.iCode == EStdKeyLeftArrow))

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

// WebView::NewL

// Public Class Method

// Two-phased constructor.

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

WebView* WebView::NewL( CCoeControl& parent, CBrCtl* brctl )

{

    WebView* self = new (ELeave) WebView( brctl );

    CleanupStack::PushL( self );

    self->ConstructL( parent );

    CleanupStack::Pop(); // self

    return self;

}

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

// WebView::CWebKitView

// Private Class Method

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

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

WebView::WebView( CBrCtl* brctl ) :

m_brctl(brctl)

, m_isEditable(false)

, m_currentEventKey(KNullKeyEvent)

, m_currentEventCode(EEventNull)

, m_scrollingSpeed(KNormalScrollRange*KZoomLevelDefaultValue/100)

, m_focusedElementType(TBrCtlDefs::EElementNone)

, m_pageScaler(NULL)

, m_pageScalerEnabled(false)

, m_inFindState(false)

, m_pageView(NULL)

, m_savedCursorPosition(KInitialOffset, KInitialOffset)

, m_findKeyword(NULL)

, m_webFormFill(NULL)

, m_fepTimer(0)

, m_isClosing(false)

, m_widgetextension(0)

, m_userAgent(NULL)

, m_pageZoomHandler(NULL)

, m_currentZoomLevel(KZoomLevelDefaultValue)

, m_lastZoomLevel(KZoomLevelMinValue)

, m_maxZoomLevel(KZoomLevelMaxValue)

, m_minZoomLevel(KZoomLevelMinValue)

, m_defaultZoomLevel(KZoomLevelDefaultValue)

, m_pageFullScreenHandler(NULL)

, m_viewIsScrolling(false)

, m_ptrbuffer(0)

, m_showCursor(false)

, m_allowRepaints(true)

, m_prevEditMode(false)

, m_firedEvent(0)

, m_waitTimer(0)

{

}

WebView::~WebView()

{

    StaticObjectsContainer::instance()->webCursor()->stopTransparencyTimer();

    // the zoom handler is a client of WebView (also owned by

    // WebView--a circular dependency) so it must be deleted before

    // the WebView object is destroyed because in its destructor it

    // operates on the WebView object

    delete m_pageZoomHandler;

    m_pageZoomHandler = NULL;

    m_zoomLevelArray.Close();

    // prevent frameViews to access members when topView is

    // closing down.

    m_isClosing = true;

    m_page->setGroupName(String());

    if (m_fastScrollTimer)

        m_fastScrollTimer->Cancel();

    delete m_fastScrollTimer;

    delete [] m_ptrbuffer;

    delete m_repainttimer;

    delete m_webfeptexteditor;

    delete m_webcorecontext;

    delete m_bitmapdevice;

    delete m_page;

    delete m_pageScaler;

    delete m_pageView;

    delete m_webFormFill;

    delete m_toolbar;

    delete m_toolbarinterface;

    delete m_widgetextension;

    delete m_webpointerEventHandler;

    delete m_pageScrollHandler;

    delete m_pluginplayer;

    delete m_fepTimer;

    delete m_waitTimer;

    delete m_waiter;

    delete m_popupDrawer;

    delete m_tabbedNavigation;

    delete m_userAgent;

    delete m_pageFullScreenHandler;

    delete m_bridge;

    delete m_frameView;

}

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

// WebView::ConstructL

// Private Class Method

// Symbian 2nd phase constructor can leave.

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

void WebView::ConstructL( CCoeControl& parent )

{

    SetContainerWindowL(parent);

    CCoeControl::MakeVisible(ETrue);

    m_frameView = new WebFrameView();

    m_page = new Page(new WebChromeClient(this), new WebContextMenuClient(), new WebEditorClient(this), new WebDragClient(), new WebInspectorClient());

    m_page->backForwardList()->setCapacity(0);

    m_page->setGroupName("com.s60.browser");

    //

    WebCore::Settings* settings = m_page->settings();

    settings->setLoadsImagesAutomatically(true);

    settings->setJavaScriptEnabled(true);

    settings->setMinimumFontSize(7);

    settings->setMinimumLogicalFontSize(9);

    settings->setDefaultFontSize(12);

    settings->setDefaultFixedFontSize(12);

    settings->setPluginsEnabled(true);

    settings->setJavaScriptCanOpenWindowsAutomatically(true);

    settings->setPluginsEnabled(true);

    m_tabbedNavigation = new WebTabbedNavigation(this);

    m_bridge = new WebFrameBridge();

    m_bridge->initMainFrameWithPage(m_page, "", m_frameView);

    // Create and offscreen device and context

    m_bitmapdevice = CFbsBitmapDevice::NewL( StaticObjectsContainer::instance()->webSurface()->offscreenBitmap() );

    m_webcorecontext = WebCoreGraphicsContext::NewL( m_bitmapdevice, StaticObjectsContainer::instance()->webSurface()->offscreenBitmap(), mainFrame()->frameView());

    //

    m_repainttimer = CPeriodic::NewL(CActive::EPriorityHigh);

    m_webfeptexteditor = new CWebFepTextEditor(this);

    m_fastScrollTimer = CPeriodic::NewL(CActive::EPriorityHigh);

    m_dirtyZoomMode = false;

    m_currentZoomLevel = StaticObjectsContainer::instance()->fontCache()->fontZoomFactor();

    m_startZoomLevel = m_currentZoomLevel;

    m_pageZoomHandler = WebPageZoomHandler::NewL( *this );

    if ( brCtl()->capabilities()&TBrCtlDefs::ECapabilityFitToScreen ) {

        m_minZoomLevel = (KZoomLevelDefaultValue / m_pageZoomHandler->stepSize())*m_pageZoomHandler->stepSize();

        //could happen only if m_minZoomLevel < stepSize

        if (!m_minZoomLevel) m_minZoomLevel = m_pageZoomHandler->stepSize();

    }

    // construct the zoom array from the default level

    m_zoomLevelArray.Append(KZoomLevelDefaultValue);

    TInt toAddZoomLevel = KZoomLevelDefaultValue + KZoomLevelDefaultValue*KZoomLevelDelta/100;

    while (toAddZoomLevel <= m_maxZoomLevel)

        {

        // add the zoom level after default one

        m_zoomLevelArray.Append(toAddZoomLevel);

        toAddZoomLevel = toAddZoomLevel + toAddZoomLevel*KZoomLevelDelta/100;

        }

    // now go the minimum one

    toAddZoomLevel = KZoomLevelDefaultValue - KZoomLevelDefaultValue*KZoomLevelDelta/100;

    while (toAddZoomLevel >= m_minZoomLevel)

        {

        //add the zoom level after default one

        m_zoomLevelArray.Insert(toAddZoomLevel, 0);

        toAddZoomLevel = toAddZoomLevel - toAddZoomLevel*KZoomLevelDelta/100;

        }

    m_pageFullScreenHandler = WebPageFullScreenHandler::NewL( *this );

    if ( m_brctl->capabilities() & TBrCtlDefs::ECapabilityWebKitLite ) {

        m_pageScalerEnabled = false;

    }

    else  {

        initializePageScalerL();

        m_pageScalerEnabled = true;

    }

    if (m_brctl->capabilities() & TBrCtlDefs::ECapabilityAutoFormFill) {

        m_webFormFill = new WebFormFill(this);

    }

    // Create the PointerEventHandler

    m_ptrbuffer = new TPoint[256];

    m_webpointerEventHandler = WebPointerEventHandler::NewL(this);

    // Create the ScrollHandler

    m_pageScrollHandler = WebPageScrollHandler::NewL( *this );

    if (AknLayoutUtils::PenEnabled()) {

        DrawableWindow()->SetPointerGrab(ETrue);

        EnableDragEvents();

    }

    CUserAgent* usrAgnt = CUserAgent::NewL();

    CleanupStack::PushL( usrAgnt );

    HBufC8* userAgent8 = usrAgnt->UserAgentL();

    CleanupStack::PushL( userAgent8 );

    m_userAgent = HBufC::NewL(userAgent8->Length());

    m_userAgent->Des().Copy(userAgent8->Des());

    CleanupStack::PopAndDestroy(2); // userAgent8, usrAgnt

    MakeViewVisible(ETrue);

    m_isPluginsVisible=ETrue;

    CCoeControl::SetFocus(ETrue);

    cache()->setCapacities(0, 0, defaultCacheCapacity);

    m_waiter = new(ELeave) CActiveSchedulerWait();

}

void WebView::initializePageScalerL()

{

    TBool lowQuality = !( m_brctl->capabilities() & TBrCtlDefs::ECapabilityGraphicalHistory );

    m_pageScaler = CPageScaler::NewL( *this, EColor64K, lowQuality );

    m_pageScaler->SetVisible( EFalse );

    //update the minimap support info from page scaler

    m_pageScalerEnabled = (m_pageScaler->HasOverlaySupport());

}

void WebView::fepTimerFired(Timer<WebView>*)

{

    CCoeEnv::Static()->SimulateKeyEventL(m_keyevent, m_eventcode);

}

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

// WebView::Draw ( from CCoeControl )

// BitBlts the offscreen bitmap to the GraphicsContext

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

void WebView::Draw( const TRect& rect ) const

{

    if (StaticObjectsContainer::instance()->isPluginFullscreen()) return;

    CWindowGc& gc = SystemGc();

    CEikBorderedControl::Draw( rect );

    // put offscreen bitmap onto the screen

    if ( !m_dirtyZoomMode ) {

        StaticObjectsContainer::instance()->webSurface()->flip( Rect().iTl, gc );

        if (m_widgetextension){

            m_widgetextension->DrawTransition(gc,StaticObjectsContainer::instance()->webSurface()->offscreenBitmap());

        }

    }

    else {

        gc.DrawBitmap( m_destRectForZooming, StaticObjectsContainer::instance()->webSurface()->offscreenBitmap(), m_srcRectForZooming );

        if ( m_startZoomLevel > m_currentZoomLevel) {

            TRect rectLeft( TPoint( rect.iTl.iX + m_destRectForZooming.Width() - 2, rect.iTl.iY ),

                            TPoint( rect.iBr ));

            TRect rectBottom( TPoint( rect.iTl.iX, rect.iTl.iY + m_destRectForZooming.Height() - 2 ),

                              TPoint( rect.iBr.iX + m_destRectForZooming.Width(), rect.iBr.iY ));

            const TRgb colorTest(KZoomBgRectColor,KZoomBgRectColor,KZoomBgRectColor);

            gc.SetPenColor(colorTest);

            gc.SetBrushStyle( CGraphicsContext::EForwardDiagonalHatchBrush );

            gc.SetBrushColor(colorTest);

            gc.DrawRect( rectLeft );

            gc.DrawRect( rectBottom );

        }

    }

    if (m_pageScalerEnabled && m_pageScaler->Visible()) {

        m_pageScaler->Draw( gc, rect );

    }

    if (m_toolbar) {

        m_toolbar->Draw();

    }

    if (m_popupDrawer)

    {

        m_popupDrawer->drawPopup();

    }

    if (m_widgetextension){

        m_widgetextension->DrawTransition(gc,StaticObjectsContainer::instance()->webSurface()->offscreenBitmap());

    }

}

WebCore::Page* WebView::page()

{

    return m_page;

}

WebFrame* WebView::mainFrame()

{

    if (!m_page)

        return NULL;

    return kit(m_page->mainFrame());

}

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

// WebView::syncRepaint

// Repaint the given rectangle synchronously

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

void WebView::syncRepaint( const TRect& rect)

{

    m_repaints.AddRect( rect );

    syncRepaint();

}

void WebView::MakeVisible(TBool visible)

{

    if (visible == IsVisible()) return;

    CCoeControl::MakeVisible(visible);

    MakeViewVisible(visible);

}

void WebView::MakeViewVisible(TBool visible)

{

    if ( visible ) {

        // resize the offscreen surface, this is needed

        // because the shared surface is changed.

        StaticObjectsContainer::instance()->webSurface()->setView( this );

        m_bitmapdevice->Resize( m_offscreenrect.Size() );

        m_webcorecontext->resized();

    }

    WebCursor* cursor = StaticObjectsContainer::instance()->webCursor();

    if (cursor) {

        if (visible) {

            cursor->setCurrentView(*this);

            //Reset the iFocusedElementType to be the same as before the second window is opened.

            cursor->setPosition(m_savedCursorPosition);

            cursor->updatePositionAndElemType(m_savedCursorPosition);

        } else

            m_savedCursorPosition = cursor->position();

        cursor->cursorUpdate(visible & !AknLayoutUtils::PenEnabled());

    }

    Frame* f = m_page->mainFrame();

    while ( f ) {

        PassRefPtr<HTMLCollection> objects = f->document()->objects();

        for (Node* n = objects->firstItem(); n; n = objects->nextItem()) {

            MWebCoreObjectWidget* w = widget(n);

            if (w)

                w->makeVisible(visible);

        }

        PassRefPtr<HTMLCollection> embeds = f->document()->embeds();

        for (Node* n = embeds->firstItem(); n; n = embeds->nextItem()) {

            MWebCoreObjectWidget* w = widget(n);

            if (w)

                w->makeVisible(visible);

        }

        f = f->tree()->traverseNext();

    }

    if ( m_pageScaler )  {

        m_pageScaler->SetContainerRect(TRect(Rect().Size()));

    }

    if ( m_webFormFillPopup ){

        // don't show the popup if view's visibility changes.

        m_webFormFillPopup->MakeVisible(EFalse);