Merge branch '4.7' of scm.dev.nokia.troll.no:qt/qt into 4.7

17 files changed, 2050 insertions, 42 deletions

diff --git a/src/3rdparty/webkit/WebKit/qt/Api/qwebframe.cpp b/src/3rdparty/webkit/WebKit/qt/Api/qwebframe.cpp
index 721aaa6..cc7b11c 100644
--- a/src/3rdparty/webkit/WebKit/qt/Api/qwebframe.cpp
+++ b/src/3rdparty/webkit/WebKit/qt/Api/qwebframe.cpp
@@ -1431,8 +1431,8 @@ void QWebFrame::print(QPrinter *printer) const
     if (!painter.begin(printer))
         return;
 
-    const qreal zoomFactorX = printer->logicalDpiX() / qt_defaultDpi();
-    const qreal zoomFactorY = printer->logicalDpiY() / qt_defaultDpi();
+    const qreal zoomFactorX = (qreal)printer->logicalDpiX() / qt_defaultDpi();
+    const qreal zoomFactorY = (qreal)printer->logicalDpiY() / qt_defaultDpi();
 
     PrintContext printContext(d->frame);
     float pageHeight = 0;
diff --git a/src/3rdparty/webkit/WebKit/qt/Api/qwebpage.cpp b/src/3rdparty/webkit/WebKit/qt/Api/qwebpage.cpp
index 4460ad3..9a4e9b2 100644
--- a/src/3rdparty/webkit/WebKit/qt/Api/qwebpage.cpp
+++ b/src/3rdparty/webkit/WebKit/qt/Api/qwebpage.cpp
@@ -453,6 +453,9 @@ QWebPagePrivate::QWebPagePrivate(QWebPage *qq)
     WebCore::InitializeLoggingChannelsIfNecessary();
     JSC::initializeThreading();
     WebCore::SecurityOrigin::setLocalLoadPolicy(WebCore::SecurityOrigin::AllowLocalLoadsForLocalAndSubstituteData);
+#if QT_VERSION < QT_VERSION_CHECK(4, 7, 0)
+    WebCore::Font::setCodePath(WebCore::Font::Complex);
+#endif
 
     chromeClient = new ChromeClientQt(q);
     contextMenuClient = new ContextMenuClientQt();
@@ -766,7 +769,7 @@ void QWebPagePrivate::timerEvent(QTimerEvent *ev)
     if (timerId == tripleClickTimer.timerId())
         tripleClickTimer.stop();
     else
-        q->QObject::timerEvent(ev);
+        q->timerEvent(ev);
 }
 
 void QWebPagePrivate::mouseMoveEvent(QGraphicsSceneMouseEvent* ev)
diff --git a/src/3rdparty/webkit/WebKit/qt/ChangeLog b/src/3rdparty/webkit/WebKit/qt/ChangeLog
index 475d22d..0e73680 100644
--- a/src/3rdparty/webkit/WebKit/qt/ChangeLog
+++ b/src/3rdparty/webkit/WebKit/qt/ChangeLog
@@ -1,3 +1,331 @@
+2010-06-11  Jocelyn Turcotte  <jocelyn.turcotte@nokia.com>
+
+        Reviewed by nobody, build fix.
+
+        [Qt] Second fix attempt for the build break introduced by r61002.
+
+        * Api/qwebpage.cpp:
+        (QWebPagePrivate::QWebPagePrivate):
+
+2010-06-11  Jocelyn Turcotte  <jocelyn.turcotte@nokia.com>
+
+        Reviewed by nobody, build fix.
+
+        [Qt] Fix build break introduced by r61002.
+
+        * Api/qwebpage.cpp:
+        (QWebPagePrivate::QWebPagePrivate):
+
+2010-05-31  Jocelyn Turcotte  <jocelyn.turcotte@nokia.com>
+
+        Reviewed by Simon Hausmann.
+
+        [Qt] Implement the simple text code path.
+        https://bugs.webkit.org/show_bug.cgi?id=40077
+
+        Remove the FONT_FAST_PATH macro and use the Qt's
+        fast text implementation instead of the one of WebKit.
+
+        The Qt::TextBypassShaping flag is used to tell Qt to
+        only use the glyph advances.
+
+        Qt 4.7 is needed to get this flag thus the complex path is always
+        used if QtWebKit is compiled against an earlier version.
+
+        Contrary to the WebKit's implementation, the complex code path
+        is taken if the text is RightToLeft, justified or is formatted
+        with non-zero letter or word spacing.
+
+        * Api/qwebpage.cpp:
+        (QWebPagePrivate::QWebPagePrivate):
+
+2010-06-21  Simon Hausmann  <simon.hausmann@nokia.com>
+
+        Unreviewed build fix.
+
+        [Qt] Fix package builds
+
+        Don't use rpath unless we're building inside the trunk.
+
+        * declarative/declarative.pro:
+
+2010-06-19  Mirko Damiani  <mirko@develer.com>
+
+        Reviewed by Simon Hausmann.
+
+        [Qt] Avoid truncation of zoom factor in QWebFrame's print function.
+        https://bugs.webkit.org/show_bug.cgi?id=40662
+
+        The zoom factor is a qreal number but its value is truncated to an
+        integer. So a cast to qreal is needed to avoid this issue.
+
+        * Api/qwebframe.cpp:
+        (QWebFrame::print):
+
+2010-06-19  No'am Rosenthal  <noam.rosenthal@nokia.com>
+
+        Reviewed by Simon Hausmann.
+
+        Bridge documentation: some snippets have the wrong indentation
+        https://bugs.webkit.org/show_bug.cgi?id=40717
+
+        Fixed code snippets
+
+        * docs/webkitsnippets/qtwebkit_bridge_snippets.cpp:
+        (wrapInFunction):
+
+2010-06-19  Olivier Goffart  <olivier.goffart@nokia.com>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        [Qt] Compilation in QWebPagePrivate::timerEvent with clang
+        https://bugs.webkit.org/show_bug.cgi?id=40714
+
+        QObject::timerEvent is protected and cannot be accessed by QWebPagePrivate
+        with clang
+
+        QWebPagePrivate is a friend of QWebPage and then should have access to
+        all protected members of parents of QWebPage, including QObject.
+        But the clang team do not want to conform to this aspect of the specification
+        because "It is either a drafting error or a horrible mistake."
+        See http://llvm.org/bugs/show_bug.cgi?id=6840
+
+        This change is better because QWebPage does not reimplement the timerEvent
+        (QWebPagePrivate::timerEvent is called from QWebPage::event)
+        So customers that would reimplement their own timerEvent
+        for their own timer now get a chance to catch them.
+
+
+        * Api/qwebpage.cpp:
+        (QWebPagePrivate::timerEvent):
+
+2010-06-18  Alexis Menard  <alexis.menard@nokia.com>
+
+        Reviewed by Simon Hausmann.
+
+        [Qt] Fix documentation for the declarative module import.
+
+        * declarative/qdeclarativewebview.cpp:
+
+2010-06-18  Simon Hausmann  <simon.hausmann@nokia.com>
+
+        Reviewed by Antti Koivisto.
+
+        REGRESSION(r60958) [Qt] qwebpage::inputMethods auto-test fails
+        https://bugs.webkit.org/show_bug.cgi?id=40830
+
+        When activating a regular input method field, always set or unset the ImhHiddenText
+        input method hint.
+
+        * WebCoreSupport/EditorClientQt.cpp:
+        (WebCore::EditorClientQt::setInputMethodState):
+
+2010-06-10  Raine Makelainen  <raine.makelainen@nokia.com>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        Impossible to set input method hints based HTML5 input types
+        https://bugs.webkit.org/show_bug.cgi?id=40107
+
+        EditorClientQt to set input method hints for "number", "tel",
+        "email", and "url" HTML input elements.
+
+        Tests for HTML input elements and input method hints added for
+        QGraphicsWebView and QWebView.
+
+        * WebCoreSupport/EditorClientQt.cpp:
+        (WebCore::EditorClientQt::setInputMethodState):
+        * tests/qgraphicswebview/resources/input_types.html: Added.
+        * tests/qgraphicswebview/tst_qgraphicswebview.cpp:
+        (GraphicsWebView::GraphicsWebView):
+        (GraphicsWebView::fireMouseClick):
+        (tst_QGraphicsWebView::focusInputTypes):
+        * tests/qgraphicswebview/tst_qgraphicswebview.qrc: Added.
+        * tests/qwebview/resources/input_types.html: Added.
+        * tests/qwebview/tst_qwebview.cpp:
+        (WebView::fireMouseClick):
+        (tst_QWebView::focusInputTypes):
+        * tests/qwebview/tst_qwebview.qrc:
+
+2010-06-18  Alexis Menard  <alexis.menard@nokia.com>
+
+        Reviewed by Simon Hausmann.
+
+        Fix documentation issue on the onAlert handler.
+        Fix compilation issue with QT_NO_ACTION.
+
+        * declarative/qdeclarativewebview.cpp:
+        * declarative/qdeclarativewebview_p.h:
+
+2010-06-18  Alexis Menard  <alexis.menard@nokia.com>
+
+        Reviewed by Simon Hausmann.
+
+        [Qt] Change the target path to QtWebKit.
+
+        * declarative/declarative.pro:
+
+2010-06-17  Robert Hogan  <robert@webkit.org>
+
+        [Qt] Build fix
+
+        Unreviewed.
+
+        Remove includes in qdeclarativewebview*.* that rely on an installation
+        of QtWebKit.
+
+        * declarative/qdeclarativewebview.cpp:
+        * declarative/qdeclarativewebview_p.h:
+
+2010-06-17  Alexis Menard  <alexis.menard@nokia.com>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        [Qt] Upstream the WebKit QML integration plugin
+        https://bugs.webkit.org/show_bug.cgi?id=40050
+
+        Add to the Qt port the QML WebKit integration plugin.
+        QDeclarativeWebView is creating the item and expose
+        properties. The C++ API is not public, only the
+        properties are.
+
+        * declarative/declarative.pro: Added.
+        * declarative/plugin.cpp: Added.
+        (WebKitQmlPlugin::registerTypes):
+        * declarative/qdeclarativewebview.cpp: Added.
+        (QDeclarativeWebViewPrivate::QDeclarativeWebViewPrivate):
+        (QDeclarativeWebViewPrivate::):
+        (QDeclarativeWebViewPrivate::windowObjectsAppend):
+        (GraphicsWebView::GraphicsWebView):
+        (GraphicsWebView::mousePressEvent):
+        (GraphicsWebView::mouseReleaseEvent):
+        (GraphicsWebView::mouseDoubleClickEvent):
+        (GraphicsWebView::timerEvent):
+        (GraphicsWebView::mouseMoveEvent):
+        (QDeclarativeWebView::QDeclarativeWebView):
+        (QDeclarativeWebView::~QDeclarativeWebView):
+        (QDeclarativeWebView::init):
+        (QDeclarativeWebView::componentComplete):
+        (QDeclarativeWebView::status):
+        (QDeclarativeWebView::progress):
+        (QDeclarativeWebView::doLoadStarted):
+        (QDeclarativeWebView::doLoadProgress):
+        (QDeclarativeWebView::pageUrlChanged):
+        (QDeclarativeWebView::doLoadFinished):
+        (QDeclarativeWebView::url):
+        (QDeclarativeWebView::setUrl):
+        (QDeclarativeWebView::preferredWidth):
+        (QDeclarativeWebView::setPreferredWidth):
+        (QDeclarativeWebView::preferredHeight):
+        (QDeclarativeWebView::setPreferredHeight):
+        (QDeclarativeWebView::evaluateJavaScript):
+        (QDeclarativeWebView::updateDeclarativeWebViewSize):
+        (QDeclarativeWebView::initialLayout):
+        (QDeclarativeWebView::updateContentsSize):
+        (QDeclarativeWebView::geometryChanged):
+        (QDeclarativeWebView::javaScriptWindowObjects):
+        (QDeclarativeWebView::qmlAttachedProperties):
+        (QDeclarativeWebViewPrivate::updateWindowObjects):
+        (QDeclarativeWebView::renderingEnabled):
+        (QDeclarativeWebView::setRenderingEnabled):
+        (QDeclarativeWebView::heuristicZoom):
+        (QDeclarativeWebView::pressGrabTime):
+        (QDeclarativeWebView::setPressGrabTime):
+        (QDeclarativeWebView::backAction):
+        (QDeclarativeWebView::forwardAction):
+        (QDeclarativeWebView::reloadAction):
+        (QDeclarativeWebView::stopAction):
+        (QDeclarativeWebView::title):
+        (QDeclarativeWebView::icon):
+        (QDeclarativeWebView::setStatusText):
+        (QDeclarativeWebView::windowObjectCleared):
+        (QDeclarativeWebView::statusText):
+        (QDeclarativeWebView::page):
+        (QDeclarativeWebView::settingsObject):
+        (QDeclarativeWebView::setPage):
+        (QDeclarativeWebView::load):
+        (QDeclarativeWebView::html):
+        (QDeclarativeWebView::setHtml):
+        (QDeclarativeWebView::setContent):
+        (QDeclarativeWebView::history):
+        (QDeclarativeWebView::settings):
+        (QDeclarativeWebView::createWindow):
+        (QDeclarativeWebView::newWindowComponent):
+        (QDeclarativeWebView::setNewWindowComponent):
+        (QDeclarativeWebView::newWindowParent):
+        (QDeclarativeWebView::setNewWindowParent):
+        (QDeclarativeWebView::contentsSize):
+        (QDeclarativeWebView::contentsScale):
+        (QDeclarativeWebView::setContentsScale):
+        (QDeclarativeWebView::elementAreaAt):
+        (QDeclarativeWebPage::QDeclarativeWebPage):
+        (QDeclarativeWebPage::~QDeclarativeWebPage):
+        (QDeclarativeWebPage::chooseFile):
+        (QDeclarativeWebPage::javaScriptAlert):
+        (QDeclarativeWebPage::javaScriptConfirm):
+        (QDeclarativeWebPage::javaScriptPrompt):
+        (QDeclarativeWebPage::viewItem):
+        (QDeclarativeWebPage::createWindow):
+        * declarative/qdeclarativewebview_p.h: Added.
+        (QDeclarativeWebView::):
+        (QDeclarativeWebView::isComponentCompletePublic):
+        (QDeclarativeWebViewAttached::QDeclarativeWebViewAttached):
+        (QDeclarativeWebViewAttached::windowObjectName):
+        (QDeclarativeWebViewAttached::setWindowObjectName):
+        (QDeclarativeWebSettings::QDeclarativeWebSettings):
+        (QDeclarativeWebSettings::standardFontFamily):
+        (QDeclarativeWebSettings::setStandardFontFamily):
+        (QDeclarativeWebSettings::fixedFontFamily):
+        (QDeclarativeWebSettings::setFixedFontFamily):
+        (QDeclarativeWebSettings::serifFontFamily):
+        (QDeclarativeWebSettings::setSerifFontFamily):
+        (QDeclarativeWebSettings::sansSerifFontFamily):
+        (QDeclarativeWebSettings::setSansSerifFontFamily):
+        (QDeclarativeWebSettings::cursiveFontFamily):
+        (QDeclarativeWebSettings::setCursiveFontFamily):
+        (QDeclarativeWebSettings::fantasyFontFamily):
+        (QDeclarativeWebSettings::setFantasyFontFamily):
+        (QDeclarativeWebSettings::minimumFontSize):
+        (QDeclarativeWebSettings::setMinimumFontSize):
+        (QDeclarativeWebSettings::minimumLogicalFontSize):
+        (QDeclarativeWebSettings::setMinimumLogicalFontSize):
+        (QDeclarativeWebSettings::defaultFontSize):
+        (QDeclarativeWebSettings::setDefaultFontSize):
+        (QDeclarativeWebSettings::defaultFixedFontSize):
+        (QDeclarativeWebSettings::setDefaultFixedFontSize):
+        (QDeclarativeWebSettings::autoLoadImages):
+        (QDeclarativeWebSettings::setAutoLoadImages):
+        (QDeclarativeWebSettings::javascriptEnabled):
+        (QDeclarativeWebSettings::setJavascriptEnabled):
+        (QDeclarativeWebSettings::javaEnabled):
+        (QDeclarativeWebSettings::setJavaEnabled):
+        (QDeclarativeWebSettings::pluginsEnabled):
+        (QDeclarativeWebSettings::setPluginsEnabled):
+        (QDeclarativeWebSettings::privateBrowsingEnabled):
+        (QDeclarativeWebSettings::setPrivateBrowsingEnabled):
+        (QDeclarativeWebSettings::javascriptCanOpenWindows):
+        (QDeclarativeWebSettings::setJavascriptCanOpenWindows):
+        (QDeclarativeWebSettings::javascriptCanAccessClipboard):
+        (QDeclarativeWebSettings::setJavascriptCanAccessClipboard):
+        (QDeclarativeWebSettings::developerExtrasEnabled):
+        (QDeclarativeWebSettings::setDeveloperExtrasEnabled):
+        (QDeclarativeWebSettings::linksIncludedInFocusChain):
+        (QDeclarativeWebSettings::setLinksIncludedInFocusChain):
+        (QDeclarativeWebSettings::zoomTextOnly):
+        (QDeclarativeWebSettings::setZoomTextOnly):
+        (QDeclarativeWebSettings::printElementBackgrounds):
+        (QDeclarativeWebSettings::setPrintElementBackgrounds):
+        (QDeclarativeWebSettings::offlineStorageDatabaseEnabled):
+        (QDeclarativeWebSettings::setOfflineStorageDatabaseEnabled):
+        (QDeclarativeWebSettings::offlineWebApplicationCacheEnabled):
+        (QDeclarativeWebSettings::setOfflineWebApplicationCacheEnabled):
+        (QDeclarativeWebSettings::localStorageDatabaseEnabled):
+        (QDeclarativeWebSettings::setLocalStorageDatabaseEnabled):
+        (QDeclarativeWebSettings::localContentCanAccessRemoteUrls):
+        (QDeclarativeWebSettings::setLocalContentCanAccessRemoteUrls):
+        * declarative/qmldir: Added.
+        * docs/qtwebkit.qdocconf:
+
 2010-06-17  Mark Brand  <mabrand@mabrand.nl>
 
         Reviewed by Simon Hausmann.
