/*

    Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies)

    Copyright (C) 2009 Girish Ramakrishnan <girish@forwardbias.in>

    This library is free software; you can redistribute it and/or

    modify it under the terms of the GNU Library General Public

    License as published by the Free Software Foundation; either

    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public License

    along with this library; see the file COPYING.LIB.  If not, write to

    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

    Boston, MA 02110-1301, USA.

*/

#include "config.h"

#include "qgraphicswebview.h"

#include "qwebframe.h"

#include "qwebframe_p.h"

#include "qwebpage.h"

#include "qwebpage_p.h"

#include "PageClientQt.h"

#include "FrameView.h"

#include "GraphicsContext.h"

#include "IntRect.h"

#include "TiledBackingStore.h"

#include <QtCore/qmetaobject.h>

#include <QtCore/qsharedpointer.h>

#include <QtCore/qtimer.h>

#include <QtGui/qapplication.h>

#include <QtGui/qgraphicsscene.h>

#include <QtGui/qgraphicssceneevent.h>

#include <QtGui/qgraphicsview.h>

#include <QtGui/qpixmapcache.h>

#include <QtGui/qscrollbar.h>

#include <QtGui/qstyleoption.h>

#include <QtGui/qinputcontext.h>

#if defined(Q_WS_X11)

#include <QX11Info>

#endif

#include <Settings.h>

using namespace WebCore;

class QGraphicsWebViewPrivate {

public:

    QGraphicsWebViewPrivate(QGraphicsWebView* parent)

        : q(parent)

        , page(0)

        , resizesToContents(false) {}

    virtual ~QGraphicsWebViewPrivate();

    void syncLayers();

    void updateResizesToContentsForPage();

    void detachCurrentPage();

    void _q_doLoadFinished(bool success);

    void _q_contentsSizeChanged(const QSize&);

    void _q_scaleChanged();

    void _q_updateMicroFocus();

    void _q_pageDestroyed();

    QGraphicsWebView* q;

    QWebPage* page;

    bool resizesToContents;

    QSize deviceSize;

    // Just a convenience to avoid using page->client->overlay always

    QSharedPointer<QGraphicsItemOverlay> overlay;

};

QGraphicsWebViewPrivate::~QGraphicsWebViewPrivate()

{

    detachCurrentPage();

}

void QGraphicsWebViewPrivate::syncLayers()

{

#if USE(ACCELERATED_COMPOSITING)

    static_cast<PageClientQGraphicsWidget*>(page->d->client)->syncLayers();

#endif

}

void QGraphicsWebViewPrivate::_q_doLoadFinished(bool success)

{

    // If the page had no title, still make sure it gets the signal

    if (q->title().isEmpty())

        emit q->urlChanged(q->url());

    emit q->loadFinished(success);

}

void QGraphicsWebViewPrivate::_q_updateMicroFocus()

{

#if !defined(QT_NO_IM) && (defined(Q_WS_X11) || defined(Q_WS_QWS) || defined(Q_OS_SYMBIAN))

    // Ideally, this should be handled by a common call to an updateMicroFocus function

    // in QGraphicsItem. See http://bugreports.qt.nokia.com/browse/QTBUG-7578.

    QList<QGraphicsView*> views = q->scene()->views();

    for (int c = 0; c < views.size(); ++c) {

        QInputContext* ic = views.at(c)->inputContext();

        if (ic)

            ic->update();

    }

#endif

}

void QGraphicsWebViewPrivate::_q_pageDestroyed()

{

    page = 0;

    q->setPage(0);

}

void QGraphicsWebViewPrivate::updateResizesToContentsForPage()

{

    ASSERT(page);

    static_cast<PageClientQGraphicsWidget*>(page->d->client)->viewResizesToContents = resizesToContents;

    if (resizesToContents) {

        // resizes to contents mode requires preferred contents size to be set

        if (!page->preferredContentsSize().isValid())

            page->setPreferredContentsSize(QSize(960, 800));

#if QT_VERSION >= QT_VERSION_CHECK(4, 6, 0)

        QObject::connect(page->mainFrame(), SIGNAL(contentsSizeChanged(QSize)),

            q, SLOT(_q_contentsSizeChanged(const QSize&)), Qt::UniqueConnection);

#else

        QObject::connect(page->mainFrame(), SIGNAL(contentsSizeChanged(QSize)),

            q, SLOT(_q_contentsSizeChanged(const QSize&)));

#endif

    } else {

        QObject::disconnect(page->mainFrame(), SIGNAL(contentsSizeChanged(QSize)),

                         q, SLOT(_q_contentsSizeChanged(const QSize&)));

    }

}

