Merge WebKit at r75993: Initial merge by git.

Change-Id: I602bbdc3974787a3b0450456a30a7868286921c3

17 files changed, 2603 insertions, 0 deletions

diff --git a/Source/WebKit2/UIProcess/API/qt/ClientImpl.cpp b/Source/WebKit2/UIProcess/API/qt/ClientImpl.cpp
new file mode 100644
index 0000000..642e529
--- /dev/null
+++ b/Source/WebKit2/UIProcess/API/qt/ClientImpl.cpp
@@ -0,0 +1,169 @@
+/*
+    Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
+
+    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 "ClientImpl.h"
+
+#include "WebFrameProxy.h"
+#include "WKAPICast.h"
+#include "WKStringQt.h"
+#include "WKURLQt.h"
+#include <qwkpage.h>
+#include <qwkpage_p.h>
+#include <WKFrame.h>
+#include <WKType.h>
+
+using namespace WebKit;
+
+static QWKPage* toQWKPage(const void* clientInfo)
+{
+    if (clientInfo)
+        return reinterpret_cast<QWKPage*>(const_cast<void*>(clientInfo));
+    return 0;
+}
+
+static void loadFinished(WKFrameRef frame, const void* clientInfo, bool ok)
+{
+    if (!WKFrameIsMainFrame(frame))
+        return;
+    emit toQWKPage(clientInfo)->loadFinished(ok);
+    QWKPagePrivate::get(toQWKPage(clientInfo))->updateNavigationActions();
+}
+
+void qt_wk_didStartProvisionalLoadForFrame(WKPageRef page, WKFrameRef frame, WKTypeRef userData, const void* clientInfo)
+{
+    if (!WKFrameIsMainFrame(frame))
+        return;
+    emit toQWKPage(clientInfo)->loadStarted();
+    QWKPagePrivate::get(toQWKPage(clientInfo))->updateNavigationActions();
+}
+
+void qt_wk_didReceiveServerRedirectForProvisionalLoadForFrame(WKPageRef page, WKFrameRef frame, WKTypeRef userData, const void* clientInfo)
+{
+}
+
+void qt_wk_didFailProvisionalLoadWithErrorForFrame(WKPageRef page, WKFrameRef frame, WKErrorRef error, WKTypeRef userData, const void* clientInfo)
+{
+    loadFinished(frame, clientInfo, false);
+}
+
+void qt_wk_didCommitLoadForFrame(WKPageRef page, WKFrameRef frame, WKTypeRef userData, const void* clientInfo)
+{
+    if (!WKFrameIsMainFrame(frame))
+        return;
+    WebFrameProxy* wkframe = toImpl(frame);
+    QString urlStr(wkframe->url());
+    QUrl qUrl = urlStr;
+    emit toQWKPage(clientInfo)->urlChanged(qUrl);
+    QWKPagePrivate::get(toQWKPage(clientInfo))->updateNavigationActions();
+}
+
+void qt_wk_didFinishDocumentLoadForFrame(WKPageRef page, WKFrameRef frame, WKTypeRef userData, const void* clientInfo)
+{
+    // FIXME: Implement (bug #44934)
+}
+
+void qt_wk_didFinishLoadForFrame(WKPageRef page, WKFrameRef frame, WKTypeRef userData, const void* clientInfo)
+{
+    loadFinished(frame, clientInfo, true);
+}
+
+void qt_wk_didFailLoadWithErrorForFrame(WKPageRef page, WKFrameRef frame, WKErrorRef error, WKTypeRef userData, const void* clientInfo)
+{
+    loadFinished(frame, clientInfo, false);
+}
+
+void qt_wk_didReceiveTitleForFrame(WKPageRef page, WKStringRef title, WKFrameRef frame, WKTypeRef userData, const void* clientInfo)
+{
+    if (!WKFrameIsMainFrame(frame))
+        return;
+    QString qTitle = WKStringCopyQString(title);
+    emit toQWKPage(clientInfo)->titleChanged(qTitle);
+}
+
+void qt_wk_didFirstLayoutForFrame(WKPageRef page, WKFrameRef frame, WKTypeRef userData, const void* clientInfo)
+{
+    if (!WKFrameIsMainFrame(frame))
+        return;
+    emit toQWKPage(clientInfo)->initialLayoutCompleted();
+}
+
+void qt_wk_didRemoveFrameFromHierarchy(WKPageRef page, WKFrameRef frame, WKTypeRef userData, const void* clientInfo)
+{
+    // FIXME: Implement (bug #46432)
+}
+
+void qt_wk_didFirstVisuallyNonEmptyLayoutForFrame(WKPageRef page, WKFrameRef frame, WKTypeRef userData, const void* clientInfo)
+{
+    if (!WKFrameIsMainFrame(frame))
+        return;
+    // FIXME: emit toWKView(clientInfo)->initialLayoutCompleted();
+}
+
+void qt_wk_didStartProgress(WKPageRef page, const void* clientInfo)
+{
+    emit toQWKPage(clientInfo)->loadProgress(0);
+}
+
+void qt_wk_didChangeProgress(WKPageRef page, const void* clientInfo)
+{
+    emit toQWKPage(clientInfo)->loadProgress(WKPageGetEstimatedProgress(page) * 100);
+}
+
+void qt_wk_didFinishProgress(WKPageRef page, const void* clientInfo)
+{
+    emit toQWKPage(clientInfo)->loadProgress(100);
+}
+
+void qt_wk_didBecomeUnresponsive(WKPageRef page, const void* clientInfo)
+{
+}
+
+void qt_wk_didBecomeResponsive(WKPageRef page, const void* clientInfo)
+{
+}
+
+WKPageRef qt_wk_createNewPage(WKPageRef page, WKDictionaryRef features, WKEventModifiers modifiers, WKEventMouseButton mouseButton, const void* clientInfo)
+{
+    QWKPage* wkPage = toQWKPage(clientInfo);
+    QWKPagePrivate* d = QWKPagePrivate::get(wkPage);
+    QWKPage::CreateNewPageFn createNewPageFn = d->createNewPageFn;
+
+    if (!createNewPageFn)
+        return 0;
+
+    if (QWKPage* newPage = createNewPageFn(wkPage)) {
+        WKRetain(newPage->pageRef());
+        return newPage->pageRef();
+    }
+
+    return 0;
+}
+
+void qt_wk_showPage(WKPageRef page, const void* clientInfo)
+{
+}
+
+void qt_wk_close(WKPageRef page, const void* clientInfo)
+{
+    emit toQWKPage(clientInfo)->windowCloseRequested();
+}
+
+void qt_wk_runJavaScriptAlert(WKPageRef page, WKStringRef alertText, WKFrameRef frame, const void* clientInfo)
+{
+}
diff --git a/Source/WebKit2/UIProcess/API/qt/ClientImpl.h b/Source/WebKit2/UIProcess/API/qt/ClientImpl.h
new file mode 100644
index 0000000..5d8c062
--- /dev/null
+++ b/Source/WebKit2/UIProcess/API/qt/ClientImpl.h
@@ -0,0 +1,58 @@
+/*
+    Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
+
+    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.
+*/
+
+#ifndef DefaultClientCallbacksQt_h
+#define DefaultClientCallbacksQt_h
+
+#include <WebKit2/WKPage.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// loader client
+void qt_wk_didStartProvisionalLoadForFrame(WKPageRef, WKFrameRef, WKTypeRef, const void* clientInfo);
+void qt_wk_didReceiveServerRedirectForProvisionalLoadForFrame(WKPageRef, WKFrameRef, WKTypeRef, const void* clientInfo);
+void qt_wk_didFailProvisionalLoadWithErrorForFrame(WKPageRef, WKFrameRef, WKErrorRef, WKTypeRef, const void* clientInfo);
+void qt_wk_didCommitLoadForFrame(WKPageRef, WKFrameRef, WKTypeRef, const void* clientInfo);
+void qt_wk_didFinishDocumentLoadForFrame(WKPageRef, WKFrameRef, WKTypeRef, const void* clientInfo);
+void qt_wk_didFinishLoadForFrame(WKPageRef, WKFrameRef, WKTypeRef, const void* clientInfo);
+void qt_wk_didFailLoadWithErrorForFrame(WKPageRef, WKFrameRef, WKErrorRef, WKTypeRef, const void* clientInfo);
+void qt_wk_didReceiveTitleForFrame(WKPageRef, WKStringRef title, WKFrameRef, WKTypeRef, const void* clientInfo);
+void qt_wk_didFirstLayoutForFrame(WKPageRef, WKFrameRef, WKTypeRef, const void* clientInfo);
+void qt_wk_didFirstVisuallyNonEmptyLayoutForFrame(WKPageRef, WKFrameRef, WKTypeRef, const void* clientInfo);
+void qt_wk_didRemoveFrameFromHierarchy(WKPageRef, WKFrameRef, WKTypeRef, const void* clientInfo);
+void qt_wk_didStartProgress(WKPageRef, const void* clientInfo);
+void qt_wk_didChangeProgress(WKPageRef, const void* clientInfo);
+void qt_wk_didFinishProgress(WKPageRef, const void* clientInfo);
+void qt_wk_didBecomeUnresponsive(WKPageRef, const void* clientInfo);
+void qt_wk_didBecomeResponsive(WKPageRef, const void* clientInfo);
+
+// ui client
+WKPageRef qt_wk_createNewPage(WKPageRef page, WKDictionaryRef features, WKEventModifiers modifiers, WKEventMouseButton mouseButton, const void *clientInfo);
+void qt_wk_showPage(WKPageRef page, const void *clientInfo);
+void qt_wk_close(WKPageRef page, const void *clientInfo);
+void qt_wk_runJavaScriptAlert(WKPageRef page, WKStringRef alertText, WKFrameRef frame, const void* clientInfo);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* DefaultClientCallbacksQt_h */
+
diff --git a/Source/WebKit2/UIProcess/API/qt/WKView.h b/Source/WebKit2/UIProcess/API/qt/WKView.h
new file mode 100644
index 0000000..5bb95e8
--- /dev/null
+++ b/Source/WebKit2/UIProcess/API/qt/WKView.h
@@ -0,0 +1,28 @@
+/*
+    Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
+
+    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.
+*/
+
+#ifndef WKView_h
+#define WKView_h
+
+#include <WebKit2/qgraphicswkview.h>
+#include <WebKit2/qwkcontext.h>
+#include <WebKit2/qwkpage.h>
+#include <WebKit2/qwkpreferences.h>
+
+#endif /* WKView_h */
diff --git a/Source/WebKit2/UIProcess/API/qt/qgraphicswkview.cpp b/Source/WebKit2/UIProcess/API/qt/qgraphicswkview.cpp
new file mode 100644
index 0000000..f01c5b2
--- /dev/null
+++ b/Source/WebKit2/UIProcess/API/qt/qgraphicswkview.cpp
@@ -0,0 +1,442 @@
+/*
+ * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
+ *
+ * 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 program 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 program; 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 "qgraphicswkview.h"
+
+#include "ChunkedUpdateDrawingAreaProxy.h"
+#include "IntSize.h"
+#include "RunLoop.h"
+#include "TiledDrawingAreaProxy.h"
+#include "UpdateChunk.h"
+#include "WKAPICast.h"
+#include "qwkpage.h"
+#include "qwkpage_p.h"
+#include <QApplication>
+#include <QCursor>
+#include <QGraphicsSceneMouseEvent>
+#include <QGraphicsView>
+#include <QMenu>
+#include <QPainter>
+#include <QScrollBar>
+#include <QStyleOptionGraphicsItem>
+#include <QUrl>
+#include <QtDebug>
+#include <WebKit2/WKRetainPtr.h>
+#include <wtf/RefPtr.h>
+#include <wtf/text/WTFString.h>
+
+using namespace WebKit;
+using namespace WebCore;
+
+struct QGraphicsWKViewPrivate {
+    QGraphicsWKViewPrivate(QGraphicsWKView* view);
+    WKPageRef pageRef() const { return page->pageRef(); }
+
+    void onScaleChanged();
+    void commitScale();
+
+    QGraphicsWKView* q;
+    QWKPage* page;
+    QMenu* activeMenu;
+    RunLoop::Timer<QGraphicsWKViewPrivate> m_scaleCommitTimer;
+    bool m_isChangingScale;
+};
+
+QGraphicsWKView::QGraphicsWKView(QWKContext* context, BackingStoreType backingStoreType, QGraphicsItem* parent)
+    : QGraphicsWidget(parent)
+    , d(new QGraphicsWKViewPrivate(this))
+{
+    setFocusPolicy(Qt::StrongFocus);
+    setAcceptHoverEvents(true);
+
+    PassOwnPtr<DrawingAreaProxy> drawingAreaProxy;
+
+    d->page = new QWKPage(context);
+
+    switch (backingStoreType) {
+#if ENABLE(TILED_BACKING_STORE)
+    case Tiled:
+        drawingAreaProxy = TiledDrawingAreaProxy::create(this, toImpl(page()->pageRef()));
+        connect(this, SIGNAL(scaleChanged()), this, SLOT(onScaleChanged()));
+        break;
+#endif
+    case Simple:
+    default:
+        drawingAreaProxy = ChunkedUpdateDrawingAreaProxy::create(this, toImpl(page()->pageRef()));
+        break;
+    }
+
+    d->page->d->init(this, drawingAreaProxy);
+    connect(d->page, SIGNAL(titleChanged(QString)), this, SIGNAL(titleChanged(QString)));
+    connect(d->page, SIGNAL(loadStarted()), this, SIGNAL(loadStarted()));
+    connect(d->page, SIGNAL(loadFinished(bool)), this, SIGNAL(loadFinished(bool)));
+    connect(d->page, SIGNAL(loadProgress(int)), this, SIGNAL(loadProgress(int)));
+    connect(d->page, SIGNAL(initialLayoutCompleted()), this, SIGNAL(initialLayoutCompleted()));
+    connect(d->page, SIGNAL(urlChanged(const QUrl&)), this, SIGNAL(urlChanged(const QUrl&)));
+    connect(d->page, SIGNAL(cursorChanged(const QCursor&)), this, SLOT(updateCursor(const QCursor&)));
+    connect(d->page, SIGNAL(focusNextPrevChild(bool)), this, SLOT(focusNextPrevChildCallback(bool)));
+    connect(d->page, SIGNAL(showContextMenu(QMenu*)), this, SLOT(showContextMenu(QMenu*)));
+}
+
+QGraphicsWKView::~QGraphicsWKView()
+{
+    delete d->page;
+    delete d;
+}
+
+QWKPage* QGraphicsWKView::page() const
+{
+    return d->page;
+}
+
+void QGraphicsWKView::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget*)
+{
+    page()->d->paint(painter, option->exposedRect.toAlignedRect());
+}
+
+void QGraphicsWKView::setGeometry(const QRectF& rect)
+{
+    QSizeF oldSize = geometry().size();
+    QGraphicsWidget::setGeometry(rect);
+    if (geometry().size() == oldSize)
+        return;
+
+    // NOTE: call geometry() as setGeometry ensures that
+    // the geometry is within legal bounds (minimumSize, maximumSize)
+    page()->setViewportSize(geometry().size().toSize());
+}
+
+void QGraphicsWKView::load(const QUrl& url)
+{
+    page()->load(url);
+}
+
+void QGraphicsWKView::setUrl(const QUrl& url)
+{
+    page()->setUrl(url);
+}
+
+QUrl QGraphicsWKView::url() const
+{
+    return page()->url();
+}
+
+QString QGraphicsWKView::title() const
+{
+    return page()->title();
+}
+
+void QGraphicsWKView::triggerPageAction(QWKPage::WebAction action, bool checked)
+{
+    page()->triggerAction(action, checked);
+}
+
+void QGraphicsWKView::back()
+{
+    page()->triggerAction(QWKPage::Back);
+}
+
+void QGraphicsWKView::forward()
+{
+    page()->triggerAction(QWKPage::Forward);
+}
+
+void QGraphicsWKView::reload()
+{
+    page()->triggerAction(QWKPage::Reload);
+}
+
+void QGraphicsWKView::stop()
+{
+    page()->triggerAction(QWKPage::Stop);
+}
+
+void QGraphicsWKView::updateCursor(const QCursor& cursor)
+{
+    setCursor(cursor);
+}
+
+class FriendlyWidget : public QWidget
+{
+public:
+    bool focusNextPrevChild(bool next);
+};
+
+void QGraphicsWKView::focusNextPrevChildCallback(bool next)
+{
+    if (hasFocus()) {
+        // find the view which has the focus:
+        QList<QGraphicsView*> views = scene()->views();
+        const int viewCount = views.count();
+        QGraphicsView* focusedView = 0;
+        for (int i = 0; i < viewCount; ++i) {
+            if (views[i]->hasFocus()) {
+                focusedView = views[i];
+                break;
+            }
+        }
+
+        if (focusedView) {
+            QWidget* window = focusedView->window();
+            FriendlyWidget* friendlyWindow = static_cast<FriendlyWidget*>(window);
+            friendlyWindow->focusNextPrevChild(next);
+        }
+    }
+}
+
+/*! \reimp
+*/
+bool QGraphicsWKView::focusNextPrevChild(bool next)
+{
+    QKeyEvent ev(QEvent::KeyPress, Qt::Key_Tab, Qt::KeyboardModifiers(next ? Qt::NoModifier : Qt::ShiftModifier));
+    page()->d->keyPressEvent(&ev);
+    return true;
+}
+
+/*! \reimp
+*/
+QVariant QGraphicsWKView::itemChange(GraphicsItemChange change, const QVariant& value)
+{
+    // Here so that it can be reimplemented without breaking ABI.
+    return QGraphicsWidget::itemChange(change, value);
+}
+
+/*! \reimp
+*/
+bool QGraphicsWKView::event(QEvent* event)
+{
+    QEvent::Type eventType = event->type();
+    switch (eventType) {
+    case QEvent::TouchBegin:
+    case QEvent::TouchEnd:
+    case QEvent::TouchUpdate:
+        touchEvent(static_cast<QTouchEvent*>(event));
+        return true;
+    case QEvent::Show:
+        page()->d->page->drawingArea()->setPageIsVisible(true);
+        break;
+    case QEvent::Hide:
+        page()->d->page->drawingArea()->setPageIsVisible(false);
+        break;
+    default:
+        break;
+    }
+
+    // Here so that it can be reimplemented without breaking ABI.
+    return QGraphicsWidget::event(event);
+}
+
+/*! \reimp
+*/
+QSizeF QGraphicsWKView::sizeHint(Qt::SizeHint which, const QSizeF& constraint) const
+{
+    if (which == Qt::PreferredSize)
+        return QSizeF(800, 600);
+    return QGraphicsWidget::sizeHint(which, constraint);
+}
+
+/*! \reimp
+*/
+QVariant QGraphicsWKView::inputMethodQuery(Qt::InputMethodQuery query) const
+{
+    // implement
+    return QVariant();
+}
+
+/*! \reimp
+*/
+void QGraphicsWKView::keyPressEvent(QKeyEvent* ev)
+{
+    page()->d->keyPressEvent(ev);
+}
+
+/*! \reimp
+*/
+void QGraphicsWKView::keyReleaseEvent(QKeyEvent* ev)
+{
+    page()->d->keyReleaseEvent(ev);
+}
+
+void QGraphicsWKView::hoverMoveEvent(QGraphicsSceneHoverEvent* ev)
+{
+    QGraphicsSceneMouseEvent me(QEvent::GraphicsSceneMouseMove);
+    me.setPos(ev->pos());
+    me.setScreenPos(ev->screenPos());
+
+    page()->d->mouseMoveEvent(&me);
+
+    if (!ev->isAccepted())
+        QGraphicsItem::hoverMoveEvent(ev);
+}
+
+void QGraphicsWKView::mouseMoveEvent(QGraphicsSceneMouseEvent* ev)
+{
+    page()->d->mouseMoveEvent(ev);
+    if (!ev->isAccepted())
+        QGraphicsItem::mouseMoveEvent(ev);
+}
+
+void QGraphicsWKView::mousePressEvent(QGraphicsSceneMouseEvent* ev)
+{
+    page()->d->mousePressEvent(ev);
+    if (!ev->isAccepted())
+        QGraphicsItem::mousePressEvent(ev);
+}
+
+void QGraphicsWKView::mouseReleaseEvent(QGraphicsSceneMouseEvent* ev)
+{
+    page()->d->mouseReleaseEvent(ev);
+    if (!ev->isAccepted())
+        QGraphicsItem::mouseReleaseEvent(ev);
+}
+
+void QGraphicsWKView::mouseDoubleClickEvent(QGraphicsSceneMouseEvent* ev)
+{
+    page()->d->mouseDoubleClickEvent(ev);
+    if (!ev->isAccepted())
+        QGraphicsItem::mouseReleaseEvent(ev);
+}
+
+void QGraphicsWKView::wheelEvent(QGraphicsSceneWheelEvent* ev)
+{
+    page()->d->wheelEvent(ev);
+    if (!ev->isAccepted())
+        QGraphicsItem::wheelEvent(ev);
+}
+
+void QGraphicsWKView::touchEvent(QTouchEvent* ev)
+{
+    page()->d->touchEvent(ev);
+}
+
+void QGraphicsWKView::focusInEvent(QFocusEvent*)
+{
+    page()->d->page->viewStateDidChange(WebPageProxy::ViewIsFocused | WebPageProxy::ViewWindowIsActive);
+}
+
+void QGraphicsWKView::focusOutEvent(QFocusEvent*)
+{
+    page()->d->page->viewStateDidChange(WebPageProxy::ViewIsFocused | WebPageProxy::ViewWindowIsActive);
+}
+
+void QGraphicsWKView::showContextMenu(QMenu* menu)
+{
+    // Remove the active menu in case this function is called twice.
+    if (d->activeMenu)
+        d->activeMenu->hide();
+
+    d->activeMenu = menu;
+
+    QWidget* view = 0;
+    if (QGraphicsScene* myScene = scene()) {
+        const QList<QGraphicsView*> views = myScene->views();
+        for (unsigned i = 0; i < views.size(); ++i) {
+            if (views.at(i) == QApplication::focusWidget()) {
+                view = views.at(i);
+                break;
+            }
+        }
+        if (!view)
+            view = views.value(0, 0);
+    }
+    if (view)
+        menu->setParent(view, menu->windowFlags());
+    menu->exec(view->mapToGlobal(menu->pos()));
+    if (d->activeMenu == menu)
+        d->activeMenu = 0;
+}
+
+void QGraphicsWKView::takeSnapshot(const QSize& size, const QRect& contentsRect)
+{
+#if ENABLE(TILED_BACKING_STORE)
+    DrawingAreaProxy* drawingArea = page()->d->page->drawingArea();
+    if (drawingArea->info().type != DrawingAreaInfo::Tiled)
+        return;
+    TiledDrawingAreaProxy* tiledDrawingArea = static_cast<TiledDrawingAreaProxy*>(drawingArea);
+    tiledDrawingArea->takeSnapshot(size, contentsRect);
+#endif
+}
+
+QGraphicsWKViewPrivate::QGraphicsWKViewPrivate(QGraphicsWKView* view)
+    : q(view)
+    , activeMenu(0)
+    , m_scaleCommitTimer(RunLoop::current(), this, &QGraphicsWKViewPrivate::commitScale)
+    , m_isChangingScale(false)
+{
+}
+
+QRectF QGraphicsWKView::visibleRect() const
+{
+    if (!scene())
+        return QRectF();
+
+    QList<QGraphicsView*> views = scene()->views();
+    if (views.isEmpty())
+        return QRectF();
+
+    QGraphicsView* graphicsView = views.at(0);
+    int xOffset = graphicsView->horizontalScrollBar()->value();
+    int yOffset = graphicsView->verticalScrollBar()->value();
+    return mapRectFromScene(QRectF(QPointF(xOffset, yOffset), graphicsView->viewport()->size()));
+}
+
+void QGraphicsWKView::prepareScaleChange()
+{
+#if ENABLE(TILED_BACKING_STORE)
+    ASSERT(!d->m_isChangingScale);
+    d->m_isChangingScale = true;
+    d->m_scaleCommitTimer.stop();
+#endif
+}
+
+void QGraphicsWKView::commitScaleChange()
+{
+#if ENABLE(TILED_BACKING_STORE)
+    ASSERT(d->m_isChangingScale);
+    d->m_isChangingScale = false;
+    d->commitScale();
+#endif
+}
+
+void QGraphicsWKViewPrivate::onScaleChanged()
+{
+#if ENABLE(TILED_BACKING_STORE)
+    if (!m_isChangingScale)
+        m_scaleCommitTimer.startOneShot(0.1);
+#endif
+}
+
+void QGraphicsWKViewPrivate::commitScale()
+{
+#if ENABLE(TILED_BACKING_STORE)
+    DrawingAreaProxy* drawingArea = page->d->page->drawingArea();
+    float newScale = q->scale();
+    if (drawingArea->info().type == DrawingAreaInfo::Tiled) {
+        TiledDrawingAreaProxy* tiledDrawingArea = static_cast<TiledDrawingAreaProxy*>(drawingArea);
+        if (tiledDrawingArea->contentsScale() == newScale)
+            return;
+        tiledDrawingArea->setContentsScale(newScale);
+        // For now we block until complete.
+        tiledDrawingArea->waitUntilUpdatesComplete();
+    }
+#endif
+}
+
+#include "moc_qgraphicswkview.cpp"
diff --git a/Source/WebKit2/UIProcess/API/qt/qgraphicswkview.h b/Source/WebKit2/UIProcess/API/qt/qgraphicswkview.h
new file mode 100644
index 0000000..caf8e0d
--- /dev/null
+++ b/Source/WebKit2/UIProcess/API/qt/qgraphicswkview.h
@@ -0,0 +1,102 @@
+#ifndef qgraphicswkview_h
+#define qgraphicswkview_h
+
+#include "qwebkitglobal.h"
+
+#include <WebKit2/WKBase.h>
+#include <QGraphicsWidget>
+#include "qwkpage.h"
+
+QT_BEGIN_NAMESPACE
+class QCursor;
+QT_END_NAMESPACE
+
+class QWKContext;
+class QGraphicsWKViewPrivate;
+
+WKStringRef WKStringCreateWithQString(const QString& qString);
+QString WKStringCopyQString(WKStringRef stringRef);
+
+class QWEBKIT_EXPORT QGraphicsWKView : public QGraphicsWidget {
+    Q_OBJECT
+    Q_PROPERTY(QString title READ title)
+    Q_PROPERTY(QUrl url READ url WRITE setUrl)
+
+public:
+    enum BackingStoreType { Simple, Tiled };
+    QGraphicsWKView(QWKContext* context, BackingStoreType backingStoreType = Simple, QGraphicsItem* parent = 0);
+
+    virtual ~QGraphicsWKView();
+
+    QWKPage* page() const;
+
+    virtual void setGeometry(const QRectF&);
+
+    void load(const QUrl&);
+    void setUrl(const QUrl&);
+    QUrl url() const;
+
+    QString title() const;
+
+    void triggerPageAction(QWKPage::WebAction action, bool checked = false);
+
+    virtual void paint(QPainter*, const QStyleOptionGraphicsItem*, QWidget*);
+    virtual QVariant itemChange(GraphicsItemChange, const QVariant&);
+    virtual bool event(QEvent*);
+    virtual QSizeF sizeHint(Qt::SizeHint, const QSizeF&) const;
+    virtual QVariant inputMethodQuery(Qt::InputMethodQuery) const;
+
+    void takeSnapshot(const QSize& size, const QRect& documentRect);
+
+    // FIXME: should not be public
+    virtual QRectF visibleRect() const;
+
+    void prepareScaleChange();
+    void commitScaleChange();
+
+public:
+    Q_SIGNAL void titleChanged(const QString& title);
+    Q_SIGNAL void loadStarted();
+    Q_SIGNAL void loadFinished(bool ok);
+    Q_SIGNAL void loadProgress(int progress);
+    Q_SIGNAL void initialLayoutCompleted();
+    Q_SIGNAL void urlChanged(const QUrl&);
+    Q_SIGNAL void snapshotTaken(const QImage&);
+
+public Q_SLOTS:
+    void back();
+    void forward();
+    void reload();
+    void stop();
+
+protected:
+    virtual void keyPressEvent(QKeyEvent*);
+    virtual void keyReleaseEvent(QKeyEvent*);
+    virtual void mouseMoveEvent(QGraphicsSceneMouseEvent*);
+    virtual void mousePressEvent(QGraphicsSceneMouseEvent*);
+    virtual void mouseReleaseEvent(QGraphicsSceneMouseEvent*);
+    virtual void mouseDoubleClickEvent(QGraphicsSceneMouseEvent*);
+    virtual void wheelEvent(QGraphicsSceneWheelEvent*);
+    virtual void touchEvent(QTouchEvent*);
+
+    virtual void hoverMoveEvent(QGraphicsSceneHoverEvent*);
+
+    Q_SLOT void updateCursor(const QCursor&);
+    Q_SLOT void focusNextPrevChildCallback(bool next);
+
+    virtual bool focusNextPrevChild(bool next);
+    virtual void focusInEvent(QFocusEvent*);
+    virtual void focusOutEvent(QFocusEvent*);
+
+private Q_SLOTS:
+    void showContextMenu(QMenu*);
+
+private:
+    Q_PRIVATE_SLOT(d, void onScaleChanged());
+
+    QGraphicsWKViewPrivate* d;
+    friend class QGraphicsWKViewPrivate;
+    friend class TiledDrawingAreaProxy;
+};
+
+#endif /* qgraphicswkview_h */
diff --git a/Source/WebKit2/UIProcess/API/qt/qwkcontext.cpp b/Source/WebKit2/UIProcess/API/qt/qwkcontext.cpp
new file mode 100644
index 0000000..b17c100
--- /dev/null
+++ b/Source/WebKit2/UIProcess/API/qt/qwkcontext.cpp
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
+ *
+ * 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 program 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 program; 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 "qwkcontext.h"
+#include "qwkcontext_p.h"
+
+#include "WebPlatformStrategies.h"
+
+using namespace WebKit;
+
+static inline void initializePlatformStrategiesIfNeeded()
+{
+    static bool initialized = false;
+    if (initialized)
+        return;
+
+    WebPlatformStrategies::initialize();
+    initialized = true;
+}
+
+QWKContextPrivate::QWKContextPrivate(QWKContext* qq)
+    : q(qq)
+{
+    initializePlatformStrategiesIfNeeded();
+}
+
+QWKContextPrivate::~QWKContextPrivate()
+{
+}
+
+QWKContext::QWKContext(QObject* parent)
+    : QObject(parent)
+    , d(new QWKContextPrivate(this))
+{
+    d->context = WebContext::create(String());
+}
+
+QWKContext::QWKContext(WKContextRef contextRef, QObject* parent)
+    : QObject(parent)
+    , d(new QWKContextPrivate(this))
+{
+    d->context = toImpl(contextRef);
+}
+
+QWKContext::~QWKContext()
+{
+    delete d;
+}
+
+#include "moc_qwkcontext.cpp"
diff --git a/Source/WebKit2/UIProcess/API/qt/qwkcontext.h b/Source/WebKit2/UIProcess/API/qt/qwkcontext.h
new file mode 100644
index 0000000..384d629
--- /dev/null
+++ b/Source/WebKit2/UIProcess/API/qt/qwkcontext.h
@@ -0,0 +1,44 @@
+/*
+    Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
+
+    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.
+*/
+
+#ifndef qwkcontext_h
+#define qwkcontext_h
+
+#include "qwebkitglobal.h"
+#include <QObject>
+#include <WebKit2/WKContext.h>
+
+class QWKContextPrivate;
+
+class QWEBKIT_EXPORT QWKContext : public QObject {
+    Q_OBJECT
+public:
+    QWKContext(QObject* parent = 0);
+    virtual ~QWKContext();
+
+    // Bridge from the C API
+    QWKContext(WKContextRef contextRef, QObject* parent = 0);
+
+private:
+    QWKContextPrivate* d;
+
+    friend class QWKPagePrivate;
+};
+
+#endif /* qwkcontext_h */
diff --git a/Source/WebKit2/UIProcess/API/qt/qwkcontext_p.h b/Source/WebKit2/UIProcess/API/qt/qwkcontext_p.h
new file mode 100644
index 0000000..625e87c
--- /dev/null
+++ b/Source/WebKit2/UIProcess/API/qt/qwkcontext_p.h
@@ -0,0 +1,37 @@
+/*
+    Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
+
+    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.
+*/
+
+
+#ifndef qwkcontext_p_h
+#define qwkcontext_p_h
+
+#include "WebContext.h"
+#include <wtf/RefPtr.h>
+
+class QWKContextPrivate {
+public:
+    QWKContextPrivate(QWKContext*);
+    ~QWKContextPrivate();
+
+    QWKContext* q;
+
+    RefPtr<WebKit::WebContext> context;
+};
+
+#endif /* qkcontext_p_h */
diff --git a/Source/WebKit2/UIProcess/API/qt/qwkhistory.cpp b/Source/WebKit2/UIProcess/API/qt/qwkhistory.cpp
new file mode 100644
index 0000000..3f424b5
--- /dev/null
+++ b/Source/WebKit2/UIProcess/API/qt/qwkhistory.cpp
@@ -0,0 +1,182 @@
+/*
+ * Copyright (C) 2010 Juha Savolainen (juha.savolainen@weego.fi)
+ *
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. 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 INC. 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 "config.h"
+#include "qwkhistory.h"
+
+#include <QSharedData>
+#include <QString>
+#include <QUrl>
+#include "qwkhistory_p.h"
+#include "WebBackForwardList.h"
+#include <WebKit2/WKArray.h>
+#include <WebKit2/WKRetainPtr.h>
+#include "WKBackForwardList.h"
+#include "WKStringQt.h"
+#include "WKURL.h"
+#include "WKURLQt.h"
+
+using namespace WebKit;
+
+QWKHistoryItemPrivate::QWKHistoryItemPrivate(WKBackForwardListItemRef listItem)
+    : m_backForwardListItem(listItem)
+{
+}
+
+QWKHistoryItemPrivate::~QWKHistoryItemPrivate()
+{
+}
+
+QWKHistoryItem::QWKHistoryItem(const QWKHistoryItem& other)
+    : d(other.d) 
+{
+}
+
+QWKHistoryItem& QWKHistoryItem::QWKHistoryItem::operator=(const QWKHistoryItem& other) 
+{ 
+    d = other.d;
+    return *this; 
+}
+
+QWKHistoryItem::QWKHistoryItem(WKBackForwardListItemRef item)
+    : d(new QWKHistoryItemPrivate(item))
+{
+}
+
+QWKHistoryItem::~QWKHistoryItem()
+{
+}
+
+QString QWKHistoryItem::title() const
+{
+    if (!d->m_backForwardListItem)
+        return QString();
+    WKRetainPtr<WKStringRef> title = WKBackForwardListItemCopyTitle(d->m_backForwardListItem.get());
+    return WKStringCopyQString(title.get());
+}
+
+QUrl QWKHistoryItem::url() const
+{
+    if (!d->m_backForwardListItem)
+        return QUrl();
+    WKRetainPtr<WKURLRef> url = WKBackForwardListItemCopyURL(d->m_backForwardListItem.get());
+    return WKURLCopyQUrl(url.get());
+}
+
+QWKHistoryPrivate::QWKHistoryPrivate(WebKit::WebBackForwardList* list)
+    : m_backForwardList(list)
+{
+}
+
+QWKHistory* QWKHistoryPrivate::createHistory(WebKit::WebBackForwardList* list)
+{
+    QWKHistory* history = new QWKHistory();
+    history->d = new QWKHistoryPrivate(list);
+    return history;
+}
+
+QWKHistoryPrivate::~QWKHistoryPrivate()
+{
+}
+
+QWKHistory::QWKHistory()
+{
+}
+
+QWKHistory::~QWKHistory()
+{
+    delete d;
+}
+
+int QWKHistory::backListCount() const
+{
+    return WKBackForwardListGetBackListCount(toAPI(d->m_backForwardList));
+}
+
+int QWKHistory::forwardListCount() const
+{
+    return WKBackForwardListGetForwardListCount(toAPI(d->m_backForwardList));
+}
+
+int QWKHistory::count() const
+{
+    return backListCount() + forwardListCount();
+}
+
+QWKHistoryItem QWKHistory::currentItem() const
+{
+    WKRetainPtr<WKBackForwardListItemRef> itemRef = WKBackForwardListGetCurrentItem(toAPI(d->m_backForwardList));
+    QWKHistoryItem item(itemRef.get());
+    return item;
+}
+
+QWKHistoryItem QWKHistory::backItem() const
+{
+    WKRetainPtr<WKBackForwardListItemRef> itemRef = WKBackForwardListGetBackItem(toAPI(d->m_backForwardList));
+    QWKHistoryItem item(itemRef.get());
+    return item;
+}
+
+QWKHistoryItem QWKHistory::forwardItem() const
+{
+    WKRetainPtr<WKBackForwardListItemRef> itemRef = WKBackForwardListGetForwardItem(toAPI(d->m_backForwardList));
+    QWKHistoryItem item(itemRef.get());
+    return item;
+}
+
+QWKHistoryItem QWKHistory::itemAt(int index) const
+{
+    WKRetainPtr<WKBackForwardListItemRef> itemRef = WKBackForwardListGetItemAtIndex(toAPI(d->m_backForwardList), index);
+    QWKHistoryItem item(itemRef.get());
+    return item;
+}
+
+QList<QWKHistoryItem> QWKHistory::backItems(int maxItems) const
+{
+    WKArrayRef arrayRef = WKBackForwardListCopyBackListWithLimit(toAPI(d->m_backForwardList), maxItems);
+    int size = WKArrayGetSize(arrayRef);
+    QList<QWKHistoryItem> itemList;
+    for (int i = 0; i < size; ++i) {
+        WKTypeRef wkHistoryItem = WKArrayGetItemAtIndex(arrayRef, i);
+        WKBackForwardListItemRef itemRef = static_cast<WKBackForwardListItemRef>(wkHistoryItem);
+        QWKHistoryItem item(itemRef);
+        itemList.append(item);
+    }
+    return itemList;
+}
+
+QList<QWKHistoryItem> QWKHistory::forwardItems(int maxItems) const
+{
+    WKArrayRef arrayRef = WKBackForwardListCopyForwardListWithLimit(toAPI(d->m_backForwardList), maxItems);
+    int size = WKArrayGetSize(arrayRef);
+    QList<QWKHistoryItem> itemList;
+    for (int i = 0; i < size; ++i) {
+        WKTypeRef wkHistoryItem = WKArrayGetItemAtIndex(arrayRef, i);
+        WKBackForwardListItemRef itemRef = static_cast<WKBackForwardListItemRef>(wkHistoryItem);
+        QWKHistoryItem item(itemRef);
+        itemList.append(item);
+    }
+    return itemList;
+}
+
diff --git a/Source/WebKit2/UIProcess/API/qt/qwkhistory.h b/Source/WebKit2/UIProcess/API/qt/qwkhistory.h
new file mode 100644
index 0000000..81081c9
--- /dev/null
+++ b/Source/WebKit2/UIProcess/API/qt/qwkhistory.h
@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2010 Juha Savolainen (juha.savolainen@weego.fi)
+ *
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. 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 INC. 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.
+*/
+
+#ifndef qwkhistory_h
+#define qwkhistory_h
+
+#include "qwebkitglobal.h"
+#include <QObject>
+#include <QSharedData>
+#include "WKBackForwardListItem.h"
+
+class QWKHistoryPrivate;
+class QWKHistoryItemPrivate;
+class QUrl;
+class QString;
+
+namespace WebKit {
+class WebBackForwardList;
+}
+
+class QWEBKIT_EXPORT QWKHistoryItem {
+public:
+    QWKHistoryItem(const QWKHistoryItem& other);
+    QWKHistoryItem &operator=(const QWKHistoryItem& other);
+
+    ~QWKHistoryItem();
+    QString title() const;
+    QUrl url() const;
+
+private:
+    QWKHistoryItem(WKBackForwardListItemRef item);
+
+    QExplicitlySharedDataPointer<QWKHistoryItemPrivate> d;
+
+    friend class QWKHistory;
+    friend class QWKHistoryItemPrivate;
+};
+
+class QWEBKIT_EXPORT QWKHistory : public QObject {
+    Q_OBJECT
+public:
+    int backListCount() const;
+    int forwardListCount() const;
+    int count() const;
+    QWKHistoryItem currentItem() const;
+    QWKHistoryItem backItem() const;
+    QWKHistoryItem forwardItem() const;
+    QWKHistoryItem itemAt(int index) const;
+    QList<QWKHistoryItem> backItems(int maxItems) const;
+    QList<QWKHistoryItem> forwardItems(int maxItems) const;
+
+private:
+    QWKHistory();
+    ~QWKHistory();
+
+    QWKHistoryPrivate* d;
+    friend class QWKHistoryPrivate;
+    friend class QWKPagePrivate;
+};
+#endif /* qwkhistory_h */
diff --git a/Source/WebKit2/UIProcess/API/qt/qwkhistory_p.h b/Source/WebKit2/UIProcess/API/qt/qwkhistory_p.h
new file mode 100644
index 0000000..dd1d696
--- /dev/null
+++ b/Source/WebKit2/UIProcess/API/qt/qwkhistory_p.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2010 Juha Savolainen (juha.savolainen@weego.fi)
+ *
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. 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 INC. 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.
+*/
+
+#ifndef qwkhistory_p_h
+#define qwkhistory_p_h
+
+#include <QSharedData>
+#include "qwebkitglobal.h"
+#include <WebKit2/WKBase.h>
+#include <WebKit2/WKRetainPtr.h>
+#include <wtf/PassRefPtr.h>
+
+namespace WebKit {
+class WebBackForwardList;
+}
+
+class QWKHistory;
+
+class QWEBKIT_EXPORT QWKHistoryItemPrivate : public QSharedData {
+public:
+       ~QWKHistoryItemPrivate();
+private:
+    QWKHistoryItemPrivate(WKBackForwardListItemRef listItem);
+    WKRetainPtr<WKBackForwardListItemRef> m_backForwardListItem;
+
+    friend class QWKHistory;
+    friend class QWKHistoryItem;
+};
+
+class QWEBKIT_EXPORT QWKHistoryPrivate {
+public:
+    static QWKHistory* createHistory(WebKit::WebBackForwardList* list);
+
+private:
+    QWKHistoryPrivate(WebKit::WebBackForwardList* list);
+    ~QWKHistoryPrivate();
+
+    WebKit::WebBackForwardList* m_backForwardList;
+
+    friend class QWKHistory;
+};
+
+#endif /* qwkhistory_p_h */
diff --git a/Source/WebKit2/UIProcess/API/qt/qwkpage.cpp b/Source/WebKit2/UIProcess/API/qt/qwkpage.cpp
new file mode 100644
index 0000000..638d9e3
--- /dev/null
+++ b/Source/WebKit2/UIProcess/API/qt/qwkpage.cpp
@@ -0,0 +1,759 @@
+/*
+ * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
+ *
+ * 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 program 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 program; 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 "qwkpage.h"
+#include "qwkpage_p.h"
+
+#include "qwkpreferences_p.h"
+
+#include "ChunkedUpdateDrawingAreaProxy.h"
+#include "ClientImpl.h"
+#include "qgraphicswkview.h"
+#include "qwkcontext.h"
+#include "qwkcontext_p.h"
+#include "qwkhistory.h"
+#include "qwkhistory_p.h"
+#include "FindIndicator.h"
+#include "LocalizedStrings.h"
+#include "NativeWebKeyboardEvent.h"
+#include "TiledDrawingAreaProxy.h"
+#include "WebContext.h"
+#include "WebContextMenuProxyQt.h"
+#include "WebEventFactoryQt.h"
+#include "WebPopupMenuProxyQt.h"
+#include "WKStringQt.h"
+#include "WKURLQt.h"
+#include "ViewportArguments.h"
+#include <QAction>
+#include <QApplication>
+#include <QGraphicsSceneMouseEvent>
+#include <QStyle>
+#include <QTouchEvent>
+#include <QtDebug>
+#include <WebCore/Cursor.h>
+#include <WebCore/FloatRect.h>
+#include <WebKit2/WKFrame.h>
+#include <WebKit2/WKPageGroup.h>
+#include <WebKit2/WKRetainPtr.h>
+
+using namespace WebKit;
+using namespace WebCore;
+
+static WebCore::ContextMenuAction contextMenuActionForWebAction(QWKPage::WebAction action)
+{
+    switch (action) {
+    case QWKPage::OpenLink:
+        return WebCore::ContextMenuItemTagOpenLink;
+    case QWKPage::OpenLinkInNewWindow:
+        return WebCore::ContextMenuItemTagOpenLinkInNewWindow;
+    case QWKPage::CopyLinkToClipboard:
+        return WebCore::ContextMenuItemTagCopyLinkToClipboard;
+    case QWKPage::OpenImageInNewWindow:
+        return WebCore::ContextMenuItemTagOpenImageInNewWindow;
+    case QWKPage::Cut:
+        return WebCore::ContextMenuItemTagCut;
+    case QWKPage::Copy:
+        return WebCore::ContextMenuItemTagCopy;
+    case QWKPage::Paste:
+        return WebCore::ContextMenuItemTagPaste;
+    case QWKPage::SelectAll:
+        return WebCore::ContextMenuItemTagSelectAll;
+    default:
+        ASSERT(false);
+        break;
+    }
+    return WebCore::ContextMenuItemTagNoAction;
+}
+
+QWKPagePrivate::QWKPagePrivate(QWKPage* qq, QWKContext* c)
+    : q(qq)
+    , view(0)
+    , context(c)
+    , preferences(0)
+    , createNewPageFn(0)
+{
+    memset(actions, 0, sizeof(actions));
+    page = context->d->context->createWebPage(this, 0);
+    history = QWKHistoryPrivate::createHistory(page->backForwardList());
+}
+
+QWKPagePrivate::~QWKPagePrivate()
+{
+    page->close();
+    delete history;
+}
+
+void QWKPagePrivate::init(QGraphicsItem* view, PassOwnPtr<DrawingAreaProxy> proxy)
+{
+    this->view = view;
+    page->setDrawingArea(proxy);
+    page->initializeWebPage();
+}
+
+void QWKPagePrivate::setCursor(const WebCore::Cursor& cursor)
+{
+#ifndef QT_NO_CURSOR
+    emit q->cursorChanged(*cursor.platformCursor());
+#endif
+}
+
+void QWKPagePrivate::setViewportArguments(const ViewportArguments& args)
+{
+    viewportArguments = args;
+    emit q->viewportChangeRequested();
+}
+
+void QWKPagePrivate::takeFocus(bool direction)
+{
+    emit q->focusNextPrevChild(direction);
+}
+
+PassOwnPtr<DrawingAreaProxy> QWKPagePrivate::createDrawingAreaProxy()
+{
+    // FIXME: We should avoid this cast by decoupling the view from the page.
+    QGraphicsWKView* wkView = static_cast<QGraphicsWKView*>(view);
+
+#if ENABLE(TILED_BACKING_STORE)
+    if (page->drawingArea()->info().type == DrawingAreaInfo::Tiled)
+        return TiledDrawingAreaProxy::create(wkView, page.get());
+#endif
+    return ChunkedUpdateDrawingAreaProxy::create(wkView, page.get());
+}
+
+void QWKPagePrivate::setViewNeedsDisplay(const WebCore::IntRect& rect)
+{
+    view->update(QRect(rect));
+}
+
+void QWKPagePrivate::displayView()
+{
+    // FIXME: Implement.
+}
+
+WebCore::IntSize QWKPagePrivate::viewSize()
+{
+    // FIXME: Implement.
+    return WebCore::IntSize();
+}
+
+bool QWKPagePrivate::isViewWindowActive()
+{
+    // FIXME: Implement.
+    return true;
+}
+
+bool QWKPagePrivate::isViewFocused()
+{
+    // FIXME: Implement.
+    return true;
+}
+
+bool QWKPagePrivate::isViewVisible()
+{
+    // FIXME: Implement.
+    return true;
+}
+
+bool QWKPagePrivate::isViewInWindow()
+{
+    // FIXME: Implement.
+    return true;
+}
+
+void QWKPagePrivate::pageDidRequestScroll(const IntSize& delta)
+{
+    emit q->scrollRequested(delta.width(), delta.height());
+}
+
+void QWKPagePrivate::didChangeContentsSize(const IntSize& newSize)
+{
+    emit q->contentsSizeChanged(QSize(newSize));
+}
+
+void QWKPagePrivate::toolTipChanged(const String&, const String& newTooltip)
+{
+    emit q->statusBarMessage(QString(newTooltip));
+}
+
+void QWKPagePrivate::registerEditCommand(PassRefPtr<WebEditCommandProxy>, WebPageProxy::UndoOrRedo)
+{
+}
+
+void QWKPagePrivate::clearAllEditCommands()
+{
+}
+
+FloatRect QWKPagePrivate::convertToDeviceSpace(const FloatRect& rect)
+{
+    return rect;
+}
+
+FloatRect QWKPagePrivate::convertToUserSpace(const FloatRect& rect)
+{
+    return rect;
+}
+
+void QWKPagePrivate::selectionChanged(bool, bool, bool, bool)
+{
+}
+
+void QWKPagePrivate::didNotHandleKeyEvent(const NativeWebKeyboardEvent&)
+{
+}
+
+PassRefPtr<WebPopupMenuProxy> QWKPagePrivate::createPopupMenuProxy(WebPageProxy*)
+{
+    return WebPopupMenuProxyQt::create();
+}
+
+PassRefPtr<WebContextMenuProxy> QWKPagePrivate::createContextMenuProxy(WebPageProxy*)
+{
+    return WebContextMenuProxyQt::create(q);
+}
+
+void QWKPagePrivate::setFindIndicator(PassRefPtr<FindIndicator>, bool fadeOut)
+{
+}
+
+void QWKPagePrivate::didCommitLoadForMainFrame(bool useCustomRepresentation)
+{
+}
+
+void QWKPagePrivate::didFinishLoadingDataForCustomRepresentation(const CoreIPC::DataReference&)
+{
+}
+
+void QWKPagePrivate::paint(QPainter* painter, QRect area)
+{
+    if (page->isValid() && page->drawingArea())
+        page->drawingArea()->paint(IntRect(area), painter);
+    else
+        painter->fillRect(area, Qt::white);
+}
+
+void QWKPagePrivate::keyPressEvent(QKeyEvent* ev)
+{
+    page->handleKeyboardEvent(NativeWebKeyboardEvent(ev));
+}
+
+void QWKPagePrivate::keyReleaseEvent(QKeyEvent* ev)
+{
+    page->handleKeyboardEvent(NativeWebKeyboardEvent(ev));
+}
+
+void QWKPagePrivate::mouseMoveEvent(QGraphicsSceneMouseEvent* ev)
+{
+    // For some reason mouse press results in mouse hover (which is
+    // converted to mouse move for WebKit). We ignore these hover
+    // events by comparing lastPos with newPos.
+    // NOTE: lastPos from the event always comes empty, so we work
+    // around that here.
+    static QPointF lastPos = QPointF();
+    if (lastPos == ev->pos())
+        return;
+    lastPos = ev->pos();
+
+    WebMouseEvent mouseEvent = WebEventFactory::createWebMouseEvent(ev, 0);
+    page->handleMouseEvent(mouseEvent);
+}
+
+void QWKPagePrivate::mousePressEvent(QGraphicsSceneMouseEvent* ev)
+{
+    if (tripleClickTimer.isActive() && (ev->pos() - tripleClick).manhattanLength() < QApplication::startDragDistance()) {
+        WebMouseEvent mouseEvent = WebEventFactory::createWebMouseEvent(ev, 3);
+        page->handleMouseEvent(mouseEvent);
+        return;
+    }
+
+    WebMouseEvent mouseEvent = WebEventFactory::createWebMouseEvent(ev, 1);
+    page->handleMouseEvent(mouseEvent);
+}
+
+void QWKPagePrivate::mouseReleaseEvent(QGraphicsSceneMouseEvent* ev)
+{
+    WebMouseEvent mouseEvent = WebEventFactory::createWebMouseEvent(ev, 0);
+    page->handleMouseEvent(mouseEvent);
+}
+
+void QWKPagePrivate::mouseDoubleClickEvent(QGraphicsSceneMouseEvent* ev)
+{
+    WebMouseEvent mouseEvent = WebEventFactory::createWebMouseEvent(ev, 2);
+    page->handleMouseEvent(mouseEvent);
+
+    tripleClickTimer.start(QApplication::doubleClickInterval(), q);
+    tripleClick = ev->pos().toPoint();
+}
+
+void QWKPagePrivate::wheelEvent(QGraphicsSceneWheelEvent* ev)
+{
+    WebWheelEvent wheelEvent = WebEventFactory::createWebWheelEvent(ev);
+    page->handleWheelEvent(wheelEvent);
+}
+
+void QWKPagePrivate::setEditCommandState(const WTF::String&, bool, int)
+{
+}
+
+void QWKPagePrivate::updateAction(QWKPage::WebAction action)
+{
+#ifdef QT_NO_ACTION
+    Q_UNUSED(action)
+#else
+    QAction* a = actions[action];
+    if (!a)
+        return;
+
+    RefPtr<WebKit::WebFrameProxy> mainFrame = page->mainFrame();
+    if (!mainFrame)
+        return;
+
+    bool enabled = a->isEnabled();
+    bool checked = a->isChecked();
+
+    switch (action) {
+    case QWKPage::Back:
+        enabled = page->canGoBack();
+        break;
+    case QWKPage::Forward:
+        enabled = page->canGoForward();
+        break;
+    case QWKPage::Stop:
+        enabled = !(WebFrameProxy::LoadStateFinished == mainFrame->loadState());
+        break;
+    case QWKPage::Reload:
+        enabled = (WebFrameProxy::LoadStateFinished == mainFrame->loadState());
+        break;
+    default:
+        break;
+    }
+
+    a->setEnabled(enabled);
+
+    if (a->isCheckable())
+        a->setChecked(checked);
+#endif // QT_NO_ACTION
+}
+
+void QWKPagePrivate::updateNavigationActions()
+{
+    updateAction(QWKPage::Back);
+    updateAction(QWKPage::Forward);
+    updateAction(QWKPage::Stop);
+    updateAction(QWKPage::Reload);
+}
+
+#ifndef QT_NO_ACTION
+void QWKPagePrivate::_q_webActionTriggered(bool checked)
+{
+    QAction* a = qobject_cast<QAction*>(q->sender());
+    if (!a)
+        return;
+    QWKPage::WebAction action = static_cast<QWKPage::WebAction>(a->data().toInt());
+    q->triggerAction(action, checked);
+}
+#endif // QT_NO_ACTION
+
+void QWKPagePrivate::touchEvent(QTouchEvent* event)
+{
+#if ENABLE(TOUCH_EVENTS)
+    WebTouchEvent touchEvent = WebEventFactory::createWebTouchEvent(event);
+    page->handleTouchEvent(touchEvent);
+#else
+    event->ignore();
+#endif
+}
+
+QWKPage::QWKPage(QWKContext* context)
+    : d(new QWKPagePrivate(this, context))
+{
+    WKPageLoaderClient loadClient = {
+        0,      /* version */
+        this,   /* clientInfo */
+        qt_wk_didStartProvisionalLoadForFrame,
+        qt_wk_didReceiveServerRedirectForProvisionalLoadForFrame,
+        qt_wk_didFailProvisionalLoadWithErrorForFrame,
+        qt_wk_didCommitLoadForFrame,
+        qt_wk_didFinishDocumentLoadForFrame,
+        qt_wk_didFinishLoadForFrame,
+        qt_wk_didFailLoadWithErrorForFrame,
+        0, /* didSameDocumentNavigationForFrame */
+        qt_wk_didReceiveTitleForFrame,
+        qt_wk_didFirstLayoutForFrame,
+        qt_wk_didFirstVisuallyNonEmptyLayoutForFrame,
+        qt_wk_didRemoveFrameFromHierarchy,
+        0, /* didDisplayInsecureContentForFrame */
+        0, /* didRunInsecureContentForFrame */
+        0, /* canAuthenticateAgainstProtectionSpaceInFrame */
+        0, /* didReceiveAuthenticationChallengeInFrame */
+        qt_wk_didStartProgress,
+        qt_wk_didChangeProgress,
+        qt_wk_didFinishProgress,
+        qt_wk_didBecomeUnresponsive,
+        qt_wk_didBecomeResponsive,
+        0,  /* processDidCrash */
+        0   /* didChangeBackForwardList */
+    };
+    WKPageSetPageLoaderClient(pageRef(), &loadClient);
+
+    WKPageUIClient uiClient = {
+        0,      /* version */
+        this,   /* clientInfo */
+        qt_wk_createNewPage,
+        qt_wk_showPage,
+        qt_wk_close,
+        qt_wk_runJavaScriptAlert,
+        0,  /* runJavaScriptConfirm */
+        0,  /* runJavaScriptPrompt */
+        0,  /* setStatusText */
+        0,  /* mouseDidMoveOverElement */
+        0,  /* missingPluginButtonClicked */
+        0,  /* didNotHandleKeyEvent */
+        0,  /* toolbarsAreVisible */
+        0,  /* setToolbarsAreVisible */
+        0,  /* menuBarIsVisible */
+        0,  /* setMenuBarIsVisible */
+        0,  /* statusBarIsVisible */
+        0,  /* setStatusBarIsVisible */
+        0,  /* isResizable */
+        0,  /* setIsResizable */
+        0,  /* getWindowFrame */
+        0,  /* setWindowFrame */
+        0,  /* runBeforeUnloadConfirmPanel */
+        0,  /* didDraw */
+        0,  /* pageDidScroll */
+        0,  /* exceededDatabaseQuota */
+        0,  /* runOpenPanel */
+        0   /* decidePolicyForGeolocationPermissionRequest */
+    };
+    WKPageSetPageUIClient(pageRef(), &uiClient);
+}
+
+QWKPage::~QWKPage()
+{
+    delete d;
+}
+
+QWKPage::ViewportAttributes::ViewportAttributes()
+    : d(0)
+    , m_initialScaleFactor(-1.0)
+    , m_minimumScaleFactor(-1.0)
+    , m_maximumScaleFactor(-1.0)
+    , m_devicePixelRatio(-1.0)
+    , m_isUserScalable(true)
+    , m_isValid(false)
+{
+
+}
+
+QWKPage::ViewportAttributes::ViewportAttributes(const QWKPage::ViewportAttributes& other)
+    : d(other.d)
+    , m_initialScaleFactor(other.m_initialScaleFactor)
+    , m_minimumScaleFactor(other.m_minimumScaleFactor)
+    , m_maximumScaleFactor(other.m_maximumScaleFactor)
+    , m_devicePixelRatio(other.m_devicePixelRatio)
+    , m_isUserScalable(other.m_isUserScalable)
+    , m_isValid(other.m_isValid)
+    , m_size(other.m_size)
+{
+
+}
+
+QWKPage::ViewportAttributes::~ViewportAttributes()
+{
+
+}
+
+QWKPage::ViewportAttributes& QWKPage::ViewportAttributes::operator=(const QWKPage::ViewportAttributes& other)
+{
+    if (this != &other) {
+        d = other.d;
+        m_initialScaleFactor = other.m_initialScaleFactor;
+        m_minimumScaleFactor = other.m_minimumScaleFactor;
+        m_maximumScaleFactor = other.m_maximumScaleFactor;
+        m_devicePixelRatio = other.m_devicePixelRatio;
+        m_isUserScalable = other.m_isUserScalable;
+        m_isValid = other.m_isValid;
+        m_size = other.m_size;
+    }
+
+    return *this;
+}
+
+QWKPage::ViewportAttributes QWKPage::viewportAttributesForSize(const QSize& availableSize) const
+{
+    static int desktopWidth = 980;
+    static int deviceDPI = 160;
+
+    ViewportAttributes result;
+
+     if (availableSize.isEmpty())
+         return result; // Returns an invalid instance.
+
+    // FIXME: Add a way to get these data via the platform plugin and fall back
+    // to the size of the view.
+    int deviceWidth = 480;
+    int deviceHeight = 864;
+
+    WebCore::ViewportAttributes conf = WebCore::computeViewportAttributes(d->viewportArguments, desktopWidth, deviceWidth, deviceHeight, deviceDPI, availableSize);
+
+    result.m_isValid = true;
+    result.m_size = conf.layoutSize;
+    result.m_initialScaleFactor = conf.initialScale;
+    result.m_minimumScaleFactor = conf.minimumScale;
+    result.m_maximumScaleFactor = conf.maximumScale;
+    result.m_devicePixelRatio = conf.devicePixelRatio;
+    result.m_isUserScalable = conf.userScalable;
+
+    return result;
+}
+
+void QWKPage::setActualVisibleContentsRect(const QRect& rect) const
+{
+#if ENABLE(TILED_BACKING_STORE)
+    d->page->setActualVisibleContentRect(rect);
+#endif
+}
+
+void QWKPage::timerEvent(QTimerEvent* ev)
+{
+    int timerId = ev->timerId();
+    if (timerId == d->tripleClickTimer.timerId())
+        d->tripleClickTimer.stop();
+    else
+        QObject::timerEvent(ev);
+}
+
+WKPageRef QWKPage::pageRef() const
+{
+    return toAPI(d->page.get());
+}
+
+QWKContext* QWKPage::context() const
+{
+    return d->context;
+}
+
+QWKPreferences* QWKPage::preferences() const
+{
+    if (!d->preferences) {
+        WKPageGroupRef pageGroupRef = WKPageGetPageGroup(pageRef());
+        d->preferences = QWKPreferencesPrivate::createPreferences(pageGroupRef);
+    }
+
+    return d->preferences;
+}
+
+void QWKPage::setCreateNewPageFunction(CreateNewPageFn function)
+{
+    d->createNewPageFn = function;
+}
+
+void QWKPage::setCustomUserAgent(const QString& userAgent)
+{
+    WKRetainPtr<WKStringRef> wkUserAgent(WKStringCreateWithQString(userAgent));
+    WKPageSetCustomUserAgent(pageRef(), wkUserAgent.get());
+}
+
+QString QWKPage::customUserAgent() const
+{
+    return WKStringCopyQString(WKPageCopyCustomUserAgent(pageRef()));
+}
+
+void QWKPage::load(const QUrl& url)
+{
+    WKRetainPtr<WKURLRef> wkurl(WKURLCreateWithQUrl(url));
+    WKPageLoadURL(pageRef(), wkurl.get());
+}
+
+void QWKPage::setUrl(const QUrl& url)
+{
+    load(url);
+}
+
+QUrl QWKPage::url() const
+{
+    WKRetainPtr<WKFrameRef> frame = WKPageGetMainFrame(pageRef());
+    if (!frame)
+        return QUrl();
+    return WKURLCopyQUrl(WKFrameCopyURL(frame.get()));
+}
+
+QString QWKPage::title() const
+{
+    return WKStringCopyQString(WKPageCopyTitle(pageRef()));
+}
+
+void QWKPage::setViewportSize(const QSize& size)
+{
+    if (d->page->drawingArea())
+        d->page->drawingArea()->setSize(IntSize(size));
+}
+
+qreal QWKPage::textZoomFactor() const
+{
+    return WKPageGetTextZoomFactor(pageRef());
+}
+
+void QWKPage::setTextZoomFactor(qreal zoomFactor)
+{
+    WKPageSetTextZoomFactor(pageRef(), zoomFactor);
+}
+
+qreal QWKPage::pageZoomFactor() const
+{
+    return WKPageGetPageZoomFactor(pageRef());
+}
+
+void QWKPage::setPageZoomFactor(qreal zoomFactor)
+{
+    WKPageSetPageZoomFactor(pageRef(), zoomFactor);
+}
+
+void QWKPage::setPageAndTextZoomFactors(qreal pageZoomFactor, qreal textZoomFactor)
+{
+    WKPageSetPageAndTextZoomFactors(pageRef(), pageZoomFactor, textZoomFactor);
+}
+
+QWKHistory* QWKPage::history() const
+{
+    return d->history;
+}
+
+void QWKPage::setResizesToContentsUsingLayoutSize(const QSize& targetLayoutSize)
+{
+#if ENABLE(TILED_BACKING_STORE)
+    d->page->setResizesToContentsUsingLayoutSize(targetLayoutSize);
+#endif
+}
+
+#ifndef QT_NO_ACTION
+void QWKPage::triggerAction(WebAction webAction, bool)
+{
+    switch (webAction) {
+    case Back:
+        d->page->goBack();
+        return;
+    case Forward:
+        d->page->goForward();
+        return;
+    case Stop:
+        d->page->stopLoading();
+        return;
+    case Reload:
+        d->page->reload(/* reloadFromOrigin */ true);
+        return;
+    default:
+        break;
+    }
+
+    QAction* qtAction = action(webAction);
+    WebKit::WebContextMenuItemData menuItemData(ActionType, contextMenuActionForWebAction(webAction), qtAction->text(), qtAction->isEnabled(), qtAction->isChecked());
+    d->page->contextMenuItemSelected(menuItemData);
+}
+#endif // QT_NO_ACTION
+
+#ifndef QT_NO_ACTION
+QAction* QWKPage::action(WebAction action) const
+{
+    if (action == QWKPage::NoWebAction || action >= WebActionCount)
+        return 0;
+
+    if (d->actions[action])
+        return d->actions[action];
+
+    QString text;
+    QIcon icon;
+    QStyle* style = qobject_cast<QApplication*>(QCoreApplication::instance())->style();
+    bool checkable = false;
+
+    switch (action) {
+    case OpenLink:
+        text = contextMenuItemTagOpenLink();
+        break;
+    case OpenLinkInNewWindow:
+        text = contextMenuItemTagOpenLinkInNewWindow();
+        break;
+    case CopyLinkToClipboard:
+        text = contextMenuItemTagCopyLinkToClipboard();
+        break;
+    case OpenImageInNewWindow:
+        text = contextMenuItemTagOpenImageInNewWindow();
+        break;
+    case Back:
+        text = contextMenuItemTagGoBack();
+        icon = style->standardIcon(QStyle::SP_ArrowBack);
+        break;
+    case Forward:
+        text = contextMenuItemTagGoForward();
+        icon = style->standardIcon(QStyle::SP_ArrowForward);
+        break;
+    case Stop:
+        text = contextMenuItemTagStop();
+        icon = style->standardIcon(QStyle::SP_BrowserStop);
+        break;
+    case Reload:
+        text = contextMenuItemTagReload();
+        icon = style->standardIcon(QStyle::SP_BrowserReload);
+        break;
+    case Cut:
+        text = contextMenuItemTagCut();
+        break;
+    case Copy:
+        text = contextMenuItemTagCopy();
+        break;
+    case Paste:
+        text = contextMenuItemTagPaste();
+        break;
+    case SelectAll:
+        text = contextMenuItemTagSelectAll();
+        break;
+    default:
+        return 0;
+        break;
+    }
+
+    if (text.isEmpty())
+        return 0;
+
+    QAction* a = new QAction(d->q);
+    a->setText(text);
+    a->setData(action);
+    a->setCheckable(checkable);
+    a->setIcon(icon);
+
+    connect(a, SIGNAL(triggered(bool)), this, SLOT(_q_webActionTriggered(bool)));
+
+    d->actions[action] = a;
+    d->updateAction(action);
+    return a;
+}
+#endif // QT_NO_ACTION
+
+void QWKPage::findZoomableAreaForPoint(const QPoint& point)
+{
+    d->page->findZoomableAreaForPoint(point);
+}
+
+void QWKPagePrivate::didFindZoomableArea(const IntRect& area)
+{
+    emit q->zoomableAreaFound(QRect(area));
+}
+
+#include "moc_qwkpage.cpp"
diff --git a/Source/WebKit2/UIProcess/API/qt/qwkpage.h b/Source/WebKit2/UIProcess/API/qt/qwkpage.h
new file mode 100644
index 0000000..e0bb4c3
--- /dev/null
+++ b/Source/WebKit2/UIProcess/API/qt/qwkpage.h
@@ -0,0 +1,151 @@
+#ifndef qwkpage_h
+#define qwkpage_h
+
+#include "qwebkitglobal.h"
+#include <QAction>
+#include <QObject>
+#include <QPoint>
+#include <QRect>
+#include <QSize>
+#include <QUrl>
+#include <WebKit2/WKBase.h>
+#include <WebKit2/WKPage.h>
+
+class QCursor;
+class QGraphicsItem;
+class QWKContext;
+class QWKGraphicsWidget;
+class QWKPreferences;
+class QWKPagePrivate;
+class QtViewportAttributesPrivate;
+class QWKHistory;
+
+class QWEBKIT_EXPORT QWKPage : public QObject {
+    Q_OBJECT
+    Q_PROPERTY(QString title READ title)
+    Q_PROPERTY(QUrl url READ url WRITE setUrl)
+
+public:
+    enum WebAction {
+        NoWebAction = - 1,
+
+        OpenLink,
+        OpenLinkInNewWindow,
+        CopyLinkToClipboard,
+        OpenImageInNewWindow,
+
+        Back,
+        Forward,
+        Stop,
+        Reload,
+
+        Cut,
+        Copy,
+        Paste,
+        SelectAll,
+
+        WebActionCount
+    };
+
+    class ViewportAttributes {
+    public:
+        ViewportAttributes();
+        ViewportAttributes(const QWKPage::ViewportAttributes& other);
+
+        ~ViewportAttributes();
+
+        QWKPage::ViewportAttributes& operator=(const QWKPage::ViewportAttributes& other);
+
+        inline qreal initialScaleFactor() const { return m_initialScaleFactor; };
+        inline qreal minimumScaleFactor() const { return m_minimumScaleFactor; };
+        inline qreal maximumScaleFactor() const { return m_maximumScaleFactor; };
+        inline qreal devicePixelRatio() const { return m_devicePixelRatio; };
+        inline bool isUserScalable() const { return m_isUserScalable; };
+        inline bool isValid() const { return m_isValid; };
+        inline QSize size() const { return m_size; };
+
+    private:
+        QSharedDataPointer<QtViewportAttributesPrivate> d;
+        qreal m_initialScaleFactor;
+        qreal m_minimumScaleFactor;
+        qreal m_maximumScaleFactor;
+        qreal m_devicePixelRatio;
+        bool m_isUserScalable;
+        bool m_isValid;
+        QSize m_size;
+
+        friend class QWKPage;
+    };
+
+    QWKPage(QWKContext*);
+    virtual ~QWKPage();
+
+    WKPageRef pageRef() const;
+
+    QWKPreferences* preferences() const;
+
+    void load(const QUrl& url);
+    void setUrl(const QUrl& url);
+    QUrl url() const;
+
+    QString title() const;
+
+    void setViewportSize(const QSize&);
+    ViewportAttributes viewportAttributesForSize(const QSize& availableSize) const;
+
+    void setActualVisibleContentsRect(const QRect& rect) const;
+
+    void setResizesToContentsUsingLayoutSize(const QSize& targetLayoutSize);
+
+    QAction* action(WebAction action) const;
+    void triggerAction(WebAction action, bool checked = false);
+
+    typedef QWKPage* (*CreateNewPageFn)(QWKPage*);
+    void setCreateNewPageFunction(CreateNewPageFn function);
+
+    void setCustomUserAgent(const QString&);
+    QString customUserAgent() const;
+
+    qreal textZoomFactor() const;
+    qreal pageZoomFactor() const;
+    void setTextZoomFactor(qreal zoomFactor);
+    void setPageZoomFactor(qreal zoomFactor);
+    void setPageAndTextZoomFactors(qreal pageZoomFactor, qreal textZoomFactor);
+
+    QWKHistory* history() const;
+    QWKContext* context() const;
+
+    void findZoomableAreaForPoint(const QPoint&);
+
+public:
+    Q_SIGNAL void statusBarMessage(const QString&);
+    Q_SIGNAL void titleChanged(const QString&);
+    Q_SIGNAL void loadStarted();
+    Q_SIGNAL void loadFinished(bool ok);
+    Q_SIGNAL void loadProgress(int progress);
+    Q_SIGNAL void initialLayoutCompleted();
+    Q_SIGNAL void urlChanged(const QUrl&);
+    Q_SIGNAL void contentsSizeChanged(const QSize&);
+    Q_SIGNAL void scrollRequested(int dx, int dy);
+    Q_SIGNAL void cursorChanged(const QCursor&);
+    Q_SIGNAL void viewportChangeRequested();
+    Q_SIGNAL void windowCloseRequested();
+    Q_SIGNAL void zoomableAreaFound(const QRect&);
+    Q_SIGNAL void focusNextPrevChild(bool);
+    Q_SIGNAL void showContextMenu(QMenu*);
+
+protected:
+    void timerEvent(QTimerEvent*);
+
+private:
+#ifndef QT_NO_ACTION
+    Q_PRIVATE_SLOT(d, void _q_webActionTriggered(bool checked));
+#endif
+    QWKPagePrivate* d;
+
+    friend class QGraphicsWKView;
+    friend class QGraphicsWKViewPrivate;
+    friend class QWKPagePrivate;
+};
+
+#endif /* qwkpage_h */
diff --git a/Source/WebKit2/UIProcess/API/qt/qwkpage_p.h b/Source/WebKit2/UIProcess/API/qt/qwkpage_p.h
new file mode 100644
index 0000000..85135c2
--- /dev/null
+++ b/Source/WebKit2/UIProcess/API/qt/qwkpage_p.h
@@ -0,0 +1,134 @@
+/*
+ * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
+ *
+ * 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 program 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 program; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef qwkpage_p_h
+#define qwkpage_p_h
+
+#include "DrawingAreaProxy.h"
+#include "PageClient.h"
+#include "qwkpage.h"
+#include "WebPageProxy.h"
+#include <wtf/PassOwnPtr.h>
+#include <wtf/RefPtr.h>
+#include <QBasicTimer>
+#include <QGraphicsView>
+#include <QKeyEvent>
+
+class QGraphicsWKView;
+class QWKPreferences;
+
+class QWKPagePrivate : WebKit::PageClient {
+public:
+    QWKPagePrivate(QWKPage*, QWKContext*);
+    ~QWKPagePrivate();
+
+    static QWKPagePrivate* get(QWKPage* page) { return page->d; }
+
+    void init(QGraphicsItem*, WTF::PassOwnPtr<WebKit::DrawingAreaProxy>);
+
+    // PageClient
+    virtual PassOwnPtr<WebKit::DrawingAreaProxy> createDrawingAreaProxy();
+    virtual void setViewNeedsDisplay(const WebCore::IntRect&);
+    virtual void displayView();
+
+    virtual WebCore::IntSize viewSize();
+    virtual bool isViewWindowActive();
+    virtual bool isViewFocused();
+    virtual bool isViewVisible();
+    virtual bool isViewInWindow();
+
+#if USE(ACCELERATED_COMPOSITING)
+    void pageDidEnterAcceleratedCompositing() { }
+    void pageDidLeaveAcceleratedCompositing() { }
+#endif // USE(ACCELERATED_COMPOSITING)
+    virtual void pageDidRequestScroll(const WebCore::IntSize&);
+    virtual void processDidCrash() { }
+    virtual void didRelaunchProcess() { }
+    virtual void didChangeContentsSize(const WebCore::IntSize&);
+    virtual void didFindZoomableArea(const WebCore::IntRect&);
+    virtual void setCursor(const WebCore::Cursor&);
+    virtual void setViewportArguments(const WebCore::ViewportArguments&);
+    virtual void takeFocus(bool direction);
+    virtual void toolTipChanged(const WTF::String&, const WTF::String&);
+    virtual void registerEditCommand(PassRefPtr<WebKit::WebEditCommandProxy>, WebKit::WebPageProxy::UndoOrRedo);
+    virtual void clearAllEditCommands();
+    virtual WebCore::FloatRect convertToDeviceSpace(const WebCore::FloatRect&);
+    virtual WebCore::FloatRect convertToUserSpace(const WebCore::FloatRect&);
+    virtual void didNotHandleKeyEvent(const WebKit::NativeWebKeyboardEvent&);
+    virtual void selectionChanged(bool, bool, bool, bool);
+    virtual PassRefPtr<WebKit::WebPopupMenuProxy> createPopupMenuProxy(WebKit::WebPageProxy*);
+    virtual PassRefPtr<WebKit::WebContextMenuProxy> createContextMenuProxy(WebKit::WebPageProxy*);
+
+    virtual void setFindIndicator(PassRefPtr<WebKit::FindIndicator>, bool fadeOut);
+
+    virtual void didCommitLoadForMainFrame(bool useCustomRepresentation);
+    virtual void didFinishLoadingDataForCustomRepresentation(const CoreIPC::DataReference&);
+    virtual double customRepresentationZoomFactor() { return 1; }
+    virtual void setCustomRepresentationZoomFactor(double) { }
+
+    void paint(QPainter* painter, QRect);
+
+    void keyPressEvent(QKeyEvent*);
+    void keyReleaseEvent(QKeyEvent*);
+    void mouseMoveEvent(QGraphicsSceneMouseEvent*);
+    void mousePressEvent(QGraphicsSceneMouseEvent*);
+    void mouseReleaseEvent(QGraphicsSceneMouseEvent*);
+    void mouseDoubleClickEvent(QGraphicsSceneMouseEvent*);
+    void wheelEvent(QGraphicsSceneWheelEvent*);
+
+    void updateAction(QWKPage::WebAction action);
+    void updateNavigationActions();
+    void updateEditorActions();
+    void setEditCommandState(const WTF::String&, bool, int);
+
+    void _q_webActionTriggered(bool checked);
+
+    void touchEvent(QTouchEvent*);
+
+    QWKPage* q;
+
+    QGraphicsItem* view;
+    QWKContext* context;
+    QWKHistory* history;
+
+    QAction* actions[QWKPage::WebActionCount];
+    QWKPreferences* preferences;
+
+    RefPtr<WebKit::WebPageProxy> page;
+
+    WebCore::ViewportArguments viewportArguments;
+
+    QWKPage::CreateNewPageFn createNewPageFn;
+
+    QPoint tripleClick;
+    QBasicTimer tripleClickTimer;
+};
+
+class QtViewportAttributesPrivate : public QSharedData {
+public:
+    QtViewportAttributesPrivate(QWKPage::ViewportAttributes* qq)
+        : q(qq)
+    { }
+
+    QWKPage::ViewportAttributes* q;
+};
+
+
+#endif /* qkpage_p_h */
diff --git a/Source/WebKit2/UIProcess/API/qt/qwkpreferences.cpp b/Source/WebKit2/UIProcess/API/qt/qwkpreferences.cpp
new file mode 100644
index 0000000..dea18aa
--- /dev/null
+++ b/Source/WebKit2/UIProcess/API/qt/qwkpreferences.cpp
@@ -0,0 +1,185 @@
+/*
+    Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
+
+    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 "qwkpreferences.h"
+
+#include "WKPageGroup.h"
+#include "WKPreferences.h"
+#include "WKStringQt.h"
+#include "WKRetainPtr.h"
+#include "qwkpreferences_p.h"
+
+
+QWKPreferences* QWKPreferencesPrivate::createPreferences(WKPageGroupRef pageGroupRef)
+{
+    QWKPreferences* prefs = new QWKPreferences;
+    prefs->d->ref = WKPageGroupGetPreferences(pageGroupRef);
+    return prefs;
+}
+
+QWKPreferences* QWKPreferencesPrivate::createSharedPreferences()
+{
+    QWKPreferences* prefs = new QWKPreferences;
+    prefs->d->ref = WKPreferencesCreate();
+    return prefs;
+}
+
+QWKPreferences* QWKPreferences::sharedPreferences()
+{
+    static QWKPreferences* instance = 0;
+
+    if (!instance)
+        instance = QWKPreferencesPrivate::createSharedPreferences();
+    return instance;
+}
+
+QWKPreferences::QWKPreferences()
+    : d(new QWKPreferencesPrivate)
+{
+}
+
+QWKPreferences::~QWKPreferences()
+{
+    delete d;
+}
+
+void QWKPreferences::setFontFamily(FontFamily which, const QString& family)
+{
+    switch (which) {
+    case StandardFont:
+        WKPreferencesSetStandardFontFamily(d->ref, WKStringCreateWithQString(family));
+        break;
+    case FixedFont:
+        WKPreferencesSetFixedFontFamily(d->ref, WKStringCreateWithQString(family));
+        break;
+    case SerifFont:
+        WKPreferencesSetSerifFontFamily(d->ref, WKStringCreateWithQString(family));
+        break;
+    case SansSerifFont:
+        WKPreferencesSetSansSerifFontFamily(d->ref, WKStringCreateWithQString(family));
+        break;
+    case CursiveFont:
+        WKPreferencesSetCursiveFontFamily(d->ref, WKStringCreateWithQString(family));
+        break;
+    case FantasyFont:
+        WKPreferencesSetFantasyFontFamily(d->ref, WKStringCreateWithQString(family));
+        break;
+    default:
+        break;
+    }
+}
+
+QString QWKPreferences::fontFamily(FontFamily which) const
+{
+    switch (which) {
+    case StandardFont: {
+        WKRetainPtr<WKStringRef> stringRef(AdoptWK, WKPreferencesCopyStandardFontFamily(d->ref));
+        return WKStringCopyQString(stringRef.get());
+    }
+    case FixedFont: {
+        WKRetainPtr<WKStringRef> stringRef(AdoptWK, WKPreferencesCopyFixedFontFamily(d->ref));
+        return WKStringCopyQString(stringRef.get());
+    }
+    case SerifFont: {
+        WKRetainPtr<WKStringRef> stringRef(AdoptWK, WKPreferencesCopySerifFontFamily(d->ref));
+        return WKStringCopyQString(stringRef.get());
+    }
+    case SansSerifFont: {
+        WKRetainPtr<WKStringRef> stringRef(AdoptWK, WKPreferencesCopySansSerifFontFamily(d->ref));
+        return WKStringCopyQString(stringRef.get());
+    }
+    case CursiveFont: {
+        WKRetainPtr<WKStringRef> stringRef(AdoptWK, WKPreferencesCopyCursiveFontFamily(d->ref));
+        return WKStringCopyQString(stringRef.get());
+    }
+    case FantasyFont: {
+        WKRetainPtr<WKStringRef> stringRef(AdoptWK, WKPreferencesCopyFantasyFontFamily(d->ref));
+        return WKStringCopyQString(stringRef.get());
+    }
+    default:
+        return QString();
+    }
+}
+
+bool QWKPreferences::testAttribute(WebAttribute attr) const
+{
+    switch (attr) {
+    case AutoLoadImages:
+        return WKPreferencesGetLoadsImagesAutomatically(d->ref);
+    case JavascriptEnabled:
+        return WKPreferencesGetJavaScriptEnabled(d->ref);
+    case PluginsEnabled:
+        return WKPreferencesGetPluginsEnabled(d->ref);
+    case OfflineWebApplicationCacheEnabled:
+        return WKPreferencesGetOfflineWebApplicationCacheEnabled(d->ref);
+    case LocalStorageEnabled:
+        return WKPreferencesGetLocalStorageEnabled(d->ref);
+    case XSSAuditingEnabled:
+        return WKPreferencesGetXSSAuditorEnabled(d->ref);
+    case FrameFlatteningEnabled:
+        return WKPreferencesGetFrameFlatteningEnabled(d->ref);
+    case PrivateBrowsingEnabled:
+        return WKPreferencesGetPrivateBrowsingEnabled(d->ref);
+    case DeveloperExtrasEnabled:
+        return WKPreferencesGetDeveloperExtrasEnabled(d->ref);
+    case DnsPrefetchEnabled:
+        return WKPreferencesGetDNSPrefetchingEnabled(d->ref);
+    default:
+        ASSERT_NOT_REACHED();
+        return false;
+    }
+}
+
+void QWKPreferences::setAttribute(WebAttribute attr, bool on)
+{
+    switch (attr) {
+    case AutoLoadImages:
+        WKPreferencesSetLoadsImagesAutomatically(d->ref, on);
+        break;
+    case JavascriptEnabled:
+        WKPreferencesSetJavaScriptEnabled(d->ref, on);
+        break;
+    case PluginsEnabled:
+        WKPreferencesSetPluginsEnabled(d->ref, on);
+        break;
+    case OfflineWebApplicationCacheEnabled:
+        WKPreferencesSetOfflineWebApplicationCacheEnabled(d->ref, on);
+        break;
+    case LocalStorageEnabled:
+        WKPreferencesSetLocalStorageEnabled(d->ref, on);
+        break;
+    case XSSAuditingEnabled:
+        WKPreferencesSetXSSAuditorEnabled(d->ref, on);
+        break;
+    case FrameFlatteningEnabled:
+        WKPreferencesSetFrameFlatteningEnabled(d->ref, on);
+        break;
+    case PrivateBrowsingEnabled:
+        WKPreferencesSetPrivateBrowsingEnabled(d->ref, on);
+        break;
+    case DeveloperExtrasEnabled:
+        WKPreferencesSetDeveloperExtrasEnabled(d->ref, on);
+        break;
+    case DnsPrefetchEnabled:
+        WKPreferencesSetDNSPrefetchingEnabled(d->ref, on);
+        break;
+    default:
+        ASSERT_NOT_REACHED();
+    }
+}
diff --git a/Source/WebKit2/UIProcess/API/qt/qwkpreferences.h b/Source/WebKit2/UIProcess/API/qt/qwkpreferences.h
new file mode 100644
index 0000000..d9f7bc0
--- /dev/null
+++ b/Source/WebKit2/UIProcess/API/qt/qwkpreferences.h
@@ -0,0 +1,72 @@
+/*
+    Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
+
+    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.
+*/
+
+#ifndef QWKPREFERENCES_H
+#define QWKPREFERENCES_H
+
+#include "qwebkitglobal.h"
+
+class QWKPage;
+class QWKPreferencesPrivate;
+
+class QWEBKIT_EXPORT QWKPreferences {
+public:
+    enum FontFamily {
+        StandardFont,
+        FixedFont,
+        SerifFont,
+        SansSerifFont,
+        CursiveFont,
+        FantasyFont
+    };
+
+    enum WebAttribute {
+        AutoLoadImages,
+        JavascriptEnabled,
+        PluginsEnabled,
+        OfflineWebApplicationCacheEnabled,
+        LocalStorageEnabled,
+        XSSAuditingEnabled,
+        FrameFlatteningEnabled,
+        PrivateBrowsingEnabled,
+        DeveloperExtrasEnabled,
+        DnsPrefetchEnabled
+    };
+
+    static QWKPreferences* sharedPreferences();
+
+    void setFontFamily(FontFamily which, const QString& family);
+    QString fontFamily(FontFamily which) const;
+
+    void setAttribute(WebAttribute attr, bool on);
+    bool testAttribute(WebAttribute attr) const;
+
+private:
+    Q_DISABLE_COPY(QWKPreferences)
+
+    QWKPreferences();
+    ~QWKPreferences();
+
+    QWKPreferencesPrivate *d;
+
+    friend class QWKPage;
+    friend class QWKPreferencesPrivate;
+};
+
+#endif // QWKPREFERENCES_H
diff --git a/Source/WebKit2/UIProcess/API/qt/qwkpreferences_p.h b/Source/WebKit2/UIProcess/API/qt/qwkpreferences_p.h
new file mode 100644
index 0000000..7fe2389
--- /dev/null
+++ b/Source/WebKit2/UIProcess/API/qt/qwkpreferences_p.h
@@ -0,0 +1,28 @@
+/*
+    Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
+
+    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 "WKPreferences.h"
+
+class QWKPreferencesPrivate {
+public:
+    static QWKPreferences* createPreferences(WKPageGroupRef);
+    static QWKPreferences* createSharedPreferences();
+
+    WKPreferencesRef ref;
+};