diff --git a/src/3rdparty/webkit/WebKit/qt/WebCoreSupport/EditorClientQt.cpp b/src/3rdparty/webkit/WebKit/qt/WebCoreSupport/EditorClientQt.cpp
index 0ce6383..1cebef7 100644
--- a/src/3rdparty/webkit/WebKit/qt/WebCoreSupport/EditorClientQt.cpp
+++ b/src/3rdparty/webkit/WebKit/qt/WebCoreSupport/EditorClientQt.cpp
@@ -599,20 +599,29 @@ void EditorClientQt::setInputMethodState(bool active)
     QWebPageClient* webPageClient = m_page->d->client;
     if (webPageClient) {
 #if QT_VERSION >= 0x040600
-        bool isPasswordField = false;
-        if (!active) {
-            // Setting the Qt::WA_InputMethodEnabled attribute true and Qt::ImhHiddenText flag
-            // for password fields. The Qt platform is responsible for determining which widget 
-            // will receive input method events for password fields.
-            Frame* frame = m_page->d->page->focusController()->focusedOrMainFrame();
-            if (frame && frame->document() && frame->document()->focusedNode()) {
-                if (frame->document()->focusedNode()->hasTagName(HTMLNames::inputTag)) {
-                    HTMLInputElement* inputElement = static_cast<HTMLInputElement*>(frame->document()->focusedNode());
-                    active = isPasswordField = inputElement->isPasswordField();
-              }
+        HTMLInputElement* inputElement = 0;
+        Frame* frame = m_page->d->page->focusController()->focusedOrMainFrame();
+        if (frame && frame->document() && frame->document()->focusedNode())
+            if (frame->document()->focusedNode()->hasTagName(HTMLNames::inputTag))
+                inputElement = static_cast<HTMLInputElement*>(frame->document()->focusedNode());
+
+        if (inputElement) {
+            if (!active) {
+                // Setting the Qt::WA_InputMethodEnabled attribute true and Qt::ImhHiddenText flag
+                // for password fields. The Qt platform is responsible for determining which widget
+                // will receive input method events for password fields.
+                active = inputElement->isPasswordField();
+                webPageClient->setInputMethodHint(Qt::ImhHiddenText, active);
+            } else {
+                // Set input method hints for "number", "tel", "email", and "url" input elements.
+                webPageClient->setInputMethodHint(Qt::ImhDialableCharactersOnly, inputElement->isTelephoneField());
+                webPageClient->setInputMethodHint(Qt::ImhDigitsOnly, inputElement->isNumberField());
+                webPageClient->setInputMethodHint(Qt::ImhEmailCharactersOnly, inputElement->isEmailField());
+                webPageClient->setInputMethodHint(Qt::ImhUrlCharactersOnly, inputElement->isUrlField());
+                webPageClient->setInputMethodHint(Qt::ImhHiddenText, inputElement->isPasswordField());
             }
         }
-        webPageClient->setInputMethodHint(Qt::ImhHiddenText, isPasswordField);
+
 #if defined(Q_WS_MAEMO_5) || defined(Q_OS_SYMBIAN)
         // disables auto-uppercase and predictive text for mobile devices
         webPageClient->setInputMethodHint(Qt::ImhNoAutoUppercase, true);
diff --git a/src/3rdparty/webkit/WebKit/qt/declarative/declarative.pro b/src/3rdparty/webkit/WebKit/qt/declarative/declarative.pro
new file mode 100644
index 0000000..122d90a
--- /dev/null
+++ b/src/3rdparty/webkit/WebKit/qt/declarative/declarative.pro
@@ -0,0 +1,76 @@
+TARGET  = qmlwebkitplugin
+TARGETPATH = QtWebKit
+
+TEMPLATE = lib
+CONFIG += qt plugin
+
+win32|mac:!wince*:!win32-msvc:!macx-xcode:CONFIG += debug_and_release
+
+QMLDIRFILE = $${_PRO_FILE_PWD_}/qmldir
+copy2build.input = QMLDIRFILE
+CONFIG(QTDIR_build) {
+    copy2build.output = $$QT_BUILD_TREE/imports/$$TARGETPATH/qmldir
+} else {
+    copy2build.output = $$OUTPUT_DIR/imports/$$TARGETPATH/qmldir
+}
+!contains(TEMPLATE_PREFIX, vc):copy2build.variable_out = PRE_TARGETDEPS
+copy2build.commands = $$QMAKE_COPY ${QMAKE_FILE_IN} ${QMAKE_FILE_OUT}
+copy2build.name = COPY ${QMAKE_FILE_IN}
+copy2build.CONFIG += no_link
+QMAKE_EXTRA_COMPILERS += copy2build
+
+TARGET = $$qtLibraryTarget($$TARGET)
+contains(QT_CONFIG, reduce_exports):CONFIG += hide_symbols
+
+wince*:LIBS += $$QMAKE_LIBS_GUI
+
+symbian: {
+    TARGET.EPOCALLOWDLLDATA=1
+    TARGET.CAPABILITY = All -Tcb
+    load(armcc_warnings)
+}
+
+include(../../../WebKit.pri)
+
+QT += declarative
+
+!CONFIG(standalone_package) {
+    linux-* {
+        # From Creator's src/rpath.pri:
+        # Do the rpath by hand since it's not possible to use ORIGIN in QMAKE_RPATHDIR
+        # this expands to $ORIGIN (after qmake and make), it does NOT read a qmake var.
+        QMAKE_RPATHDIR = $$OUTPUT_DIR/lib $$QMAKE_RPATHDIR
+        MY_RPATH = $$join(QMAKE_RPATHDIR, ":")
+
+        QMAKE_LFLAGS += -Wl,-z,origin \'-Wl,-rpath,$${MY_RPATH}\'
+        QMAKE_RPATHDIR =
+    } else {
+        QMAKE_RPATHDIR = $$OUTPUT_DIR/lib $$QMAKE_RPATHDIR
+    }
+}
+
+SOURCES += qdeclarativewebview.cpp plugin.cpp
+HEADERS += qdeclarativewebview_p.h
+
+CONFIG(QTDIR_build) {
+    DESTDIR = $$QT_BUILD_TREE/imports/$$TARGETPATH
+} else {
+    DESTDIR = $$OUTPUT_DIR/imports/$$TARGETPATH
+}
+target.path = $$[QT_INSTALL_IMPORTS]/$$TARGETPATH
+
+
+qmldir.files += $$PWD/qmldir
+qmldir.path +=  $$[QT_INSTALL_IMPORTS]/$$TARGETPATH
+
+symbian:{
+    load(data_caging_paths)
+    include($$QT_SOURCE_TREE/demos/symbianpkgrules.pri)
+
+    importFiles.sources = qmlwebkitplugin.dll qmldir
+    importFiles.path = $$QT_IMPORTS_BASE_DIR/$$TARGETPATH
+
+    DEPLOYMENT = importFiles
+}
+
+INSTALLS += target qmldir
diff --git a/src/3rdparty/webkit/WebKit/qt/declarative/plugin.cpp b/src/3rdparty/webkit/WebKit/qt/declarative/plugin.cpp
new file mode 100644
index 0000000..f1f165e
--- /dev/null
+++ b/src/3rdparty/webkit/WebKit/qt/declarative/plugin.cpp
@@ -0,0 +1,43 @@
+/*
+    Copyright (C) 2009 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 "qdeclarativewebview_p.h"
+
+#include <QtDeclarative/qdeclarative.h>
+#include <QtDeclarative/qdeclarativeextensionplugin.h>
+
+QT_BEGIN_NAMESPACE
+
+class WebKitQmlPlugin : public QDeclarativeExtensionPlugin {
+    Q_OBJECT
+public:
+    virtual void registerTypes(const char* uri)
+    {
+        Q_ASSERT(QLatin1String(uri) == QLatin1String("QtWebKit"));
+        qmlRegisterType<QDeclarativeWebSettings>();
+        qmlRegisterType<QDeclarativeWebView>(uri, 1, 0, "WebView");
+    }
+};
+
+QT_END_NAMESPACE
+
+#include "plugin.moc"
+
+Q_EXPORT_PLUGIN2(qmlwebkitplugin, QT_PREPEND_NAMESPACE(WebKitQmlPlugin));
+
diff --git a/src/3rdparty/webkit/WebKit/qt/declarative/qdeclarativewebview.cpp b/src/3rdparty/webkit/WebKit/qt/declarative/qdeclarativewebview.cpp
new file mode 100644
index 0000000..a349bec
--- /dev/null
+++ b/src/3rdparty/webkit/WebKit/qt/declarative/qdeclarativewebview.cpp
@@ -0,0 +1,1022 @@
+/*
+    Copyright (C) 2009 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 "qdeclarativewebview_p.h"
+
+#include <QtCore/QDebug>
+#include <QtCore/QEvent>
+#include <QtCore/QFile>
+#include <QtDeclarative/QDeclarativeContext>
+#include <QtDeclarative/QDeclarativeEngine>
+#include <QtDeclarative/qdeclarative.h>
+#include <QtGui/QApplication>
+#include <QtGui/QGraphicsSceneMouseEvent>
+#include <QtGui/QKeyEvent>
+#include <QtGui/QMouseEvent>
+#include <QtGui/QPen>
+#include "qwebelement.h"
+#include "qwebframe.h"
+#include "qwebpage.h"
+#include "qwebsettings.h"
+
+QT_BEGIN_NAMESPACE
+
+class QDeclarativeWebViewPrivate {
+public:
+    QDeclarativeWebViewPrivate(QDeclarativeWebView* qq)
+      : q(qq)
+      , preferredwidth(0)
+      , preferredheight(0)
+      , progress(1.0)
+      , status(QDeclarativeWebView::Null)
+      , pending(PendingNone)
+      , newWindowComponent(0)
+      , newWindowParent(0)
+      , rendering(true)
+    {
+    }
+
+    QDeclarativeWebView* q;
+
+    QUrl url; // page url might be different if it has not loaded yet
+    GraphicsWebView* view;
+
+    int preferredwidth, preferredheight;
+    qreal progress;
+    QDeclarativeWebView::Status status;
+    QString statusText;
+    enum { PendingNone, PendingUrl, PendingHtml, PendingContent } pending;
+    QUrl pendingUrl;
+    QString pendingString;
+    QByteArray pendingData;
+    mutable QDeclarativeWebSettings settings;
+    QDeclarativeComponent* newWindowComponent;
+    QDeclarativeItem* newWindowParent;
+
+    static void windowObjectsAppend(QDeclarativeListProperty<QObject>* prop, QObject* o)
+    {
+        static_cast<QDeclarativeWebViewPrivate*>(prop->data)->windowObjects.append(o);
+        static_cast<QDeclarativeWebViewPrivate*>(prop->data)->updateWindowObjects();
+    }
+
+    void updateWindowObjects();
+    QObjectList windowObjects;
+
+    bool rendering;
+};
+
+GraphicsWebView::GraphicsWebView(QDeclarativeWebView* parent)
+    : QGraphicsWebView(parent)
+    , parent(parent)
+    , pressTime(400)
+{
+}
+
+void GraphicsWebView::mousePressEvent(QGraphicsSceneMouseEvent* event)
+{
+    setFocus();
+    pressPoint = event->pos();
+    if (pressTime) {
+        pressTimer.start(pressTime, this);
+        parent->setKeepMouseGrab(false);
+    } else {
+        grabMouse();
+        parent->setKeepMouseGrab(true);
+    }
+    QGraphicsWebView::mousePressEvent(event);
+}
+
+void GraphicsWebView::mouseReleaseEvent(QGraphicsSceneMouseEvent* event)
+{
+    QGraphicsWebView::mouseReleaseEvent(event);
+    pressTimer.stop();
+    parent->setKeepMouseGrab(false);
+    ungrabMouse();
+}
+
+void GraphicsWebView::mouseDoubleClickEvent(QGraphicsSceneMouseEvent* event)
+{
+    QMouseEvent* me = new QMouseEvent(QEvent::MouseButtonDblClick, (event->pos() / parent->contentsScale()).toPoint(), event->button(), event->buttons(), 0);
+    emit doubleClick(event->pos().x(), event->pos().y());
+    delete me;
+}
+
+void GraphicsWebView::timerEvent(QTimerEvent* event)
+{
+    if (event->timerId() == pressTimer.timerId()) {
+        pressTimer.stop();
+        grabMouse();
+        parent->setKeepMouseGrab(true);
+    }
+}
+
+void GraphicsWebView::mouseMoveEvent(QGraphicsSceneMouseEvent* event)
+{
+    if (pressTimer.isActive()) {
+        if ((event->pos() - pressPoint).manhattanLength() > QApplication::startDragDistance())
+            pressTimer.stop();
+    }
+    if (parent->keepMouseGrab())
+        QGraphicsWebView::mouseMoveEvent(event);
+}
+
+/*!
+    \qmlclass WebView QDeclarativeWebView
+    \since 4.7
+    \brief The WebView item allows you to add web content to a canvas.
+    \inherits Item
+
+    A WebView renders web content based on a URL.
+
+    This type is made available by importing the \c QtWebKit module:
+
+    \bold{import QtWebKit 1.0}
+
+    If the width and height of the item is not set, they will
+    dynamically adjust to a size appropriate for the content.
+    This width may be large for typical online web pages.
+
+    If the width or height is explictly set, the rendered website
+    will be clipped, not scaled, to fit into the set dimensions.
+
+    If the preferredWidth is set, the width will be this amount or larger,
+    usually laying out the web content to fit the preferredWidth.
+
+    \qml
+    import QtWebKit 1.0
+
+    WebView {
+        url: "http://www.nokia.com"
+        preferredWidth: 490
+        preferredHeight: 400
+        scale: 0.5
+        smooth: false
+        smoothCache: true
+    }
+    \endqml
+
+    \image webview.png
+
+    The item includes no scrolling, scaling,
+    toolbars, etc., those must be implemented around WebView. See the WebBrowser example
+    for a demonstration of this.
+
+    When this item has keyboard focus, all keyboard input will be sent directly to the
+    web page within.
+*/
+
+/*!
+    \internal
+    \class QDeclarativeWebView
+    \brief The QDeclarativeWebView class allows you to add web content to a QDeclarativeView.
+
+    A WebView renders web content base on a URL.
+
+    \image webview.png
+
+    The item includes no scrolling, scaling,
+    toolbars, etc., those must be implemented around WebView. See the WebBrowser example
+    for a demonstration of this.
+
+    A QDeclarativeWebView object can be instantiated in Qml using the tag \l WebView.
+*/
+
+QDeclarativeWebView::QDeclarativeWebView(QDeclarativeItem *parent) : QDeclarativeItem(parent)
+{
+    init();
+}
+
+QDeclarativeWebView::~QDeclarativeWebView()
+{
+    delete d;
+}
+
+void QDeclarativeWebView::init()
+{
+    d = new QDeclarativeWebViewPrivate(this);
+
+    QWebSettings::enablePersistentStorage();
+
+    setAcceptedMouseButtons(Qt::LeftButton);
+    setFlag(QGraphicsItem::ItemHasNoContents, true);
+    setClip(true);
+
+    d->view = new GraphicsWebView(this);
+    d->view->setResizesToContents(true);
+    QWebPage* wp = new QDeclarativeWebPage(this);
+    setPage(wp);
+    connect(d->view, SIGNAL(geometryChanged()), this, SLOT(updateDeclarativeWebViewSize()));
+    connect(d->view, SIGNAL(doubleClick(int, int)), this, SIGNAL(doubleClick(int, int)));
+    connect(d->view, SIGNAL(scaleChanged()), this, SIGNAL(contentsScaleChanged()));
+}
+
+void QDeclarativeWebView::componentComplete()
+{
+    QDeclarativeItem::componentComplete();
+    page()->setNetworkAccessManager(qmlEngine(this)->networkAccessManager());
+
+    switch (d->pending) {
+    case QDeclarativeWebViewPrivate::PendingUrl:
+        setUrl(d->pendingUrl);
+        break;
+    case QDeclarativeWebViewPrivate::PendingHtml:
+        setHtml(d->pendingString, d->pendingUrl);
+        break;
+    case QDeclarativeWebViewPrivate::PendingContent:
+        setContent(d->pendingData, d->pendingString, d->pendingUrl);
+        break;
+    default:
+        break;
+    }
+    d->pending = QDeclarativeWebViewPrivate::PendingNone;
+    d->updateWindowObjects();
+}
+
+QDeclarativeWebView::Status QDeclarativeWebView::status() const
+{
+    return d->status;
+}
+
+
+/*!
+    \qmlproperty real WebView::progress
+    This property holds the progress of loading the current URL, from 0 to 1.
+
+    If you just want to know when progress gets to 1, use
+    WebView::onLoadFinished() or WebView::onLoadFailed() instead.
+*/
+qreal QDeclarativeWebView::progress() const
+{
+    return d->progress;
+}
+
+void QDeclarativeWebView::doLoadStarted()
+{
+    if (!d->url.isEmpty()) {
+        d->status = Loading;
+        emit statusChanged(d->status);
+    }
+    emit loadStarted();
+}
+
+void QDeclarativeWebView::doLoadProgress(int p)
+{
+    if (d->progress == p / 100.0)
+        return;
+    d->progress = p / 100.0;
+    emit progressChanged();
+}
+
+void QDeclarativeWebView::pageUrlChanged()
+{
+    updateContentsSize();
+
+    if ((d->url.isEmpty() && page()->mainFrame()->url() != QUrl(QLatin1String("about:blank")))
+        || (d->url != page()->mainFrame()->url() && !page()->mainFrame()->url().isEmpty()))
+    {
+        d->url = page()->mainFrame()->url();
+        if (d->url == QUrl(QLatin1String("about:blank")))
+            d->url = QUrl();
+        emit urlChanged();
+    }
+}
+
+void QDeclarativeWebView::doLoadFinished(bool ok)
+{
+    if (ok) {
+        d->status = d->url.isEmpty() ? Null : Ready;
+        emit loadFinished();
+    } else {
+        d->status = Error;
+        emit loadFailed();
+    }
+    emit statusChanged(d->status);
+}
+
+/*!
+    \qmlproperty url WebView::url
+    This property holds the URL to the page displayed in this item. It can be set,
+    but also can change spontaneously (eg. because of network redirection).
+
+    If the url is empty, the page is blank.
+
+    The url is always absolute (QML will resolve relative URL strings in the context
+    of the containing QML document).
+*/
+QUrl QDeclarativeWebView::url() const
+{
+    return d->url;
+}
+
+void QDeclarativeWebView::setUrl(const QUrl& url)
+{
+    if (url == d->url)
+        return;
+
+    if (isComponentComplete()) {
+        d->url = url;
+        updateContentsSize();
+        QUrl seturl = url;
+        if (seturl.isEmpty())
+            seturl = QUrl(QLatin1String("about:blank"));
+
+        Q_ASSERT(!seturl.isRelative());
+
+        page()->mainFrame()->load(seturl);
+
+        emit urlChanged();
+    } else {
+        d->pending = d->PendingUrl;
+        d->pendingUrl = url;
+    }
+}
+
+/*!
+    \qmlproperty int WebView::preferredWidth
+    This property holds the ideal width for displaying the current URL.
+*/
+int QDeclarativeWebView::preferredWidth() const
+{
+    return d->preferredwidth;
+}
+
+void QDeclarativeWebView::setPreferredWidth(int width)
+{
+    if (d->preferredwidth == width)
+        return;
+    d->preferredwidth = width;
+    updateContentsSize();
+    emit preferredWidthChanged();
+}
+
+/*!
+    \qmlproperty int WebView::preferredHeight
+    This property holds the ideal height for displaying the current URL.
+    This only affects the area zoomed by heuristicZoom().
+*/
+int QDeclarativeWebView::preferredHeight() const
+{
+    return d->preferredheight;
+}
+
+void QDeclarativeWebView::setPreferredHeight(int height)
+{
+    if (d->preferredheight == height)
+        return;
+    d->preferredheight = height;
+    updateContentsSize();
+    emit preferredHeightChanged();
+}
+
+/*!
+    \qmlmethod bool WebView::evaluateJavaScript(string)
+
+    Evaluates the \a scriptSource JavaScript inside the context of the
+    main web frame, and returns the result of the last executed statement.
+
+    Note that this JavaScript does \e not have any access to QML objects
+    except as made available as windowObjects.
+*/
+QVariant QDeclarativeWebView::evaluateJavaScript(const QString& scriptSource)
+{
+    return this->page()->mainFrame()->evaluateJavaScript(scriptSource);
+}
+
+void QDeclarativeWebView::updateDeclarativeWebViewSize()
+{
+    QSizeF size = d->view->geometry().size() * contentsScale();
+    setImplicitWidth(size.width());
+    setImplicitHeight(size.height());
+}
+
+void QDeclarativeWebView::initialLayout()
+{
+    // nothing useful to do at this point
+}
+
+void QDeclarativeWebView::updateContentsSize()
+{
+    if (page()) {
+        page()->setPreferredContentsSize(QSize(
+            d->preferredwidth>0 ? d->preferredwidth : width(),
+            d->preferredheight>0 ? d->preferredheight : height()));
+    }
+}
+
+void QDeclarativeWebView::geometryChanged(const QRectF& newGeometry, const QRectF& oldGeometry)
+{
+    QWebPage* webPage = page();
+    if (newGeometry.size() != oldGeometry.size() && webPage) {
+        QSize contentSize = webPage->preferredContentsSize();
+        if (widthValid())
+            contentSize.setWidth(width());
+        if (heightValid())
+            contentSize.setHeight(height());
+        if (contentSize != webPage->preferredContentsSize())
+            webPage->setPreferredContentsSize(contentSize);
+    }
+    QDeclarativeItem::geometryChanged(newGeometry, oldGeometry);
+}
+
+/*!
+    \qmlproperty list<object> WebView::javaScriptWindowObjects
+
+    A list of QML objects to expose to the web page.
+
+    Each object will be added as a property of the web frame's window object.  The
+    property name is controlled by the value of \c WebView.windowObjectName
+    attached property.
+
+    Exposing QML objects to a web page allows JavaScript executing in the web
+    page itself to communicate with QML, by reading and writing properties and
+    by calling methods of the exposed QML objects.
+
+    This example shows how to call into a QML method using a window object.
+
+    \qml
+    WebView {
+        javaScriptWindowObjects: QtObject {
+            WebView.windowObjectName: "qml"
+
+            function qmlCall() {
+                console.log("This call is in QML!");
+            }
+        }
+
+        html: "<script>console.log(\"This is in WebKit!\"); window.qml.qmlCall();</script>"
+    }
+    \endqml
+
+    The output of the example will be:
+    \code
+    This is in WebKit!
+    This call is in QML!
+    \endcode
+
+    If Javascript is not enabled for the page, then this property does nothing.
+*/
+QDeclarativeListProperty<QObject> QDeclarativeWebView::javaScriptWindowObjects()
+{
+    return QDeclarativeListProperty<QObject>(this, d, &QDeclarativeWebViewPrivate::windowObjectsAppend);
+}
+
+QDeclarativeWebViewAttached* QDeclarativeWebView::qmlAttachedProperties(QObject* o)
+{
+    return new QDeclarativeWebViewAttached(o);
+}
+
+void QDeclarativeWebViewPrivate::updateWindowObjects()
+{
+    if (!q->isComponentCompletePublic() || !q->page())
+        return;
+
+    for (int i = 0; i < windowObjects.count(); ++i) {
+        QObject* object = windowObjects.at(i);
+        QDeclarativeWebViewAttached* attached = static_cast<QDeclarativeWebViewAttached *>(qmlAttachedPropertiesObject<QDeclarativeWebView>(object));
+        if (attached && !attached->windowObjectName().isEmpty())
+            q->page()->mainFrame()->addToJavaScriptWindowObject(attached->windowObjectName(), object);
+    }
+}
+
+bool QDeclarativeWebView::renderingEnabled() const
+{
+    return d->rendering;
+}
+
+void QDeclarativeWebView::setRenderingEnabled(bool enabled)
+{
+    if (d->rendering == enabled)
+        return;
+    d->rendering = enabled;
+    emit renderingEnabledChanged();
+    d->view->setTiledBackingStoreFrozen(!enabled);
+}
+
+/*!
+    \qmlsignal WebView::onDoubleClick(clickx, clicky)
+
+    The WebView does not pass double-click events to the web engine, but rather
+    emits this signals.
+*/
+
+/*!
+    \qmlmethod bool WebView::heuristicZoom(clickX,clickY,maxzoom)
+
+    Finds a zoom that:
+    \list
+    \i shows a whole item
+    \i includes (\a clickX, \a clickY)
+    \i fits into the preferredWidth and preferredHeight
+    \i zooms by no more than \a maxZoom
+    \i is more than 10% above the current zoom
+    \endlist
+
+    If such a zoom exists, emits zoomTo(zoom,centerX,centerY) and returns true; otherwise,
+    no signal is emitted and returns false.
+*/
+bool QDeclarativeWebView::heuristicZoom(int clickX, int clickY, qreal maxZoom)
+{
+    if (contentsScale() >= maxZoom / scale())
+        return false;
+    qreal ozf = contentsScale();
+    QRect showArea = elementAreaAt(clickX, clickY, d->preferredwidth / maxZoom, d->preferredheight / maxZoom);
+    qreal z = qMin(qreal(d->preferredwidth) / showArea.width(), qreal(d->preferredheight) / showArea.height());
+    if (z > maxZoom / scale())
+        z = maxZoom / scale();
+    if (z / ozf > 1.2) {
+        QRectF r(showArea.left() * z, showArea.top() * z, showArea.width() * z, showArea.height() * z);
+        emit zoomTo(z, r.x() + r.width() / 2, r.y() + r.height() / 2);
+        return true;
+    }
+    return false;
+}
+
+/*!
+    \qmlproperty int WebView::pressGrabTime
+
+    The number of milliseconds the user must press before the WebView
+    starts passing move events through to the web engine (rather than
+    letting other QML elements such as a Flickable take them).
+
+    Defaults to 400ms. Set to 0 to always grab and pass move events to
+    the web engine.
+*/
+int QDeclarativeWebView::pressGrabTime() const
+{
+    return d->view->pressTime;
+}
+
+void QDeclarativeWebView::setPressGrabTime(int millis)
+{
+    if (d->view->pressTime == millis)
+        return;
+    d->view->pressTime = millis;
+    emit pressGrabTimeChanged();
+}
+
+#ifndef QT_NO_ACTION
+/*!
+    \qmlproperty action WebView::back
+    This property holds the action for causing the previous URL in the history to be displayed.
+*/
+QAction* QDeclarativeWebView::backAction() const
+{
+    return page()->action(QWebPage::Back);
+}
+
+/*!
+    \qmlproperty action WebView::forward
+    This property holds the action for causing the next URL in the history to be displayed.
+*/
+QAction* QDeclarativeWebView::forwardAction() const
+{
+    return page()->action(QWebPage::Forward);
+}
+
+/*!
+    \qmlproperty action WebView::reload
+    This property holds the action for reloading with the current URL
+*/
+QAction* QDeclarativeWebView::reloadAction() const
+{
+    return page()->action(QWebPage::Reload);
+}
+
+/*!
+    \qmlproperty action WebView::stop
+    This property holds the action for stopping loading with the current URL
+*/
+QAction* QDeclarativeWebView::stopAction() const
+{
+    return page()->action(QWebPage::Stop);
+}
+#endif // QT_NO_ACTION
+
+/*!
+    \qmlproperty real WebView::title
+    This property holds the title of the web page currently viewed
+
+    By default, this property contains an empty string.
+*/
+QString QDeclarativeWebView::title() const
+{
+    return page()->mainFrame()->title();
+}
+
+/*!
+    \qmlproperty pixmap WebView::icon
+    This property holds the icon associated with the web page currently viewed
+*/
+QPixmap QDeclarativeWebView::icon() const
+{
+    return page()->mainFrame()->icon().pixmap(QSize(256, 256));
+}
+
+/*!
+    \qmlproperty string WebView::statusText
+
+    This property is the current status suggested by the current web page. In a web browser,
+    such status is often shown in some kind of status bar.
+*/
+void QDeclarativeWebView::setStatusText(const QString& text)
+{
+    d->statusText = text;
+    emit statusTextChanged();
+}
+
+void QDeclarativeWebView::windowObjectCleared()
+{
+    d->updateWindowObjects();
+}
+
+QString QDeclarativeWebView::statusText() const
+{
+    return d->statusText;
+}
+
+QWebPage* QDeclarativeWebView::page() const
+{
+    return d->view->page();
+}
+
+// The QObject interface to settings().
+/*!
+    \qmlproperty string WebView::settings.standardFontFamily
+    \qmlproperty string WebView::settings.fixedFontFamily
+    \qmlproperty string WebView::settings.serifFontFamily
+    \qmlproperty string WebView::settings.sansSerifFontFamily
+    \qmlproperty string WebView::settings.cursiveFontFamily
+    \qmlproperty string WebView::settings.fantasyFontFamily
+
+    \qmlproperty int WebView::settings.minimumFontSize
+    \qmlproperty int WebView::settings.minimumLogicalFontSize
+    \qmlproperty int WebView::settings.defaultFontSize
+    \qmlproperty int WebView::settings.defaultFixedFontSize
+
+    \qmlproperty bool WebView::settings.autoLoadImages
+    \qmlproperty bool WebView::settings.javascriptEnabled
+    \qmlproperty bool WebView::settings.javaEnabled
+    \qmlproperty bool WebView::settings.pluginsEnabled
+    \qmlproperty bool WebView::settings.privateBrowsingEnabled
+    \qmlproperty bool WebView::settings.javascriptCanOpenWindows
+    \qmlproperty bool WebView::settings.javascriptCanAccessClipboard
+    \qmlproperty bool WebView::settings.developerExtrasEnabled
+    \qmlproperty bool WebView::settings.linksIncludedInFocusChain
+    \qmlproperty bool WebView::settings.zoomTextOnly
+    \qmlproperty bool WebView::settings.printElementBackgrounds
+    \qmlproperty bool WebView::settings.offlineStorageDatabaseEnabled
+    \qmlproperty bool WebView::settings.offlineWebApplicationCacheEnabled
+    \qmlproperty bool WebView::settings.localStorageDatabaseEnabled
+    \qmlproperty bool WebView::settings.localContentCanAccessRemoteUrls
+
+    These properties give access to the settings controlling the web view.
+
+    See QWebSettings for details of these properties.
+
+    \qml
+        WebView {
+            settings.pluginsEnabled: true
+            settings.standardFontFamily: "Arial"
+            ...
+        }
+    \endqml
+*/
+QDeclarativeWebSettings* QDeclarativeWebView::settingsObject() const
+{
+    d->settings.s = page()->settings();
+    return &d->settings;
+}
+
+void QDeclarativeWebView::setPage(QWebPage* page)
+{
+    if (d->view->page() == page)
+        return;
+
+    d->view->setPage(page);
+    updateContentsSize();
+    page->mainFrame()->setScrollBarPolicy(Qt::Horizontal, Qt::ScrollBarAlwaysOff);
+    page->mainFrame()->setScrollBarPolicy(Qt::Vertical, Qt::ScrollBarAlwaysOff);
+    connect(page->mainFrame(), SIGNAL(urlChanged(QUrl)), this, SLOT(pageUrlChanged()));
+    connect(page->mainFrame(), SIGNAL(titleChanged(QString)), this, SIGNAL(titleChanged(QString)));
+    connect(page->mainFrame(), SIGNAL(titleChanged(QString)), this, SIGNAL(iconChanged()));
+    connect(page->mainFrame(), SIGNAL(iconChanged()), this, SIGNAL(iconChanged()));
+    connect(page->mainFrame(), SIGNAL(initialLayoutCompleted()), this, SLOT(initialLayout()));
+    connect(page->mainFrame(), SIGNAL(contentsSizeChanged(QSize)), this, SIGNAL(contentsSizeChanged(QSize)));
+
+    connect(page, SIGNAL(loadStarted()), this, SLOT(doLoadStarted()));
+    connect(page, SIGNAL(loadProgress(int)), this, SLOT(doLoadProgress(int)));
+    connect(page, SIGNAL(loadFinished(bool)), this, SLOT(doLoadFinished(bool)));
+    connect(page, SIGNAL(statusBarMessage(QString)), this, SLOT(setStatusText(QString)));
+
+    connect(page->mainFrame(), SIGNAL(javaScriptWindowObjectCleared()), this, SLOT(windowObjectCleared()));
+
+    page->settings()->setAttribute(QWebSettings::TiledBackingStoreEnabled, true);
+
+}
+
+/*!
+    \qmlsignal WebView::onLoadStarted()
+
+    This handler is called when the web engine begins loading
+    a page. Later, WebView::onLoadFinished() or WebView::onLoadFailed()
+    will be emitted.
+*/
+
+/*!
+    \qmlsignal WebView::onLoadFinished()
+
+    This handler is called when the web engine \e successfully
+    finishes loading a page, including any component content
+    (WebView::onLoadFailed() will be emitted otherwise).
+
+    \sa progress
+*/
+
+/*!
+    \qmlsignal WebView::onLoadFailed()
+
+    This handler is called when the web engine fails loading
+    a page or any component content
+    (WebView::onLoadFinished() will be emitted on success).
+*/
+
+void QDeclarativeWebView::load(const QNetworkRequest& request, QNetworkAccessManager::Operation operation, const QByteArray& body)
+{
+    page()->mainFrame()->load(request, operation, body);
+}
+
+QString QDeclarativeWebView::html() const
+{
+    return page()->mainFrame()->toHtml();
+}
+
+/*!
+    \qmlproperty string WebView::html
+    This property holds HTML text set directly
+
+    The html property can be set as a string.
+
+    \qml
+    WebView {
+        html: "<p>This is <b>HTML</b>."
+    }
+    \endqml
+*/
+void QDeclarativeWebView::setHtml(const QString& html, const QUrl& baseUrl)
+{
+    updateContentsSize();
+    if (isComponentComplete())
+        page()->mainFrame()->setHtml(html, baseUrl);
+    else {
+        d->pending = d->PendingHtml;
+        d->pendingUrl = baseUrl;
+        d->pendingString = html;
+    }
+    emit htmlChanged();
+}
+
+void QDeclarativeWebView::setContent(const QByteArray& data, const QString& mimeType, const QUrl& baseUrl)
+{
+    updateContentsSize();
+
+    if (isComponentComplete())
+        page()->mainFrame()->setContent(data, mimeType, qmlContext(this)->resolvedUrl(baseUrl));
+    else {
+        d->pending = d->PendingContent;
+        d->pendingUrl = baseUrl;
+        d->pendingString = mimeType;
+        d->pendingData = data;
+    }
+}
+
+QWebHistory* QDeclarativeWebView::history() const
+{
+    return page()->history();
+}
+
+QWebSettings* QDeclarativeWebView::settings() const
+{
+    return page()->settings();
+}
+
+QDeclarativeWebView* QDeclarativeWebView::createWindow(QWebPage::WebWindowType type)
+{
+    switch (type) {
+    case QWebPage::WebBrowserWindow: {
+        if (!d->newWindowComponent && d->newWindowParent)
+            qWarning("WebView::newWindowComponent not set - WebView::newWindowParent ignored");
+        else if (d->newWindowComponent && !d->newWindowParent)
+            qWarning("WebView::newWindowParent not set - WebView::newWindowComponent ignored");
+        else if (d->newWindowComponent && d->newWindowParent) {
+            QDeclarativeWebView* webview = 0;
+            QDeclarativeContext* windowContext = new QDeclarativeContext(qmlContext(this));
+
+            QObject* newObject = d->newWindowComponent->create(windowContext);
+            if (newObject) {
+                windowContext->setParent(newObject);
+                QDeclarativeItem* item = qobject_cast<QDeclarativeItem *>(newObject);
+                if (!item)
+                    delete newObject;
+                else {
+                    webview = item->findChild<QDeclarativeWebView*>();
+                    if (!webview)
+                        delete item;
+                    else {
+                        newObject->setParent(d->newWindowParent);
+                        static_cast<QGraphicsObject*>(item)->setParentItem(d->newWindowParent);
+                    }
+                }
+            } else
+                delete windowContext;
+
+            return webview;
+        }
+    }
+    break;
+    case QWebPage::WebModalDialog: {
+        // Not supported
+    }
+    }
+    return 0;
+}
+
+/*!
+    \qmlproperty component WebView::newWindowComponent
+
+    This property holds the component to use for new windows.
+    The component must have a WebView somewhere in its structure.
+
+    When the web engine requests a new window, it will be an instance of
+    this component.
+
+    The parent of the new window is set by newWindowParent. It must be set.
+*/
+QDeclarativeComponent* QDeclarativeWebView::newWindowComponent() const
+{
+    return d->newWindowComponent;
+}
+
+void QDeclarativeWebView::setNewWindowComponent(QDeclarativeComponent* newWindow)
+{
+    if (newWindow == d->newWindowComponent)
+        return;
+    d->newWindowComponent = newWindow;
+    emit newWindowComponentChanged();
+}
+
+
+/*!
+    \qmlproperty item WebView::newWindowParent
+
+    The parent item for new windows.
+
+    \sa newWindowComponent
+*/
+QDeclarativeItem* QDeclarativeWebView::newWindowParent() const
+{
+    return d->newWindowParent;
+}
+
+void QDeclarativeWebView::setNewWindowParent(QDeclarativeItem* parent)
+{
+    if (parent == d->newWindowParent)
+        return;
+    if (d->newWindowParent && parent) {
+        QList<QGraphicsItem *> children = d->newWindowParent->childItems();
+        for (int i = 0; i < children.count(); ++i)
+            children.at(i)->setParentItem(parent);
+    }
+    d->newWindowParent = parent;
+    emit newWindowParentChanged();
+}
+
+QSize QDeclarativeWebView::contentsSize() const
+{
+    return page()->mainFrame()->contentsSize() * contentsScale();
+}
+
+qreal QDeclarativeWebView::contentsScale() const
+{
+    return d->view->scale();
+}
+
+void QDeclarativeWebView::setContentsScale(qreal scale)
+{
+    if (scale == d->view->scale())
+        return;
+    d->view->setScale(scale);
+    updateDeclarativeWebViewSize();
+    emit contentsScaleChanged();
+}
+
+/*!
+    Returns the area of the largest element at position (\a x,\a y) that is no larger
+    than \a maxWidth by \a maxHeight pixels.
+
+    May return an area larger in the case when no smaller element is at the position.
+*/
+QRect QDeclarativeWebView::elementAreaAt(int x, int y, int maxWidth, int maxHeight) const
+{
+    QWebHitTestResult hit = page()->mainFrame()->hitTestContent(QPoint(x, y));
+    QRect hitRect = hit.boundingRect();
+    QWebElement element = hit.enclosingBlockElement();
+    if (maxWidth <= 0)
+        maxWidth = INT_MAX;
+    if (maxHeight <= 0)
+        maxHeight = INT_MAX;
+    while (!element.parent().isNull() && element.geometry().width() <= maxWidth && element.geometry().height() <= maxHeight) {
+        hitRect = element.geometry();
+        element = element.parent();
+    }
+    return hitRect;
+}
+
+/*!
+    \internal
+    \class QDeclarativeWebPage
+    \brief The QDeclarativeWebPage class is a QWebPage that can create QML plugins.
+
+    \sa QDeclarativeWebView
+*/
+QDeclarativeWebPage::QDeclarativeWebPage(QDeclarativeWebView* parent) :
+    QWebPage(parent)
+{
+}
+
+QDeclarativeWebPage::~QDeclarativeWebPage()
+{
+}
+
+QString QDeclarativeWebPage::chooseFile(QWebFrame* originatingFrame, const QString& oldFile)
+{
+    // Not supported (it's modal)
+    Q_UNUSED(originatingFrame)
+    Q_UNUSED(oldFile)
+    return oldFile;
+}
+
+/*!
+    \qmlsignal WebView::onAlert(message)
+
+    The handler is called when the web engine sends a JavaScript alert. The \a message is the text
+    to be displayed in the alert to the user.
+*/
+
+
+void QDeclarativeWebPage::javaScriptAlert(QWebFrame* originatingFrame, const QString& msg)
+{
+    Q_UNUSED(originatingFrame)
+    emit viewItem()->alert(msg);
+}
+
+bool QDeclarativeWebPage::javaScriptConfirm(QWebFrame* originatingFrame, const QString& msg)
+{
+    // Not supported (it's modal)
+    Q_UNUSED(originatingFrame)
+    Q_UNUSED(msg)
+    return false;
+}
+
+bool QDeclarativeWebPage::javaScriptPrompt(QWebFrame* originatingFrame, const QString& msg, const QString& defaultValue, QString* result)
+{
+    // Not supported (it's modal)
+    Q_UNUSED(originatingFrame)
+    Q_UNUSED(msg)
+    Q_UNUSED(defaultValue)
+    Q_UNUSED(result)
+    return false;
+}
+
+
+QDeclarativeWebView* QDeclarativeWebPage::viewItem()
+{
+    return static_cast<QDeclarativeWebView*>(parent());
+}
+
+QWebPage* QDeclarativeWebPage::createWindow(WebWindowType type)
+{
+    QDeclarativeWebView* newView = viewItem()->createWindow(type);
+    if (newView)
+        return newView->page();
+    return 0;
+}
+
+QT_END_NAMESPACE
+
diff --git a/src/3rdparty/webkit/WebKit/qt/declarative/qdeclarativewebview_p.h b/src/3rdparty/webkit/WebKit/qt/declarative/qdeclarativewebview_p.h
new file mode 100644
index 0000000..b2055bf
--- /dev/null
+++ b/src/3rdparty/webkit/WebKit/qt/declarative/qdeclarativewebview_p.h
@@ -0,0 +1,371 @@
+/*
+    Copyright (C) 2009 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 qdeclarativewebview_p_h
+#define qdeclarativewebview_p_h
+
+#include <QtCore/QBasicTimer>
+#include <QtCore/QUrl>
+#include <QtDeclarative/QDeclarativeItem>
+#include <QtGui/QAction>
+#include <QtNetwork/QNetworkAccessManager>
+#include "qgraphicswebview.h"
+#include "qwebpage.h"
+
+
+QT_BEGIN_HEADER
+
+class QWebHistory;
+class QWebSettings;
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Declarative)
+class QDeclarativeWebSettings;
+class QDeclarativeWebViewPrivate;
+class QNetworkRequest;
+class QDeclarativeWebView;
+class QDeclarativeWebViewPrivate;
+
+class QDeclarativeWebPage : public QWebPage {
+    Q_OBJECT
+public:
+    explicit QDeclarativeWebPage(QDeclarativeWebView *parent);
+    ~QDeclarativeWebPage();
+protected:
+    QWebPage *createWindow(WebWindowType type);
+    QString chooseFile(QWebFrame *originatingFrame, const QString& oldFile);
+    void javaScriptAlert(QWebFrame *originatingFrame, const QString& msg);
+    bool javaScriptConfirm(QWebFrame *originatingFrame, const QString& msg);
+    bool javaScriptPrompt(QWebFrame *originatingFrame, const QString& msg, const QString& defaultValue, QString* result);
+
+private:
+    QDeclarativeWebView *viewItem();
+};
+
+class GraphicsWebView : public QGraphicsWebView {
+    Q_OBJECT
+public:
+    GraphicsWebView(QDeclarativeWebView* parent = 0);
+protected:
+    void mousePressEvent(QGraphicsSceneMouseEvent* event);
+    void mouseReleaseEvent(QGraphicsSceneMouseEvent* event);
+    void mouseMoveEvent(QGraphicsSceneMouseEvent* event);
+    void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event);
+    void timerEvent(QTimerEvent* event);
+Q_SIGNALS:
+    void doubleClick(int clickX, int clickY);
+private:
+    QDeclarativeWebView *parent;
+    QPointF pressPoint;
+    QBasicTimer pressTimer;
+    int pressTime; // milliseconds before the touch event becomes a "tap and hold"
+    friend class QDeclarativeWebView;
+};
+
+class QDeclarativeWebViewAttached;
+
+// TODO: browser plugins
+
+class QDeclarativeWebView : public QDeclarativeItem {
+    Q_OBJECT
+
+    Q_ENUMS(Status SelectionMode)
+
+    Q_PROPERTY(QString title READ title NOTIFY titleChanged)
+    Q_PROPERTY(QPixmap icon READ icon NOTIFY iconChanged)
+    Q_PROPERTY(QString statusText READ statusText NOTIFY statusTextChanged)
+
+    Q_PROPERTY(QString html READ html WRITE setHtml NOTIFY htmlChanged)
+
+    Q_PROPERTY(int pressGrabTime READ pressGrabTime WRITE setPressGrabTime NOTIFY pressGrabTimeChanged)
+
+    Q_PROPERTY(int preferredWidth READ preferredWidth WRITE setPreferredWidth NOTIFY preferredWidthChanged)
+    Q_PROPERTY(int preferredHeight READ preferredHeight WRITE setPreferredHeight NOTIFY preferredHeightChanged)
+    Q_PROPERTY(QUrl url READ url WRITE setUrl NOTIFY urlChanged)
+    Q_PROPERTY(qreal progress READ progress NOTIFY progressChanged)
+    Q_PROPERTY(Status status READ status NOTIFY statusChanged)
+
+#ifndef QT_NO_ACTION
+    Q_PROPERTY(QAction* reload READ reloadAction CONSTANT)
+    Q_PROPERTY(QAction* back READ backAction CONSTANT)
+    Q_PROPERTY(QAction* forward READ forwardAction CONSTANT)
+    Q_PROPERTY(QAction* stop READ stopAction CONSTANT)
+#endif
+
+    Q_PROPERTY(QDeclarativeWebSettings* settings READ settingsObject CONSTANT)
+
+    Q_PROPERTY(QDeclarativeListProperty<QObject> javaScriptWindowObjects READ javaScriptWindowObjects CONSTANT)
+
+    Q_PROPERTY(QDeclarativeComponent* newWindowComponent READ newWindowComponent WRITE setNewWindowComponent NOTIFY newWindowComponentChanged)
+    Q_PROPERTY(QDeclarativeItem* newWindowParent READ newWindowParent WRITE setNewWindowParent NOTIFY newWindowParentChanged)
+
+    Q_PROPERTY(bool renderingEnabled READ renderingEnabled WRITE setRenderingEnabled NOTIFY renderingEnabledChanged)
+
+    Q_PROPERTY(QSize contentsSize READ contentsSize NOTIFY contentsSizeChanged)
+    Q_PROPERTY(qreal contentsScale READ contentsScale WRITE setContentsScale NOTIFY contentsScaleChanged)
+
+public:
+    QDeclarativeWebView(QDeclarativeItem *parent = 0);
+    ~QDeclarativeWebView();
+
+    QUrl url() const;
+    void setUrl(const QUrl &);
+
+    QString title() const;
+
+    QPixmap icon() const;
+
+    Q_INVOKABLE bool heuristicZoom(int clickX, int clickY, qreal maxzoom);
+    QRect elementAreaAt(int x, int y, int minwidth, int minheight) const;
+
+    int pressGrabTime() const;
+    void setPressGrabTime(int);
+
+    int preferredWidth() const;
+    void setPreferredWidth(int);
+    int preferredHeight() const;
+    void setPreferredHeight(int);
+
+    enum Status { Null, Ready, Loading, Error };
+    Status status() const;
+    qreal progress() const;
+    QString statusText() const;
+
+#ifndef QT_NO_ACTION
+    QAction *reloadAction() const;
+    QAction *backAction() const;
+    QAction *forwardAction() const;
+    QAction *stopAction() const;
+#endif
+
+    QWebPage *page() const;
+    void setPage(QWebPage *page);
+
+    void load(const QNetworkRequest &request,
+              QNetworkAccessManager::Operation operation = QNetworkAccessManager::GetOperation,
+              const QByteArray &body = QByteArray());
+
+    QString html() const;
+
+    void setHtml(const QString &html, const QUrl &baseUrl = QUrl());
+    void setContent(const QByteArray &data, const QString &mimeType = QString(), const QUrl &baseUrl = QUrl());
+
+    QWebHistory* history() const;
+    QWebSettings* settings() const;
+    QDeclarativeWebSettings *settingsObject() const;
+
+    bool renderingEnabled() const;
+    void setRenderingEnabled(bool);
+
+    QDeclarativeListProperty<QObject> javaScriptWindowObjects();
+
+    static QDeclarativeWebViewAttached* qmlAttachedProperties(QObject*);
+
+    QDeclarativeComponent *newWindowComponent() const;
+    void setNewWindowComponent(QDeclarativeComponent *newWindow);
+    QDeclarativeItem* newWindowParent() const;
+    void setNewWindowParent(QDeclarativeItem* newWindow);
+
+    bool isComponentCompletePublic() const { return isComponentComplete(); }
+
+    QSize contentsSize() const;
+
+    void setContentsScale(qreal scale);
+    qreal contentsScale() const;
+
+Q_SIGNALS:
+    void preferredWidthChanged();
+    void preferredHeightChanged();
+    void urlChanged();
+    void progressChanged();
+    void statusChanged(Status);
+    void titleChanged(const QString&);
+    void iconChanged();
+    void statusTextChanged();
+    void htmlChanged();
+    void pressGrabTimeChanged();
+    void newWindowComponentChanged();
+    void newWindowParentChanged();
+    void renderingEnabledChanged();
+    void contentsSizeChanged(const QSize&);
+    void contentsScaleChanged();
+
+    void loadStarted();
+    void loadFinished();
+    void loadFailed();
+
+    void doubleClick(int clickX, int clickY);
+
+    void zoomTo(qreal zoom, int centerX, int centerY);
+
+    void alert(const QString& message);
+
+public Q_SLOTS:
+    QVariant evaluateJavaScript(const QString&);
+
+private Q_SLOTS:
+    void doLoadStarted();
+    void doLoadProgress(int p);
+    void doLoadFinished(bool ok);
+    void setStatusText(const QString&);
+    void windowObjectCleared();
+    void pageUrlChanged();
+    void initialLayout();
+
+    void updateDeclarativeWebViewSize();
+
+    virtual void geometryChanged(const QRectF &newGeometry,
+                                 const QRectF &oldGeometry);
+    QDeclarativeWebView* createWindow(QWebPage::WebWindowType type);
+
+private:
+    void updateContentsSize();
+    void init();
+    virtual void componentComplete();
+    Q_DISABLE_COPY(QDeclarativeWebView)
+    QDeclarativeWebViewPrivate* d;
+    QMouseEvent* sceneMouseEventToMouseEvent(QGraphicsSceneMouseEvent*);
+    QMouseEvent* sceneHoverMoveEventToMouseEvent(QGraphicsSceneHoverEvent*);
+    friend class QDeclarativeWebPage;
+};
+
+class QDeclarativeWebViewAttached : public QObject {
+    Q_OBJECT
+    Q_PROPERTY(QString windowObjectName READ windowObjectName WRITE setWindowObjectName)
+public:
+    QDeclarativeWebViewAttached(QObject* parent)
+        : QObject(parent)
+    {
+    }
+
+    QString windowObjectName() const
+    {
+        return m_windowObjectName;
+    }
+
+    void setWindowObjectName(const QString &n)
+    {
+        m_windowObjectName = n;
+    }
+
+private:
+    QString m_windowObjectName;
+};
+
+class QDeclarativeWebSettings : public QObject {
+    Q_OBJECT
+
+    Q_PROPERTY(QString standardFontFamily READ standardFontFamily WRITE setStandardFontFamily)
+    Q_PROPERTY(QString fixedFontFamily READ fixedFontFamily WRITE setFixedFontFamily)
+    Q_PROPERTY(QString serifFontFamily READ serifFontFamily WRITE setSerifFontFamily)
+    Q_PROPERTY(QString sansSerifFontFamily READ sansSerifFontFamily WRITE setSansSerifFontFamily)
+    Q_PROPERTY(QString cursiveFontFamily READ cursiveFontFamily WRITE setCursiveFontFamily)
+    Q_PROPERTY(QString fantasyFontFamily READ fantasyFontFamily WRITE setFantasyFontFamily)
+
+    Q_PROPERTY(int minimumFontSize READ minimumFontSize WRITE setMinimumFontSize)
+    Q_PROPERTY(int minimumLogicalFontSize READ minimumLogicalFontSize WRITE setMinimumLogicalFontSize)
+    Q_PROPERTY(int defaultFontSize READ defaultFontSize WRITE setDefaultFontSize)
+    Q_PROPERTY(int defaultFixedFontSize READ defaultFixedFontSize WRITE setDefaultFixedFontSize)
+
+    Q_PROPERTY(bool autoLoadImages READ autoLoadImages WRITE setAutoLoadImages)
+    Q_PROPERTY(bool javascriptEnabled READ javascriptEnabled WRITE setJavascriptEnabled)
+    Q_PROPERTY(bool javaEnabled READ javaEnabled WRITE setJavaEnabled)
+    Q_PROPERTY(bool pluginsEnabled READ pluginsEnabled WRITE setPluginsEnabled)
+    Q_PROPERTY(bool privateBrowsingEnabled READ privateBrowsingEnabled WRITE setPrivateBrowsingEnabled)
+    Q_PROPERTY(bool javascriptCanOpenWindows READ javascriptCanOpenWindows WRITE setJavascriptCanOpenWindows)
+    Q_PROPERTY(bool javascriptCanAccessClipboard READ javascriptCanAccessClipboard WRITE setJavascriptCanAccessClipboard)
+    Q_PROPERTY(bool developerExtrasEnabled READ developerExtrasEnabled WRITE setDeveloperExtrasEnabled)
+    Q_PROPERTY(bool linksIncludedInFocusChain READ linksIncludedInFocusChain WRITE setLinksIncludedInFocusChain)
+    Q_PROPERTY(bool zoomTextOnly READ zoomTextOnly WRITE setZoomTextOnly)
+    Q_PROPERTY(bool printElementBackgrounds READ printElementBackgrounds WRITE setPrintElementBackgrounds)
+    Q_PROPERTY(bool offlineStorageDatabaseEnabled READ offlineStorageDatabaseEnabled WRITE setOfflineStorageDatabaseEnabled)
+    Q_PROPERTY(bool offlineWebApplicationCacheEnabled READ offlineWebApplicationCacheEnabled WRITE setOfflineWebApplicationCacheEnabled)
+    Q_PROPERTY(bool localStorageDatabaseEnabled READ localStorageDatabaseEnabled WRITE setLocalStorageDatabaseEnabled)
+    Q_PROPERTY(bool localContentCanAccessRemoteUrls READ localContentCanAccessRemoteUrls WRITE setLocalContentCanAccessRemoteUrls)
+
+public:
+    QDeclarativeWebSettings() {}
+
+    QString standardFontFamily() const { return s->fontFamily(QWebSettings::StandardFont); }
+    void setStandardFontFamily(const QString& f) { s->setFontFamily(QWebSettings::StandardFont, f); }
+    QString fixedFontFamily() const { return s->fontFamily(QWebSettings::FixedFont); }
+    void setFixedFontFamily(const QString& f) { s->setFontFamily(QWebSettings::FixedFont, f); }
+    QString serifFontFamily() const { return s->fontFamily(QWebSettings::SerifFont); }
+    void setSerifFontFamily(const QString& f) { s->setFontFamily(QWebSettings::SerifFont, f); }
+    QString sansSerifFontFamily() const { return s->fontFamily(QWebSettings::SansSerifFont); }
+    void setSansSerifFontFamily(const QString& f) { s->setFontFamily(QWebSettings::SansSerifFont, f); }
+    QString cursiveFontFamily() const { return s->fontFamily(QWebSettings::CursiveFont); }
+    void setCursiveFontFamily(const QString& f) { s->setFontFamily(QWebSettings::CursiveFont, f); }
+    QString fantasyFontFamily() const { return s->fontFamily(QWebSettings::FantasyFont); }
+    void setFantasyFontFamily(const QString& f) { s->setFontFamily(QWebSettings::FantasyFont, f); }
+
+    int minimumFontSize() const { return s->fontSize(QWebSettings::MinimumFontSize); }
+    void setMinimumFontSize(int size) { s->setFontSize(QWebSettings::MinimumFontSize, size); }
+    int minimumLogicalFontSize() const { return s->fontSize(QWebSettings::MinimumLogicalFontSize); }
+    void setMinimumLogicalFontSize(int size) { s->setFontSize(QWebSettings::MinimumLogicalFontSize, size); }
+    int defaultFontSize() const { return s->fontSize(QWebSettings::DefaultFontSize); }
+    void setDefaultFontSize(int size) { s->setFontSize(QWebSettings::DefaultFontSize, size); }
+    int defaultFixedFontSize() const { return s->fontSize(QWebSettings::DefaultFixedFontSize); }
+    void setDefaultFixedFontSize(int size) { s->setFontSize(QWebSettings::DefaultFixedFontSize, size); }
+
+    bool autoLoadImages() const { return s->testAttribute(QWebSettings::AutoLoadImages); }
+    void setAutoLoadImages(bool on) { s->setAttribute(QWebSettings::AutoLoadImages, on); }
+    bool javascriptEnabled() const { return s->testAttribute(QWebSettings::JavascriptEnabled); }
+    void setJavascriptEnabled(bool on) { s->setAttribute(QWebSettings::JavascriptEnabled, on); }
+    bool javaEnabled() const { return s->testAttribute(QWebSettings::JavaEnabled); }
+    void setJavaEnabled(bool on) { s->setAttribute(QWebSettings::JavaEnabled, on); }
+    bool pluginsEnabled() const { return s->testAttribute(QWebSettings::PluginsEnabled); }
+    void setPluginsEnabled(bool on) { s->setAttribute(QWebSettings::PluginsEnabled, on); }
+    bool privateBrowsingEnabled() const { return s->testAttribute(QWebSettings::PrivateBrowsingEnabled); }
+    void setPrivateBrowsingEnabled(bool on) { s->setAttribute(QWebSettings::PrivateBrowsingEnabled, on); }
+    bool javascriptCanOpenWindows() const { return s->testAttribute(QWebSettings::JavascriptCanOpenWindows); }
+    void setJavascriptCanOpenWindows(bool on) { s->setAttribute(QWebSettings::JavascriptCanOpenWindows, on); }
+    bool javascriptCanAccessClipboard() const { return s->testAttribute(QWebSettings::JavascriptCanAccessClipboard); }
+    void setJavascriptCanAccessClipboard(bool on) { s->setAttribute(QWebSettings::JavascriptCanAccessClipboard, on); }
+    bool developerExtrasEnabled() const { return s->testAttribute(QWebSettings::DeveloperExtrasEnabled); }
+    void setDeveloperExtrasEnabled(bool on) { s->setAttribute(QWebSettings::DeveloperExtrasEnabled, on); }
+    bool linksIncludedInFocusChain() const { return s->testAttribute(QWebSettings::LinksIncludedInFocusChain); }
+    void setLinksIncludedInFocusChain(bool on) { s->setAttribute(QWebSettings::LinksIncludedInFocusChain, on); }
+    bool zoomTextOnly() const { return s->testAttribute(QWebSettings::ZoomTextOnly); }
+    void setZoomTextOnly(bool on) { s->setAttribute(QWebSettings::ZoomTextOnly, on); }
+    bool printElementBackgrounds() const { return s->testAttribute(QWebSettings::PrintElementBackgrounds); }
+    void setPrintElementBackgrounds(bool on) { s->setAttribute(QWebSettings::PrintElementBackgrounds, on); }
+    bool offlineStorageDatabaseEnabled() const { return s->testAttribute(QWebSettings::OfflineStorageDatabaseEnabled); }
+    void setOfflineStorageDatabaseEnabled(bool on) { s->setAttribute(QWebSettings::OfflineStorageDatabaseEnabled, on); }
+    bool offlineWebApplicationCacheEnabled() const { return s->testAttribute(QWebSettings::OfflineWebApplicationCacheEnabled); }
+    void setOfflineWebApplicationCacheEnabled(bool on) { s->setAttribute(QWebSettings::OfflineWebApplicationCacheEnabled, on); }
+    bool localStorageDatabaseEnabled() const { return s->testAttribute(QWebSettings::LocalStorageDatabaseEnabled); }
+    void setLocalStorageDatabaseEnabled(bool on) { s->setAttribute(QWebSettings::LocalStorageDatabaseEnabled, on); }
+    bool localContentCanAccessRemoteUrls() const { return s->testAttribute(QWebSettings::LocalContentCanAccessRemoteUrls); }
+    void setLocalContentCanAccessRemoteUrls(bool on) { s->setAttribute(QWebSettings::LocalContentCanAccessRemoteUrls, on); }
+
+    QWebSettings *s;
+};
+
+QT_END_NAMESPACE
+
+QML_DECLARE_TYPE(QDeclarativeWebView)
+QML_DECLARE_TYPE(QDeclarativeWebSettings)
+QML_DECLARE_TYPEINFO(QDeclarativeWebView, QML_HAS_ATTACHED_PROPERTIES)
+
+QT_END_HEADER
+
+#endif
diff --git a/src/3rdparty/webkit/WebKit/qt/declarative/qmldir b/src/3rdparty/webkit/WebKit/qt/declarative/qmldir
new file mode 100644
index 0000000..dcfdd06
--- /dev/null
+++ b/src/3rdparty/webkit/WebKit/qt/declarative/qmldir
@@ -0,0 +1 @@
+plugin qmlwebkitplugin
diff --git a/src/3rdparty/webkit/WebKit/qt/docs/qtwebkit.qdocconf b/src/3rdparty/webkit/WebKit/qt/docs/qtwebkit.qdocconf
index 292c124..5f877c2 100644
--- a/src/3rdparty/webkit/WebKit/qt/docs/qtwebkit.qdocconf
+++ b/src/3rdparty/webkit/WebKit/qt/docs/qtwebkit.qdocconf
@@ -3,8 +3,8 @@
 project     = qtwebkit
 description = "Qt WebKit API Documentation"
 
-headerdirs = $SRCDIR/WebKit/qt/Api
-sourcedirs = $SRCDIR/WebKit/qt/Api $SRCDIR/WebKit/qt/docs $SRCDIR/JavaScriptCore/qt/api
+headerdirs = $SRCDIR/WebKit/qt/Api $SRCDIR/WebKit/qt/declarative
+sourcedirs = $SRCDIR/WebKit/qt/Api $SRCDIR/WebKit/qt/docs $SRCDIR/JavaScriptCore/qt/api $SRCDIR/WebKit/qt/declarative
 outputdir = $OUTPUT_DIR/doc/html
 outputformats = HTML
 sources.fileextensions  = "*.cpp *.doc *.qdoc *.h"
diff --git a/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/qtwebkit_bridge_snippets.cpp b/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/qtwebkit_bridge_snippets.cpp
index 62eeeca..6a517c2 100644
--- a/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/qtwebkit_bridge_snippets.cpp
+++ b/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/qtwebkit_bridge_snippets.cpp
@@ -12,10 +12,10 @@ void wrapInFunction()
     //! [1]
     {
         width: ...,
-            height: ...,
-                toDataURL: function() { ... },
-                    assignToHTMLImageElement: function(element) { ... }
-        }
+        height: ...,
+        toDataURL: function() { ... },
+        assignToHTMLImageElement: function(element) { ... }
+    }
     //! [1]
 #endif
     //! [2]
@@ -24,7 +24,7 @@ void wrapInFunction()
         Q_PROPERTY(QPixmap myPixmap READ getPixmap)
 
     public:
-                QPixmap getPixmap() const;
+        QPixmap getPixmap() const;
     };
 
     /* ... */
@@ -36,21 +36,22 @@ void wrapInFunction()
 #if 0
     //! [3]
     <html>
-            <head>
+        <head>
             <script>
-            function loadImage() {
-        myObject.myPixmap.assignToHTMLImageElement(document.getElementById("imageElement"));
-    }
-    </script>
-            </head>
-            <body onload="loadImage()">
-                         <img id="imageElement" width="300" height="200" />
-                                                                   </body>
-                                                                   </html>
-                                                                   //! [3]
+                function loadImage()
+                {
+                    myObject.myPixmap.assignToHTMLImageElement(document.getElementById("imageElement"));
+                }
+            </script>
+        </head>
+        <body onload="loadImage()">
+            <img id="imageElement" width="300" height="200" />
+        </body>
+    </html>
+//! [3]
 #endif
-                                                                   //! [4]
-                                                                   class MyObject : QObject {
+//! [4]
+class MyObject : QObject {
         Q_OBJECT
 
     public slots:
@@ -161,11 +162,7 @@ void wrapInFunction()
     myQObject.enabled = !myQObject.enabled;
     //! [24]
     //! [25]
-    myQObject.enabled = true;
-
-    ...
-
-    myQObject.enabled = !myQObject.enabled;
+    myDialog.okButton
     //! [25]
     //! [26]
     myDialog.okButton
diff --git a/src/3rdparty/webkit/WebKit/qt/tests/qgraphicswebview/resources/input_types.html b/src/3rdparty/webkit/WebKit/qt/tests/qgraphicswebview/resources/input_types.html
new file mode 100644
index 0000000..18ab314
--- /dev/null
+++ b/src/3rdparty/webkit/WebKit/qt/tests/qgraphicswebview/resources/input_types.html
@@ -0,0 +1,8 @@
+<html><body>
+<input type='text' maxlength='20' style='position: absolute; left: 10px; top: 0px; height: 50px; width: 100px;'/><br>
+<input type='password' style='position: absolute; left: 10px; top: 50px; height: 50px; width: 100px;'/><br>
+<input type='tel' style='position: absolute; left: 10px; top: 100px; height: 50px; width: 100px;'/><br>
+<input type='number' style='position: absolute; left: 10px; top: 150px; height: 50px; width: 100px;'/><br>
+<input type='email' style='position: absolute; left: 10px; top: 200px; height: 50px; width: 100px;'/><br>
+<input type='url' style='position: absolute; left: 10px; top: 250px; height: 50px; width: 100px;'/><br>"
+</body></html>
\ No newline at end of file
diff --git a/src/3rdparty/webkit/WebKit/qt/tests/qgraphicswebview/tst_qgraphicswebview.cpp b/src/3rdparty/webkit/WebKit/qt/tests/qgraphicswebview/tst_qgraphicswebview.cpp
index ebe847d..e06524d 100644
--- a/src/3rdparty/webkit/WebKit/qt/tests/qgraphicswebview/tst_qgraphicswebview.cpp
+++ b/src/3rdparty/webkit/WebKit/qt/tests/qgraphicswebview/tst_qgraphicswebview.cpp
@@ -19,6 +19,7 @@
 
 #include "../util.h"
 #include <QtTest/QtTest>
+#include <QGraphicsSceneMouseEvent>
 #include <QGraphicsView>
 #include <qgraphicswebview.h>
 #include <qwebpage.h>
@@ -32,6 +33,7 @@ private slots:
     void qgraphicswebview();
     void crashOnViewlessWebPages();
     void microFocusCoordinates();
+    void focusInputTypes();
 };
 
 void tst_QGraphicsWebView::qgraphicswebview()
@@ -75,6 +77,29 @@ private slots:
     }
 };
 
+class GraphicsWebView : public QGraphicsWebView
+{
+    Q_OBJECT
+
+public:
+    GraphicsWebView(QGraphicsItem* parent = 0): QGraphicsWebView(parent)
+    {
+    }
+
+    void fireMouseClick(QPointF point) {
+        QGraphicsSceneMouseEvent presEv(QEvent::GraphicsSceneMousePress);
+        presEv.setPos(point);
+        presEv.setButton(Qt::LeftButton);
+        presEv.setButtons(Qt::LeftButton);
+        QGraphicsSceneMouseEvent relEv(QEvent::GraphicsSceneMouseRelease);
+        relEv.setPos(point);
+        relEv.setButton(Qt::LeftButton);
+        relEv.setButtons(Qt::LeftButton);
+        QGraphicsWebView::sceneEvent(&presEv);
+        QGraphicsWebView::sceneEvent(&relEv);
+    }
+};
+
 void tst_QGraphicsWebView::crashOnViewlessWebPages()
 {
     QGraphicsScene scene;
@@ -140,6 +165,57 @@ void tst_QGraphicsWebView::microFocusCoordinates()
     delete view;
 }
 
+void tst_QGraphicsWebView::focusInputTypes()
+{
+    QWebPage* page = new QWebPage;
+    GraphicsWebView* webView = new GraphicsWebView;
+    webView->setPage( page );
+    QGraphicsView* view = new QGraphicsView;
+    QGraphicsScene* scene = new QGraphicsScene(view);
+    view->setScene(scene);
+    scene->addItem(webView);
+    view->setGeometry(QRect(0,0,500,500));
+    QCoreApplication::processEvents();
+    QUrl url("qrc:///resources/input_types.html");
+    page->mainFrame()->load(url);
+    page->mainFrame()->setFocus();
+
+    QVERIFY(waitForSignal(page, SIGNAL(loadFinished(bool))));
+
+    // 'text' type
+    webView->fireMouseClick(QPointF(20.0, 10.0));
+#if defined(Q_WS_MAEMO_5) || defined(Q_WS_MAEMO_6) || defined(Q_OS_SYMBIAN)
+    QVERIFY(webView->inputMethodHints() & Qt::ImhNoAutoUppercase);
+    QVERIFY(webView->inputMethodHints() & Qt::ImhNoPredictiveText);
+#else
+    QVERIFY(webView->inputMethodHints() == Qt::ImhNone);
+#endif
+
+    // 'password' field
+    webView->fireMouseClick(QPointF(20.0, 60.0));
+    QVERIFY(webView->inputMethodHints() & Qt::ImhHiddenText);
+
+    // 'tel' field
+    webView->fireMouseClick(QPointF(20.0, 110.0));
+    QVERIFY(webView->inputMethodHints() & Qt::ImhDialableCharactersOnly);
+
+    // 'number' field
+    webView->fireMouseClick(QPointF(20.0, 160.0));
+    QVERIFY(webView->inputMethodHints() & Qt::ImhDigitsOnly);
+
+    // 'email' field
+    webView->fireMouseClick(QPointF(20.0, 210.0));
+    QVERIFY(webView->inputMethodHints() & Qt::ImhEmailCharactersOnly);
+
+    // 'url' field
+    webView->fireMouseClick(QPointF(20.0, 260.0));
+    QVERIFY(webView->inputMethodHints() & Qt::ImhUrlCharactersOnly);
+
+    delete webView;
+    delete view;
+}
+
+
 
 QTEST_MAIN(tst_QGraphicsWebView)
 
diff --git a/src/3rdparty/webkit/WebKit/qt/tests/qgraphicswebview/tst_qgraphicswebview.qrc b/src/3rdparty/webkit/WebKit/qt/tests/qgraphicswebview/tst_qgraphicswebview.qrc
new file mode 100644
index 0000000..c91bb9c
--- /dev/null
+++ b/src/3rdparty/webkit/WebKit/qt/tests/qgraphicswebview/tst_qgraphicswebview.qrc
@@ -0,0 +1,6 @@
+<!DOCTYPE RCC><RCC version="1.0">
+<qresource>
+    <file>resources/input_types.html</file>
+</qresource>
+</RCC>
+
diff --git a/src/3rdparty/webkit/WebKit/qt/tests/qwebview/resources/input_types.html b/src/3rdparty/webkit/WebKit/qt/tests/qwebview/resources/input_types.html
new file mode 100644
index 0000000..18ab314
--- /dev/null
+++ b/src/3rdparty/webkit/WebKit/qt/tests/qwebview/resources/input_types.html
@@ -0,0 +1,8 @@
+<html><body>
+<input type='text' maxlength='20' style='position: absolute; left: 10px; top: 0px; height: 50px; width: 100px;'/><br>
+<input type='password' style='position: absolute; left: 10px; top: 50px; height: 50px; width: 100px;'/><br>
+<input type='tel' style='position: absolute; left: 10px; top: 100px; height: 50px; width: 100px;'/><br>
+<input type='number' style='position: absolute; left: 10px; top: 150px; height: 50px; width: 100px;'/><br>
+<input type='email' style='position: absolute; left: 10px; top: 200px; height: 50px; width: 100px;'/><br>
+<input type='url' style='position: absolute; left: 10px; top: 250px; height: 50px; width: 100px;'/><br>"
+</body></html>
\ No newline at end of file
diff --git a/src/3rdparty/webkit/WebKit/qt/tests/qwebview/tst_qwebview.cpp b/src/3rdparty/webkit/WebKit/qt/tests/qwebview/tst_qwebview.cpp
index 100399e..835ad82 100644
--- a/src/3rdparty/webkit/WebKit/qt/tests/qwebview/tst_qwebview.cpp
+++ b/src/3rdparty/webkit/WebKit/qt/tests/qwebview/tst_qwebview.cpp
@@ -30,8 +30,6 @@
 #include <qwebkitversion.h>
 #include <qwebframe.h>
 
-#include <QDebug>
-
 class tst_QWebView : public QObject
 {
     Q_OBJECT
@@ -49,10 +47,25 @@ private slots:
     void reusePage_data();
     void reusePage();
     void microFocusCoordinates();
+    void focusInputTypes();
 
     void crashTests();
 };
 
+class WebView : public QWebView
+{
+    Q_OBJECT
+
+public:
+    void fireMouseClick(QPoint point) {
+        QMouseEvent presEv(QEvent::MouseButtonPress, point, Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+        QMouseEvent relEv(QEvent::MouseButtonRelease, point, Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+        QWebView::mousePressEvent(&presEv);
+        QWebView::mousePressEvent(&relEv);
+    }
+
+};
+
 // This will be called before the first test function is executed.
 // It is only called once.
 void tst_QWebView::initTestCase()
@@ -230,6 +243,52 @@ void tst_QWebView::microFocusCoordinates()
     QCOMPARE(initialMicroFocus.toRect().translated(QPoint(0,-50)), currentMicroFocus.toRect());
 }
 
+void tst_QWebView::focusInputTypes()
+{
+    QWebPage* page = new QWebPage;
+    WebView* webView = new WebView;
+    webView->setPage( page );
+
+    QCoreApplication::processEvents();
+    QUrl url("qrc:///resources/input_types.html");
+    page->mainFrame()->load(url);
+    page->mainFrame()->setFocus();
+
+    QVERIFY(waitForSignal(page, SIGNAL(loadFinished(bool))));
+
+    // 'text' type
+    webView->fireMouseClick(QPoint(20, 10));
+#if defined(Q_WS_MAEMO_5) || defined(Q_WS_MAEMO_6) || defined(Q_OS_SYMBIAN)
+    QVERIFY(webView->inputMethodHints() & Qt::ImhNoAutoUppercase);
+    QVERIFY(webView->inputMethodHints() & Qt::ImhNoPredictiveText);
+#else
+    QVERIFY(webView->inputMethodHints() == Qt::ImhNone);
+#endif
+
+    // 'password' field
+    webView->fireMouseClick(QPoint(20, 60));
+    QVERIFY(webView->inputMethodHints() & Qt::ImhHiddenText);
+
+    // 'tel' field
+    webView->fireMouseClick(QPoint(20, 110));
+    QVERIFY(webView->inputMethodHints() & Qt::ImhDialableCharactersOnly);
+
+    // 'number' field
+    webView->fireMouseClick(QPoint(20, 160));
+    QVERIFY(webView->inputMethodHints() & Qt::ImhDigitsOnly);
+
+    // 'email' field
+    webView->fireMouseClick(QPoint(20, 210));
+    QVERIFY(webView->inputMethodHints() & Qt::ImhEmailCharactersOnly);
+
+    // 'url' field
+    webView->fireMouseClick(QPoint(20, 260));
+    QVERIFY(webView->inputMethodHints() & Qt::ImhUrlCharactersOnly);
+
+    delete webView;
+
+}
+
 QTEST_MAIN(tst_QWebView)
 #include "tst_qwebview.moc"
 
diff --git a/src/3rdparty/webkit/WebKit/qt/tests/qwebview/tst_qwebview.qrc b/src/3rdparty/webkit/WebKit/qt/tests/qwebview/tst_qwebview.qrc
index 5abc64c..8710a9a 100644
--- a/src/3rdparty/webkit/WebKit/qt/tests/qwebview/tst_qwebview.qrc
+++ b/src/3rdparty/webkit/WebKit/qt/tests/qwebview/tst_qwebview.qrc
@@ -2,6 +2,7 @@
 <qresource>
     <file>resources/index.html</file>
     <file>resources/frame_a.html</file>
+    <file>resources/input_types.html</file>
 </qresource>
 </RCC>