void QGraphicsWebViewPrivate::_q_contentsSizeChanged(const QSize& size)

{

    if (!resizesToContents)

        return;

    q->setGeometry(QRectF(q->geometry().topLeft(), size));

}

void QGraphicsWebViewPrivate::_q_scaleChanged()

{

#if ENABLE(TILED_BACKING_STORE)

    if (!page)

        return;

    static_cast<PageClientQGraphicsWidget*>(page->d->client)->updateTiledBackingStoreScale();

#endif

}

/*!

    \class QGraphicsWebView

    \brief The QGraphicsWebView class allows Web content to be added to a GraphicsView.

    \since 4.6

    An instance of this class renders Web content from a URL or supplied as data, using

    features of the QtWebKit module.

    If the width and height of the item are not set, they will default to 800 and 600,

    respectively. If the Web page contents is larger than that, scrollbars will be shown

    if not disabled explicitly.

    \section1 Browser Features

    Many of the functions, signals and properties provided by QWebView are also available

    for this item, making it simple to adapt existing code to use QGraphicsWebView instead

    of QWebView.

    The item uses a QWebPage object to perform the rendering of Web content, and this can

    be obtained with the page() function, enabling the document itself to be accessed and

    modified.

    As with QWebView, the item records the browsing history using a QWebHistory object,

    accessible using the history() function. The QWebSettings object that defines the

    configuration of the browser can be obtained with the settings() function, enabling

    features like plugin support to be customized for each item.

    \sa QWebView, QGraphicsTextItem

*/

/*!

    \fn void QGraphicsWebView::titleChanged(const QString &title)

    This signal is emitted whenever the \a title of the main frame changes.

    \sa title()

*/

/*!

    \fn void QGraphicsWebView::urlChanged(const QUrl &url)

    This signal is emitted when the \a url of the view changes.

    \sa url(), load()

*/

/*!

    \fn void QGraphicsWebView::iconChanged()

    This signal is emitted whenever the icon of the page is loaded or changes.

    In order for icons to be loaded, you will need to set an icon database path

    using QWebSettings::setIconDatabasePath().

    \sa icon(), QWebSettings::setIconDatabasePath()

*/

/*!

    \fn void QGraphicsWebView::loadStarted()

    This signal is emitted when a new load of the page is started.

    \sa loadProgress(), loadFinished()

*/

/*!

    \fn void QGraphicsWebView::loadFinished(bool ok)

    This signal is emitted when a load of the page is finished.

    \a ok will indicate whether the load was successful or any error occurred.

    \sa loadStarted()

*/

/*!

    Constructs an empty QGraphicsWebView with parent \a parent.

    \sa load()

*/

QGraphicsWebView::QGraphicsWebView(QGraphicsItem* parent)

    : QGraphicsWidget(parent)

    , d(new QGraphicsWebViewPrivate(this))

{

#if QT_VERSION >= 0x040600

    setFlag(QGraphicsItem::ItemUsesExtendedStyleOption, true);

#endif

    setAcceptDrops(true);

    setAcceptHoverEvents(true);

#if QT_VERSION >= QT_VERSION_CHECK(4, 6, 0)

    setAcceptTouchEvents(true);

#endif

    setFocusPolicy(Qt::StrongFocus);

    setFlag(QGraphicsItem::ItemClipsChildrenToShape, true);

#if ENABLE(TILED_BACKING_STORE)

    QObject::connect(this, SIGNAL(scaleChanged()), this, SLOT(_q_scaleChanged()));

#endif

}

/*!

    Destroys the item.

*/

QGraphicsWebView::~QGraphicsWebView()

{

    delete d;

}

/*!

    Returns a pointer to the underlying web page.

    \sa setPage()

*/

QWebPage* QGraphicsWebView::page() const

{

    if (!d->page) {

        QGraphicsWebView* that = const_cast<QGraphicsWebView*>(this);

        QWebPage* page = new QWebPage(that);

        // Default to not having a background, in the case

        // the page doesn't provide one.

        QPalette palette = QApplication::palette();

        palette.setBrush(QPalette::Base, QColor::fromRgbF(0, 0, 0, 0));

        page->setPalette(palette);

        that->setPage(page);

    }

    return d->page;

}

/*! \reimp

*/

void QGraphicsWebView::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget*)

{

#if ENABLE(TILED_BACKING_STORE)

    if (WebCore::TiledBackingStore* backingStore = QWebFramePrivate::core(page()->mainFrame())->tiledBackingStore()) {

        // FIXME: We should set the backing store viewport earlier than in paint

        backingStore->adjustVisibleRect();

        // QWebFrame::render is a public API, bypass it for tiled rendering so behavior does not need to change.

        WebCore::GraphicsContext context(painter); 

        page()->mainFrame()->d->renderFromTiledBackingStore(&context, option->exposedRect.toAlignedRect());

        return;

    } 

#endif

#if USE(ACCELERATED_COMPOSITING)

    page()->mainFrame()->render(painter, d->overlay ? QWebFrame::ContentsLayer : QWebFrame::AllLayers, option->exposedRect.toAlignedRect());

#else

    page()->mainFrame()->render(painter, QWebFrame::AllLayers, option->exposedRect.toRect());

#endif

}

/*! \reimp

*/

bool QGraphicsWebView::sceneEvent(QEvent* event)

{

    // Re-implemented in order to allows fixing event-related bugs in patch releases.

#if QT_VERSION >= QT_VERSION_CHECK(4, 6, 0)

    if (d->page && (event->type() == QEvent::TouchBegin

                || event->type() == QEvent::TouchEnd

                || event->type() == QEvent::TouchUpdate)) {

        d->page->event(event);

        // Always return true so that we'll receive also TouchUpdate and TouchEnd events

        return true;

    }

#endif

    return QGraphicsWidget::sceneEvent(event);

}

/*! \reimp

*/

QVariant QGraphicsWebView::itemChange(GraphicsItemChange change, const QVariant& value)

{

    switch (change) {

    // Differently from QWebView, it is interesting to QGraphicsWebView to handle

    // post mouse cursor change notifications. Reason: 'ItemCursorChange' is sent

    // as the first action in QGraphicsItem::setCursor implementation, and at that

    // item widget's cursor has not been effectively changed yet.

    // After cursor is properly set (at 'ItemCursorHasChanged' emission time), we

    // fire 'CursorChange'.

    case ItemCursorChange:

        return value;

    case ItemCursorHasChanged: {

            QEvent event(QEvent::CursorChange);

            QApplication::sendEvent(this, &event);

            return value;

        }

    default:

        break;

    }

    return QGraphicsWidget::itemChange(change, value);

}

/*! \reimp

*/

QSizeF QGraphicsWebView::sizeHint(Qt::SizeHint which, const QSizeF& constraint) const

{

    if (which == Qt::PreferredSize)

        return QSizeF(800, 600); // ###

    return QGraphicsWidget::sizeHint(which, constraint);

}

/*! \reimp

*/

QVariant QGraphicsWebView::inputMethodQuery(Qt::InputMethodQuery query) const

{

    if (d->page)

        return d->page->inputMethodQuery(query);

    return QVariant();

}

/*! \reimp

*/

bool QGraphicsWebView::event(QEvent* event)

{

    // Re-implemented in order to allows fixing event-related bugs in patch releases.

    if (d->page) {

#ifndef QT_NO_CONTEXTMENU

        if (event->type() == QEvent::GraphicsSceneContextMenu) {

            if (!isEnabled())

                return false;

            QGraphicsSceneContextMenuEvent* ev = static_cast<QGraphicsSceneContextMenuEvent*>(event);

            QContextMenuEvent fakeEvent(QContextMenuEvent::Reason(ev->reason()), ev->pos().toPoint());

            if (d->page->swallowContextMenuEvent(&fakeEvent)) {

                event->accept();

                return true;

            }

            d->page->updatePositionDependentActions(fakeEvent.pos());

        } else

#endif // QT_NO_CONTEXTMENU

        {

#ifndef QT_NO_CURSOR

            if (event->type() == QEvent::CursorChange) {

                // An unsetCursor will set the cursor to Qt::ArrowCursor.

                // Thus this cursor change might be a QWidget::unsetCursor()

                // If this is not the case and it came from WebCore, the

                // QWebPageClient already has set its cursor internally

                // to Qt::ArrowCursor, so updating the cursor is always

                // right, as it falls back to the last cursor set by

                // WebCore.

                // FIXME: Add a QEvent::CursorUnset or similar to Qt.

                if (cursor().shape() == Qt::ArrowCursor)

                    d->page->d->client->resetCursor();

            }

#endif

        }

    }

    return QGraphicsWidget::event(event);

}

void QGraphicsWebViewPrivate::detachCurrentPage()

{

    if (!page)

        return;

#if QT_VERSION >= 0x040600

    page->d->view.clear();

#else

    page->d->view = 0;

#endif

    // The client has always to be deleted.

    delete page->d->client;

    page->d->client = 0;

    // if the page was created by us, we own it and need to

    // destroy it as well.

    if (page->parent() == q)

        delete page;

    else

        page->disconnect(q);

    page = 0;

}

/*!

    Makes \a page the new web page of the web graphicsitem.

    The parent QObject of the provided page remains the owner

    of the object. If the current document is a child of the web

    view, it will be deleted.

    \sa page()

*/

void QGraphicsWebView::setPage(QWebPage* page)

{

    if (d->page == page)

        return;

    d->detachCurrentPage();

    d->page = page;

    if (!d->page)

        return;

    d->page->d->client = new PageClientQGraphicsWidget(this, page); // set the page client

    d->overlay = static_cast<PageClientQGraphicsWidget*>(d->page->d->client)->overlay;

    if (d->overlay)

        d->overlay->prepareGraphicsItemGeometryChange();

    QSize size = geometry().size().toSize();

    page->setViewportSize(size);

    if (d->resizesToContents)

        d->updateResizesToContentsForPage();

    QWebFrame* mainFrame = d->page->mainFrame();

    connect(mainFrame, SIGNAL(titleChanged(QString)),

            this, SIGNAL(titleChanged(QString)));

    connect(mainFrame, SIGNAL(iconChanged()),

            this, SIGNAL(iconChanged()));

    connect(mainFrame, SIGNAL(urlChanged(QUrl)),

            this, SIGNAL(urlChanged(QUrl)));

    connect(d->page, SIGNAL(loadStarted()),

            this, SIGNAL(loadStarted()));

    connect(d->page, SIGNAL(loadProgress(int)),

            this, SIGNAL(loadProgress(int)));

    connect(d->page, SIGNAL(loadFinished(bool)),

            this, SLOT(_q_doLoadFinished(bool)));

    connect(d->page, SIGNAL(statusBarMessage(QString)),

            this, SIGNAL(statusBarMessage(QString)));

    connect(d->page, SIGNAL(linkClicked(QUrl)),

            this, SIGNAL(linkClicked(QUrl)));

    connect(d->page, SIGNAL(microFocusChanged()),

            this, SLOT(_q_updateMicroFocus()));

    connect(d->page, SIGNAL(destroyed()),

            this, SLOT(_q_pageDestroyed()));

}

/*!

    \property QGraphicsWebView::url

    \brief the url of the web page currently viewed

    Setting this property clears the view and loads the URL.

    By default, this property contains an empty, invalid URL.

    \sa load(), urlChanged()

*/

void QGraphicsWebView::setUrl(const QUrl &url)

{

    page()->mainFrame()->setUrl(url);

}

QUrl QGraphicsWebView::url() const

{

    if (d->page)

        return d->page->mainFrame()->url();

    return QUrl();

}

/*!

    \property QGraphicsWebView::title

    \brief the title of the web page currently viewed

    By default, this property contains an empty string.

    \sa titleChanged()

*/