Merge branch '4.7' of scm.dev.nokia.troll.no:qt/oslo-staging-2 into 4.7

author: David Boddie <dboddie@trolltech.com> 2010-06-10 12:56:11 (GMT)
committer: David Boddie <dboddie@trolltech.com> 2010-06-10 12:56:11 (GMT)
commit: 19e19142d8a56ba880dca869c5721ea8f72fea16 (patch)
tree: ba18b0ac8ec954bc905af5a9adb1be00b6da1bbc /src
parent: 95fcfccf3c6d9d102fa1c5481e6be52a21749af6 (diff)
parent: 7101ae5a0e90d97acf86a444c4d51ca45e7863fe (diff)
download: Qt-19e19142d8a56ba880dca869c5721ea8f72fea16.zip
Qt-19e19142d8a56ba880dca869c5721ea8f72fea16.tar.gz
Qt-19e19142d8a56ba880dca869c5721ea8f72fea16.tar.bz2
290 files changed, 6994 insertions, 2494 deletions
diff --git a/src/3rdparty/javascriptcore/JavaScriptCore/jit/JITStubs.cpp b/src/3rdparty/javascriptcore/JavaScriptCore/jit/JITStubs.cpp
index 022689b..b3c229e 100644
--- a/src/3rdparty/javascriptcore/JavaScriptCore/jit/JITStubs.cpp
+++ b/src/3rdparty/javascriptcore/JavaScriptCore/jit/JITStubs.cpp
@@ -1094,6 +1094,10 @@ RVCT()
 #define DEFINE_STUB_FUNCTION(rtype, op) rtype JIT_STUB cti_##op(STUB_ARGS_DECLARATION)
 #endif
 
+#if COMPILER(GCC)
+#pragma GCC visibility push(hidden)
+#endif
+
 DEFINE_STUB_FUNCTION(EncodedJSValue, op_convert_this)
 {
     STUB_INIT_STACK_FRAME(stackFrame);
@@ -3205,6 +3209,10 @@ DEFINE_STUB_FUNCTION(EncodedJSValue, to_object)
     return JSValue::encode(stackFrame.args[0].jsValue().toObject(callFrame));
 }
 
+#if COMPILER(GCC)
+#pragma GCC visibility pop
+#endif
+
 } // namespace JSC
 
 #endif // ENABLE(JIT)
diff --git a/src/3rdparty/phonon/mmf/abstractaudioeffect.cpp b/src/3rdparty/phonon/mmf/abstractaudioeffect.cpp
index 6cfeb76..9b64ab3 100644
--- a/src/3rdparty/phonon/mmf/abstractaudioeffect.cpp
+++ b/src/3rdparty/phonon/mmf/abstractaudioeffect.cpp
@@ -184,6 +184,8 @@ int AbstractAudioEffect::effectParameterChanged(
     const EffectParameter &param, const QVariant &value)
 {
     // Default implementation
+    Q_UNUSED(param)
+    Q_UNUSED(value)
     Q_ASSERT_X(false, Q_FUNC_INFO, "Effect has no parameters");
     return 0;
 }
diff --git a/src/3rdparty/phonon/mmf/abstractaudioeffect.h b/src/3rdparty/phonon/mmf/abstractaudioeffect.h
index d71993b..70adcf6 100644
--- a/src/3rdparty/phonon/mmf/abstractaudioeffect.h
+++ b/src/3rdparty/phonon/mmf/abstractaudioeffect.h
@@ -118,6 +118,10 @@ private:
 // for each of the effects.  Using this reduces repetition of boilerplate
 // in the implementations of the backend effect nodes.
 
+#ifdef Q_CC_NOKIAX86
+#   pragma warn_illtokenpasting off
+#endif
+
 #define PHONON_MMF_DEFINE_EFFECT_FUNCTIONS(Effect)                      \
                                                                         \
 void Effect##::createEffect(AudioPlayer::NativePlayer *player)          \
diff --git a/src/3rdparty/phonon/mmf/audiooutput.cpp b/src/3rdparty/phonon/mmf/audiooutput.cpp
index c6be20b..3588683 100644
--- a/src/3rdparty/phonon/mmf/audiooutput.cpp
+++ b/src/3rdparty/phonon/mmf/audiooutput.cpp
@@ -78,6 +78,9 @@ bool MMF::AudioOutput::setOutputDevice(int index)
 {
     Q_ASSERT_X(index == AudioOutputDeviceID, Q_FUNC_INFO,
                "We only support one output device, with id 0");
+#ifdef QT_NO_DEBUG
+    Q_UNUSED(index)
+#endif
     return true;
 }
 
diff --git a/src/3rdparty/phonon/mmf/bassboost.cpp b/src/3rdparty/phonon/mmf/bassboost.cpp
index c7af939..67076f6 100644
--- a/src/3rdparty/phonon/mmf/bassboost.cpp
+++ b/src/3rdparty/phonon/mmf/bassboost.cpp
@@ -49,6 +49,7 @@ const char* BassBoost::description()
 bool BassBoost::getParameters(CMdaAudioOutputStream *stream,
     QList<EffectParameter> &parameters)
 {
+    Q_UNUSED(parameters)
     QScopedPointer<CBassBoost> effect;
     TRAPD(err, effect.reset(CBassBoost::NewL(*stream)));
     return (KErrNone == err);
diff --git a/src/3rdparty/phonon/mmf/effectfactory.cpp b/src/3rdparty/phonon/mmf/effectfactory.cpp
index c5e33d5..4643978 100644
--- a/src/3rdparty/phonon/mmf/effectfactory.cpp
+++ b/src/3rdparty/phonon/mmf/effectfactory.cpp
@@ -183,8 +183,9 @@ EffectFactory::EffectData EffectFactory::getData()
          /* defaultValue */       QVariant(bool(true)));
     data.m_parameters.append(param);
 
-    if (data.m_supported = BackendNode::getParameters
-            (stream.data(), data.m_parameters)) {
+    data.m_supported = BackendNode::getParameters(stream.data(),
+                                                  data.m_parameters);
+    if (data.m_supported) {
         const QString description = QCoreApplication::translate
             ("Phonon::MMF::EffectFactory", BackendNode::description());
         data.m_descriptions.insert("name", description);
diff --git a/src/3rdparty/phonon/mmf/loudness.cpp b/src/3rdparty/phonon/mmf/loudness.cpp
index 1079a35..ca05ab0 100644
--- a/src/3rdparty/phonon/mmf/loudness.cpp
+++ b/src/3rdparty/phonon/mmf/loudness.cpp
@@ -49,6 +49,7 @@ const char* Loudness::description()
 bool Loudness::getParameters(CMdaAudioOutputStream *stream,
     QList<EffectParameter> &parameters)
 {
+    Q_UNUSED(parameters)
     QScopedPointer<CLoudness> effect;
     TRAPD(err, effect.reset(CLoudness::NewL(*stream)));
     return (KErrNone == err);
diff --git a/src/3rdparty/webkit/.tag b/src/3rdparty/webkit/.tag
index 1973377..09a4fe2 100644
--- a/src/3rdparty/webkit/.tag
+++ b/src/3rdparty/webkit/.tag
@@ -1 +1 @@
-807157e42add842605ec67d9363dd3f1861748ca
+f943ead2759537527faa7f3cb057d995291663b9
diff --git a/src/3rdparty/webkit/ChangeLog b/src/3rdparty/webkit/ChangeLog
index 8f9c7ac..c2862fd 100644
--- a/src/3rdparty/webkit/ChangeLog
+++ b/src/3rdparty/webkit/ChangeLog
@@ -1,3 +1,15 @@
+2010-05-04  Laszlo Gombos  <laszlo.1.gombos@nokia.com>
+
+        Unreviewed, build fix for Symbian.
+
+        [Symbian] Symbian builds does not support shadow builds
+
+        Revision r54715 broke the Symbian build. For Symbian
+        the include directory is generated in the root of the source tree.
+        This patch sets the INCLUDEPATH accordingly for Symbian.
+
+        * WebKit.pri:
+
 2010-05-14  Simon Hausmann  <simon.hausmann@nokia.com>
 
         Rubber-stamped by Antti Koivisto.
diff --git a/src/3rdparty/webkit/JavaScriptCore/ChangeLog b/src/3rdparty/webkit/JavaScriptCore/ChangeLog
index 016e0dd..d9b2987 100644
--- a/src/3rdparty/webkit/JavaScriptCore/ChangeLog
+++ b/src/3rdparty/webkit/JavaScriptCore/ChangeLog
@@ -1,3 +1,18 @@
+2010-06-07  Benjamin Poulain  <benjamin.poulain@nokia.com>
+
+        Reviewed by Simon Hausmann.
+
+        [Qt] Crash when compiling on Snow Leopard and running on Leopard
+        https://bugs.webkit.org/show_bug.cgi?id=31403
+
+        Disable the use of pthread_setname_np and other symbols
+        when targetting Leopard.
+
+        Use the defines TARGETING_XX instead of BUILDING_ON_XX 
+        for features that cannot be used before Snow Leopard.
+
+        * wtf/Platform.h:
+
 2010-04-20  Csaba Osztrogonác  <ossy@webkit.org>
 
         [Qt] Unreviewed speculative buildfix for WinCE after r57882
diff --git a/src/3rdparty/webkit/JavaScriptCore/wtf/Platform.h b/src/3rdparty/webkit/JavaScriptCore/wtf/Platform.h
index fac477e..876e60e 100644
--- a/src/3rdparty/webkit/JavaScriptCore/wtf/Platform.h
+++ b/src/3rdparty/webkit/JavaScriptCore/wtf/Platform.h
@@ -700,11 +700,11 @@
 #define HAVE_SYS_TIME_H 1
 #define HAVE_SYS_TIMEB_H 1
 
-#if !defined(BUILDING_ON_TIGER) && !defined(BUILDING_ON_LEOPARD)
+#if !defined(TARGETING_TIGER) && !defined(TARGETING_LEOPARD)
 
 #define HAVE_DISPATCH_H 1
 
-#if !PLATFORM(IPHONE) && !PLATFORM(QT)
+#if !PLATFORM(IPHONE)
 #define HAVE_MADV_FREE_REUSE 1
 #define HAVE_MADV_FREE 1
 #define HAVE_PTHREAD_SETNAME_NP 1
diff --git a/src/3rdparty/webkit/VERSION b/src/3rdparty/webkit/VERSION
index 79581d1..a19b85a 100644
--- a/src/3rdparty/webkit/VERSION
+++ b/src/3rdparty/webkit/VERSION
@@ -4,4 +4,4 @@ This is a snapshot of the Qt port of WebKit from
 
 and has the sha1 checksum
 
-        cacbdf18fc917122834042d77a9164a490aafde4
+        6db5de6d18c3ab8b74809303e4d79abacfc570a8
diff --git a/src/3rdparty/webkit/WebCore/ChangeLog b/src/3rdparty/webkit/WebCore/ChangeLog
index 481b416..1d9d739 100644
--- a/src/3rdparty/webkit/WebCore/ChangeLog
+++ b/src/3rdparty/webkit/WebCore/ChangeLog
@@ -1,3 +1,471 @@
+2010-06-07  Jocelyn Turcotte  <jocelyn.turcotte@nokia.com>
+
+        Reviewed by Simon Hausmann.
+
+        [Qt] Fix text selection drawing.
+        https://bugs.webkit.org/show_bug.cgi?id=40221
+
+        The regression was introduced in r60169.
+
+        * platform/graphics/qt/FontQt.cpp:
+        (WebCore::drawTextCommon):
+
+2010-06-04  No'am Rosenthal  <noam.rosenthal@nokia.com>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        [Qt] Fix compilation with QT_NO_FEATURE
+        https://bugs.webkit.org/show_bug.cgi?id=38324
+
+        The #ifdef QT_NO_GRAPHICSEFFECT was in the wrong place, would have
+        made AC not work at all.
+
+        No new tests.
+
+        * platform/graphics/qt/GraphicsLayerQt.cpp:
+        (WebCore::GraphicsLayerQtImpl::flushChanges):
+
+2010-05-24  Tasuku Suzuki  <tasuku.suzuki@nokia.com>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        [Qt] Fix compilation with QT_NO_TEMPORARYFILE
+        https://bugs.webkit.org/show_bug.cgi?id=38324
+
+        * platform/qt/FileSystemQt.cpp:
+        (WebCore::openTemporaryFile):
+
+2010-05-21  Tasuku Suzuki  <tasuku.suzuki@nokia.com>
+
+        Reviewed by Simon Hausmann.
+
+        [Qt] Fix compilation with QT_NO_GRAPHICSEFFECT
+        https://bugs.webkit.org/show_bug.cgi?id=38324
+
+        * platform/graphics/qt/GraphicsLayerQt.cpp:
+        (WebCore::GraphicsLayerQtImpl::flushChanges):
+
+2010-05-02  Tasuku Suzuki  <tasuku.suzuki@nokia.com>
+
+        Reviewed by Simon Hausmann.
+
+        [Qt] Fix compilation with QT_NO_BEARERMANAGEMENT
+        https://bugs.webkit.org/show_bug.cgi?id=38324
+
+        * platform/network/NetworkStateNotifier.h:
+        * platform/network/qt/NetworkStateNotifierQt.cpp:
+
+2010-05-02  Tasuku Suzuki  <tasuku.suzuki@nokia.com>
+
+        Reviewed by Simon Hausmann.
+
+        [Qt] Fix compilation with QT_NO_LINEEDIT
+        https://bugs.webkit.org/show_bug.cgi?id=38324
+
+        * platform/qt/RenderThemeQt.cpp:
+        (WebCore::RenderThemeQt::~RenderThemeQt):
+        (WebCore::RenderThemeQt::findFrameLineWidth):
+
+2010-06-04  Simon Hausmann  <simon.hausmann@nokia.com>
+
+        Reviewed by Tor Arne Vestbø.
+
+        [Qt] Compilation fails when compiling against Qt 4.7 and Qt Mobility is installed
+        https://bugs.webkit.org/show_bug.cgi?id=40116
+
+        CONFIG += mobility has the side-effect of pulling in mobility includes, which conflict
+        with Qt 4.7's bearer managenent includes and break the build.
+
+        * WebCore.pro:
+
+2010-06-03  Tor Arne Vestbø  <tor.arne.vestbo@nokia.com>
+
+        Reviewed by Simon Hausmann.
+
+        [Qt] Fix NPAPI support on Mac OS X/Cocoa-32
+
+        qt_mac_window_for() returns a NSWindow on Cocoa, so we were
+        passing in a NSWindow instead of a WindowRef as part of the
+        NP_CGContext.
+
+        https://bugs.webkit.org/show_bug.cgi?id=38762
+
+        * WebCore.gypi: Reflect rename
+        * WebCore.pro: Reflect rename
+        * plugins/mac/PluginViewMac.cpp: Renamed to PluginViewMac.mm
+        and fix bug by getting the Carbon windowRef from the NSWindow.
+        * wscript: Reflect rename
+
+2010-06-02  Nico Weber  <thakis@chromium.org>
+
+        Reviewed by Simon Fraser.
+
+        Scroll events are sent twice per keypress for ports that don't have a platformWidget scrollbar
+        https://bugs.webkit.org/show_bug.cgi?id=39918
+
+        This was regressed by http://trac.webkit.org/changeset/58615 . Fix this by slightly tweaking
+        that patch.
+
+        Test: editing/input/page-up-down-scrolls.html
+
+        * page/FrameView.cpp:
+        (WebCore::FrameView::scrollPositionChanged):
+        * page/FrameView.h:
+        * platform/ScrollView.cpp:
+        (WebCore::ScrollView::valueChanged):
+        * platform/ScrollView.h:
+        (WebCore::ScrollView::repaintFixedElementsAfterScrolling):
+
+2010-06-02  Jocelyn Turcotte  <jocelyn.turcotte@nokia.com>
+
+        Reviewed by Simon Hausmann.
+
+        [Qt] Fix make install on Symbian for headers in package builds when INSTALL_HEADERS is not defined
+
+        First we wrote inst_headers.output with $$[QT_INSTALL_HEADERS] and then
+        overwrote it with the $$INSTALL_HEADERS variant without checking if the
+        variable was set.
+
+        Fixed and cleaned up the logic of falling back to $$[QT_INSTALL_HEADERS].
+
+        * WebCore.pro:
+
+2010-06-01  No'am Rosenthal  <noam.rosenthal@nokia.com>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        [Qt] GraphicsLayer: warnings when reloading page
+        https://bugs.webkit.org/show_bug.cgi?id=39694
+
+        Made sure recaching and masks aren't attempted on zero-size layers.
+
+        No new tests. Old tests (e.g. LayoutTests/compositing/masks) show the problem.
+
+        * platform/graphics/qt/GraphicsLayerQt.cpp:
+        (WebCore::MaskEffectQt::draw):
+        (WebCore::GraphicsLayerQtImpl::recache):
+
+2010-05-10  Rodrigo Belem  <rodrigo.belem@openbossa.org>
+
+        Reviewed by Kenneth Christiansen , Simon Hausmann and Gustavo Noronha.
+
+        [Qt, Gtk] Allows build-webkit script to receive an install prefix as parameter
+        https://bugs.webkit.org/show_bug.cgi?id=26224
+
+        This patch adds the ability, in the QtWebkit build system, to change
+        the installation path.
+
+        * WebCore.pro:
+
+2010-06-01  Simon Hausmann  <simon.hausmann@nokia.com>
+
+        Reviewed by Laszlo Gombos.
+
+        [Qt] Fix installation of the QtWebKit module .pri file when building inside of Qt
+
+        * WebCore.pro:
+
+2010-06-01  Jocelyn Turcotte  <jocelyn.turcotte@nokia.com>
+
+        Reviewed by Simon Hausmann.
+
+        [Qt] Fix a QtWebKit.pc corruption problem.
+        https://bugs.webkit.org/show_bug.cgi?id=36826
+
+        The problem occurs while installing QtWebKit from trunk
+        or a source package.
+
+        * WebCore.pro:
+
+2010-06-01  Simon Hausmann  <simon.hausmann@nokia.com>
+
+        Reviewed by Laszlo Gombos.
+
+        [Qt] Fix Symbian package dependencies of apps against QtWebKit when installing into Qt
+
+        Install the versioning qt_webkit_version.pri into $$[QMAKE_MKSPECS]/modules, which is
+        where mkspecs/features/qt.prf expects it.
+
+        * WebCore.pro:
+
+2010-05-17  Andreas Kling  <andreas.kling@nokia.com>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        Bring CanvasRenderingContext2D's createImageData() in line with HTML5 spec
+        Added createImageData(ImageData) which returns a new ImageData with the same size as the one passed.
+        Changed createImageData(width, height) to use the absolute values of width and height.
+
+        https://bugs.webkit.org/show_bug.cgi?id=39189
+
+        Spec link:
+        http://www.whatwg.org/specs/web-apps/current-work/#dom-context-2d-createimagedata
+
+        Test: fast/canvas/canvas-createImageData.html
+
+        * bindings/js/JSCanvasRenderingContext2DCustom.cpp:
+        (WebCore::JSCanvasRenderingContext2D::createImageData):
+        * html/canvas/CanvasRenderingContext2D.cpp:
+        (WebCore::CanvasRenderingContext2D::createImageData):
+        * html/canvas/CanvasRenderingContext2D.h:
+        * html/canvas/CanvasRenderingContext2D.idl:
+
+2010-05-16  Andreas Kling  <andreas.kling@nokia.com>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        Properly handle invalid arguments to CanvasRenderingContext2D's getImageData() and putImageData().
+        Both should throw NOT_SUPPORTED_ERR when called with nonfinite arguments.
+        getImageData() should throw INDEX_SIZE_ERR if either width or height is 0.
+
+        https://bugs.webkit.org/show_bug.cgi?id=39175
+
+        Spec link:
+        http://www.whatwg.org/specs/web-apps/current-work/#pixel-manipulation
+
+        Test: fast/canvas/canvas-getImageData-invalid.html
+
+        * html/canvas/CanvasRenderingContext2D.cpp:
+        (WebCore::CanvasRenderingContext2D::createImageData):
+        (WebCore::CanvasRenderingContext2D::getImageData):
+        (WebCore::CanvasRenderingContext2D::putImageData):
+
+2010-05-31  Oswald Buddenhagen  <oswald.buddenhagen@nokia.com>
+
+        Reviewed by Simon Hausmann.
+
+        [Qt] Escape backslashes in the .pro files
+
+        qmake in Qt 4.7 warns about unescaped backspaces and deprecates them.
+
+        * WebCore.pro:
+
+2010-05-28  Antti Koivisto  <koivisto@iki.fi>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        https://bugs.webkit.org/show_bug.cgi?id=39874
+        [Qt] Make tiled backing store more configurable
+    
+        Make tile size, tile creation delay and tiling area dynamically configurable.
+
+        * platform/graphics/TiledBackingStore.cpp:
+        (WebCore::TiledBackingStore::TiledBackingStore):
+        (WebCore::TiledBackingStore::setTileSize):
+        (WebCore::TiledBackingStore::setTileCreationDelay):
+        (WebCore::TiledBackingStore::setKeepAndCoverAreaMultipliers):
+        (WebCore::TiledBackingStore::createTiles):
+        * platform/graphics/TiledBackingStore.h:
+        (WebCore::TiledBackingStore::tileSize):
+        (WebCore::TiledBackingStore::tileCreationDelay):
+        (WebCore::TiledBackingStore::getKeepAndCoverAreaMultipliers):
+
+2010-05-28  Andreas Kling  <andreas.kling@nokia.com>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        [Qt] REGRESSION(r59837): Incorrect clipping of TransparencyLayers
+        https://bugs.webkit.org/show_bug.cgi?id=39784
+
+        Move coordinate transformation from TransparencyLayer to clipToImageBuffer()
+
+        * platform/graphics/qt/GraphicsContextQt.cpp:
+        (WebCore::TransparencyLayer::TransparencyLayer):
+        (WebCore::GraphicsContext::clipToImageBuffer):
+
+2010-05-13  Antti Koivisto  <koivisto@iki.fi>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        https://bugs.webkit.org/show_bug.cgi?id=39063
+        [Qt] Tiled backing store checker pattern does not paint correctly when scaling factor is not 1
+
+        Use the dirty rect that has been adjusted for scaling instead of the original one.
+
+        * platform/graphics/TiledBackingStore.cpp:
+        (WebCore::TiledBackingStore::paint):
+
+2010-05-24  Kenneth Rohde Christiansen  <kenneth@webkit.org>
+
+        Reviewed by Simon Hausmann.
+
+        [Qt] Make text filling work together with text stroke.
+
+        When the text has stroke a new QPen was set, overriding the pen
+        set for text filling. This patch fixes that by storing the two
+        pens and using where appropriate.
+
+        * platform/graphics/qt/FontQt.cpp:
+        (WebCore::Font::drawComplexText):
+
+2010-05-17  Antonio Gomes  <tonikitoo@webkit.org>
+
+        Reviewed by Darin Adler.
+
+        Add an optional "starting node' parameter to scrollRecursively and scrollOverflow of EventHandler
+        https://bugs.webkit.org/show_bug.cgi?id=39217
+
+        It would be usefull if scrollOverflow and scrollRecursively methods of EventHandler
+        could receive a parameter to specify where to start scrolling from. Currently they
+        start scrolling from either the current focused node or the node where mouse last
+        pressed on. Patch proposes an aditional starting point as an optional parameter.
+        Since it is optional, all call sites can remain as are, and if a Null node is passed
+        in, both methods work as previously.
+
+        * page/EventHandler.cpp:
+        (WebCore::EventHandler::scrollOverflow):
+        (WebCore::EventHandler::scrollRecursively):
+        * page/EventHandler.h:
+
+2010-05-23  Noam Rosenthal  <noam.rosenthal@nokia.com>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        [Qt] Using Accelerated Composing the rocket back animation on http://www.the-art-of-web.com/css/css-animation/ works differently as when not using AC.
+        https://bugs.webkit.org/show_bug.cgi?id=39513
+
+        The value of GraphicsLayer->transform() needs to be changed during the animation, regardless of m_fillsForward.
+        m_fillsForward should only apply at the end of the animation. Based on previous patch by Kenneth Christiansen.
+
+        * platform/graphics/qt/GraphicsLayerQt.cpp:
+        (WebCore::TransformAnimationQt::applyFrame):
+        (WebCore::OpacityAnimationQt::applyFrame):
+
+2010-05-25  Kenneth Rohde Christiansen  <kenneth.christiansen@openbossa.org>
+
+        Reviewed by Laszlo Gombos.
+
+        [Qt] Running with accelerated compositing enabled sometimes result in a crash
+        https://bugs.webkit.org/show_bug.cgi?id=39609
+
+        Check if we have a scene before applying the workaround for
+        the QGraphicsScene bug where opacity change doesn't always have
+        immediate effect.
+
+        * platform/graphics/qt/GraphicsLayerQt.cpp:
+        (WebCore::OpacityAnimationQt::applyFrame):
+
+2010-05-19  Kenneth Rohde Christiansen  <kenneth@webkit.org>
+
+        Reviewed by Simon Hausmann.
+
+        Fix painting when using clipToImageBuffer()
+
+        When we apply the transform of the parent painter to the painter of
+        the transparency layer, we adopt its coordinate system, thus offset
+        should not be in page coordinates, but in the coordinate system of
+        the parent painter.
+
+        * platform/graphics/qt/GraphicsContextQt.cpp:
+        (WebCore::TransparencyLayer::TransparencyLayer):
+
+2010-05-19  Andreas Kling  <andreas.kling@nokia.com>
+
+        Reviewed by Simon Hausmann.
+
+        [Qt] REGRESSION: CoolClock isn't rendered properly
+
+        https://bugs.webkit.org/show_bug.cgi?id=38526
+
+        CanvasRenderingContext2D's arc() should connect to the previous point
+        with a straight line (HTML5 spec 4.8.11.1.8), but if the path is empty
+        to begin with, we don't want a line back to (0,0)
+        This also fixes the rendering artifact discussed in bug 36226.
+
+        Spec link:
+        http://www.whatwg.org/specs/web-apps/current-work/#dom-context-2d-arc
+
+        Test: fast/canvas/canvas-arc-connecting-line.html
+
+        * platform/graphics/qt/PathQt.cpp:
+        (WebCore::Path::addArc):
+
+2010-05-18  Kenneth Rohde Christiansen  <kenneth@webkit.org>
+
+        Rubberstamped by Simon Hausmann.
+
+        Return null when creating an ImageBuffer failed, due to for
+        instance a nulled pixmap.
+
+        * platform/graphics/qt/ImageBufferQt.cpp:
+        (WebCore::ImageBufferData::ImageBufferData):
+        (WebCore::ImageBuffer::ImageBuffer):
+
+2010-05-17  Antti Koivisto  <koivisto@iki.fi>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        https://bugs.webkit.org/show_bug.cgi?id=39218
+        [Qt] Tiled backing store tiles sometimes flicker when exiting a zoom animation
+        
+        Tiles sometimes flicker when exiting a zoom animation. This happens as a result
+        of the visible rectangle being momentarily out of sync.
+        
+        Instead of updating the visible rect by explicitly setting it, pull it through
+        the client and recompute in the WebKit level.
+
+        * page/ChromeClient.h:
+        (WebCore::ChromeClient::visibleRectForTiledBackingStore):
+        * page/Frame.cpp:
+        (WebCore::Frame::tiledBackingStoreVisibleRect):
+        * page/Frame.h:
+        * platform/graphics/TiledBackingStore.cpp:
+        (WebCore::TiledBackingStore::checkVisibleRectChanged):
+        (WebCore::TiledBackingStore::createTiles):
+        * platform/graphics/TiledBackingStore.h:
+        * platform/graphics/TiledBackingStoreClient.h:
+
+2010-05-18  Zoltan Herczeg  <zherczeg@webkit.org>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        [Qt] Implementing clipToImageBuffer for Qt port.
+        https://bugs.webkit.org/show_bug.cgi?id=24289
+
+        The implementation combines pixmap layers and destinationIn
+        composition mode.
+
+        * platform/graphics/qt/GraphicsContextQt.cpp:
+        (WebCore::TransparencyLayer::TransparencyLayer):
+        (WebCore::GraphicsContextPlatformPrivate::GraphicsContextPlatformPrivate):
+        (WebCore::GraphicsContext::savePlatformState):
+        (WebCore::GraphicsContext::restorePlatformState):
+        (WebCore::GraphicsContext::inTransparencyLayer):
+        (WebCore::GraphicsContext::beginTransparencyLayer):
+        (WebCore::GraphicsContext::endTransparencyLayer):
+        (WebCore::GraphicsContext::clipToImageBuffer):
+
+2010-05-16  Andreas Kling  <andreas.kling@nokia.com>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        Canvas's toDataURL() should be case insensitive wrt the mimeType argument.
+        https://bugs.webkit.org/show_bug.cgi?id=39153
+
+        Spec link:
+        http://www.whatwg.org/specs/web-apps/current-work/#dom-canvas-todataurl
+
+        Test: fast/canvas/canvas-toDataURL-case-insensitive-mimetype.html
+
+        * dom/CanvasSurface.cpp:
+        (WebCore::CanvasSurface::toDataURL):
+
+2010-05-16  Andreas Kling  <andreas.kling@nokia.com>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        Canvas's getContext() must return null when called with an invalid/unsupported parameter.
+        (HTML5 spec 4.8.11): http://www.whatwg.org/specs/web-apps/current-work/multipage/the-canvas-element.html#dom-canvas-getcontext
+
+        https://bugs.webkit.org/show_bug.cgi?id=39150
+
+        Test: fast/canvas/canvas-getContext-invalid.html
+
+        * bindings/js/JSHTMLCanvasElementCustom.cpp:
+        (WebCore::JSHTMLCanvasElement::getContext):
+        * bindings/v8/custom/V8HTMLCanvasElementCustom.cpp:
+        (WebCore::V8HTMLCanvasElement::getContextCallback):
+
 2010-05-17  Kenneth Rohde Christiansen  <kenneth@webkit.org>
 
         Reviewed by Laszlo Gombos.
diff --git a/src/3rdparty/webkit/WebCore/WebCore.gypi b/src/3rdparty/webkit/WebCore/WebCore.gypi
index 1e92f1f..94a6052 100644
--- a/src/3rdparty/webkit/WebCore/WebCore.gypi
+++ b/src/3rdparty/webkit/WebCore/WebCore.gypi
@@ -2920,7 +2920,7 @@
             'plugins/gtk/xembed.h',
             'plugins/mac/PluginDataMac.mm',
             'plugins/mac/PluginPackageMac.cpp',
-            'plugins/mac/PluginViewMac.cpp',
+            'plugins/mac/PluginViewMac.mm',
             'plugins/qt/PluginDataQt.cpp',
             'plugins/qt/PluginPackageQt.cpp',
             'plugins/qt/PluginViewQt.cpp',
diff --git a/src/3rdparty/webkit/WebCore/WebCore.pro b/src/3rdparty/webkit/WebCore/WebCore.pro
index 63e78a7..048fc93 100644
--- a/src/3rdparty/webkit/WebCore/WebCore.pro
+++ b/src/3rdparty/webkit/WebCore/WebCore.pro
@@ -74,7 +74,8 @@ CONFIG(QTDIR_build) {
     !static: DEFINES += QT_MAKEDLL
     symbian: TARGET =$$TARGET$${QT_LIBINFIX}
 }
-include($$PWD/../WebKit/qt/qtwebkit_version.pri)
+moduleFile=$$PWD/../WebKit/qt/qt_webkit_version.pri
+include($$moduleFile)
 VERSION = $${QT_WEBKIT_MAJOR_VERSION}.$${QT_WEBKIT_MINOR_VERSION}.$${QT_WEBKIT_PATCH_VERSION}
 
 unix {
@@ -2165,7 +2166,7 @@ contains(DEFINES, ENABLE_NETSCAPE_PLUGIN_API=1) {
             mac {
                 SOURCES += \
                     plugins/mac/PluginPackageMac.cpp \
-                    plugins/mac/PluginViewMac.cpp
+                    plugins/mac/PluginViewMac.mm
                 OBJECTIVE_SOURCES += \
                     platform/text/mac/StringImplMac.mm \
                     platform/mac/WebCoreNSStringExtras.mm
@@ -2495,8 +2496,12 @@ contains(DEFINES, ENABLE_QT_BEARER=1) {
     SOURCES += \
         platform/network/qt/NetworkStateNotifierQt.cpp
 
-    CONFIG += mobility
-    MOBILITY += bearer
+    # Bearer management is part of Qt 4.7, so don't accidentially
+    # pull in Qt Mobility when building against >= 4.7
+    !greaterThan(QT_MINOR_VERSION, 6) {
+        CONFIG += mobility
+        MOBILITY += bearer
+    }
 }
 
 contains(DEFINES, ENABLE_SVG=1) {
@@ -2840,24 +2845,45 @@ contains(DEFINES, ENABLE_SYMBIAN_DIALOG_PROVIDERS) {
 include($$PWD/../WebKit/qt/Api/headers.pri)
 HEADERS += $$WEBKIT_API_HEADERS
 
-!CONFIG(QTDIR_build) {
+CONFIG(QTDIR_build) {
+    modfile.files = $$moduleFile
+    modfile.path = $$[QMAKE_MKSPECS]/modules
+
+    INSTALLS += modfile
+} else {
     exists($$OUTPUT_DIR/include/QtWebKit/classheaders.pri): include($$OUTPUT_DIR/include/QtWebKit/classheaders.pri)
     WEBKIT_INSTALL_HEADERS = $$WEBKIT_API_HEADERS $$WEBKIT_CLASS_HEADERS
 
     !symbian {
         headers.files = $$WEBKIT_INSTALL_HEADERS
-        headers.path = $$[QT_INSTALL_HEADERS]/QtWebKit
-        target.path = $$[QT_INSTALL_LIBS]
 
-        INSTALLS += target headers
+        !isEmpty(INSTALL_HEADERS): headers.path = $$INSTALL_HEADERS/QtWebKit
+        else: headers.path = $$[QT_INSTALL_HEADERS]/QtWebKit
+
+        !isEmpty(INSTALL_LIBS): target.path = $$INSTALL_LIBS
+        else: target.path = $$[QT_INSTALL_LIBS]
+
+        modfile.files = $$moduleFile
+        modfile.path = $$[QMAKE_MKSPECS]/modules
+
+        INSTALLS += target headers modfile
     } else {
         # INSTALLS is not implemented in qmake's s60 generators, copy headers manually
         inst_headers.commands = $$QMAKE_COPY ${QMAKE_FILE_NAME} ${QMAKE_FILE_OUT}
         inst_headers.input = WEBKIT_INSTALL_HEADERS
-        inst_headers.output = $$[QT_INSTALL_HEADERS]/QtWebKit/${QMAKE_FILE_BASE}${QMAKE_FILE_EXT}
+
+        !isEmpty(INSTALL_HEADERS): inst_headers.output = $$INSTALL_HEADERS/QtWebKit/${QMAKE_FILE_BASE}${QMAKE_FILE_EXT}
+        else: inst_headers.output = $$[QT_INSTALL_HEADERS]/QtWebKit/${QMAKE_FILE_BASE}${QMAKE_FILE_EXT}
+
         QMAKE_EXTRA_COMPILERS += inst_headers
 
-        install.depends += compiler_inst_headers_make_all
+        inst_modfile.commands = $$inst_headers.commands
+        inst_modfile.input = moduleFile
+        inst_modfile.output = $$[QMAKE_MKSPECS]/modules
+
+        QMAKE_EXTRA_COMPILERS += inst_modfile
+
+        install.depends += compiler_inst_headers_make_all compiler_inst_modfile_make_all
         QMAKE_EXTRA_TARGETS += install
     }
 
@@ -2875,7 +2901,7 @@ HEADERS += $$WEBKIT_API_HEADERS
         QMAKE_PKGCONFIG_LIBDIR = $$target.path
         QMAKE_PKGCONFIG_INCDIR = $$headers.path
         QMAKE_PKGCONFIG_DESTDIR = pkgconfig
-        lib_replace.match = $$DESTDIR
+        lib_replace.match = $$re_escape($$DESTDIR)
         lib_replace.replace = $$[QT_INSTALL_LIBS]
         QMAKE_PKGCONFIG_INSTALL_REPLACE += lib_replace
     }
diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasRenderingContext2DCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasRenderingContext2DCustom.cpp
index a271923..0254d0f 100644
--- a/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasRenderingContext2DCustom.cpp
+++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasRenderingContext2DCustom.cpp
@@ -361,6 +361,24 @@ JSValue JSCanvasRenderingContext2D::createPattern(ExecState* exec, const ArgList
     return jsUndefined();
 }
 
+JSValue JSCanvasRenderingContext2D::createImageData(ExecState* exec, const ArgList& args)
+{
+    // createImageData has two variants
+    // createImageData(ImageData)
+    // createImageData(width, height)
+    CanvasRenderingContext2D* context = static_cast<CanvasRenderingContext2D*>(impl());
+    RefPtr<ImageData> imageData = 0;
+
+    ExceptionCode ec = 0;
+    if (args.size() == 1)
+        imageData = context->createImageData(toImageData(args.at(0)), ec);
+    else if (args.size() == 2)
+        imageData = context->createImageData(args.at(0).toFloat(exec), args.at(1).toFloat(exec), ec);
+
+    setDOMException(exec, ec);
+    return toJS(exec, globalObject(), WTF::getPtr(imageData));
+}
+
 JSValue JSCanvasRenderingContext2D::putImageData(ExecState* exec, const ArgList& args)
 {
     // putImageData has two variants
diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLCanvasElementCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLCanvasElementCustom.cpp
index 80634f7..8f241f9 100644
--- a/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLCanvasElementCustom.cpp
+++ b/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLCanvasElementCustom.cpp
@@ -78,7 +78,10 @@ JSValue JSHTMLCanvasElement::getContext(ExecState* exec, const ArgList& args)
         }
     }
 #endif
-    return toJS(exec, globalObject(), WTF::getPtr(canvas->getContext(contextId, attrs.get())));
+    CanvasRenderingContext* context = canvas->getContext(contextId, attrs.get());
+    if (!context)
+        return jsNull();
+    return toJS(exec, globalObject(), WTF::getPtr(context));
 }
 
 } // namespace WebCore
diff --git a/src/3rdparty/webkit/WebCore/generated/JSCanvasRenderingContext2D.cpp b/src/3rdparty/webkit/WebCore/generated/JSCanvasRenderingContext2D.cpp
index a991e8d..d97b54a 100644
--- a/src/3rdparty/webkit/WebCore/generated/JSCanvasRenderingContext2D.cpp
+++ b/src/3rdparty/webkit/WebCore/generated/JSCanvasRenderingContext2D.cpp
@@ -165,7 +165,7 @@ static const HashTableValue JSCanvasRenderingContext2DPrototypeTableValues[45] =
     { "drawImageFromRect", DontDelete|Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionDrawImageFromRect), (intptr_t)0 },
     { "setShadow", DontDelete|Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionSetShadow), (intptr_t)0 },
     { "createPattern", DontDelete|Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionCreatePattern), (intptr_t)0 },
-    { "createImageData", DontDelete|Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionCreateImageData), (intptr_t)2 },
+    { "createImageData", DontDelete|Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionCreateImageData), (intptr_t)0 },
     { "getImageData", DontDelete|Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionGetImageData), (intptr_t)4 },
     { "putImageData", DontDelete|Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionPutImageData), (intptr_t)0 },
     { 0, 0, 0, 0 }
@@ -1018,15 +1018,7 @@ JSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionCreateImageData
     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))
         return throwError(exec, TypeError);
     JSCanvasRenderingContext2D* castedThisObj = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));
-    CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThisObj->impl());
-    ExceptionCode ec = 0;
-    float sw = args.at(0).toFloat(exec);
-    float sh = args.at(1).toFloat(exec);
-
-
-    JSC::JSValue result = toJS(exec, castedThisObj->globalObject(), WTF::getPtr(imp->createImageData(sw, sh, ec)));
-    setDOMException(exec, ec);
-    return result;
+    return castedThisObj->createImageData(exec, args);
 }
 
 JSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionGetImageData(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
diff --git a/src/3rdparty/webkit/WebCore/generated/JSCanvasRenderingContext2D.h b/src/3rdparty/webkit/WebCore/generated/JSCanvasRenderingContext2D.h
index 218e455..92fabb7 100644
--- a/src/3rdparty/webkit/WebCore/generated/JSCanvasRenderingContext2D.h
+++ b/src/3rdparty/webkit/WebCore/generated/JSCanvasRenderingContext2D.h
@@ -61,6 +61,7 @@ public:
     JSC::JSValue drawImageFromRect(JSC::ExecState*, const JSC::ArgList&);
     JSC::JSValue setShadow(JSC::ExecState*, const JSC::ArgList&);
     JSC::JSValue createPattern(JSC::ExecState*, const JSC::ArgList&);
+    JSC::JSValue createImageData(JSC::ExecState*, const JSC::ArgList&);
     JSC::JSValue putImageData(JSC::ExecState*, const JSC::ArgList&);
 protected:
     static const unsigned StructureFlags = JSC::OverridesGetOwnPropertySlot | Base::StructureFlags;
diff --git a/src/3rdparty/webkit/WebCore/html/HTMLCanvasElement.cpp b/src/3rdparty/webkit/WebCore/html/HTMLCanvasElement.cpp
index 30a620c..0c5159d 100644
--- a/src/3rdparty/webkit/WebCore/html/HTMLCanvasElement.cpp
+++ b/src/3rdparty/webkit/WebCore/html/HTMLCanvasElement.cpp
@@ -143,10 +143,12 @@ String HTMLCanvasElement::toDataURL(const String& mimeType, ExceptionCode& ec)
     if (m_size.isEmpty() || !buffer())
         return String("data:,");
 
-    if (mimeType.isNull() || !MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType))
+    String lowercaseMimeType = mimeType.lower();
+
+    if (mimeType.isNull() || !MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(lowercaseMimeType))
         return buffer()->toDataURL("image/png");
 
-    return buffer()->toDataURL(mimeType);
+    return buffer()->toDataURL(lowercaseMimeType);
 }
 
 CanvasRenderingContext* HTMLCanvasElement::getContext(const String& type, CanvasContextAttributes* attrs)
diff --git a/src/3rdparty/webkit/WebCore/html/canvas/CanvasRenderingContext2D.cpp b/src/3rdparty/webkit/WebCore/html/canvas/CanvasRenderingContext2D.cpp
index 398e4d8..9cec7a9 100644
--- a/src/3rdparty/webkit/WebCore/html/canvas/CanvasRenderingContext2D.cpp
+++ b/src/3rdparty/webkit/WebCore/html/canvas/CanvasRenderingContext2D.cpp
@@ -1278,14 +1278,30 @@ static PassRefPtr<ImageData> createEmptyImageData(const IntSize& size)
     return data.get();
 }
 
+PassRefPtr<ImageData> CanvasRenderingContext2D::createImageData(PassRefPtr<ImageData> imageData, ExceptionCode& ec) const
+{
+    if (!imageData) {
+        ec = NOT_SUPPORTED_ERR;
+        return 0;
+    }
+
+    IntSize size(imageData->width(), imageData->height());
+    return createEmptyImageData(size);
+}
+
 PassRefPtr<ImageData> CanvasRenderingContext2D::createImageData(float sw, float sh, ExceptionCode& ec) const
 {
     ec = 0;
+    if (!sw || !sh) {
+        ec = INDEX_SIZE_ERR;
+        return 0;
+    }
     if (!isfinite(sw) || !isfinite(sh)) {
         ec = NOT_SUPPORTED_ERR;
         return 0;
     }
-    FloatSize unscaledSize(sw, sh);
+
+    FloatSize unscaledSize(fabs(sw), fabs(sh));
     IntSize scaledSize = canvas()->convertLogicalToDevice(unscaledSize);
     if (scaledSize.width() < 1)
         scaledSize.setWidth(1);
@@ -1301,7 +1317,15 @@ PassRefPtr<ImageData> CanvasRenderingContext2D::getImageData(float sx, float sy,
         ec = SECURITY_ERR;
         return 0;
     }
-    
+    if (!sw || !sh) {
+        ec = INDEX_SIZE_ERR;
+        return 0;
+    }
+    if (!isfinite(sx) || !isfinite(sy) || !isfinite(sw) || !isfinite(sh)) {
+        ec = NOT_SUPPORTED_ERR;
+        return 0;
+    }
+
     FloatRect unscaledRect(sx, sy, sw, sh);
     IntRect scaledRect = canvas()->convertLogicalToDevice(unscaledRect);
     if (scaledRect.width() < 1)
@@ -1332,7 +1356,7 @@ void CanvasRenderingContext2D::putImageData(ImageData* data, float dx, float dy,
     }
     if (!isfinite(dx) || !isfinite(dy) || !isfinite(dirtyX) || 
         !isfinite(dirtyY) || !isfinite(dirtyWidth) || !isfinite(dirtyHeight)) {
-        ec = INDEX_SIZE_ERR;
+        ec = NOT_SUPPORTED_ERR;
         return;
     }
 
diff --git a/src/3rdparty/webkit/WebCore/html/canvas/CanvasRenderingContext2D.h b/src/3rdparty/webkit/WebCore/html/canvas/CanvasRenderingContext2D.h
index 553ffd2..2220f7e 100644
--- a/src/3rdparty/webkit/WebCore/html/canvas/CanvasRenderingContext2D.h
+++ b/src/3rdparty/webkit/WebCore/html/canvas/CanvasRenderingContext2D.h
@@ -178,6 +178,7 @@ namespace WebCore {
         PassRefPtr<CanvasPattern> createPattern(HTMLImageElement*, const String& repetitionType, ExceptionCode&);
         PassRefPtr<CanvasPattern> createPattern(HTMLCanvasElement*, const String& repetitionType, ExceptionCode&);
         
+        PassRefPtr<ImageData> createImageData(PassRefPtr<ImageData> imageData, ExceptionCode&) const;
         PassRefPtr<ImageData> createImageData(float width, float height, ExceptionCode&) const;
         PassRefPtr<ImageData> getImageData(float sx, float sy, float sw, float sh, ExceptionCode&) const;
         void putImageData(ImageData*, float dx, float dy, ExceptionCode&);
diff --git a/src/3rdparty/webkit/WebCore/html/canvas/CanvasRenderingContext2D.idl b/src/3rdparty/webkit/WebCore/html/canvas/CanvasRenderingContext2D.idl
index f93a752..3f7ead7 100644
--- a/src/3rdparty/webkit/WebCore/html/canvas/CanvasRenderingContext2D.idl
+++ b/src/3rdparty/webkit/WebCore/html/canvas/CanvasRenderingContext2D.idl
@@ -105,13 +105,12 @@ module html {
         [Custom] void drawImageFromRect(/* 10 */);
         [Custom] void setShadow(/* 3 */);
         [Custom] void createPattern(/* 2 */);
+        [Custom] ImageData createImageData(/* 3 */);
         
         attribute [Custom] custom strokeStyle;
         attribute [Custom] custom fillStyle;
         
         // pixel manipulation
-        ImageData createImageData(in float sw, in float sh)
-            raises (DOMException);
         ImageData getImageData(in float sx, in float sy, in float sw, in float sh)
             raises(DOMException);
         [Custom] void putImageData(/* in ImageData imagedata, in float dx, in float dy [, in float dirtyX, in float dirtyY, in float dirtyWidth, in float dirtyHeight] */);
diff --git a/src/3rdparty/webkit/WebCore/page/ChromeClient.h b/src/3rdparty/webkit/WebCore/page/ChromeClient.h
index 0bfdbaf..a01eef1 100644
--- a/src/3rdparty/webkit/WebCore/page/ChromeClient.h
+++ b/src/3rdparty/webkit/WebCore/page/ChromeClient.h
@@ -222,7 +222,11 @@ namespace WebCore {
         virtual bool supportsFullscreenForNode(const Node*) { return false; }
         virtual void enterFullscreenForNode(Node*) { }
         virtual void exitFullscreenForNode(Node*) { }
-        
+
+#if ENABLE(TILED_BACKING_STORE)
+        virtual IntRect visibleRectForTiledBackingStore() const { return IntRect(); }
+#endif
+
 #if PLATFORM(MAC)
         virtual KeyboardUIMode keyboardUIMode() { return KeyboardAccessDefault; }
 
diff --git a/src/3rdparty/webkit/WebCore/page/EventHandler.cpp b/src/3rdparty/webkit/WebCore/page/EventHandler.cpp
index 46dd7ae..c40299c 100644
--- a/src/3rdparty/webkit/WebCore/page/EventHandler.cpp
+++ b/src/3rdparty/webkit/WebCore/page/EventHandler.cpp
@@ -929,9 +929,13 @@ void EventHandler::setMousePressNode(PassRefPtr<Node> node)
     m_mousePressNode = node;
 }
 
-bool EventHandler::scrollOverflow(ScrollDirection direction, ScrollGranularity granularity)
+bool EventHandler::scrollOverflow(ScrollDirection direction, ScrollGranularity granularity, Node* startingNode)
 {
-    Node* node = m_frame->document()->focusedNode();
+    Node* node = startingNode;
+
+    if (!node)
+        node = m_frame->document()->focusedNode();
+
     if (!node)
         node = m_mousePressNode.get();
     
@@ -946,9 +950,9 @@ bool EventHandler::scrollOverflow(ScrollDirection direction, ScrollGranularity g
     return false;
 }
 
-bool EventHandler::scrollRecursively(ScrollDirection direction, ScrollGranularity granularity)
+bool EventHandler::scrollRecursively(ScrollDirection direction, ScrollGranularity granularity, Node* startingNode)
 {
-    bool handled = scrollOverflow(direction, granularity);
+    bool handled = scrollOverflow(direction, granularity, startingNode);
     if (!handled) {
         Frame* frame = m_frame;
         do {
diff --git a/src/3rdparty/webkit/WebCore/page/EventHandler.h b/src/3rdparty/webkit/WebCore/page/EventHandler.h
index 282100d..a94e7bf 100644
--- a/src/3rdparty/webkit/WebCore/page/EventHandler.h
+++ b/src/3rdparty/webkit/WebCore/page/EventHandler.h
@@ -130,9 +130,9 @@ public:
 
     static Frame* subframeForTargetNode(Node*);
 
-    bool scrollOverflow(ScrollDirection, ScrollGranularity);
+    bool scrollOverflow(ScrollDirection, ScrollGranularity, Node* startingNode = 0);
 
-    bool scrollRecursively(ScrollDirection, ScrollGranularity);
+    bool scrollRecursively(ScrollDirection, ScrollGranularity, Node* startingNode = 0);
 
 #if ENABLE(DRAG_SUPPORT)
     bool shouldDragAutoNode(Node*, const IntPoint&) const; // -webkit-user-drag == auto
diff --git a/src/3rdparty/webkit/WebCore/page/Frame.cpp b/src/3rdparty/webkit/WebCore/page/Frame.cpp
index 6dbca69..379bf7d 100644
--- a/src/3rdparty/webkit/WebCore/page/Frame.cpp
+++ b/src/3rdparty/webkit/WebCore/page/Frame.cpp
@@ -37,6 +37,7 @@
 #include "CSSPropertyNames.h"
 #include "CachedCSSStyleSheet.h"
 #include "Chrome.h"
+#include "ChromeClient.h"
 #include "DOMWindow.h"
 #include "DocLoader.h"
 #include "DocumentType.h"
@@ -1853,6 +1854,13 @@ IntRect Frame::tiledBackingStoreContentsRect()
         return IntRect();
     return IntRect(IntPoint(), m_view->contentsSize());
 }
+
+IntRect Frame::tiledBackingStoreVisibleRect()
+{
+    if (!m_page)
+        return IntRect();
+    return m_page->chrome()->client()->visibleRectForTiledBackingStore();
+}
 #endif
 
 } // namespace WebCore
diff --git a/src/3rdparty/webkit/WebCore/page/Frame.h b/src/3rdparty/webkit/WebCore/page/Frame.h
index 67761f9..a654cd7 100644
--- a/src/3rdparty/webkit/WebCore/page/Frame.h
+++ b/src/3rdparty/webkit/WebCore/page/Frame.h
@@ -288,6 +288,7 @@ namespace WebCore {
         virtual void tiledBackingStorePaint(GraphicsContext*, const IntRect&);
         virtual void tiledBackingStorePaintEnd(const Vector<IntRect>& paintedArea);
         virtual IntRect tiledBackingStoreContentsRect();
+        virtual IntRect tiledBackingStoreVisibleRect();
 #endif
 
     #if PLATFORM(MAC)
diff --git a/src/3rdparty/webkit/WebCore/page/FrameView.cpp b/src/3rdparty/webkit/WebCore/page/FrameView.cpp
index 39c92de..bc0519f 100644
--- a/src/3rdparty/webkit/WebCore/page/FrameView.cpp
+++ b/src/3rdparty/webkit/WebCore/page/FrameView.cpp
@@ -1060,7 +1060,11 @@ void FrameView::setScrollPosition(const IntPoint& scrollPoint)
 void FrameView::scrollPositionChanged()
 {
     frame()->eventHandler()->sendScrollEvent();
+    repaintFixedElementsAfterScrolling();
+}
 
+void FrameView::repaintFixedElementsAfterScrolling()
+{
     // For fixed position elements, update widget positions and compositing layers after scrolling,
     // but only if we're not inside of layout.
     // FIXME: we could skip this if we knew the page had no fixed position elements.
diff --git a/src/3rdparty/webkit/WebCore/page/FrameView.h b/src/3rdparty/webkit/WebCore/page/FrameView.h
index 7119975..71e2966 100644
--- a/src/3rdparty/webkit/WebCore/page/FrameView.h
+++ b/src/3rdparty/webkit/WebCore/page/FrameView.h
@@ -139,7 +139,8 @@ public:
 
     virtual void scrollRectIntoViewRecursively(const IntRect&);
     virtual void setScrollPosition(const IntPoint&);
-    virtual void scrollPositionChanged();
+    void scrollPositionChanged();
+    virtual void repaintFixedElementsAfterScrolling();
 
     String mediaType() const;
     void setMediaType(const String&);
diff --git a/src/3rdparty/webkit/WebCore/platform/ScrollView.cpp b/src/3rdparty/webkit/WebCore/platform/ScrollView.cpp
index e50ab55..5753e1d 100644
--- a/src/3rdparty/webkit/WebCore/platform/ScrollView.cpp
+++ b/src/3rdparty/webkit/WebCore/platform/ScrollView.cpp
@@ -292,7 +292,7 @@ void ScrollView::valueChanged(Scrollbar* scrollbar)
     if (scrollbarsSuppressed())
         return;
 
-    scrollPositionChanged();
+    repaintFixedElementsAfterScrolling();
     scrollContents(scrollDelta);
 }
 
diff --git a/src/3rdparty/webkit/WebCore/platform/ScrollView.h b/src/3rdparty/webkit/WebCore/platform/ScrollView.h
index 118a310..0f79fa8 100644
--- a/src/3rdparty/webkit/WebCore/platform/ScrollView.h
+++ b/src/3rdparty/webkit/WebCore/platform/ScrollView.h
@@ -303,7 +303,7 @@ private:
     void updateScrollbars(const IntSize& desiredOffset);
 
     // Called when the scroll position within this view changes.  FrameView overrides this to generate repaint invalidations.
-    virtual void scrollPositionChanged() {}
+    virtual void repaintFixedElementsAfterScrolling() {}
 
     void platformInit();
     void platformDestroy();
diff --git a/src/3rdparty/webkit/WebCore/platform/graphics/TiledBackingStore.cpp b/src/3rdparty/webkit/WebCore/platform/graphics/TiledBackingStore.cpp
index 6214f1b..1d6f237 100644
--- a/src/3rdparty/webkit/WebCore/platform/graphics/TiledBackingStore.cpp
+++ b/src/3rdparty/webkit/WebCore/platform/graphics/TiledBackingStore.cpp
@@ -35,6 +35,9 @@ TiledBackingStore::TiledBackingStore(TiledBackingStoreClient* client)
     , m_tileBufferUpdateTimer(new TileTimer(this, &TiledBackingStore::tileBufferUpdateTimerFired))
     , m_tileCreationTimer(new TileTimer(this, &TiledBackingStore::tileCreationTimerFired))
     , m_tileSize(defaultTileWidth, defaultTileHeight)
+    , m_tileCreationDelay(0.01)
+    , m_keepAreaMultiplier(2.f, 3.5f)
+    , m_coverAreaMultiplier(1.5f, 2.5f)
     , m_contentsScale(1.f)
     , m_pendingScale(0)
     , m_contentsFrozen(false)
@@ -46,6 +49,25 @@ TiledBackingStore::~TiledBackingStore()
     delete m_tileBufferUpdateTimer;
     delete m_tileCreationTimer;
 }
+    
+void TiledBackingStore::setTileSize(const IntSize& size)
+{
+    m_tileSize = size;
+    m_tiles.clear();
+    startTileCreationTimer();
+}
+
+void TiledBackingStore::setTileCreationDelay(double delay)
+{
+    m_tileCreationDelay = delay;
+}
+
+void TiledBackingStore::setKeepAndCoverAreaMultipliers(const FloatSize& keepMultiplier, const FloatSize& coverMultiplier)
+{
+    m_keepAreaMultiplier = keepMultiplier;
+    m_coverAreaMultiplier = coverMultiplier;
+    startTileCreationTimer();
+}
 
 void TiledBackingStore::invalidate(const IntRect& contentsDirtyRect)
 {
@@ -120,22 +142,23 @@ void TiledBackingStore::paint(GraphicsContext* context, const IntRect& rect)
             if (currentTile && currentTile->isReadyToPaint())
                 currentTile->paint(context, dirtyRect);
             else {
-                FloatRect tileRect = tileRectForCoordinate(currentCoordinate);
-                FloatRect target = intersection(tileRect, FloatRect(rect));
-                Tile::paintCheckerPattern(context, target);
+                IntRect tileRect = tileRectForCoordinate(currentCoordinate);
+                IntRect target = intersection(tileRect, dirtyRect);
+                if (target.isEmpty())
+                    continue;
+                Tile::paintCheckerPattern(context, FloatRect(target));
             }
         }
     }
     context->restore();
 }
 
-void TiledBackingStore::viewportChanged(const IntRect& contentsViewport)
+void TiledBackingStore::adjustVisibleRect()
 {
-    IntRect viewport = mapFromContents(contentsViewport);
-    if (m_viewport == viewport)
+    IntRect visibleRect = mapFromContents(m_client->tiledBackingStoreVisibleRect());
+    if (m_previousVisibleRect == visibleRect)
         return;
-
-    m_viewport = viewport;
+    m_previousVisibleRect = visibleRect;
 
     startTileCreationTimer();
 }
@@ -177,24 +200,26 @@ void TiledBackingStore::createTiles()
 {
     if (m_contentsFrozen)
         return;
+    
+    IntRect visibleRect = mapFromContents(m_client->tiledBackingStoreVisibleRect());
+    m_previousVisibleRect = visibleRect;
 
-    if (m_viewport.isEmpty())
+    if (visibleRect.isEmpty())
         return;
 
     // Remove tiles that extend outside the current contents rect.
     dropOverhangingTiles();
 
-    // FIXME: Make configurable/adapt to memory.
-    IntRect keepRect = m_viewport;
-    keepRect.inflateX(m_viewport.width());
-    keepRect.inflateY(3 * m_viewport.height());
+    IntRect keepRect = visibleRect;
+    keepRect.inflateX(visibleRect.width() * (m_keepAreaMultiplier.width() - 1.f));
+    keepRect.inflateY(visibleRect.height() * (m_keepAreaMultiplier.height() - 1.f));
     keepRect.intersect(contentsRect());
     
     dropTilesOutsideRect(keepRect);
     
-    IntRect coverRect = m_viewport;
-    coverRect.inflateX(m_viewport.width() / 2);
-    coverRect.inflateY(2 * m_viewport.height());
+    IntRect coverRect = visibleRect;
+    coverRect.inflateX(visibleRect.width() * (m_coverAreaMultiplier.width() - 1.f));
+    coverRect.inflateY(visibleRect.height() * (m_coverAreaMultiplier.height() - 1.f));
     coverRect.intersect(contentsRect());
     
     // Search for the tile position closest to the viewport center that does not yet contain a tile. 
@@ -211,7 +236,7 @@ void TiledBackingStore::createTiles()
                 continue;
             ++requiredTileCount;
             // Distance is 0 for all currently visible tiles.
-            double distance = tileDistance(m_viewport, currentCoordinate);
+            double distance = tileDistance(visibleRect, currentCoordinate);
             if (distance > shortestDistance)
                 continue;
             if (distance < shortestDistance) {
@@ -236,7 +261,7 @@ void TiledBackingStore::createTiles()
 
     // Keep creating tiles until the whole coverRect is covered.
     if (requiredTileCount)
-        m_tileCreationTimer->startOneShot(0);
+        m_tileCreationTimer->startOneShot(m_tileCreationDelay);
 }
 
 void TiledBackingStore::dropOverhangingTiles()
diff --git a/src/3rdparty/webkit/WebCore/platform/graphics/TiledBackingStore.h b/src/3rdparty/webkit/WebCore/platform/graphics/TiledBackingStore.h
index 8ed4336..58477db 100644
--- a/src/3rdparty/webkit/WebCore/platform/graphics/TiledBackingStore.h
+++ b/src/3rdparty/webkit/WebCore/platform/graphics/TiledBackingStore.h
@@ -41,7 +41,7 @@ public:
     TiledBackingStore(TiledBackingStoreClient*);
     ~TiledBackingStore();
 
-    void viewportChanged(const IntRect& viewportRect);
+    void adjustVisibleRect();
     
     float contentsScale() { return m_contentsScale; }
     void setContentsScale(float);
@@ -51,6 +51,20 @@ public:
 
     void invalidate(const IntRect& dirtyRect);
     void paint(GraphicsContext*, const IntRect&);
+    
+    IntSize tileSize() { return m_tileSize; }
+    void setTileSize(const IntSize&);
+    
+    double tileCreationDelay() const { return m_tileCreationDelay; }
+    void setTileCreationDelay(double delay);
+    
+    // Tiled are dropped outside the keep area, and created for cover area. The values a relative to the viewport size.
+    void getKeepAndCoverAreaMultipliers(FloatSize& keepMultiplier, FloatSize& coverMultiplier)
+    {
+        keepMultiplier = m_keepAreaMultiplier;
+        coverMultiplier = m_coverAreaMultiplier;
+    }
+    void setKeepAndCoverAreaMultipliers(const FloatSize& keepMultiplier, const FloatSize& coverMultiplier);    
 
 private:
     void startTileBufferUpdateTimer();
@@ -94,8 +108,11 @@ private:
     TileTimer* m_tileCreationTimer;
 
     IntSize m_tileSize;
+    double m_tileCreationDelay;
+    FloatSize m_keepAreaMultiplier;
+    FloatSize m_coverAreaMultiplier;
     
-    IntRect m_viewport;
+    IntRect m_previousVisibleRect;
     float m_contentsScale;
     float m_pendingScale;
 
diff --git a/src/3rdparty/webkit/WebCore/platform/graphics/TiledBackingStoreClient.h b/src/3rdparty/webkit/WebCore/platform/graphics/TiledBackingStoreClient.h
index 4adbbab..c5845b9 100644
--- a/src/3rdparty/webkit/WebCore/platform/graphics/TiledBackingStoreClient.h
+++ b/src/3rdparty/webkit/WebCore/platform/graphics/TiledBackingStoreClient.h
@@ -29,6 +29,7 @@ public:
     virtual void tiledBackingStorePaint(GraphicsContext*, const IntRect&) = 0;
     virtual void tiledBackingStorePaintEnd(const Vector<IntRect>& paintedArea) = 0;
     virtual IntRect tiledBackingStoreContentsRect() = 0;
+    virtual IntRect tiledBackingStoreVisibleRect() = 0;
 };
 
 #else
diff --git a/src/3rdparty/webkit/WebCore/platform/graphics/qt/FontQt.cpp b/src/3rdparty/webkit/WebCore/platform/graphics/qt/FontQt.cpp
index 1e92dcc..ae1033e 100644
--- a/src/3rdparty/webkit/WebCore/platform/graphics/qt/FontQt.cpp
+++ b/src/3rdparty/webkit/WebCore/platform/graphics/qt/FontQt.cpp
@@ -73,28 +73,31 @@ void Font::drawComplexText(GraphicsContext* ctx, const TextRun& run, const Float
 
     QPainter *p = ctx->platformContext();
 
+    QPen textFillPen;
     if (ctx->textDrawingMode() & cTextFill) {
         if (ctx->fillGradient()) {
             QBrush brush(*ctx->fillGradient()->platformGradient());
             brush.setTransform(ctx->fillGradient()->gradientSpaceTransform());
-            p->setPen(QPen(brush, 0));
+            textFillPen = QPen(brush, 0);
         } else if (ctx->fillPattern()) {
             AffineTransform affine;
-            p->setPen(QPen(QBrush(ctx->fillPattern()->createPlatformPattern(affine)), 0));
+            textFillPen = QPen(QBrush(ctx->fillPattern()->createPlatformPattern(affine)), 0);
         } else
-            p->setPen(QColor(ctx->fillColor()));
+            textFillPen = QPen(QColor(ctx->fillColor()));
     }
 
+    QPen textStrokePen;
     if (ctx->textDrawingMode() & cTextStroke) {
         if (ctx->strokeGradient()) {
             QBrush brush(*ctx->strokeGradient()->platformGradient());
             brush.setTransform(ctx->strokeGradient()->gradientSpaceTransform());
-            p->setPen(QPen(brush, ctx->strokeThickness()));
+            textStrokePen = QPen(brush, ctx->strokeThickness());
         } else if (ctx->strokePattern()) {
             AffineTransform affine;
-            p->setPen(QPen(QBrush(ctx->strokePattern()->createPlatformPattern(affine)), ctx->strokeThickness()));
+            QBrush brush(ctx->strokePattern()->createPlatformPattern(affine));
+            textStrokePen = QPen(brush, ctx->strokeThickness());
         } else
-            p->setPen(QPen(QColor(ctx->strokeColor()), ctx->strokeThickness()));
+            textStrokePen = QPen(QColor(ctx->strokeColor()), ctx->strokeThickness());
     }
 
     String sanitized = Font::normalizeSpaces(String(run.characters(), run.length()));
@@ -143,6 +146,7 @@ void Font::drawComplexText(GraphicsContext* ctx, const TextRun& run, const Float
             line.draw(p, pt);
             p->restore();
         }
+        p->setPen(textFillPen);
         line.draw(p, pt);
         p->restore();
         return;
@@ -163,10 +167,13 @@ void Font::drawComplexText(GraphicsContext* ctx, const TextRun& run, const Float
     if (ctx->textDrawingMode() & cTextStroke) {
         QPainterPath path;
         path.addText(pt, font(), string);
+        p->setPen(textStrokePen);
         p->strokePath(path, p->pen());
     }
-    if (ctx->textDrawingMode() & cTextFill)
+    if (ctx->textDrawingMode() & cTextFill) {
+        p->setPen(textFillPen);
         p->drawText(pt, string, flags, run.padding());
+    }
 }
 
 float Font::floatWidthForComplexText(const TextRun& run, HashSet<const SimpleFontData*>*) const
diff --git a/src/3rdparty/webkit/WebCore/platform/graphics/qt/GraphicsContextQt.cpp b/src/3rdparty/webkit/WebCore/platform/graphics/qt/GraphicsContextQt.cpp
index 0100b72..bdb810a 100644
--- a/src/3rdparty/webkit/WebCore/platform/graphics/qt/GraphicsContextQt.cpp
+++ b/src/3rdparty/webkit/WebCore/platform/graphics/qt/GraphicsContextQt.cpp
@@ -167,8 +167,11 @@ static inline Qt::FillRule toQtFillRule(WindRule rule)
 }
 
 struct TransparencyLayer : FastAllocBase {
-    TransparencyLayer(const QPainter* p, const QRect &rect)
+    TransparencyLayer(const QPainter* p, const QRect &rect, qreal opacity, QPixmap& alphaMask)
         : pixmap(rect.width(), rect.height())
+        , opacity(opacity)
+        , alphaMask(alphaMask)
+        , saveCounter(1) // see the comment for saveCounter
     {
         offset = rect.topLeft();
         pixmap.fill(Qt::transparent);
@@ -182,7 +185,9 @@ struct TransparencyLayer : FastAllocBase {
         painter.setFont(p->font());
         if (painter.paintEngine()->hasFeature(QPaintEngine::PorterDuff))
             painter.setCompositionMode(p->compositionMode());
-        painter.setClipPath(p->clipPath());
+        // if the path is an empty region, this assignment disables all painting
+        if (!p->clipPath().isEmpty())
+            painter.setClipPath(p->clipPath());
     }
 
     TransparencyLayer()
@@ -193,6 +198,11 @@ struct TransparencyLayer : FastAllocBase {
     QPoint offset;
     QPainter painter;
     qreal opacity;
+    // for clipToImageBuffer
+    QPixmap alphaMask;
+    // saveCounter is only used in combination with alphaMask
+    // otherwise, its value is unspecified
+    int saveCounter;
 private:
     TransparencyLayer(const TransparencyLayer &) {}
     TransparencyLayer & operator=(const TransparencyLayer &) { return *this; }
@@ -217,6 +227,9 @@ public:
     bool antiAliasingForRectsAndLines;
 
     QStack<TransparencyLayer*> layers;
+    // Counting real layers. Required by inTransparencyLayer() calls
+    // For example, layers with valid alphaMask are not real layers
+    int layerCount;
     QPainter* redirect;
 
     // reuse this brush for solid color (to prevent expensive QBrush construction)
@@ -235,6 +248,7 @@ private:
 GraphicsContextPlatformPrivate::GraphicsContextPlatformPrivate(QPainter* p)
 {
     painter = p;
+    layerCount = 0;
     redirect = 0;
 
     solidColor = QBrush(Qt::black);
@@ -289,11 +303,17 @@ AffineTransform GraphicsContext::getCTM() const
 
 void GraphicsContext::savePlatformState()
 {
+    if (!m_data->layers.isEmpty() && !m_data->layers.top()->alphaMask.isNull())
+        ++m_data->layers.top()->saveCounter;
     m_data->p()->save();
 }
 
 void GraphicsContext::restorePlatformState()
 {
+    if (!m_data->layers.isEmpty() && !m_data->layers.top()->alphaMask.isNull())
+        if (!--m_data->layers.top()->saveCounter)
+            endTransparencyLayer();
+
     m_data->p()->restore();
 
     if (!m_data->currentPath.isEmpty() && m_common->state.pathTransform.isInvertible()) {
@@ -678,7 +698,7 @@ void GraphicsContext::addPath(const Path& path)
 
 bool GraphicsContext::inTransparencyLayer() const
 {
-    return !m_data->layers.isEmpty();
+    return m_data->layerCount;
 }
 
 PlatformPath* GraphicsContext::currentPath()
@@ -837,10 +857,9 @@ void GraphicsContext::beginTransparencyLayer(float opacity)
     w = int(qBound(qreal(0), deviceClip.width(), (qreal)w) + 2);
     h = int(qBound(qreal(0), deviceClip.height(), (qreal)h) + 2);
 
-    TransparencyLayer * layer = new TransparencyLayer(m_data->p(), QRect(x, y, w, h));
-
-    layer->opacity = opacity;
-    m_data->layers.push(layer);
+    QPixmap emptyAlphaMask;
+    m_data->layers.push(new TransparencyLayer(m_data->p(), QRect(x, y, w, h), opacity, emptyAlphaMask));
+    ++m_data->layerCount;
 }
 
 void GraphicsContext::endTransparencyLayer()
@@ -849,6 +868,12 @@ void GraphicsContext::endTransparencyLayer()
         return;
 
     TransparencyLayer* layer = m_data->layers.pop();
+    if (!layer->alphaMask.isNull()) {
+        layer->painter.resetTransform();
+        layer->painter.setCompositionMode(QPainter::CompositionMode_DestinationIn);
+        layer->painter.drawPixmap(QPoint(), layer->alphaMask);
+    } else
+        --m_data->layerCount; // see the comment for layerCount
     layer->painter.end();
 
     QPainter* p = m_data->p();
@@ -1086,9 +1111,21 @@ void GraphicsContext::clipOutEllipseInRect(const IntRect& rect)
     }
 }
 
-void GraphicsContext::clipToImageBuffer(const FloatRect&, const ImageBuffer*)
+void GraphicsContext::clipToImageBuffer(const FloatRect& floatRect, const ImageBuffer* image)
 {
-    notImplemented();
+    if (paintingDisabled())
+        return;
+
+    QPixmap* nativeImage = image->image()->nativeImageForCurrentFrame();
+    if (!nativeImage)
+        return;
+
+    IntRect rect(floatRect);
+    QPixmap alphaMask = *nativeImage;
+    if (alphaMask.width() != rect.width() || alphaMask.height() != rect.height())
+        alphaMask = alphaMask.scaled(rect.width(), rect.height());
+
+    m_data->layers.push(new TransparencyLayer(m_data->p(), m_data->p()->transform().mapRect(rect), 1.0, alphaMask));
 }
 
 void GraphicsContext::addInnerRoundedRectClip(const IntRect& rect,
diff --git a/src/3rdparty/webkit/WebCore/platform/graphics/qt/GraphicsLayerQt.cpp b/src/3rdparty/webkit/WebCore/platform/graphics/qt/GraphicsLayerQt.cpp
index 969e00a..be44fca 100644
--- a/src/3rdparty/webkit/WebCore/platform/graphics/qt/GraphicsLayerQt.cpp
+++ b/src/3rdparty/webkit/WebCore/platform/graphics/qt/GraphicsLayerQt.cpp
@@ -43,6 +43,7 @@
 
 namespace WebCore {
 
+#ifndef QT_NO_GRAPHICSEFFECT
 class MaskEffectQt : public QGraphicsEffect {
 public:
     MaskEffectQt(QObject* parent, QGraphicsItem* maskLayer)
@@ -57,7 +58,12 @@ public:
         // It's more efficient to do it this way because
         // (a) we don't need the QBrush abstraction - we always end up using QGraphicsItem::paint from the mask layer
         // (b) QGraphicsOpacityEffect detaches the pixmap, which is inefficient on OpenGL.
-        QPixmap maskPixmap(sourceBoundingRect().toAlignedRect().size());
+        const QSize maskSize = sourceBoundingRect().toAlignedRect().size();
+        if (!maskSize.isValid() || maskSize.isEmpty()) {
+            drawSource(painter);
+            return;
+        }
+        QPixmap maskPixmap(maskSize);
 
         // we need to do this so the pixmap would have hasAlpha()
         maskPixmap.fill(Qt::transparent);
@@ -91,6 +97,7 @@ public:
 
     QGraphicsItem* m_maskLayer;
 };
+#endif // QT_NO_GRAPHICSEFFECT
 
 class GraphicsLayerQtImpl : public QGraphicsObject {
     Q_OBJECT
@@ -179,7 +186,9 @@ public:
     TransformationMatrix m_transformRelativeToRootLayer;
     bool m_transformAnimationRunning;
     bool m_opacityAnimationRunning;
+#ifndef QT_NO_GRAPHICSEFFECT
     QWeakPointer<MaskEffectQt> m_maskEffect;
+#endif
 
     struct ContentData {
         QPixmap pixmap;
@@ -294,7 +303,7 @@ const GraphicsLayerQtImpl* GraphicsLayerQtImpl::rootLayer() const
 
 QPixmap GraphicsLayerQtImpl::recache(const QRegion& regionToUpdate)
 {
-    if (!m_layer->drawsContent())
+    if (!m_layer->drawsContent() || m_size.isEmpty() ||!m_size.isValid())
         return QPixmap();
 
     QRegion region = regionToUpdate;
@@ -515,6 +524,7 @@ void GraphicsLayerQtImpl::flushChanges(bool recursive, bool forceUpdateTransform
         // we can't paint here, because we don't know if the mask layer
         // itself is ready... we'll have to wait till this layer tries to paint
         setFlag(ItemClipsChildrenToShape, m_layer->maskLayer() || m_layer->masksToBounds());
+#ifndef QT_NO_GRAPHICSEFFECT
         setGraphicsEffect(0);
         if (m_layer->maskLayer()) {
             if (GraphicsLayerQtImpl* mask = qobject_cast<GraphicsLayerQtImpl*>(m_layer->maskLayer()->platformLayer()->toGraphicsObject())) {
@@ -522,6 +532,7 @@ void GraphicsLayerQtImpl::flushChanges(bool recursive, bool forceUpdateTransform
                 setGraphicsEffect(mask->m_maskEffect.data());
             }
         }
+#endif
     }
 
     if (m_changeMask & SizeChange) {
@@ -596,11 +607,15 @@ void GraphicsLayerQtImpl::flushChanges(bool recursive, bool forceUpdateTransform
     if ((m_changeMask & ContentsOpaqueChange) && m_state.contentsOpaque != m_layer->contentsOpaque())
         prepareGeometryChange();
 
+#ifndef QT_NO_GRAPHICSEFFECT
     if (m_maskEffect)
         m_maskEffect.data()->update();
-    else if (m_changeMask & DisplayChange) {        
-        // Recache now: all the content is ready and we don't want to wait until the paint event. We only need to do this for HTML content, 
-        // there's no point in caching directly composited content like images or solid rectangles.
+    else
+#endif
+    if (m_changeMask & DisplayChange) {
+        // Recache now: all the content is ready and we don't want to wait until the paint event.
+        // We only need to do this for HTML content, there's no point in caching directly composited
+        // content like images or solid rectangles.
         if (m_pendingContent.contentType == HTMLContentType)
             recache(m_pendingContent.regionToUpdate);
         update(m_pendingContent.regionToUpdate.boundingRect());
@@ -1191,9 +1206,9 @@ public:
             transformMatrix.blend(m_sourceMatrix, progress);
         }
 
+        m_layer.data()->m_layer->setTransform(transformMatrix);
+        // We force the actual opacity change, otherwise it would be ignored because of the animation.
         m_layer.data()->setBaseTransform(transformMatrix);
-        if (m_fillsForwards)
-            m_layer.data()->m_layer->setTransform(m_layer.data()->m_baseTransform);
     }
 
     virtual void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState)
@@ -1231,18 +1246,19 @@ public:
         if (m_fillsForwards)
             setCurrentTime(1);
     }
+
     virtual void applyFrame(const qreal& fromValue, const qreal& toValue, qreal progress)
     {
         qreal opacity = qBound(qreal(0), fromValue + (toValue-fromValue)*progress, qreal(1));
 
         // FIXME: this is a hack, due to a probable QGraphicsScene bug.
         // Without this the opacity change doesn't always have immediate effect.
-        if (!m_layer.data()->opacity() && opacity)
+        if (m_layer.data()->scene() && !m_layer.data()->opacity() && opacity)
             m_layer.data()->scene()->update();
 
+        m_layer.data()->m_layer->setOpacity(opacity);
+        // We force the actual opacity change, otherwise it would be ignored because of the animation.
         m_layer.data()->setOpacity(opacity);
-        if (m_fillsForwards)
-            m_layer.data()->m_layer->setOpacity(opacity);
     }
 
     virtual void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState)
diff --git a/src/3rdparty/webkit/WebCore/platform/graphics/qt/ImageBufferQt.cpp b/src/3rdparty/webkit/WebCore/platform/graphics/qt/ImageBufferQt.cpp
index d831566..eafdcf0 100644
--- a/src/3rdparty/webkit/WebCore/platform/graphics/qt/ImageBufferQt.cpp
+++ b/src/3rdparty/webkit/WebCore/platform/graphics/qt/ImageBufferQt.cpp
@@ -46,12 +46,19 @@ namespace WebCore {
 
 ImageBufferData::ImageBufferData(const IntSize& size)
     : m_pixmap(size)
+    , m_painter(0)
 {
+    if (m_pixmap.isNull())
+        return;
+
     m_pixmap.fill(QColor(Qt::transparent));
 
-    QPainter* painter = new QPainter(&m_pixmap);
+    QPainter* painter = new QPainter;
     m_painter.set(painter);
 
+    if (!painter->begin(&m_pixmap))
+        return;
+
     // Since ImageBuffer is used mainly for Canvas, explicitly initialize
     // its painter's pen and brush with the corresponding canvas defaults
     // NOTE: keep in sync with CanvasRenderingContext2D::State
@@ -72,8 +79,11 @@ ImageBuffer::ImageBuffer(const IntSize& size, ImageColorSpace, bool& success)
     : m_data(size)
     , m_size(size)
 {
+    success = m_data.m_painter && m_data.m_painter->isActive();
+    if (!success)
+        return;
+
     m_context.set(new GraphicsContext(m_data.m_painter.get()));
-    success = true;
 }
 
 ImageBuffer::~ImageBuffer()
diff --git a/src/3rdparty/webkit/WebCore/platform/graphics/qt/PathQt.cpp b/src/3rdparty/webkit/WebCore/platform/graphics/qt/PathQt.cpp
index 4b0c21f..a7351a0 100644
--- a/src/3rdparty/webkit/WebCore/platform/graphics/qt/PathQt.cpp
+++ b/src/3rdparty/webkit/WebCore/platform/graphics/qt/PathQt.cpp
@@ -298,9 +298,10 @@ void Path::addArc(const FloatPoint& p, float r, float sar, float ear, bool antic
         span += ea - sa;
     }
 
-    // connect to the previous point by a straight line
-    m_path.lineTo(QPointF(xc + radius  * cos(sar),
-                          yc - radius  * sin(sar)));
+    // If the path is empty, move to where the arc will start to avoid painting a line from (0,0)
+    // NOTE: QPainterPath::isEmpty() won't work here since it ignores a lone MoveToElement
+    if (!m_path.elementCount())
+        m_path.arcMoveTo(xs, ys, width, height, sa);
 
     m_path.arcTo(xs, ys, width, height, sa, span);
 
diff --git a/src/3rdparty/webkit/WebCore/platform/network/NetworkStateNotifier.h b/src/3rdparty/webkit/WebCore/platform/network/NetworkStateNotifier.h
index 781259c..d1f2db4 100644
--- a/src/3rdparty/webkit/WebCore/platform/network/NetworkStateNotifier.h
+++ b/src/3rdparty/webkit/WebCore/platform/network/NetworkStateNotifier.h
@@ -44,6 +44,15 @@ typedef const struct __SCDynamicStore * SCDynamicStoreRef;
 
 #include <windows.h>
 
+#elif PLATFORM(QT)
+
+#include <QtCore/qglobal.h>
+
+#ifdef QT_NO_BEARERMANAGEMENT
+#undef ENABLE_QT_BEARER
+#define ENABLE_QT_BEARER 0
+#endif
+
 #endif
 
 namespace WebCore {
diff --git a/src/3rdparty/webkit/WebCore/platform/network/qt/NetworkStateNotifierQt.cpp b/src/3rdparty/webkit/WebCore/platform/network/qt/NetworkStateNotifierQt.cpp
index 52512aa..3aae92a 100644
--- a/src/3rdparty/webkit/WebCore/platform/network/qt/NetworkStateNotifierQt.cpp
+++ b/src/3rdparty/webkit/WebCore/platform/network/qt/NetworkStateNotifierQt.cpp
@@ -20,6 +20,8 @@
 #include "config.h"
 #include "NetworkStateNotifier.h"
 
+#if PLATFORM(QT) && ENABLE(QT_BEARER)
+
 #include "NetworkStateNotifierPrivate.h"
 #include "qnetworkconfigmanager.h"
 
@@ -89,4 +91,6 @@ void NetworkStateNotifier::setNetworkAccessAllowed(bool isAllowed)
 
 } // namespace WebCore
 
+#endif
+
 #include "moc_NetworkStateNotifierPrivate.cpp"
diff --git a/src/3rdparty/webkit/WebCore/platform/qt/FileSystemQt.cpp b/src/3rdparty/webkit/WebCore/platform/qt/FileSystemQt.cpp
index f9ced98..54ecbf1 100644
--- a/src/3rdparty/webkit/WebCore/platform/qt/FileSystemQt.cpp
+++ b/src/3rdparty/webkit/WebCore/platform/qt/FileSystemQt.cpp
@@ -117,6 +117,7 @@ Vector<String> listDirectory(const String& path, const String& filter)
 
 CString openTemporaryFile(const char* prefix, PlatformFileHandle& handle)
 {
+#ifndef QT_NO_TEMPORARYFILE
     QTemporaryFile* tempFile = new QTemporaryFile(QLatin1String(prefix));
     tempFile->setAutoRemove(false);
     QFile* temp = tempFile;
@@ -124,6 +125,7 @@ CString openTemporaryFile(const char* prefix, PlatformFileHandle& handle)
         handle = temp;
         return String(temp->fileName()).utf8();
     }
+#endif
     handle = invalidPlatformFileHandle;
     return CString();
 }
diff --git a/src/3rdparty/webkit/WebCore/platform/qt/QWebPageClient.h b/src/3rdparty/webkit/WebCore/platform/qt/QWebPageClient.h
index 467941f..8e48d1f 100644
--- a/src/3rdparty/webkit/WebCore/platform/qt/QWebPageClient.h
+++ b/src/3rdparty/webkit/WebCore/platform/qt/QWebPageClient.h
@@ -89,6 +89,8 @@ public:
 
     virtual QStyle* style() const = 0;
 
+    virtual QRectF graphicsItemVisibleRect() const { return QRectF(); }
+
 protected:
 #ifndef QT_NO_CURSOR
     virtual QCursor cursor() const = 0;
diff --git a/src/3rdparty/webkit/WebCore/platform/qt/RenderThemeQt.cpp b/src/3rdparty/webkit/WebCore/platform/qt/RenderThemeQt.cpp
index 577903b..08b7aca 100644
--- a/src/3rdparty/webkit/WebCore/platform/qt/RenderThemeQt.cpp
+++ b/src/3rdparty/webkit/WebCore/platform/qt/RenderThemeQt.cpp
@@ -163,7 +163,9 @@ RenderThemeQt::RenderThemeQt(Page* page)
 RenderThemeQt::~RenderThemeQt()
 {
     delete m_fallbackStyle;
+#ifndef QT_NO_LINEEDIT
     delete m_lineEdit;
+#endif
 }
 
 #if USE(QT_MOBILE_THEME)
@@ -264,11 +266,17 @@ bool RenderThemeQt::supportsControlTints() const
 
 int RenderThemeQt::findFrameLineWidth(QStyle* style) const
 {
+#ifndef QT_NO_LINEEDIT
     if (!m_lineEdit)
         m_lineEdit = new QLineEdit();
+#endif
 
     QStyleOptionFrameV2 opt;
-    return style->pixelMetric(QStyle::PM_DefaultFrameWidth, &opt, m_lineEdit);
+    QWidget* widget = 0;
+#ifndef QT_NO_LINEEDIT
+    widget = m_lineEdit;
+#endif
+    return style->pixelMetric(QStyle::PM_DefaultFrameWidth, &opt, widget);
 }
 
 static QRect inflateButtonRect(const QRect& originalRect, QStyle* style)
diff --git a/src/3rdparty/webkit/WebCore/plugins/mac/PluginViewMac.cpp b/src/3rdparty/webkit/WebCore/plugins/mac/PluginViewMac.mm
index 1fd4676..57d74ab 100644
--- a/src/3rdparty/webkit/WebCore/plugins/mac/PluginViewMac.cpp
+++ b/src/3rdparty/webkit/WebCore/plugins/mac/PluginViewMac.mm
@@ -103,9 +103,12 @@ static inline WindowRef nativeWindowFor(PlatformWidget widget)
 {
 #if PLATFORM(QT)
     if (widget)
+#if QT_MAC_USE_COCOA
+        return static_cast<WindowRef>([qt_mac_window_for(widget) windowRef]);
+#else
         return static_cast<WindowRef>(qt_mac_window_for(widget));
 #endif
-#if PLATFORM(WX)
+#elif PLATFORM(WX)
     if (widget)
         return (WindowRef)widget->MacGetTopLevelWindowRef();
 #endif
diff --git a/src/3rdparty/webkit/WebKit.pri b/src/3rdparty/webkit/WebKit.pri
index a3ccd9d..921a6e0 100644
--- a/src/3rdparty/webkit/WebKit.pri
+++ b/src/3rdparty/webkit/WebKit.pri
@@ -48,7 +48,12 @@ CONFIG(release, debug|release) {
 }
 
 BASE_DIR = $$PWD
-INCLUDEPATH += $$OUTPUT_DIR/include/QtWebKit
+
+symbian {
+    INCLUDEPATH += $$PWD/include/QtWebKit
+} else {
+    INCLUDEPATH += $$OUTPUT_DIR/include/QtWebKit
+}
 
 CONFIG -= warn_on
 *-g++*:QMAKE_CXXFLAGS += -Wall -Wreturn-type -fno-strict-aliasing -Wcast-align -Wchar-subscripts -Wformat-security -Wreturn-type -Wno-unused-parameter -Wno-sign-compare -Wno-switch -Wno-switch-enum -Wundef -Wmissing-noreturn -Winit-self
diff --git a/src/3rdparty/webkit/WebKit/qt/Api/qgraphicswebview.cpp b/src/3rdparty/webkit/WebKit/qt/Api/qgraphicswebview.cpp
index 75a23d9..7a25646 100644
--- a/src/3rdparty/webkit/WebKit/qt/Api/qgraphicswebview.cpp
+++ b/src/3rdparty/webkit/WebKit/qt/Api/qgraphicswebview.cpp
@@ -127,7 +127,7 @@ public:
 #endif
 
     void updateResizesToContentsForPage();
-    QRectF graphicsItemVisibleRect() const;
+    virtual QRectF graphicsItemVisibleRect() const;
 #if ENABLE(TILED_BACKING_STORE)
     void updateTiledBackingStoreScale();
 #endif
@@ -597,12 +597,7 @@ void QGraphicsWebView::paint(QPainter* painter, const QStyleOptionGraphicsItem*
 #if ENABLE(TILED_BACKING_STORE)
     if (WebCore::TiledBackingStore* backingStore = QWebFramePrivate::core(page()->mainFrame())->tiledBackingStore()) {
         // FIXME: We should set the backing store viewport earlier than in paint
-        if (d->resizesToContents)
-            backingStore->viewportChanged(WebCore::IntRect(d->graphicsItemVisibleRect()));
-        else {
-            QRectF visibleRect(d->page->mainFrame()->scrollPosition(), d->page->mainFrame()->geometry().size());
-            backingStore->viewportChanged(WebCore::IntRect(visibleRect));
-        }
+        backingStore->adjustVisibleRect();
         // QWebFrame::render is a public API, bypass it for tiled rendering so behavior does not need to change.
         WebCore::GraphicsContext context(painter); 
         page()->mainFrame()->d->renderFromTiledBackingStore(&context, option->exposedRect.toAlignedRect());
diff --git a/src/3rdparty/webkit/WebKit/qt/Api/qwebframe.cpp b/src/3rdparty/webkit/WebKit/qt/Api/qwebframe.cpp
index 44cc3b5..721aaa6 100644
--- a/src/3rdparty/webkit/WebKit/qt/Api/qwebframe.cpp
+++ b/src/3rdparty/webkit/WebKit/qt/Api/qwebframe.cpp
@@ -275,8 +275,9 @@ void QWEBKIT_EXPORT qt_drt_evaluateScriptInIsolatedWorld(QWebFrame* qFrame, int
         JSC::JSValue result = frame->script()->executeScriptInWorld(mainThreadNormalWorld(), script, true).jsValue();
 }
 
-static bool webframe_scrollOverflow(WebCore::Frame* frame, int dx, int dy, const QPoint& pos)
+bool QWEBKIT_EXPORT qtwebkit_webframe_scrollOverflow(QWebFrame* qFrame, int dx, int dy, const QPoint& pos)
 {
+    WebCore::Frame* frame = QWebFramePrivate::core(qFrame);
     if (!frame || !frame->document() || !frame->view() || !frame->eventHandler())
         return false;
 
@@ -299,17 +300,24 @@ static bool webframe_scrollOverflow(WebCore::Frame* frame, int dx, int dy, const
     bool scrolledHorizontal = false;
     bool scrolledVertical = false;
 
-    if (dx > 0)
-        scrolledHorizontal = renderLayer->scroll(ScrollRight, ScrollByPixel, dx);
-    else if (dx < 0)
-        scrolledHorizontal = renderLayer->scroll(ScrollLeft, ScrollByPixel, qAbs(dx));
+    do {
+        if (dx > 0)
+            scrolledHorizontal = renderLayer->scroll(ScrollRight, ScrollByPixel, dx);
+        else if (dx < 0)
+            scrolledHorizontal = renderLayer->scroll(ScrollLeft, ScrollByPixel, qAbs(dx));
+
+        if (dy > 0)
+            scrolledVertical = renderLayer->scroll(ScrollDown, ScrollByPixel, dy);
+        else if (dy < 0)
+            scrolledVertical = renderLayer->scroll(ScrollUp, ScrollByPixel, qAbs(dy));
 
-    if (dy > 0)
-        scrolledVertical = renderLayer->scroll(ScrollDown, ScrollByPixel, dy);
-    else if (dy < 0)
-        scrolledVertical = renderLayer->scroll(ScrollUp, ScrollByPixel, qAbs(dy));
+        if (scrolledHorizontal || scrolledVertical)
+            return true;
 
-    return (scrolledHorizontal || scrolledVertical);
+        renderLayer = renderLayer->parent();
+    } while (renderLayer);
+
+    return false;
 }
 
 
@@ -325,7 +333,7 @@ void QWEBKIT_EXPORT qtwebkit_webframe_scrollRecursively(QWebFrame* qFrame, int d
     if (!qFrame)
         return;
 
-    if (webframe_scrollOverflow(QWebFramePrivate::core(qFrame), dx, dy, pos))
+    if (qtwebkit_webframe_scrollOverflow(qFrame, dx, dy, pos))
         return;
 
     bool scrollHorizontal = false;
@@ -339,7 +347,7 @@ void QWEBKIT_EXPORT qtwebkit_webframe_scrollRecursively(QWebFrame* qFrame, int d
 
         if (dy > 0)  // scroll down
             scrollVertical = qFrame->scrollBarValue(Qt::Vertical) < qFrame->scrollBarMaximum(Qt::Vertical);
-            else if (dy < 0) //scroll up
+        else if (dy < 0) //scroll up
             scrollVertical = qFrame->scrollBarValue(Qt::Vertical) > qFrame->scrollBarMinimum(Qt::Vertical);
 
         if (scrollHorizontal || scrollVertical) {
diff --git a/src/3rdparty/webkit/WebKit/qt/Api/qwebhistory.cpp b/src/3rdparty/webkit/WebKit/qt/Api/qwebhistory.cpp
index d852012..06e6cfa 100644
--- a/src/3rdparty/webkit/WebKit/qt/Api/qwebhistory.cpp
+++ b/src/3rdparty/webkit/WebKit/qt/Api/qwebhistory.cpp
@@ -540,6 +540,8 @@ QDataStream& operator>>(QDataStream& source, QWebHistory& history)
                 d->lst->addItem(item);
             }
             d->lst->removeItem(nullItem);
+            // Update the HistoryController.
+            history.d->lst->page()->mainFrame()->loader()->history()->setCurrentItem(history.d->lst->entries()[currentIndex].get());
             history.goToItem(history.itemAt(currentIndex));
         }
     }
diff --git a/src/3rdparty/webkit/WebKit/qt/Api/qwebpage.cpp b/src/3rdparty/webkit/WebKit/qt/Api/qwebpage.cpp
index c5f508f..2788085 100644
--- a/src/3rdparty/webkit/WebKit/qt/Api/qwebpage.cpp
+++ b/src/3rdparty/webkit/WebKit/qt/Api/qwebpage.cpp
@@ -51,6 +51,7 @@
 #include "EditorClientQt.h"
 #include "SecurityOrigin.h"
 #include "Settings.h"
+#include "TiledBackingStore.h"
 #include "Page.h"
 #include "Pasteboard.h"
 #include "FrameLoader.h"
@@ -1294,6 +1295,9 @@ void QWebPagePrivate::inputMethodEvent(QInputMethodEvent *ev)
 {
     WebCore::Frame *frame = page->focusController()->focusedOrMainFrame();
     WebCore::Editor *editor = frame->editor();
+#if QT_VERSION >= 0x040600
+    QInputMethodEvent::Attribute selection(QInputMethodEvent::Selection, 0, 0, QVariant());
+#endif
 
     if (!editor->canEdit()) {
         ev->ignore();
@@ -1310,6 +1314,7 @@ void QWebPagePrivate::inputMethodEvent(QInputMethodEvent *ev)
         renderTextControl = toRenderTextControl(renderer);
 
     Vector<CompositionUnderline> underlines;
+    bool hasSelection = false;
 
     for (int i = 0; i < ev->attributes().size(); ++i) {
         const QInputMethodEvent::Attribute& a = ev->attributes().at(i);
@@ -1333,10 +1338,8 @@ void QWebPagePrivate::inputMethodEvent(QInputMethodEvent *ev)
         }
 #if QT_VERSION >= 0x040600
         case QInputMethodEvent::Selection: {
-            if (renderTextControl) {
-                renderTextControl->setSelectionStart(qMin(a.start, (a.start + a.length)));
-                renderTextControl->setSelectionEnd(qMax(a.start, (a.start + a.length)));
-            }
+            selection = a;
+            hasSelection = true;
             break;
         }
 #endif
@@ -1345,13 +1348,29 @@ void QWebPagePrivate::inputMethodEvent(QInputMethodEvent *ev)
 
     if (!ev->commitString().isEmpty())
         editor->confirmComposition(ev->commitString());
-    else if (!ev->preeditString().isEmpty()) {
+    else {
+        // 1. empty preedit with a selection attribute, and start/end of 0 cancels composition
+        // 2. empty preedit with a selection attribute, and start/end of non-0 updates selection of current preedit text
+        // 3. populated preedit with a selection attribute, and start/end of 0 or non-0 updates selection of supplied preedit text
+        // 4. otherwise event is updating supplied pre-edit text
         QString preedit = ev->preeditString();
-        editor->setComposition(preedit, underlines, preedit.length(), 0);
+#if QT_VERSION >= 0x040600
+        if (hasSelection) {
+            QString text = (renderTextControl) ? QString(renderTextControl->text()) : QString();
+            if (preedit.isEmpty() && selection.start + selection.length > 0)
+                preedit = text;
+            editor->setComposition(preedit, underlines,
+                                   (selection.length < 0) ? selection.start + selection.length : selection.start,
+                                   (selection.length < 0) ? selection.start : selection.start + selection.length);
+        } else
+#endif
+            editor->setComposition(preedit, underlines, preedit.length(), 0);
     }
+
     ev->accept();
 }
 
+#ifndef QT_NO_PROPERTIES
 void QWebPagePrivate::dynamicPropertyChangeEvent(QDynamicPropertyChangeEvent* event)
 {
     if (event->propertyName() == "_q_viewMode") {
@@ -1369,8 +1388,44 @@ void QWebPagePrivate::dynamicPropertyChangeEvent(QDynamicPropertyChangeEvent* ev
     } else if (event->propertyName() == "_q_HTMLTokenizerTimeDelay") {
         double timeDelay = q->property("_q_HTMLTokenizerTimeDelay").toDouble();
         q->handle()->page->setCustomHTMLTokenizerTimeDelay(timeDelay);
+    } 
+#if ENABLE(TILED_BACKING_STORE)
+    else if (event->propertyName() == "_q_TiledBackingStoreTileSize") {
+        WebCore::Frame* frame = QWebFramePrivate::core(q->mainFrame());
+        if (!frame->tiledBackingStore())
+            return;
+        QSize tileSize = q->property("_q_TiledBackingStoreTileSize").toSize();
+        frame->tiledBackingStore()->setTileSize(tileSize);
+    } else if (event->propertyName() == "_q_TiledBackingStoreTileCreationDelay") {
+        WebCore::Frame* frame = QWebFramePrivate::core(q->mainFrame());
+        if (!frame->tiledBackingStore())
+            return;
+        int tileCreationDelay = q->property("_q_TiledBackingStoreTileCreationDelay").toInt();
+        frame->tiledBackingStore()->setTileCreationDelay(static_cast<double>(tileCreationDelay) / 1000.);
+    } else if (event->propertyName() == "_q_TiledBackingStoreKeepAreaMultiplier") {
+        WebCore::Frame* frame = QWebFramePrivate::core(q->mainFrame());
+        if (!frame->tiledBackingStore())
+            return;
+        FloatSize keepMultiplier;
+        FloatSize coverMultiplier;
+        frame->tiledBackingStore()->getKeepAndCoverAreaMultipliers(keepMultiplier, coverMultiplier);
+        QSizeF qSize = q->property("_q_TiledBackingStoreKeepAreaMultiplier").toSizeF();
+        keepMultiplier = FloatSize(qSize.width(), qSize.height());
+        frame->tiledBackingStore()->setKeepAndCoverAreaMultipliers(keepMultiplier, coverMultiplier);
+    } else if (event->propertyName() == "_q_TiledBackingStoreCoverAreaMultiplier") {
+        WebCore::Frame* frame = QWebFramePrivate::core(q->mainFrame());
+        if (!frame->tiledBackingStore())
+            return;
+        FloatSize keepMultiplier;
+        FloatSize coverMultiplier;
+        frame->tiledBackingStore()->getKeepAndCoverAreaMultipliers(keepMultiplier, coverMultiplier);
+        QSizeF qSize = q->property("_q_TiledBackingStoreCoverAreaMultiplier").toSizeF();
+        coverMultiplier = FloatSize(qSize.width(), qSize.height());
+        frame->tiledBackingStore()->setKeepAndCoverAreaMultipliers(keepMultiplier, coverMultiplier);
     }
+#endif
 }
+#endif
 
 void QWebPagePrivate::shortcutOverrideEvent(QKeyEvent* event)
 {
@@ -1518,7 +1573,7 @@ QVariant QWebPage::inputMethodQuery(Qt::InputMethodQuery property) const
                     RefPtr<Range> range = editor->compositionRange();
                     return QVariant(renderTextControl->selectionEnd() - TextIterator::rangeLength(range.get()));
                 }
-                return QVariant(renderTextControl->selectionEnd());
+                return QVariant(frame->selection()->extent().offsetInContainerNode());
             }
             return QVariant();
         }
@@ -1550,7 +1605,7 @@ QVariant QWebPage::inputMethodQuery(Qt::InputMethodQuery property) const
                     RefPtr<Range> range = editor->compositionRange();
                     return QVariant(renderTextControl->selectionStart() - TextIterator::rangeLength(range.get()));
                 }
-                return QVariant(renderTextControl->selectionStart());
+                return QVariant(frame->selection()->base().offsetInContainerNode());
             }
             return QVariant();
         }
@@ -1692,6 +1747,7 @@ InspectorController* QWebPagePrivate::inspectorController()
     \value Back Navigate back in the history of navigated links.
     \value Forward Navigate forward in the history of navigated links.
     \value Stop Stop loading the current page.
+    \value StopScheduledPageRefresh Stop all pending page refresh/redirect requests.
     \value Reload Reload the current page.
     \value ReloadAndBypassCache Reload the current page, but do not use any local cache. (Added in Qt 4.6)
     \value Cut Cut the content currently selected into the clipboard.
@@ -2097,6 +2153,15 @@ static void openNewWindow(const QUrl& url, WebCore::Frame* frame)
     }
 }
 
+static void collectChildFrames(QWebFrame* frame, QList<QWebFrame*>& list)
+{
+    list << frame->childFrames();
+    QListIterator<QWebFrame*> it(frame->childFrames());
+    while (it.hasNext()) {
+        collectChildFrames(it.next(), list);
+    }
+}
+
 /*!
     This function can be called to trigger the specified \a action.
     It is also called by QtWebKit if the user triggers the action, for example
@@ -2193,6 +2258,16 @@ void QWebPage::triggerAction(WebAction action, bool)
 #endif
             break;
         }
+        case StopScheduledPageRefresh: {
+            QWebFrame* topFrame = mainFrame();
+            topFrame->d->frame->redirectScheduler()->cancel();
+            QList<QWebFrame*> childFrames;
+            collectChildFrames(topFrame, childFrames);
+            QListIterator<QWebFrame*> it(childFrames);
+            while (it.hasNext())
+                it.next()->d->frame->redirectScheduler()->cancel();
+            break;
+        }
         default:
             command = QWebPagePrivate::editorCommandForWebActions(action);
             break;
@@ -2735,9 +2810,11 @@ bool QWebPage::event(QEvent *ev)
         d->touchEvent(static_cast<QTouchEvent*>(ev));
         break;
 #endif
+#ifndef QT_NO_PROPERTIES
     case QEvent::DynamicPropertyChange:
         d->dynamicPropertyChangeEvent(static_cast<QDynamicPropertyChangeEvent*>(ev));
         break;
+#endif
     default:
         return QObject::event(ev);
     }
@@ -3329,12 +3406,37 @@ QString QWebPage::userAgentForUrl(const QUrl&) const
 #elif defined Q_WS_X11
         "X11"
 #elif defined Q_OS_SYMBIAN
-        "SymbianOS"
+        "Symbian"
 #else
         "Unknown"
 #endif
     );
 
+#if defined Q_OS_SYMBIAN
+        QSysInfo::SymbianVersion symbianVersion = QSysInfo::symbianVersion();
+        switch (symbianVersion) {
+        case QSysInfo::SV_9_2:
+            firstPartTemp += QString::fromLatin1("OS/9.2");
+            break;
+        case QSysInfo::SV_9_3:
+            firstPartTemp += QString::fromLatin1("OS/9.3");
+            break;                
+        case QSysInfo::SV_9_4:
+            firstPartTemp += QString::fromLatin1("OS/9.4");
+            break;
+        case QSysInfo::SV_SF_2:
+            firstPartTemp += QString::fromLatin1("/2");
+            break;
+        case QSysInfo::SV_SF_3:
+            firstPartTemp += QString::fromLatin1("/3");
+            break;
+        case QSysInfo::SV_SF_4:
+            firstPartTemp += QString::fromLatin1("/4");
+        default:
+            break;
+        }
+#endif
+
         firstPartTemp += QString::fromLatin1("; ");
 
         // SSL support
@@ -3458,51 +3560,22 @@ QString QWebPage::userAgentForUrl(const QUrl&) const
         firstPartTemp += QString::fromLatin1("Sun Solaris");
 #elif defined Q_OS_ULTRIX
         firstPartTemp += QString::fromLatin1("DEC Ultrix");
-#elif defined Q_OS_SYMBIAN
-        firstPartTemp += QString::fromLatin1("SymbianOS");
-        QSysInfo::SymbianVersion symbianVersion = QSysInfo::symbianVersion();
-        switch (symbianVersion) {
-        case QSysInfo::SV_9_2:
-            firstPartTemp += QString::fromLatin1("/9.2");
-            break;
-        case QSysInfo::SV_9_3:
-            firstPartTemp += QString::fromLatin1("/9.3");
-            break;
-        case QSysInfo::SV_9_4:
-            firstPartTemp += QString::fromLatin1("/9.4");
-            break;
-        case QSysInfo::SV_SF_2:
-            firstPartTemp += QString::fromLatin1("^2");
-            break;
-        case QSysInfo::SV_SF_3:
-            firstPartTemp += QString::fromLatin1("^3");
-            break;
-        case QSysInfo::SV_SF_4:
-            firstPartTemp += QString::fromLatin1("^4");
-            break;
-        default:
-            firstPartTemp += QString::fromLatin1("/Unknown");
-        }
-
-#if defined Q_WS_S60
+#elif defined Q_WS_S60
         firstPartTemp += QLatin1Char(' ');
-        firstPartTemp += QString::fromLatin1("Series60");
         QSysInfo::S60Version s60Version = QSysInfo::s60Version();
         switch (s60Version) {
         case QSysInfo::SV_S60_3_1:
-            firstPartTemp += QString::fromLatin1("/3.1");
+            firstPartTemp += QString::fromLatin1("Series60/3.1");
             break;
         case QSysInfo::SV_S60_3_2:
-            firstPartTemp += QString::fromLatin1("/3.2");
+            firstPartTemp += QString::fromLatin1("Series60/3.2");
             break;
         case QSysInfo::SV_S60_5_0:
-            firstPartTemp += QString::fromLatin1("/5.0");
+            firstPartTemp += QString::fromLatin1("Series60/5.0");
             break;
         default:
-            firstPartTemp += QString::fromLatin1("/Unknown");
+            break;
         }
-#endif
-
 #elif defined Q_OS_UNIX
         firstPartTemp += QString::fromLatin1("UNIX BSD/SYSV system");
 #elif defined Q_OS_UNIXWARE
@@ -3532,8 +3605,8 @@ QString QWebPage::userAgentForUrl(const QUrl&) const
 
         QString thirdPartTemp;
         thirdPartTemp.reserve(150);
-#if defined(Q_WS_S60) || defined(Q_WS_MAEMO_5)
-        thirdPartTemp + QLatin1String(" Mobile Safari/");
+#if defined(Q_OS_SYMBIAN) || defined(Q_WS_MAEMO_5)
+        thirdPartTemp += QLatin1String(" Mobile Safari/");
 #else
         thirdPartTemp += QLatin1String(" Safari/");
 #endif
@@ -3551,7 +3624,7 @@ QString QWebPage::userAgentForUrl(const QUrl&) const
         languageName = d->client->ownerWidget()->locale().name();
     else
         languageName = QLocale().name();
-    languageName[2] = QLatin1Char('-');
+    languageName.replace(QLatin1Char('_'), QLatin1Char('-'));
 
     // Application name/version
     QString appName = QCoreApplication::applicationName();
diff --git a/src/3rdparty/webkit/WebKit/qt/Api/qwebpage.h b/src/3rdparty/webkit/WebKit/qt/Api/qwebpage.h
index 1adde06..34f675b 100644
--- a/src/3rdparty/webkit/WebKit/qt/Api/qwebpage.h
+++ b/src/3rdparty/webkit/WebKit/qt/Api/qwebpage.h
@@ -169,6 +169,8 @@ public:
         AlignLeft,
         AlignRight,
 
+        StopScheduledPageRefresh,
+
         WebActionCount
     };
 
diff --git a/src/3rdparty/webkit/WebKit/qt/Api/qwebpage_p.h b/src/3rdparty/webkit/WebKit/qt/Api/qwebpage_p.h
index 5350cd9..1b90a66 100644
--- a/src/3rdparty/webkit/WebKit/qt/Api/qwebpage_p.h
+++ b/src/3rdparty/webkit/WebKit/qt/Api/qwebpage_p.h
@@ -112,7 +112,9 @@ public:
 
     void inputMethodEvent(QInputMethodEvent*);
 
+#ifndef QT_NO_PROPERTIES
     void dynamicPropertyChangeEvent(QDynamicPropertyChangeEvent*);
+#endif
 
     void shortcutOverrideEvent(QKeyEvent*);
     void leaveEvent(QEvent*);
diff --git a/src/3rdparty/webkit/WebKit/qt/Api/qwebsettings.cpp b/src/3rdparty/webkit/WebKit/qt/Api/qwebsettings.cpp
index 115f9fc..a5fc794 100644
--- a/src/3rdparty/webkit/WebKit/qt/Api/qwebsettings.cpp
+++ b/src/3rdparty/webkit/WebKit/qt/Api/qwebsettings.cpp
@@ -48,9 +48,7 @@
 #include <QUrl>
 #include <QFileInfo>
 
-#if ENABLE(QT_BEARER)
 #include "NetworkStateNotifier.h"
-#endif
 
 void QWEBKIT_EXPORT qt_networkAccessAllowed(bool isAllowed)
 {
@@ -74,7 +72,6 @@ public:
     QString localStoragePath;
     QString offlineWebApplicationCachePath;
     qint64 offlineStorageDefaultQuota;
-    QUrl inspectorLocation;
 
     void apply();
     WebCore::Settings* settings;
@@ -1011,31 +1008,6 @@ void QWebSettings::setLocalStoragePath(const QString& path)
 }
 
 /*!
-    \since 4.7
-
-    Specifies the \a location of a frontend to load with each web page when using Web Inspector.
-
-    \sa inspectorUrl()
-*/
-void QWebSettings::setInspectorUrl(const QUrl& location)
-{
-    d->inspectorLocation = location;
-    d->apply();
-}
-
-/*!
-    \since 4.7
-
-    Returns the location of the Web Inspector frontend.
-
-    \sa setInspectorUrl()
-*/
-QUrl QWebSettings::inspectorUrl() const
-{
-    return d->inspectorLocation;
-}
-
-/*!
     \since 4.6
 
     Returns the path for HTML5 local storage.
diff --git a/src/3rdparty/webkit/WebKit/qt/Api/qwebsettings.h b/src/3rdparty/webkit/WebKit/qt/Api/qwebsettings.h
index 3592e2c..b978f5e 100644
--- a/src/3rdparty/webkit/WebKit/qt/Api/qwebsettings.h
+++ b/src/3rdparty/webkit/WebKit/qt/Api/qwebsettings.h
@@ -136,9 +136,6 @@ public:
     void setLocalStoragePath(const QString& path);
     QString localStoragePath() const; 
 
-    void setInspectorUrl(const QUrl &location);
-    QUrl inspectorUrl() const;
-
     static void clearMemoryCaches();
 
     static void enablePersistentStorage(const QString& path = QString());
diff --git a/src/3rdparty/webkit/WebKit/qt/ChangeLog b/src/3rdparty/webkit/WebKit/qt/ChangeLog
index efc8f27..3deb9ac 100644
--- a/src/3rdparty/webkit/WebKit/qt/ChangeLog
+++ b/src/3rdparty/webkit/WebKit/qt/ChangeLog
@@ -1,3 +1,299 @@
+2010-06-02  Tasuku Suzuki  <tasuku.suzuki@nokia.com>
+
+        Reviewed by Shinichiro Hamaji.
+
+        [Qt] Fix compilation with QT_NO_PROPERTIES
+        https://bugs.webkit.org/show_bug.cgi?id=38324
+
+        * Api/qwebpage.cpp:
+        (QWebPage::event):
+        * Api/qwebpage_p.h:
+        * WebCoreSupport/InspectorClientQt.cpp:
+        (WebCore::InspectorClientQt::openInspectorFrontend):
+
+2010-05-17  Tasuku Suzuki  <tasuku.suzuki@nokia.com>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        [Qt] Fix compilation with QT_NO_COMBOBOX
+        https://bugs.webkit.org/show_bug.cgi?id=38324
+
+        * WebCoreSupport/ChromeClientQt.cpp:
+        (WebCore::ChromeClientQt::createSelectPopup):
+        * WebCoreSupport/QtFallbackWebPopup.cpp:
+        * WebCoreSupport/QtFallbackWebPopup.h:
+
+2010-05-02  Tasuku Suzuki  <tasuku.suzuki@nokia.com>
+
+        Reviewed by Simon Hausmann.
+
+        [Qt] Fix compilation with QT_NO_BEARERMANAGEMENT
+        https://bugs.webkit.org/show_bug.cgi?id=38324
+
+        * Api/qwebsettings.cpp:
+
+2010-03-24  Viatcheslav Ostapenko  <ostapenko.viatcheslav@nokia.com>
+
+        Reviewed by Laszlo Gombos.
+
+        Auto-uppercase and predictive text need to be disabled for S60 (as for maemo)
+        https://bugs.webkit.org/show_bug.cgi?id=33176
+
+        * WebCoreSupport/EditorClientQt.cpp:
+
+2010-06-01  Noam Rosenthal  <noam.rosenthal@nokia.com>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        [Qt] Add documentation to the QtWebkit bridge
+        https://bugs.webkit.org/show_bug.cgi?id=35861
+
+        This patch includes comprehensive qdoc documentation for the QtWebkit bridge.
+
+        * docs/qtwebkit-bridge.qdoc: Added.
+        * docs/qtwebkit.qdoc:
+        * docs/webkitsnippets/doc_src_qtscript.qdoc: Added.
+        * docs/webkitsnippets/qtwebkit_bridge_snippets.cpp: Added.
+        (wrapInFunction):
+
+2010-06-01  Simon Hausmann  <simon.hausmann@nokia.com>
+
+        Reviewed by Laszlo Gombos.
+
+        [Qt] Rename versioning .pri file to what Qt's mkspecs/features/qt.pri expects.
+
+        * qt_webkit_version.pri: Renamed from WebKit/qt/qtwebkit_version.pri.
+
+2010-05-31  Oswald Buddenhagen  <oswald.buddenhagen@nokia.com>
+
+        Reviewed by Simon Hausmann.
+
+        [Qt] Escape backslashes in the .pro files
+
+        qmake in Qt 4.7 warns about unescaped backspaces and deprecates them.
+
+        * Api/DerivedSources.pro:
+        * docs/docs.pri:
+
+2010-05-19  Denis Dzyubenko <denis.dzyubenko@nokia.com>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        When creating the UA, do not sassmue the language code is a
+        two-letter iso639-1 code.
+
+        * Api/qwebpage.cpp:
+        (QWebPage::userAgentForUrl):
+
+2010-05-28  Antti Koivisto  <koivisto@iki.fi>
+
+        Reviewed by Kenneth Rohde Christiansen.
+    
+        Add a missing #if ENABLE(), some null checking.
+
+        * Api/qwebpage.cpp:
+        (QWebPagePrivate::dynamicPropertyChangeEvent):
+
+2010-05-28  Antti Koivisto  <koivisto@iki.fi>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        https://bugs.webkit.org/show_bug.cgi?id=39874
+        [Qt] Make tiled backing store more configurable
+    
+        Make tile size, tile creation delay and tiling area dynamically configurable.
+
+        * Api/qwebpage.cpp:
+        (QWebPagePrivate::dynamicPropertyChangeEvent):
+
+2010-05-29  Dawit Alemayehu  <adawit@kde.org>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        Added a WebAction to stop all pending page refresh/redirect
+        requests set through the <meta http-equiv="refresh"...> tag.
+
+        https://bugs.webkit.org/show_bug.cgi?id=29899
+
+        * Api/qwebpage.cpp:
+        (QWebPage::triggerAction):
+        * Api/qwebpage.h:
+        * tests/qwebpage/tst_qwebpage.cpp:
+        (tst_QWebPage::testStopScheduledPageRefresh):
+
+2010-04-20  Robert Hogan  <robert@webkit.org>
+
+        Reviewed by Simon Hausmann.
+
+        [Qt] Add more support for textInputController
+
+        Add support for selectedRange(), setMarkedText(), insertText(),
+        and firstRectForCharacterRange().
+
+        https://bugs.webkit.org/show_bug.cgi?id=35702
+
+        * Api/qwebpage.cpp:
+        (QWebPagePrivate::inputMethodEvent):
+        * tests/qwebpage/tst_qwebpage.cpp:
+        (tst_QWebPage::inputMethods):
+
+2010-05-20  Janne Koskinen  <janne.p.koskinen@digia.com>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        [Qt] WINSCW compile fix for qwebframe test
+        https://bugs.webkit.org/show_bug.cgi?id=38722
+
+        WINSCW cannot determine template type up the hierarchy
+        to common base class.
+
+        * tests/qwebframe/tst_qwebframe.cpp:
+
+2010-05-23  Laszlo Gombos  <laszlo.1.gombos@nokia.com>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        [Qt] Update the Symbian version for the user agent
+        https://bugs.webkit.org/show_bug.cgi?id=38389
+
+        Fixes a regression introduced by r58648. Ensure that the "Symbian" string
+        is only listed one time in the User Agent string.
+
+        In addition make an effort to align the User Agent string to already
+        released WebKit based products for Symbian.
+
+        * Api/qwebpage.cpp:
+        (QWebPage::userAgentForUrl):
+
+2010-05-21  Simon Hausmann  <simon.hausmann@nokia.com>
+
+        Symbian build fix.
+
+        [Qt] Updated the wins def file with one new export.
+
+        The DRT symbols are still missing, but I can't build DRT ;(
+
+        * symbian/bwins/QtWebKitu.def:
+
+2010-05-12  Simon Hausmann  <simon.hausmann@nokia.com>
+
+        Reviewed by Laszlo Gombos.
+
+        Add a comment to explain the web inspector dynamic property url hook
+        and that it's there on purpose :)
+
+        https://bugs.webkit.org/show_bug.cgi?id=35340
+
+        * WebCoreSupport/InspectorClientQt.cpp:
+        (WebCore::InspectorClientQt::openInspectorFrontend):
+
+2010-05-06  Simon Hausmann  <simon.hausmann@nokia.com>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        [Qt] Replace public inspector url with private property for QtLauncher
+        https://bugs.webkit.org/show_bug.cgi?id=35340
+
+        Replace the public API with a private dynamic property until this feature
+        is ready.
+
+        * Api/qwebsettings.cpp:
+        * Api/qwebsettings.h:
+        * WebCoreSupport/InspectorClientQt.cpp:
+        (WebCore::InspectorClientQt::openInspectorFrontend):
+        * symbian/bwins/QtWebKitu.def:
+        * symbian/eabi/QtWebKitu.def:
+
+2010-05-20  Luiz Agostini  <luiz.agostini@openbossa.org>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        [Qt] Skipping popup focus test for maemo
+        https://bugs.webkit.org/show_bug.cgi?id=39314
+
+        Skipping popup focus test for maemo in qwebframe auto test.
+
+        The test method tst_QWebFrame::popupFocus() was testing popup focus AND input
+        field focus. The input field focus has been removed from the method popupFocus()
+        and a new test method named inputFieldFocus() has been added. Finally the test 
+        method popupFocus() has been skipped for maemo.
+
+        * tests/qwebframe/tst_qwebframe.cpp:
+
+2010-05-20  Rajiv Ramanasankaran  <rajiv.ramanasankaran@nokia.com>
+
+        Reviewed by Simon Hausmann.
+        
+        [Qt] QWebPage::inputMethodQuery() returns wrong values for Qt::ImCursorPosition, Qt::ImAnchorPosition
+        https://bugs.webkit.org/show_bug.cgi?id=38779
+
+        The earlier implementation was written with the assumption that in this scenario the 
+        anchor position always corresponds to the START index and that the current cursor position
+        always corresponds to the END index in WebKit.
+
+        Updated the implementation of QWebPage::inputMethodQuery(Qt::ImCursorPosition) and 
+        QWebPage::inputMethodQuery(Qt::ImAnchorPosition) for the case where the Editor is not in
+        composition mode. In the non-composition mode, the Anchor and the Current cursor positions
+        correspond to the Base and Extent position offsets in WebKit.
+
+        Also added the auto-tests for the RIGHT to LEFT and LEFT to RIGHT selections.
+
+        * Api/qwebpage.cpp:
+        (QWebPage::inputMethodQuery): Now returning correct values for Qt::ImCursorPosition and
+        Qt::ImAnchorPosition when the Editor is not in composition mode. 
+        * tests/qwebpage/tst_qwebpage.cpp:
+        (tst_QWebPage::inputMethods): Added auto-tests for RIGHT to LEFT and LEFT to RIGHT selections
+
+2010-05-12  Joe Ligman  <joseph.ligman@nokia.com>
+
+        Reviewed by Laszlo Gombos.
+
+        [Qt] Nested overflow div does not scroll
+        https://bugs.webkit.org/show_bug.cgi?id=38641
+
+        Modify qtwebkit_webframe_scrollOverflow, if the current node's render layer
+        does not scroll it will try and scroll the parent's render layer. Also export
+        qtwebkit_webframe_scrollOverflow so we can use it independently of
+        qtwebkit_webframe_scrollRecursively
+
+        * Api/qwebframe.cpp:
+        (qtwebkit_webframe_scrollOverflow):
+        (qtwebkit_webframe_scrollRecursively):
+
+2010-05-17  Antti Koivisto  <koivisto@iki.fi>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        https://bugs.webkit.org/show_bug.cgi?id=39218
+        [Qt] Tiled backing store tiles sometimes flicker when exiting a zoom animation
+        
+        Tiles sometimes flicker when exiting a zoom animation. This happens as a result
+        of the visible rectangle being momentarily out of sync.
+        
+        Instead of updating the visible rect by explicitly setting it, pull it through
+        the client and recompute in WebKit the level.
+
+        * Api/qgraphicswebview.cpp:
+        (QGraphicsWebView::paint):
+        * WebCoreSupport/ChromeClientQt.cpp:
+        (WebCore::ChromeClientQt::visibleRectForTiledBackingStore):
+        * WebCoreSupport/ChromeClientQt.h:
+
+2010-05-18  Jedrzej Nowacki  <jedrzej.nowacki@nokia.com>
+
+        Reviewed by Simon Hausmann.
+
+        Fix QWebHistory serialization.
+
+        Regression was caused by bug 33224. The streaming function
+        should generate a documentSequenceNumber for all loaded values.
+
+        [Qt] tst_QWebHistory::serialize_2() fails
+        https://bugs.webkit.org/show_bug.cgi?id=37322
+
+        * Api/qwebhistory.cpp:
+        (operator>>):
+
 2010-05-14  Kent Hansen <kent.hansen@nokia.com>, Jocelyn Turcotte <jocelyn.turcotte@nokia.com>, Tor Arne Vestbø <tor.arne.vestbo@nokia.com>, Henry Haverinen <henry.haverinen@nokia.com>, Jedrzej Nowacki <jedrzej.nowacki@nokia.com>, Andreas Kling <andreas.kling@nokia.com>
 
         Reviewed by Simon Hausmann.
diff --git a/src/3rdparty/webkit/WebKit/qt/WebCoreSupport/ChromeClientQt.cpp b/src/3rdparty/webkit/WebKit/qt/WebCoreSupport/ChromeClientQt.cpp
index 9eb10d6..7d1c794 100644
--- a/src/3rdparty/webkit/WebKit/qt/WebCoreSupport/ChromeClientQt.cpp
+++ b/src/3rdparty/webkit/WebKit/qt/WebCoreSupport/ChromeClientQt.cpp
@@ -559,13 +559,24 @@ bool ChromeClientQt::allowsAcceleratedCompositing() const
 }
 
 #endif
+    
+#if ENABLE(TILED_BACKING_STORE)
+IntRect ChromeClientQt::visibleRectForTiledBackingStore() const
+{ 
+    if (!platformPageClient())
+        return IntRect();
+    return enclosingIntRect(FloatRect(platformPageClient()->graphicsItemVisibleRect()));
+}
+#endif
 
 QtAbstractWebPopup* ChromeClientQt::createSelectPopup()
 {
 #if defined(Q_WS_MAEMO_5)
     return new QtMaemoWebPopup;
-#else
+#elif !defined(QT_NO_COMBOBOX)
     return new QtFallbackWebPopup;
+#else
+    return result;
 #endif
 }
 
diff --git a/src/3rdparty/webkit/WebKit/qt/WebCoreSupport/ChromeClientQt.h b/src/3rdparty/webkit/WebKit/qt/WebCoreSupport/ChromeClientQt.h
index f0a7c8c..a47adf0 100644
--- a/src/3rdparty/webkit/WebKit/qt/WebCoreSupport/ChromeClientQt.h
+++ b/src/3rdparty/webkit/WebKit/qt/WebCoreSupport/ChromeClientQt.h
@@ -140,6 +140,10 @@ namespace WebCore {
         virtual bool allowsAcceleratedCompositing() const;
 #endif
 
+#if ENABLE(TILED_BACKING_STORE)
+        virtual IntRect visibleRectForTiledBackingStore() const;
+#endif
+
 #if ENABLE(TOUCH_EVENTS)
         virtual void needTouchEvents(bool) { }
 #endif
diff --git a/src/3rdparty/webkit/WebKit/qt/WebCoreSupport/EditorClientQt.cpp b/src/3rdparty/webkit/WebKit/qt/WebCoreSupport/EditorClientQt.cpp
index 7b7f610..0ce6383 100644
--- a/src/3rdparty/webkit/WebKit/qt/WebCoreSupport/EditorClientQt.cpp
+++ b/src/3rdparty/webkit/WebKit/qt/WebCoreSupport/EditorClientQt.cpp
@@ -613,11 +613,11 @@ void EditorClientQt::setInputMethodState(bool active)
             }
         }
         webPageClient->setInputMethodHint(Qt::ImhHiddenText, isPasswordField);
-#ifdef Q_WS_MAEMO_5
-        // Maemo 5 MicroB Browser disables auto-uppercase and predictive text, thus, so do we.
+#if defined(Q_WS_MAEMO_5) || defined(Q_OS_SYMBIAN)
+        // disables auto-uppercase and predictive text for mobile devices
         webPageClient->setInputMethodHint(Qt::ImhNoAutoUppercase, true);
         webPageClient->setInputMethodHint(Qt::ImhNoPredictiveText, true);
-#endif // Q_WS_MAEMO_5
+#endif // Q_WS_MAEMO_5 || Q_OS_SYMBIAN
 #endif // QT_VERSION check
         webPageClient->setInputMethodEnabled(active);
     }
diff --git a/src/3rdparty/webkit/WebKit/qt/WebCoreSupport/InspectorClientQt.cpp b/src/3rdparty/webkit/WebKit/qt/WebCoreSupport/InspectorClientQt.cpp
index 7fabbda..2d11700 100644
--- a/src/3rdparty/webkit/WebKit/qt/WebCoreSupport/InspectorClientQt.cpp
+++ b/src/3rdparty/webkit/WebKit/qt/WebCoreSupport/InspectorClientQt.cpp
@@ -88,12 +88,20 @@ void InspectorClientQt::openInspectorFrontend(WebCore::InspectorController*)
     InspectorClientWebPage* inspectorPage = new InspectorClientWebPage(inspectorView);
     inspectorView->setPage(inspectorPage);
 
-    QUrl inspectorUrl = m_inspectedWebPage->settings()->inspectorUrl();
+    QWebInspector* inspector = m_inspectedWebPage->d->getOrCreateInspector();
+    // This is a known hook that allows changing the default URL for the
+    // Web inspector. This is used for SDK purposes. Please keep this hook
+    // around and don't remove it.
+    // https://bugs.webkit.org/show_bug.cgi?id=35340
+    QUrl inspectorUrl;
+#ifndef QT_NO_PROPERTIES
+    inspectorUrl = inspector->property("_q_inspectorUrl").toUrl();
+#endif
     if (!inspectorUrl.isValid())
         inspectorUrl = QUrl("qrc:/webkit/inspector/inspector.html");
     inspectorView->page()->mainFrame()->load(inspectorUrl);
     m_inspectedWebPage->d->inspectorFrontend = inspectorView;
-    m_inspectedWebPage->d->getOrCreateInspector()->d->setFrontend(inspectorView);
+    inspector->d->setFrontend(inspectorView);
 
     inspectorView->page()->d->page->inspectorController()->setInspectorFrontendClient(new InspectorFrontendClientQt(m_inspectedWebPage, inspectorView));
 }
diff --git a/src/3rdparty/webkit/WebKit/qt/WebCoreSupport/QtFallbackWebPopup.cpp b/src/3rdparty/webkit/WebKit/qt/WebCoreSupport/QtFallbackWebPopup.cpp
index 7514077..26420e5 100644
--- a/src/3rdparty/webkit/WebKit/qt/WebCoreSupport/QtFallbackWebPopup.cpp
+++ b/src/3rdparty/webkit/WebKit/qt/WebCoreSupport/QtFallbackWebPopup.cpp
@@ -21,6 +21,8 @@
 #include "config.h"
 #include "QtFallbackWebPopup.h"
 
+#ifndef QT_NO_COMBOBOX
+
 #include "HostWindow.h"
 #include "PopupMenuClient.h"
 #include "QWebPageClient.h"
@@ -225,3 +227,5 @@ void QtFallbackWebPopup::activeChanged(int index)
 }
 
 }
+
+#endif // QT_NO_COMBOBOX
diff --git a/src/3rdparty/webkit/WebKit/qt/WebCoreSupport/QtFallbackWebPopup.h b/src/3rdparty/webkit/WebKit/qt/WebCoreSupport/QtFallbackWebPopup.h
index 62b8aea..6d2e1ff 100644
--- a/src/3rdparty/webkit/WebKit/qt/WebCoreSupport/QtFallbackWebPopup.h
+++ b/src/3rdparty/webkit/WebKit/qt/WebCoreSupport/QtFallbackWebPopup.h
@@ -23,6 +23,8 @@
 #include "QtAbstractWebPopup.h"
 #include <QComboBox>
 
+#ifndef QT_NO_COMBOBOX
+
 QT_BEGIN_NAMESPACE
 class QGraphicsProxyWidget;
 QT_END_NAMESPACE
@@ -67,4 +69,6 @@ private:
 
 }
 
+#endif // QT_NO_COMBOBOX
+
 #endif // QtFallbackWebPopup_h
diff --git a/src/3rdparty/webkit/WebKit/qt/docs/qtwebkit-bridge.qdoc b/src/3rdparty/webkit/WebKit/qt/docs/qtwebkit-bridge.qdoc
new file mode 100644
index 0000000..4f41d29
--- /dev/null
+++ b/src/3rdparty/webkit/WebKit/qt/docs/qtwebkit-bridge.qdoc
@@ -0,0 +1,425 @@
+/*!
+    \inmodule QtWebKit
+    \page qtwebkit-bridge.html
+    \title The QtWebKit Bridge
+    \contentspage QtWebKit
+    \section1 Overview
+    \section2 The technology
+
+    The QtWebKit bridge is a mechanism that extends WebKit's JavaScript environment to access native
+    objects that are represented as QObjects. It takes advantage of the inherent introspection of the
+    \l{Qt Object Model}, which has a natural alignment to the way JavaScript worked.
+
+    For example, both JavaScript and QObjects have properties: a construct that represent a getter/setter
+    pair under one name.
+
+    \section2 Use Cases
+
+    There are two main use cases for the QtWebKit bridge. Web content in a native application, and Thin Client.
+
+    \section3 Web Content in a Native Application
+
+    This is a common use case in classic Qt application, and a design pattern used by several modern
+    applications. For example, an application that contains both a media-player, playlist manager, and
+    a music store. The playlist manager is usually best authored as a classic desktop application,
+    with the native-looking robust \l{QWidget}s helping with producing that application.
+    The media-player control, which usually looks custom, can be written using \l{The Graphics View framework}
+    or with in a declarative way with \l{QtDeclarative}. The music store, which shows dynamic content
+    from the internet, and gets modified rapidly, is best authored in HTML and maintained on the server.
+
+    With the QtWebKit bridge, that music store component can interact with native parts of the application,
+    for example, if a file needs to be saved to a specific location.
+
+    \section3 Thin Client
+
+    Another use case is using Qt as a native backend to a full web application,
+    referred to here as a thin client. In this use-case, the entire UI is driven by
+    HTML, JavaScript and CSS, and native Qt-based components are used to allow that application
+    access to native features not usually exposed to the web, or to enable helper components that
+    are best written with C++.
+
+    An example for such client is a UI for a video-on-demand service on a TV. The entire content and
+    UI can be kept on the server, served dynamically through HTTP and rendered with WebKit, with additional
+    native components for accessing hardware-specific features like extracting the list of images
+    out of the video.
+
+    \section2 Difference from Other Bridge Technologies
+
+    Of course QtWebKit is not the only bridge technology out there. NPAPI, for example,
+    is a long-time standard or web-native bridging. Due to Qt's meta-object system, full applications
+    built partially with web-technologies are much easier to develop. NPAPI, however, is more geared
+    towards cross-browser plugins, due to it being an accepted standard.
+
+    When developing a plugin for a browser, NPAPI is recommended. When developing a full application
+    that utilizes HTML-rendering, the QtWebKit bridge is recommended.
+
+    \section2 Relationship with QtScript
+
+    The QtWebKit bridge is similar to \l{QtScript}, especially to some of the features described in the
+    \l{Making Applications Scriptable} page. However, as of Qt 4.7, full QtScript API is not supported for web applications.
+    That is planned as an enhancement for future versions. You might notice that some of the features
+    described here are an exact copy of the ones described in the \l{Making Applications Scriptable} page. That is because
+    the QtWebKit bridge is a subset of that functionality, and this page tries to capture the full
+    capabilities available through the QtWebKit bridge specifically.
+
+    \section1 Accessing QObjects
+
+    \section2 Creating the link via QWebFrame
+
+    By default, no QObjects are accessible through the web environment, for security reasons.
+    To enable web content access to a native QObject, the application has to explicitly grant it access,
+    using the following call:
+
+    \snippet webkitsnippets/qtwebkit_bridge_snippets.cpp 0
+
+    See \l{QWebFrame::addToJavaScriptWindowObject()} for more information.
+
+    \section2 Using Signals and Slots
+
+    Qt Script adapts Qt's central \l{Signals and Slots} feature for
+    scripting. There are three principal ways to use signals and slots
+    with Qt Script:
+
+    \list
+    \i \bold{Hybrid C++/script}: C++ application code connects a
+    signal to a script function. The script function can, for example, be
+    a function that the user has typed in, or one that you have read from a
+    file. This approach is useful if you have a QObject but don't want
+    to expose the object itself to the scripting environment; you just
+    want a script to be able to define how a signal should be reacted
+    to, and leave it up to the C++ side of your application to establish
+    the connection.
+
+    \i \bold{Hybrid script/C++}: A script can connect signals and slots
+    to establish connections between pre-defined objects that the
+    application exposes to the scripting environment. In this scenario,
+    the slots themselves are still written in C++, but the definition of
+    the connections is fully dynamic (script-defined).
+
+    \i \bold{Purely script-defined}: A script can both define signal
+    handler functions (effectively "slots written in Qt Script"),
+    \e{and} set up the connections that utilize those handlers. For
+    example, a script can define a function that will handle the
+    QLineEdit::returnPressed() signal, and then connect that signal to the
+    script function.
+    \endlist
+
+    Note that QtScript functions such as qScriptConnect are unavilable in the web environment.
+
+    \section3 Signal to Function Connections
+
+    \c{connect(function)}
+
+    In this form of connection, the argument to \c{connect()} is the
+    function to connect to the signal.
+
+    \snippet webkitsnippets/doc_src_qtscript.qdoc 2
+
+    The argument can be a Qt Script function, as in the above
+    example, or it can be a QObject slot, as in
+    the following example:
+
+    \snippet webkitsnippets/doc_src_qtscript.qdoc 3
+
+    When the argument is a QObject slot, the argument types of the
+    signal and slot do not necessarily have to be compatible;
+    the QtWebKit bridge will, if necessary, perform conversion of the signal
+    arguments to match the argument types of the slot.
+
+    To disconnect from a signal, you invoke the signal's
+    \c{disconnect()} function, passing the function to disconnect
+    as argument:
+
+    \snippet webkitsnippets/doc_src_qtscript.qdoc 4
+
+    When a script function is invoked in response to a signal, the
+    \c this object will be the Global Object.
+
+    \section3 Signal to Member Function Connections
+
+    \c{connect(thisObject, function)}
+
+    In this form of the \c{connect()} function, the first argument
+    is the object that will be bound to the variable, \c this, when
+    the function specified using the second argument is invoked.
+
+    If you have a push button in a form, you typically want to do
+    something involving the form in response to the button's
+    \c{clicked} signal; passing the form as the \c this object
+    makes sense in such a case.
+
+    \snippet webkitsnippets/doc_src_qtscript.qdoc 5
+
+    To disconnect from the signal, pass the same arguments to \c{disconnect()}:
+
+    \snippet webkitsnippets/doc_src_qtscript.qdoc 6
+
+    \section3 Signal to Named Member Function Connections
+
+    \c{connect(thisObject, functionName)}
+
+    In this form of the \c{connect()} function, the first argument is
+    the object that will be bound to the variable, \c this, when
+    a function is invoked in response to the signal. The second argument
+    specifies the name of a function that is connected to the signal,
+    and this refers to a member function of the object passed as the
+    first argument (\c thisObject in the above scheme).
+
+    Note that the function is resolved when the connection is made, not
+    when the signal is emitted.
+
+    \snippet webkitsnippets/doc_src_qtscript.qdoc 7
+
+    To disconnect from the signal, pass the same arguments to \c{disconnect()}:
+
+    \snippet webkitsnippets/doc_src_qtscript.qdoc 8
+
+    \section3 Error Handling
+
+    When \c{connect()} or \c{disconnect()} succeeds, the function will
+    return \c{undefined}; otherwise, it will throw a script exception.
+    You can obtain an error message from the resulting \c{Error} object.
+    Example:
+
+    \snippet webkitsnippets/doc_src_qtscript.qdoc 9
+
+    \section3 Emitting Signals from Scripts
+
+    To emit a signal from script code, you simply invoke the signal
+    function, passing the relevant arguments:
+
+    \snippet webkitsnippets/doc_src_qtscript.qdoc 10
+
+    It is currently not possible to define a new signal in a script;
+    i.e., all signals must be defined by C++ classes.
+
+    \section3 Overloaded Signals and Slots
+
+    When a signal or slot is overloaded, the QtWebKit bridge will attempt to
+    pick the right overload based on the actual types of the QScriptValue arguments
+    involved in the function invocation. For example, if your class has slots
+    \c{myOverloadedSlot(int)} and \c{myOverloadedSlot(QString)}, the following
+    script code will behave reasonably:
+
+    \snippet webkitsnippets/doc_src_qtscript.qdoc 11
+
+    You can specify a particular overload by using array-style property access
+    with the \l{QMetaObject::normalizedSignature()}{normalized signature} of
+    the C++ function as the property name:
+
+    \snippet webkitsnippets/doc_src_qtscript.qdoc 12
+
+    If the overloads have different number of arguments, the QtWebKit bridge will
+    pick the overload with the argument count that best matches the
+    actual number of arguments passed to the slot.
+
+    For overloaded signals, JavaScript will throw an error if you try to connect
+    to the signal by name; you have to refer to the signal with the full
+    normalized signature of the particular overload you want to connect to.
+
+    \section3 Invokable Methods
+
+    Both slots and signals are invokable from script by default. In addition, it's also
+    possible to define a method that's invokable from script without it being a signal or a slot.
+    This is especially useful for functions with return types, as slots normally do not return anything
+    (it would be meaningless to return values from a slot, as the connected signals don't handle the returned data).
+    To make a non-slot method invokable, simply add the Q_INVOKABLE macro before its definition:
+
+    \snippet webkitsnippets/doc_src_qtscript.qdoc 20
+
+    \section2 Accessing Properties
+
+    The properties of the QObject are available as properties
+    of the corresponding JavaScript object. When you manipulate
+    a property in script code, the C++ get/set method for that
+    property will automatically be invoked. For example, if your
+    C++ class has a property declared as follows:
+
+    \snippet webkitsnippets/doc_src_qtscript.qdoc 13
+
+    then script code can do things like the following:
+
+    \snippet webkitsnippets/doc_src_qtscript.qdoc 14
+
+    \section2 Accessing Child QObjects
+
+    Every named child of the QObject (that is, for which
+    QObject::objectName() is not an empty string) is by default available as
+    a property of the JavaScript wrapper object. For example,
+    if you have a QDialog with a child widget whose \c{objectName} property is
+    \c{"okButton"}, you can access this object in script code through
+    the expression
+
+    \snippet webkitsnippets/doc_src_qtscript.qdoc 15
+
+    Since \c{objectName} is itself a Q_PROPERTY, you can manipulate
+    the name in script code to, for example, rename an object:
+
+    \snippet webkitsnippets/doc_src_qtscript.qdoc 16
+
+    \section2 Data types
+
+    When calling slots, receiving signals or accessing properties, usually some payload is involved.
+    For example, a property "text" might return a \l{QString} parameter.
+    The QtWebKit bridge does the job of converting between a given JavaScript data-type, and the
+    expected or given Qt type. Each Qt type has a coresponding set of rules of how JavaScript treats it.
+
+    The data type conversions are also applicable for the data returned from non-void invokable methods.
+
+    \section3 Numbers
+
+    All Qt numeric data types are converted to or from a JavaScript number. These include int, short, float,
+    double, and the porable Qt types (qreal, qint etc). A special case is \l{QChar};
+    If a slot expects a QChar, the QtWebKit bridge would use the unicode value in case of a number,
+    or the first character in a string.
+
+    Note that non-standard (typedefed) number types are not automatically converted to
+    or from a JavaScript number - it's advised to use standard number types for signal, slots
+    and properties.
+
+    When a non-number is passed as an argument to a method or property that expects a number,
+    the appropriate JavaScript conversion function (parseInt / parseFloat) would be used.
+
+    \section3 Strings
+
+    When JavaScript accesses methods or properties that expect a \l{QString}, the QtWebKit bridge
+    will automatically convert the value to a string (if it's not already a string), using the
+    built-in JavaScript toString method.
+
+    When a QString is passed to JavaScript from a signal or a property, The QtWebKit bridge will
+    convert it into a JavaScript string.
+
+    \section3 Date & Time
+
+    Both \l{QDate}, \l{QTime} and \l{QDateTime} are automatically translated to or from the JavaScript
+    Date object. If a number is passed as an argument to a method that expects one of the date/time
+    types, the QtWebKit bridge would treat it as a timestamp. If a sting is passed, QtWebKit would
+    try different Qt date parsing functions to find the right one.
+
+    \section3 Regular Expressions
+
+    The QtWebKit bridge would automatically convert JavaScript RegEx object to a \l{QRegExp}.
+    If a string is passed to a method expecting a \l{QRegExp}, the string would be converted
+    to that \l{QRegExp}.
+
+    \section3 Lists
+
+    The QtWebKit bridge treats several types of lists in a special way: \l{QVariantList}, \l{QStringList},
+    \l{QObjectList} and \l{QList}<int>. When a slot or property expects one of those list types,
+    the QtWebKit bridge would try to convert a JavaScript array into that type, converting each of
+    the array's elements to the single-element type of the list.
+
+    The most useful type of list is perhaps \l{QVariantList}, which can be converted to from any
+    JavaScript array.
+
+    \section3 Compound (JSON) objects
+
+    JavaScript compound objects, also known as JSON objects, are variables which hold a list
+    of key-value pairs, where all the keys are strings and the values can have any type.
+    This translates very well to \l{QVariantMap}, which is nothing more than a \l{QMap} of \l{QString}
+    to \l{QVariant}.
+
+    The seamless conversion between JSON objects and \l{QVariantMap} allows for a very convenient
+    way of passing arbitrary structured data between C++ and the JavaScript environment. The native \l{QObject} has
+    to make sure that compound values are converted to \l{QVariantMap}s and \l{QVariantList}s, and JavaScript is
+    guaranteed to receive them in a meaningful way.
+
+    Note that types that are not supported by JSON, such as JavaScript functions and getters/setters,
+    are not converted.
+
+    \section3 QVariants
+
+    When a slot or property accepts a \l{QVariant}, the QtWebKit bridge would create a \l{QVariant} that best
+    matches the argument passed by JavaScript. A string, for example, would become a \l{QVariant} holding a \l{QString},
+    a normal JSON object would become a \l{QVariantMap}, and a JavaScript array would become a \l{QVariantList}.
+
+    Using \l{QVariant}s generously in C++ in that way makes C++ programming feel a bit more like JavaScript programming,
+    as it adds another level of indirection - passing \l{QVariant}s around is very flexible, as the program can figure out
+    the type of argument in runtime just like JavaScript would do, but it also takes away from the type-safety and robust
+    nature of C++. It's recommended to use \l{QVariant}s only for convenience high-level functions, and to keep most of your
+    \l{QObject}s somewhat type-safe.
+
+    \section3 QObjects
+
+    A pointer to a \l{QObject} or a \l{QWidget} can be passed as payload in signals, slots and properties. That object
+    can then be used like an object that's exposed directly; i.e. its slots can be invoked, its signals connected to etc.
+    However, this functionality is fairly limited - the type used has to be \l{QObject}* or \l{QWidget}*. If the type
+    specified is a pointer to a non-\l{QWidget} subclass of \l{QObject}, the QtWebKit bridge would not recognize it to be
+    a \l{QObject}.
+
+    In general its advised to use care when passing \l{QObject}s as arguments, as those objects don't become owned by
+    the Javascipt engine; That means that the application developer has to be extra careful not to try to access
+    \l{QObject}s that have already been deleted by the native environment.
+
+    \section3 Pixmaps and Images
+
+    \since 4.7
+
+    The QtWebKit bridge handles \l{QPixmap}s and \l{QImage}s in a special way. Since QtWebKit stores \l{QPixmap}s to
+    represent HTML images, \l{QPixmap}s coming from the native environment can be used directly inside WebKit.
+    A \l{QImage} or a \l{QPixmap} coming from the Qt environment would convert to an intermediate JavaScript object,
+    that can be represented like this:
+
+    \snippet webkitsnippets/qtwebkit_bridge_snippets.cpp 1
+
+    The JavaScript environment can then use the pixmap it gets from Qt and display it inside the HTML environment,
+    by assigning it to an existing <img /> element using assignToHTMLImageElement. It can also use the toDataURL() function,
+    which allows using the pixmap as the src attribute of an image or as a background-image url. Note that the toDataURL()
+    function is costly and should be used with caution.
+
+    Example code:
+
+    C++:
+    \snippet webkitsnippets/qtwebkit_bridge_snippets.cpp 2
+
+    HTML:
+    \snippet webkitsnippets/qtwebkit_bridge_snippets.cpp 3
+
+    When a Qt object expects a \l{QImage} or a \l{QPixmap} as input, and the argument passed is an HTML image element,
+    the QtWebKit bridge would convert the pixmap assigned to that image element into a \l{QPixmap} or a \l{QImage}.
+
+    \since 4.7
+
+    \section3 QWebElement
+
+    A signal, slot or property that expects or returns a \l{QWebElement} can work seamlessly with JavaScript references
+    to DOM elements. The JavaScript environment can select DOM elements, keep them in variables, then pass them to Qt as
+    a \l{QWebElement}, and receive them back. Example:
+
+    C++:
+    \snippet webkitsnippets/qtwebkit_bridge_snippets.cpp 4
+
+    HTML:
+    \snippet webkitsnippets/qtwebkit_bridge_snippets.cpp 5
+
+    This is specifically useful to create custom renderers or extensions to the web environment. Instead of forcing Qt
+    to select the element, the web environment already selects the element and then send the selected element directly to Qt.
+
+    Note that \l{QWebElement}s are not thread safe - an object handling them has to live in the UI thread.
+
+    \section1 Architecture issues
+
+    \section2 Limiting the Scope of the Hybrid Layer
+
+    When using QtWebKit's hybrid features, it's a common pitfall to make the API exposed to JavaScript very rich and
+    use all its features. This, however, leads to complexity and can create bugs that are hard to trace.
+    Instead, it's advisable to keep the hybrid layer small and manageable: create a gate only when
+    there's an actual need for it, i.e. there's a new native enabler that requires a direct interface
+    to the application layer. Sometimes new functionality is better handled internally in the native layer
+    or in the web layer; simplicity is your friend.
+
+    This usually becomes more apparent when the hybrid layer can create or destroy objects, or uses
+    signals slots or properties with a \l{QObject}* argument. It's advised to be very careful and to treat
+    an exposed \l{QObject} as a system - with careful attention to memory management and object ownership.
+
+    \section2 Internet Security
+
+    When exposing native object to an open web environment, it's important to understand the security
+    implications. Think whether the exposed object enables the web environment access to things that
+    shouldn't be open, and whether the web content loaded by that web page comes from a trusted. In general, when
+    exposing native QObjects that give the web environment access to private information or to functionality
+    that's potentially harmful to the client, such exposure should be balanced by limiting the web page's
+    access to trusted URLs only with HTTPS and other security measures.
+
+
+*/
diff --git a/src/3rdparty/webkit/WebKit/qt/docs/qtwebkit.qdoc b/src/3rdparty/webkit/WebKit/qt/docs/qtwebkit.qdoc
index c6dd550..d3f5502 100644
--- a/src/3rdparty/webkit/WebKit/qt/docs/qtwebkit.qdoc
+++ b/src/3rdparty/webkit/WebKit/qt/docs/qtwebkit.qdoc
@@ -20,8 +20,9 @@
     scripted with JavaScript.
 
     A bridge between the JavaScript execution environment and the Qt object
-    model makes it possible for custom QObjects to be scripted. Integration
-    with the Qt networking module enables Web pages to be transparently loaded
+    model makes it possible for custom QObjects to be scripted. For detailed
+    documentation see \l{The QtWebkit Bridge}.
+    Integration with the Qt networking module enables Web pages to be transparently loaded
     from Web servers, the local file system or even the Qt resource system.
 
     In addition to providing pure rendering features, HTML documents can be
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
new file mode 100644
index 0000000..d83ab3f
--- /dev/null
+++ b/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/qtwebkit_bridge_snippets.cpp
@@ -0,0 +1,83 @@
+
+void wrapInFunction()
+{
+
+//! [0]
+    // ...
+    QWebFrame *frame = myWebPage->mainFrame();
+    frame->addToJavaScriptWindowObject("someNameForMyObject", myObject);
+    // ...
+//! [0]
+#if 0
+    //! [1]
+   {
+       width: ...,
+       height: ...,
+       toDataURL: function() { ... },
+       assignToHTMLImageElement: function(element) { ... }
+   }
+   //! [1]
+#endif
+    //! [2]
+     class MyObject : QObject {
+         Q_OBJECT
+         Q_PROPERTY(QPixmap myPixmap READ getPixmap)
+
+     public:
+         QPixmap getPixmap() const;
+     };
+
+     /* ... */
+
+     MyObject myObject;
+     myWebPage.mainFrame()->addToJavaScriptWindowObject("myObject", &myObject);
+
+    //! [2]
+ #if 0
+     //! [3]
+     <html>
+        <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]
+ #endif
+     //! [4]
+      class MyObject : QObject {
+          Q_OBJECT
+
+      public slots:
+          void doSomethingWithWebElement(const QWebElement&);
+      };
+
+      /* ... */
+
+      MyObject myObject;
+      myWebPage.mainFrame()->addToJavaScriptWindowObject("myObject", &myObject);
+
+     //! [4]
+  #if 0
+      //! [5]
+      <html>
+         <head>
+          <script>
+              function runExample() {
+                  myObject.doSomethingWithWebElement(document.getElementById("someElement"));
+              }
+          </script>
+         </head>
+         <body onload="runExample()">
+          <span id="someElement">Text</span>
+         </body>
+      </html>
+     //! [5]
+  #endif
+}
+
diff --git a/src/3rdparty/webkit/WebKit/qt/qtwebkit_version.pri b/src/3rdparty/webkit/WebKit/qt/qt_webkit_version.pri
index ffd192c..ffd192c 100644
--- a/src/3rdparty/webkit/WebKit/qt/qtwebkit_version.pri
+++ b/src/3rdparty/webkit/WebKit/qt/qt_webkit_version.pri
diff --git a/src/3rdparty/webkit/WebKit/qt/symbian/bwins/QtWebKitu.def b/src/3rdparty/webkit/WebKit/qt/symbian/bwins/QtWebKitu.def
index 910ba8f..969defe 100644
--- a/src/3rdparty/webkit/WebKit/qt/symbian/bwins/QtWebKitu.def
+++ b/src/3rdparty/webkit/WebKit/qt/symbian/bwins/QtWebKitu.def
@@ -625,7 +625,7 @@ EXPORTS
 	?qt_suspendActiveDOMObjects@@YAXPAVQWebFrame@@@Z @ 624 NONAME ; void qt_suspendActiveDOMObjects(class QWebFrame *)
 	?qtwebkit_webframe_scrollRecursively@@YA_NPAVQWebFrame@@HH@Z @ 625 NONAME ABSENT ; bool qtwebkit_webframe_scrollRecursively(class QWebFrame *, int, int)
 	?closeEvent@QWebInspector@@MAEXPAVQCloseEvent@@@Z @ 626 NONAME ; void QWebInspector::closeEvent(class QCloseEvent *)
-	?inspectorUrl@QWebSettings@@QBE?AVQUrl@@XZ @ 627 NONAME ; class QUrl QWebSettings::inspectorUrl(void) const
+	?inspectorUrl@QWebSettings@@QBE?AVQUrl@@XZ @ 627 NONAME ABSENT ; class QUrl QWebSettings::inspectorUrl(void) const
 	?isTiledBackingStoreFrozen@QGraphicsWebView@@QBE_NXZ @ 628 NONAME ; bool QGraphicsWebView::isTiledBackingStoreFrozen(void) const
 	?pageChanged@QWebFrame@@IAEXXZ @ 629 NONAME ; void QWebFrame::pageChanged(void)
 	?qt_drt_enableCaretBrowsing@@YAXPAVQWebPage@@_N@Z @ 630 NONAME ; void qt_drt_enableCaretBrowsing(class QWebPage *, bool)
@@ -646,7 +646,8 @@ EXPORTS
 	?qtwebkit_webframe_scrollRecursively@@YAXPAVQWebFrame@@HHABVQPoint@@@Z @ 645 NONAME ; void qtwebkit_webframe_scrollRecursively(class QWebFrame *, int, int, class QPoint const &)
 	?resizesToContents@QGraphicsWebView@@QBE_NXZ @ 646 NONAME ; bool QGraphicsWebView::resizesToContents(void) const
 	?scrollToAnchor@QWebFrame@@QAEXABVQString@@@Z @ 647 NONAME ; void QWebFrame::scrollToAnchor(class QString const &)
-	?setInspectorUrl@QWebSettings@@QAEXABVQUrl@@@Z @ 648 NONAME ; void QWebSettings::setInspectorUrl(class QUrl const &)
+	?setInspectorUrl@QWebSettings@@QAEXABVQUrl@@@Z @ 648 NONAME ABSENT ; void QWebSettings::setInspectorUrl(class QUrl const &)
 	?setResizesToContents@QGraphicsWebView@@QAEX_N@Z @ 649 NONAME ; void QGraphicsWebView::setResizesToContents(bool)
 	?setTiledBackingStoreFrozen@QGraphicsWebView@@QAEX_N@Z @ 650 NONAME ; void QGraphicsWebView::setTiledBackingStoreFrozen(bool)
+	?qtwebkit_webframe_scrollOverflow@@YA_NPAVQWebFrame@@HHABVQPoint@@@Z @ 651 NONAME ; bool qtwebkit_webframe_scrollOverflow(QWebFrame *, int, int, const QPoint&)
 
diff --git a/src/3rdparty/webkit/WebKit/qt/symbian/eabi/QtWebKitu.def b/src/3rdparty/webkit/WebKit/qt/symbian/eabi/QtWebKitu.def
index ca462d0..e0f2125 100644
--- a/src/3rdparty/webkit/WebKit/qt/symbian/eabi/QtWebKitu.def
+++ b/src/3rdparty/webkit/WebKit/qt/symbian/eabi/QtWebKitu.def
@@ -712,11 +712,61 @@ EXPORTS
 	_Z47qt_drt_setDomainRelaxationForbiddenForURLSchemebRK7QString @ 711 NONAME
 	_ZN9QWebFrame11pageChangedEv @ 712 NONAME
 	_ZN9QWebFrame14scrollToAnchorERK7QString @ 713 NONAME
-	_ZN12QWebSettings15setInspectorUrlERK4QUrl @ 714 NONAME
+	_ZN12QWebSettings15setInspectorUrlERK4QUrl @ 714 NONAME ABSENT
 	_ZN13QWebInspector10closeEventEP11QCloseEvent @ 715 NONAME
 	_ZN16QGraphicsWebView26setTiledBackingStoreFrozenEb @ 716 NONAME
 	_ZNK16QGraphicsWebView25isTiledBackingStoreFrozenEv @ 717 NONAME
 	_Z18qt_wrt_setViewModeP8QWebPageRK7QString @ 718 NONAME ABSENT
 	_Z19qt_drt_setMediaTypeP9QWebFrameRK7QString @ 719 NONAME
 	_Z26qt_drt_enableCaretBrowsingP8QWebPageb @ 720 NONAME
-	_ZNK12QWebSettings12inspectorUrlEv @ 721 NONAME
+	_ZNK12QWebSettings12inspectorUrlEv @ 721 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt19webPageSetGroupNameEP8QWebPageRK7QString @ 722 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt16webPageGroupNameEP8QWebPage @ 723 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt23garbageCollectorCollectEv @ 724 NONAME ABSENT
+	_Z32qtwebkit_webframe_scrollOverflowP9QWebFrameiiRK6QPoint @ 725 NONAME
+	_ZN23DumpRenderTreeSupportQt12setMediaTypeEP9QWebFrameRK7QString @ 726 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt13numberOfPagesEP9QWebFrameff @ 727 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt13selectedRangeEP8QWebPage @ 728 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt14clearFrameNameEP9QWebFrame @ 729 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt14pauseAnimationEP9QWebFrameRK7QStringdS4_ @ 730 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt15dumpFrameLoaderEb @ 731 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt16dumpNotificationEb @ 732 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt16isCommandEnabledEP8QWebPageRK7QString @ 733 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt16webInspectorShowEP8QWebPage @ 734 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt17pauseSVGAnimationEP9QWebFrameRK7QStringdS4_ @ 735 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt17webInspectorCloseEP8QWebPage @ 736 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt17workerThreadCountEv @ 737 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt18hasDocumentElementEP9QWebFrame @ 738 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt20dumpEditingCallbacksEb @ 739 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt21markerTextForListItemERK11QWebElement @ 740 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt22javaScriptObjectsCountEv @ 741 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt23setCaretBrowsingEnabledEP8QWebPageb @ 742 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt24executeCoreCommandByNameEP8QWebPageRK7QStringS4_ @ 743 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt21dumpSetAcceptsEditingEb @744 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt22resumeActiveDOMObjectsEP9QWebFrame @745 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt23suspendActiveDOMObjectsEP9QWebFrame @746 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt24numberOfActiveAnimationsEP9QWebFrame @747 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt24pageNumberForElementByIdEP9QWebFrameRK7QStringff @748 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt25dumpResourceLoadCallbacksEb @749 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt25pauseTransitionOfPropertyEP9QWebFrameRK7QStringdS4_ @750 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt25setFrameFlatteningEnabledEP8QWebPageb @751 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt25webInspectorExecuteScriptEP8QWebPagelRK7QString @752 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt25whiteListAccessFromOriginERK7QStringS2_S2_b @753 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt26counterValueForElementByIdEP9QWebFrameRK7QString @754 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt26firstRectForCharacterRangeEP8QWebPageii @755 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt26overwritePluginDirectoriesEv @756 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt27resetOriginAccessWhiteListsEv @757 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt27setSmartInsertDeleteEnabledEP8QWebPageb @758 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt27setTimelineProfilingEnabledEP8QWebPageb @759 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt28setDumpRenderTreeModeEnabledEb @760 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt29dumpResourceLoadCallbacksPathERK7QString @761 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt29evaluateScriptInIsolatedWorldEP9QWebFrameiRK7QString @762 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt29setJavaScriptProfilingEnabledEP9QWebFrameb @763 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt29setWillSendRequestReturnsNullEb @764 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt30setWillSendRequestClearHeadersERK11QStringList @765 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt33computedStyleIncludingVisitedInfoERK11QWebElement @766 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt34setSelectTrailingWhitespaceEnabledEP8QWebPageb @767 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt39elementDoesAutoCompleteForElementWithIdEP9QWebFrameRK7QString @768 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt39setWillSendRequestReturnsNullOnRedirectEb @769 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt40garbageCollectorCollectOnAlternateThreadEb @770 NONAME ABSENT
+	_ZN23DumpRenderTreeSupportQt40setDomainRelaxationForbiddenForURLSchemeEbRK7QString @771 NONAME ABSENT
diff --git a/src/3rdparty/webkit/WebKit/qt/tests/qwebframe/tst_qwebframe.cpp b/src/3rdparty/webkit/WebKit/qt/tests/qwebframe/tst_qwebframe.cpp
index bea7a67..76fdba3 100644
--- a/src/3rdparty/webkit/WebKit/qt/tests/qwebframe/tst_qwebframe.cpp
+++ b/src/3rdparty/webkit/WebKit/qt/tests/qwebframe/tst_qwebframe.cpp
@@ -600,7 +600,12 @@ private slots:
     void setHtmlWithBaseURL();
     void ipv6HostEncoding();
     void metaData();
+#if !defined(Q_WS_MAEMO_5)
+    // as maemo 5 does not use QComboBoxes to implement the popups
+    // this test does not make sense for it.
     void popupFocus();
+#endif
+    void inputFieldFocus();
     void hitTestContent();
     void jsByteArray();
     void ownership();
@@ -686,13 +691,13 @@ private:
     QWebView* m_view;
     QWebPage* m_page;
     MyQObject* m_myObject;
-    QWebView* m_popupTestView;
-    int m_popupTestPaintCount;
+    QWebView* m_inputFieldsTestView;
+    int m_inputFieldTestPaintCount;
 };
 
 tst_QWebFrame::tst_QWebFrame()
     : sTrue("true"), sFalse("false"), sUndefined("undefined"), sArray("array"), sFunction("function"), sError("error"),
-        sString("string"), sObject("object"), sNumber("number"), m_popupTestView(0), m_popupTestPaintCount(0)
+        sString("string"), sObject("object"), sNumber("number"), m_inputFieldsTestView(0), m_inputFieldTestPaintCount(0)
 {
 }
 
@@ -702,10 +707,10 @@ tst_QWebFrame::~tst_QWebFrame()
 
 bool tst_QWebFrame::eventFilter(QObject* watched, QEvent* event)
 {
-    // used on the popupFocus test
-    if (watched == m_popupTestView) {
+    // used on the inputFieldFocus test
+    if (watched == m_inputFieldsTestView) {
         if (event->type() == QEvent::Paint)
-            m_popupTestPaintCount++;
+            m_inputFieldTestPaintCount++;
     }
     return QObject::eventFilter(watched, event);
 }
@@ -780,7 +785,7 @@ void tst_QWebFrame::getSetStaticProperty()
         QCOMPARE(vm.size(), 3);
         QCOMPARE(vm.value("a").toInt(), 123);
         QCOMPARE(vm.value("b").toString(), QLatin1String("foo"));
-        QCOMPARE(vm.value("c").value<QObject*>(), m_myObject);
+        QCOMPARE(vm.value("c").value<QObject*>(), static_cast<QObject*>(m_myObject));
     }
     QCOMPARE(evalJS("myObject.variantMapProperty.a === 123"), sTrue);
     QCOMPARE(evalJS("myObject.variantMapProperty.b === 'foo'"), sTrue);
@@ -2549,6 +2554,7 @@ void tst_QWebFrame::metaData()
     QCOMPARE(metaData.value("nonexistant"), QString());
 }
 
+#if !defined(Q_WS_MAEMO_5)
 void tst_QWebFrame::popupFocus()
 {
     QWebView view;
@@ -2580,16 +2586,27 @@ void tst_QWebFrame::popupFocus()
     // hide the popup and check if focus is on the page
     combo->hidePopup();
     QTRY_VERIFY(view.hasFocus() && !combo->view()->hasFocus()); // Focus should be back on the WebView
+}
+#endif
+
+void tst_QWebFrame::inputFieldFocus()
+{
+    QWebView view;
+    view.setHtml("<html><body><input type=\"text\"></input></body></html>");
+    view.resize(400, 100);
+    view.show();
+    view.setFocus();
+    QTRY_VERIFY(view.hasFocus());
 
     // double the flashing time, should at least blink once already
     int delay = qApp->cursorFlashTime() * 2;
 
     // focus the lineedit and check if it blinks
-    QTest::mouseClick(&view, Qt::LeftButton, 0, QPoint(200, 25));
-    m_popupTestView = &view;
+    QTest::mouseClick(&view, Qt::LeftButton, 0, QPoint(25, 25));
+    m_inputFieldsTestView = &view;
     view.installEventFilter( this );
     QTest::qWait(delay);
-    QVERIFY2(m_popupTestPaintCount >= 3,
+    QVERIFY2(m_inputFieldTestPaintCount >= 3,
              "The input field should have a blinking caret");
 }
 
diff --git a/src/3rdparty/webkit/WebKit/qt/tests/qwebpage/tst_qwebpage.cpp b/src/3rdparty/webkit/WebKit/qt/tests/qwebpage/tst_qwebpage.cpp
index 12fb9b3..27f4b27 100644
--- a/src/3rdparty/webkit/WebKit/qt/tests/qwebpage/tst_qwebpage.cpp
+++ b/src/3rdparty/webkit/WebKit/qt/tests/qwebpage/tst_qwebpage.cpp
@@ -121,7 +121,8 @@ private slots:
     void originatingObjectInNetworkRequests();
     void testJSPrompt();
     void showModalDialog();
-
+    void testStopScheduledPageRefresh();
+    
 private:
     QWebView* m_view;
     QWebPage* m_page;
@@ -1450,11 +1451,16 @@ void tst_QWebPage::inputMethods()
     QString selectionValue = variant.value<QString>();
     QCOMPARE(selectionValue, QString("eb"));
 
-    //Set selection with negative length
-    inputAttributes << QInputMethodEvent::Attribute(QInputMethodEvent::Selection, 6, -5, QVariant());
+    //Cancel current composition first
+    inputAttributes << QInputMethodEvent::Attribute(QInputMethodEvent::Selection, 0, 0, QVariant());
     QInputMethodEvent eventSelection2("",inputAttributes);
     page->event(&eventSelection2);
 
+    //Set selection with negative length
+    inputAttributes << QInputMethodEvent::Attribute(QInputMethodEvent::Selection, 6, -5, QVariant());
+    QInputMethodEvent eventSelection3("",inputAttributes);
+    page->event(&eventSelection3);
+
     //ImAnchorPosition
     variant = page->inputMethodQuery(Qt::ImAnchorPosition);
     anchorPosition =  variant.toInt();
@@ -1492,6 +1498,98 @@ void tst_QWebPage::inputMethods()
     QCOMPARE(value, QString("QtWebKit"));
 #endif
 
+    // Cancel current composition first
+    inputAttributes << QInputMethodEvent::Attribute(QInputMethodEvent::Selection, 0, 0, QVariant());
+    QInputMethodEvent eventSelection4("", inputAttributes);
+    page->event(&eventSelection4);
+
+    // START - Tests for Selection when the Editor is NOT in Composition mode
+
+    // LEFT to RIGHT selection
+    // Deselect the selection by sending MouseButtonPress events
+    // This moves the current cursor to the end of the text
+    page->event(&evpres);
+    page->event(&evrel);
+
+    //Move to the start of the line
+    page->triggerAction(QWebPage::MoveToStartOfLine);
+
+    QKeyEvent keyRightEventPress(QEvent::KeyPress, Qt::Key_Right, Qt::NoModifier);
+    QKeyEvent keyRightEventRelease(QEvent::KeyRelease, Qt::Key_Right, Qt::NoModifier);
+
+    //Move 2 characters RIGHT
+    for (int j = 0; j < 2; ++j) {
+        page->event(&keyRightEventPress);
+        page->event(&keyRightEventRelease);
+    }
+
+    //Select to the end of the line
+    page->triggerAction(QWebPage::SelectEndOfLine);
+
+    //ImAnchorPosition QtWebKit
+    variant = page->inputMethodQuery(Qt::ImAnchorPosition);
+    anchorPosition =  variant.toInt();
+    QCOMPARE(anchorPosition, 2);
+
+    //ImCursorPosition
+    variant = page->inputMethodQuery(Qt::ImCursorPosition);
+    cursorPosition =  variant.toInt();
+    QCOMPARE(cursorPosition, 8);
+
+    //ImCurrentSelection
+    variant = page->inputMethodQuery(Qt::ImCurrentSelection);
+    selectionValue = variant.value<QString>();
+    QCOMPARE(selectionValue, QString("WebKit"));
+
+    //RIGHT to LEFT selection
+    //Deselect the selection (this moves the current cursor to the end of the text)
+    page->event(&evpres);
+    page->event(&evrel);
+
+    //ImAnchorPosition
+    variant = page->inputMethodQuery(Qt::ImAnchorPosition);
+    anchorPosition =  variant.toInt();
+    QCOMPARE(anchorPosition, 8);
+
+    //ImCursorPosition
+    variant = page->inputMethodQuery(Qt::ImCursorPosition);
+    cursorPosition =  variant.toInt();
+    QCOMPARE(cursorPosition, 8);
+
+    //ImCurrentSelection
+    variant = page->inputMethodQuery(Qt::ImCurrentSelection);
+    selectionValue = variant.value<QString>();
+    QCOMPARE(selectionValue, QString(""));
+
+    QKeyEvent keyLeftEventPress(QEvent::KeyPress, Qt::Key_Left, Qt::NoModifier);
+    QKeyEvent keyLeftEventRelease(QEvent::KeyRelease, Qt::Key_Left, Qt::NoModifier);
+
+    //Move 2 characters LEFT
+    for (int i = 0; i < 2; ++i) {
+        page->event(&keyLeftEventPress);
+        page->event(&keyLeftEventRelease);
+    }
+
+    //Select to the start of the line
+    page->triggerAction(QWebPage::SelectStartOfLine);
+
+    //ImAnchorPosition
+    variant = page->inputMethodQuery(Qt::ImAnchorPosition);
+    anchorPosition =  variant.toInt();
+    QCOMPARE(anchorPosition, 6);
+
+    //ImCursorPosition
+    variant = page->inputMethodQuery(Qt::ImCursorPosition);
+    cursorPosition =  variant.toInt();
+    QCOMPARE(cursorPosition, 0);
+
+    //ImCurrentSelection
+    variant = page->inputMethodQuery(Qt::ImCurrentSelection);
+    selectionValue = variant.value<QString>();
+    QCOMPARE(selectionValue, QString("QtWebK"));
+
+    //END - Tests for Selection when the Editor is not in Composition mode
+
     //ImhHiddenText
     QMouseEvent evpresPassword(QEvent::MouseButtonPress, inputs.at(1).geometry().center(), Qt::LeftButton, Qt::NoButton, Qt::NoModifier);
     page->event(&evpresPassword);
@@ -1998,5 +2096,30 @@ void tst_QWebPage::showModalDialog()
     QCOMPARE(res, QString("This is a test"));
 }
 
+void tst_QWebPage::testStopScheduledPageRefresh()
+{    
+    // Without QWebPage::StopScheduledPageRefresh
+    QWebPage page1;
+    page1.setNetworkAccessManager(new TestNetworkManager(&page1));
+    page1.mainFrame()->setHtml("<html><head>"
+                                "<meta http-equiv=\"refresh\"content=\"0;URL=http://qt.nokia.com/favicon.ico\">"
+                                "</head><body><h1>Page redirects immediately...</h1>"
+                                "</body></html>");
+    QVERIFY(::waitForSignal(&page1, SIGNAL(loadFinished(bool))));
+    QTest::qWait(500);
+    QCOMPARE(page1.mainFrame()->url().toString(), QString("http://qt.nokia.com/favicon.ico"));
+    
+    // With QWebPage::StopScheduledPageRefresh
+    QWebPage page2;
+    page2.setNetworkAccessManager(new TestNetworkManager(&page2));
+    page2.mainFrame()->setHtml("<html><head>"
+                               "<meta http-equiv=\"refresh\"content=\"1;URL=http://qt.nokia.com/favicon.ico\">"
+                               "</head><body><h1>Page redirect test with 1 sec timeout...</h1>"
+                               "</body></html>");
+    page2.triggerAction(QWebPage::StopScheduledPageRefresh);
+    QTest::qWait(1500);
+    QCOMPARE(page2.mainFrame()->url().toString(), QString("about:blank"));
+}
+
 QTEST_MAIN(tst_QWebPage)
 #include "tst_qwebpage.moc"
diff --git a/src/corelib/arch/qatomic_alpha.h b/src/corelib/arch/qatomic_alpha.h
index 5d0b2b6..6989c25 100644
--- a/src/corelib/arch/qatomic_alpha.h
+++ b/src/corelib/arch/qatomic_alpha.h
@@ -367,7 +367,7 @@ Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetRelease(T *expectedValu
 template <typename T>
 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreRelaxed(T *newValue)
 {
-    register void *old, *tmp;
+    register T *old, *tmp;
     asm volatile("1:\n"
                  "ldq_l %0,%2\n"   /* old=*ptr;                               */
                  "mov   %3,%1\n"   /* tmp=newval;                             */
@@ -385,7 +385,7 @@ Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreRelaxed(T *newValue)
 template <typename T>
 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreAcquire(T *newValue)
 {
-    register void *old, *tmp;
+    register T *old, *tmp;
     asm volatile("1:\n"
                  "ldq_l %0,%2\n"   /* old=*ptr;                               */
                  "mov   %3,%1\n"   /* tmp=newval;                             */
@@ -404,7 +404,7 @@ Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreAcquire(T *newValue)
 template <typename T>
 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreRelease(T *newValue)
 {
-    register void *old, *tmp;
+    register T *old, *tmp;
     asm volatile("mb\n"
                  "1:\n"
                  "ldq_l %0,%2\n"   /* old=*ptr;                               */
@@ -423,7 +423,7 @@ Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreRelease(T *newValue)
 template <typename T>
 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddRelaxed(qptrdiff valueToAdd)
 {
-    register void *old, *tmp;
+    register T *old, *tmp;
     asm volatile("1:\n"
                  "ldq_l %0,%2\n"   /* old=*ptr;                               */
                  "addq  %0,%3,%1\n"/* tmp=old+value;                          */
@@ -441,7 +441,7 @@ Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddRelaxed(qptrdiff valueTo
 template <typename T>
 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddAcquire(qptrdiff valueToAdd)
 {
-    register void *old, *tmp;
+    register T *old, *tmp;
     asm volatile("1:\n"
                  "ldq_l %0,%2\n"   /* old=*ptr;                               */
                  "addq  %0,%3,%1\n"/* tmp=old+value;                          */
@@ -460,7 +460,7 @@ Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddAcquire(qptrdiff valueTo
 template <typename T>
 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddRelease(qptrdiff valueToAdd)
 {
-    register void *old, *tmp;
+    register T *old, *tmp;
     asm volatile("mb\n"
                  "1:\n"
                  "ldq_l %0,%2\n"   /* old=*ptr;                               */
diff --git a/src/corelib/global/qconfig-medium.h b/src/corelib/global/qconfig-medium.h
index ccd6759..6cb6c2c 100644
--- a/src/corelib/global/qconfig-medium.h
+++ b/src/corelib/global/qconfig-medium.h
@@ -213,6 +213,9 @@
 #ifndef QT_NO_UNDOVIEW
 #  define QT_NO_UNDOVIEW
 #endif
+#ifndef QT_NO_GESTURES
+#  define QT_NO_GESTURES
+#endif
 
 /* Widgets */
 #ifndef QT_NO_LCDNUMBER
diff --git a/src/corelib/global/qconfig-minimal.h b/src/corelib/global/qconfig-minimal.h
index 99b16e8..c285e99 100644
--- a/src/corelib/global/qconfig-minimal.h
+++ b/src/corelib/global/qconfig-minimal.h
@@ -447,6 +447,9 @@
 #ifndef QT_NO_UNDOVIEW
 #  define QT_NO_UNDOVIEW
 #endif
+#ifndef QT_NO_GESTURES
+#  define QT_NO_GESTURES
+#endif
 
 /* Widgets */
 #ifndef QT_NO_GROUPBOX
diff --git a/src/corelib/global/qconfig-small.h b/src/corelib/global/qconfig-small.h
index 1716b8d..dd74dcf 100644
--- a/src/corelib/global/qconfig-small.h
+++ b/src/corelib/global/qconfig-small.h
@@ -250,6 +250,9 @@
 #ifndef QT_NO_SYSTEMTRAYICON
 #  define QT_NO_SYSTEMTRAYICON
 #endif
+#ifndef QT_NO_GESTURES
+#  define QT_NO_GESTURES
+#endif
 
 /* Widgets */
 #ifndef QT_NO_LCDNUMBER
diff --git a/src/corelib/global/qfeatures.h b/src/corelib/global/qfeatures.h
index a333153..b606843 100644
--- a/src/corelib/global/qfeatures.h
+++ b/src/corelib/global/qfeatures.h
@@ -85,6 +85,9 @@
 // Freetype Font Engine
 //#define QT_NO_FREETYPE
 
+// Gesture
+//#define QT_NO_GESTURES
+
 // QGroupBox
 //#define QT_NO_GROUPBOX
 
diff --git a/src/corelib/global/qfeatures.txt b/src/corelib/global/qfeatures.txt
index 3e6af24..4d938a9 100644
--- a/src/corelib/global/qfeatures.txt
+++ b/src/corelib/global/qfeatures.txt
@@ -1185,6 +1185,12 @@ Requires: PROPERTIES
 Name: State machine
 SeeAlso: ???
 
+Feature: GESTURES
+Description: Provides a framework for gestures.
+Section: Utilities
+Requires:
+Name: Gesture
+SeeAlso: ???
 
 # SVG
 
diff --git a/src/corelib/global/qglobal.h b/src/corelib/global/qglobal.h
index 31f8b85..1eab394 100644
--- a/src/corelib/global/qglobal.h
+++ b/src/corelib/global/qglobal.h
@@ -2425,6 +2425,9 @@ QT3_SUPPORT Q_CORE_EXPORT const char *qInstallPathSysconf();
 #if defined(Q_OS_SYMBIAN)
 
 #ifdef SYMBIAN_BUILD_GCE
+#define Q_SYMBIAN_SUPPORTS_SURFACES
+//RWsPointerCursor is fixed, so don't use low performance sprites
+#define Q_SYMBIAN_FIXED_POINTER_CURSORS
 #define Q_SYMBIAN_HAS_EXTENDED_BITMAP_TYPE
 #define Q_SYMBIAN_WINDOW_SIZE_CACHE
 #define QT_SYMBIAN_SUPPORTS_ADVANCED_POINTER
diff --git a/src/corelib/global/qnamespace.h b/src/corelib/global/qnamespace.h
index 08674d2..a12e121 100644
--- a/src/corelib/global/qnamespace.h
+++ b/src/corelib/global/qnamespace.h
@@ -236,7 +236,8 @@ public:
         TextJustificationForced = 0x10000,
         TextForceLeftToRight = 0x20000,
         TextForceRightToLeft = 0x40000,
-        TextLongestVariant = 0x80000
+        TextLongestVariant = 0x80000,
+        TextBypassShaping = 0x100000
 
 #if defined(QT3_SUPPORT) && !defined(Q_MOC_RUN)
         ,SingleLine = TextSingleLine,
@@ -947,6 +948,8 @@ public:
 #endif
         Key_MediaNext  = 0x01000083,
         Key_MediaRecord = 0x01000084,
+        Key_MediaPause = 0x1000085,
+        Key_MediaTogglePlayPause = 0x1000086,
         Key_HomePage  = 0x01000090,
         Key_Favorites  = 0x01000091,
         Key_Search  = 0x01000092,
@@ -1089,11 +1092,15 @@ public:
         Key_Context2 = 0x01100001,
         Key_Context3 = 0x01100002,
         Key_Context4 = 0x01100003,
-        Key_Call = 0x01100004,
-        Key_Hangup = 0x01100005,
+        Key_Call = 0x01100004,      // set absolute state to in a call (do not toggle state)
+        Key_Hangup = 0x01100005,    // set absolute state to hang up (do not toggle state)
         Key_Flip = 0x01100006,
-        Key_Camera = 0x01100007,
-        Key_CameraFocus = 0x01100008,
+        Key_ToggleCallHangup = 0x01100007, // a toggle key for answering, or hanging up, based on current call state
+        Key_VoiceDial = 0x01100008,
+        Key_LastNumberRedial = 0x01100009,
+
+        Key_Camera = 0x01100020,
+        Key_CameraFocus = 0x01100021,
 
         Key_unknown = 0x01ffffff
     };
@@ -1554,7 +1561,8 @@ public:
 
     enum LayoutDirection {
         LeftToRight,
-        RightToLeft
+        RightToLeft,
+        LayoutDirectionAuto
     };
 
     enum AnchorPoint {
@@ -1719,6 +1727,7 @@ public:
     };
     Q_DECLARE_FLAGS(TouchPointStates, TouchPointState)
 
+#ifndef QT_NO_GESTURES
     enum GestureState
     {
         NoGesture,
@@ -1748,6 +1757,7 @@ public:
         IgnoredGesturesPropagateToParent = 0x04
     };
     Q_DECLARE_FLAGS(GestureFlags, GestureFlag)
+#endif // QT_NO_GESTURES
 
     enum NavigationMode
     {
@@ -1777,7 +1787,9 @@ Q_DECLARE_OPERATORS_FOR_FLAGS(Qt::MatchFlags)
 Q_DECLARE_OPERATORS_FOR_FLAGS(Qt::TextInteractionFlags)
 Q_DECLARE_OPERATORS_FOR_FLAGS(Qt::InputMethodHints)
 Q_DECLARE_OPERATORS_FOR_FLAGS(Qt::TouchPointStates)
+#ifndef QT_NO_GESTURES
 Q_DECLARE_OPERATORS_FOR_FLAGS(Qt::GestureFlags)
+#endif
 
 typedef bool (*qInternalCallback)(void **);
 
diff --git a/src/corelib/global/qnamespace.qdoc b/src/corelib/global/qnamespace.qdoc
index f71ba9d..abbc03e 100644
--- a/src/corelib/global/qnamespace.qdoc
+++ b/src/corelib/global/qnamespace.qdoc
@@ -1317,7 +1317,7 @@
     \value Key_Enter     Typically located on the keypad.
     \value Key_Insert
     \value Key_Delete
-    \value Key_Pause
+    \value Key_Pause    The Pause/Break key (\note Not anything to do with pausing media)
     \value Key_Print
     \value Key_SysReq
     \value Key_Clear
@@ -1615,12 +1615,14 @@
     \value Key_BassDown
     \value Key_TrebleUp
     \value Key_TrebleDown
-    \value Key_MediaPlay
-    \value Key_MediaStop
+    \value Key_MediaPlay    A key setting the state of the media player to play
+    \value Key_MediaStop    A key setting the state of the media player to stop
     \value Key_MediaPrevious
     \omitvalue Key_MediaPrev
     \value Key_MediaNext
     \value Key_MediaRecord
+    \value Key_MediaPause   A key setting the state of the media player to pause (\note not the pause/break key)
+    \value Key_MediaTogglePlayPause   A key to toggle the play/pause state in the media player (rather than setting an absolute state)
     \value Key_HomePage
     \value Key_Favorites
     \value Key_Search
@@ -1741,18 +1743,21 @@
     \value Key_MediaLast
     \value Key_unknown
 
-    \value Key_Call
-    \value Key_Camera
-    \value Key_CameraFocus
+    \value Key_Call     A key to answer or initiate a call (\see Key_ToggleCallHangup for a key to toggle current call state)
+    \value Key_Camera   A key to activate the camera shutter
+    \value Key_CameraFocus  A key to focus the camera
     \value Key_Context1
     \value Key_Context2
     \value Key_Context3
     \value Key_Context4
     \value Key_Flip
-    \value Key_Hangup
+    \value Key_Hangup   A key to end an ongoing call (\see Key_ToggleCallHangup for a key to toggle current call state)
     \value Key_No
     \value Key_Select
     \value Key_Yes
+    \value Key_ToggleCallHangup A key to toggle the current call state (ie. either answer, or hangup) depending on current call state
+    \value Key_VoiceDial
+    \value Key_LastNumberRedial
 
     \value Key_Execute
     \value Key_Printer
@@ -2567,15 +2572,23 @@
 /*!
     \enum Qt::LayoutDirection
 
-    Specifies the direction of Qt's layouts:
+    Specifies the direction of Qt's layouts and text handling.
 
     \value LeftToRight  Left-to-right layout.
     \value RightToLeft  Right-to-left layout.
+    \value LayoutDirectionAuto   Automatic layout.
 
     Right-to-left layouts are necessary for certain languages,
     notably Arabic and Hebrew.
 
-    \sa QApplication::setLayoutDirection(), QWidget::setLayoutDirection()
+    LayoutDirectionAuto serves two purposes. When used in conjunction with widgets and layouts, it
+    will imply to use the layout direction set on the parent widget or QApplication. This
+    has the same effect as QWidget::unsetLayoutDirection().
+
+    When LayoutDirectoinAuto is used in conjunction with text layouting, it will imply that the text
+    directionality is determined from the content of the string to be layouted.
+
+    \sa QApplication::setLayoutDirection(), QWidget::setLayoutDirection(), QTextOption::setTextDirection(), QString::isRightToLeft()
 */
 
 /*!
diff --git a/src/corelib/io/qresource.cpp b/src/corelib/io/qresource.cpp
index 8e76e9e..ce9c57e 100644
--- a/src/corelib/io/qresource.cpp
+++ b/src/corelib/io/qresource.cpp
@@ -928,7 +928,7 @@ public:
     }
 };
 
-#if defined(Q_OS_UNIX)
+#if defined(Q_OS_UNIX) && !defined(Q_OS_SYMBIAN)
 #define QT_USE_MMAP
 #endif
 
diff --git a/src/corelib/kernel/qabstractitemmodel.cpp b/src/corelib/kernel/qabstractitemmodel.cpp
index 24c26b6..b0e2f48 100644
--- a/src/corelib/kernel/qabstractitemmodel.cpp
+++ b/src/corelib/kernel/qabstractitemmodel.cpp
@@ -2508,29 +2508,35 @@ bool QAbstractItemModelPrivate::allowMove(const QModelIndex &srcParent, int star
     When reimplementing a subclass, this method simplifies moving
     entities in your model. This method is responsible for moving
     persistent indexes in the model, which you would otherwise be
-    required to do yourself.
-
-    Using beginMoveRows and endMoveRows is an alternative to emitting
-    layoutAboutToBeChanged and layoutChanged directly along with
-    changePersistentIndexes.  layoutAboutToBeChanged is emitted by
-    this method for compatibility reasons.
+    required to do yourself. Using beginMoveRows and endMoveRows
+    is an alternative to emitting layoutAboutToBeChanged and
+    layoutChanged directly along with changePersistentIndexes.
+    layoutAboutToBeChanged is emitted by this method for compatibility
+    reasons.
 
     The \a sourceParent index corresponds to the parent from which the
-    rows are moved; \a sourceFirst and \a sourceLast are the row
-    numbers of the rows to be moved. The \a destinationParent index
-    corresponds to the parent into which the rows are moved. The \a
+    rows are moved; \a sourceFirst and \a sourceLast are the first and last
+    row numbers of the rows to be moved. The \a destinationParent index
+    corresponds to the parent into which those rows are moved. The \a
     destinationChild is the row to which the rows will be moved.  That
     is, the index at row \a sourceFirst in \a sourceParent will become
-    row \a destinationChild in \a destinationParent. Its siblings will
-    be moved correspondingly.
-
-    Note that \a sourceParent and \a destinationParent may be the
-    same, in which case you must ensure that the \a destinationChild is
-    not within the range of \a sourceFirst and \a sourceLast.  You
-    must also ensure that you do not attempt to move a row to one of
-    its own children or ancestors.  This method returns false if either
-    condition is true, in which case you should abort your move
-    operation.
+    row \a destinationChild in \a destinationParent, followed by all other
+    rows up to \a sourceLast.
+
+    However, when moving rows down in the same parent (\a sourceParent
+    and \a destinationParent are equal), the rows will be placed before the
+    \a destinationChild index. That is, if you wish to move rows 0 and 1 so
+    they will become rows 1 and 2, \a destinationChild should be 3. In this
+    case, the new index for the source row \c i (which is between
+    \a sourceFirst and \a sourceLast) is equal to
+    \c {(destinationChild-sourceLast-1+i)}.
+
+    Note that if \a sourceParent and \a destinationParent are the same,
+    you must ensure that the \a destinationChild is not within the range
+    of \a sourceFirst and \a sourceLast + 1.  You must also ensure that you
+    do not attempt to move a row to one of its own children or ancestors.
+    This method returns false if either condition is true, in which case you
+    should abort your move operation.
 
     \table 80%
     \row
@@ -2761,29 +2767,35 @@ void QAbstractItemModel::endRemoveColumns()
     When reimplementing a subclass, this method simplifies moving
     entities in your model. This method is responsible for moving
     persistent indexes in the model, which you would otherwise be
-    required to do yourself.
-
-    Using beginMoveColumns and endMoveColumns is an alternative to
-    emitting layoutAboutToBeChanged and layoutChanged directly along
-    with changePersistentIndexes.  layoutAboutToBeChanged is emitted
-    by this method for compatibility reasons.
+    required to do yourself. Using beginMoveRows and endMoveRows
+    is an alternative to emitting layoutAboutToBeChanged and
+    layoutChanged directly along with changePersistentIndexes.
+    layoutAboutToBeChanged is emitted by this method for compatibility
+    reasons.
 
     The \a sourceParent index corresponds to the parent from which the
-    columns are moved; \a sourceFirst and \a sourceLast are the column
-    numbers of the columns to be moved. The \a destinationParent index
-    corresponds to the parent into which the columns are moved. The \a
-    destinationChild is the column to which the columns will be
-    moved.  That is, the index at column \a sourceFirst in \a
-    sourceParent will become column \a destinationChild in \a
-    destinationParent. Its siblings will be moved correspondingly.
-
-    Note that \a sourceParent and \a destinationParent may be the
-    same, in which case you must ensure that the \a destinationChild
-    is not within the range of \a sourceFirst and \a sourceLast.  You
-    must also ensure that you do not attempt to move a row to one of
-    its own chilren or ancestors.  This method returns false if either
-    condition is true, in which case you should abort your move
-    operation.
+    columns are moved; \a sourceFirst and \a sourceLast are the first and last
+    column numbers of the columns to be moved. The \a destinationParent index
+    corresponds to the parent into which those columns are moved. The \a
+    destinationChild is the column to which the columns will be moved.  That
+    is, the index at column \a sourceFirst in \a sourceParent will become
+    column \a destinationChild in \a destinationParent, followed by all other
+    columns up to \a sourceLast.
+
+    However, when moving columns down in the same parent (\a sourceParent
+    and \a destinationParent are equal), the columnss will be placed before the
+    \a destinationChild index. That is, if you wish to move columns 0 and 1 so
+    they will become columns 1 and 2, \a destinationChild should be 3. In this
+    case, the new index for the source column \c i (which is between
+    \a sourceFirst and \a sourceLast) is equal to
+    \c {(destinationChild-sourceLast-1+i)}.
+
+    Note that if \a sourceParent and \a destinationParent are the same,
+    you must ensure that the \a destinationChild is not within the range
+    of \a sourceFirst and \a sourceLast + 1.  You must also ensure that you
+    do not attempt to move a column to one of its own children or ancestors.
+    This method returns false if either condition is true, in which case you
+    should abort your move operation.
 
     \sa endMoveColumns()
 
diff --git a/src/corelib/kernel/qcoreevent.h b/src/corelib/kernel/qcoreevent.h
index a20d171..9d3513a 100644
--- a/src/corelib/kernel/qcoreevent.h
+++ b/src/corelib/kernel/qcoreevent.h
@@ -275,17 +275,19 @@ public:
         TouchUpdate = 195,
         TouchEnd = 196,
 
+#ifndef QT_NO_GESTURES
         NativeGesture = 197,                    // Internal for platform gesture support
-
+#endif
         RequestSoftwareInputPanel = 199,
         CloseSoftwareInputPanel = 200,
 
         UpdateSoftKeys = 201,                   // Internal for compressing soft key updates
 
         WinIdChange = 203,
+#ifndef QT_NO_GESTURES
         Gesture = 198,
         GestureOverride = 202,
-
+#endif
         // 512 reserved for Qt Jambi's MetaCall event
         // 513 reserved for Qt Jambi's DeleteOnMainThread event
 
@@ -327,7 +329,9 @@ private:
     friend class QGraphicsView;
     friend class QGraphicsViewPrivate;
     friend class QGraphicsScenePrivate;
+#ifndef QT_NO_GESTURES
     friend class QGestureManager;
+#endif
 };
 
 class Q_CORE_EXPORT QTimerEvent : public QEvent
diff --git a/src/corelib/kernel/qeventdispatcher_symbian.cpp b/src/corelib/kernel/qeventdispatcher_symbian.cpp
index 1cb8455..9d8ee5a 100644
--- a/src/corelib/kernel/qeventdispatcher_symbian.cpp
+++ b/src/corelib/kernel/qeventdispatcher_symbian.cpp
@@ -484,9 +484,9 @@ void QSelectThread::run()
                 } // end for
 
                 // traversed all, so update
+                updateActivatedNotifiers(QSocketNotifier::Exception, &exceptionfds);
                 updateActivatedNotifiers(QSocketNotifier::Read, &readfds);
                 updateActivatedNotifiers(QSocketNotifier::Write, &writefds);
-                updateActivatedNotifiers(QSocketNotifier::Exception, &exceptionfds);
 
                 break;
             case EINTR: // Should never occur on Symbian, but this is future proof!
@@ -496,9 +496,9 @@ void QSelectThread::run()
                 break;
             }
         } else {
+            updateActivatedNotifiers(QSocketNotifier::Exception, &exceptionfds);
             updateActivatedNotifiers(QSocketNotifier::Read, &readfds);
             updateActivatedNotifiers(QSocketNotifier::Write, &writefds);
-            updateActivatedNotifiers(QSocketNotifier::Exception, &exceptionfds);
         }
 
         m_waitCond.wait(&m_mutex);
diff --git a/src/corelib/kernel/qeventdispatcher_win.cpp b/src/corelib/kernel/qeventdispatcher_win.cpp
index 135ec303..cede810 100644
--- a/src/corelib/kernel/qeventdispatcher_win.cpp
+++ b/src/corelib/kernel/qeventdispatcher_win.cpp
@@ -71,10 +71,12 @@ extern uint qGlobalPostedEventsCount();
 #ifndef WM_TOUCH
 #  define WM_TOUCH 0x0240
 #endif
+#ifndef QT_NO_GESTURES
 #ifndef WM_GESTURE
 #  define WM_GESTURE 0x0119
 #  define WM_GESTURENOTIFY 0x011A
 #endif
+#endif // QT_NO_GESTURES
 
 enum {
     WM_QT_SOCKETNOTIFIER = WM_USER,
@@ -738,8 +740,10 @@ bool QEventDispatcherWin32::processEvents(QEventLoop::ProcessEventsFlags flags)
                         || msg.message == WM_MOUSEWHEEL
                         || msg.message == WM_MOUSEHWHEEL
                         || msg.message == WM_TOUCH
+#ifndef QT_NO_GESTURES
                         || msg.message == WM_GESTURE
                         || msg.message == WM_GESTURENOTIFY
+#endif
                         || msg.message == WM_CLOSE)) {
                     // queue user input events for later processing
                     haveMessage = false;
diff --git a/src/corelib/kernel/qeventloop.cpp b/src/corelib/kernel/qeventloop.cpp
index 628afa7..c19f718 100644
--- a/src/corelib/kernel/qeventloop.cpp
+++ b/src/corelib/kernel/qeventloop.cpp
@@ -43,7 +43,7 @@
 
 #include "qabstracteventdispatcher.h"
 #include "qcoreapplication.h"
-#include "qdatetime.h"
+#include "qelapsedtimer.h"
 
 #include "qobject_p.h"
 #include <private/qthread_p.h>
@@ -247,7 +247,7 @@ void QEventLoop::processEvents(ProcessEventsFlags flags, int maxTime)
     if (!d->threadData->eventDispatcher)
         return;
 
-    QTime start;
+    QElapsedTimer start;
     start.start();
     if (flags & DeferredDeletion)
         QCoreApplication::sendPostedEvents(0, QEvent::DeferredDelete);
diff --git a/src/corelib/kernel/qtranslator.cpp b/src/corelib/kernel/qtranslator.cpp
index ca54c6c..1321b14 100644
--- a/src/corelib/kernel/qtranslator.cpp
+++ b/src/corelib/kernel/qtranslator.cpp
@@ -56,7 +56,7 @@
 #include "qhash.h"
 #include "qtranslator_p.h"
 
-#if defined(Q_OS_UNIX)
+#if defined(Q_OS_UNIX) && !defined(Q_OS_SYMBIAN)
 #define QT_USE_MMAP
 #include "private/qcore_unix_p.h"
 #endif
diff --git a/src/corelib/tools/qelapsedtimer.cpp b/src/corelib/tools/qelapsedtimer.cpp
index 28dfc23..cb5e701 100644
--- a/src/corelib/tools/qelapsedtimer.cpp
+++ b/src/corelib/tools/qelapsedtimer.cpp
@@ -137,7 +137,7 @@ QT_BEGIN_NAMESPACE
     used.
 
     \value SystemTime       The human-readable system time. This clock is not monotonic.
-    \value MonotonicClock   The system's monotonic clock, usually found in Unix systems. This clock is not monotonic and does not overflow.
+    \value MonotonicClock   The system's monotonic clock, usually found in Unix systems. This clock is monotonic and does not overflow.
     \value TickCounter      The system's tick counter, used on Windows and Symbian systems. This clock may overflow.
     \value MachAbsoluteTime The Mach kernel's absolute time (Mac OS X). This clock is monotonic and does not overflow.
 
diff --git a/src/corelib/tools/qhash.h b/src/corelib/tools/qhash.h
index 3374c80..0777f06 100644
--- a/src/corelib/tools/qhash.h
+++ b/src/corelib/tools/qhash.h
@@ -931,7 +931,7 @@ public:
     { return QHash<Key, T>::insertMulti(key, value); }
 
     inline QMultiHash &operator+=(const QMultiHash &other)
-    { unite(other); return *this; }
+    { this->unite(other); return *this; }
     inline QMultiHash operator+(const QMultiHash &other) const
     { QMultiHash result = *this; result += other; return result; }
 
@@ -1006,12 +1006,7 @@ Q_INLINE_TEMPLATE int QMultiHash<Key, T>::remove(const Key &key, const T &value)
     typename QHash<Key, T>::iterator end(QHash<Key, T>::end());
     while (i != end && i.key() == key) {
         if (i.value() == value) {
-#if defined(Q_CC_RVCT)
-            // RVCT has problems with scoping, apparently.
-            i = QHash<Key, T>::erase(i);
-#else
-            i = erase(i);
-#endif
+            i = this->erase(i);
             ++n;
         } else {
             ++i;
diff --git a/src/corelib/tools/qlocale.cpp b/src/corelib/tools/qlocale.cpp
index c000dc8..a51ee81 100644
--- a/src/corelib/tools/qlocale.cpp
+++ b/src/corelib/tools/qlocale.cpp
@@ -3478,6 +3478,25 @@ QLocale::MeasurementSystem QLocale::measurementSystem() const
 }
 
 /*!
+  \since 4.7
+
+  Returns the text direction of the language.
+*/
+Qt::LayoutDirection QLocale::textDirection() const
+{
+    Language lang = language();
+    if (lang == QLocale::Arabic ||
+        lang == QLocale::Hebrew ||
+        lang == QLocale::Persian ||
+        lang == QLocale::Urdu ||
+        lang == QLocale::Syriac)
+        return Qt::RightToLeft;
+
+    return Qt::LeftToRight;
+}
+
+
+/*!
     \since 4.5
 
     Returns the localized name of the "AM" suffix for times specified using
diff --git a/src/corelib/tools/qlocale.h b/src/corelib/tools/qlocale.h
index f2fd892..8b424bb 100644
--- a/src/corelib/tools/qlocale.h
+++ b/src/corelib/tools/qlocale.h
@@ -666,6 +666,8 @@ public:
 
     MeasurementSystem measurementSystem() const;
 
+    Qt::LayoutDirection textDirection() const;
+
     inline bool operator==(const QLocale &other) const;
     inline bool operator!=(const QLocale &other) const;
 
diff --git a/src/corelib/tools/qmap.h b/src/corelib/tools/qmap.h
index 5696ba6..e4b73a1 100644
--- a/src/corelib/tools/qmap.h
+++ b/src/corelib/tools/qmap.h
@@ -977,7 +977,7 @@ public:
     { return QMap<Key, T>::insertMulti(key, value); }
 
     inline QMultiMap &operator+=(const QMultiMap &other)
-    { unite(other); return *this; }
+    { this->unite(other); return *this; }
     inline QMultiMap operator+(const QMultiMap &other) const
     { QMultiMap result = *this; result += other; return result; }
 
@@ -1052,12 +1052,7 @@ Q_INLINE_TEMPLATE int QMultiMap<Key, T>::remove(const Key &key, const T &value)
     typename QMap<Key, T>::iterator end(QMap<Key, T>::end());
     while (i != end && !qMapLessThanKey<Key>(key, i.key())) {
         if (i.value() == value) {
-#if defined(Q_CC_RVCT)
-            // RVCT has problems with scoping, apparently.
-            i = QMap<Key, T>::erase(i);
-#else
-            i = erase(i);
-#endif
+            i = this->erase(i);
             ++n;
         } else {
             ++i;
diff --git a/src/corelib/tools/qstring.cpp b/src/corelib/tools/qstring.cpp
index 6acbcec..1d5fab3 100644
--- a/src/corelib/tools/qstring.cpp
+++ b/src/corelib/tools/qstring.cpp
@@ -113,7 +113,7 @@ int qFindStringBoyerMoore(const QChar *haystack, int haystackLen, int from,
 static int ucstricmp(const ushort *a, const ushort *ae, const ushort *b, const ushort *be)
 {
     if (a == b)
-        return 0;
+        return (ae - be);
     if (a == 0)
         return 1;
     if (b == 0)
@@ -125,7 +125,7 @@ static int ucstricmp(const ushort *a, const ushort *ae, const ushort *b, const u
 
     uint alast = 0;
     uint blast = 0;
-    while (a != e) {
+    while (a < e) {
 //         qDebug() << hex << alast << blast;
 //         qDebug() << hex << "*a=" << *a << "alast=" << alast << "folded=" << foldCase (*a, alast);
 //         qDebug() << hex << "*b=" << *b << "blast=" << blast << "folded=" << foldCase (*b, blast);
@@ -154,7 +154,7 @@ static int ucstricmp(const ushort *a, const ushort *ae, const uchar *b)
     if (b == 0)
         return -1;
 
-    while (a != ae && *b) {
+    while (a < ae && *b) {
         int diff = foldCase(*a) - foldCase(*b);
         if ((diff))
             return diff;
@@ -4640,9 +4640,12 @@ int QString::compare_helper(const QChar *data1, int length1, QLatin1String s2,
         return length1;
 
     if (cs == Qt::CaseSensitive) {
-        while (uc != e && *c && *uc == *c)
+        while (uc < e && *c && *uc == *c)
             uc++, c++;
 
+        if (uc == e)
+            return -*c;
+
         return *uc - *c;
     } else {
         return ucstricmp(uc, e, c);
@@ -6913,20 +6916,23 @@ void QString::updateProperties() const
         p++;
     }
 
-    p = d->data;
-    d->righttoleft = false;
+    d->righttoleft = isRightToLeft();
+    d->clean = true;
+}
+
+bool QString::isRightToLeft() const
+{
+    ushort *p = d->data;
+    const ushort * const end = p + d->size;
+    bool righttoleft = false;
     while (p < end) {
         switch(QChar::direction(*p))
         {
         case QChar::DirL:
-        case QChar::DirLRO:
-        case QChar::DirLRE:
             goto end;
         case QChar::DirR:
         case QChar::DirAL:
-        case QChar::DirRLO:
-        case QChar::DirRLE:
-            d->righttoleft = true;
+            righttoleft = true;
             goto end;
         default:
             break;
@@ -6934,8 +6940,7 @@ void QString::updateProperties() const
         ++p;
     }
  end:
-    d->clean = true;
-    return;
+    return righttoleft;
 }
 
 /*! \fn bool QString::isSimpleText() const
@@ -7093,7 +7098,7 @@ QString QString::fromRawData(const QChar *unicode, int size)
 */
 QString &QString::setRawData(const QChar *unicode, int size)
 {
-    if (d->ref != 1 || d->alloc) {
+    if (d->ref != 1 || (d->data == d->array && d->alloc)) {
         *this = fromRawData(unicode, size);
     } else {
 #ifdef QT3_SUPPORT
diff --git a/src/corelib/tools/qstring.h b/src/corelib/tools/qstring.h
index a1c4e77..e52f59f 100644
--- a/src/corelib/tools/qstring.h
+++ b/src/corelib/tools/qstring.h
@@ -590,7 +590,7 @@ public:
 #endif
 
     bool isSimpleText() const { if (!d->clean) updateProperties(); return d->simpletext; }
-    bool isRightToLeft() const { if (!d->clean) updateProperties(); return d->righttoleft; }
+    bool isRightToLeft() const;
 
     QString(int size, Qt::Initialization);
 
diff --git a/src/corelib/tools/qvarlengtharray.h b/src/corelib/tools/qvarlengtharray.h
index 9773d4b..4a6bb4b 100644
--- a/src/corelib/tools/qvarlengtharray.h
+++ b/src/corelib/tools/qvarlengtharray.h
@@ -127,14 +127,21 @@ public:
     inline T *data() { return ptr; }
     inline const T *data() const { return ptr; }
     inline const T * constData() const { return ptr; }
+    typedef int size_type;
+    typedef T value_type;
+    typedef value_type *pointer;
+    typedef const value_type *const_pointer;
+    typedef value_type &reference;
+    typedef const value_type &const_reference;
+    typedef qptrdiff difference_type;
 
 private:
     friend class QPodList<T, Prealloc>;
     void realloc(int size, int alloc);
 
-    int a;
-    int s;
-    T *ptr;
+    int a;      // capacity
+    int s;      // size
+    T *ptr;     // data
     union {
         // ### Qt 5: Use 'Prealloc * sizeof(T)' as array size
         char array[sizeof(qint64) * (((Prealloc * sizeof(T)) / sizeof(qint64)) + 1)];
@@ -197,8 +204,8 @@ Q_OUTOFLINE_TEMPLATE void QVarLengthArray<T, Prealloc>::realloc(int asize, int a
     Q_ASSERT(aalloc >= asize);
     T *oldPtr = ptr;
     int osize = s;
-    // s = asize;
 
+    const int copySize = qMin(asize, osize);
     if (aalloc != a) {
         ptr = reinterpret_cast<T *>(qMalloc(aalloc * sizeof(T)));
         Q_CHECK_PTR(ptr);
@@ -209,7 +216,6 @@ Q_OUTOFLINE_TEMPLATE void QVarLengthArray<T, Prealloc>::realloc(int asize, int a
             if (QTypeInfo<T>::isStatic) {
                 QT_TRY {
                     // copy all the old elements
-                    const int copySize = qMin(asize, osize);
                     while (s < copySize) {
                         new (ptr+s) T(*(oldPtr+s));
                         (oldPtr+s)->~T();
@@ -225,19 +231,19 @@ Q_OUTOFLINE_TEMPLATE void QVarLengthArray<T, Prealloc>::realloc(int asize, int a
                     QT_RETHROW;
                 }
             } else {
-                qMemCopy(ptr, oldPtr, qMin(asize, osize) * sizeof(T));
+                qMemCopy(ptr, oldPtr, copySize * sizeof(T));
             }
         } else {
             ptr = oldPtr;
             return;
         }
     }
+    s = copySize;
 
     if (QTypeInfo<T>::isComplex) {
+        // destroy remaining old objects
         while (osize > asize)
             (oldPtr+(--osize))->~T();
-        if (!QTypeInfo<T>::isStatic)
-            s = osize;
     }
 
     if (oldPtr != reinterpret_cast<T *>(array) && oldPtr != ptr)
diff --git a/src/corelib/tools/qvarlengtharray.qdoc b/src/corelib/tools/qvarlengtharray.qdoc
index 38901e5..ef2dc58 100644
--- a/src/corelib/tools/qvarlengtharray.qdoc
+++ b/src/corelib/tools/qvarlengtharray.qdoc
@@ -302,3 +302,52 @@
     \a defaultValue.
 */
 
+/*!
+    \typedef QVarLengthArray::size_type
+    \since 4.7
+
+    Typedef for int. Provided for STL compatibility.
+*/
+
+/*!
+    \typedef QVarLengthArray::value_type
+    \since 4.7
+
+    Typedef for T. Provided for STL compatibility.
+*/
+
+/*!
+    \typedef QVarLengthArray::difference_type
+    \since 4.7
+
+    Typedef for ptrdiff_t. Provided for STL compatibility.
+*/
+
+/*!
+    \typedef QVarLengthArray::pointer
+    \since 4.7
+
+    Typedef for T *. Provided for STL compatibility.
+*/
+
+/*!
+    \typedef QVarLengthArray::const_pointer
+    \since 4.7
+
+    Typedef for const T *. Provided for STL compatibility.
+*/
+
+/*!
+    \typedef QVarLengthArray::reference
+    \since 4.7
+
+    Typedef for T &. Provided for STL compatibility.
+*/
+
+/*!
+    \typedef QVarLengthArray::const_reference
+    \since 4.7
+
+    Typedef for const T &. Provided for STL compatibility.
+*/
+
diff --git a/src/declarative/QmlChanges.txt b/src/declarative/QmlChanges.txt
index 142920c..5735b1e 100644
--- a/src/declarative/QmlChanges.txt
+++ b/src/declarative/QmlChanges.txt
@@ -2,7 +2,6 @@
 The changes below are pre Qt 4.7.0 RC
 
 TextInput and TextEdit: 
-   - showInputPanelOnFocus property added
    - openSoftwareInputPanel() and closeSoftwareInputPanel() functions added
 Flickable:
    - overShoot is replaced by boundsBehavior enumeration
@@ -14,6 +13,8 @@ Component:
       status property instead
     - errorsString() renamed to errorString()
 
+TextInput xToPosition -> positionAt (to match TextEdit.positionAt)
+
 QList<QObject*> models no longer provide properties in model object.  The
 properties are now updated when the object changes.  An object's property
 "foo" may now be accessed as "foo", modelData.foo" or model.modelData.foo"
diff --git a/src/declarative/debugger/debugger.pri b/src/declarative/debugger/debugger.pri
index 6777868..33d0843 100644
--- a/src/declarative/debugger/debugger.pri
+++ b/src/declarative/debugger/debugger.pri
@@ -6,7 +6,7 @@ SOURCES += \
     $$PWD/qdeclarativedebugservice.cpp \
     $$PWD/qdeclarativedebugclient.cpp \
     $$PWD/qdeclarativedebug.cpp \
-    $$PWD/qdeclarativedebugtiming.cpp
+    $$PWD/qdeclarativedebugtrace.cpp
 
 HEADERS += \
     $$PWD/qdeclarativedebuggerstatus_p.h \
@@ -14,4 +14,4 @@ HEADERS += \
     $$PWD/qdeclarativedebugservice_p.h \
     $$PWD/qdeclarativedebugclient_p.h \
     $$PWD/qdeclarativedebug_p.h \
-    $$PWD/qdeclarativedebugtiming_p.h
+    $$PWD/qdeclarativedebugtrace_p.h
diff --git a/src/declarative/debugger/qdeclarativedebugtiming.cpp b/src/declarative/debugger/qdeclarativedebugtrace.cpp
index 5b93852..5e6d5e7 100644
--- a/src/declarative/debugger/qdeclarativedebugtiming.cpp
+++ b/src/declarative/debugger/qdeclarativedebugtrace.cpp
@@ -39,37 +39,44 @@
 **
 ****************************************************************************/
 
-#include "qdeclarativedebugtiming_p.h"
+#include "qdeclarativedebugtrace_p.h"
 
 #include <QtCore/qdatastream.h>
+#include <QtCore/qurl.h>
 
-Q_GLOBAL_STATIC(QDeclarativeDebugTiming, timerInstance);
+Q_GLOBAL_STATIC(QDeclarativeDebugTrace, traceInstance);
 
-QDeclarativeDebugTiming::QDeclarativeDebugTiming()
+QDeclarativeDebugTrace::QDeclarativeDebugTrace()
 : QDeclarativeDebugService(QLatin1String("CanvasFrameRate"))
 {
     m_timer.start();
 }
 
-void QDeclarativeDebugTiming::addEvent(EventType t)
+void QDeclarativeDebugTrace::addEvent(EventType t)
 {
     if (QDeclarativeDebugService::isDebuggingEnabled()) 
-        timerInstance()->addEventImpl(t);
+        traceInstance()->addEventImpl(t);
 }
 
-void QDeclarativeDebugTiming::startRange(RangeType t)
+void QDeclarativeDebugTrace::startRange(RangeType t)
 {
     if (QDeclarativeDebugService::isDebuggingEnabled()) 
-        timerInstance()->startRangeImpl(t);
+        traceInstance()->startRangeImpl(t);
 }
 
-void QDeclarativeDebugTiming::endRange(RangeType t)
+void QDeclarativeDebugTrace::rangeData(RangeType t, const QUrl &url)
 {
     if (QDeclarativeDebugService::isDebuggingEnabled()) 
-        timerInstance()->endRangeImpl(t);
+        traceInstance()->rangeDataImpl(t, url);
 }
 
-void QDeclarativeDebugTiming::addEventImpl(EventType event)
+void QDeclarativeDebugTrace::endRange(RangeType t)
+{
+    if (QDeclarativeDebugService::isDebuggingEnabled()) 
+        traceInstance()->endRangeImpl(t);
+}
+
+void QDeclarativeDebugTrace::addEventImpl(EventType event)
 {
     QByteArray data;
     QDataStream ds(&data, QIODevice::WriteOnly);
@@ -77,7 +84,7 @@ void QDeclarativeDebugTiming::addEventImpl(EventType event)
     sendMessage(data);
 }
 
-void QDeclarativeDebugTiming::startRangeImpl(RangeType range)
+void QDeclarativeDebugTrace::startRangeImpl(RangeType range)
 {
     QByteArray data;
     QDataStream ds(&data, QIODevice::WriteOnly);
@@ -85,7 +92,15 @@ void QDeclarativeDebugTiming::startRangeImpl(RangeType range)
     sendMessage(data);
 }
 
-void QDeclarativeDebugTiming::endRangeImpl(RangeType range)
+void QDeclarativeDebugTrace::rangeDataImpl(RangeType range, const QUrl &u)
+{
+    QByteArray data;
+    QDataStream ds(&data, QIODevice::WriteOnly);
+    ds << m_timer.elapsed() << (int)RangeData << (int)range << (QString)u.toString();
+    sendMessage(data);
+}
+
+void QDeclarativeDebugTrace::endRangeImpl(RangeType range)
 {
     QByteArray data;
     QDataStream ds(&data, QIODevice::WriteOnly);
diff --git a/src/declarative/debugger/qdeclarativedebugtiming_p.h b/src/declarative/debugger/qdeclarativedebugtrace_p.h
index d9ed67c..704c49a 100644
--- a/src/declarative/debugger/qdeclarativedebugtiming_p.h
+++ b/src/declarative/debugger/qdeclarativedebugtrace_p.h
@@ -39,8 +39,8 @@
 **
 ****************************************************************************/
 
-#ifndef QDECLARATIVEDEBUGTIMING_P_H
-#define QDECLARATIVEDEBUGTIMING_P_H
+#ifndef QDECLARATIVEDEBUGTRACE_P_H
+#define QDECLARATIVEDEBUGTRACE_P_H
 
 #include <private/qdeclarativedebugservice_p.h>
 #include <QtCore/qelapsedtimer.h>
@@ -49,7 +49,8 @@ QT_BEGIN_HEADER
 
 QT_BEGIN_NAMESPACE
 
-class QDeclarativeDebugTiming : public QDeclarativeDebugService
+class QUrl;
+class Q_AUTOTEST_EXPORT QDeclarativeDebugTrace : public QDeclarativeDebugService
 {
 public:
     enum EventType {
@@ -63,6 +64,7 @@ public:
     enum Message {
         Event,
         RangeStart,
+        RangeData,
         RangeEnd,
 
         MaximumMessage
@@ -77,13 +79,16 @@ public:
     };
 
     static void addEvent(EventType);
+
     static void startRange(RangeType);
+    static void rangeData(RangeType, const QUrl &);
     static void endRange(RangeType);
 
-    QDeclarativeDebugTiming();
+    QDeclarativeDebugTrace();
 private:
     void addEventImpl(EventType);
     void startRangeImpl(RangeType);
+    void rangeDataImpl(RangeType, const QUrl &);
     void endRangeImpl(RangeType);
     QElapsedTimer m_timer;
 };
@@ -92,5 +97,5 @@ QT_END_NAMESPACE
 
 QT_END_HEADER
 
-#endif // QDECLARATIVEDEBUGTIMING_P_H
+#endif // QDECLARATIVEDEBUGTRACE_P_H
 
diff --git a/src/declarative/graphicsitems/qdeclarativeanimatedimage.cpp b/src/declarative/graphicsitems/qdeclarativeanimatedimage.cpp
index a05e426..261cc5c 100644
--- a/src/declarative/graphicsitems/qdeclarativeanimatedimage.cpp
+++ b/src/declarative/graphicsitems/qdeclarativeanimatedimage.cpp
@@ -72,13 +72,22 @@ QT_BEGIN_NAMESPACE
     \o \image animatedimageitem.gif
     \o
     \qml
-Item {
-    width: anim.width; height: anim.height+8
-    AnimatedImage { id: anim; source: "pics/games-anim.gif" }
-    Rectangle { color: "red"; width: 4; height: 8; y: anim.height
-        x: (anim.width-width)*anim.currentFrame/(anim.frameCount-1)
+    import Qt 4.7
+
+    Rectangle {
+        width: animation.width; height: animation.height + 8
+
+        AnimatedImage { id: animation; source: "animation.gif" }
+
+        Rectangle { 
+            property int frames: animation.frameCount
+
+            width: 4; height: 8
+            x: (animation.width - width) * animation.currentFrame / frames
+            y: animation.height
+            color: "red"
+        }
     }
-}
     \endqml
     \endtable
 */
@@ -96,7 +105,7 @@ QDeclarativeAnimatedImage::~QDeclarativeAnimatedImage()
 
 /*!
   \qmlproperty bool AnimatedImage::paused
-  This property holds whether the animated image is paused or not
+  This property holds whether the animated image is paused.
 
   Defaults to false, and can be set to true when you want to pause.
 */
@@ -120,7 +129,7 @@ void QDeclarativeAnimatedImage::setPaused(bool pause)
 }
 /*!
   \qmlproperty bool AnimatedImage::playing
-  This property holds whether the animated image is playing or not
+  This property holds whether the animated image is playing.
 
   Defaults to true, so as to start playing immediately.
 */
diff --git a/src/declarative/graphicsitems/qdeclarativeflipable.cpp b/src/declarative/graphicsitems/qdeclarativeflipable.cpp
index d926119..8c9d2dd 100644
--- a/src/declarative/graphicsitems/qdeclarativeflipable.cpp
+++ b/src/declarative/graphicsitems/qdeclarativeflipable.cpp
@@ -74,7 +74,7 @@ public:
     \inherits Item
 
     Flipable is an item that can be visibly "flipped" between its front and
-    back sides. It is used together with Rotation and State/Transition to
+    back sides. It is used together with \l Rotation and \l {State}/\l {Transition} to
     produce a flipping effect.
 
     Here is a Flipable that flips whenever it is clicked:
@@ -83,10 +83,12 @@ public:
 
     \image flipable.gif
 
-    The Rotation element is used to specify the angle and axis of the flip,
-    and the State defines the changes in angle which produce the flipping
-    effect. Finally, the Transition creates the animation that changes the
+    The \l Rotation element is used to specify the angle and axis of the flip,
+    and the \l State defines the changes in angle which produce the flipping
+    effect. Finally, the \l Transition creates the animation that changes the
     angle over one second.
+    
+    \sa {declarative/ui-components/flipable}{Flipable example}
 */
 
 /*!
diff --git a/src/declarative/graphicsitems/qdeclarativegridview.cpp b/src/declarative/graphicsitems/qdeclarativegridview.cpp
index 906f1fc..ffffc2f 100644
--- a/src/declarative/graphicsitems/qdeclarativegridview.cpp
+++ b/src/declarative/graphicsitems/qdeclarativegridview.cpp
@@ -904,28 +904,43 @@ void QDeclarativeGridViewPrivate::flick(AxisData &data, qreal minExtent, qreal m
     \inherits Flickable
     \brief The GridView item provides a grid view of items provided by a model.
 
-    The model is typically provided by a QAbstractListModel "C++ model object",
-    but can also be created directly in QML.
+    A GridView displays data from models created from built-in QML elements like ListModel
+    and XmlListModel, or custom model classes defined in C++ that inherit from
+    QAbstractListModel.
 
-    The items are laid out top to bottom (vertically) or left to right (horizontally)
-    and may be flicked to scroll.
+    A GridView has a \l model, which defines the data to be displayed, and
+    a \l delegate, which defines how the data should be displayed. Items in a 
+    GridView are laid out horizontally or vertically. Grid views are inherently flickable
+    as GridView inherits from \l Flickable.
 
-    The below example creates a very simple grid, using a QML model.
+    For example, if there is a simple list model defined in a file \c ContactModel.qml like this:
 
-    \image gridview.png
+    \snippet doc/src/snippets/declarative/gridview/ContactModel.qml 0
 
-    \snippet doc/src/snippets/declarative/gridview/gridview.qml 3
+    Another component can display this model data in a GridView, like this:
 
-    The model is defined as a ListModel using QML:
-    \quotefile doc/src/snippets/declarative/gridview/dummydata/ContactModel.qml
+    \snippet doc/src/snippets/declarative/gridview/gridview.qml import
+    \codeline
+    \snippet doc/src/snippets/declarative/gridview/gridview.qml classdocs simple
+    \image gridview-simple.png
 
-    In this case ListModel is a handy way for us to test our UI.  In practice
-    the model would be implemented in C++, or perhaps via a SQL data source.
+    Here, the GridView creates a \c ContactModel component for its model, and a \l Column element
+    (containing \l Image and \ Text elements) for its delegate. The view will create a new delegate 
+    for each item in the model. Notice the delegate is able to access the model's \c name and 
+    \c portrait data directly.
+
+    An improved grid view is shown below. The delegate is visually improved and is moved 
+    into a separate \c contactDelegate component. Also, the currently selected item is highlighted
+    with a blue \l Rectangle using the \l highlight property, and \c focus is set to \c true
+    to enable keyboard navigation for the grid view.
+    
+    \snippet doc/src/snippets/declarative/gridview/gridview.qml classdocs advanced
+    \image gridview-highlight.png
 
     Delegates are instantiated as needed and may be destroyed at any time.
     State should \e never be stored in a delegate.
 
-    \bold Note that views do not enable \e clip automatically.  If the view
+    \note Views do not enable \e clip automatically.  If the view
     is not clipped by another item or the screen, it will be necessary
     to set \e {clip: true} in order to have the out of view items clipped
     nicely.
@@ -971,19 +986,7 @@ QDeclarativeGridView::~QDeclarativeGridView()
     The example below ensures that the animation completes before
     the item is removed from the grid.
 
-    \code
-    Component {
-        id: myDelegate
-        Item {
-            id: wrapper
-            GridView.onRemove: SequentialAnimation {
-                PropertyAction { target: wrapper; property: "GridView.delayRemove"; value: true }
-                NumberAnimation { target: wrapper; property: "scale"; to: 0; duration: 250; easing.type: Easing.InOutQuad }
-                PropertyAction { target: wrapper; property: "GridView.delayRemove"; value: false }
-            }
-        }
-    }
-    \endcode
+    \snippet doc/src/snippets/declarative/gridview/gridview.qml delayRemove
 */
 
 /*!
@@ -1001,10 +1004,10 @@ QDeclarativeGridView::~QDeclarativeGridView()
   \qmlproperty model GridView::model
   This property holds the model providing data for the grid.
 
-  The model provides a set of data that is used to create the items
-  for the view.  For large or dynamic datasets the model is usually
-  provided by a C++ model object.  The C++ model object must be a \l
-  {QAbstractItemModel} subclass, a VisualModel, or a simple list.
+    The model provides the set of data that is used to create the items
+    in the view. Models can be created directly in QML using \l ListModel, \l XmlListModel
+    or \l VisualItemModel, or provided by C++ model classes. If a C++ model class is
+    used, it must be a subclass of \l QAbstractItemModel or a simple list.
 
   \sa {qmlmodels}{Data Models}
 */
@@ -1079,11 +1082,11 @@ void QDeclarativeGridView::setModel(const QVariant &model)
     that is not needed for the normal display of the delegate in a \l Loader which
     can load additional elements when needed.
 
-    Note that the GridView will layout the items based on the size of the root item
+    The GridView will layout the items based on the size of the root item
     in the delegate.
 
-    Here is an example delegate:
-    \snippet doc/src/snippets/declarative/gridview/gridview.qml 0
+    \note Delegates are instantiated as needed and may be destroyed at any time.
+    State should \e never be stored in a delegate.
 */
 QDeclarativeComponent *QDeclarativeGridView::delegate() const
 {
@@ -1157,8 +1160,7 @@ QDeclarativeItem *QDeclarativeGridView::currentItem()
 /*!
   \qmlproperty Item GridView::highlightItem
 
-  \c highlightItem holds the highlight item, which was created
-  from the \l highlight component.
+  This holds the highlight item created from the \l highlight component.
 
   The highlightItem is managed by the view unless
   \l highlightFollowsCurrentItem is set to false.
@@ -1189,13 +1191,10 @@ int QDeclarativeGridView::count() const
   \qmlproperty Component GridView::highlight
   This property holds the component to use as the highlight.
 
-  An instance of the highlight component will be created for each view.
-  The geometry of the resultant component instance will be managed by the view
+  An instance of the highlight component is created for each view.
+  The geometry of the resulting component instance will be managed by the view
   so as to stay with the current item, unless the highlightFollowsCurrentItem property is false.
 
-  The below example demonstrates how to make a simple highlight:
-  \snippet doc/src/snippets/declarative/gridview/gridview.qml 1
-
   \sa highlightItem, highlightFollowsCurrentItem
 */
 QDeclarativeComponent *QDeclarativeGridView::highlight() const
@@ -1218,21 +1217,14 @@ void QDeclarativeGridView::setHighlight(QDeclarativeComponent *highlight)
   \qmlproperty bool GridView::highlightFollowsCurrentItem
   This property sets whether the highlight is managed by the view.
 
-  If highlightFollowsCurrentItem is true, the highlight will be moved smoothly
-  to follow the current item.  If highlightFollowsCurrentItem is false, the
-  highlight will not be moved by the view, and must be implemented
-  by the highlight component, for example:
-
-  \code
-  Component {
-      id: myHighlight
-      Rectangle {
-          id: wrapper; color: "lightsteelblue"; radius: 4; width: 320; height: 60
-          SpringFollow on y { source: wrapper.GridView.view.currentItem.y; spring: 3; damping: 0.2 }
-          SpringFollow on x { source: wrapper.GridView.view.currentItem.x; spring: 3; damping: 0.2 }
-      }
-  }
-  \endcode
+    If this property is true, the highlight is moved smoothly
+    to follow the current item.  Otherwise, the
+    highlight is not moved by the view, and any movement must be implemented
+    by the highlight.  
+    
+    Here is a highlight with its motion defined by a \l {SpringFollow} item:
+
+    \snippet doc/src/snippets/declarative/gridview/gridview.qml highlightFollowsCurrentItem
 */
 bool QDeclarativeGridView::highlightFollowsCurrentItem() const
 {
@@ -1290,32 +1282,30 @@ void QDeclarativeGridView::setHighlightMoveDuration(int duration)
     \qmlproperty real GridView::preferredHighlightEnd
     \qmlproperty enumeration GridView::highlightRangeMode
 
-    These properties set the preferred range of the highlight (current item)
-    within the view.
+    These properties define the preferred range of the highlight (for the current item)
+    within the view. The \c preferredHighlightBegin value must be less than the
+    \c preferredHighlightEnd value. 
 
-    Note that this is the correct way to influence where the
-    current item ends up when the view scrolls. For example, if you want the
-    currently selected item to be in the middle of the list, then set the
-    highlight range to be where the middle item would go. Then, when the view scrolls,
-    the currently selected item will be the item at that spot. This also applies to
-    when the currently selected item changes - it will scroll to within the preferred
-    highlight range. Furthermore, the behaviour of the current item index will occur
-    whether or not a highlight exists.
+    These properties affect the position of the current item when the view is scrolled.
+    For example, if the currently selected item should stay in the middle of the
+    view when it is scrolled, set the \c preferredHighlightBegin and 
+    \c preferredHighlightEnd values to the top and bottom coordinates of where the middle 
+    item would be. If the \c currentItem is changed programmatically, the view will
+    automatically scroll so that the current item is in the middle of the view.
+    Furthermore, the behavior of the current item index will occur whether or not a
+    highlight exists.
 
-    If highlightRangeMode is set to \e GridView.ApplyRange the view will
-    attempt to maintain the highlight within the range, however
-    the highlight can move outside of the range at the ends of the list
-    or due to a mouse interaction.
+    Valid values for \c highlightRangeMode are:
 
-    If highlightRangeMode is set to \e GridView.StrictlyEnforceRange the highlight will never
-    move outside of the range.  This means that the current item will change
-    if a keyboard or mouse action would cause the highlight to move
-    outside of the range.
-
-    The default value is \e GridView.NoHighlightRange.
-
-    Note that a valid range requires preferredHighlightEnd to be greater
-    than or equal to preferredHighlightBegin.
+    \list
+    \o GridView.ApplyRange - the view attempts to maintain the highlight within the range.
+       However, the highlight can move outside of the range at the ends of the view or due
+       to mouse interaction.
+    \o GridView.StrictlyEnforceRange - the highlight never moves outside of the range.
+       The current item changes if a keyboard or mouse action would cause the highlight to move
+       outside of the range.
+    \o GridView.NoHighlightRange - this is the default value.
+    \endlist
 */
 qreal QDeclarativeGridView::preferredHighlightBegin() const
 {
@@ -1370,10 +1360,12 @@ void QDeclarativeGridView::setHighlightRangeMode(HighlightRangeMode mode)
   \qmlproperty enumeration GridView::flow
   This property holds the flow of the grid.
 
-  Possible values are \c GridView.LeftToRight (default) and \c GridView.TopToBottom.
+    Possible values:
 
-  If \a flow is \c GridView.LeftToRight, the view will scroll vertically.
-  If \a flow is \c GridView.TopToBottom, the view will scroll horizontally.
+    \list
+    \o GridView.LeftToRight (default) - Items are laid out from left to right, and the view scrolls vertically
+    \o GridView.TopToBottom - Items are laid out from top to bottom, and the view scrolls horizontally
+    \endlist
 */
 QDeclarativeGridView::Flow QDeclarativeGridView::flow() const
 {
@@ -1405,8 +1397,9 @@ void QDeclarativeGridView::setFlow(Flow flow)
   \qmlproperty bool GridView::keyNavigationWraps
   This property holds whether the grid wraps key navigation
 
-  If this property is true then key presses to move off of one end of the grid will cause the
-  selection to jump to the other side.
+    If this is true, key navigation that would move the current item selection
+    past one end of the view instead wraps around and moves the selection to
+    the other end of the view.
 */
 bool QDeclarativeGridView::isWrapEnabled() const
 {
@@ -1463,7 +1456,7 @@ void QDeclarativeGridView::setCacheBuffer(int buffer)
   \qmlproperty int GridView::cellWidth
   \qmlproperty int GridView::cellHeight
 
-  These properties holds the width and height of each cell in the grid
+  These properties holds the width and height of each cell in the grid.
 
   The default cell size is 100x100.
 */
@@ -1503,14 +1496,14 @@ void QDeclarativeGridView::setCellHeight(int cellHeight)
 /*!
     \qmlproperty enumeration GridView::snapMode
 
-    This property determines where the view will settle following a drag or flick.
-    The allowed values are:
+    This property determines how the view scrolling will settle following a drag or flick.
+    The possible values are:
 
     \list
-    \o GridView.NoSnap (default) - the view will stop anywhere within the visible area.
-    \o GridView.SnapToRow - the view will settle with a row (or column for TopToBottom flow)
+    \o GridView.NoSnap (default) - the view stops anywhere within the visible area.
+    \o GridView.SnapToRow - the view settles with a row (or column for \c GridView.TopToBottom flow)
     aligned with the start of the view.
-    \o GridView.SnapOneRow - the view will settle no more than one row (or column for TopToBottom flow)
+    \o GridView.SnapOneRow - the view will settle no more than one row (or column for \c GridView.TopToBottom flow)
     away from the first visible row at the time the mouse button is released.
     This mode is particularly useful for moving one page at a time.
     \endlist
@@ -1789,22 +1782,22 @@ void QDeclarativeGridView::moveCurrentIndexRight()
     \a mode:
 
     \list
-    \o Beginning - position item at the top (or left for TopToBottom flow) of the view.
-    \o Center- position item in the center of the view.
-    \o End - position item at bottom (or right for horizontal orientation) of the view.
-    \o Visible - if any part of the item is visible then take no action, otherwise
+    \o GridView.Beginning - position item at the top (or left for \c GridView.TopToBottom flow) of the view.
+    \o GridView.Center - position item in the center of the view.
+    \o GridView.End - position item at bottom (or right for horizontal orientation) of the view.
+    \o GridView.Visible - if any part of the item is visible then take no action, otherwise
     bring the item into view.
-    \o Contain - ensure the entire item is visible.  If the item is larger than
-    the view the item is positioned at the top (or left for TopToBottom flow) of the view.
+    \o GridView.Contain - ensure the entire item is visible.  If the item is larger than
+    the view the item is positioned at the top (or left for \c GridView.TopToBottom flow) of the view.
     \endlist
 
     If positioning the view at the index would cause empty space to be displayed at
     the beginning or end of the view, the view will be positioned at the boundary.
 
-    It is not recommended to use contentX or contentY to position the view
+    It is not recommended to use \l {Flickable::}{contentX} or \l {Flickable::}{contentY} to position the view
     at a particular index.  This is unreliable since removing items from the start
     of the view does not cause all other items to be repositioned.
-    The correct way to bring an item into view is with positionViewAtIndex.
+    The correct way to bring an item into view is with \c positionViewAtIndex.
 */
 void QDeclarativeGridView::positionViewAtIndex(int index, int mode)
 {
diff --git a/src/declarative/graphicsitems/qdeclarativeimage.cpp b/src/declarative/graphicsitems/qdeclarativeimage.cpp
index 4593cf8..94240c2 100644
--- a/src/declarative/graphicsitems/qdeclarativeimage.cpp
+++ b/src/declarative/graphicsitems/qdeclarativeimage.cpp
@@ -275,11 +275,6 @@ qreal QDeclarativeImage::paintedHeight() const
     \o Image.Error - an error occurred while loading the image
     \endlist
 
-    Note that a change in the status property does not cause anything to happen
-    (although it reflects what has happened with the image internally). If you wish
-    to react to the change in status you need to do it yourself, for example in one
-    of the following ways:
-
     Use this status to provide an update or respond to the status change in some way.
     For example, you could:
 
diff --git a/src/declarative/graphicsitems/qdeclarativeimage_p.h b/src/declarative/graphicsitems/qdeclarativeimage_p.h
index 5ea700d..fa5b2a9 100644
--- a/src/declarative/graphicsitems/qdeclarativeimage_p.h
+++ b/src/declarative/graphicsitems/qdeclarativeimage_p.h
@@ -87,8 +87,6 @@ protected:
     QDeclarativeImage(QDeclarativeImagePrivate &dd, QDeclarativeItem *parent);
     void geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry);
     void pixmapChange();
-
-protected Q_SLOTS:
     void updatePaintedGeometry();
 
 private:
diff --git a/src/declarative/graphicsitems/qdeclarativeitem.cpp b/src/declarative/graphicsitems/qdeclarativeitem.cpp
index 134bd6d..9949e65 100644
--- a/src/declarative/graphicsitems/qdeclarativeitem.cpp
+++ b/src/declarative/graphicsitems/qdeclarativeitem.cpp
@@ -97,9 +97,11 @@ QT_BEGIN_NAMESPACE
 
     The Translate object provides independent control over position in addition to the Item's x and y properties.
 
-    The following example moves the Y axis of the Rectangles while still allowing the Row element
+    The following example moves the Y axis of the \l Rectangle elements while still allowing the \l Row element
     to lay the items out as if they had not been transformed:
     \qml
+    import Qt 4.7
+
     Row {
         Rectangle {
             width: 100; height: 100
@@ -113,6 +115,8 @@ QT_BEGIN_NAMESPACE
         }
     }
     \endqml
+
+    \image translate.png
 */
 
 /*!
diff --git a/src/declarative/graphicsitems/qdeclarativelayoutitem.cpp b/src/declarative/graphicsitems/qdeclarativelayoutitem.cpp
index c8ecbb6..38d5f59 100644
--- a/src/declarative/graphicsitems/qdeclarativelayoutitem.cpp
+++ b/src/declarative/graphicsitems/qdeclarativelayoutitem.cpp
@@ -50,20 +50,24 @@ QT_BEGIN_NAMESPACE
 /*!
     \qmlclass LayoutItem QDeclarativeLayoutItem
     \since 4.7
-    \brief The LayoutItem element allows you to place your declarative UI elements inside a classical Qt layout.
+    \brief The LayoutItem element allows declarative UI elements to be placed inside Qt's Graphics View layouts.
 
-    LayoutItem is a variant of Item with a couple of additional properties. These properties provide the size hints
-    needed for items to work in conjunction with Qt Layouts. The Qt Layout will resize the LayoutItem as appropriate,
+    LayoutItem is a variant of \l Item with additional size hint properties. These properties provide the size hints
+    necessary for items to work in conjunction with Qt \l{Graphics View Framework}{Graphics View} layout classes
+    such as QGraphicsLinearLayout and QGraphicsGridLayout. The Qt layout mechanisms will resize the LayoutItem as appropriate,
     taking its size hints into account, and you can propagate this to the other elements in your UI via anchors and bindings.
 
-    This is a QGraphicsLayoutItem subclass, and the properties merely expose the QGraphicsLayoutItem functionality to QML.
-    See the QGraphicsLayoutItem documentation for further details.
+    This is a QGraphicsLayoutItem subclass, and its properties merely expose the QGraphicsLayoutItem functionality to QML.
+
+    The \l{declarative/cppextensions/qgraphicslayouts/layoutitem}{LayoutItem example}
+    demonstrates how a LayoutItem can be used within a \l{Graphics View Framework}{Graphics View}
+    scene.
 */
 
 /*!
     \internal
     \class QDeclarativeLayoutItem
-    \brief The QDeclarativeLayoutItem class allows you to place your Fluid UI elements inside a classical Qt layout.
+    \brief The QDeclarativeLayoutItem class allows you to place your QML UI elements inside Qt's Graphics View layouts.
 */
 
 
diff --git a/src/declarative/graphicsitems/qdeclarativelistview.cpp b/src/declarative/graphicsitems/qdeclarativelistview.cpp
index 78c56d6..dbd1976 100644
--- a/src/declarative/graphicsitems/qdeclarativelistview.cpp
+++ b/src/declarative/graphicsitems/qdeclarativelistview.cpp
@@ -427,6 +427,8 @@ public:
                 scheduleLayout();
             }
         }
+        if (currentItem && currentItem->item == item)
+            updateHighlight();
         if (trackedItem && trackedItem->item == item)
             q->trackedPositionChanged();
     }
@@ -1103,7 +1105,9 @@ void QDeclarativeListViewPrivate::updateHeader()
 
 void QDeclarativeListViewPrivate::fixupPosition()
 {
-    moveReason = Other;
+    if ((haveHighlightRange && highlightRange == QDeclarativeListView::StrictlyEnforceRange)
+        || snapMode != QDeclarativeListView::NoSnap)
+        moveReason = Other;
     if (orient == QDeclarativeListView::Vertical)
         fixupY();
     else
@@ -1325,13 +1329,11 @@ void QDeclarativeListViewPrivate::flick(AxisData &data, qreal minExtent, qreal m
 
     Another component can display this model data in a ListView, like this:
 
-    \table 
-    \row 
-    \o \snippet doc/src/snippets/declarative/listview/listview.qml import
+    \snippet doc/src/snippets/declarative/listview/listview.qml import
     \codeline
     \snippet doc/src/snippets/declarative/listview/listview.qml classdocs simple
-    \o \image listview-simple.png
-    \endtable
+
+    \image listview-simple.png
 
     Here, the ListView creates a \c ContactModel component for its model, and a \l Text element
     for its delegate. The view will create a new \l Text component for each item in the model. Notice
@@ -1342,13 +1344,10 @@ void QDeclarativeListViewPrivate::flick(AxisData &data, qreal minExtent, qreal m
     with a blue \l Rectangle using the \l highlight property, and \c focus is set to \c true
     to enable keyboard navigation for the list view.
     
-    \table
-    \row
-    \o \snippet doc/src/snippets/declarative/listview/listview.qml classdocs advanced
-    \o \image listview-highlight.png
-    \endtable
+    \snippet doc/src/snippets/declarative/listview/listview.qml classdocs advanced
+    \image listview-highlight.png
 
-    In a ListView, delegates are instantiated as needed and may be destroyed at any time.
+    In a GridView, delegates are instantiated as needed and may be destroyed at any time.
     State should \e never be stored in a delegate.
 
     \note Views do not enable \e clip automatically.  If the view
@@ -1466,13 +1465,15 @@ void QDeclarativeListView::setModel(const QVariant &model)
         disconnect(d->model, SIGNAL(destroyingItem(QDeclarativeItem*)), this, SLOT(destroyingItem(QDeclarativeItem*)));
     }
     d->clear();
+    QDeclarativeVisualModel *oldModel = d->model;
+    d->model = 0;
     d->setPosition(0);
     d->modelVariant = model;
     QObject *object = qvariant_cast<QObject*>(model);
     QDeclarativeVisualModel *vim = 0;
     if (object && (vim = qobject_cast<QDeclarativeVisualModel *>(object))) {
         if (d->ownModel) {
-            delete d->model;
+            delete oldModel;
             d->ownModel = false;
         }
         d->model = vim;
@@ -1480,6 +1481,8 @@ void QDeclarativeListView::setModel(const QVariant &model)
         if (!d->ownModel) {
             d->model = new QDeclarativeVisualDataModel(qmlContext(this), this);
             d->ownModel = true;
+        } else {
+            d->model = oldModel;
         }
         if (QDeclarativeVisualDataModel *dataModel = qobject_cast<QDeclarativeVisualDataModel*>(d->model))
             dataModel->setModel(model);
@@ -1630,7 +1633,7 @@ int QDeclarativeListView::count() const
     This property holds the component to use as the highlight.
 
     An instance of the highlight component is created for each list.
-    The geometry of the resultant component instance is managed by the list
+    The geometry of the resulting component instance is managed by the list
     so as to stay with the current item, unless the highlightFollowsCurrentItem
     property is false.
 
@@ -1663,7 +1666,7 @@ void QDeclarativeListView::setHighlight(QDeclarativeComponent *highlight)
     highlight is not moved by the view, and any movement must be implemented
     by the highlight.  
     
-    Here is a highlight with its motion defined by the a \l {SpringFollow} item:
+    Here is a highlight with its motion defined by a \l {SpringFollow} item:
 
     \snippet doc/src/snippets/declarative/listview/listview.qml highlightFollowsCurrentItem
 
@@ -2038,8 +2041,8 @@ void QDeclarativeListView::setHighlightResizeDuration(int duration)
 /*!
     \qmlproperty enumeration ListView::snapMode
 
-    This property determines where the view's scrolling behavior stops following a drag or flick.
-    The allowed values are:
+    This property determines how the view scrolling will settle following a drag or flick.
+    The possible values are:
 
     \list
     \o ListView.NoSnap (default) - the view stops anywhere within the visible area.
diff --git a/src/declarative/graphicsitems/qdeclarativeloader.cpp b/src/declarative/graphicsitems/qdeclarativeloader.cpp
index 4995baf..898c5a5 100644
--- a/src/declarative/graphicsitems/qdeclarativeloader.cpp
+++ b/src/declarative/graphicsitems/qdeclarativeloader.cpp
@@ -115,27 +115,37 @@ void QDeclarativeLoaderPrivate::initResize()
     subtree from a QML URL or Component.
 
     Loader instantiates an item from a component. The component to
-    instantiate may be specified directly by the \c sourceComponent
-    property, or loaded from a URL via the \c source property.
+    instantiate may be specified directly by the \l sourceComponent
+    property, or loaded from a URL via the \l source property.
 
     It is also an effective means of delaying the creation of a component
     until it is required:
     \code
+    import Qt 4.7
+
     Loader { id: pageLoader }
+
     Rectangle {
-        MouseArea { anchors.fill: parent; onClicked: pageLoader.source = "Page1.qml" }
+        MouseArea { 
+            anchors.fill: parent
+            onClicked: pageLoader.source = "Page1.qml"
+        }
     }
     \endcode
 
     If the Loader source is changed, any previous items instantiated
-    will be destroyed.  Setting \c source to an empty string, or setting
+    will be destroyed.  Setting \l source to an empty string, or setting
     sourceComponent to \e undefined
     will destroy the currently instantiated items, freeing resources
     and leaving the Loader empty.  For example:
 
     \code
     pageLoader.source = ""
+    \endcode
+
       or
+
+    \code
     pageLoader.sourceComponent = undefined
     \endcode
 
@@ -340,19 +350,31 @@ void QDeclarativeLoaderPrivate::_q_sourceLoaded()
     \o Loader.Error - an error occurred while loading the QML source
     \endlist
 
-    Note that a change in the status property does not cause anything to happen
-    (although it reflects what has happened to the loader internally). If you wish
-    to react to the change in status you need to do it yourself, for example in one
-    of the following ways:
-    \list
-    \o Create a state, so that a state change occurs, e.g. State{name: 'loaded'; when: loader.status = Loader.Ready;}
-    \o Do something inside the onLoaded signal handler, e.g. Loader{id: loader; onLoaded: console.log('Loaded');}
-    \o Bind to the status variable somewhere, e.g. Text{text: if(loader.status!=Loader.Ready){'Not Loaded';}else{'Loaded';}}
-    \endlist
-    \sa progress
+    Use this status to provide an update or respond to the status change in some way.
+    For example, you could:
+
+    \e {Trigger a state change:}
+    \qml 
+        State { name: 'loaded'; when: loader.status = Loader.Ready }
+    \endqml
+
+    \e {Implement an \c onStatusChanged signal handler:}
+    \qml 
+        Loader {
+            id: loader
+            onStatusChanged: if (loader.status == Loader.Ready) console.log('Loaded')
+        }
+    \endqml
+
+    \e {Bind to the status value:}
+    \qml
+        Text { text: loader.status != Loader.Ready ? 'Not Loaded' : 'Loaded' }
+    \endqml
 
     Note that if the source is a local file, the status will initially be Ready (or Error). While
     there will be no onStatusChanged signal in that case, the onLoaded will still be invoked.
+
+    \sa progress
 */
 
 QDeclarativeLoader::Status QDeclarativeLoader::status() const
diff --git a/src/declarative/graphicsitems/qdeclarativemousearea.cpp b/src/declarative/graphicsitems/qdeclarativemousearea.cpp
index 1947c00..6fca283 100644
--- a/src/declarative/graphicsitems/qdeclarativemousearea.cpp
+++ b/src/declarative/graphicsitems/qdeclarativemousearea.cpp
@@ -172,17 +172,21 @@ QDeclarativeMouseAreaPrivate::~QDeclarativeMouseAreaPrivate()
 
     A MouseArea is typically used in conjunction with a visible item,
     where the MouseArea effectively 'proxies' mouse handling for that
-    item. For example, we can put a MouseArea in a Rectangle that changes
-    the Rectangle color to red when clicked:
-    \snippet doc/src/snippets/declarative/mouseregion.qml 0
+    item. For example, we can put a MouseArea in a \l Rectangle that changes
+    the \l Rectangle color to red when clicked:
+
+    \snippet doc/src/snippets/declarative/mousearea.qml import
+    \codeline
+    \snippet doc/src/snippets/declarative/mousearea.qml intro
 
     Many MouseArea signals pass a \l {MouseEvent}{mouse} parameter that contains
     additional information about the mouse event, such as the position, button,
     and any key modifiers.
 
-    Below we have the previous
-    example extended so as to give a different color when you right click.
-    \snippet doc/src/snippets/declarative/mouseregion.qml 1
+    Here is an extension of the previous example that produces a different
+    color when the area is right clicked:
+
+    \snippet doc/src/snippets/declarative/mousearea.qml intro-extended
 
     For basic key handling, see the \l {Keys}{Keys attached property}.
 
@@ -238,7 +242,7 @@ QDeclarativeMouseAreaPrivate::~QDeclarativeMouseAreaPrivate()
     releasing is also considered a click).
 
     The \l {MouseEvent}{mouse} parameter provides information about the click, including the x and y
-    position of the release of the click, and whether the click wasHeld.
+    position of the release of the click, and whether the click was held.
 
     The \e accepted property of the MouseEvent parameter is ignored in this handler.
 */
@@ -262,7 +266,7 @@ QDeclarativeMouseAreaPrivate::~QDeclarativeMouseAreaPrivate()
 
     This handler is called when there is a release.
     The \l {MouseEvent}{mouse} parameter provides information about the click, including the x and y
-    position of the release of the click, and whether the click wasHeld.
+    position of the release of the click, and whether the click was held.
 
     The \e accepted property of the MouseEvent parameter is ignored in this handler.
 */
@@ -282,7 +286,7 @@ QDeclarativeMouseAreaPrivate::~QDeclarativeMouseAreaPrivate()
 
     This handler is called when there is a double-click (a press followed by a release followed by a press).
     The \l {MouseEvent}{mouse} parameter provides information about the click, including the x and y
-    position of the release of the click, and whether the click wasHeld.
+    position of the release of the click, and whether the click was held.
 
     The \e accepted property of the MouseEvent parameter is ignored in this handler.
 */
@@ -328,10 +332,10 @@ QDeclarativeMouseArea::~QDeclarativeMouseArea()
     while a button is pressed, and will remain valid as long as the button is held
     even if the mouse is moved outside the area.
 
-    If hoverEnabled is true then these properties will be valid:
+    If hoverEnabled is true then these properties will be valid when:
     \list
-        \i when no button is pressed, but the mouse is within the MouseArea (containsMouse is true).
-        \i if a button is pressed and held, even if it has since moved out of the area.
+        \i no button is pressed, but the mouse is within the MouseArea (containsMouse is true).
+        \i a button is pressed and held, even if it has since moved out of the area.
     \endlist
 
     The coordinates are relative to the MouseArea.
@@ -378,18 +382,7 @@ void QDeclarativeMouseArea::setEnabled(bool a)
     \endlist
 
     The code below displays "right" when the right mouse buttons is pressed:
-    \code
-    Text {
-        text: mr.pressedButtons & Qt.RightButton ? "right" : ""
-        horizontalAlignment: Text.AlignHCenter
-        verticalAlignment: Text.AlignVCenter
-        MouseArea {
-            id: mr
-            acceptedButtons: Qt.LeftButton | Qt.RightButton
-            anchors.fill: parent
-        }
-    }
-    \endcode
+    \snippet doc/src/snippets/declarative/mousearea.qml mousebuttons
 
     \sa acceptedButtons
 */
@@ -705,7 +698,7 @@ void QDeclarativeMouseArea::setHovered(bool h)
     MouseArea { acceptedButtons: Qt.LeftButton | Qt.RightButton }
     \endcode
 
-    The default is to accept the Left button.
+    The default value is \c Qt.LeftButton.
 */
 Qt::MouseButtons QDeclarativeMouseArea::acceptedButtons() const
 {
@@ -765,17 +758,19 @@ QDeclarativeDrag *QDeclarativeMouseArea::drag()
     \qmlproperty real MouseArea::drag.minimumY
     \qmlproperty real MouseArea::drag.maximumY
 
-    drag provides a convenient way to make an item draggable.
+    \c drag provides a convenient way to make an item draggable.
 
     \list
-    \i \c target specifies the item to drag.
-    \i \c active specifies if the target item is being currently dragged.
-    \i \c axis specifies whether dragging can be done horizontally (Drag.XAxis), vertically (Drag.YAxis), or both (Drag.XandYAxis)
-    \i the minimum and maximum properties limit how far the target can be dragged along the corresponding axes.
+    \i \c drag.target specifies the item to drag.
+    \i \c drag.active specifies if the target item is currently being dragged.
+    \i \c drag.axis specifies whether dragging can be done horizontally (\c Drag.XAxis), vertically (\c Drag.YAxis), or both (\c Drag.XandYAxis)
+    \i \c drag.minimum and \c drag.maximum limit how far the target can be dragged along the corresponding axes.
     \endlist
 
-    The following example uses drag to reduce the opacity of an image as it moves to the right:
-    \snippet doc/src/snippets/declarative/drag.qml 0
+    The following example displays an image that can be dragged along the X-axis. The opacity
+    of the image is reduced when it is dragged to the right.
+
+    \snippet doc/src/snippets/declarative/mousearea.qml drag
 */
 
 QT_END_NAMESPACE
diff --git a/src/declarative/graphicsitems/qdeclarativepath.cpp b/src/declarative/graphicsitems/qdeclarativepath.cpp
index 2d08c7c..a904869 100644
--- a/src/declarative/graphicsitems/qdeclarativepath.cpp
+++ b/src/declarative/graphicsitems/qdeclarativepath.cpp
@@ -628,7 +628,7 @@ void QDeclarativePathLine::addToPath(QPainterPath &path)
     \qml
     Path {
         startX: 0; startY: 0
-        PathQuad x: 200; y: 0; controlX: 100; controlY: 150 }
+        PathQuad { x: 200; y: 0; controlX: 100; controlY: 150 }
     }
     \endqml
     \endtable
@@ -713,8 +713,9 @@ void QDeclarativePathQuad::addToPath(QPainterPath &path)
     Path {
         startX: 20; startY: 0
         PathCubic {
-            x: 180; y: 0; control1X: -10; control1Y: 90
-                          control2X: 210; control2Y: 90
+            x: 180; y: 0
+            control1X: -10; control1Y: 90
+            control2X: 210; control2Y: 90
         }
     }
     \endqml
@@ -867,6 +868,9 @@ qreal QDeclarativePathPercent::value() const
 
 void QDeclarativePathPercent::setValue(qreal value)
 {
-    _value = value;
+    if (_value != value) {
+        _value = value;
+        emit changed();
+    }
 }
 QT_END_NAMESPACE
diff --git a/src/declarative/graphicsitems/qdeclarativepath_p.h b/src/declarative/graphicsitems/qdeclarativepath_p.h
index 17a2ea3..dad43e6 100644
--- a/src/declarative/graphicsitems/qdeclarativepath_p.h
+++ b/src/declarative/graphicsitems/qdeclarativepath_p.h
@@ -175,7 +175,7 @@ private:
 class Q_DECLARATIVE_EXPORT QDeclarativePathPercent : public QDeclarativePathElement
 {
     Q_OBJECT
-    Q_PROPERTY(qreal value READ value WRITE setValue)
+    Q_PROPERTY(qreal value READ value WRITE setValue NOTIFY changed)
 public:
     QDeclarativePathPercent(QObject *parent=0) : QDeclarativePathElement(parent) {}
 
diff --git a/src/declarative/graphicsitems/qdeclarativepathview.cpp b/src/declarative/graphicsitems/qdeclarativepathview.cpp
index 448ec06..f58b054 100644
--- a/src/declarative/graphicsitems/qdeclarativepathview.cpp
+++ b/src/declarative/graphicsitems/qdeclarativepathview.cpp
@@ -310,11 +310,21 @@ void QDeclarativePathViewPrivate::regenerate()
     \brief The PathView element lays out model-provided items on a path.
     \inherits Item
 
-    The model is typically provided by a QAbstractListModel "C++ model object", but can also be created directly in QML.
+    A PathView displays data from models created from built-in QML elements like ListModel
+    and XmlListModel, or custom model classes defined in C++ that inherit from
+    QAbstractListModel.
 
+    A ListView has a \l model, which defines the data to be displayed, and
+    a \l delegate, which defines how the data should be displayed.  
     The \l delegate is instantiated for each item on the \l path.
     The items may be flicked to move them along the path.
 
+    For example, if there is a simple list model defined in a file \c ContactModel.qml like this:
+
+    \snippet doc/src/snippets/declarative/pathview/ContactModel.qml 0
+
+    This data can be represented as a PathView, like this:
+
     \snippet doc/src/snippets/declarative/pathview/pathview.qml 0
 
     \image pathview.gif
@@ -885,6 +895,7 @@ void QDeclarativePathView::setPathItemCount(int i)
     if (i < 1)
         i = 1;
     d->pathItems = i;
+    d->updateMappedRange();
     if (d->isValid() && isComponentComplete()) {
         d->regenerate();
     }
diff --git a/src/declarative/graphicsitems/qdeclarativepositioners.cpp b/src/declarative/graphicsitems/qdeclarativepositioners.cpp
index 8796e63..20cc46b 100644
--- a/src/declarative/graphicsitems/qdeclarativepositioners.cpp
+++ b/src/declarative/graphicsitems/qdeclarativepositioners.cpp
@@ -302,7 +302,7 @@ void QDeclarativeBasePositioner::finishApplyTransitions()
 /*!
   \qmlclass Column QDeclarativeColumn
     \since 4.7
-  \brief The Column item lines up its children vertically.
+  \brief The Column item arranges its children vertically.
   \inherits Item
 
   The Column item positions its child items so that they are vertically
@@ -346,7 +346,8 @@ Column {
   will not change. If you manually change the x or y properties in script, bind
   the x or y properties, use anchors on a child of a positioner, or have the
   height of a child depend on the position of a child, then the
-  positioner may exhibit strange behaviour.
+  positioner may exhibit strange behaviour. If you need to perform any of these
+  actions, consider positioning the items without the use of a Column.
 
 */
 /*!
@@ -396,7 +397,7 @@ Column {
   spacing is the amount in pixels left empty between each adjacent
   item, and defaults to 0.
 
-  The below example places a Grid containing a red, a blue and a
+  The below example places a \l Grid containing a red, a blue and a
   green rectangle on a gray background. The area the grid positioner
   occupies is colored white. The top positioner has the default of no spacing,
   and the bottom positioner has its spacing set to 2.
@@ -468,17 +469,15 @@ void QDeclarativeColumn::reportConflictingAnchors()
 /*!
   \qmlclass Row QDeclarativeRow
   \since 4.7
-  \brief The Row item lines up its children horizontally.
+  \brief The Row item arranges its children horizontally.
   \inherits Item
 
   The Row item positions its child items so that they are
-  horizontally aligned and not overlapping. Spacing can be added between the
-  items, and a margin around all items can also be added. It also provides for
-  transitions to be set when items are added, moved, or removed in the
-  positioner. Adding and removing apply both to items which are deleted or have
-  their position in the document changed so as to no longer be children of the
-  positioner, as well as to items which have their opacity set to or from zero
-  so as to appear or disappear.
+  horizontally aligned and not overlapping. 
+
+  Use \l spacing to set the spacing between items in a Row, and use the
+  \l add and \l move properties to set the transitions that should be applied
+  when items are added to, removed from, or re-positioned within the Row.
 
   The below example lays out differently shaped rectangles using a Row.
   \qml
@@ -495,8 +494,8 @@ Row {
   will not change. If you manually change the x or y properties in script, bind
   the x or y properties, use anchors on a child of a positioner, or have the
   width of a child depend on the position of a child, then the
-  positioner may exhibit strange behaviour.
-
+  positioner may exhibit strange behaviour. If you need to perform any of these
+  actions, consider positioning the items without the use of a Row.
 */
 /*!
     \qmlproperty Transition Row::add
@@ -504,12 +503,10 @@ Row {
     The transition will only be applied to the added item(s).
     Positioner transitions will only affect the position (x,y) of items.
 
-    Added can mean that either the object has been created or
-    reparented, and thus is now a child or the positioner, or that the
+    An object is considered to be added to the positioner if it has been
+    created or reparented and thus is now a child or the positioner, or if the
     object has had its opacity increased from zero, and thus is now
     visible.
-
-
 */
 /*!
     \qmlproperty Transition Row::move
@@ -540,7 +537,7 @@ Row {
   spacing is the amount in pixels left empty between each adjacent
   item, and defaults to 0.
 
-  The below example places a Grid containing a red, a blue and a
+  The below example places a \l Grid containing a red, a blue and a
   green rectangle on a gray background. The area the grid positioner
   occupies is colored white. The top positioner has the default of no spacing,
   and the bottom positioner has its spacing set to 2.
@@ -610,18 +607,20 @@ void QDeclarativeRow::reportConflictingAnchors()
   \inherits Item
 
   The Grid item positions its child items so that they are
-  aligned in a grid and are not overlapping. Spacing can be added
-  between the items. It also provides for transitions to be set when items are
+  aligned in a grid and are not overlapping. 
+  
+  Spacing can be added
+  between child items. It also provides for transitions to be set when items are
   added, moved, or removed in the positioner. Adding and removing apply
   both to items which are deleted or have their position in the
   document changed so as to no longer be children of the positioner, as
   well as to items which have their opacity set to or from zero so
   as to appear or disappear.
 
-  The Grid defaults to using four columns, and as many rows as
-  are necessary to fit all the child items. The number of rows
-  and/or the number of columns can be constrained by setting the rows
-  or columns properties. The grid positioner calculates a grid with
+  A Grid defaults to four columns, and as many rows as
+  are necessary to fit all child items. The number of rows
+  and/or the number of columns can be constrained by setting the \l rows
+  or \l columns properties. The grid positioner calculates a grid with
   rectangular cells of sufficient size to hold all items, and then
   places the items in the cells, going across then down, and
   positioning each item at the (0,0) corner of the cell. The below
@@ -648,7 +647,8 @@ Grid {
   will not change. If you manually change the x or y properties in script, bind
   the x or y properties, use anchors on a child of a positioner, or have the
   width or height of a child depend on the position of a child, then the
-  positioner may exhibit strange behaviour.
+  positioner may exhibit strange behaviour. If you need to perform any of these
+  actions, consider positioning the items without the use of a Grid.
 */
 /*!
     \qmlproperty Transition Grid::add
@@ -658,12 +658,10 @@ Grid {
     as that is all the positioners affect. To animate other property change
     you will have to do so based on how you have changed those properties.
 
-    Added can mean that either the object has been created or
-    reparented, and thus is now a child or the positioner, or that the
+    An object is considered to be added to the positioner if it has been
+    created or reparented and thus is now a child or the positioner, or if the
     object has had its opacity increased from zero, and thus is now
     visible.
-
-
 */
 /*!
     \qmlproperty Transition Grid::move
@@ -714,18 +712,16 @@ QDeclarativeGrid::QDeclarativeGrid(QDeclarativeItem *parent) :
     \qmlproperty int Grid::columns
     This property holds the number of columns in the grid.
 
-    When the columns property is set the Grid will always have
-    that many columns. Note that if you do not have enough items to
-    fill this many columns some columns will be of zero width.
+    If the grid does not have enough items to fill the specified
+    number of columns, some columns will be of zero width.
 */
 
 /*!
     \qmlproperty int Grid::rows
     This property holds the number of rows in the grid.
 
-    When the rows property is set the Grid will always have that
-    many rows. Note that if you do not have enough items to fill this
-    many rows some rows will be of zero width.
+    If the grid does not have enough items to fill the specified
+    number of rows, some rows will be of zero width.
 */
 
 void QDeclarativeGrid::setColumns(const int columns)
@@ -750,12 +746,14 @@ void QDeclarativeGrid::setRows(const int rows)
     \qmlproperty enumeration Grid::flow
     This property holds the flow of the layout.
 
-    Possible values are \c Grid.LeftToRight (default) and \c Grid.TopToBottom.
+    Possible values are:
 
-    If \a flow is \c Grid.LeftToRight, the items are positioned next to
-    to each other from left to right, then wrapped to the next line.
-    If \a flow is \c Grid.TopToBottom, the items are positioned next to each
-    other from top to bottom, then wrapped to the next column.
+    \list
+    \o Grid.LeftToRight (default) - Items are positioned next to
+       to each other from left to right, then wrapped to the next line.
+    \o Grid.TopToBottom - Items are positioned next to each
+       other from top to bottom, then wrapped to the next column.
+    \endlist
 */
 QDeclarativeGrid::Flow QDeclarativeGrid::flow() const
 {
@@ -893,14 +891,18 @@ void QDeclarativeGrid::reportConflictingAnchors()
 /*!
   \qmlclass Flow QDeclarativeFlow
   \since 4.7
-  \brief The Flow item lines up its children side by side, wrapping as necessary.
+  \brief The Flow item arranges its children side by side, wrapping as necessary.
   \inherits Item
 
+  The Flow item positions its child items so that they are side by side and are
+  not overlapping.
+
   Note that the positioner assumes that the x and y positions of its children
   will not change. If you manually change the x or y properties in script, bind
   the x or y properties, use anchors on a child of a positioner, or have the
   width or height of a child depend on the position of a child, then the
-  positioner may exhibit strange behaviour.
+  positioner may exhibit strange behaviour.  If you need to perform any of these
+  actions, consider positioning the items without the use of a Flow.
 
 */
 /*!
@@ -909,9 +911,10 @@ void QDeclarativeGrid::reportConflictingAnchors()
     The transition will only be applied to the added item(s).
     Positioner transitions will only affect the position (x,y) of items.
 
-    Added can mean that either the object has been created or reparented, and thus is now a child or the positioner, or that the object has had its opacity increased from zero, and thus is now visible.
-
-
+    An object is considered to be added to the positioner if it has been
+    created or reparented and thus is now a child or the positioner, or if the
+    object has had its opacity increased from zero, and thus is now
+    visible.
 */
 /*!
     \qmlproperty Transition Flow::move
@@ -965,14 +968,16 @@ QDeclarativeFlow::QDeclarativeFlow(QDeclarativeItem *parent)
     \qmlproperty enumeration Flow::flow
     This property holds the flow of the layout.
 
-    Possible values are \c Flow.LeftToRight (default) and \c Flow.TopToBottom.
+    Possible values are:
 
-    If \a flow is \c Flow.LeftToRight, the items are positioned next to
+    \list
+    \o Flow.LeftToRight (default) - Items are positioned next to
     to each other from left to right until the width of the Flow
     is exceeded, then wrapped to the next line.
-    If \a flow is \c Flow.TopToBottom, the items are positioned next to each
+    \o Flow.TopToBottom - Items are positioned next to each
     other from top to bottom until the height of the Flow is exceeded,
     then wrapped to the next column.
+    \endlist
 */
 QDeclarativeFlow::Flow QDeclarativeFlow::flow() const
 {
diff --git a/src/declarative/graphicsitems/qdeclarativerectangle.cpp b/src/declarative/graphicsitems/qdeclarativerectangle.cpp
index 301ca00..2756877 100644
--- a/src/declarative/graphicsitems/qdeclarativerectangle.cpp
+++ b/src/declarative/graphicsitems/qdeclarativerectangle.cpp
@@ -160,6 +160,8 @@ void QDeclarativeGradient::doUpdate()
     You can also create rounded rectangles using the \l radius property.
 
     \qml
+    import Qt 4.7
+
     Rectangle {
         width: 100
         height: 100
@@ -202,8 +204,20 @@ void QDeclarativeRectangle::doUpdate()
 
     A width of 1 creates a thin line. For no line, use a width of 0 or a transparent color.
 
-    To keep the border smooth (rather than blurry), odd widths cause the rectangle to be painted at
-    a half-pixel offset;
+    If \c border.width is an odd number, the rectangle is painted at a half-pixel offset to retain
+    border smoothness. Also, the border is rendered evenly on either side of the 
+    rectangle's boundaries, and the spare pixel is rendered to the right and below the
+    rectangle (as documented for QRect rendering). This can cause unintended effects if 
+    \c border.width is 1 and the rectangle is \l{Item::clip}{clipped} by a parent item:
+   
+    \table
+    \row
+    \o \snippet doc/src/snippets/declarative/rect-border-width.qml 0
+    \o \image rect-border-width.png
+    \endtable
+
+    Here, the innermost rectangle's border is clipped on the bottom and right edges by its
+    parent. To avoid this, the border width can be set to two instead of one.
 */
 QDeclarativePen *QDeclarativeRectangle::border()
 {
diff --git a/src/declarative/graphicsitems/qdeclarativerepeater.cpp b/src/declarative/graphicsitems/qdeclarativerepeater.cpp
index 04076f8..691cfa2 100644
--- a/src/declarative/graphicsitems/qdeclarativerepeater.cpp
+++ b/src/declarative/graphicsitems/qdeclarativerepeater.cpp
@@ -80,14 +80,20 @@ QDeclarativeRepeaterPrivate::~QDeclarativeRepeaterPrivate()
     The index is always exposed as an accessible \c index property.
     In the case of an object or string list, the data element (of type string
     or object) is available as the \c modelData property.  In the case of a Qt model,
-    all roles are available as named properties just like in the view classes. The
-    following example shows how to use the index property inside the instantiated
-    items.
+    all roles are available as named properties just like in the view classes. 
 
-    \snippet doc/src/snippets/declarative/repeater-index.qml 0
+    The following example shows how to use the \c index property inside the instantiated
+    items:
 
+    \snippet doc/src/snippets/declarative/repeater-index.qml 0
     \image repeater-index.png
 
+    The repeater could also use the \c modelData property to reference the data for a
+    particular index:
+
+    \snippet doc/src/snippets/declarative/repeater-modeldata.qml 0
+    \image repeater-modeldata.png
+
     Items instantiated by the Repeater are inserted, in order, as
     children of the Repeater's parent.  The insertion starts immediately after
     the repeater's position in its parent stacking list.  This is to allow
diff --git a/src/declarative/graphicsitems/qdeclarativescalegrid.cpp b/src/declarative/graphicsitems/qdeclarativescalegrid.cpp
index fe89190..a053aa0 100644
--- a/src/declarative/graphicsitems/qdeclarativescalegrid.cpp
+++ b/src/declarative/graphicsitems/qdeclarativescalegrid.cpp
@@ -130,8 +130,9 @@ QDeclarativeGridScaledImage::QDeclarativeGridScaledImage(QIODevice *data)
     int b = -1;
     QString imgFile;
 
-    while(!data->atEnd()) {
-        QString line = QString::fromUtf8(data->readLine().trimmed());
+    QByteArray raw;
+    while(raw = data->readLine(), !raw.isEmpty()) {
+        QString line = QString::fromUtf8(raw.trimmed());
         if (line.isEmpty() || line.startsWith(QLatin1Char('#')))
             continue;
 
diff --git a/src/declarative/graphicsitems/qdeclarativetext.cpp b/src/declarative/graphicsitems/qdeclarativetext.cpp
index 55cef8b..f4722c3 100644
--- a/src/declarative/graphicsitems/qdeclarativetext.cpp
+++ b/src/declarative/graphicsitems/qdeclarativetext.cpp
@@ -119,6 +119,8 @@ QSet<QUrl> QTextDocumentWithImageResources::errors;
     A Text item can display both plain and rich text. For example:
 
     \qml
+    import Qt 4.7
+
     Text { text: "Hello World!"; font.family: "Helvetica"; font.pointSize: 24; color: "red" }
     Text { text: "<b>Hello</b> <i>World!</i>" }
     \endqml
@@ -477,6 +479,7 @@ void QDeclarativeText::setHAlign(HAlignment align)
         return;
 
     d->hAlign = align;
+    update();
     emit horizontalAlignmentChanged(align);
 }
 
@@ -493,6 +496,7 @@ void QDeclarativeText::setVAlign(VAlignment align)
         return;
 
     d->vAlign = align;
+    update();
     emit verticalAlignmentChanged(align);
 }
 
diff --git a/src/declarative/graphicsitems/qdeclarativetextedit.cpp b/src/declarative/graphicsitems/qdeclarativetextedit.cpp
index 997c666..94973f2 100644
--- a/src/declarative/graphicsitems/qdeclarativetextedit.cpp
+++ b/src/declarative/graphicsitems/qdeclarativetextedit.cpp
@@ -89,6 +89,13 @@ TextEdit {
     A particular look-and-feel might use smooth scrolling (eg. using SmoothedFollow), might have a visible
     scrollbar, or a scrollbar that fades in to show location, etc.
 
+    Clipboard support is provided by the cut(), copy(), and paste() functions, and the selection can
+    be handled in a traditional "mouse" mechanism by setting selectByMouse, or handled completely
+    from QML by manipulating selectionStart and selectionEnd, or using selectAll() or selectWord().
+
+    You can translate between cursor positions (characters from the start of the document) and pixel
+    points using positionAt() and positionToRectangle().
+
     \sa Text
 */
 
@@ -541,6 +548,70 @@ qreal QDeclarativeTextEdit::paintedHeight() const
     return implicitHeight();
 }
 
+/*!
+    \qmlmethod rectangle TextEdit::positionToRectangle(position)
+
+    Returns the rectangle at the given \a position in the text. The x, y,
+    and height properties correspond to the cursor that would describe
+    that position.
+*/
+QRectF QDeclarativeTextEdit::positionToRectangle(int pos) const
+{
+    Q_D(const QDeclarativeTextEdit);
+    QTextCursor c(d->document);
+    c.setPosition(pos);
+    return d->control->cursorRect(c);
+
+}
+
+/*!
+    \qmlmethod int TextEdit::positionAt(x,y)
+
+    Returns the text position closest to pixel position (\a x,\a y).
+
+    Position 0 is before the first character, position 1 is after the first character
+    but before the second, and so on until position text.length, which is after all characters.
+*/
+int QDeclarativeTextEdit::positionAt(int x, int y) const
+{
+    Q_D(const QDeclarativeTextEdit);
+    int r = d->document->documentLayout()->hitTest(QPoint(x,y-d->yoff), Qt::FuzzyHit);
+    return r;
+}
+
+/*!
+    \qmlmethod int TextEdit::moveCursorSelection(int pos)
+
+    Moves the cursor to \a position and updates the selection accordingly.
+    (To only move the cursor, set the \l cursorPosition property.)
+
+    When this method is called it additionally sets either the
+    selectionStart or the selectionEnd (whichever was at the previous cursor position)
+    to the specified position. This allows you to easily extend and contract the selected
+    text range.
+
+    For example, take this sequence of calls:
+
+    \code
+        cursorPosition = 5
+        moveCursorSelection(9)
+        moveCursorSelection(7)
+    \endcode
+
+    This moves the cursor to position 5, extend the selection end from 5 to 9
+    and then retract the selection end from 9 to 7, leaving the text from position 5 to 7
+    selected (the 6th and 7th characters).
+*/
+void QDeclarativeTextEdit::moveCursorSelection(int pos)
+{
+    //Note that this is the same as setCursorPosition but with the KeepAnchor flag set
+    Q_D(QDeclarativeTextEdit);
+    QTextCursor cursor = d->control->textCursor();
+    if (cursor.position() == pos)
+        return;
+    cursor.setPosition(pos, QTextCursor::KeepAnchor);
+    d->control->setTextCursor(cursor);
+}
 
 /*!
     \qmlproperty bool TextEdit::cursorVisible
@@ -656,12 +727,9 @@ void QDeclarativeTextEdit::loadCursorDelegate()
     \qmlproperty int TextEdit::selectionStart
 
     The cursor position before the first character in the current selection.
-    Setting this and selectionEnd allows you to specify a selection in the
-    text edit.
 
-    Note that if selectionStart == selectionEnd then there is no current
-    selection. If you attempt to set selectionStart to a value outside of
-    the current text, selectionStart will not be changed.
+    This property is read-only. To change the selection, use select(start,end),
+    selectAll(), or selectWord().
 
     \sa selectionEnd, cursorPosition, selectedText
 */
@@ -671,25 +739,13 @@ int QDeclarativeTextEdit::selectionStart() const
     return d->control->textCursor().selectionStart();
 }
 
-void QDeclarativeTextEdit::setSelectionStart(int s)
-{
-    Q_D(QDeclarativeTextEdit);
-    if(d->lastSelectionStart == s || s < 0 || s > text().length())
-        return;
-    d->lastSelectionStart = s;
-    d->updateSelection();// Will emit the relevant signals
-}
-
 /*!
     \qmlproperty int TextEdit::selectionEnd
 
     The cursor position after the last character in the current selection.
-    Setting this and selectionStart allows you to specify a selection in the
-    text edit.
 
-    Note that if selectionStart == selectionEnd then there is no current
-    selection. If you attempt to set selectionEnd to a value outside of
-    the current text, selectionEnd will not be changed.
+    This property is read-only. To change the selection, use select(start,end),
+    selectAll(), or selectWord().
 
     \sa selectionStart, cursorPosition, selectedText
 */
@@ -699,15 +755,6 @@ int QDeclarativeTextEdit::selectionEnd() const
     return d->control->textCursor().selectionEnd();
 }
 
-void QDeclarativeTextEdit::setSelectionEnd(int s)
-{
-    Q_D(QDeclarativeTextEdit);
-    if(d->lastSelectionEnd == s || s < 0 || s > text().length())
-        return;
-    d->lastSelectionEnd = s;
-    d->updateSelection();// Will emit the relevant signals
-}
-
 /*!
     \qmlproperty string TextEdit::selectedText
 
@@ -957,6 +1004,8 @@ void QDeclarativeTextEditPrivate::focusChanged(bool hasFocus)
 }
 
 /*!
+    \qmlmethod void TextEdit::selectAll()
+
     Causes all text to be selected.
 */
 void QDeclarativeTextEdit::selectAll()
@@ -966,6 +1015,83 @@ void QDeclarativeTextEdit::selectAll()
 }
 
 /*!
+    \qmlmethod void TextEdit::selectWord()
+
+    Causes the word closest to the current cursor position to be selected.
+*/
+void QDeclarativeTextEdit::selectWord()
+{
+    Q_D(QDeclarativeTextEdit);
+    QTextCursor c = d->control->textCursor();
+    c.select(QTextCursor::WordUnderCursor);
+    d->control->setTextCursor(c);
+}
+
+/*!
+    \qmlmethod void TextEdit::select(start,end)
+
+    Causes the text from \a start to \a end to be selected.
+
+    If either start or end is out of range, the selection is not changed.
+
+    After calling this, selectionStart will become the lesser
+    and selectionEnd will become the greater (regardless of the order passed
+    to this method).
+
+    \sa selectionStart, selectionEnd
+*/
+void QDeclarativeTextEdit::select(int start, int end)
+{
+    Q_D(QDeclarativeTextEdit);
+    if (start < 0 || end < 0 || start > d->text.length() || end > d->text.length())
+        return;
+    QTextCursor cursor = d->control->textCursor();
+    cursor.beginEditBlock();
+    cursor.setPosition(start, QTextCursor::MoveAnchor);
+    cursor.setPosition(end, QTextCursor::KeepAnchor);
+    cursor.endEditBlock();
+    d->control->setTextCursor(cursor);
+
+    // QTBUG-11100
+    updateSelectionMarkers();
+}
+
+#ifndef QT_NO_CLIPBOARD
+/*!
+    \qmlmethod TextEdit::cut()
+
+    Moves the currently selected text to the system clipboard.
+*/
+void QDeclarativeTextEdit::cut()
+{
+    Q_D(QDeclarativeTextEdit);
+    d->control->cut();
+}
+
+/*!
+    \qmlmethod TextEdit::copy()
+
+    Copies the currently selected text to the system clipboard.
+*/
+void QDeclarativeTextEdit::copy()
+{
+    Q_D(QDeclarativeTextEdit);
+    d->control->copy();
+}
+
+/*!
+    \qmlmethod TextEdit::paste()
+
+    Relaces the currently selected text by the contents of the system clipboard.
+*/
+void QDeclarativeTextEdit::paste()
+{
+    Q_D(QDeclarativeTextEdit);
+    d->control->paste();
+}
+#endif // QT_NO_CLIPBOARD
+
+/*!
 \overload
 Handles the given mouse \a event.
 */
@@ -981,9 +1107,15 @@ void QDeclarativeTextEdit::mousePressEvent(QGraphicsSceneMouseEvent *event)
             p = p->parentItem();
         }
         setFocus(true);
-        if (hasFocus() == hadFocus && d->showInputPanelOnFocus && !isReadOnly()) {
-            // re-open input panel on press if already focused
-            openSoftwareInputPanel();
+        if (d->showInputPanelOnFocus) {
+            if (hasFocus() && hadFocus && !isReadOnly()) {
+                // re-open input panel on press if already focused
+                openSoftwareInputPanel();
+            }
+        } else { // show input panel on click
+            if (hasFocus() && !hadFocus) {
+                d->clickCausedFocus = true;
+            }
         }
     }
     if (event->type() != QEvent::GraphicsSceneMouseDoubleClick || d->selectByMouse)
@@ -1000,6 +1132,17 @@ void QDeclarativeTextEdit::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
 {
     Q_D(QDeclarativeTextEdit);
     d->control->processEvent(event, QPointF(0, -d->yoff));
+    if (!d->showInputPanelOnFocus) { // input panel on click
+        if (d->focusOnPress && !isReadOnly() && boundingRect().contains(event->pos())) {
+            if (QGraphicsView * view = qobject_cast<QGraphicsView*>(qApp->focusWidget())) {
+                if (view->scene() && view->scene() == scene()) {
+                    qt_widget_private(view)->handleSoftwareInputPanel(event->button(), d->clickCausedFocus);
+                }
+            }
+        }
+    }
+    d->clickCausedFocus = false;
+
     if (!event->isAccepted())
         QDeclarativePaintedItem::mouseReleaseEvent(event);
 }
@@ -1076,9 +1219,14 @@ void QDeclarativeTextEdit::drawContents(QPainter *painter, const QRect &bounds)
 void QDeclarativeTextEdit::updateImgCache(const QRectF &rf)
 {
     Q_D(const QDeclarativeTextEdit);
-    QRect r = rf.toRect();
-    if (r != QRect(0,0,INT_MAX,INT_MAX)) // Don't translate "everything"
-        r = r.translated(0,d->yoff);
+    QRect r;
+    if (!rf.isValid()) {
+        r = QRect(0,0,INT_MAX,INT_MAX);
+    } else {
+        r = rf.toRect();
+        if (r != QRect(0,0,INT_MAX,INT_MAX)) // Don't translate "everything"
+            r = r.translated(0,d->yoff);
+    }
     dirtyCache(r);
     emit update();
 }
@@ -1148,7 +1296,6 @@ void QDeclarativeTextEditPrivate::updateSelection()
     QTextCursor cursor = control->textCursor();
     bool startChange = (lastSelectionStart != cursor.selectionStart());
     bool endChange = (lastSelectionEnd != cursor.selectionEnd());
-    //### Is it worth calculating a more minimal set of movements?
     cursor.beginEditBlock();
     cursor.setPosition(lastSelectionStart, QTextCursor::MoveAnchor);
     cursor.setPosition(lastSelectionEnd, QTextCursor::KeepAnchor);
@@ -1158,8 +1305,6 @@ void QDeclarativeTextEditPrivate::updateSelection()
         q->selectionStartChanged();
     if(endChange)
         q->selectionEndChanged();
-    startChange = (lastSelectionStart != control->textCursor().selectionStart());
-    endChange = (lastSelectionEnd != control->textCursor().selectionEnd());
 }
 
 void QDeclarativeTextEdit::updateSelectionMarkers()
@@ -1245,10 +1390,14 @@ void QDeclarativeTextEditPrivate::updateDefaultTextOption()
     customizing when you want the input keyboard to be shown and hidden in
     your application.
 
-    By default input panels are shown when TextEdit element gains focus and hidden
-    when the focus is lost. You can disable the automatic behavior by setting the
-    property showInputPanelOnFocus to false and use functions openSoftwareInputPanel()
-    and closeSoftwareInputPanel() to implement the behavior you want.
+    By default the opening of input panels follows the platform style. On Symbian^1 and
+    Symbian^3 -based devices the panels are opened by clicking TextEdit and need to be
+    manually closed by the user. On other platforms the panels are automatically opened
+    when TextEdit element gains focus and closed when the focus is lost.
+
+  . You can disable the automatic behavior by setting the property \c focusOnPress to false
+    and use functions openSoftwareInputPanel() and closeSoftwareInputPanel() to implement
+    the behavior you want.
 
     Only relevant on platforms, which provide virtual keyboards.
 
@@ -1257,12 +1406,19 @@ void QDeclarativeTextEditPrivate::updateDefaultTextOption()
         TextEdit {
             id: textEdit
             text: "Hello world!"
-            showInputPanelOnFocus: false
+            focusOnPress: false
             MouseArea {
                 anchors.fill: parent
-                onClicked: textEdit.openSoftwareInputPanel()
+                onClicked: {
+                    if (!textEdit.focus) {
+                        textEdit.focus = true;
+                        textEdit.openSoftwareInputPanel();
+                    } else {
+                        textEdit.focus = false;
+                        textEdit.closeSoftwareInputPanel();
+                    }
+                }
             }
-            onFocusChanged: if (!focus) closeSoftwareInputpanel()
         }
     \endcode
 */
@@ -1285,10 +1441,14 @@ void QDeclarativeTextEdit::openSoftwareInputPanel()
     for customizing when you want the input keyboard to be shown and hidden in
     your application.
 
-    By default input panels are shown when TextEdit element gains focus and hidden
-    when the focus is lost. You can disable the automatic behavior by setting the
-    property showInputPanelOnFocus to false and use functions openSoftwareInputPanel()
-    and closeSoftwareInputPanel() to implement the behavior you want.
+    By default the opening of input panels follows the platform style. On Symbian^1 and
+    Symbian^3 -based devices the panels are opened by clicking TextEdit and need to be
+    manually closed by the user. On other platforms the panels are automatically opened
+    when TextEdit element gains focus and closed when the focus is lost.
+
+  . You can disable the automatic behavior by setting the property \c focusOnPress to false
+    and use functions openSoftwareInputPanel() and closeSoftwareInputPanel() to implement
+    the behavior you want.
 
     Only relevant on platforms, which provide virtual keyboards.
 
@@ -1297,12 +1457,19 @@ void QDeclarativeTextEdit::openSoftwareInputPanel()
         TextEdit {
             id: textEdit
             text: "Hello world!"
-            showInputPanelOnFocus: false
+            focusOnPress: false
             MouseArea {
                 anchors.fill: parent
-                onClicked: textEdit.openSoftwareInputPanel()
+                onClicked: {
+                    if (!textEdit.focus) {
+                        textEdit.focus = true;
+                        textEdit.openSoftwareInputPanel();
+                    } else {
+                        textEdit.focus = false;
+                        textEdit.closeSoftwareInputPanel();
+                    }
+                }
             }
-            onFocusChanged: if (!focus) closeSoftwareInputpanel()
         }
     \endcode
 */
@@ -1318,35 +1485,13 @@ void QDeclarativeTextEdit::closeSoftwareInputPanel()
     }
 }
 
-/*!
-    \qmlproperty bool TextEdit::showInputPanelOnFocus
-    Whether input panels are automatically shown when TextEdit element gains
-    focus and hidden when focus is lost. By default this is set to true.
-
-    Only relevant on platforms, which provide virtual keyboards.
-*/
-bool QDeclarativeTextEdit::showInputPanelOnFocus() const
-{
-    Q_D(const QDeclarativeTextEdit);
-    return d->showInputPanelOnFocus;
-}
-
-void QDeclarativeTextEdit::setShowInputPanelOnFocus(bool showOnFocus)
-{
-    Q_D(QDeclarativeTextEdit);
-    if (d->showInputPanelOnFocus == showOnFocus)
-        return;
-
-    d->showInputPanelOnFocus = showOnFocus;
-
-    emit showInputPanelOnFocusChanged(d->showInputPanelOnFocus);
-}
-
 void QDeclarativeTextEdit::focusInEvent(QFocusEvent *event)
 {
     Q_D(const QDeclarativeTextEdit);
-    if (d->showInputPanelOnFocus && !isReadOnly() && event->reason() != Qt::ActiveWindowFocusReason) {
-        openSoftwareInputPanel();
+    if (d->showInputPanelOnFocus) {
+        if (d->focusOnPress && !isReadOnly() && event->reason() != Qt::ActiveWindowFocusReason) {
+            openSoftwareInputPanel();
+        }
     }
     QDeclarativePaintedItem::focusInEvent(event);
 }
@@ -1354,8 +1499,10 @@ void QDeclarativeTextEdit::focusInEvent(QFocusEvent *event)
 void QDeclarativeTextEdit::focusOutEvent(QFocusEvent *event)
 {
     Q_D(const QDeclarativeTextEdit);
-    if (d->showInputPanelOnFocus && !isReadOnly()) {
-        closeSoftwareInputPanel();
+    if (d->showInputPanelOnFocus) {
+        if (d->focusOnPress && !isReadOnly()) {
+            closeSoftwareInputPanel();
+        }
     }
     QDeclarativePaintedItem::focusOutEvent(event);
 }
diff --git a/src/declarative/graphicsitems/qdeclarativetextedit_p.h b/src/declarative/graphicsitems/qdeclarativetextedit_p.h
index 47174f4..0ecb2f3 100644
--- a/src/declarative/graphicsitems/qdeclarativetextedit_p.h
+++ b/src/declarative/graphicsitems/qdeclarativetextedit_p.h
@@ -82,11 +82,10 @@ class Q_DECLARATIVE_EXPORT QDeclarativeTextEdit : public QDeclarativePaintedItem
     Q_PROPERTY(int cursorPosition READ cursorPosition WRITE setCursorPosition NOTIFY cursorPositionChanged)
     Q_PROPERTY(QRect cursorRectangle READ cursorRectangle NOTIFY cursorRectangleChanged)
     Q_PROPERTY(QDeclarativeComponent* cursorDelegate READ cursorDelegate WRITE setCursorDelegate NOTIFY cursorDelegateChanged)
-    Q_PROPERTY(int selectionStart READ selectionStart WRITE setSelectionStart NOTIFY selectionStartChanged)
-    Q_PROPERTY(int selectionEnd READ selectionEnd WRITE setSelectionEnd NOTIFY selectionEndChanged)
+    Q_PROPERTY(int selectionStart READ selectionStart NOTIFY selectionStartChanged)
+    Q_PROPERTY(int selectionEnd READ selectionEnd NOTIFY selectionEndChanged)
     Q_PROPERTY(QString selectedText READ selectedText NOTIFY selectionChanged)
     Q_PROPERTY(bool focusOnPress READ focusOnPress WRITE setFocusOnPress NOTIFY focusOnPressChanged)
-    Q_PROPERTY(bool showInputPanelOnFocus READ showInputPanelOnFocus WRITE setShowInputPanelOnFocus NOTIFY showInputPanelOnFocusChanged)
     Q_PROPERTY(bool persistentSelection READ persistentSelection WRITE setPersistentSelection NOTIFY persistentSelectionChanged)
     Q_PROPERTY(qreal textMargin READ textMargin WRITE setTextMargin NOTIFY textMarginChanged)
     Q_PROPERTY(Qt::InputMethodHints inputMethodHints READ inputMethodHints WRITE setInputMethodHints)
@@ -160,19 +159,13 @@ public:
     void setCursorDelegate(QDeclarativeComponent*);
 
     int selectionStart() const;
-    void setSelectionStart(int);
-
     int selectionEnd() const;
-    void setSelectionEnd(int);
 
     QString selectedText() const;
 
     bool focusOnPress() const;
     void setFocusOnPress(bool on);
 
-    bool showInputPanelOnFocus() const;
-    void setShowInputPanelOnFocus(bool showOnFocus);
-
     bool persistentSelection() const;
     void setPersistentSelection(bool on);
 
@@ -198,6 +191,10 @@ public:
     qreal paintedWidth() const;
     qreal paintedHeight() const;
 
+    Q_INVOKABLE QRectF positionToRectangle(int) const;
+    Q_INVOKABLE int positionAt(int x, int y) const;
+    Q_INVOKABLE void moveCursorSelection(int pos);
+
 Q_SIGNALS:
     void textChanged(const QString &);
     void paintedSizeChanged();
@@ -221,10 +218,16 @@ Q_SIGNALS:
     void persistentSelectionChanged(bool isPersistentSelection);
     void textMarginChanged(qreal textMargin);
     void selectByMouseChanged(bool selectByMouse);
-    void showInputPanelOnFocusChanged(bool showOnFocus);
 
 public Q_SLOTS:
     void selectAll();
+    void selectWord();
+    void select(int start, int end);
+#ifndef QT_NO_CLIPBOARD
+    void cut();
+    void copy();
+    void paste();
+#endif
 
 private Q_SLOTS:
     void updateImgCache(const QRectF &rect);
diff --git a/src/declarative/graphicsitems/qdeclarativetextedit_p_p.h b/src/declarative/graphicsitems/qdeclarativetextedit_p_p.h
index 8e1d630..4092e65 100644
--- a/src/declarative/graphicsitems/qdeclarativetextedit_p_p.h
+++ b/src/declarative/graphicsitems/qdeclarativetextedit_p_p.h
@@ -70,12 +70,17 @@ public:
     QDeclarativeTextEditPrivate()
       : color("black"), hAlign(QDeclarativeTextEdit::AlignLeft), vAlign(QDeclarativeTextEdit::AlignTop),
       imgDirty(true), dirty(false), richText(false), cursorVisible(false), focusOnPress(true),
-      showInputPanelOnFocus(true), persistentSelection(true), textMargin(0.0), lastSelectionStart(0),
-      lastSelectionEnd(0), cursorComponent(0), cursor(0), format(QDeclarativeTextEdit::AutoText),
-      document(0), wrapMode(QDeclarativeTextEdit::NoWrap),
+      showInputPanelOnFocus(true), clickCausedFocus(false), persistentSelection(true), textMargin(0.0),
+      lastSelectionStart(0), lastSelectionEnd(0), cursorComponent(0), cursor(0),
+      format(QDeclarativeTextEdit::AutoText), document(0), wrapMode(QDeclarativeTextEdit::NoWrap),
       selectByMouse(false),
       yoff(0)
     {
+#ifdef Q_OS_SYMBIAN
+        if (QSysInfo::symbianVersion() == QSysInfo::SV_SF_1 || QSysInfo::symbianVersion() == QSysInfo::SV_SF_3) {
+            showInputPanelOnFocus = false;
+        }
+#endif
     }
 
     void init();
@@ -102,6 +107,7 @@ public:
     bool cursorVisible : 1;
     bool focusOnPress : 1;
     bool showInputPanelOnFocus : 1;
+    bool clickCausedFocus : 1;
     bool persistentSelection : 1;
     qreal textMargin;
     int lastSelectionStart;
diff --git a/src/declarative/graphicsitems/qdeclarativetextinput.cpp b/src/declarative/graphicsitems/qdeclarativetextinput.cpp
index 305540f..8d320f4 100644
--- a/src/declarative/graphicsitems/qdeclarativetextinput.cpp
+++ b/src/declarative/graphicsitems/qdeclarativetextinput.cpp
@@ -46,6 +46,7 @@
 #include <qdeclarativeinfo.h>
 
 #include <QValidator>
+#include <QTextCursor>
 #include <QApplication>
 #include <QFontMetrics>
 #include <QPainter>
@@ -429,10 +430,12 @@ void QDeclarativeTextInput::setCursorPosition(int cp)
   Returns a Rect which encompasses the cursor, but which may be larger than is
   required. Ignores custom cursor delegates.
 */
-QRect QDeclarativeTextInput::cursorRect() const
+QRect QDeclarativeTextInput::cursorRectangle() const
 {
     Q_D(const QDeclarativeTextInput);
-    return d->control->cursorRect();
+    QRect r = d->control->cursorRect();
+    r.setHeight(r.height()-1); // Make consistent with TextEdit (QLineControl inexplicably adds 1)
+    return r;
 }
 
 /*!
@@ -454,15 +457,6 @@ int QDeclarativeTextInput::selectionStart() const
     return d->lastSelectionStart;
 }
 
-void QDeclarativeTextInput::setSelectionStart(int s)
-{
-    Q_D(QDeclarativeTextInput);
-    if(d->lastSelectionStart == s || s < 0 || s > text().length())
-        return;
-    d->lastSelectionStart = s;
-    d->control->setSelection(s, d->lastSelectionEnd - s);
-}
-
 /*!
     \qmlproperty int TextInput::selectionEnd
 
@@ -482,13 +476,12 @@ int QDeclarativeTextInput::selectionEnd() const
     return d->lastSelectionEnd;
 }
 
-void QDeclarativeTextInput::setSelectionEnd(int s)
+void QDeclarativeTextInput::select(int start, int end)
 {
     Q_D(QDeclarativeTextInput);
-    if(d->lastSelectionEnd == s || s < 0 || s > text().length())
+    if (start < 0 || end < 0 || start > d->control->text().length() || end > d->control->text().length())
         return;
-    d->lastSelectionEnd = s;
-    d->control->setSelection(d->lastSelectionStart, s - d->lastSelectionStart);
+    d->control->setSelection(start, end-start);
 }
 
 /*!
@@ -835,7 +828,20 @@ void QDeclarativeTextInput::moveCursor()
 }
 
 /*!
-    \qmlmethod int TextInput::xToPosition(int x)
+    \qmlmethod rect TextInput::positionToRectangle(int x)
+*/
+QRectF QDeclarativeTextInput::positionToRectangle(int x) const
+{
+    Q_D(const QDeclarativeTextInput);
+    QFontMetrics fm = QFontMetrics(d->font);
+    return QRectF(d->control->cursorToX(x)-d->hscroll,
+        0.0,
+        d->control->cursorWidth(),
+        cursorRectangle().height());
+}
+
+/*!
+    \qmlmethod int TextInput::positionAt(int x)
 
     This function returns the character position at
     x pixels from the left of the textInput. Position 0 is before the
@@ -845,10 +851,10 @@ void QDeclarativeTextInput::moveCursor()
     This means that for all x values before the first character this function returns 0,
     and for all x values after the last character this function returns text.length.
 */
-int QDeclarativeTextInput::xToPosition(int x)
+int QDeclarativeTextInput::positionAt(int x) const
 {
     Q_D(const QDeclarativeTextInput);
-    return d->control->xToPos(x - d->hscroll);
+    return d->control->xToPos(x + d->hscroll);
 }
 
 void QDeclarativeTextInputPrivate::focusChanged(bool hasFocus)
@@ -885,6 +891,22 @@ void QDeclarativeTextInput::keyPressEvent(QKeyEvent* ev)
         QDeclarativePaintedItem::keyPressEvent(ev);
 }
 
+/*!
+\overload
+Handles the given mouse \a event.
+*/
+void QDeclarativeTextInput::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)
+{
+    Q_D(QDeclarativeTextInput);
+    if (d->selectByMouse) {
+        int cursor = d->xToPos(event->pos().x());
+        d->control->selectWordAtPos(cursor);
+        event->setAccepted(true);
+    } else {
+        QDeclarativePaintedItem::mouseDoubleClickEvent(event);
+    }
+}
+
 void QDeclarativeTextInput::mousePressEvent(QGraphicsSceneMouseEvent *event)
 {
     Q_D(QDeclarativeTextInput);
@@ -897,12 +919,17 @@ void QDeclarativeTextInput::mousePressEvent(QGraphicsSceneMouseEvent *event)
             p = p->parentItem();
         }
         setFocus(true);
-        if (hasFocus() == hadFocus && d->showInputPanelOnFocus && !isReadOnly()) {
-            // re-open input panel on press w already focused
-            openSoftwareInputPanel();
+        if (d->showInputPanelOnFocus) {
+            if (hasFocus() && hadFocus && !isReadOnly()) {
+                // re-open input panel on press if already focused
+                openSoftwareInputPanel();
+            }
+        } else { // show input panel on click
+            if (hasFocus() && !hadFocus) {
+                d->clickCausedFocus = true;
+            }
         }
     }
-
     bool mark = event->modifiers() & Qt::ShiftModifier;
     int cursor = d->xToPos(event->pos().x());
     d->control->moveCursor(cursor, mark);
@@ -927,6 +954,16 @@ Handles the given mouse \a event.
 void QDeclarativeTextInput::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
 {
     Q_D(QDeclarativeTextInput);
+    if (!d->showInputPanelOnFocus) { // input panel on click
+        if (d->focusOnPress && !isReadOnly() && boundingRect().contains(event->pos())) {
+            if (QGraphicsView * view = qobject_cast<QGraphicsView*>(qApp->focusWidget())) {
+                if (view->scene() && view->scene() == scene()) {
+                    qt_widget_private(view)->handleSoftwareInputPanel(event->button(), d->clickCausedFocus);
+                }
+            }
+        }
+    }
+    d->clickCausedFocus = false;
     d->control->processEvent(event);
     if (!event->isAccepted())
         QDeclarativePaintedItem::mouseReleaseEvent(event);
@@ -943,10 +980,9 @@ bool QDeclarativeTextInput::event(QEvent* ev)
         case QEvent::GraphicsSceneMousePress:
         case QEvent::GraphicsSceneMouseMove:
         case QEvent::GraphicsSceneMouseRelease:
+        case QEvent::GraphicsSceneMouseDoubleClick:
             break;
         default:
-            if (ev->type() == QEvent::GraphicsSceneMouseDoubleClick && !d->selectByMouse)
-                break;
             handled = d->control->processEvent(ev);
             if (ev->type() == QEvent::InputMethod)
                 updateSize();
@@ -1021,7 +1057,6 @@ void QDeclarativeTextInput::drawContents(QPainter *p, const QRect &r)
         d->hscroll -= minLB;
         offset = QPoint(d->hscroll, 0);
     }
-
     d->control->draw(p, offset, r, flags);
 
     p->restore();
@@ -1059,12 +1094,27 @@ QVariant QDeclarativeTextInput::inputMethodQuery(Qt::InputMethodQuery property)
     }
 }
 
+/*!
+    \qmlmethod void TextInput::selectAll()
+
+    Causes all text to be selected.
+*/
 void QDeclarativeTextInput::selectAll()
 {
     Q_D(QDeclarativeTextInput);
     d->control->setSelection(0, d->control->text().length());
 }
 
+/*!
+    \qmlmethod void TextInput::selectWord()
+
+    Causes the word closest to the current cursor position to be selected.
+*/
+void QDeclarativeTextInput::selectWord()
+{
+    Q_D(QDeclarativeTextInput);
+    d->control->selectWordAtPos(d->control->cursor());
+}
 
 /*!
     \qmlproperty bool TextInput::smooth
@@ -1183,26 +1233,37 @@ void QDeclarativeTextInput::moveCursorSelection(int position)
     customizing when you want the input keyboard to be shown and hidden in
     your application.
 
-    By default input panels are shown when TextInput element gains focus and hidden
-    when the focus is lost. You can disable the automatic behavior by setting the
-    property showInputPanelOnFocus to false and use functions openSoftwareInputPanel()
-    and closeSoftwareInputPanel() to implement the behavior you want.
+    By default the opening of input panels follows the platform style. On Symbian^1 and
+    Symbian^3 -based devices the panels are opened by clicking TextInput and need to be
+    manually closed by the user. On other platforms the panels are automatically opened
+    when TextInput element gains focus and closed when the focus is lost.
+
+  . You can disable the automatic behavior by setting the property \c focusOnPress to false
+    and use functions openSoftwareInputPanel() and closeSoftwareInputPanel() to implement
+    the behavior you want.
 
     Only relevant on platforms, which provide virtual keyboards.
 
-    \code
+    \qml
         import Qt 4.7
         TextInput {
             id: textInput
             text: "Hello world!"
-            showInputPanelOnFocus: false
+            focusOnPress: false
             MouseArea {
                 anchors.fill: parent
-                onClicked: textInput.openSoftwareInputPanel()
+                onClicked: {
+                    if (!textInput.focus) {
+                        textInput.focus = true;
+                        textInput.openSoftwareInputPanel();
+                    } else {
+                        textInput.focus = false;
+                        textInput.closeSoftwareInputPanel();
+                    }
+                }
             }
-            onFocusChanged: if (!focus) closeSoftwareInputPanel()
         }
-    \endcode
+    \endqml
 */
 void QDeclarativeTextInput::openSoftwareInputPanel()
 {
@@ -1223,26 +1284,37 @@ void QDeclarativeTextInput::openSoftwareInputPanel()
     for customizing when you want the input keyboard to be shown and hidden in
     your application.
 
-    By default input panels are shown when TextInput element gains focus and hidden
-    when the focus is lost. You can disable the automatic behavior by setting the
-    property showInputPanelOnFocus to false and use functions openSoftwareInputPanel()
-    and closeSoftwareInputPanel() to implement the behavior you want.
+    By default the opening of input panels follows the platform style. On Symbian^1 and
+    Symbian^3 -based devices the panels are opened by clicking TextInput and need to be
+    manually closed by the user. On other platforms the panels are automatically opened
+    when TextInput element gains focus and closed when the focus is lost.
+
+  . You can disable the automatic behavior by setting the property \c focusOnPress to false
+    and use functions openSoftwareInputPanel() and closeSoftwareInputPanel() to implement
+    the behavior you want.
 
     Only relevant on platforms, which provide virtual keyboards.
 
-    \code
+    \qml
         import Qt 4.7
         TextInput {
             id: textInput
             text: "Hello world!"
-            showInputPanelOnFocus: false
+            focusOnPress: false
             MouseArea {
                 anchors.fill: parent
-                onClicked: textInput.openSoftwareInputPanel()
+                onClicked: {
+                    if (!textInput.focus) {
+                        textInput.focus = true;
+                        textInput.openSoftwareInputPanel();
+                    } else {
+                        textInput.focus = false;
+                        textInput.closeSoftwareInputPanel();
+                    }
+                }
             }
-            onFocusChanged: if (!focus) closeSoftwareInputPanel()
         }
-    \endcode
+    \endqml
 */
 void QDeclarativeTextInput::closeSoftwareInputPanel()
 {
@@ -1257,35 +1329,13 @@ void QDeclarativeTextInput::closeSoftwareInputPanel()
     }
 }
 
-/*!
-    \qmlproperty bool TextInput::showInputPanelOnFocus
-    Whether input panels are automatically shown when TextInput element gains
-    focus and hidden when focus is lost. By default this is set to true.
-
-    Only relevant on platforms, which provide virtual keyboards.
-*/
-bool QDeclarativeTextInput::showInputPanelOnFocus() const
-{
-    Q_D(const QDeclarativeTextInput);
-    return d->showInputPanelOnFocus;
-}
-
-void QDeclarativeTextInput::setShowInputPanelOnFocus(bool showOnFocus)
-{
-    Q_D(QDeclarativeTextInput);
-    if (d->showInputPanelOnFocus == showOnFocus)
-        return;
-
-    d->showInputPanelOnFocus = showOnFocus;
-
-    emit showInputPanelOnFocusChanged(d->showInputPanelOnFocus);
-}
-
 void QDeclarativeTextInput::focusInEvent(QFocusEvent *event)
 {
     Q_D(const QDeclarativeTextInput);
-    if (d->showInputPanelOnFocus && !isReadOnly() && event->reason() != Qt::ActiveWindowFocusReason) {
-        openSoftwareInputPanel();
+    if (d->showInputPanelOnFocus) {
+        if (d->focusOnPress && !isReadOnly() && event->reason() != Qt::ActiveWindowFocusReason) {
+            openSoftwareInputPanel();
+        }
     }
     QDeclarativePaintedItem::focusInEvent(event);
 }
@@ -1293,8 +1343,10 @@ void QDeclarativeTextInput::focusInEvent(QFocusEvent *event)
 void QDeclarativeTextInput::focusOutEvent(QFocusEvent *event)
 {
     Q_D(const QDeclarativeTextInput);
-    if (d->showInputPanelOnFocus && !isReadOnly()) {
-        closeSoftwareInputPanel();
+    if (d->showInputPanelOnFocus) {
+        if (d->focusOnPress && !isReadOnly()) {
+            closeSoftwareInputPanel();
+        }
     }
     QDeclarativePaintedItem::focusOutEvent(event);
 }
@@ -1304,7 +1356,6 @@ void QDeclarativeTextInputPrivate::init()
     Q_Q(QDeclarativeTextInput);
     control->setCursorWidth(1);
     control->setPasswordCharacter(QLatin1Char('*'));
-    control->setLayoutDirection(Qt::LeftToRight);
     q->setSmooth(smooth);
     q->setAcceptedMouseButtons(Qt::LeftButton);
     q->setFlag(QGraphicsItem::ItemHasNoContents, false);
diff --git a/src/declarative/graphicsitems/qdeclarativetextinput_p.h b/src/declarative/graphicsitems/qdeclarativetextinput_p.h
index 3dba844..e34634a 100644
--- a/src/declarative/graphicsitems/qdeclarativetextinput_p.h
+++ b/src/declarative/graphicsitems/qdeclarativetextinput_p.h
@@ -72,10 +72,10 @@ class Q_DECLARATIVE_EXPORT QDeclarativeTextInput : public QDeclarativePaintedIte
     Q_PROPERTY(bool readOnly READ isReadOnly WRITE setReadOnly NOTIFY readOnlyChanged)
     Q_PROPERTY(bool cursorVisible READ isCursorVisible WRITE setCursorVisible NOTIFY cursorVisibleChanged)
     Q_PROPERTY(int cursorPosition READ cursorPosition WRITE setCursorPosition NOTIFY cursorPositionChanged)
-    Q_PROPERTY(QRect cursorRect READ cursorRect NOTIFY cursorPositionChanged)
+    Q_PROPERTY(QRect cursorRectangle READ cursorRectangle NOTIFY cursorPositionChanged)
     Q_PROPERTY(QDeclarativeComponent *cursorDelegate READ cursorDelegate WRITE setCursorDelegate NOTIFY cursorDelegateChanged)
-    Q_PROPERTY(int selectionStart READ selectionStart WRITE setSelectionStart NOTIFY selectionStartChanged)
-    Q_PROPERTY(int selectionEnd READ selectionEnd WRITE setSelectionEnd NOTIFY selectionEndChanged)
+    Q_PROPERTY(int selectionStart READ selectionStart NOTIFY selectionStartChanged)
+    Q_PROPERTY(int selectionEnd READ selectionEnd NOTIFY selectionEndChanged)
     Q_PROPERTY(QString selectedText READ selectedText NOTIFY selectedTextChanged)
 
     Q_PROPERTY(int maximumLength READ maxLength WRITE setMaxLength NOTIFY maximumLengthChanged)
@@ -88,7 +88,6 @@ class Q_DECLARATIVE_EXPORT QDeclarativeTextInput : public QDeclarativePaintedIte
     Q_PROPERTY(bool acceptableInput READ hasAcceptableInput NOTIFY acceptableInputChanged)
     Q_PROPERTY(EchoMode echoMode READ echoMode WRITE setEchoMode NOTIFY echoModeChanged)
     Q_PROPERTY(bool focusOnPress READ focusOnPress WRITE setFocusOnPress NOTIFY focusOnPressChanged)
-    Q_PROPERTY(bool showInputPanelOnFocus READ showInputPanelOnFocus WRITE setShowInputPanelOnFocus NOTIFY showInputPanelOnFocusChanged)
     Q_PROPERTY(QString passwordCharacter READ passwordCharacter WRITE setPasswordCharacter NOTIFY passwordCharacterChanged)
     Q_PROPERTY(QString displayText READ displayText NOTIFY displayTextChanged)
     Q_PROPERTY(bool autoScroll READ autoScroll WRITE setAutoScroll NOTIFY autoScrollChanged)
@@ -112,7 +111,8 @@ public:
     };
 
     //Auxilliary functions needed to control the TextInput from QML
-    Q_INVOKABLE int xToPosition(int x);
+    Q_INVOKABLE int positionAt(int x) const;
+    Q_INVOKABLE QRectF positionToRectangle(int x) const;
     Q_INVOKABLE void moveCursorSelection(int pos);
 
     Q_INVOKABLE void openSoftwareInputPanel();
@@ -145,13 +145,10 @@ public:
     int cursorPosition() const;
     void setCursorPosition(int cp);
 
-    QRect cursorRect() const;
+    QRect cursorRectangle() const;
 
     int selectionStart() const;
-    void setSelectionStart(int);
-
     int selectionEnd() const;
-    void setSelectionEnd(int);
 
     QString selectedText() const;
 
@@ -179,9 +176,6 @@ public:
     bool focusOnPress() const;
     void setFocusOnPress(bool);
 
-    bool showInputPanelOnFocus() const;
-    void setShowInputPanelOnFocus(bool showOnFocus);
-
     bool autoScroll() const;
     void setAutoScroll(bool);
 
@@ -218,7 +212,6 @@ Q_SIGNALS:
     void focusOnPressChanged(bool focusOnPress);
     void autoScrollChanged(bool autoScroll);
     void selectByMouseChanged(bool selectByMouse);
-    void showInputPanelOnFocusChanged(bool showOnFocus);
 
 protected:
     virtual void geometryChanged(const QRectF &newGeometry,
@@ -227,6 +220,7 @@ protected:
     void mousePressEvent(QGraphicsSceneMouseEvent *event);
     void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
     void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
+    void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event);
     void keyPressEvent(QKeyEvent* ev);
     bool event(QEvent *e);
     void focusInEvent(QFocusEvent *event);
@@ -234,6 +228,8 @@ protected:
 
 public Q_SLOTS:
     void selectAll();
+    void selectWord();
+    void select(int start, int end);
 
 private Q_SLOTS:
     void updateSize(bool needsRedraw = true);
diff --git a/src/declarative/graphicsitems/qdeclarativetextinput_p_p.h b/src/declarative/graphicsitems/qdeclarativetextinput_p_p.h
index f44d014..6865147 100644
--- a/src/declarative/graphicsitems/qdeclarativetextinput_p_p.h
+++ b/src/declarative/graphicsitems/qdeclarativetextinput_p_p.h
@@ -72,9 +72,15 @@ public:
                  color((QRgb)0), style(QDeclarativeText::Normal),
                  styleColor((QRgb)0), hAlign(QDeclarativeTextInput::AlignLeft),
                  hscroll(0), oldScroll(0), focused(false), focusOnPress(true),
-                 showInputPanelOnFocus(true), cursorVisible(false), autoScroll(true),
-                 selectByMouse(false)
+                 showInputPanelOnFocus(true), clickCausedFocus(false), cursorVisible(false),
+                 autoScroll(true), selectByMouse(false)
     {
+#ifdef Q_OS_SYMBIAN
+        if (QSysInfo::symbianVersion() == QSysInfo::SV_SF_1 || QSysInfo::symbianVersion() == QSysInfo::SV_SF_3) {
+            showInputPanelOnFocus = false;
+        }
+#endif
+
     }
 
     ~QDeclarativeTextInputPrivate()
@@ -116,6 +122,7 @@ public:
     bool focused;
     bool focusOnPress;
     bool showInputPanelOnFocus;
+    bool clickCausedFocus;
     bool cursorVisible;
     bool autoScroll;
     bool selectByMouse;
diff --git a/src/declarative/graphicsitems/qdeclarativevisualitemmodel.cpp b/src/declarative/graphicsitems/qdeclarativevisualitemmodel.cpp
index c6ee46f..2a88a80 100644
--- a/src/declarative/graphicsitems/qdeclarativevisualitemmodel.cpp
+++ b/src/declarative/graphicsitems/qdeclarativevisualitemmodel.cpp
@@ -119,11 +119,11 @@ public:
     visual delegate (items).
 
     An item can determine its index within the
-    model via the VisualItemModel.index attached property.
+    model via the \c VisualItemModel.index attached property.
 
     The example below places three colored rectangles in a ListView.
     \code
-    Item {
+    Rectangle {
         VisualItemModel {
             id: itemModel
             Rectangle { height: 30; width: 80; color: "red" }
@@ -137,6 +137,8 @@ public:
         }
     }
     \endcode
+
+    \image visualitemmodel.png
 */
 QDeclarativeVisualItemModel::QDeclarativeVisualItemModel(QObject *parent)
     : QDeclarativeVisualModel(*(new QDeclarativeVisualItemModelPrivate), parent)
diff --git a/src/declarative/qml/parser/qdeclarativejslexer.cpp b/src/declarative/qml/parser/qdeclarativejslexer.cpp
index 975ad4c..fcaaece 100644
--- a/src/declarative/qml/parser/qdeclarativejslexer.cpp
+++ b/src/declarative/qml/parser/qdeclarativejslexer.cpp
@@ -57,7 +57,7 @@
 #include <string.h>
 
 QT_BEGIN_NAMESPACE
-Q_DECL_IMPORT extern double qstrtod(const char *s00, char const **se, bool *ok);
+Q_CORE_EXPORT double qstrtod(const char *s00, char const **se, bool *ok);
 QT_END_NAMESPACE
 
 QT_QML_BEGIN_NAMESPACE
diff --git a/src/declarative/qml/qdeclarative.h b/src/declarative/qml/qdeclarative.h
index d75f0a8..53ff51c 100644
--- a/src/declarative/qml/qdeclarative.h
+++ b/src/declarative/qml/qdeclarative.h
@@ -67,7 +67,7 @@ QT_BEGIN_HEADER
     QML_DECLARE_TYPE_HASMETATYPE(INTERFACE)
 
 enum { /* TYPEINFO flags */
-    QML_HAS_ATTACHED_PROPERTIES = 0x01,
+    QML_HAS_ATTACHED_PROPERTIES = 0x01
 };
 
 #define QML_DECLARE_TYPEINFO(TYPE, FLAGS) \
diff --git a/src/declarative/qml/qdeclarativecomponent.cpp b/src/declarative/qml/qdeclarativecomponent.cpp
index 2dc2d2d..9847079 100644
--- a/src/declarative/qml/qdeclarativecomponent.cpp
+++ b/src/declarative/qml/qdeclarativecomponent.cpp
@@ -53,7 +53,7 @@
 #include "private/qdeclarativebinding_p_p.h"
 #include "private/qdeclarativeglobal_p.h"
 #include "private/qdeclarativescriptparser_p.h"
-#include "private/qdeclarativedebugtiming_p.h"
+#include "private/qdeclarativedebugtrace_p.h"
 
 #include <QStack>
 #include <QStringList>
@@ -696,7 +696,8 @@ QDeclarativeComponentPrivate::beginCreate(QDeclarativeContextData *context, cons
 
     bool isRoot = !ep->inBeginCreate;
     if (isRoot) 
-        QDeclarativeDebugTiming::startRange(QDeclarativeDebugTiming::Creating);
+        QDeclarativeDebugTrace::startRange(QDeclarativeDebugTrace::Creating);
+    QDeclarativeDebugTrace::rangeData(QDeclarativeDebugTrace::Creating, cc->url);
 
     QDeclarativeContextData *ctxt = new QDeclarativeContextData;
     ctxt->isInternal = true;
@@ -867,7 +868,7 @@ void QDeclarativeComponentPrivate::completeCreate()
         QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(engine);
         complete(ep, &state);
 
-        QDeclarativeDebugTiming::endRange(QDeclarativeDebugTiming::Creating);
+        QDeclarativeDebugTrace::endRange(QDeclarativeDebugTrace::Creating);
     }
 }
 
diff --git a/src/declarative/qml/qdeclarativecontext_p.h b/src/declarative/qml/qdeclarativecontext_p.h
index 6b6cd0a..1f5aaf1 100644
--- a/src/declarative/qml/qdeclarativecontext_p.h
+++ b/src/declarative/qml/qdeclarativecontext_p.h
@@ -108,7 +108,7 @@ public:
 
 class QDeclarativeComponentAttached;
 class QDeclarativeGuardedContextData;
-class QDeclarativeContextData
+class Q_AUTOTEST_EXPORT QDeclarativeContextData
 {
 public:
     QDeclarativeContextData();
diff --git a/src/declarative/qml/qdeclarativeengine.cpp b/src/declarative/qml/qdeclarativeengine.cpp
index 2f2ee08..39b0802 100644
--- a/src/declarative/qml/qdeclarativeengine.cpp
+++ b/src/declarative/qml/qdeclarativeengine.cpp
@@ -155,14 +155,26 @@ void QDeclarativeEnginePrivate::defineModule()
 \qmlclass Qt QDeclarativeEnginePrivate
 \brief The QML global Qt object provides useful enums and functions from Qt.
 
-The Qt object provides useful enums and functions from Qt, for use in all QML files. 
+The \c Qt object provides useful enums and functions from Qt, for use in all QML files. 
+
+The \c Qt object is not a QML element; it cannot be instantiated. It is a global object 
+with enums and functions.  To use it, call the members of the global \c Qt object directly. 
+For example:
+
+\qml
+import Qt 4.7
+
+Text {
+    color: Qt.rgba(255, 0, 0, 1)
+    text: Qt.md5("hello, world")
+}
+\endqml
 
-You do not create instances of this type, but instead use the members of the global "Qt" object.
 
 \section1 Enums
 
 The Qt object contains all enums in the Qt namespace. For example, you can
-access the AlignLeft member of the Qt::AlignmentFlag enum with \c Qt.AlignLeft.
+access the \c AlignLeft member of the \c Qt::AlignmentFlag enum with \c Qt.AlignLeft.
 
 For a full list of enums, see the \l{Qt Namespace} documentation.
 
@@ -172,7 +184,7 @@ data types. This is primarily useful when setting the properties of an item
 when the property has one of the following types:
 
 \list
-\o \c color - use \l{Qt::rgba()}{Qt.rgba()}, \l{Qt::darker()}{Qt.darker()}, \l{Qt::lighter()}{Qt.lighter()} or \l{Qt::tint()}{Qt.tint()}
+\o \c color - use \l{Qt::rgba()}{Qt.rgba()}, \l{Qt::hsla()}{Qt.hsla()}, \l{Qt::darker()}{Qt.darker()}, \l{Qt::lighter()}{Qt.lighter()} or \l{Qt::tint()}{Qt.tint()}
 \o \c rect - use \l{Qt::rect()}{Qt.rect()}
 \o \c point - use \l{Qt::point()}{Qt.point()}
 \o \c size - use \l{Qt::size()}{Qt.size()}
@@ -200,8 +212,8 @@ items from files or strings. See \l{Dynamic Object Management} for an overview
 of their use.
 
 \list
-    \o \l{Qt::createComponent}{object Qt.createComponent(url)}
-    \o \l{Qt::createQmlObject}{object Qt.createQmlObject(string qml, object parent, string filepath)}
+    \o \l{Qt::createComponent()}{object Qt.createComponent(url)}
+    \o \l{Qt::createQmlObject()}{object Qt.createQmlObject(string qml, object parent, string filepath)}
 \endlist
 */
 
@@ -1036,7 +1048,7 @@ QString QDeclarativeEnginePrivate::urlToLocalFileOrQrc(const QUrl& url)
 /*!
 \qmlmethod object Qt::createComponent(url)
 
-Returns a \l Component object created from the QML file at the specified \a url,
+Returns a \l Component object created using the QML file at the specified \a url,
 or \c null if there was an error in creating the component.
 
 Call \l {Component::createObject()}{Component.createObject()} on the returned
@@ -1364,7 +1376,7 @@ QScriptValue QDeclarativeEnginePrivate::formatDateTime(QScriptContext*ctxt, QScr
 /*!
 \qmlmethod color Qt::rgba(real red, real green, real blue, real alpha)
 
-Returns a Color with the specified \c red, \c green, \c blue and \c alpha components.
+Returns a color with the specified \c red, \c green, \c blue and \c alpha components.
 All components should be in the range 0-1 inclusive.
 */
 QScriptValue QDeclarativeEnginePrivate::rgba(QScriptContext *ctxt, QScriptEngine *engine)
@@ -1392,7 +1404,7 @@ QScriptValue QDeclarativeEnginePrivate::rgba(QScriptContext *ctxt, QScriptEngine
 /*!
 \qmlmethod color Qt::hsla(real hue, real saturation, real lightness, real alpha)
 
-Returns a Color with the specified \c hue, \c saturation, \c lightness and \c alpha components.
+Returns a color with the specified \c hue, \c saturation, \c lightness and \c alpha components.
 All components should be in the range 0-1 inclusive.
 */
 QScriptValue QDeclarativeEnginePrivate::hsla(QScriptContext *ctxt, QScriptEngine *engine)
@@ -1420,7 +1432,9 @@ QScriptValue QDeclarativeEnginePrivate::hsla(QScriptContext *ctxt, QScriptEngine
 /*!
 \qmlmethod rect Qt::rect(int x, int y, int width, int height) 
 
-Returns a Rect with the top-left corner at \c x, \c y and the specified \c width and \c height.
+Returns a \c rect with the top-left corner at \c x, \c y and the specified \c width and \c height.
+
+The returned object has \c x, \c y, \c width and \c height attributes with the given values.
 */
 QScriptValue QDeclarativeEnginePrivate::rect(QScriptContext *ctxt, QScriptEngine *engine)
 {
diff --git a/src/declarative/qml/qdeclarativeimport.cpp b/src/declarative/qml/qdeclarativeimport.cpp
index c658a31..a2e3831 100644
--- a/src/declarative/qml/qdeclarativeimport.cpp
+++ b/src/declarative/qml/qdeclarativeimport.cpp
@@ -823,7 +823,7 @@ void QDeclarativeImportDatabase::addPluginPath(const QString& path)
         qDebug() << "QDeclarativeImportDatabase::addPluginPath" << path;
 
     QUrl url = QUrl(path);
-    if (url.isRelative() || url.scheme() == QString::fromLocal8Bit("file")) {
+    if (url.isRelative() || url.scheme() == QLatin1String("file")) {
         QDir dir = QDir(path);
         filePluginPath.prepend(dir.canonicalPath());
     } else {
@@ -842,7 +842,7 @@ void QDeclarativeImportDatabase::addImportPath(const QString& path)
     QUrl url = QUrl(path);
     QString cPath;
 
-    if (url.isRelative() || url.scheme() == QString::fromLocal8Bit("file")) {
+    if (url.isRelative() || url.scheme() == QLatin1String("file")) {
         QDir dir = QDir(path);
         cPath = dir.canonicalPath();
     } else {
diff --git a/src/declarative/qml/qdeclarativeinstruction_p.h b/src/declarative/qml/qdeclarativeinstruction_p.h
index dc5f2f8..4627eb3 100644
--- a/src/declarative/qml/qdeclarativeinstruction_p.h
+++ b/src/declarative/qml/qdeclarativeinstruction_p.h
@@ -158,7 +158,7 @@ public:
         // 
         // Deferred creation
         //
-        Defer,                    /* defer */
+        Defer                    /* defer */
     };
     QDeclarativeInstruction()
         : line(0) {}
diff --git a/src/declarative/qml/qdeclarativepropertycache_p.h b/src/declarative/qml/qdeclarativepropertycache_p.h
index b01e5cc..72cfeba 100644
--- a/src/declarative/qml/qdeclarativepropertycache_p.h
+++ b/src/declarative/qml/qdeclarativepropertycache_p.h
@@ -65,7 +65,7 @@ QT_BEGIN_NAMESPACE
 class QDeclarativeEngine;
 class QMetaProperty;
 
-class QDeclarativePropertyCache : public QDeclarativeRefCount, public QDeclarativeCleanup
+class Q_AUTOTEST_EXPORT QDeclarativePropertyCache : public QDeclarativeRefCount, public QDeclarativeCleanup
 {
 public:
     QDeclarativePropertyCache(QDeclarativeEngine *);
diff --git a/src/declarative/qml/qdeclarativevaluetype_p.h b/src/declarative/qml/qdeclarativevaluetype_p.h
index 476c73d..3eaecc1 100644
--- a/src/declarative/qml/qdeclarativevaluetype_p.h
+++ b/src/declarative/qml/qdeclarativevaluetype_p.h
@@ -446,7 +446,7 @@ public:
         InBounce = QEasingCurve::InBounce, OutBounce = QEasingCurve::OutBounce,
         InOutBounce = QEasingCurve::InOutBounce, OutInBounce = QEasingCurve::OutInBounce,
         InCurve = QEasingCurve::InCurve, OutCurve = QEasingCurve::OutCurve,
-        SineCurve = QEasingCurve::SineCurve, CosineCurve = QEasingCurve::CosineCurve,
+        SineCurve = QEasingCurve::SineCurve, CosineCurve = QEasingCurve::CosineCurve
     };
 
     QDeclarativeEasingValueType(QObject *parent = 0);
diff --git a/src/declarative/qml/qdeclarativeworkerscript.cpp b/src/declarative/qml/qdeclarativeworkerscript.cpp
index 2ca030e..e0ee84f 100644
--- a/src/declarative/qml/qdeclarativeworkerscript.cpp
+++ b/src/declarative/qml/qdeclarativeworkerscript.cpp
@@ -521,7 +521,7 @@ void QDeclarativeWorkerScriptEngine::run()
     that the main GUI thread is not blocked.
 
     Messages can be passed between the new thread and the parent thread
-    using sendMessage() and the onMessage() handler.
+    using \l sendMessage() and the \l {WorkerScript::onMessage}{onMessage()} handler.
 
     Here is an example:
 
@@ -555,7 +555,7 @@ QDeclarativeWorkerScript::~QDeclarativeWorkerScript()
 /*!
     \qmlproperty url WorkerScript::source
 
-    This holds the url of the javascript file that implements the
+    This holds the url of the JavaScript file that implements the
     \tt WorkerScript.onMessage() handler for threaded operations.
 */
 QUrl QDeclarativeWorkerScript::source() const
@@ -576,7 +576,7 @@ void QDeclarativeWorkerScript::setSource(const QUrl &source)
     emit sourceChanged();
 }
 
-/*
+/*!
     \qmlmethod WorkerScript::sendMessage(jsobject message)
 
     Sends the given \a message to a worker script handler in another
diff --git a/src/declarative/util/qdeclarativeanimation.cpp b/src/declarative/util/qdeclarativeanimation.cpp
index de1c0cb..0eae136 100644
--- a/src/declarative/util/qdeclarativeanimation.cpp
+++ b/src/declarative/util/qdeclarativeanimation.cpp
@@ -557,6 +557,8 @@ void QDeclarativeAbstractAnimation::timelineComplete()
         NumberAnimation { ... duration: 200 }
     }
     \endcode
+
+    \sa {QML Animation}, {declarative/animation/basics}{Animation basics example}
 */
 /*!
     \internal
@@ -627,6 +629,8 @@ QAbstractAnimation *QDeclarativePauseAnimation::qtAnimation()
     When used in a transition, ColorAnimation will by default animate
     all properties of type color that are changing. If a property or properties
     are explicitly set for the animation, then those will be used instead.
+
+    \sa {QML Animation}, {declarative/animation/basics}{Animation basics example}
 */
 /*!
     \internal
@@ -1082,11 +1086,13 @@ void QDeclarativePropertyAction::transition(QDeclarativeStateActions &actions,
     \inherits PropertyAnimation
     \brief The NumberAnimation element allows you to animate changes in properties of type qreal.
 
-    Animate a set of properties over 200ms, from their values in the start state to
+    For example, to animate a set of properties over 200ms, from their values in the start state to
     their values in the end state of the transition:
     \code
     NumberAnimation { properties: "x,y,scale"; duration: 200 }
     \endcode
+
+    \sa {QML Animation}, {declarative/animation/basics}{Animation basics example}
 */
 
 /*!
@@ -1156,6 +1162,8 @@ void QDeclarativeNumberAnimation::setTo(qreal t)
     \since 4.7
     \inherits PropertyAnimation
     \brief The Vector3dAnimation element allows you to animate changes in properties of type QVector3d.
+
+    \sa {QML Animation}, {declarative/animation/basics}{Animation basics example}
 */
 
 /*!
@@ -1224,7 +1232,8 @@ void QDeclarativeVector3dAnimation::setTo(QVector3D t)
 
     When used in a transition RotationAnimation will rotate all
     properties named "rotation" or "angle". You can override this by providing
-    your own properties via \c properties or \c property.
+    your own properties via \l {PropertyAnimation::properties}{properties} or 
+    \l {PropertyAnimation::property}{property}.
 
     In the following example we use RotationAnimation to animate the rotation
     between states via the shortest path.
@@ -1238,6 +1247,8 @@ void QDeclarativeVector3dAnimation::setTo(QVector3D t)
         RotationAnimation { direction: RotationAnimation.Shortest }
     }
     \endqml
+
+    \sa {QML Animation}, {declarative/animation/basics}{Animation basics example}
 */
 
 /*!
@@ -1446,7 +1457,7 @@ QDeclarativeListProperty<QDeclarativeAbstractAnimation> QDeclarativeAnimationGro
     }
     \endcode
 
-    \sa ParallelAnimation
+    \sa ParallelAnimation, {QML Animation}, {declarative/animation/basics}{Animation basics example}
 */
 
 QDeclarativeSequentialAnimation::QDeclarativeSequentialAnimation(QObject *parent) :
@@ -1508,7 +1519,7 @@ void QDeclarativeSequentialAnimation::transition(QDeclarativeStateActions &actio
     }
     \endcode
 
-    \sa SequentialAnimation
+    \sa SequentialAnimation, {QML Animation}, {declarative/animation/basics}{Animation basics example}
 */
 /*!
     \internal
@@ -1657,6 +1668,8 @@ void QDeclarativePropertyAnimationPrivate::convertVariant(QVariant &variant, int
     Depending on how the animation is used, the set of properties normally used will be
     different. For more information see the individual property documentation, as well
     as the \l{QML Animation} introduction.
+
+    \sa {QML Animation}, {declarative/animation/basics}{Animation basics example}
 */
 
 QDeclarativePropertyAnimation::QDeclarativePropertyAnimation(QObject *parent)
@@ -2319,6 +2332,8 @@ void QDeclarativePropertyAnimation::transition(QDeclarativeStateActions &actions
 
     When used in a transition, ParentAnimation will by default animate
     all ParentChanges.
+
+    \sa {QML Animation}, {declarative/animation/basics}{Animation basics example}
 */
 
 /*!
diff --git a/src/declarative/util/qdeclarativefontloader.cpp b/src/declarative/util/qdeclarativefontloader.cpp
index c73f827..3c2e239 100644
--- a/src/declarative/util/qdeclarativefontloader.cpp
+++ b/src/declarative/util/qdeclarativefontloader.cpp
@@ -83,6 +83,8 @@ public:
 
     Example:
     \qml
+    import Qt 4.7
+
     FontLoader { id: fixedFont; name: "Courier" }
     FontLoader { id: webFont; source: "http://www.mysite.com/myfont.ttf" }
 
@@ -183,15 +185,26 @@ void QDeclarativeFontLoader::setName(const QString &name)
     \o FontLoader.Error - an error occurred while loading the font
     \endlist
 
-    Note that a change in the status property does not cause anything to happen
-    (although it reflects what has happened to the font loader internally). If you wish
-    to react to the change in status you need to do it yourself, for example in one
-    of the following ways:
-    \list
-    \o Create a state, so that a state change occurs, e.g. State{name: 'loaded'; when: loader.status = FontLoader.Ready;}
-    \o Do something inside the onStatusChanged signal handler, e.g. FontLoader{id: loader; onStatusChanged: if(loader.status == FontLoader.Ready) console.log('Loaded');}
-    \o Bind to the status variable somewhere, e.g. Text{text: if(loader.status!=FontLoader.Ready){'Not Loaded';}else{'Loaded';}}
-    \endlist
+    Use this status to provide an update or respond to the status change in some way.
+    For example, you could:
+
+    \e {Trigger a state change:}
+    \qml 
+        State { name: 'loaded'; when: loader.status = FontLoader.Ready }
+    \endqml
+
+    \e {Implement an \c onStatusChanged signal handler:}
+    \qml 
+        FontLoader {
+            id: loader
+            onStatusChanged: if (loader.status == FontLoader.Ready) console.log('Loaded')
+        }
+    \endqml
+
+    \e {Bind to the status value:}
+    \qml
+        Text { text: loader.status != FontLoader.Ready ? 'Not Loaded' : 'Loaded' }
+    \endqml
 */
 QDeclarativeFontLoader::Status QDeclarativeFontLoader::status() const
 {
diff --git a/src/declarative/util/qdeclarativepackage_p.h b/src/declarative/util/qdeclarativepackage_p.h
index 87d9b80..57d9c22 100644
--- a/src/declarative/util/qdeclarativepackage_p.h
+++ b/src/declarative/util/qdeclarativepackage_p.h
@@ -58,7 +58,7 @@ QT_MODULE(Declarative)
 
 class QDeclarativePackagePrivate;
 class QDeclarativePackageAttached;
-class QDeclarativePackage : public QObject
+class Q_AUTOTEST_EXPORT QDeclarativePackage : public QObject
 {
     Q_OBJECT
     Q_DECLARE_PRIVATE(QDeclarativePackage)
diff --git a/src/declarative/util/qdeclarativepropertychanges.cpp b/src/declarative/util/qdeclarativepropertychanges.cpp
index d99de7a..e98afeb 100644
--- a/src/declarative/util/qdeclarativepropertychanges.cpp
+++ b/src/declarative/util/qdeclarativepropertychanges.cpp
@@ -62,11 +62,11 @@ QT_BEGIN_NAMESPACE
 /*!
     \qmlclass PropertyChanges QDeclarativePropertyChanges
     \since 4.7
-    \brief The PropertyChanges element describes new property values for a state.
+    \brief The PropertyChanges element describes new property bindings or values for a state.
 
     PropertyChanges provides a state change that modifies the properties of an item.
 
-    Here is a property change that modifies the text and color of a Text element
+    Here is a property change that modifies the text and color of a \l Text element
     when it is clicked:
     
     \qml
@@ -89,6 +89,21 @@ QT_BEGIN_NAMESPACE
         MouseArea { anchors.fill: parent; onClicked: myText.state = 'myState' }
     }
     \endqml
+
+    By default, PropertyChanges will establish new bindings where appropriate.
+    For example, the following creates a new binding for myItem's height property.
+
+    \qml
+    PropertyChanges {
+        target: myItem
+        height: parent.height
+    }
+    \endqml
+
+    If you don't want a binding to be established (and instead just want to assign
+    the value of the binding at the time the state is entered),
+    you should set the PropertyChange's \l{PropertyChanges::explicit}{explicit}
+    property to \c true.
     
     State-specific script for signal handlers can also be specified:
 
diff --git a/src/declarative/util/qdeclarativesmoothedanimation.cpp b/src/declarative/util/qdeclarativesmoothedanimation.cpp
index bd48ef0..6b6df4d 100644
--- a/src/declarative/util/qdeclarativesmoothedanimation.cpp
+++ b/src/declarative/util/qdeclarativesmoothedanimation.cpp
@@ -307,7 +307,7 @@ Rectangle {
     set to a value such as 0.5 units/second.  Animating from 0 to 1.0 with a velocity
     of 0.5 will take 2000 ms to complete.
 
-    \sa SpringFollow
+    \sa SpringFollow, {QML Animation}, {declarative/animation/basics}{Animation basics example}
 */
 
 QDeclarativeSmoothedAnimation::QDeclarativeSmoothedAnimation(QObject *parent)
diff --git a/src/declarative/util/qdeclarativesmoothedanimation_p_p.h b/src/declarative/util/qdeclarativesmoothedanimation_p_p.h
index 81cd229..8cdbea2 100644
--- a/src/declarative/util/qdeclarativesmoothedanimation_p_p.h
+++ b/src/declarative/util/qdeclarativesmoothedanimation_p_p.h
@@ -65,7 +65,7 @@
 
 QT_BEGIN_NAMESPACE
 
-class QSmoothedAnimation : public QAbstractAnimation
+class Q_AUTOTEST_EXPORT QSmoothedAnimation : public QAbstractAnimation
 {
 public:
     QSmoothedAnimation(QObject *parent=0);
diff --git a/src/declarative/util/qdeclarativestate_p.h b/src/declarative/util/qdeclarativestate_p.h
index 25715c6..37b24cb 100644
--- a/src/declarative/util/qdeclarativestate_p.h
+++ b/src/declarative/util/qdeclarativestate_p.h
@@ -84,7 +84,7 @@ public:
     void deleteFromBinding();
 };
 
-class QDeclarativeActionEvent
+class Q_AUTOTEST_EXPORT QDeclarativeActionEvent
 {
 public:
     virtual ~QDeclarativeActionEvent();
diff --git a/src/declarative/util/qdeclarativetimeline_p_p.h b/src/declarative/util/qdeclarativetimeline_p_p.h
index 598c897..61f6bcd 100644
--- a/src/declarative/util/qdeclarativetimeline_p_p.h
+++ b/src/declarative/util/qdeclarativetimeline_p_p.h
@@ -63,7 +63,7 @@ class QDeclarativeTimeLineValue;
 class QDeclarativeTimeLineCallback;
 struct QDeclarativeTimeLinePrivate;
 class QDeclarativeTimeLineObject;
-class QDeclarativeTimeLine : public QAbstractAnimation
+class Q_AUTOTEST_EXPORT QDeclarativeTimeLine : public QAbstractAnimation
 {
 Q_OBJECT
 public:
@@ -117,7 +117,7 @@ private:
     QDeclarativeTimeLinePrivate *d;
 };
 
-class QDeclarativeTimeLineObject
+class Q_AUTOTEST_EXPORT QDeclarativeTimeLineObject
 {
 public:
     QDeclarativeTimeLineObject();
@@ -129,7 +129,7 @@ protected:
     QDeclarativeTimeLine *_t;
 };
 
-class QDeclarativeTimeLineValue : public QDeclarativeTimeLineObject
+class Q_AUTOTEST_EXPORT QDeclarativeTimeLineValue : public QDeclarativeTimeLineObject
 {
 public:
     QDeclarativeTimeLineValue(qreal v = 0.) : _v(v) {}
@@ -147,7 +147,7 @@ private:
     qreal _v;
 };
 
-class QDeclarativeTimeLineCallback
+class Q_AUTOTEST_EXPORT QDeclarativeTimeLineCallback
 {
 public:
     typedef void (*Callback)(void *);
diff --git a/src/declarative/util/qdeclarativetimer.cpp b/src/declarative/util/qdeclarativetimer.cpp
index 53a9d83..9e18eb5 100644
--- a/src/declarative/util/qdeclarativetimer.cpp
+++ b/src/declarative/util/qdeclarativetimer.cpp
@@ -80,17 +80,22 @@ public:
     the text every 500 milliseconds:
 
     \qml
-    Timer {
-        interval: 500; running: true; repeat: true
-        onTriggered: time.text = Date().toString()
-    }
-    Text {
-        id: time
+    import Qt 4.7
+
+    Item {
+        Timer {
+            interval: 500; running: true; repeat: true
+            onTriggered: time.text = Date().toString()
+        }
+
+        Text {
+            id: time
+        }
     }
     \endqml
 
-    QDeclarativeTimer is synchronized with the animation timer.  Since the animation
-    timer is usually set to 60fps, the resolution of QDeclarativeTimer will be
+    The Timer element is synchronized with the animation timer.  Since the animation
+    timer is usually set to 60fps, the resolution of Timer will be
     at best 16ms.
 
     If the Timer is running and one of its properties is changed, the
@@ -98,8 +103,6 @@ public:
     1000ms has its \e repeat property changed 500ms after starting, the
     elapsed time will be reset to 0, and the Timer will be triggered
     1000ms later.
-
-    \sa {QtDeclarative}
 */
 
 QDeclarativeTimer::QDeclarativeTimer(QObject *parent)
diff --git a/src/declarative/util/qdeclarativetransitionmanager_p_p.h b/src/declarative/util/qdeclarativetransitionmanager_p_p.h
index 2e23898..75d11a9 100644
--- a/src/declarative/util/qdeclarativetransitionmanager_p_p.h
+++ b/src/declarative/util/qdeclarativetransitionmanager_p_p.h
@@ -59,7 +59,7 @@ QT_BEGIN_NAMESPACE
 
 class QDeclarativeStatePrivate;
 class QDeclarativeTransitionManagerPrivate;
-class QDeclarativeTransitionManager 
+class Q_AUTOTEST_EXPORT QDeclarativeTransitionManager 
 {
 public:
     QDeclarativeTransitionManager();
diff --git a/src/declarative/util/qdeclarativeview.cpp b/src/declarative/util/qdeclarativeview.cpp
index d2dab76..6059ad6 100644
--- a/src/declarative/util/qdeclarativeview.cpp
+++ b/src/declarative/util/qdeclarativeview.cpp
@@ -48,7 +48,7 @@
 #include <qdeclarativeglobal_p.h>
 #include <qdeclarativeguard_p.h>
 
-#include <private/qdeclarativedebugtiming_p.h>
+#include <private/qdeclarativedebugtrace_p.h>
 
 #include <qscriptvalueiterator.h>
 #include <qdebug.h>
@@ -93,35 +93,35 @@ QDeclarativeScene::QDeclarativeScene()
 
 void QDeclarativeScene::keyPressEvent(QKeyEvent *e)
 {
-    QDeclarativeDebugTiming::addEvent(QDeclarativeDebugTiming::Key);
+    QDeclarativeDebugTrace::addEvent(QDeclarativeDebugTrace::Key);
 
     QGraphicsScene::keyPressEvent(e);
 }
 
 void QDeclarativeScene::keyReleaseEvent(QKeyEvent *e)
 {
-    QDeclarativeDebugTiming::addEvent(QDeclarativeDebugTiming::Key);
+    QDeclarativeDebugTrace::addEvent(QDeclarativeDebugTrace::Key);
 
     QGraphicsScene::keyReleaseEvent(e);
 }
 
 void QDeclarativeScene::mouseMoveEvent(QGraphicsSceneMouseEvent *e)
 {
-    QDeclarativeDebugTiming::addEvent(QDeclarativeDebugTiming::Mouse);
+    QDeclarativeDebugTrace::addEvent(QDeclarativeDebugTrace::Mouse);
 
     QGraphicsScene::mouseMoveEvent(e);
 }
 
 void QDeclarativeScene::mousePressEvent(QGraphicsSceneMouseEvent *e)
 {
-    QDeclarativeDebugTiming::addEvent(QDeclarativeDebugTiming::Mouse);
+    QDeclarativeDebugTrace::addEvent(QDeclarativeDebugTrace::Mouse);
 
     QGraphicsScene::mousePressEvent(e);
 }
 
 void QDeclarativeScene::mouseReleaseEvent(QGraphicsSceneMouseEvent *e)
 {
-    QDeclarativeDebugTiming::addEvent(QDeclarativeDebugTiming::Mouse);
+    QDeclarativeDebugTrace::addEvent(QDeclarativeDebugTrace::Mouse);
 
     QGraphicsScene::mouseReleaseEvent(e);
 }
@@ -675,8 +675,8 @@ void QDeclarativeView::paintEvent(QPaintEvent *event)
 {
     Q_D(QDeclarativeView);
 
-    QDeclarativeDebugTiming::addEvent(QDeclarativeDebugTiming::FramePaint);
-    QDeclarativeDebugTiming::startRange(QDeclarativeDebugTiming::Painting);
+    QDeclarativeDebugTrace::addEvent(QDeclarativeDebugTrace::FramePaint);
+    QDeclarativeDebugTrace::startRange(QDeclarativeDebugTrace::Painting);
 
     int time = 0;
     if (frameRateDebug()) 
@@ -684,7 +684,7 @@ void QDeclarativeView::paintEvent(QPaintEvent *event)
 
     QGraphicsView::paintEvent(event);
 
-    QDeclarativeDebugTiming::endRange(QDeclarativeDebugTiming::Painting);
+    QDeclarativeDebugTrace::endRange(QDeclarativeDebugTrace::Painting);
 
     if (frameRateDebug())
         qDebug() << "paintEvent:" << d->frameTimer.elapsed() << "time since last frame:" << time;
diff --git a/src/gui/egl/qegl.cpp b/src/gui/egl/qegl.cpp
index 671a568..e6ea198 100644
--- a/src/gui/egl/qegl.cpp
+++ b/src/gui/egl/qegl.cpp
@@ -72,12 +72,12 @@ public:
     static bool displayOpened() { return displayOpen; }
 
 private:
-    static QAtomicInt contexts;
-    static QAtomicInt displayOpen;
+    static QBasicAtomicInt contexts;
+    static QBasicAtomicInt displayOpen;
 };
 
-QAtomicInt QEglContextTracker::contexts = 0;
-QAtomicInt QEglContextTracker::displayOpen = 0;
+QBasicAtomicInt QEglContextTracker::contexts = Q_BASIC_ATOMIC_INITIALIZER(0);
+QBasicAtomicInt QEglContextTracker::displayOpen = Q_BASIC_ATOMIC_INITIALIZER(0);
 
 // Current GL and VG contexts.  These are used to determine if
 // we can avoid an eglMakeCurrent() after a call to lazyDoneCurrent().
diff --git a/src/gui/embedded/qwsmanager_qws.cpp b/src/gui/embedded/qwsmanager_qws.cpp
index 79076c5..b0259b9 100644
--- a/src/gui/embedded/qwsmanager_qws.cpp
+++ b/src/gui/embedded/qwsmanager_qws.cpp
@@ -394,7 +394,7 @@ void QWSManagerPrivate::dirtyRegion(int decorationRegion,
                                     const QRegion &clip)
 {
     QTLWExtra *topextra = managed->d_func()->extra->topextra;
-    QWidgetBackingStore *bs = topextra->backingStore;
+    QWidgetBackingStore *bs = topextra->backingStore.data();
     const bool pendingUpdateRequest = bs->isDirty();
 
     if (decorationRegion == QDecoration::All) {
diff --git a/src/gui/graphicsview/qgraphicsitem.cpp b/src/gui/graphicsview/qgraphicsitem.cpp
index 36d21a6..8042c46 100644
--- a/src/gui/graphicsview/qgraphicsitem.cpp
+++ b/src/gui/graphicsview/qgraphicsitem.cpp
@@ -1427,12 +1427,14 @@ QGraphicsItem::~QGraphicsItem()
     d_ptr->inDestructor = 1;
     d_ptr->removeExtraItemCache();
 
+#ifndef QT_NO_GESTURES
     if (d_ptr->isObject && !d_ptr->gestureContext.isEmpty()) {
         QGraphicsObject *o = static_cast<QGraphicsObject *>(this);
         QGestureManager *manager = QGestureManager::instance();
         foreach (Qt::GestureType type, d_ptr->gestureContext.keys())
             manager->cleanupCachedGestures(o, type);
     }
+#endif
 
     clearFocus();
 
@@ -5687,32 +5689,30 @@ void QGraphicsItem::scroll(qreal dx, qreal dy, const QRectF &rect)
         return;
     }
 
+    // Find pixmap in cache.
     QPixmap cachedPixmap;
     if (!QPixmapCache::find(cache->key, &cachedPixmap)) {
         update(rect);
         return;
     }
 
+    QRect scrollRect = (rect.isNull() ? boundingRect() : rect).toAlignedRect();
+    if (!scrollRect.intersects(cache->boundingRect))
+        return; // Nothing to scroll.
+
+    // Remove from cache to avoid deep copy when modifying.
+    QPixmapCache::remove(cache->key);
+
     QRegion exposed;
-    const bool scrollEntirePixmap = rect.isNull();
-    if (scrollEntirePixmap) {
-        // Scroll entire pixmap.
-        cachedPixmap.scroll(dx, dy, cachedPixmap.rect(), &exposed);
-    } else {
-        if (!rect.intersects(cache->boundingRect))
-            return; // Nothing to scroll.
-        // Scroll sub-rect of pixmap. The rect is in item coordinates
-        // so we have to translate it to pixmap coordinates.
-        QRect scrollRect = rect.toAlignedRect();
-        cachedPixmap.scroll(dx, dy, scrollRect.translated(-cache->boundingRect.topLeft()), &exposed);
-    }
+    cachedPixmap.scroll(dx, dy, scrollRect.translated(-cache->boundingRect.topLeft()), &exposed);
 
-    QPixmapCache::replace(cache->key, cachedPixmap);
+    // Reinsert into cache.
+    cache->key = QPixmapCache::insert(cachedPixmap);
 
     // Translate the existing expose.
     for (int i = 0; i < cache->exposed.size(); ++i) {
         QRectF &e = cache->exposed[i];
-        if (!scrollEntirePixmap && !e.intersects(rect))
+        if (!rect.isNull() && !e.intersects(rect))
             continue;
         e.translate(dx, dy);
     }
@@ -7573,6 +7573,7 @@ QGraphicsObject::QGraphicsObject(QGraphicsItemPrivate &dd, QGraphicsItem *parent
     QGraphicsItem::d_ptr->isObject = true;
 }
 
+#ifndef QT_NO_GESTURES
 /*!
     Subscribes the graphics object to the given \a gesture with specific \a flags.
 
@@ -7596,6 +7597,8 @@ void QGraphicsObject::ungrabGesture(Qt::GestureType gesture)
     if (QGraphicsItem::d_ptr->gestureContext.remove(gesture) && QGraphicsItem::d_ptr->scene)
         QGraphicsItem::d_ptr->scene->d_func()->ungrabGesture(this, gesture);
 }
+#endif // QT_NO_GESTURES
+
 /*!
     Updates the item's micro focus. This is slot for convenience.
 
diff --git a/src/gui/graphicsview/qgraphicsitem.h b/src/gui/graphicsview/qgraphicsitem.h
index 9891af3..d7d5332 100644
--- a/src/gui/graphicsview/qgraphicsitem.h
+++ b/src/gui/graphicsview/qgraphicsitem.h
@@ -485,7 +485,9 @@ private:
     friend class QGraphicsSceneBspTreeIndexPrivate;
     friend class QGraphicsItemEffectSourcePrivate;
     friend class QGraphicsTransformPrivate;
+#ifndef QT_NO_GESTURES
     friend class QGestureManager;
+#endif
     friend class ::tst_QGraphicsItem;
     friend bool qt_closestLeaf(const QGraphicsItem *, const QGraphicsItem *);
     friend bool qt_closestItemFirst(const QGraphicsItem *, const QGraphicsItem *);
@@ -572,8 +574,10 @@ public:
     using QObject::children;
 #endif
 
+#ifndef QT_NO_GESTURES
     void grabGesture(Qt::GestureType type, Qt::GestureFlags flags = Qt::GestureFlags());
     void ungrabGesture(Qt::GestureType type);
+#endif
 
 protected Q_SLOTS:
     void updateMicroFocus();
diff --git a/src/gui/graphicsview/qgraphicsitem_p.h b/src/gui/graphicsview/qgraphicsitem_p.h
index e812f29..bde6e7d 100644
--- a/src/gui/graphicsview/qgraphicsitem_p.h
+++ b/src/gui/graphicsview/qgraphicsitem_p.h
@@ -525,7 +525,9 @@ public:
     QGraphicsItem *focusScopeItem;
     Qt::InputMethodHints imHints;
     QGraphicsItem::PanelModality panelModality;
+#ifndef QT_NO_GESTURES
     QMap<Qt::GestureType, Qt::GestureFlags> gestureContext;
+#endif
 
     // Packed 32 bits
     quint32 acceptedMouseButtons : 5;
diff --git a/src/gui/graphicsview/qgraphicsscene.cpp b/src/gui/graphicsview/qgraphicsscene.cpp
index 22c3f92..7b0722e 100644
--- a/src/gui/graphicsview/qgraphicsscene.cpp
+++ b/src/gui/graphicsview/qgraphicsscene.cpp
@@ -699,6 +699,7 @@ void QGraphicsScenePrivate::removeItemHelper(QGraphicsItem *item)
     if (!selectionChanging && selectedItems.size() != oldSelectedItemsSize)
         emit q->selectionChanged();
 
+#ifndef QT_NO_GESTURES
     QHash<QGesture *, QGraphicsObject *>::iterator it;
     for (it = gestureTargets.begin(); it != gestureTargets.end();) {
         if (it.value() == item)
@@ -706,6 +707,7 @@ void QGraphicsScenePrivate::removeItemHelper(QGraphicsItem *item)
         else
             ++it;
     }
+
     QGraphicsObject *dummy = static_cast<QGraphicsObject *>(item);
     cachedTargetItems.removeOne(dummy);
     cachedItemGestures.remove(dummy);
@@ -713,6 +715,7 @@ void QGraphicsScenePrivate::removeItemHelper(QGraphicsItem *item)
 
     foreach (Qt::GestureType gesture, item->d_ptr->gestureContext.keys())
         ungrabGesture(item, gesture);
+#endif // QT_NO_GESTURES
 }
 
 /*!
@@ -1180,11 +1183,13 @@ bool QGraphicsScenePrivate::filterEvent(QGraphicsItem *item, QEvent *event)
 bool QGraphicsScenePrivate::sendEvent(QGraphicsItem *item, QEvent *event)
 {
     if (QGraphicsObject *object = item->toGraphicsObject()) {
+#ifndef QT_NO_GESTURES
         QGestureManager *gestureManager = QApplicationPrivate::instance()->gestureManager;
         if (gestureManager) {
             if (gestureManager->filterEvent(object, event))
                 return true;
         }
+#endif // QT_NO_GESTURES
     }
 
     if (filterEvent(item, event))
@@ -2602,8 +2607,10 @@ void QGraphicsScene::addItem(QGraphicsItem *item)
         d->enableTouchEventsOnViews();
     }
 
+#ifndef QT_NO_GESTURES
     foreach (Qt::GestureType gesture, item->d_ptr->gestureContext.keys())
         d->grabGesture(item, gesture);
+#endif
 
     // Update selection lists
     if (item->isSelected())
@@ -3525,10 +3532,12 @@ bool QGraphicsScene::event(QEvent *event)
     case QEvent::TouchEnd:
         d->touchEventHandler(static_cast<QTouchEvent *>(event));
         break;
+#ifndef QT_NO_GESTURES
     case QEvent::Gesture:
     case QEvent::GestureOverride:
         d->gestureEventHandler(static_cast<QGestureEvent *>(event));
         break;
+#endif // QT_NO_GESTURES
     default:
         return QObject::event(event);
     }
@@ -5637,8 +5646,10 @@ bool QGraphicsScene::sendEvent(QGraphicsItem *item, QEvent *event)
 void QGraphicsScenePrivate::addView(QGraphicsView *view)
 {
     views << view;
+#ifndef QT_NO_GESTURES
     foreach (Qt::GestureType gesture, grabbedGestures.keys())
         view->viewport()->grabGesture(gesture);
+#endif
 }
 
 void QGraphicsScenePrivate::removeView(QGraphicsView *view)
@@ -5968,6 +5979,7 @@ void QGraphicsScenePrivate::leaveModal(QGraphicsItem *panel)
     dispatchHoverEvent(&hoverEvent);
 }
 
+#ifndef QT_NO_GESTURES
 void QGraphicsScenePrivate::gestureTargetsAtHotSpots(const QSet<QGesture *> &gestures,
                                               Qt::GestureFlag flag,
                                               QHash<QGraphicsObject *, QSet<QGesture *> > *targets,
@@ -6356,6 +6368,7 @@ void QGraphicsScenePrivate::ungrabGesture(QGraphicsItem *item, Qt::GestureType g
             view->viewport()->ungrabGesture(gesture);
     }
 }
+#endif // QT_NO_GESTURES
 
 QT_END_NAMESPACE
 
diff --git a/src/gui/graphicsview/qgraphicsscene.h b/src/gui/graphicsview/qgraphicsscene.h
index c34a303..f8615f4 100644
--- a/src/gui/graphicsview/qgraphicsscene.h
+++ b/src/gui/graphicsview/qgraphicsscene.h
@@ -313,7 +313,9 @@ private:
     friend class QGraphicsSceneBspTreeIndex;
     friend class QGraphicsSceneBspTreeIndexPrivate;
     friend class QGraphicsItemEffectSourcePrivate;
+#ifndef QT_NO_GESTURES
     friend class QGesture;
+#endif
 };
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(QGraphicsScene::SceneLayers)
diff --git a/src/gui/graphicsview/qgraphicsscene_p.h b/src/gui/graphicsview/qgraphicsscene_p.h
index 8ad2a0a..f28dfe9 100644
--- a/src/gui/graphicsview/qgraphicsscene_p.h
+++ b/src/gui/graphicsview/qgraphicsscene_p.h
@@ -299,6 +299,7 @@ public:
     void enableTouchEventsOnViews();
 
     QList<QGraphicsObject *> cachedTargetItems;
+#ifndef QT_NO_GESTURES
     QHash<QGraphicsObject *, QSet<QGesture *> > cachedItemGestures;
     QHash<QGraphicsObject *, QSet<QGesture *> > cachedAlreadyDeliveredGestures;
     QHash<QGesture *, QGraphicsObject *> gestureTargets;
@@ -313,6 +314,7 @@ public:
     void cancelGesturesForChildren(QGesture *original);
     void grabGesture(QGraphicsItem *, Qt::GestureType gesture);
     void ungrabGesture(QGraphicsItem *, Qt::GestureType gesture);
+#endif // QT_NO_GESTURES
 
     void updateInputMethodSensitivityInViews();
 
diff --git a/src/gui/graphicsview/qgraphicsview.cpp b/src/gui/graphicsview/qgraphicsview.cpp
index a83b528..0674610 100644
--- a/src/gui/graphicsview/qgraphicsview.cpp
+++ b/src/gui/graphicsview/qgraphicsview.cpp
@@ -2688,10 +2688,12 @@ void QGraphicsView::setupViewport(QWidget *widget)
     if (d->scene && !d->scene->d_func()->allItemsIgnoreTouchEvents)
         widget->setAttribute(Qt::WA_AcceptTouchEvents);
 
+#ifndef QT_NO_GESTURES
     if (d->scene) {
         foreach (Qt::GestureType gesture, d->scene->d_func()->grabbedGestures.keys())
             widget->grabGesture(gesture);
     }
+#endif
 
     widget->setAcceptDrops(acceptDrops());
 }
@@ -2838,6 +2840,7 @@ bool QGraphicsView::viewportEvent(QEvent *event)
 
         return true;
     }
+#ifndef QT_NO_GESTURES
     case QEvent::Gesture:
     case QEvent::GestureOverride:
     {
@@ -2851,6 +2854,7 @@ bool QGraphicsView::viewportEvent(QEvent *event)
         }
         return true;
     }
+#endif // QT_NO_GESTURES
     default:
         break;
     }
diff --git a/src/gui/image/qiconloader.cpp b/src/gui/image/qiconloader.cpp
index a515ef8..34f40a9 100644
--- a/src/gui/image/qiconloader.cpp
+++ b/src/gui/image/qiconloader.cpp
@@ -63,6 +63,8 @@
 #include <private/qt_x11_p.h>
 #endif
 
+#include <private/qstylehelper_p.h>
+
 QT_BEGIN_NAMESPACE
 
 Q_GLOBAL_STATIC(QIconLoader, iconLoaderInstance)
@@ -488,14 +490,12 @@ QPixmap PixmapEntry::pixmap(const QSize &size, QIcon::Mode mode, QIcon::State st
         basePixmap.load(filename);
 
     int actualSize = qMin(size.width(), size.height());
-    QString key = QLatin1String("$qt_theme_")
-                  + QString::number(basePixmap.cacheKey(), 16)
-                  + QLatin1Char('_')
-                  + QString::number(mode)
-                  + QLatin1Char('_')
-                  + QString::number(qApp->palette().cacheKey(), 16)
-                  + QLatin1Char('_')
-                  + QString::number(actualSize);
+
+    QString key = QLatin1Literal("$qt_theme_")
+                  % HexString<qint64>(basePixmap.cacheKey())
+                  % HexString<int>(mode)
+                  % HexString<qint64>(qApp->palette().cacheKey())
+                  % HexString<int>(actualSize);
 
     QPixmap cachedPixmap;
     if (QPixmapCache::find(key, &cachedPixmap)) {
diff --git a/src/gui/image/qimage.cpp b/src/gui/image/qimage.cpp
index 98f235e..d89ffe6 100644
--- a/src/gui/image/qimage.cpp
+++ b/src/gui/image/qimage.cpp
@@ -272,6 +272,8 @@ bool QImageData::checkForAlphaPixels() const
 
     switch (format) {
 
+    case QImage::Format_Mono:
+    case QImage::Format_MonoLSB:
     case QImage::Format_Indexed8:
         has_alpha_pixels = has_alpha_clut;
         break;
diff --git a/src/gui/image/qpixmap.cpp b/src/gui/image/qpixmap.cpp
index 48c5d3f..20e4b50 100644
--- a/src/gui/image/qpixmap.cpp
+++ b/src/gui/image/qpixmap.cpp
@@ -82,6 +82,7 @@
 #endif
 
 #include "qpixmap_raster_p.h"
+#include "private/qstylehelper_p.h"
 
 QT_BEGIN_NAMESPACE
 
@@ -635,17 +636,21 @@ void QPixmap::resize_helper(const QSize &s)
     if (size() == s)
         return;
 
+    // QPixmap.data member may be QRuntimePixmapData so use pixmapData() function to get
+    // the actual underlaying runtime pixmap data.
+    QPixmapData *pd = pixmapData();
+
     // Create new pixmap
-    QPixmap pm(QSize(w, h), data ? data->type : QPixmapData::PixmapType);
+    QPixmap pm(QSize(w, h), pd ? pd->type : QPixmapData::PixmapType);
     bool uninit = false;
 #if defined(Q_WS_X11)
-    QX11PixmapData *x11Data = data && data->classId() == QPixmapData::X11Class ? static_cast<QX11PixmapData*>(data.data()) : 0;
+    QX11PixmapData *x11Data = pd && pd->classId() == QPixmapData::X11Class ? static_cast<QX11PixmapData*>(pd) : 0;
     if (x11Data) {
         pm.x11SetScreen(x11Data->xinfo.screen());
         uninit = x11Data->flags & QX11PixmapData::Uninitialized;
     }
 #elif defined(Q_WS_MAC)
-    QMacPixmapData *macData = data && data->classId() == QPixmapData::MacClass ? static_cast<QMacPixmapData*>(data.data()) : 0;
+    QMacPixmapData *macData = pd && pd->classId() == QPixmapData::MacClass ? static_cast<QMacPixmapData*>(pd) : 0;
     if (macData)
         uninit = macData->uninit;
 #endif
@@ -659,7 +664,7 @@ void QPixmap::resize_helper(const QSize &s)
 
 #if defined(Q_WS_X11)
     if (x11Data && x11Data->x11_mask) {
-        QX11PixmapData *pmData = static_cast<QX11PixmapData*>(pm.data.data());
+        QX11PixmapData *pmData = static_cast<QX11PixmapData*>(pd);
         pmData->x11_mask = (Qt::HANDLE)XCreatePixmap(X11->display,
                                                      RootWindow(x11Data->xinfo.display(),
                                                                 x11Data->xinfo.screen()),
@@ -825,8 +830,14 @@ bool QPixmap::load(const QString &fileName, const char *format, Qt::ImageConvers
         return false;
 
     QFileInfo info(fileName);
-    QString key = QLatin1String("qt_pixmap_") + info.absoluteFilePath() + QLatin1Char('_') + QString::number(info.lastModified().toTime_t()) + QLatin1Char('_') +
-        QString::number(info.size()) + QLatin1Char('_') + QString::number(data ? data->pixelType() : QPixmapData::PixmapType);
+    if (!info.exists())
+        return false;
+
+    QString key = QLatin1Literal("qt_pixmap")
+                  % info.absoluteFilePath()
+                  % HexString<uint>(info.lastModified().toTime_t())
+                  % HexString<quint64>(info.size())
+                  % HexString<uint>(data ? data->pixelType() : QPixmapData::PixmapType);
 
     if (QPixmapCache::find(key, *this))
         return true;
@@ -1163,8 +1174,9 @@ QPixmap QPixmap::grabWidget(QWidget * widget, const QRect &rect)
 Qt::HANDLE QPixmap::handle() const
 {
 #if defined(Q_WS_X11)
-    if (data && data->classId() == QPixmapData::X11Class)
-        return static_cast<const QX11PixmapData*>(data.constData())->handle();
+    const QPixmapData *pd = pixmapData();
+    if (pd && pd->classId() == QPixmapData::X11Class)
+        return static_cast<const QX11PixmapData*>(pd)->handle();
 #endif
     return 0;
 }
@@ -1944,17 +1956,20 @@ void QPixmap::detach()
     if (!data)
         return;
 
-    QPixmapData::ClassId id = data->classId();
+    // QPixmap.data member may be QRuntimePixmapData so use pixmapData() function to get
+    // the actual underlaying runtime pixmap data.
+    QPixmapData *pd = pixmapData();
+    QPixmapData::ClassId id = pd->classId();
     if (id == QPixmapData::RasterClass) {
-        QRasterPixmapData *rasterData = static_cast<QRasterPixmapData*>(data.data());
+        QRasterPixmapData *rasterData = static_cast<QRasterPixmapData*>(pd);
         rasterData->image.detach();
     }
 
     if (data->is_cached && data->ref == 1)
-        QImagePixmapCleanupHooks::executePixmapDataModificationHooks(data.data());
+        QImagePixmapCleanupHooks::executePixmapDataModificationHooks(pd);
 
 #if defined(Q_WS_MAC)
-    QMacPixmapData *macData = id == QPixmapData::MacClass ? static_cast<QMacPixmapData*>(data.data()) : 0;
+    QMacPixmapData *macData = id == QPixmapData::MacClass ? static_cast<QMacPixmapData*>(pd) : 0;
     if (macData) {
         if (macData->cg_mask) {
             CGImageRelease(macData->cg_mask);
@@ -1969,8 +1984,8 @@ void QPixmap::detach()
     ++data->detach_no;
 
 #if defined(Q_WS_X11)
-    if (data->classId() == QPixmapData::X11Class) {
-        QX11PixmapData *d = static_cast<QX11PixmapData*>(data.data());
+    if (pd->classId() == QPixmapData::X11Class) {
+        QX11PixmapData *d = static_cast<QX11PixmapData*>(pd);
         d->flags &= ~QX11PixmapData::Uninitialized;
 
         // reset the cache data
@@ -2060,9 +2075,15 @@ QPixmap QPixmap::fromImage(const QImage &image, Qt::ImageConversionFlags flags)
 */
 QPixmapData* QPixmap::pixmapData() const
 {
-    return data.data();
+    if (data) {
+        QPixmapData* pm = data.data();
+        return pm->runtimeData() ? pm->runtimeData() : pm;
+    }
+
+    return 0;
 }
 
+
 /*!
     \enum QPixmap::HBitmapFormat
 
diff --git a/src/gui/image/qpixmap.h b/src/gui/image/qpixmap.h
index 180af3b..82546da 100644
--- a/src/gui/image/qpixmap.h
+++ b/src/gui/image/qpixmap.h
@@ -271,9 +271,7 @@ private:
     friend class QX11PaintEngine;
     friend class QCoreGraphicsPaintEngine;
     friend class QWidgetPrivate;
-    friend class QRasterPaintEngine;
     friend class QRasterBuffer;
-    friend class QPixmapCacheEntry;
 #if !defined(QT_NO_DATASTREAM)
     friend Q_GUI_EXPORT QDataStream &operator>>(QDataStream &, QPixmap &);
 #endif
diff --git a/src/gui/image/qpixmapcache_p.h b/src/gui/image/qpixmapcache_p.h
index 825f272..6db3b20 100644
--- a/src/gui/image/qpixmapcache_p.h
+++ b/src/gui/image/qpixmapcache_p.h
@@ -81,8 +81,9 @@ class QPixmapCacheEntry : public QPixmap
 public:
     QPixmapCacheEntry(const QPixmapCache::Key &key, const QPixmap &pix) : QPixmap(pix), key(key)
     {
-        if (data && data->classId() == QPixmapData::RasterClass) {
-            QRasterPixmapData *d = static_cast<QRasterPixmapData*>(data.data());
+        QPixmapData *pd = pixmapData();
+        if (pd && pd->classId() == QPixmapData::RasterClass) {
+            QRasterPixmapData *d = static_cast<QRasterPixmapData*>(pd);
             if (!d->image.isNull() && d->image.d->paintEngine
                 && !d->image.d->paintEngine->isActive())
             {
diff --git a/src/gui/image/qpixmapdata_p.h b/src/gui/image/qpixmapdata_p.h
index 827fa18..60ed26a 100644
--- a/src/gui/image/qpixmapdata_p.h
+++ b/src/gui/image/qpixmapdata_p.h
@@ -73,7 +73,7 @@ public:
     };
 #endif
     enum ClassId { RasterClass, X11Class, MacClass, DirectFBClass,
-                   OpenGLClass, OpenVGClass, CustomClass = 1024 };
+                   OpenGLClass, OpenVGClass, RuntimeClass, CustomClass = 1024 };
 
     QPixmapData(PixelType pixelType, int classId);
     virtual ~QPixmapData();
@@ -133,7 +133,10 @@ public:
 
     static QPixmapData *create(int w, int h, PixelType type);
 
+    virtual QPixmapData *runtimeData() const { return 0; }
+
 protected:
+
     void setSerialNumber(int serNo);
     int w;
     int h;
diff --git a/src/gui/inputmethod/qcoefepinputcontext_s60.cpp b/src/gui/inputmethod/qcoefepinputcontext_s60.cpp
index d081cfd..4cdc4ad 100644
--- a/src/gui/inputmethod/qcoefepinputcontext_s60.cpp
+++ b/src/gui/inputmethod/qcoefepinputcontext_s60.cpp
@@ -44,6 +44,9 @@
 #include "qcoefepinputcontext_p.h"
 #include <qapplication.h>
 #include <qtextformat.h>
+#include <qgraphicsview.h>
+#include <qgraphicsscene.h>
+#include <qgraphicswidget.h>
 #include <private/qcore_symbian_p.h>
 
 #include <fepitfr.h>
@@ -320,12 +323,14 @@ TCoeInputCapabilities QCoeFepInputContext::inputCapabilities()
     return TCoeInputCapabilities(m_textCapabilities, this, 0);
 }
 
-static QTextCharFormat qt_TCharFormat2QTextCharFormat(const TCharFormat &cFormat)
+static QTextCharFormat qt_TCharFormat2QTextCharFormat(const TCharFormat &cFormat, bool validStyleColor)
 {
     QTextCharFormat qFormat;
 
-    QBrush foreground(QColor(cFormat.iFontPresentation.iTextColor.Internal()));
-    qFormat.setForeground(foreground);
+    if (validStyleColor) {
+        QBrush foreground(QColor(cFormat.iFontPresentation.iTextColor.Internal()));
+        qFormat.setForeground(foreground);
+    }
 
     qFormat.setFontStrikeOut(cFormat.iFontPresentation.iStrikethrough == EStrikethroughOn);
     qFormat.setFontUnderline(cFormat.iFontPresentation.iUnderline == EUnderlineOn);
@@ -484,10 +489,30 @@ void QCoeFepInputContext::applyHints(Qt::InputMethodHints hints)
 void QCoeFepInputContext::applyFormat(QList<QInputMethodEvent::Attribute> *attributes)
 {
     TCharFormat cFormat;
-    const QColor styleTextColor = focusWidget() ? focusWidget()->palette().text().color() : 
-        QApplication::palette("QLineEdit").text().color();
-    const TLogicalRgb fontColor(TRgb(styleTextColor.red(), styleTextColor.green(), styleTextColor.blue(), styleTextColor.alpha()));
-    cFormat.iFontPresentation.iTextColor = fontColor;
+    QColor styleTextColor;
+    if (QWidget *focused = focusWidget()) {
+        QGraphicsView *gv = qobject_cast<QGraphicsView*>(focused);
+        if (!gv) // could be either the QGV or its viewport that has focus
+            gv = qobject_cast<QGraphicsView*>(focused->parentWidget());
+        if (gv) {
+            if (QGraphicsScene *scene = gv->scene()) {
+                if (QGraphicsItem *focusItem = scene->focusItem()) {
+                    if (focusItem->isWidget()) {
+                        styleTextColor = static_cast<QGraphicsWidget*>(focusItem)->palette().text().color();
+                    }
+                }
+            }
+        } else {
+            styleTextColor = focused->palette().text().color();
+        }
+    } else {
+        styleTextColor = QApplication::palette("QLineEdit").text().color();
+    }
+
+    if (styleTextColor.isValid()) {
+        const TLogicalRgb fontColor(TRgb(styleTextColor.red(), styleTextColor.green(), styleTextColor.blue(), styleTextColor.alpha()));
+        cFormat.iFontPresentation.iTextColor = fontColor;
+    }
 
     TInt numChars = 0;
     TInt charPos = 0;
@@ -501,7 +526,7 @@ void QCoeFepInputContext::applyFormat(QList<QInputMethodEvent::Attribute> *attri
         attributes->append(QInputMethodEvent::Attribute(QInputMethodEvent::TextFormat,
                                                         charPos,
                                                         numChars,
-                                                        QVariant(qt_TCharFormat2QTextCharFormat(cFormat))));
+                                                        QVariant(qt_TCharFormat2QTextCharFormat(cFormat, styleTextColor.isValid()))));
         charPos += numChars;
         if (charPos >= m_preeditString.size()) {
             break;
diff --git a/src/gui/inputmethod/qximinputcontext_x11.cpp b/src/gui/inputmethod/qximinputcontext_x11.cpp
index d048b36..ed5aa23 100644
--- a/src/gui/inputmethod/qximinputcontext_x11.cpp
+++ b/src/gui/inputmethod/qximinputcontext_x11.cpp
@@ -346,10 +346,7 @@ static XFontSet getFontSet(const QFont &f)
 
 extern bool qt_use_rtl_extensions; // from qapplication_x11.cpp
 #ifndef QT_NO_XKB
-extern void q_getLocaleAndDirection(QLocale *locale,
-                                  Qt::LayoutDirection *direction,
-                                  const QByteArray &layoutName,
-                                  const QByteArray &variantName);
+extern QLocale q_getKeyboardLocale(const QByteArray &layoutName, const QByteArray &variantName);
 #endif
 
 QXIMInputContext::QXIMInputContext()
@@ -407,17 +404,12 @@ QXIMInputContext::QXIMInputContext()
             QList<QByteArray> layoutNames = QByteArray::fromRawData(names[2], qstrlen(names[2])).split(',');
             QList<QByteArray> variantNames = QByteArray::fromRawData(names[3], qstrlen(names[3])).split(',');
             for (int i = 0; i < qMin(layoutNames.count(), variantNames.count()); ++i  ) {
-                QLocale keyboardInputLocale;
-                Qt::LayoutDirection keyboardInputDirection;
                 QByteArray variantName = variantNames.at(i);
                 const int dashPos = variantName.indexOf("-");
                 if (dashPos >= 0)
                     variantName.truncate(dashPos);
-                q_getLocaleAndDirection(&keyboardInputLocale,
-                                      &keyboardInputDirection,
-                                      layoutNames.at(i),
-                                      variantName);
-                if (keyboardInputDirection == Qt::RightToLeft)
+                QLocale keyboardInputLocale = q_getKeyboardLocale(layoutNames.at(i), variantName);
+                if (keyboardInputLocale.textDirection() == Qt::RightToLeft)
                     qt_use_rtl_extensions = true;
             }
         }
diff --git a/src/gui/kernel/qapplication.cpp b/src/gui/kernel/qapplication.cpp
index 0d11b27..52767b8 100644
--- a/src/gui/kernel/qapplication.cpp
+++ b/src/gui/kernel/qapplication.cpp
@@ -70,6 +70,10 @@
 #include "qmessagebox.h"
 #include <QtGui/qgraphicsproxywidget.h>
 
+#ifdef QT_GRAPHICSSYSTEM_RUNTIME
+#include "private/qgraphicssystem_runtime_p.h"
+#endif
+
 #include "qinputcontext.h"
 #include "qkeymapper_p.h"
 
@@ -142,7 +146,7 @@ static void initResources()
 
 QT_BEGIN_NAMESPACE
 
-Q_DECL_IMPORT extern void qt_call_post_routines();
+Q_CORE_EXPORT void qt_call_post_routines();
 
 int QApplicationPrivate::app_compile_version = 0x040000; //we don't know exactly, but it's at least 4.0.0
 
@@ -183,8 +187,10 @@ QApplicationPrivate::QApplicationPrivate(int &argc, char **argv, QApplication::T
     directPainters = 0;
 #endif
 
+#ifndef QT_NO_GESTURES
     gestureManager = 0;
     gestureWidget = 0;
+#endif // QT_NO_GESTURES
 
 #if defined(Q_WS_X11) || defined(Q_WS_WIN)
     move_cursor = 0;
@@ -442,6 +448,7 @@ QPalette *QApplicationPrivate::set_pal = 0;        // default palette set by pro
 
 QGraphicsSystem *QApplicationPrivate::graphics_system = 0; // default graphics system
 QString QApplicationPrivate::graphics_system_name;         // graphics system id - for delayed initialization
+bool QApplicationPrivate::runtime_graphics_system = false;
 
 Q_GLOBAL_STATIC(QMutex, applicationFontMutex)
 QFont *QApplicationPrivate::app_font = 0;        // default application font
@@ -775,6 +782,9 @@ void QApplicationPrivate::construct(
 
     qt_is_gui_used = (qt_appType != QApplication::Tty);
     process_cmdline();
+    // the environment variable has the lowest precedence of runtime graphicssystem switches
+    if (graphics_system_name.isEmpty())
+        graphics_system_name = QString::fromLocal8Bit(qgetenv("QT_GRAPHICSSYSTEM"));
     // Must be called before initialize()
     qt_init(this, qt_appType
 #ifdef Q_WS_X11
@@ -1555,10 +1565,18 @@ QStyle* QApplication::setStyle(const QString& style)
     on-screen widgets and QPixmaps. The available systems are \c{"native"},
     \c{"raster"} and \c{"opengl"}.
 
-    This function call overrides both the application commandline
-    \c{-graphicssystem} switch and the configure \c{-graphicssystem} switch.
+    There are several ways to set the graphics backend, in order of decreasing
+    precedence:
+    \list
+        \o the application commandline \c{-graphicssystem} switch
+        \o QApplication::setGraphicsSystem()
+        \o the QT_GRAPHICSSYSTEM environment variable
+        \o the Qt configure \c{-graphicssystem} switch
+    \endlist
+    If the highest precedence switch sets an invalid name, the error will be
+    ignored and the default backend will be used.
 
-    \warning This function must be called before the QApplication constructor
+    \warning This function is only effective before the QApplication constructor
     is called.
 
     \note The \c{"opengl"} option is currently experimental.
@@ -1566,7 +1584,14 @@ QStyle* QApplication::setStyle(const QString& style)
 
 void QApplication::setGraphicsSystem(const QString &system)
 {
-    QApplicationPrivate::graphics_system_name = system;
+#ifdef QT_GRAPHICSSYSTEM_RUNTIME
+    if (QApplicationPrivate::graphics_system_name == QLatin1String("runtime")) {
+        QRuntimeGraphicsSystem *r =
+                static_cast<QRuntimeGraphicsSystem *>(QApplicationPrivate::graphics_system);
+        r->setGraphicsSystem(system);
+    } else
+#endif
+        QApplicationPrivate::graphics_system_name = system;
 }
 
 /*!
@@ -3519,7 +3544,7 @@ int QApplication::startDragDistance()
 
 void QApplication::setLayoutDirection(Qt::LayoutDirection direction)
 {
-    if (layout_direction == direction)
+    if (layout_direction == direction || direction == Qt::LayoutDirectionAuto)
         return;
 
     layout_direction = direction;
@@ -3695,6 +3720,7 @@ bool QApplication::notify(QObject *receiver, QEvent *e)
 #endif // !QT_NO_WHEELEVENT || !QT_NO_TABLETEVENT
     }
 
+#ifndef QT_NO_GESTURES
     // walk through parents and check for gestures
     if (d->gestureManager) {
         switch (e->type()) {
@@ -3739,7 +3765,7 @@ bool QApplication::notify(QObject *receiver, QEvent *e)
             }
         }
     }
-
+#endif // QT_NO_GESTURES
 
     // User input and window activation makes tooltips sleep
     switch (e->type()) {
@@ -4244,6 +4270,7 @@ bool QApplication::notify(QObject *receiver, QEvent *e)
         res = d->notify_helper(receiver, e);
         break;
 
+#ifndef QT_NO_GESTURES
     case QEvent::NativeGesture:
     {
         // only propagate the first gesture event (after the GID_BEGIN)
@@ -4322,6 +4349,7 @@ bool QApplication::notify(QObject *receiver, QEvent *e)
         }
         break;
     }
+#endif // QT_NO_GESTURES
     default:
         res = d->notify_helper(receiver, e);
         break;
@@ -5754,6 +5782,7 @@ Q_GUI_EXPORT void qt_translateRawTouchEvent(QWidget *window,
     QApplicationPrivate::translateRawTouchEvent(window, deviceType, touchPoints);
 }
 
+#ifndef QT_NO_GESTURES
 QGestureManager* QGestureManager::instance()
 {
     QApplicationPrivate *qAppPriv = QApplicationPrivate::instance();
@@ -5761,6 +5790,7 @@ QGestureManager* QGestureManager::instance()
         qAppPriv->gestureManager = new QGestureManager(qApp);
     return qAppPriv->gestureManager;
 }
+#endif // QT_NO_GESTURES
 
 // These pixmaps approximate the images in the Windows User Interface Guidelines.
 
diff --git a/src/gui/kernel/qapplication.h b/src/gui/kernel/qapplication.h
index c21b982..cb1d063 100644
--- a/src/gui/kernel/qapplication.h
+++ b/src/gui/kernel/qapplication.h
@@ -399,7 +399,9 @@ private:
     friend class QDirectPainter;
     friend class QDirectPainterPrivate;
 #endif
+#ifndef QT_NO_GESTURES
     friend class QGestureManager;
+#endif
 
 #if defined(Q_WS_MAC) || defined(Q_WS_X11)
     Q_PRIVATE_SLOT(d_func(), void _q_alertTimeOut())
diff --git a/src/gui/kernel/qapplication_p.h b/src/gui/kernel/qapplication_p.h
index e30b6be..3a3f816 100644
--- a/src/gui/kernel/qapplication_p.h
+++ b/src/gui/kernel/qapplication_p.h
@@ -84,7 +84,9 @@ class QInputContext;
 class QObject;
 class QWidget;
 class QSocketNotifier;
+#ifndef QT_NO_GESTURES
 class QGestureManager;
+#endif
 
 extern bool qt_is_gui_used;
 #ifndef QT_NO_CLIPBOARD
@@ -200,6 +202,7 @@ typedef BOOL (WINAPI *PtrRegisterTouchWindow)(HWND, ULONG);
 typedef BOOL (WINAPI *PtrGetTouchInputInfo)(HANDLE, UINT, PVOID, int);
 typedef BOOL (WINAPI *PtrCloseTouchInputHandle)(HANDLE);
 
+#ifndef QT_NO_GESTURES
 typedef BOOL (WINAPI *PtrGetGestureInfo)(HANDLE, PVOID);
 typedef BOOL (WINAPI *PtrGetGestureExtraArgs)(HANDLE, UINT, PBYTE);
 typedef BOOL (WINAPI *PtrCloseGestureInfoHandle)(HANDLE);
@@ -263,6 +266,8 @@ typedef struct tagGESTURECONFIG
 #define GID_ROLLOVER 0xf003
 #endif
 
+#endif // QT_NO_GESTURES
+
 #endif // Q_WS_WIN
 
 class QScopedLoopLevelCounter
@@ -412,6 +417,7 @@ public:
     static QPalette *set_pal;
     static QGraphicsSystem *graphics_system;
     static QString graphics_system_name;
+    static bool runtime_graphics_system;
 
 private:
     static QFont *app_font; // private for a reason! Always use QApplication::font() instead!
@@ -518,6 +524,7 @@ public:
     void sendSyntheticEnterLeave(QWidget *widget);
 #endif
 
+#ifndef QT_NO_GESTURES
     QGestureManager *gestureManager;
     QWidget *gestureWidget;
 #if defined(Q_WS_X11) || defined(Q_WS_WIN)
@@ -525,6 +532,7 @@ public:
     QPixmap *copy_cursor;
     QPixmap *link_cursor;
 #endif
+#endif
 #if defined(Q_WS_WIN)
     QPixmap *ignore_cursor;
 #endif
@@ -553,6 +561,7 @@ public:
     QHash<DWORD, int> touchInputIDToTouchPointID;
     bool translateTouchEvent(const MSG &msg);
 
+#ifndef QT_NO_GESTURES
     PtrGetGestureInfo GetGestureInfo;
     PtrGetGestureExtraArgs GetGestureExtraArgs;
     PtrCloseGestureInfoHandle CloseGestureInfoHandle;
@@ -561,6 +570,7 @@ public:
     PtrBeginPanningFeedback BeginPanningFeedback;
     PtrUpdatePanningFeedback UpdatePanningFeedback;
     PtrEndPanningFeedback EndPanningFeedback;
+#endif // QT_NO_GESTURES
 #endif
 
 #ifdef QT_RX71_MULTITOUCH
diff --git a/src/gui/kernel/qapplication_s60.cpp b/src/gui/kernel/qapplication_s60.cpp
index dc8d8f7..a50fd95 100644
--- a/src/gui/kernel/qapplication_s60.cpp
+++ b/src/gui/kernel/qapplication_s60.cpp
@@ -62,6 +62,9 @@
 #include "qpaintengine.h"
 #include "private/qmenubar_p.h"
 #include "private/qsoftkeymanager_p.h"
+#ifdef QT_GRAPHICSSYSTEM_RUNTIME
+#include "private/qgraphicssystem_runtime_p.h"
+#endif
 
 #include "apgwgnam.h" // For CApaWindowGroupName
 #include <mdaaudiotoneplayer.h>     // For CMdaAudioToneUtility
@@ -83,6 +86,10 @@
 
 QT_BEGIN_NAMESPACE
 
+// Goom Events through Window Server
+static const int KGoomMemoryLowEvent = 0x10282DBF;
+static const int KGoomMemoryGoodEvent = 0x20026790;
+
 #if defined(QT_DEBUG)
 static bool        appNoGrab        = false;        // Grabbing enabled
 #endif
@@ -408,32 +415,44 @@ void QSymbianControl::HandleLongTapEventL( const TPoint& aPenEventLocation, cons
 void QSymbianControl::translateAdvancedPointerEvent(const TAdvancedPointerEvent *event)
 {
     QApplicationPrivate *d = QApplicationPrivate::instance();
+    QPointF screenPos = qwidget->mapToGlobal(QPoint(event->iPosition.iX, event->iPosition.iY));
     qreal pressure;
     if(d->pressureSupported
         && event->Pressure() > 0) //workaround for misconfigured HAL
         pressure = event->Pressure() / qreal(d->maxTouchPressure);
     else
         pressure = qreal(1.0);
+    processTouchEvent(event->PointerNumber(), event->iType, screenPos, pressure);
+}
+#endif
 
+void QSymbianControl::processTouchEvent(int pointerNumber, TPointerEvent::TType type, QPointF screenPos, qreal pressure)
+{
     QRect screenGeometry = qApp->desktop()->screenGeometry(qwidget);
 
+    QApplicationPrivate *d = QApplicationPrivate::instance();
+
     QList<QTouchEvent::TouchPoint> points = d->appAllTouchPoints;
-    while (points.count() <= event->PointerNumber())
+    while (points.count() <= pointerNumber)
         points.append(QTouchEvent::TouchPoint(points.count()));
 
     Qt::TouchPointStates allStates = 0;
     for (int i = 0; i < points.count(); ++i) {
         QTouchEvent::TouchPoint &touchPoint = points[i];
 
-        if (touchPoint.id() == event->PointerNumber()) {
+        if (touchPoint.id() == pointerNumber) {
             Qt::TouchPointStates state;
-            switch (event->iType) {
+            switch (type) {
             case TPointerEvent::EButton1Down:
+#ifdef QT_SYMBIAN_SUPPORTS_ADVANCED_POINTER
             case TPointerEvent::EEnterHighPressure:
+#endif
                 state = Qt::TouchPointPressed;
                 break;
             case TPointerEvent::EButton1Up:
+#ifdef QT_SYMBIAN_SUPPORTS_ADVANCED_POINTER
             case TPointerEvent::EExitCloseProximity:
+#endif
                 state = Qt::TouchPointReleased;
                 break;
             case TPointerEvent::EDrag:
@@ -444,11 +463,10 @@ void QSymbianControl::translateAdvancedPointerEvent(const TAdvancedPointerEvent
                 state = Qt::TouchPointStationary;
                 break;
             }
-            if (event->PointerNumber() == 0)
+            if (pointerNumber == 0)
                 state |= Qt::TouchPointPrimary;
             touchPoint.setState(state);
 
-            QPointF screenPos = qwidget->mapToGlobal(QPoint(event->iPosition.iX, event->iPosition.iY));
             touchPoint.setScreenPos(screenPos);
             touchPoint.setNormalizedPos(QPointF(screenPos.x() / screenGeometry.width(),
                                                 screenPos.y() / screenGeometry.height()));
@@ -473,7 +491,6 @@ void QSymbianControl::translateAdvancedPointerEvent(const TAdvancedPointerEvent
                                                 QTouchEvent::TouchScreen,
                                                 points);
 }
-#endif
 
 void QSymbianControl::HandlePointerEventL(const TPointerEvent& pEvent)
 {
@@ -547,6 +564,13 @@ void QSymbianControl::HandlePointerEvent(const TPointerEvent& pEvent)
         qt_symbian_move_cursor_sprite();
 #endif
 
+//Generate single touch event for S60 5.0 (has touchscreen, does not have advanced pointers)
+#ifndef QT_SYMBIAN_SUPPORTS_ADVANCED_POINTER
+    if (S60->hasTouchscreen) {
+        processTouchEvent(0, pEvent.iType, QPointF(globalPos), 1.0);
+    }
+#endif
+
     sendMouseEvent(receiver, type, globalPos, button, modifiers);
 }
 
@@ -931,7 +955,16 @@ void QSymbianControl::Draw(const TRect& controlRect) const
     const TRect backingStoreRect(TPoint(backingStoreBase.x(), backingStoreBase.y()), controlRect.Size());
 
     if (engine->type() == QPaintEngine::Raster) {
-        QS60WindowSurface *s60Surface = static_cast<QS60WindowSurface *>(qwidget->windowSurface());
+        QS60WindowSurface *s60Surface;
+#ifdef QT_GRAPHICSSYSTEM_RUNTIME
+        if (QApplicationPrivate::runtime_graphics_system) {
+            QRuntimeWindowSurface *rtSurface =
+                    static_cast<QRuntimeWindowSurface*>(qwidget->windowSurface());
+            s60Surface = static_cast<QS60WindowSurface *>(rtSurface->m_windowSurface);
+        } else
+#endif
+            s60Surface = static_cast<QS60WindowSurface *>(qwidget->windowSurface());
+
         CFbsBitmap *bitmap = s60Surface->symbianBitmap();
         CWindowGc &gc = SystemGc();
 
@@ -999,6 +1032,9 @@ void QSymbianControl::SizeChanged()
                 qwidget->d_func()->syncBackingStore();
             if (!slowResize && tlwExtra)
                 tlwExtra->inTopLevelResize = false;
+        } else {
+            QResizeEvent *e = new QResizeEvent(newSize, oldSize);
+            QApplication::postEvent(qwidget, e);
         }
     }
 
@@ -1767,19 +1803,27 @@ int QApplicationPrivate::symbianProcessWsEvent(const QSymbianEvent *symbianEvent
                 return 1;
             const TWsVisibilityChangedEvent *visChangedEvent = event->VisibilityChanged();
             QWidget *w = QWidgetPrivate::mapper->value(control);
-            if (!w->d_func()->maybeTopData())
+            QWidget *const window = w->window();
+            if (!window->d_func()->maybeTopData())
                 break;
+            QRefCountedWidgetBackingStore &backingStore = window->d_func()->maybeTopData()->backingStore;
             if (visChangedEvent->iFlags & TWsVisibilityChangedEvent::ENotVisible) {
-                delete w->d_func()->topData()->backingStore;
-                w->d_func()->topData()->backingStore = 0;
+                // Decrement backing store reference count
+                backingStore.deref();
                 // In order to ensure that any resources used by the window surface
                 // are immediately freed, we flush the WSERV command buffer.
                 S60->wsSession().Flush();
-            } else if ((visChangedEvent->iFlags & TWsVisibilityChangedEvent::EPartiallyVisible)
-                       && !w->d_func()->maybeBackingStore()) {
-                w->d_func()->topData()->backingStore = new QWidgetBackingStore(w);
-                w->d_func()->invalidateBuffer(w->rect());
-                w->repaint();
+            } else if (visChangedEvent->iFlags & TWsVisibilityChangedEvent::EPartiallyVisible) {
+                if (backingStore.data()) {
+                    // Increment backing store reference count
+                    backingStore.ref();
+                } else {
+                    // Create backing store with an initial reference count of 1
+                    backingStore.create(window);
+                    backingStore.ref();
+                    w->d_func()->invalidateBuffer(w->rect());
+                    w->repaint();
+                }
             }
             return 1;
         }
@@ -1814,6 +1858,53 @@ int QApplicationPrivate::symbianProcessWsEvent(const QSymbianEvent *symbianEvent
         }
 #endif
         break;
+    case KGoomMemoryLowEvent:
+#ifdef QT_DEBUG
+        qDebug() << "QApplicationPrivate::symbianProcessWsEvent - KGoomMemoryLowEvent";
+#endif
+        if (callSymbianEventFilters(symbianEvent))
+            return 1;
+#ifdef QT_GRAPHICSSYSTEM_RUNTIME
+        if(QApplicationPrivate::runtime_graphics_system) {
+            bool switchToSwRendering(false);
+
+            foreach (QWidget *w, QApplication::topLevelWidgets()) {
+                if(w->d_func()->topData()->backingStore) {
+                    switchToSwRendering = true;
+                    break;
+                }
+            }
+
+            if (switchToSwRendering) {
+                QRuntimeGraphicsSystem *gs =
+                   static_cast<QRuntimeGraphicsSystem*>(QApplicationPrivate::graphics_system);
+
+                uint memoryUsage = gs->memoryUsage();
+                uint memoryForFullscreen = ( S60->screenDepth / 8 )
+                                           * S60->screenWidthInPixels
+                                           * S60->screenHeightInPixels;
+
+                S60->memoryLimitForHwRendering = memoryUsage - memoryForFullscreen;
+                gs->setGraphicsSystem(QLatin1String("raster"));
+            }
+        }
+#endif
+        break;
+    case KGoomMemoryGoodEvent:
+#ifdef QT_DEBUG
+        qDebug() << "QApplicationPrivate::symbianProcessWsEvent - KGoomMemoryGoodEvent";
+#endif
+        if (callSymbianEventFilters(symbianEvent))
+            return 1;
+#ifdef QT_GRAPHICSSYSTEM_RUNTIME
+        if(QApplicationPrivate::runtime_graphics_system) {
+            QRuntimeGraphicsSystem *gs =
+                   static_cast<QRuntimeGraphicsSystem*>(QApplicationPrivate::graphics_system);
+            gs->setGraphicsSystem(QLatin1String("openvg"), S60->memoryLimitForHwRendering);
+            S60->memoryLimitForHwRendering = 0;
+        }
+#endif
+        break;
     default:
         break;
     }
@@ -1996,6 +2087,9 @@ void QApplicationPrivate::initializeMultitouch_sys()
         pressureSupported = 0;
     if (HAL::Get(HALData::EPointer3DMaxPressure, maxTouchPressure) != KErrNone)
         maxTouchPressure = KMaxTInt;
+#else
+    pressureSupported = 0;
+    maxTouchPressure = KMaxTInt;
 #endif
 }
 
diff --git a/src/gui/kernel/qapplication_win.cpp b/src/gui/kernel/qapplication_win.cpp
index 60fc5e1..09535fa 100644
--- a/src/gui/kernel/qapplication_win.cpp
+++ b/src/gui/kernel/qapplication_win.cpp
@@ -52,9 +52,11 @@ extern void qt_wince_hide_taskbar(HWND hwnd); //defined in qguifunctions_wince.c
 #include <windowsm.h>
 #include <tpcshell.h>
 #ifdef QT_WINCE_GESTURES
+#ifndef QT_NO_GESTURES
 #include <gesture.h>
 #endif
 #endif
+#endif
 
 #include "qapplication.h"
 #include "qdesktopwidget.h"
@@ -198,6 +200,7 @@ struct SHRGINFO {
 #define SPI_SETSIPINFO        224
 #endif
 
+#ifndef QT_NO_GESTURES
 typedef DWORD (API *AygRecognizeGesture)(SHRGINFO*);
 static AygRecognizeGesture ptrRecognizeGesture = 0;
 static bool aygResolved = false;
@@ -211,6 +214,7 @@ static void resolveAygLibs()
         ptrRecognizeGesture = (AygRecognizeGesture) ayglib.resolve("SHRecognizeGesture");
     }
 }
+#endif // QT_NO_GESTURES
 
 #endif
 
@@ -463,7 +467,9 @@ public:
     bool        translateConfigEvent(const MSG &msg);
     bool        translateCloseEvent(const MSG &msg);
     bool        translateTabletEvent(const MSG &msg, PACKET *localPacketBuf, int numPackets);
+#ifndef QT_NO_GESTURES
     bool        translateGestureEvent(const MSG &msg, const GESTUREINFO &gi);
+#endif
     void        repolishStyle(QStyle &style);
     inline void showChildren(bool spontaneous) { d_func()->showChildren(spontaneous); }
     inline void hideChildren(bool spontaneous) { d_func()->hideChildren(spontaneous); }
@@ -843,6 +849,7 @@ void qt_init(QApplicationPrivate *priv, int)
         ptrSetProcessDPIAware();
 #endif
 
+#ifndef QT_NO_GESTURES
     priv->GetGestureInfo = 0;
     priv->GetGestureExtraArgs = 0;
     priv->CloseGestureInfoHandle = 0;
@@ -883,6 +890,7 @@ void qt_init(QApplicationPrivate *priv, int)
         (PtrEndPanningFeedback)QLibrary::resolve(QLatin1String("uxtheme"),
                                                    "EndPanningFeedback");
 #endif
+#endif // QT_NO_GESTURES
 }
 
 /*****************************************************************************
@@ -1542,7 +1550,7 @@ extern "C" LRESULT QT_WIN_CALLBACK QtWndProc(HWND hwnd, UINT message, WPARAM wPa
     case WM_SETTINGCHANGE:
 #ifdef Q_WS_WINCE
         // CE SIP hide/show
-        if (wParam == SPI_SETSIPINFO) {
+        if (qt_desktopWidget && wParam == SPI_SETSIPINFO) {
             QResizeEvent re(QSize(0, 0), QSize(0, 0)); // Calculated by QDesktopWidget
             QApplication::sendEvent(qt_desktopWidget, &re);
             break;
@@ -1667,12 +1675,14 @@ extern "C" LRESULT QT_WIN_CALLBACK QtWndProc(HWND hwnd, UINT message, WPARAM wPa
                         shrg.ptDown.y = GET_Y_LPARAM(lParam);
                         shrg.dwFlags = SHRG_RETURNCMD | SHRG_NOANIMATION;
                         resolveAygLibs();
+#ifndef QT_NO_GESTURES
                         if (ptrRecognizeGesture && (ptrRecognizeGesture(&shrg) == GN_CONTEXTMENU)) {
                             if (QApplication::activePopupWidget())
                                 QApplication::activePopupWidget()->close();
                             QContextMenuEvent e(QContextMenuEvent::Mouse, pos, globalPos);
                             result = qt_sendSpontaneousEvent(alienWidget, &e);
                         }
+#endif // QT_NO_GESTURES
                     }
                 }
             }
@@ -2556,6 +2566,7 @@ extern "C" LRESULT QT_WIN_CALLBACK QtWndProc(HWND hwnd, UINT message, WPARAM wPa
             }
             result = false;
             break;
+#ifndef QT_NO_GESTURES
 #if !defined(Q_WS_WINCE) || defined(QT_WINCE_GESTURES)
         case WM_GESTURE: {
             GESTUREINFO gi;
@@ -2590,6 +2601,7 @@ extern "C" LRESULT QT_WIN_CALLBACK QtWndProc(HWND hwnd, UINT message, WPARAM wPa
             break;
         }
 #endif // !defined(Q_WS_WINCE) || defined(QT_WINCE_GESTURES)
+#endif // QT_NO_GESTURES
 #ifndef QT_NO_CURSOR
         case WM_SETCURSOR: {
             QCursor *ovr = QApplication::overrideCursor();
@@ -3825,6 +3837,7 @@ bool QETWidget::translateCloseEvent(const MSG &)
     return d_func()->close_helper(QWidgetPrivate::CloseWithSpontaneousEvent);
 }
 
+#ifndef QT_NO_GESTURES
 bool QETWidget::translateGestureEvent(const MSG &, const GESTUREINFO &gi)
 {
     const QPoint widgetPos = QPoint(gi.ptsLocation.x, gi.ptsLocation.y);
@@ -3863,7 +3876,7 @@ bool QETWidget::translateGestureEvent(const MSG &, const GESTUREINFO &gi)
         qt_sendSpontaneousEvent(widget, &event);
     return true;
 }
-
+#endif // QT_NO_GESTURES
 
 void  QApplication::setCursorFlashTime(int msecs)
 {
diff --git a/src/gui/kernel/qapplication_x11.cpp b/src/gui/kernel/qapplication_x11.cpp
index 78fc704..3664743 100644
--- a/src/gui/kernel/qapplication_x11.cpp
+++ b/src/gui/kernel/qapplication_x11.cpp
@@ -5268,7 +5268,7 @@ bool QETWidget::translateConfigEvent(const XEvent *event)
 
         if (isVisible() && data->crect.size() != oldSize) {
             Q_ASSERT(d->extra->topextra);
-            QWidgetBackingStore *bs = d->extra->topextra->backingStore;
+            QWidgetBackingStore *bs = d->extra->topextra->backingStore.data();
             const bool hasStaticContents = bs && bs->hasStaticContents();
             // If we have a backing store with static contents, we have to disable the top-level
             // resize optimization in order to get invalidated regions for resized widgets.
diff --git a/src/gui/kernel/qcocoaview_mac.mm b/src/gui/kernel/qcocoaview_mac.mm
index 4953c48..eec9699 100644
--- a/src/gui/kernel/qcocoaview_mac.mm
+++ b/src/gui/kernel/qcocoaview_mac.mm
@@ -952,12 +952,14 @@ static int qCocoaViewCount = 0;
     if (!QApplicationPrivate::tryModalHelper(qwidget, 0))
         return;
 
+#ifndef QT_NO_GESTURES
     QNativeGestureEvent qNGEvent;
     qNGEvent.gestureType = QNativeGestureEvent::Zoom;
     NSPoint p = [[event window] convertBaseToScreen:[event locationInWindow]];
     qNGEvent.position = flipPoint(p).toPoint();
     qNGEvent.percentage = [event magnification];
     qt_sendSpontaneousEvent(qwidget, &qNGEvent);
+#endif // QT_NO_GESTURES
 }
 
 - (void)rotateWithEvent:(NSEvent *)event;
@@ -965,12 +967,14 @@ static int qCocoaViewCount = 0;
     if (!QApplicationPrivate::tryModalHelper(qwidget, 0))
         return;
 
+#ifndef QT_NO_GESTURES
     QNativeGestureEvent qNGEvent;
     qNGEvent.gestureType = QNativeGestureEvent::Rotate;
     NSPoint p = [[event window] convertBaseToScreen:[event locationInWindow]];
     qNGEvent.position = flipPoint(p).toPoint();
     qNGEvent.percentage = -[event rotation];
     qt_sendSpontaneousEvent(qwidget, &qNGEvent);
+#endif // QT_NO_GESTURES
 }
 
 - (void)swipeWithEvent:(NSEvent *)event;
@@ -978,6 +982,7 @@ static int qCocoaViewCount = 0;
     if (!QApplicationPrivate::tryModalHelper(qwidget, 0))
         return;
 
+#ifndef QT_NO_GESTURES
     QNativeGestureEvent qNGEvent;
     qNGEvent.gestureType = QNativeGestureEvent::Swipe;
     NSPoint p = [[event window] convertBaseToScreen:[event locationInWindow]];
@@ -991,6 +996,7 @@ static int qCocoaViewCount = 0;
     else if ([event deltaY] == -1)
         qNGEvent.angle = 270.0f;
     qt_sendSpontaneousEvent(qwidget, &qNGEvent);
+#endif // QT_NO_GESTURES
 }
 
 - (void)beginGestureWithEvent:(NSEvent *)event;
@@ -998,11 +1004,13 @@ static int qCocoaViewCount = 0;
     if (!QApplicationPrivate::tryModalHelper(qwidget, 0))
         return;
 
+#ifndef QT_NO_GESTURES
     QNativeGestureEvent qNGEvent;
     qNGEvent.gestureType = QNativeGestureEvent::GestureBegin;
     NSPoint p = [[event window] convertBaseToScreen:[event locationInWindow]];
     qNGEvent.position = flipPoint(p).toPoint();
     qt_sendSpontaneousEvent(qwidget, &qNGEvent);
+#endif // QT_NO_GESTURES
 }
 
 - (void)endGestureWithEvent:(NSEvent *)event;
@@ -1010,11 +1018,13 @@ static int qCocoaViewCount = 0;
     if (!QApplicationPrivate::tryModalHelper(qwidget, 0))
         return;
 
+#ifndef QT_NO_GESTURES
     QNativeGestureEvent qNGEvent;
     qNGEvent.gestureType = QNativeGestureEvent::GestureEnd;
     NSPoint p = [[event window] convertBaseToScreen:[event locationInWindow]];
     qNGEvent.position = flipPoint(p).toPoint();
     qt_sendSpontaneousEvent(qwidget, &qNGEvent);
+#endif // QT_NO_GESTURES
 }
 
 - (void)frameDidChange:(NSNotification *)note
diff --git a/src/gui/kernel/qevent.cpp b/src/gui/kernel/qevent.cpp
index acf7184..92eed33 100644
--- a/src/gui/kernel/qevent.cpp
+++ b/src/gui/kernel/qevent.cpp
@@ -3421,9 +3421,11 @@ QDebug operator<<(QDebug dbg, const QEvent *e) {
     case QEvent::ChildRemoved: n = n ? n : "ChildRemoved";
         dbg.nospace() << "QChildEvent(" << n << ", " << (static_cast<const QChildEvent*>(e))->child();
         return dbg.space();
+#ifndef QT_NO_GESTURES
     case QEvent::Gesture:
         n = "Gesture";
         break;
+#endif
     default:
         dbg.nospace() << "QEvent(" << (const void *)e << ", type = " << e->type() << ')';
         return dbg.space();
@@ -4254,6 +4256,7 @@ QTouchEvent::TouchPoint &QTouchEvent::TouchPoint::operator=(const QTouchEvent::T
     return *this;
 }
 
+#ifndef QT_NO_GESTURES
 /*!
     \class QGestureEvent
     \since 4.6
@@ -4558,4 +4561,6 @@ const QGestureEventPrivate *QGestureEvent::d_func() const
 */
 #endif
 
+#endif // QT_NO_GESTURES
+
 QT_END_NAMESPACE
diff --git a/src/gui/kernel/qevent.h b/src/gui/kernel/qevent.h
index 90242fe..9c70c02 100644
--- a/src/gui/kernel/qevent.h
+++ b/src/gui/kernel/qevent.h
@@ -62,7 +62,9 @@ QT_BEGIN_NAMESPACE
 QT_MODULE(Gui)
 
 class QAction;
+#ifndef QT_NO_GESTURES
 class QGesture;
+#endif
 
 class Q_GUI_EXPORT QInputEvent : public QEvent
 {
@@ -824,6 +826,7 @@ protected:
     friend class QApplicationPrivate;
 };
 
+#ifndef QT_NO_GESTURES
 class QGesture;
 class QGestureEventPrivate;
 class Q_GUI_EXPORT QGestureEvent : public QEvent
@@ -875,6 +878,7 @@ private:
     friend class QApplication;
     friend class QGestureManager;
 };
+#endif // QT_NO_GESTURES
 
 QT_END_NAMESPACE
 
diff --git a/src/gui/kernel/qevent_p.h b/src/gui/kernel/qevent_p.h
index 5c94a23..e323aa9 100644
--- a/src/gui/kernel/qevent_p.h
+++ b/src/gui/kernel/qevent_p.h
@@ -120,6 +120,7 @@ public:
     qreal pressure;
 };
 
+#ifndef QT_NO_GESTURES
 class QNativeGestureEvent : public QEvent
 {
 public:
@@ -164,7 +165,7 @@ public:
     QMap<Qt::GestureType, bool> accepted;
     QMap<Qt::GestureType, QWidget *> targetWidgets;
 };
-
+#endif // QT_NO_GESTURES
 
 class QFileOpenEventPrivate
 {
diff --git a/src/gui/kernel/qeventdispatcher_mac.mm b/src/gui/kernel/qeventdispatcher_mac.mm
index 0d93b9f..e26fbde 100644
--- a/src/gui/kernel/qeventdispatcher_mac.mm
+++ b/src/gui/kernel/qeventdispatcher_mac.mm
@@ -492,6 +492,7 @@ static bool IsMouseOrKeyEvent( NSEvent* event )
         case NSOtherMouseDown:   
         case NSOtherMouseUp:     
         case NSOtherMouseDragged:
+#ifndef QT_NO_GESTURES
 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
         case NSEventTypeGesture: // touch events
         case NSEventTypeMagnify:
@@ -500,6 +501,7 @@ static bool IsMouseOrKeyEvent( NSEvent* event )
         case NSEventTypeBeginGesture:
         case NSEventTypeEndGesture:
 #endif
+#endif // QT_NO_GESTURES
             result    = true;
         break;
 
diff --git a/src/gui/kernel/qgesture.cpp b/src/gui/kernel/qgesture.cpp
index 49bdea7..f5688f4 100644
--- a/src/gui/kernel/qgesture.cpp
+++ b/src/gui/kernel/qgesture.cpp
@@ -42,6 +42,8 @@
 #include "qgesture.h"
 #include "private/qgesture_p.h"
 
+#ifndef QT_NO_GESTURES
+
 QT_BEGIN_NAMESPACE
 
  /*!
@@ -725,3 +727,5 @@ void QTapAndHoldGesture::setPosition(const QPointF &value)
 }
 
 QT_END_NAMESPACE
+
+#endif // QT_NO_GESTURES
diff --git a/src/gui/kernel/qgesture.h b/src/gui/kernel/qgesture.h
index c9bdce6..8c10895 100644
--- a/src/gui/kernel/qgesture.h
+++ b/src/gui/kernel/qgesture.h
@@ -49,6 +49,8 @@
 #include <QtCore/qrect.h>
 #include <QtCore/qmetatype.h>
 
+#ifndef QT_NO_GESTURES
+
 QT_BEGIN_HEADER
 
 Q_DECLARE_METATYPE(Qt::GestureState)
@@ -258,4 +260,6 @@ QT_END_NAMESPACE
 Q_DECLARE_METATYPE(QGesture::GestureCancelPolicy)
 QT_END_HEADER
 
+#endif // QT_NO_GESTURES
+
 #endif // QGESTURE_H
diff --git a/src/gui/kernel/qgesture_p.h b/src/gui/kernel/qgesture_p.h
index bf60f97..f5474c1 100644
--- a/src/gui/kernel/qgesture_p.h
+++ b/src/gui/kernel/qgesture_p.h
@@ -59,6 +59,8 @@
 #include "qelapsedtimer.h"
 #include "private/qobject_p.h"
 
+#ifndef QT_NO_GESTURES
+
 QT_BEGIN_NAMESPACE
 
 class QGesturePrivate : public QObjectPrivate
@@ -179,4 +181,6 @@ public:
 
 QT_END_NAMESPACE
 
+#endif // QT_NO_GESTURES
+
 #endif // QGESTURE_P_H
diff --git a/src/gui/kernel/qgesturemanager.cpp b/src/gui/kernel/qgesturemanager.cpp
index 43facef..2af031b 100644
--- a/src/gui/kernel/qgesturemanager.cpp
+++ b/src/gui/kernel/qgesturemanager.cpp
@@ -66,6 +66,8 @@
 # define DEBUG qDebug
 #endif
 
+#ifndef QT_NO_GESTURES
+
 QT_BEGIN_NAMESPACE
 
 QGestureManager::QGestureManager(QObject *parent)
@@ -684,6 +686,7 @@ void QGestureManager::recycle(QGesture *gesture)
     if (recognizer) {
         gesture->setGestureCancelPolicy(QGesture::CancelNone);
         recognizer->reset(gesture);
+        m_activeGestures.remove(gesture);
     } else {
         cleanupGesturesForRemovedRecognizer(gesture);
     }
@@ -691,4 +694,6 @@ void QGestureManager::recycle(QGesture *gesture)
 
 QT_END_NAMESPACE
 
+#endif // QT_NO_GESTURES
+
 #include "moc_qgesturemanager_p.cpp"
diff --git a/src/gui/kernel/qgesturemanager_p.h b/src/gui/kernel/qgesturemanager_p.h
index c452f49..747cb1a 100644
--- a/src/gui/kernel/qgesturemanager_p.h
+++ b/src/gui/kernel/qgesturemanager_p.h
@@ -58,6 +58,8 @@
 #include "private/qwidget_p.h"
 #include "qgesturerecognizer.h"
 
+#ifndef QT_NO_GESTURES
+
 QT_BEGIN_NAMESPACE
 
 class QBasicTimer;
@@ -143,4 +145,6 @@ private:
 
 QT_END_NAMESPACE
 
+#endif // QT_NO_GESTURES
+
 #endif // QGESTUREMANAGER_P_H
diff --git a/src/gui/kernel/qgesturerecognizer.cpp b/src/gui/kernel/qgesturerecognizer.cpp
index 9dcca17..3e23bbf 100644
--- a/src/gui/kernel/qgesturerecognizer.cpp
+++ b/src/gui/kernel/qgesturerecognizer.cpp
@@ -44,6 +44,8 @@
 #include "private/qgesture_p.h"
 #include "private/qgesturemanager_p.h"
 
+#ifndef QT_NO_GESTURES
+
 QT_BEGIN_NAMESPACE
 
 /*!
@@ -231,3 +233,5 @@ void QGestureRecognizer::unregisterRecognizer(Qt::GestureType type)
 }
 
 QT_END_NAMESPACE
+
+#endif // QT_NO_GESTURES
diff --git a/src/gui/kernel/qgesturerecognizer.h b/src/gui/kernel/qgesturerecognizer.h
index 3e17c99..5afb43f 100644
--- a/src/gui/kernel/qgesturerecognizer.h
+++ b/src/gui/kernel/qgesturerecognizer.h
@@ -45,6 +45,8 @@
 #include <QtCore/qglobal.h>
 #include <QtCore/qnamespace.h>
 
+#ifndef QT_NO_GESTURES
+
 QT_BEGIN_HEADER
 
 QT_BEGIN_NAMESPACE
@@ -95,4 +97,6 @@ QT_END_NAMESPACE
 
 QT_END_HEADER
 
+#endif // QT_NO_GESTURES
+
 #endif // QGESTURERECOGNIZER_H
diff --git a/src/gui/kernel/qkeymapper_mac.cpp b/src/gui/kernel/qkeymapper_mac.cpp
index a7145d4..873b8f9 100644
--- a/src/gui/kernel/qkeymapper_mac.cpp
+++ b/src/gui/kernel/qkeymapper_mac.cpp
@@ -672,23 +672,7 @@ QKeyMapperPrivate::updateKeyboard()
 #endif
     if (iso639Code) {
         keyboardInputLocale = QLocale(QCFString::toQString(iso639Code));
-        QString monday = keyboardInputLocale.dayName(1);
-        bool rtl = false;
-        for (int i = 0; i < monday.length(); ++i) {
-            switch (monday.at(i).direction()) {
-            default:
-                break;
-            case QChar::DirR:
-            case QChar::DirAL:
-            case QChar::DirRLE:
-            case QChar::DirRLO:
-                rtl = true;
-                break;
-            }
-            if (rtl)
-                break;
-        }
-        keyboardInputDirection = rtl ? Qt::RightToLeft : Qt::LeftToRight;
+        keyboardInputDirection = keyboardInputLocale.textDirection();
     } else {
         keyboardInputLocale = QLocale::c();
         keyboardInputDirection = Qt::LeftToRight;
diff --git a/src/gui/kernel/qkeymapper_qws.cpp b/src/gui/kernel/qkeymapper_qws.cpp
index 5b6b1c4..63bb46b 100644
--- a/src/gui/kernel/qkeymapper_qws.cpp
+++ b/src/gui/kernel/qkeymapper_qws.cpp
@@ -52,7 +52,7 @@ QT_USE_NAMESPACE
 QKeyMapperPrivate::QKeyMapperPrivate()
 {
     keyboardInputLocale = QLocale::system();
-    keyboardInputDirection = Qt::RightToLeft;
+    keyboardInputDirection = keyboardInputLocale.textDirection();
 }
 
 QKeyMapperPrivate::~QKeyMapperPrivate()
diff --git a/src/gui/kernel/qkeymapper_x11.cpp b/src/gui/kernel/qkeymapper_x11.cpp
index 807959c..825edbc 100644
--- a/src/gui/kernel/qkeymapper_x11.cpp
+++ b/src/gui/kernel/qkeymapper_x11.cpp
@@ -80,22 +80,15 @@ QT_BEGIN_NAMESPACE
       (((KeySym)(keysym) >= 0x11000000) && ((KeySym)(keysym) <= 0x1100FFFF))
 #endif
 
-void q_getLocaleAndDirection(QLocale *locale,
-                                  Qt::LayoutDirection *direction,
-                                  const QByteArray &layoutName,
-                                  const QByteArray &variantName)
+QLocale q_getKeyboardLocale(const QByteArray &layoutName, const QByteArray &variantName)
 {
     int i = 0;
     while (xkbLayoutData[i].layout != 0) {
-        if (layoutName == xkbLayoutData[i].layout && variantName == xkbLayoutData[i].variant) {
-            *locale = QLocale(xkbLayoutData[i].language, xkbLayoutData[i].country);
-            *direction = xkbLayoutData[i].direction;
-            return;
-        }
+        if (layoutName == xkbLayoutData[i].layout && variantName == xkbLayoutData[i].variant)
+            return QLocale(xkbLayoutData[i].language, xkbLayoutData[i].country);
         ++i;
     }
-    *locale = QLocale::c();
-    *direction = Qt::LeftToRight;
+    return QLocale::c();
 }
 #endif // QT_NO_XKB
 
@@ -523,10 +516,8 @@ void QKeyMapperPrivate::clearMappings()
         // if (keyboardLayoutName.isEmpty())
         //     qWarning("Qt: unable to determine keyboard layout, please talk to qt-bugs@trolltech.com"); ?
 
-        q_getLocaleAndDirection(&keyboardInputLocale,
-                              &keyboardInputDirection,
-                              layoutName,
-                              variantName);
+        keyboardInputLocale = q_getKeyboardLocale(layoutName, variantName);
+        keyboardInputDirection = keyboardInputLocale.textDirection();
 
 #if 0
         qDebug() << "keyboard input locale ="
diff --git a/src/gui/kernel/qkeymapper_x11_p.cpp b/src/gui/kernel/qkeymapper_x11_p.cpp
index 20fcc86..6308973 100644
--- a/src/gui/kernel/qkeymapper_x11_p.cpp
+++ b/src/gui/kernel/qkeymapper_x11_p.cpp
@@ -271,13 +271,13 @@ static struct {
     // name = is:nodeadkeys, description = Iceland
     { "is", "nodeadkeys", Qt::LeftToRight, QLocale::Icelandic, QLocale::Iceland },
     // name = il, description = Israel
-    { "il", "", Qt::LeftToRight, QLocale::Hebrew, QLocale::Israel },
+    { "il", "", Qt::RightToLeft, QLocale::Hebrew, QLocale::Israel },
     // name = il:lyx, description = Israel
-    { "il", "lyx", Qt::LeftToRight, QLocale::Hebrew, QLocale::Israel },
+    { "il", "lyx", Qt::RightToLeft, QLocale::Hebrew, QLocale::Israel },
     // name = il:si1452, description = Israel
-    { "il", "si1452", Qt::LeftToRight, QLocale::Hebrew, QLocale::Israel },
+    { "il", "si1452", Qt::RightToLeft, QLocale::Hebrew, QLocale::Israel },
     // name = il:phonetic, description = Israel
-    { "il", "phonetic", Qt::LeftToRight, QLocale::Hebrew, QLocale::Israel },
+    { "il", "phonetic", Qt::RightToLeft, QLocale::Hebrew, QLocale::Israel },
     // name = it, description = Italy
     { "it", "", Qt::LeftToRight, QLocale::Italian, QLocale::Italy },
     // name = it:nodeadkeys, description = Italy
@@ -419,11 +419,11 @@ static struct {
     // name = ch:fr_sundeadkeys, description = Switzerland
     { "ch", "fr_sundeadkeys", Qt::LeftToRight, QLocale::French, QLocale::Switzerland },
     // name = sy, description = Syria
-    { "sy", "", Qt::RightToLeft, QLocale::Arabic, QLocale::SyrianArabRepublic },
+    { "sy", "", Qt::RightToLeft, QLocale::Syriac, QLocale::SyrianArabRepublic },
     // name = sy:syc, description = Syria
-    { "sy", "syc", Qt::RightToLeft, QLocale::Arabic, QLocale::SyrianArabRepublic },
+    { "sy", "syc", Qt::RightToLeft, QLocale::Syriac, QLocale::SyrianArabRepublic },
     // name = sy:syc_phonetic, description = Syria
-    { "sy", "syc_phonetic", Qt::RightToLeft, QLocale::Arabic, QLocale::SyrianArabRepublic },
+    { "sy", "syc_phonetic", Qt::RightToLeft, QLocale::Syriac, QLocale::SyrianArabRepublic },
     // name = tj, description = Tajikistan
     { "tj", "", Qt::LeftToRight, QLocale::Tajik, QLocale::Tajikistan },
     // name = lk, description = Sri Lanka
diff --git a/src/gui/kernel/qkeysequence.cpp b/src/gui/kernel/qkeysequence.cpp
index 931bc33..c2f275a 100644
--- a/src/gui/kernel/qkeysequence.cpp
+++ b/src/gui/kernel/qkeysequence.cpp
@@ -439,6 +439,10 @@ static const struct {
     { Qt::Key_MediaPrevious,              QT_TRANSLATE_NOOP("QShortcut", "Media Previous") },
     { Qt::Key_MediaNext,                  QT_TRANSLATE_NOOP("QShortcut", "Media Next") },
     { Qt::Key_MediaRecord,                QT_TRANSLATE_NOOP("QShortcut", "Media Record") },
+    //: Media player pause button
+    { Qt::Key_MediaPause,                 QT_TRANSLATE_NOOP("QShortcut", "Media Pause") },
+    //: Media player button to toggle between playing and paused
+    { Qt::Key_MediaTogglePlayPause,       QT_TRANSLATE_NOOP("QShortcut", "Toggle Media Play/Pause") },
     { Qt::Key_HomePage,                   QT_TRANSLATE_NOOP("QShortcut", "Home Page") },
     { Qt::Key_Favorites,                  QT_TRANSLATE_NOOP("QShortcut", "Favorites") },
     { Qt::Key_Search,                     QT_TRANSLATE_NOOP("QShortcut", "Search") },
@@ -575,13 +579,25 @@ static const struct {
 
     // --------------------------------------------------------------
     // Device keys
-    { Qt::Key_Context1,     QT_TRANSLATE_NOOP("QShortcut", "Context1") },
-    { Qt::Key_Context2,     QT_TRANSLATE_NOOP("QShortcut", "Context2") },
-    { Qt::Key_Context3,     QT_TRANSLATE_NOOP("QShortcut", "Context3") },
-    { Qt::Key_Context4,     QT_TRANSLATE_NOOP("QShortcut", "Context4") },
-    { Qt::Key_Call,         QT_TRANSLATE_NOOP("QShortcut", "Call") },
-    { Qt::Key_Hangup,       QT_TRANSLATE_NOOP("QShortcut", "Hangup") },
-    { Qt::Key_Flip,         QT_TRANSLATE_NOOP("QShortcut", "Flip") },
+    { Qt::Key_Context1,         QT_TRANSLATE_NOOP("QShortcut", "Context1") },
+    { Qt::Key_Context2,         QT_TRANSLATE_NOOP("QShortcut", "Context2") },
+    { Qt::Key_Context3,         QT_TRANSLATE_NOOP("QShortcut", "Context3") },
+    { Qt::Key_Context4,         QT_TRANSLATE_NOOP("QShortcut", "Context4") },
+    //: Button to start a call (note: a separate button is used to end the call)
+    { Qt::Key_Call,             QT_TRANSLATE_NOOP("QShortcut", "Call") },
+    //: Button to end a call (note: a separate button is used to start the call)
+    { Qt::Key_Hangup,           QT_TRANSLATE_NOOP("QShortcut", "Hangup") },
+    //: Button that will hang up if we're in call, or make a call if we're not.
+    { Qt::Key_ToggleCallHangup, QT_TRANSLATE_NOOP("QShortcut", "Toggle Call/Hangup") },
+    { Qt::Key_Flip,             QT_TRANSLATE_NOOP("QShortcut", "Flip") },
+    //: Button to trigger voice dialling
+    { Qt::Key_VoiceDial,        QT_TRANSLATE_NOOP("QShortcut", "Voice Dial") },
+    //: Button to redial the last number called
+    { Qt::Key_LastNumberRedial, QT_TRANSLATE_NOOP("QShortcut", "Last Number Redial") },
+    //: Button to trigger the camera shutter (take a picture)
+    { Qt::Key_Camera,           QT_TRANSLATE_NOOP("QShortcut", "Camera Shutter") },
+    //: Button to focus the camera
+    { Qt::Key_CameraFocus,      QT_TRANSLATE_NOOP("QShortcut", "Camera Focus") },
 
     // --------------------------------------------------------------
     // Japanese keyboard support
diff --git a/src/gui/kernel/qmacgesturerecognizer_mac.mm b/src/gui/kernel/qmacgesturerecognizer_mac.mm
index fba839b..0ccbb52 100644
--- a/src/gui/kernel/qmacgesturerecognizer_mac.mm
+++ b/src/gui/kernel/qmacgesturerecognizer_mac.mm
@@ -47,6 +47,8 @@
 #include "qwidget.h"
 #include "qdebug.h"
 
+#ifndef QT_NO_GESTURES
+
 QT_BEGIN_NAMESPACE
 
 QMacSwipeGestureRecognizer::QMacSwipeGestureRecognizer()
@@ -260,3 +262,5 @@ void QMacPanGestureRecognizer::reset(QGesture *gesture)
 #endif // QT_MAC_USE_COCOA
 
 QT_END_NAMESPACE
+
+#endif // QT_NO_GESTURES
diff --git a/src/gui/kernel/qmacgesturerecognizer_mac_p.h b/src/gui/kernel/qmacgesturerecognizer_mac_p.h
index dd8a150..f48c160 100644
--- a/src/gui/kernel/qmacgesturerecognizer_mac_p.h
+++ b/src/gui/kernel/qmacgesturerecognizer_mac_p.h
@@ -57,6 +57,8 @@
 #include "qpoint.h"
 #include "qgesturerecognizer.h"
 
+#ifndef QT_NO_GESTURES
+
 QT_BEGIN_NAMESPACE
 
 class QMacSwipeGestureRecognizer : public QGestureRecognizer
@@ -99,4 +101,6 @@ private:
 
 QT_END_NAMESPACE
 
+#endif // QT_NO_GESTURES
+
 #endif // QMACSWIPEGESTURERECOGNIZER_MAC_P_H
diff --git a/src/gui/kernel/qstandardgestures.cpp b/src/gui/kernel/qstandardgestures.cpp
index a575717..6960838 100644
--- a/src/gui/kernel/qstandardgestures.cpp
+++ b/src/gui/kernel/qstandardgestures.cpp
@@ -47,6 +47,8 @@
 #include "qabstractscrollarea.h"
 #include "qdebug.h"
 
+#ifndef QT_NO_GESTURES
+
 QT_BEGIN_NAMESPACE
 
 QPanGestureRecognizer::QPanGestureRecognizer()
@@ -563,3 +565,5 @@ void QTapAndHoldGestureRecognizer::reset(QGesture *state)
 }
 
 QT_END_NAMESPACE
+
+#endif // QT_NO_GESTURES
diff --git a/src/gui/kernel/qstandardgestures_p.h b/src/gui/kernel/qstandardgestures_p.h
index 64505d8..da73b85 100644
--- a/src/gui/kernel/qstandardgestures_p.h
+++ b/src/gui/kernel/qstandardgestures_p.h
@@ -56,6 +56,8 @@
 #include "qgesturerecognizer.h"
 #include "private/qgesture_p.h"
 
+#ifndef QT_NO_GESTURES
+
 QT_BEGIN_NAMESPACE
 
 class QPanGestureRecognizer : public QGestureRecognizer
@@ -110,4 +112,6 @@ public:
 
 QT_END_NAMESPACE
 
+#endif // QT_NO_GESTURES
+
 #endif // QSTANDARDGESTURES_P_H
diff --git a/src/gui/kernel/qt_s60_p.h b/src/gui/kernel/qt_s60_p.h
index f560458..fe3fa57 100644
--- a/src/gui/kernel/qt_s60_p.h
+++ b/src/gui/kernel/qt_s60_p.h
@@ -129,6 +129,7 @@ public:
     int supportsPremultipliedAlpha : 1;
     int avkonComponentsSupportTransparency : 1;
     int menuBeingConstructed : 1;
+    int memoryLimitForHwRendering;
     QApplication::QS60MainApplicationFactory s60ApplicationFactory; // typedef'ed pointer type
     static inline void updateScreenSize();
     static inline RWsSession& wsSession();
@@ -216,6 +217,7 @@ private:
             const QPoint &globalPos,
             Qt::MouseButton button,
             Qt::KeyboardModifiers modifiers);
+    void processTouchEvent(int pointerNumber, TPointerEvent::TType type, QPointF screenPos, qreal pressure);
     void HandleLongTapEventL( const TPoint& aPenEventLocation, const TPoint& aPenEventScreenLocation );
 #ifdef QT_SYMBIAN_SUPPORTS_ADVANCED_POINTER
     void translateAdvancedPointerEvent(const TAdvancedPointerEvent *event);
diff --git a/src/gui/kernel/qwhatsthis.cpp b/src/gui/kernel/qwhatsthis.cpp
index 6181b62..ff4641e 100644
--- a/src/gui/kernel/qwhatsthis.cpp
+++ b/src/gui/kernel/qwhatsthis.cpp
@@ -143,7 +143,7 @@ QT_BEGIN_NAMESPACE
     \sa QToolTip
 */
 
-Q_DECL_IMPORT extern void qDeleteInEventHandler(QObject *o);
+Q_CORE_EXPORT void qDeleteInEventHandler(QObject *o);
 
 class QWhatsThat : public QWidget
 {
diff --git a/src/gui/kernel/qwidget.cpp b/src/gui/kernel/qwidget.cpp
index 569af42..492954a 100644
--- a/src/gui/kernel/qwidget.cpp
+++ b/src/gui/kernel/qwidget.cpp
@@ -67,6 +67,7 @@
 # include "qt_mac_p.h"
 # include "qt_cocoa_helpers_mac_p.h"
 # include "qmainwindow.h"
+# include "qtoolbar.h"
 #endif
 #if defined(Q_WS_QWS)
 # include "qwsdisplay_qws.h"
@@ -161,6 +162,51 @@ static inline bool hasBackingStoreSupport()
 extern bool qt_sendSpontaneousEvent(QObject*, QEvent*); // qapplication.cpp
 extern QDesktopWidget *qt_desktopWidget; // qapplication.cpp
 
+
+QRefCountedWidgetBackingStore::QRefCountedWidgetBackingStore()
+    :   m_ptr(0)
+    ,   m_count(0)
+{
+
+}
+
+QRefCountedWidgetBackingStore::~QRefCountedWidgetBackingStore()
+{
+    delete m_ptr;
+}
+
+void QRefCountedWidgetBackingStore::create(QWidget *widget)
+{
+    destroy();
+    m_ptr = new QWidgetBackingStore(widget);
+    m_count = 0;
+}
+
+void QRefCountedWidgetBackingStore::destroy()
+{
+    delete m_ptr;
+    m_ptr = 0;
+    m_count = 0;
+}
+
+void QRefCountedWidgetBackingStore::ref()
+{
+    Q_ASSERT(m_ptr);
+    ++m_count;
+}
+
+void QRefCountedWidgetBackingStore::deref()
+{
+    if (m_count) {
+        Q_ASSERT(m_ptr);
+        if (0 == --m_count) {
+            delete m_ptr;
+            m_ptr = 0;
+        }
+    }
+}
+
+
 QWidgetPrivate::QWidgetPrivate(int version)
     : QObjectPrivate(version)
       , extra(0)
@@ -202,7 +248,9 @@ QWidgetPrivate::QWidgetPrivate(int version)
       , picture(0)
 #elif defined(Q_WS_WIN)
       , noPaintOnScreen(0)
+  #ifndef QT_NO_GESTURES
       , nativeGesturePanEnabled(0)
+  #endif
 #elif defined(Q_WS_MAC)
       , needWindowChange(0)
       , hasAlienChildren(0)
@@ -248,9 +296,14 @@ QWidgetPrivate::~QWidgetPrivate()
 QWindowSurface *QWidgetPrivate::createDefaultWindowSurface()
 {
     Q_Q(QWidget);
+
+    QWindowSurface *surface;
     if (QApplicationPrivate::graphicsSystem())
-        return QApplicationPrivate::graphicsSystem()->createWindowSurface(q);
-    return createDefaultWindowSurface_sys();
+        surface = QApplicationPrivate::graphicsSystem()->createWindowSurface(q);
+    else
+        surface = createDefaultWindowSurface_sys();
+
+    return surface;
 }
 
 /*!
@@ -1343,11 +1396,9 @@ void QWidget::create(WId window, bool initializeWindow, bool destroyOldWindow)
 
     // a real toplevel window needs a backing store
     if (isWindow() && windowType() != Qt::Desktop) {
-        delete d->topData()->backingStore;
-        // QWidgetBackingStore will check this variable, hence it must be 0
-        d->topData()->backingStore = 0;
+        d->topData()->backingStore.destroy();
         if (hasBackingStoreSupport())
-            d->topData()->backingStore = new QWidgetBackingStore(this);
+            d->topData()->backingStore.create(this);
     }
 
     d->setModal_sys();
@@ -1392,8 +1443,10 @@ QWidget::~QWidget()
         qWarning("QWidget: %s (%s) deleted while being painted", className(), name());
 #endif
 
+#ifndef QT_NO_GESTURES
     foreach (Qt::GestureType type, d->gestureContext.keys())
         ungrabGesture(type);
+#endif
 
     // force acceptDrops false before winId is destroyed.
     d->registerDropSite(false);
@@ -1473,8 +1526,7 @@ QWidget::~QWidget()
         // the backing store will delete its window surface, which may or may
         // not have a reference to this widget that will be used later to
         // notify the window it no longer has a surface.
-        delete d->extra->topextra->backingStore;
-        d->extra->topextra->backingStore = 0;
+        d->extra->topextra->backingStore.destroy();
     }
 #endif
     if (QWidgetBackingStore *bs = d->maybeBackingStore()) {
@@ -1571,7 +1623,6 @@ void QWidgetPrivate::createTLExtra()
         QTLWExtra* x = extra->topextra = new QTLWExtra;
         x->icon = 0;
         x->iconPixmap = 0;
-        x->backingStore = 0;
         x->windowSurface = 0;
         x->sharedPainter = 0;
         x->incw = x->inch = 0;
@@ -1655,7 +1706,7 @@ void QWidgetPrivate::deleteExtra()
 #endif
         if (extra->topextra) {
             deleteTLSysExtra();
-            delete extra->topextra->backingStore;
+            extra->topextra->backingStore.destroy();
             delete extra->topextra->icon;
             delete extra->topextra->iconPixmap;
 #if defined(Q_WS_QWS) && !defined(QT_NO_QWS_MANAGER)
@@ -4778,6 +4829,11 @@ void QWidget::setLayoutDirection(Qt::LayoutDirection direction)
 {
     Q_D(QWidget);
 
+    if (direction == Qt::LayoutDirectionAuto) {
+        unsetLayoutDirection();
+        return;
+    }
+
     setAttribute(Qt::WA_SetLayoutDirection);
     d->setLayoutDirection_helper(direction);
 }
@@ -8534,9 +8590,11 @@ bool QWidget::event(QEvent *event)
 #endif // Q_WS_MAC
         break;
     }
+#ifndef QT_NO_GESTURES
     case QEvent::Gesture:
         event->ignore();
         break;
+#endif
 #ifndef QT_NO_PROPERTIES
     case QEvent::DynamicPropertyChange: {
         const QByteArray &propName = static_cast<QDynamicPropertyChangeEvent *>(event)->propertyName();
@@ -9659,46 +9717,58 @@ QWidget *QWidget::childAt(const QPoint &p) const
 
 QWidget *QWidgetPrivate::childAt_helper(const QPoint &p, bool ignoreChildrenInDestructor) const
 {
-    Q_Q(const QWidget);
+    if (children.isEmpty())
+        return 0;
+
 #ifdef Q_WS_MAC
+    Q_Q(const QWidget);
+    // Unified tool bars on the Mac require special handling since they live outside
+    // QMainWindow's geometry(). See commit: 35667fd45ada49269a5987c235fdedfc43e92bb8
     bool includeFrame = q->isWindow() && qobject_cast<const QMainWindow *>(q)
                         && static_cast<const QMainWindow *>(q)->unifiedTitleAndToolBarOnMac();
+    if (includeFrame)
+        return childAtRecursiveHelper(p, ignoreChildrenInDestructor, includeFrame);
 #endif
 
-    if (
-#ifdef Q_WS_MAC
-            !includeFrame &&
-#endif
-            !q->rect().contains(p))
+    if (!pointInsideRectAndMask(p))
         return 0;
+    return childAtRecursiveHelper(p, ignoreChildrenInDestructor);
+}
 
-    for (int i = children.size(); i > 0 ;) {
-        --i;
-        QWidget *w = qobject_cast<QWidget *>(children.at(i));
-        if (w && !w->isWindow() && !w->isHidden()
-                && (w->geometry().contains(p)
-#ifdef Q_WS_MAC
-                    || (includeFrame && w->geometry().contains(qt_mac_nativeMapFromParent(w, p)))
+QWidget *QWidgetPrivate::childAtRecursiveHelper(const QPoint &p, bool ignoreChildrenInDestructor, bool includeFrame) const
+{
+#ifndef Q_WS_MAC
+    Q_UNUSED(includeFrame);
 #endif
-               )) {
-            if (ignoreChildrenInDestructor && w->data->in_destructor)
-                continue;
-            if (w->testAttribute(Qt::WA_TransparentForMouseEvents))
-                continue;
-            QPoint childPoint = w->mapFromParent(p);
-#ifdef Q_WS_MAC
-            if (includeFrame && !w->geometry().contains(p))
-                childPoint = qt_mac_nativeMapFromParent(w, p);
-#endif
-            if (QWidget *t = w->d_func()->childAt_helper(childPoint, ignoreChildrenInDestructor))
-                return t;
-            // if WMouseNoMask is set the widget mask is ignored, if
-            // the widget has no mask then the WMouseNoMask flag has no
-            // effect
-            if (w->testAttribute(Qt::WA_MouseNoMask) || w->mask().contains(childPoint)
-                || w->mask().isEmpty())
-                return w;
+    for (int i = children.size() - 1; i >= 0; --i) {
+        QWidget *child = qobject_cast<QWidget *>(children.at(i));
+        if (!child || child->isWindow() || child->isHidden() || child->testAttribute(Qt::WA_TransparentForMouseEvents)
+            || (ignoreChildrenInDestructor && child->data->in_destructor)) {
+            continue;
         }
+
+        // Map the point 'p' from parent coordinates to child coordinates.
+        QPoint childPoint = p;
+#ifdef Q_WS_MAC
+        // 'includeFrame' is true if the child's parent is a top-level QMainWindow with an unified tool bar.
+        // An unified tool bar on the Mac lives outside QMainWindow's geometry(), so a normal
+        // QWidget::mapFromParent won't do the trick.
+        if (includeFrame && qobject_cast<QToolBar *>(child))
+            childPoint = qt_mac_nativeMapFromParent(child, p);
+        else
+#endif
+        childPoint -= child->data->crect.topLeft();
+
+        // Check if the point hits the child.
+        if (!child->d_func()->pointInsideRectAndMask(childPoint))
+            continue;
+
+        // Do the same for the child's descendants.
+        if (QWidget *w = child->d_func()->childAtRecursiveHelper(childPoint, ignoreChildrenInDestructor))
+            return w;
+
+        // We have found our target; namely the child at position 'p'.
+        return child;
     }
     return 0;
 }
@@ -11952,6 +12022,7 @@ QGraphicsProxyWidget *QWidget::graphicsProxyWidget() const
     Synonym for QList<QWidget *>.
 */
 
+#ifndef QT_NO_GESTURES
 /*!
     Subscribes the widget to a given \a gesture with specific \a flags.
 
@@ -11979,7 +12050,7 @@ void QWidget::ungrabGesture(Qt::GestureType gesture)
         manager->cleanupCachedGestures(this, gesture);
     }
 }
-
+#endif // QT_NO_GESTURES
 
 /*!
     \typedef WId
diff --git a/src/gui/kernel/qwidget.h b/src/gui/kernel/qwidget.h
index e12148b..941bd68 100644
--- a/src/gui/kernel/qwidget.h
+++ b/src/gui/kernel/qwidget.h
@@ -360,8 +360,10 @@ public:
     void setGraphicsEffect(QGraphicsEffect *effect);
 #endif //QT_NO_GRAPHICSEFFECT
 
+#ifndef QT_NO_GESTURES
     void grabGesture(Qt::GestureType type, Qt::GestureFlags flags = Qt::GestureFlags());
     void ungrabGesture(Qt::GestureType type);
+#endif
 
 public Q_SLOTS:
     void setWindowTitle(const QString &);
@@ -742,8 +744,10 @@ private:
     friend class QGraphicsProxyWidgetPrivate;
     friend class QStyleSheetStyle;
     friend struct QWidgetExceptionCleaner;
+#ifndef QT_NO_GESTURES
     friend class QGestureManager;
     friend class QWinNativePanGestureRecognizer;
+#endif // QT_NO_GESTURES
     friend class QWidgetEffectSourcePrivate;
 
 #ifdef Q_WS_MAC
diff --git a/src/gui/kernel/qwidget_mac.mm b/src/gui/kernel/qwidget_mac.mm
index f12c956..1928599 100644
--- a/src/gui/kernel/qwidget_mac.mm
+++ b/src/gui/kernel/qwidget_mac.mm
@@ -752,6 +752,7 @@ static OSWindowRef qt_mac_create_window(QWidget *, WindowClass wclass, WindowAtt
     return window;
 }
 
+#ifndef QT_NO_GESTURES
 #if MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_6
 /* We build the release package against the 10.4 SDK.
    So, to enable gestures for applications running on
@@ -768,6 +769,7 @@ enum {
     kEventParamMagnificationAmount  = 'magn'
 };
 #endif
+#endif // QT_NO_GESTURES
 
 // window events
 static EventTypeSpec window_events[] = {
@@ -1076,6 +1078,7 @@ OSStatus QWidgetPrivate::qt_window_event(EventHandlerCallRef er, EventRef event,
         handled_event = false;
         break; }
 
+#ifndef QT_NO_GESTURES
     case kEventClassGesture: {
         // First, find the widget that was under
         // the mouse when the gesture happened:
@@ -1142,6 +1145,7 @@ OSStatus QWidgetPrivate::qt_window_event(EventHandlerCallRef er, EventRef event,
 
         QApplication::sendSpontaneousEvent(widget, &qNGEvent);
     break; }
+#endif // QT_NO_GESTURES
 
     default:
         handled_event = false;
diff --git a/src/gui/kernel/qwidget_p.h b/src/gui/kernel/qwidget_p.h
index 3f494d8..4247c3a 100644
--- a/src/gui/kernel/qwidget_p.h
+++ b/src/gui/kernel/qwidget_p.h
@@ -110,13 +110,53 @@ class QWidgetItemV2;
 
 class QStyle;
 
+class Q_AUTOTEST_EXPORT QRefCountedWidgetBackingStore
+{
+public:
+    QRefCountedWidgetBackingStore();
+    ~QRefCountedWidgetBackingStore();
+
+    void create(QWidget *tlw);
+    void destroy();
+
+    void ref();
+    void deref();
+
+    inline QWidgetBackingStore* data()
+    {
+        return m_ptr;
+    }
+
+    inline QWidgetBackingStore* operator->()
+    {
+        return m_ptr;
+    }
+
+    inline QWidgetBackingStore& operator*()
+    {
+        return *m_ptr;
+    }
+
+    inline operator bool() const
+    {
+        return (0 != m_ptr);
+    }
+
+private:
+    Q_DISABLE_COPY(QRefCountedWidgetBackingStore)
+
+private:
+    QWidgetBackingStore* m_ptr;
+    int m_count;
+};
+
 struct QTLWExtra {
     // *************************** Cross-platform variables *****************************
 
     // Regular pointers (keep them together to avoid gaps on 64 bits architectures).
     QIcon *icon; // widget icon
     QPixmap *iconPixmap;
-    QWidgetBackingStore *backingStore;
+    QRefCountedWidgetBackingStore backingStore;
     QWindowSurface *windowSurface;
     QPainter *sharedPainter;
 
@@ -502,7 +542,9 @@ public:
     bool setMinimumSize_helper(int &minw, int &minh);
     bool setMaximumSize_helper(int &maxw, int &maxh);
     void setConstraints_sys();
+    bool pointInsideRectAndMask(const QPoint &) const;
     QWidget *childAt_helper(const QPoint &, bool) const;
+    QWidget *childAtRecursiveHelper(const QPoint &p, bool, bool includeFrame = false) const;
     void updateGeometry_helper(bool forceUpdate);
 
     void getLayoutItemMargins(int *left, int *top, int *right, int *bottom) const;
@@ -685,7 +727,9 @@ public:
 #ifndef QT_NO_ACTION
     QList<QAction*> actions;
 #endif
+#ifndef QT_NO_GESTURES
     QMap<Qt::GestureType, Qt::GestureFlags> gestureContext;
+#endif
 
     // Bit fields.
     uint high_attributes[4]; // the low ones are in QWidget::widget_attributes
@@ -714,8 +758,9 @@ public:
     void updateX11AcceptFocus();
 #elif defined(Q_WS_WIN) // <--------------------------------------------------------- WIN
     uint noPaintOnScreen : 1; // see qwidget_win.cpp ::paintEngine()
+#ifndef QT_NO_GESTURES
     uint nativeGesturePanEnabled : 1;
-
+#endif
     bool shouldShowMaximizeButton();
     void winUpdateIsOpaque();
     void reparentChildren();
@@ -925,11 +970,18 @@ inline void QWidgetPrivate::setSharedPainter(QPainter *painter)
     x->sharedPainter = painter;
 }
 
+inline bool QWidgetPrivate::pointInsideRectAndMask(const QPoint &p) const
+{
+    Q_Q(const QWidget);
+    return q->rect().contains(p) && (!extra || !extra->hasMask || q->testAttribute(Qt::WA_MouseNoMask)
+                                     || extra->mask.contains(p));
+}
+
 inline QWidgetBackingStore *QWidgetPrivate::maybeBackingStore() const
 {
     Q_Q(const QWidget);
     QTLWExtra *x = q->window()->d_func()->maybeTopData();
-    return x ? x->backingStore : 0;
+    return x ? x->backingStore.data() : 0;
 }
 
 QT_END_NAMESPACE
diff --git a/src/gui/kernel/qwidget_s60.cpp b/src/gui/kernel/qwidget_s60.cpp
index 02e7cb8..86b858d 100644
--- a/src/gui/kernel/qwidget_s60.cpp
+++ b/src/gui/kernel/qwidget_s60.cpp
@@ -433,6 +433,7 @@ void QWidgetPrivate::create_sys(WId window, bool /* initializeWindow */, bool de
         // Request mouse move events.
         drawableWindow->PointerFilter(EPointerFilterEnterExit
             | EPointerFilterMove | EPointerFilterDrag, 0);
+        drawableWindow->EnableVisibilityChangeEvents();
 
         if (q->isVisible() && q->testAttribute(Qt::WA_Mapped)) {
             activateSymbianWindow(control.data());
@@ -487,11 +488,8 @@ void QWidgetPrivate::show_sys()
                 && !S60->buttonGroupContainer() && !S60->statusPane()) {
 
             bool isFullscreen = q->windowState() & Qt::WindowFullScreen;
-            bool cbaRequested = q->windowFlags() & Qt::WindowSoftkeysVisibleHint;
 
-            // If the window is fullscreen and has not explicitly requested that the CBA be visible
-            // we delay the creation even more.
-            if ((!isFullscreen || cbaRequested) && !q->testAttribute(Qt::WA_DontShowOnScreen)) {
+            if (!q->testAttribute(Qt::WA_DontShowOnScreen)) {
 
                 // Create the status pane and CBA here
                 CEikAppUi *ui = static_cast<CEikAppUi *>(S60->appUi());
@@ -911,14 +909,12 @@ void QWidgetPrivate::registerDropSite(bool /* on */)
 
 void QWidgetPrivate::createTLSysExtra()
 {
-    extra->topextra->backingStore = 0;
     extra->topextra->inExpose = 0;
 }
 
 void QWidgetPrivate::deleteTLSysExtra()
 {
-    delete extra->topextra->backingStore;
-    extra->topextra->backingStore = 0;
+    extra->topextra->backingStore.destroy();
 }
 
 void QWidgetPrivate::createSysExtra()
diff --git a/src/gui/kernel/qwidget_win.cpp b/src/gui/kernel/qwidget_win.cpp
index 5482da3..a7e66bf 100644
--- a/src/gui/kernel/qwidget_win.cpp
+++ b/src/gui/kernel/qwidget_win.cpp
@@ -2075,7 +2075,7 @@ void QWidgetPrivate::registerTouchWindow()
 
 void QWidgetPrivate::winSetupGestures()
 {
-#if !defined(QT_NO_NATIVE_GESTURES)
+#if !defined(QT_NO_GESTURES) && !defined(QT_NO_NATIVE_GESTURES)
     Q_Q(QWidget);
     if (!q || !q->isVisible() || !nativeGesturePanEnabled)
         return;
diff --git a/src/gui/kernel/qwinnativepangesturerecognizer_win.cpp b/src/gui/kernel/qwinnativepangesturerecognizer_win.cpp
index 0bddbf6..780de5d 100644
--- a/src/gui/kernel/qwinnativepangesturerecognizer_win.cpp
+++ b/src/gui/kernel/qwinnativepangesturerecognizer_win.cpp
@@ -50,6 +50,8 @@
 #include "private/qapplication_p.h"
 #include "private/qwidget_p.h"
 
+#ifndef QT_NO_GESTURES
+
 QT_BEGIN_NAMESPACE
 
 #if !defined(QT_NO_NATIVE_GESTURES)
@@ -127,3 +129,5 @@ void QWinNativePanGestureRecognizer::reset(QGesture *state)
 #endif // QT_NO_NATIVE_GESTURES
 
 QT_END_NAMESPACE
+
+#endif // QT_NO_GESTURES
diff --git a/src/gui/kernel/qwinnativepangesturerecognizer_win_p.h b/src/gui/kernel/qwinnativepangesturerecognizer_win_p.h
index 146b067..64addeb 100644
--- a/src/gui/kernel/qwinnativepangesturerecognizer_win_p.h
+++ b/src/gui/kernel/qwinnativepangesturerecognizer_win_p.h
@@ -54,6 +54,7 @@
 //
 
 #include <QGestureRecognizer>
+
 #include <objbase.h>
 
 class IInkRectangle;
@@ -87,6 +88,8 @@ DECLARE_INTERFACE_(IInkTablets, IDispatch)
 	STDMETHOD(IsPacketPropertySupported)(THIS_ BSTR packetPropertyName, VARIANT_BOOL *Supported) PURE;
 };
 
+#ifndef QT_NO_GESTURES
+
 QT_BEGIN_NAMESPACE
 
 #if !defined(QT_NO_NATIVE_GESTURES)
@@ -105,4 +108,6 @@ public:
 
 QT_END_NAMESPACE
 
+#endif // QT_NO_GESTURES
+
 #endif // QWINNATIVEPANGESTURERECOGNIZER_WIN_P_H
diff --git a/src/gui/painting/painting.pri b/src/gui/painting/painting.pri
index ed8ee76..123af1c 100644
--- a/src/gui/painting/painting.pri
+++ b/src/gui/painting/painting.pri
@@ -118,12 +118,14 @@ embedded {
 } else {
     HEADERS += \
         painting/qgraphicssystem_raster_p.h \
+        painting/qgraphicssystem_runtime_p.h \
         painting/qgraphicssystemfactory_p.h \
         painting/qgraphicssystemplugin_p.h \
         painting/qwindowsurface_raster_p.h \
 
     SOURCES += \
         painting/qgraphicssystem_raster.cpp \
+        painting/qgraphicssystem_runtime.cpp \
         painting/qgraphicssystemfactory.cpp \
         painting/qgraphicssystemplugin.cpp \
         painting/qwindowsurface_raster.cpp \
diff --git a/src/gui/painting/qbackingstore.cpp b/src/gui/painting/qbackingstore.cpp
index f9cd59b..83751ed 100644
--- a/src/gui/painting/qbackingstore.cpp
+++ b/src/gui/painting/qbackingstore.cpp
@@ -909,7 +909,7 @@ void QWidgetPrivate::moveRect(const QRect &rect, int dx, int dy)
     QWidgetPrivate *pd = pw->d_func();
     QRect clipR(pd->clipRect());
 #ifdef Q_WS_QWS
-    QWidgetBackingStore *wbs = x->backingStore;
+    QWidgetBackingStore *wbs = x->backingStore.data();
     QWSWindowSurface *surface = static_cast<QWSWindowSurface*>(wbs->windowSurface);
     clipR = clipR.intersected(surface->clipRegion().translated(-toplevelOffset).boundingRect());
 #endif
@@ -939,7 +939,7 @@ void QWidgetPrivate::moveRect(const QRect &rect, int dx, int dy)
         invalidateBuffer((newRect & clipR).translated(-data.crect.topLeft()));
     } else {
 
-        QWidgetBackingStore *wbs = x->backingStore;
+        QWidgetBackingStore *wbs = x->backingStore.data();
         QRegion childExpose(newRect & clipR);
 
         if (sourceRect.isValid() && wbs->bltRect(sourceRect, dx, dy, pw))
@@ -982,7 +982,7 @@ void QWidgetPrivate::scrollRect(const QRect &rect, int dx, int dy)
     if (x->inTopLevelResize)
         return;
 
-    QWidgetBackingStore *wbs = x->backingStore;
+    QWidgetBackingStore *wbs = x->backingStore.data();
     if (!wbs)
         return;
 
diff --git a/src/gui/painting/qbrush.cpp b/src/gui/painting/qbrush.cpp
index b468b11..d3061d8 100644
--- a/src/gui/painting/qbrush.cpp
+++ b/src/gui/painting/qbrush.cpp
@@ -48,6 +48,7 @@
 #include "qline.h"
 #include "qdebug.h"
 #include <QtCore/qcoreapplication.h>
+#include "private/qstylehelper_p.h"
 
 QT_BEGIN_NAMESPACE
 
@@ -96,9 +97,11 @@ const uchar *qt_patternForBrush(int brushStyle, bool invert)
 
 QPixmap qt_pixmapForBrush(int brushStyle, bool invert)
 {
+
     QPixmap pm;
-    QString key = QLatin1String("$qt-brush$") + QString::number(brushStyle)
-                  + QString::number((int)invert);
+    QString key = QLatin1Literal("$qt-brush$")
+                  % HexString<uint>(brushStyle)
+                  % QLatin1Char(invert ? '1' : '0');
     if (!QPixmapCache::find(key, pm)) {
         pm = QBitmap::fromData(QSize(8, 8), qt_patternForBrush(brushStyle, invert),
                                QImage::Format_MonoLSB);
diff --git a/src/gui/painting/qdrawutil.cpp b/src/gui/painting/qdrawutil.cpp
index 3ce95ef..11ea6d5 100644
--- a/src/gui/painting/qdrawutil.cpp
+++ b/src/gui/painting/qdrawutil.cpp
@@ -48,6 +48,7 @@
 #include <private/qpaintengineex_p.h>
 #include <qvarlengtharray.h>
 #include <qmath.h>
+#include <private/qstylehelper_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -1018,7 +1019,9 @@ void qDrawItem(QPainter *p, Qt::GUIStyle gs,
                 ;
 #ifndef QT_NO_IMAGE_HEURISTIC_MASK
             } else {                                // color pixmap, no mask
-                QString k = QString::fromLatin1("$qt-drawitem-%1").arg(pm.cacheKey());
+                QString k = QLatin1Literal("$qt-drawitem")
+                              % HexString<qint64>(pm.cacheKey());
+
                 if (!QPixmapCache::find(k, pm)) {
                     pm = pm.createHeuristicMask();
                     pm.setMask((QBitmap&)pm);
diff --git a/src/gui/painting/qgraphicssystem_runtime.cpp b/src/gui/painting/qgraphicssystem_runtime.cpp
new file mode 100644
index 0000000..32a8578
--- /dev/null
+++ b/src/gui/painting/qgraphicssystem_runtime.cpp
@@ -0,0 +1,487 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <private/qgraphicssystem_runtime_p.h>
+#include <private/qgraphicssystem_raster_p.h>
+#include <private/qgraphicssystemfactory_p.h>
+#include <private/qapplication_p.h>
+#include <private/qwidget_p.h>
+#include <QtCore/QDebug>
+#include <QtCore/QTimer>
+#include <QtGui/QBitmap>
+
+QT_BEGIN_NAMESPACE
+
+static int qt_pixmap_serial = 0;
+
+#define READBACK(f)                                         \
+    m_graphicsSystem->decreaseMemoryUsage(memoryUsage());   \
+    f                                                       \
+    readBackInfo();                                         \
+    m_graphicsSystem->increaseMemoryUsage(memoryUsage());   \
+
+
+class QDeferredGraphicsSystemChange : public QObject
+{
+    Q_OBJECT
+
+public:
+    QDeferredGraphicsSystemChange(QRuntimeGraphicsSystem *gs, const QString& graphicsSystemName)
+    : m_graphicsSystem(gs), m_graphicsSystemName(graphicsSystemName)
+    {
+    }
+
+    void launch()
+    {
+        QTimer::singleShot(0, this, SLOT(doChange()));
+    }
+
+private slots:
+
+    void doChange()
+    {
+        m_graphicsSystem->setGraphicsSystem(m_graphicsSystemName);
+        deleteLater();
+    }
+
+private:
+
+    QRuntimeGraphicsSystem *m_graphicsSystem;
+    QString m_graphicsSystemName;
+};
+
+QRuntimePixmapData::QRuntimePixmapData(const QRuntimeGraphicsSystem *gs, PixelType type)
+        : QPixmapData(type, RuntimeClass), m_graphicsSystem(gs)
+{
+    setSerialNumber(++qt_pixmap_serial);
+}
+
+QRuntimePixmapData::~QRuntimePixmapData()
+{
+    m_graphicsSystem->removePixmapData(this);
+    delete m_data;
+}
+
+void QRuntimePixmapData::readBackInfo()
+{
+    w = m_data->width();
+    h = m_data->height();
+    d = m_data->depth();
+    is_null = m_data->isNull();
+}
+
+
+QPixmapData *QRuntimePixmapData::createCompatiblePixmapData() const
+{
+    QRuntimePixmapData *rtData = new QRuntimePixmapData(m_graphicsSystem, pixelType());
+    rtData->m_data = m_data->createCompatiblePixmapData();
+    return rtData;
+}
+
+
+void QRuntimePixmapData::resize(int width, int height)
+{
+    READBACK(
+        m_data->resize(width, height);
+    )
+}
+
+
+void QRuntimePixmapData::fromImage(const QImage &image,
+                                   Qt::ImageConversionFlags flags)
+{
+    READBACK(
+        m_data->fromImage(image, flags);
+    )
+}
+
+
+bool QRuntimePixmapData::fromFile(const QString &filename, const char *format,
+                                  Qt::ImageConversionFlags flags)
+{
+    bool success(false);
+    READBACK(
+        success = m_data->fromFile(filename, format, flags);
+    )
+    return success;
+}
+
+bool QRuntimePixmapData::fromData(const uchar *buffer, uint len, const char *format,
+                                  Qt::ImageConversionFlags flags)
+{
+    bool success(false);
+    READBACK(
+        success = m_data->fromData(buffer, len, format, flags);
+    )
+    return success;
+}
+
+
+void QRuntimePixmapData::copy(const QPixmapData *data, const QRect &rect)
+{
+    if (data->runtimeData()) {
+        READBACK(
+            m_data->copy(data->runtimeData(), rect);
+        )
+    } else {
+        READBACK(
+            m_data->copy(data, rect);
+        )
+    }
+}
+
+bool QRuntimePixmapData::scroll(int dx, int dy, const QRect &rect)
+{
+    return m_data->scroll(dx, dy, rect);
+}
+
+
+int QRuntimePixmapData::metric(QPaintDevice::PaintDeviceMetric metric) const
+{
+    return m_data->metric(metric);
+}
+
+void QRuntimePixmapData::fill(const QColor &color)
+{
+    return m_data->fill(color);
+}
+
+QBitmap QRuntimePixmapData::mask() const
+{
+    return m_data->mask();
+}
+
+void QRuntimePixmapData::setMask(const QBitmap &mask)
+{
+    READBACK(
+        m_data->setMask(mask);
+    )
+}
+
+bool QRuntimePixmapData::hasAlphaChannel() const
+{
+    return m_data->hasAlphaChannel();
+}
+
+QPixmap QRuntimePixmapData::transformed(const QTransform &matrix,
+                                        Qt::TransformationMode mode) const
+{
+    return m_data->transformed(matrix, mode);
+}
+
+void QRuntimePixmapData::setAlphaChannel(const QPixmap &alphaChannel)
+{
+    READBACK(
+        m_data->setAlphaChannel(alphaChannel);
+    )
+}
+
+QPixmap QRuntimePixmapData::alphaChannel() const
+{
+    return m_data->alphaChannel();
+}
+
+QImage QRuntimePixmapData::toImage() const
+{
+    return m_data->toImage();
+}
+
+QPaintEngine* QRuntimePixmapData::paintEngine() const
+{
+    return m_data->paintEngine();
+}
+
+QImage* QRuntimePixmapData::buffer()
+{
+    return m_data->buffer();
+}
+
+#if defined(Q_OS_SYMBIAN)
+void* QRuntimePixmapData::toNativeType(NativeType type)
+{
+    return m_data->toNativeType(type);
+}
+
+void QRuntimePixmapData::fromNativeType(void *pixmap, NativeType type)
+{
+    m_data->fromNativeType(pixmap, type);
+    readBackInfo();
+}
+#endif
+
+QPixmapData* QRuntimePixmapData::runtimeData() const
+{
+    return m_data;
+}
+
+uint QRuntimePixmapData::memoryUsage() const
+{
+    if(is_null || d == 0)
+        return 0;
+    return w * h * (d / 8);
+}
+
+
+QRuntimeWindowSurface::QRuntimeWindowSurface(const QRuntimeGraphicsSystem *gs, QWidget *window)
+    : QWindowSurface(window), m_windowSurface(0), m_pendingWindowSurface(0), m_graphicsSystem(gs)
+{
+
+}
+
+QRuntimeWindowSurface::~QRuntimeWindowSurface()
+{
+    m_graphicsSystem->removeWindowSurface(this);
+    delete m_windowSurface;
+}
+
+QPaintDevice *QRuntimeWindowSurface::paintDevice()
+{
+    return m_windowSurface->paintDevice();
+}
+
+void QRuntimeWindowSurface::flush(QWidget *widget, const QRegion &region,
+                                  const QPoint &offset)
+{
+    m_windowSurface->flush(widget, region, offset);
+
+    int destroyPolicy = m_graphicsSystem->windowSurfaceDestroyPolicy();
+    if(m_pendingWindowSurface &&
+        destroyPolicy == QRuntimeGraphicsSystem::DestroyAfterFirstFlush) {
+#ifdef QT_DEBUG
+        qDebug() << "QRuntimeWindowSurface::flush() - destroy pending window surface";
+#endif
+        delete m_pendingWindowSurface;
+        m_pendingWindowSurface = 0;
+    }
+}
+
+void QRuntimeWindowSurface::setGeometry(const QRect &rect)
+{
+    m_graphicsSystem->decreaseMemoryUsage(memoryUsage());
+    m_windowSurface->setGeometry(rect);
+    m_graphicsSystem->increaseMemoryUsage(memoryUsage());
+}
+
+bool QRuntimeWindowSurface::scroll(const QRegion &area, int dx, int dy)
+{
+    return m_windowSurface->scroll(area, dx, dy);
+}
+
+void QRuntimeWindowSurface::beginPaint(const QRegion &rgn)
+{
+    m_windowSurface->beginPaint(rgn);
+}
+
+void QRuntimeWindowSurface::endPaint(const QRegion &rgn)
+{
+    m_windowSurface->endPaint(rgn);
+}
+
+QImage* QRuntimeWindowSurface::buffer(const QWidget *widget)
+{
+    return m_windowSurface->buffer(widget);
+}
+
+QPixmap QRuntimeWindowSurface::grabWidget(const QWidget *widget, const QRect& rectangle) const
+{
+    return m_windowSurface->grabWidget(widget, rectangle);
+}
+
+QPoint QRuntimeWindowSurface::offset(const QWidget *widget) const
+{
+    return m_windowSurface->offset(widget);
+}
+
+uint QRuntimeWindowSurface::memoryUsage() const
+{
+    QPaintDevice *pdev = m_windowSurface->paintDevice();
+    if (pdev && pdev->depth() != 0)
+        return pdev->width() * pdev->height() * (pdev->depth()/8);
+
+    return 0;
+}
+
+QRuntimeGraphicsSystem::QRuntimeGraphicsSystem()
+    : m_memoryUsage(0), m_windowSurfaceDestroyPolicy(DestroyImmediately),
+	m_graphicsSystem(0), m_graphicsSystemChangeMemoryLimit(0)
+{
+    QApplicationPrivate::graphics_system_name = QLatin1String("runtime");
+    QApplicationPrivate::runtime_graphics_system = true;
+
+#ifdef Q_OS_SYMBIAN
+    m_graphicsSystemName = QLatin1String("openvg");
+    m_windowSurfaceDestroyPolicy = DestroyAfterFirstFlush;
+#else
+    m_graphicsSystemName = QLatin1String("raster");
+#endif
+
+    m_graphicsSystem = QGraphicsSystemFactory::create(m_graphicsSystemName);
+}
+
+
+QPixmapData *QRuntimeGraphicsSystem::createPixmapData(QPixmapData::PixelType type) const
+{
+    Q_ASSERT(m_graphicsSystem);
+    QPixmapData *data = m_graphicsSystem->createPixmapData(type);
+
+    QRuntimePixmapData *rtData = new QRuntimePixmapData(this, type);
+    rtData->m_data = data;
+    m_pixmapDatas << rtData;
+
+    return rtData;
+}
+
+QWindowSurface *QRuntimeGraphicsSystem::createWindowSurface(QWidget *widget) const
+{
+    Q_ASSERT(m_graphicsSystem);
+    QRuntimeWindowSurface *rtSurface = new QRuntimeWindowSurface(this, widget);
+    rtSurface->m_windowSurface = m_graphicsSystem->createWindowSurface(widget);
+    widget->setWindowSurface(rtSurface);
+    m_windowSurfaces << rtSurface;
+    increaseMemoryUsage(rtSurface->memoryUsage());
+    return rtSurface;
+}
+
+/*!
+    Sets graphics system when resource memory consumption is under /a memoryUsageLimit.
+*/
+void QRuntimeGraphicsSystem::setGraphicsSystem(const QString &name, uint memoryUsageLimit)
+{
+#ifdef QT_DEBUG
+    qDebug() << "QRuntimeGraphicsSystem::setGraphicsSystem( "<< name <<", " << memoryUsageLimit << ")";
+    qDebug() << "        current approximated graphics system memory usage " << memoryUsage() << " bytes";
+#endif
+    if (memoryUsage() >= memoryUsageLimit) {
+        m_graphicsSystemChangeMemoryLimit = memoryUsageLimit;
+        m_pendingGraphicsSystemName = name;
+    } else {
+        setGraphicsSystem(name);
+    }
+}
+
+void QRuntimeGraphicsSystem::setGraphicsSystem(const QString &name)
+{
+    if (m_graphicsSystemName == name)
+        return;
+#ifdef QT_DEBUG
+    qDebug() << "QRuntimeGraphicsSystem::setGraphicsSystem( " << name << " )";
+    qDebug() << "        current approximated graphics system memory usage "<< memoryUsage() << " bytes";
+#endif
+    delete m_graphicsSystem;
+    m_graphicsSystem = QGraphicsSystemFactory::create(name);
+    m_graphicsSystemName = name;
+
+    Q_ASSERT(m_graphicsSystem);
+
+    m_graphicsSystemChangeMemoryLimit = 0;
+    m_pendingGraphicsSystemName = QString();
+
+    for (int i = 0; i < m_pixmapDatas.size(); ++i) {
+        QRuntimePixmapData *proxy = m_pixmapDatas.at(i);
+        QPixmapData *newData = m_graphicsSystem->createPixmapData(proxy->m_data->pixelType());
+        // ### TODO Optimize. Openvg and s60raster graphics systems could switch internal ARGB32_PRE QImage buffers.
+        newData->fromImage(proxy->m_data->toImage(), Qt::AutoColor | Qt::OrderedAlphaDither);
+        delete proxy->m_data;
+        proxy->m_data = newData;
+        proxy->readBackInfo();
+    }
+
+    for (int i = 0; i < m_windowSurfaces.size(); ++i) {
+        QRuntimeWindowSurface *proxy = m_windowSurfaces.at(i);
+        QWidget *widget = proxy->m_windowSurface->window();
+
+        if(m_windowSurfaceDestroyPolicy == DestroyImmediately) {
+            delete proxy->m_windowSurface;
+            proxy->m_pendingWindowSurface = 0;
+        } else {
+            proxy->m_pendingWindowSurface = proxy->m_windowSurface;
+        }
+
+        proxy->m_windowSurface = m_graphicsSystem->createWindowSurface(widget);
+        qt_widget_private(widget)->invalidateBuffer(widget->rect());
+    }
+}
+
+void QRuntimeGraphicsSystem::removePixmapData(QRuntimePixmapData *pixmapData) const
+{
+    int index = m_pixmapDatas.lastIndexOf(pixmapData);
+    m_pixmapDatas.removeAt(index);
+    decreaseMemoryUsage(pixmapData->memoryUsage(), true);
+}
+
+void QRuntimeGraphicsSystem::removeWindowSurface(QRuntimeWindowSurface *windowSurface) const
+{
+    int index = m_windowSurfaces.lastIndexOf(windowSurface);
+    m_windowSurfaces.removeAt(index);
+    decreaseMemoryUsage(windowSurface->memoryUsage(), true);
+}
+
+void QRuntimeGraphicsSystem::increaseMemoryUsage(uint amount) const
+{
+    m_memoryUsage += amount;
+
+    if (m_graphicsSystemChangeMemoryLimit &&
+        m_memoryUsage < m_graphicsSystemChangeMemoryLimit) {
+
+        QRuntimeGraphicsSystem *gs = const_cast<QRuntimeGraphicsSystem*>(this);
+        QDeferredGraphicsSystemChange *deferredChange =
+                    new QDeferredGraphicsSystemChange(gs, m_pendingGraphicsSystemName);
+        deferredChange->launch();
+    }
+}
+
+void QRuntimeGraphicsSystem::decreaseMemoryUsage(uint amount, bool persistent) const
+{
+    m_memoryUsage -= amount;
+
+    if (persistent && m_graphicsSystemChangeMemoryLimit &&
+        m_memoryUsage < m_graphicsSystemChangeMemoryLimit) {
+
+        QRuntimeGraphicsSystem *gs = const_cast<QRuntimeGraphicsSystem*>(this);
+        QDeferredGraphicsSystemChange *deferredChange =
+                    new QDeferredGraphicsSystemChange(gs, m_pendingGraphicsSystemName);
+        deferredChange->launch();
+    }
+}
+
+#include "qgraphicssystem_runtime.moc"
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qgraphicssystem_runtime_p.h b/src/gui/painting/qgraphicssystem_runtime_p.h
new file mode 100644
index 0000000..445f83d
--- /dev/null
+++ b/src/gui/painting/qgraphicssystem_runtime_p.h
@@ -0,0 +1,197 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QGRAPHICSSYSTEM_RUNTIME_P_H
+#define QGRAPHICSSYSTEM_RUNTIME_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qgraphicssystem_p.h"
+
+#include <private/qpixmapdata_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QRuntimeGraphicsSystem;
+
+class QRuntimePixmapData : public QPixmapData {
+public:
+    QRuntimePixmapData(const QRuntimeGraphicsSystem *gs, PixelType type);
+    ~QRuntimePixmapData();
+
+    virtual QPixmapData *createCompatiblePixmapData() const;
+    virtual void resize(int width, int height);
+    virtual void fromImage(const QImage &image,
+                           Qt::ImageConversionFlags flags);
+
+    virtual bool fromFile(const QString &filename, const char *format,
+                          Qt::ImageConversionFlags flags);
+    virtual bool fromData(const uchar *buffer, uint len, const char *format,
+                          Qt::ImageConversionFlags flags);
+
+    virtual void copy(const QPixmapData *data, const QRect &rect);
+    virtual bool scroll(int dx, int dy, const QRect &rect);
+
+    virtual int metric(QPaintDevice::PaintDeviceMetric metric) const;
+    virtual void fill(const QColor &color);
+    virtual QBitmap mask() const;
+    virtual void setMask(const QBitmap &mask);
+    virtual bool hasAlphaChannel() const;
+    virtual QPixmap transformed(const QTransform &matrix,
+                                Qt::TransformationMode mode) const;
+    virtual void setAlphaChannel(const QPixmap &alphaChannel);
+    virtual QPixmap alphaChannel() const;
+    virtual QImage toImage() const;
+    virtual QPaintEngine *paintEngine() const;
+
+    virtual QImage *buffer();
+
+    void readBackInfo();
+
+    QPixmapData *m_data;
+
+#if defined(Q_OS_SYMBIAN)
+    void* toNativeType(NativeType type);
+    void fromNativeType(void* pixmap, NativeType type);
+#endif
+
+    virtual QPixmapData *runtimeData() const;
+
+    virtual uint memoryUsage() const;
+
+private:
+    const QRuntimeGraphicsSystem *m_graphicsSystem;
+
+};
+
+class QRuntimeWindowSurface : public QWindowSurface {
+public:
+    QRuntimeWindowSurface(const QRuntimeGraphicsSystem *gs, QWidget *window);
+    ~QRuntimeWindowSurface();
+
+    virtual QPaintDevice *paintDevice();
+    virtual void flush(QWidget *widget, const QRegion &region,
+                       const QPoint &offset);
+    virtual void setGeometry(const QRect &rect);
+
+    virtual bool scroll(const QRegion &area, int dx, int dy);
+
+    virtual void beginPaint(const QRegion &);
+    virtual void endPaint(const QRegion &);
+
+    virtual QImage* buffer(const QWidget *widget);
+    virtual QPixmap grabWidget(const QWidget *widget, const QRect& rectangle = QRect()) const;
+
+    virtual QPoint offset(const QWidget *widget) const;
+
+    virtual uint memoryUsage() const;
+
+    QWindowSurface *m_windowSurface;
+    QWindowSurface *m_pendingWindowSurface;
+
+private:
+    const QRuntimeGraphicsSystem *m_graphicsSystem;
+};
+
+class QRuntimeGraphicsSystem : public QGraphicsSystem
+{
+public:
+
+    enum WindowSurfaceDestroyPolicy
+    {
+        DestroyImmediately,
+        DestroyAfterFirstFlush
+    };
+
+public:
+    QRuntimeGraphicsSystem();
+
+    QPixmapData *createPixmapData(QPixmapData::PixelType type) const;
+    QWindowSurface *createWindowSurface(QWidget *widget) const;
+
+    void removePixmapData(QRuntimePixmapData *pixmapData) const;
+    void removeWindowSurface(QRuntimeWindowSurface *windowSurface) const;
+
+    void setGraphicsSystem(const QString &name, uint memoryUsageLimit);
+    void setGraphicsSystem(const QString &name);
+    QString graphicsSystemName() const { return m_graphicsSystemName; }
+
+    void setWindowSurfaceDestroyPolicy(WindowSurfaceDestroyPolicy policy)
+    {
+        m_windowSurfaceDestroyPolicy = policy;
+    }
+
+    int windowSurfaceDestroyPolicy() const { return m_windowSurfaceDestroyPolicy; }
+
+    int memoryUsage() const { return m_memoryUsage; }
+
+private:
+
+    void increaseMemoryUsage(uint amount) const;
+    void decreaseMemoryUsage(uint amount, bool persistent = false) const;
+
+private:
+    mutable uint m_memoryUsage;
+    int m_windowSurfaceDestroyPolicy;
+    QGraphicsSystem *m_graphicsSystem;
+    mutable QList<QRuntimePixmapData *> m_pixmapDatas;
+    mutable QList<QRuntimeWindowSurface *> m_windowSurfaces;
+    QString m_graphicsSystemName;
+
+    uint m_graphicsSystemChangeMemoryLimit;
+    QString m_pendingGraphicsSystemName;
+
+    friend class QRuntimePixmapData;
+    friend class QRuntimeWindowSurface;
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/gui/painting/qgraphicssystemfactory.cpp b/src/gui/painting/qgraphicssystemfactory.cpp
index 3c09894..ee6fbd8 100644
--- a/src/gui/painting/qgraphicssystemfactory.cpp
+++ b/src/gui/painting/qgraphicssystemfactory.cpp
@@ -46,6 +46,7 @@
 
 #include "qapplication.h"
 #include "qgraphicssystem_raster_p.h"
+#include "qgraphicssystem_runtime_p.h"
 #include "qdebug.h"
 
 QT_BEGIN_NAMESPACE
@@ -68,6 +69,10 @@ QGraphicsSystem *QGraphicsSystemFactory::create(const QString& key)
     if (system.isEmpty()) {
         system = QLatin1String("openvg");
     }
+#elif defined (QT_GRAPHICSSYSTEM_RUNTIME)
+    if (system.isEmpty()) {
+        system = QLatin1String("runtime");
+    }
 #elif defined (QT_GRAPHICSSYSTEM_RASTER) && !defined(Q_WS_WIN) && !defined(Q_OS_SYMBIAN)
     if (system.isEmpty()) {
         system = QLatin1String("raster");
@@ -76,6 +81,8 @@ QGraphicsSystem *QGraphicsSystemFactory::create(const QString& key)
 
     if (system == QLatin1String("raster"))
         return new QRasterGraphicsSystem;
+    else if (system == QLatin1String("runtime"))
+        return new QRuntimeGraphicsSystem;
     else if (system.isEmpty() || system == QLatin1String("native"))
         return 0;
 
diff --git a/src/gui/painting/qpaintengine_raster.cpp b/src/gui/painting/qpaintengine_raster.cpp
index 6f395f6..08e14fb 100644
--- a/src/gui/painting/qpaintengine_raster.cpp
+++ b/src/gui/painting/qpaintengine_raster.cpp
@@ -68,6 +68,7 @@
 //   #include <private/qrasterizer_p.h>
 #include <private/qimage_p.h>
 #include <private/qstatictext_p.h>
+#include "qmemrotate_p.h"
 
 #include "qpaintengine_raster_p.h"
 //   #include "qbezier_p.h"
@@ -441,8 +442,9 @@ bool QRasterPaintEngine::begin(QPaintDevice *device)
 
     if (device->devType() == QInternal::Pixmap) {
         QPixmap *pixmap = static_cast<QPixmap *>(device);
-        if (pixmap->data->classId() == QPixmapData::RasterClass)
-            d->device = pixmap->data->buffer();
+        QPixmapData *pd = pixmap->pixmapData();
+        if (pd->classId() == QPixmapData::RasterClass)
+            d->device = pd->buffer();
     } else {
         d->device = device;
     }
@@ -2358,8 +2360,9 @@ void QRasterPaintEngine::drawPixmap(const QPointF &pos, const QPixmap &pixmap)
     qDebug() << " - QRasterPaintEngine::drawPixmap(), pos=" << pos << " pixmap=" << pixmap.size() << "depth=" << pixmap.depth();
 #endif
 
-    if (pixmap.data->classId() == QPixmapData::RasterClass) {
-        const QImage &image = static_cast<QRasterPixmapData *>(pixmap.data.data())->image;
+    QPixmapData *pd = pixmap.pixmapData();
+    if (pd->classId() == QPixmapData::RasterClass) {
+        const QImage &image = static_cast<QRasterPixmapData *>(pd)->image;
         if (image.depth() == 1) {
             Q_D(QRasterPaintEngine);
             QRasterPaintEngineState *s = state();
@@ -2398,8 +2401,9 @@ void QRasterPaintEngine::drawPixmap(const QRectF &r, const QPixmap &pixmap, cons
     qDebug() << " - QRasterPaintEngine::drawPixmap(), r=" << r << " sr=" << sr << " pixmap=" << pixmap.size() << "depth=" << pixmap.depth();
 #endif
 
-    if (pixmap.data->classId() == QPixmapData::RasterClass) {
-        const QImage &image = static_cast<QRasterPixmapData *>(pixmap.data.data())->image;
+    QPixmapData* pd = pixmap.pixmapData();
+    if (pd->classId() == QPixmapData::RasterClass) {
+        const QImage &image = static_cast<QRasterPixmapData *>(pd)->image;
         if (image.depth() == 1) {
             Q_D(QRasterPaintEngine);
             QRasterPaintEngineState *s = state();
@@ -2518,6 +2522,58 @@ QRectF qt_mapRect_non_normalizing(const QRectF &r, const QTransform &t)
     return QRectF(r.topLeft() * t, r.bottomRight() * t);
 }
 
+namespace {
+    enum RotationType {
+        Rotation90,
+        Rotation180,
+        Rotation270,
+        NoRotation
+    };
+
+    inline RotationType qRotationType(const QTransform &transform)
+    {
+        QTransform::TransformationType type = transform.type();
+
+        if (type > QTransform::TxRotate)
+            return NoRotation;
+
+        if (type == QTransform::TxRotate && qFuzzyIsNull(transform.m11()) && qFuzzyCompare(transform.m12(), qreal(-1))
+            && qFuzzyCompare(transform.m21(), qreal(1)) && qFuzzyIsNull(transform.m22()))
+            return Rotation90;
+
+        if (type == QTransform::TxScale && qFuzzyCompare(transform.m11(), qreal(-1)) && qFuzzyIsNull(transform.m12())
+            && qFuzzyIsNull(transform.m21()) && qFuzzyCompare(transform.m22(), qreal(-1)))
+            return Rotation180;
+
+        if (type == QTransform::TxRotate && qFuzzyIsNull(transform.m11()) && qFuzzyCompare(transform.m12(), qreal(1))
+            && qFuzzyCompare(transform.m21(), qreal(-1)) && qFuzzyIsNull(transform.m22()))
+            return Rotation270;
+
+        return NoRotation;
+    }
+
+    template <typename T> void memRotate(RotationType type, const T *srcBase, int w, int h, int sbpl, T *dstBase, int dbpl)
+    {
+        switch (type) {
+        case Rotation90:
+            qt_memrotate90(srcBase, w, h, sbpl, dstBase, dbpl);
+            break;
+        case Rotation180:
+            qt_memrotate180(srcBase, w, h, sbpl, dstBase, dbpl);
+            break;
+        case Rotation270:
+            qt_memrotate270(srcBase, w, h, sbpl, dstBase, dbpl);
+            break;
+        case NoRotation:
+            break;
+        }
+    }
+
+    inline bool isPixelAligned(const QRectF &rect) {
+        return QRectF(rect.toRect()) == rect;
+    }
+}
+
 /*!
     \reimp
 */
@@ -2579,6 +2635,58 @@ void QRasterPaintEngine::drawImage(const QRectF &r, const QImage &img, const QRe
 
     const QClipData *clip = d->clip();
 
+    if (s->matrix.type() > QTransform::TxTranslate
+        && !stretch_sr
+        && (!clip || clip->hasRectClip)
+        && s->intOpacity == 256
+        && (d->rasterBuffer->compositionMode == QPainter::CompositionMode_SourceOver
+            || d->rasterBuffer->compositionMode == QPainter::CompositionMode_Source)
+        && d->rasterBuffer->format == img.format()
+        && (d->rasterBuffer->format == QImage::Format_RGB16
+            || d->rasterBuffer->format == QImage::Format_RGB32
+            || (d->rasterBuffer->format == QImage::Format_ARGB32_Premultiplied
+                && d->rasterBuffer->compositionMode == QPainter::CompositionMode_Source)))
+    {
+        RotationType rotationType = qRotationType(s->matrix);
+
+        if (rotationType != NoRotation && img.rect().contains(sr.toAlignedRect())) {
+            QRectF transformedTargetRect = s->matrix.mapRect(r);
+
+            if ((!(s->renderHints & QPainter::SmoothPixmapTransform) && !(s->renderHints & QPainter::Antialiasing))
+                || (isPixelAligned(transformedTargetRect) && isPixelAligned(sr)))
+            {
+                QRect clippedTransformedTargetRect = transformedTargetRect.toRect().intersected(clip ? clip->clipRect : d->deviceRect);
+                if (clippedTransformedTargetRect.isNull())
+                    return;
+
+                QRectF clippedTargetRect = s->matrix.inverted().mapRect(QRectF(clippedTransformedTargetRect));
+
+                QRect clippedSourceRect
+                    = QRectF(sr.x() + clippedTargetRect.x() - r.x(), sr.y() + clippedTargetRect.y() - r.y(),
+                            clippedTargetRect.width(), clippedTargetRect.height()).toRect();
+
+                uint dbpl = d->rasterBuffer->bytesPerLine();
+                uint sbpl = img.bytesPerLine();
+
+                uchar *dst = d->rasterBuffer->buffer();
+                uint bpp = img.depth() >> 3;
+
+                const uchar *srcBase = img.bits() + clippedSourceRect.y() * sbpl + clippedSourceRect.x() * bpp;
+                uchar *dstBase = dst + clippedTransformedTargetRect.y() * dbpl + clippedTransformedTargetRect.x() * bpp;
+
+                uint cw = clippedSourceRect.width();
+                uint ch = clippedSourceRect.height();
+
+                if (d->rasterBuffer->format == QImage::Format_RGB16)
+                    memRotate(rotationType, (quint16 *)srcBase, cw, ch, sbpl, (quint16 *)dstBase, dbpl);
+                else
+                    memRotate(rotationType, (quint32 *)srcBase, cw, ch, sbpl, (quint32 *)dstBase, dbpl);
+
+                return;
+            }
+        }
+    }
+
     if (s->matrix.type() > QTransform::TxTranslate || stretch_sr) {
 
         if (s->flags.fast_images) {
@@ -2703,8 +2811,9 @@ void QRasterPaintEngine::drawTiledPixmap(const QRectF &r, const QPixmap &pixmap,
 
     QImage image;
 
-    if (pixmap.data->classId() == QPixmapData::RasterClass) {
-        image = static_cast<QRasterPixmapData *>(pixmap.data.data())->image;
+    QPixmapData *pd = pixmap.pixmapData();
+    if (pd->classId() == QPixmapData::RasterClass) {
+        image = static_cast<QRasterPixmapData *>(pd)->image;
     } else {
         image = pixmap.toImage();
     }
diff --git a/src/gui/painting/qpaintengine_x11.cpp b/src/gui/painting/qpaintengine_x11.cpp
index aef8b80..b8ad9b3 100644
--- a/src/gui/painting/qpaintengine_x11.cpp
+++ b/src/gui/painting/qpaintengine_x11.cpp
@@ -79,6 +79,8 @@
 #include <private/qtessellator_p.h>
 #endif
 
+#include <private/qstylehelper_p.h>
+
 QT_BEGIN_NAMESPACE
 
 extern Drawable qt_x11Handle(const QPaintDevice *pd);
@@ -224,7 +226,10 @@ static const uchar base_dither_matrix[DITHER_SIZE][DITHER_SIZE] = {
 static QPixmap qt_patternForAlpha(uchar alpha, int screen)
 {
     QPixmap pm;
-    QString key = QLatin1String("$qt-alpha-brush$") + QString::number(alpha) + QString::number(screen);
+    QString key = QLatin1Literal("$qt-alpha-brush$")
+                  % HexString<uchar>(alpha)
+                  % HexString<int>(screen);
+
     if (!QPixmapCache::find(key, pm)) {
         // #### why not use a mono image here????
         QImage pattern(DITHER_SIZE, DITHER_SIZE, QImage::Format_ARGB32);
diff --git a/src/gui/painting/qpainter.cpp b/src/gui/painting/qpainter.cpp
index 657229a..e8c4599 100644
--- a/src/gui/painting/qpainter.cpp
+++ b/src/gui/painting/qpainter.cpp
@@ -72,6 +72,7 @@
 #include <private/qmath_p.h>
 #include <qstatictext.h>
 #include <private/qstatictext_p.h>
+#include <private/qstylehelper_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -1563,7 +1564,6 @@ void QPainter::initFrom(const QWidget *widget)
         d->engine->setDirty(QPaintEngine::DirtyBrush);
         d->engine->setDirty(QPaintEngine::DirtyFont);
     }
-    d->state->layoutDirection = widget->layoutDirection();
 }
 
 
@@ -1873,7 +1873,7 @@ bool QPainter::begin(QPaintDevice *pd)
         QWidget *widget = static_cast<QWidget *>(d->original_device);
         initFrom(widget);
     } else {
-        d->state->layoutDirection = QApplication::layoutDirection();
+        d->state->layoutDirection = Qt::LayoutDirectionAuto;
         // make sure we have a font compatible with the paintdevice
         d->state->deviceFont = d->state->font = QFont(d->state->deviceFont, device());
     }
@@ -5855,14 +5855,24 @@ void QPainter::drawStaticText(const QPointF &topLeftPosition, const QStaticText
         return;
     }
 
+    if (d->extended->type() == QPaintEngine::OpenGL2 && !staticText_d->untransformedCoordinates) {
+        staticText_d->untransformedCoordinates = true;
+        staticText_d->needsRelayout = true;
+    } else if (d->extended->type() != QPaintEngine::OpenGL2 && staticText_d->untransformedCoordinates) {
+        staticText_d->untransformedCoordinates = false;
+        staticText_d->needsRelayout = true;
+    }
+
     // Don't recalculate entire layout because of translation, rather add the dx and dy
     // into the position to move each text item the correct distance.
-    QPointF transformedPosition = topLeftPosition * d->state->matrix;
-    QTransform matrix = d->state->matrix;
+    QPointF transformedPosition = topLeftPosition;
+    if (!staticText_d->untransformedCoordinates)
+        transformedPosition = transformedPosition * d->state->matrix;
+    QTransform oldMatrix;
 
     // The translation has been applied to transformedPosition. Remove translation
     // component from matrix.
-    if (d->state->matrix.isTranslating()) {
+    if (d->state->matrix.isTranslating() && !staticText_d->untransformedCoordinates) {
         qreal m11 = d->state->matrix.m11();
         qreal m12 = d->state->matrix.m12();
         qreal m13 = d->state->matrix.m13();
@@ -5871,6 +5881,7 @@ void QPainter::drawStaticText(const QPointF &topLeftPosition, const QStaticText
         qreal m23 = d->state->matrix.m23();
         qreal m33 = d->state->matrix.m33();
 
+        oldMatrix = d->state->matrix;
         d->state->matrix.setMatrix(m11, m12, m13,
                                    m21, m22, m23,
                                    0.0, 0.0, m33);
@@ -5879,7 +5890,7 @@ void QPainter::drawStaticText(const QPointF &topLeftPosition, const QStaticText
     // If the transform is not identical to the text transform,
     // we have to relayout the text (for other transformations than plain translation)
     bool staticTextNeedsReinit = staticText_d->needsRelayout;
-    if (staticText_d->matrix != d->state->matrix) {
+    if (!staticText_d->untransformedCoordinates && staticText_d->matrix != d->state->matrix) {
         staticText_d->matrix = d->state->matrix;
         staticTextNeedsReinit = true;
     }
@@ -5918,8 +5929,8 @@ void QPainter::drawStaticText(const QPointF &topLeftPosition, const QStaticText
     if (currentColor != oldPen.color())
         setPen(oldPen);
 
-    if (matrix.isTranslating())
-        d->state->matrix = matrix;
+    if (!staticText_d->untransformedCoordinates && oldMatrix.isTranslating())
+        d->state->matrix = oldMatrix;
 }
 
 /*!
@@ -5937,6 +5948,23 @@ void QPainter::drawText(const QPointF &p, const QString &str, int tf, int justif
     if (!d->engine || str.isEmpty() || pen().style() == Qt::NoPen)
         return;
 
+    if (tf & Qt::TextBypassShaping) {
+        // Skip harfbuzz complex shaping, shape using glyph advances only
+        int len = str.length();
+        int numGlyphs = len;
+        QVarLengthGlyphLayoutArray glyphs(len);
+        QFontEngine *fontEngine = d->state->font.d->engineForScript(QUnicodeTables::Common);
+        if (!fontEngine->stringToCMap(str.data(), len, &glyphs, &numGlyphs, 0)) {
+            glyphs.resize(numGlyphs);
+            if (!fontEngine->stringToCMap(str.data(), len, &glyphs, &numGlyphs, 0))
+                Q_ASSERT_X(false, Q_FUNC_INFO, "stringToCMap shouldn't fail twice");
+        }
+
+        QTextItemInt gf(glyphs, &d->state->font, fontEngine);
+        drawTextItem(p, gf);
+        return;
+    }
+
     QStackTextEngine engine(str, d->state->font);
     engine.option.setTextDirection(d->state->layoutDirection);
     if (tf & (Qt::TextForceLeftToRight|Qt::TextForceRightToLeft)) {
@@ -6217,10 +6245,9 @@ static QPixmap generateWavyPixmap(qreal maxRadius, const QPen &pen)
 {
     const qreal radiusBase = qMax(qreal(1), maxRadius);
 
-    QString key = QLatin1String("WaveUnderline-");
-    key += pen.color().name();
-    key += QLatin1Char('-');
-    key += QString::number(radiusBase);
+    QString key = QLatin1Literal("WaveUnderline-")
+                  % pen.color().name()
+                  % HexString<qreal>(radiusBase);
 
     QPixmap pixmap;
     if (QPixmapCache::find(key, pixmap))
@@ -8028,7 +8055,10 @@ start_lengthVariant:
     Sets the layout direction used by the painter when drawing text,
     to the specified \a direction.
 
-    \sa layoutDirection(), drawText(), {QPainter#Settings}{Settings}
+    The default is Qt::LayoutDirectionAuto, which will implicitly determine the
+    direction from the text drawn.
+
+    \sa QTextOption::setTextDirection(), layoutDirection(), drawText(), {QPainter#Settings}{Settings}
 */
 void QPainter::setLayoutDirection(Qt::LayoutDirection direction)
 {
@@ -8040,12 +8070,12 @@ void QPainter::setLayoutDirection(Qt::LayoutDirection direction)
 /*!
     Returns the layout direction used by the painter when drawing text.
 
-    \sa setLayoutDirection(), drawText(), {QPainter#Settings}{Settings}
+    \sa QTextOption::textDirection(), setLayoutDirection(), drawText(), {QPainter#Settings}{Settings}
 */
 Qt::LayoutDirection QPainter::layoutDirection() const
 {
     Q_D(const QPainter);
-    return d->state ? d->state->layoutDirection : Qt::LeftToRight;
+    return d->state ? d->state->layoutDirection : Qt::LayoutDirectionAuto;
 }
 
 QPainterState::QPainterState(const QPainterState *s)
diff --git a/src/gui/painting/qtransform.cpp b/src/gui/painting/qtransform.cpp
index 423cce9..47b7758 100644
--- a/src/gui/painting/qtransform.cpp
+++ b/src/gui/painting/qtransform.cpp
@@ -1626,7 +1626,7 @@ static QPainterPath mapProjective(const QTransform &transform, const QPainterPat
 QPainterPath QTransform::map(const QPainterPath &path) const
 {
     TransformationType t = inline_type();
-    if (t == TxNone || path.isEmpty())
+    if (t == TxNone || path.elementCount() == 0)
         return path;
 
     if (t >= TxProject)
diff --git a/src/gui/painting/qwindowsurface.cpp b/src/gui/painting/qwindowsurface.cpp
index e18ea3f..02a8b80 100644
--- a/src/gui/painting/qwindowsurface.cpp
+++ b/src/gui/painting/qwindowsurface.cpp
@@ -43,6 +43,7 @@
 #include <qwidget.h>
 #include <private/qwidget_p.h>
 #include <private/qbackingstore_p.h>
+#include <private/qapplication_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -116,8 +117,10 @@ public:
 QWindowSurface::QWindowSurface(QWidget *window)
     : d_ptr(new QWindowSurfacePrivate(window))
 {
-    if (window)
-        window->setWindowSurface(this);
+    if (!QApplicationPrivate::runtime_graphics_system) {
+        if(window)
+            window->setWindowSurface(this);
+    }
 }
 
 /*!
diff --git a/src/gui/painting/qwindowsurface_s60.cpp b/src/gui/painting/qwindowsurface_s60.cpp
index b25dce5..477bd93 100644
--- a/src/gui/painting/qwindowsurface_s60.cpp
+++ b/src/gui/painting/qwindowsurface_s60.cpp
@@ -43,10 +43,15 @@
 
 #include <QtGui/qpaintdevice.h>
 #include <private/qwidget_p.h>
-#include "qwindowsurface_s60_p.h"
+#include <private/qwindowsurface_s60_p.h>
 #include <private/qpixmap_s60_p.h>
 #include <private/qt_s60_p.h>
-#include "private/qdrawhelper_p.h"
+#include <private/qapplication_p.h>
+#include <private/qdrawhelper_p.h>
+
+#ifdef QT_GRAPHICSSYSTEM_RUNTIME
+#include <private/qgraphicssystem_runtime_p.h>
+#endif
 
 QT_BEGIN_NAMESPACE
 
@@ -79,13 +84,35 @@ QS60WindowSurface::QS60WindowSurface(QWidget* widget)
 
     setStaticContentsSupport(true);
 }
+
 QS60WindowSurface::~QS60WindowSurface()
 {
+#if defined(QT_GRAPHICSSYSTEM_RUNTIME) && defined(Q_SYMBIAN_SUPPORTS_SURFACES)
+    if(QApplicationPrivate::runtime_graphics_system) {
+        QRuntimeGraphicsSystem *runtimeGraphicsSystem =
+                static_cast<QRuntimeGraphicsSystem*>(QApplicationPrivate::graphics_system);
+        if(runtimeGraphicsSystem->graphicsSystemName() == QLatin1String("openvg")) {
+
+            // Graphics system has been switched from raster to openvg.
+            // Issue empty redraw to clear the UI surface
+
+            QWidget *w = window();
+            RWindow *const window = static_cast<RWindow *>(w->winId()->DrawableWindow());
+            window->BeginRedraw();
+            window->EndRedraw();
+        }
+    }
+#endif
+
     delete d_ptr;
 }
 
 void QS60WindowSurface::beginPaint(const QRegion &rgn)
 {
+#ifdef Q_SYMBIAN_SUPPORTS_SURFACES
+    S60->wsSession().Finish();
+#endif
+
     if (!qt_widget_private(window())->isOpaque) {
         QS60PixmapData *pixmapData = static_cast<QS60PixmapData *>(d_ptr->device.data_ptr().data());
         pixmapData->beginDataAccess();
diff --git a/src/gui/s60framework/qs60mainappui.cpp b/src/gui/s60framework/qs60mainappui.cpp
index feffc9f..ce13de8 100644
--- a/src/gui/s60framework/qs60mainappui.cpp
+++ b/src/gui/s60framework/qs60mainappui.cpp
@@ -64,6 +64,9 @@
 #include <private/qt_s60_p.h>
 #include <qdebug.h>
 
+//Animated wallpapers in Qt applications are not supported.
+const TInt KAknDisableAnimationBackground = 0x02000000;
+
 QT_BEGIN_NAMESPACE
 
 /*!
@@ -115,6 +118,11 @@ void QS60MainAppUi::ConstructL()
     TInt flags = CAknAppUi::EAknEnableSkin
                  | CAknAppUi::ENoScreenFurniture
                  | CAknAppUi::ENonStandardResourceFile;
+    // After 5th Edition S60, native side supports animated wallpapers.
+	// However, there is no support for that feature on Qt side, so indicate to
+	// native UI framework that this application will not support background animations.
+    if (QSysInfo::s60Version() > QSysInfo::SV_S60_5_0)
+        flags |= KAknDisableAnimationBackground;
     BaseConstructL(flags);
 }
 
diff --git a/src/gui/statemachine/qguistatemachine.cpp b/src/gui/statemachine/qguistatemachine.cpp
index 63ad94e..2b4c9c2 100644
--- a/src/gui/statemachine/qguistatemachine.cpp
+++ b/src/gui/statemachine/qguistatemachine.cpp
@@ -474,9 +474,11 @@ static QEvent *cloneEvent(QEvent *e)
     case QEvent::TouchEnd:
         return new QTouchEvent(*static_cast<QTouchEvent*>(e));
 
+#ifndef QT_NO_GESTURES
     case QEvent::NativeGesture:
         Q_ASSERT_X(false, "cloneEvent()", "not implemented");
         break;
+#endif
 
     case QEvent::RequestSoftwareInputPanel:
     case QEvent::CloseSoftwareInputPanel:
diff --git a/src/gui/styles/qgtkpainter.cpp b/src/gui/styles/qgtkpainter.cpp
index 79c53e9..0217a39 100644
--- a/src/gui/styles/qgtkpainter.cpp
+++ b/src/gui/styles/qgtkpainter.cpp
@@ -241,8 +241,10 @@ void QGtkPainter::paintBoxGap(GtkWidget *gtkWidget, const gchar* part,
     if (rect.height() > maxHeight && (gap_side == GTK_POS_TOP || gap_side == GTK_POS_BOTTOM))
         rect.setHeight(2 * border + 1);
 
-    QString gapExtras = QString(QLS("s %0 w %1 g %2")).arg(gap_side).arg(width).arg(x);
-    QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size(), gtkWidget) + gapExtras;
+    QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size(), gtkWidget)
+                         % HexString<uchar>(gap_side)
+                         % HexString<gint>(width)
+                         % HexString<gint>(x);
 
     if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
         DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_box_gap (style,
@@ -307,7 +309,7 @@ void QGtkPainter::paintBox(GtkWidget *gtkWidget, const gchar* part,
         rect.setHeight(2 * border + 1);
 
     QString pixmapName = uniqueName(QLS(part), state, shadow,
-                                    rect.size(), gtkWidget) + pmKey;
+                                    rect.size(), gtkWidget) % pmKey;
 
     if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
         DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_box (style,
@@ -357,9 +359,11 @@ void QGtkPainter::paintHline(GtkWidget *gtkWidget, const gchar* part,
         return;
 
     QPixmap cache;
-    QString hLineExtras = QString(QLS("%0 %1 %2")).arg(x1).arg(x2).arg(y);
     QString pixmapName = uniqueName(QLS(part), state, GTK_SHADOW_NONE, rect.size(), gtkWidget)
-                         + hLineExtras + pmKey;
+                         % HexString<int>(x1)
+                         % HexString<int>(x2)
+                         % HexString<int>(y)
+                         % pmKey;
     if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
         DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_hline (style,
                                          pixmap,
@@ -384,9 +388,12 @@ void QGtkPainter::paintVline(GtkWidget *gtkWidget, const gchar* part,
         return;
 
     QPixmap cache;
-    QString vLineExtras = QString(QLS("%0 %1 %2")).arg(y1).arg(y2).arg(x);
-    QString pixmapName = uniqueName(QLS(part), state, GTK_SHADOW_NONE, rect.size(),
-                                    gtkWidget) + vLineExtras +pmKey;
+    QString pixmapName = uniqueName(QLS(part), state, GTK_SHADOW_NONE, rect.size(), gtkWidget)
+                        % HexString<int>(y1)
+                        % HexString<int>(y2)
+                        % HexString<int>(x)
+                        % pmKey;
+
     if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
         DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_vline (style,
                                          pixmap,
@@ -412,8 +419,10 @@ void QGtkPainter::paintExpander(GtkWidget *gtkWidget,
         return;
 
     QPixmap cache;
-    QString pixmapName = uniqueName(QLS(part), state, GTK_SHADOW_NONE, rect.size(),
-                                    gtkWidget) + QString::number(expander_state) + pmKey;
+    QString pixmapName = uniqueName(QLS(part), state, GTK_SHADOW_NONE, rect.size(), gtkWidget)
+                         % HexString<uchar>(expander_state)
+                         % pmKey;
+
     if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
         DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_expander (style, pixmap,
                                             state, NULL,
@@ -436,7 +445,7 @@ void QGtkPainter::paintFocus(GtkWidget *gtkWidget, const gchar* part,
         return;
 
     QPixmap cache;
-    QString pixmapName = uniqueName(QLS(part), state, GTK_SHADOW_NONE, rect.size(), gtkWidget) + pmKey;
+    QString pixmapName = uniqueName(QLS(part), state, GTK_SHADOW_NONE, rect.size(), gtkWidget) % pmKey;
     if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
         DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_focus (style, pixmap, state, NULL,
                                          gtkWidget,
@@ -461,7 +470,7 @@ void QGtkPainter::paintResizeGrip(GtkWidget *gtkWidget, const gchar* part,
         return;
 
     QPixmap cache;
-    QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size(), gtkWidget) + pmKey;
+    QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size(), gtkWidget) % pmKey;
     if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
         DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_resize_grip (style, pixmap, state,
                                                NULL, gtkWidget,
@@ -486,8 +495,9 @@ void QGtkPainter::paintArrow(GtkWidget *gtkWidget, const gchar* part,
         return;
 
     QPixmap cache;
-    QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size()) +
-                         QString::number((int)arrow_type) + pmKey;
+    QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size())
+                         % HexString<uchar>(arrow_type)
+                         % pmKey;
 
     GdkRectangle gtkCliprect = {0, 0, rect.width(), rect.height()};
     int xOffset = m_cliprect.isValid() ? arrowrect.x() - m_cliprect.x() : 0;
@@ -518,7 +528,8 @@ void QGtkPainter::paintHandle(GtkWidget *gtkWidget, const gchar* part, const QRe
 
     QPixmap cache;
     QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size())
-                         + QString::number(orientation);
+                         % HexString<uchar>(orientation);
+
     if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
         DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_handle (style,
                                           pixmap,
@@ -546,7 +557,7 @@ void QGtkPainter::paintSlider(GtkWidget *gtkWidget, const gchar* part, const QRe
         return;
 
     QPixmap cache;
-    QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size(), gtkWidget) + pmKey;
+    QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size(), gtkWidget) % pmKey;
     if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
         DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_slider (style,
                                           pixmap,
@@ -577,7 +588,7 @@ void QGtkPainter::paintShadow(GtkWidget *gtkWidget, const gchar* part,
 
     QRect r = rect;
     QPixmap cache;
-    QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size()) + pmKey;
+    QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size()) % pmKey;
     if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
         DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_shadow(style, pixmap, state, shadow, NULL,
                                          gtkWidget, part, 0, 0, rect.width(), rect.height()));
@@ -596,7 +607,7 @@ void QGtkPainter::paintFlatBox(GtkWidget *gtkWidget, const gchar* part,
         return;
     QRect r = rect;
     QPixmap cache;
-    QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size()) + pmKey;
+    QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size()) % pmKey;
     if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
         DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_flat_box (style,
                                             pixmap,
@@ -623,8 +634,8 @@ void QGtkPainter::paintExtention(GtkWidget *gtkWidget,
 
     QRect r = rect;
     QPixmap cache;
-    QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size(), gtkWidget);
-    pixmapName += QString::number(gap_pos);
+    QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size(), gtkWidget)
+                         % HexString<uchar>(gap_pos);
 
     if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
         DRAW_TO_CACHE(QGtkStylePrivate::gtk_paint_extension (style, pixmap, state, shadow,
diff --git a/src/gui/styles/qgtkstyle.cpp b/src/gui/styles/qgtkstyle.cpp
index 9d6dc9a..b59a033 100644
--- a/src/gui/styles/qgtkstyle.cpp
+++ b/src/gui/styles/qgtkstyle.cpp
@@ -67,6 +67,7 @@
 #include <QtGui/QRadioButton>
 #include <QtGui/QCheckBox>
 #include <QtGui/QTreeView>
+#include <QtGui/QStyledItemDelegate>
 #include <qpixmapcache.h>
 #undef signals // Collides with GTK stymbols
 #include <private/qgtkpainter_p.h>
@@ -692,7 +693,7 @@ void QGtkStyle::drawPrimitive(PrimitiveElement element,
         // thin rectangular images
         const int pmSize = 64;
         const int border = proxy()->pixelMetric(PM_DefaultFrameWidth, option, widget);
-        const QString pmKey = QString(QLS("windowframe %0")).arg(option->state);
+        const QString pmKey = QLatin1Literal("windowframe") % HexString<uint>(option->state);
 
         QPixmap pixmap;
         QRect pmRect(QPoint(0,0), QSize(pmSize, pmSize));
@@ -817,24 +818,49 @@ void QGtkStyle::drawPrimitive(PrimitiveElement element,
                                      option->state & State_Open ? openState : closedState , gtkTreeView->style);
         }
         break;
+
+    case PE_PanelItemViewRow:
+        // This primitive is only used to draw selection behind selected expander arrows.
+        // We try not to decorate the tree branch background unless you inherit from StyledItemDelegate
+        // The reason for this is that a lot of code that relies on custom item delegates will look odd having
+        // a gradient on the branch but a flat shaded color on the item itself.
+        QCommonStyle::drawPrimitive(element, option, painter, widget);
+        if (!option->state & State_Selected) {
+            break;
+        } else {
+            if (const QAbstractItemView *view = qobject_cast<const QAbstractItemView*>(widget)) {
+                if (!qobject_cast<QStyledItemDelegate*>(view->itemDelegate()))
+                    break;
+            }
+        } // fall through
+
     case PE_PanelItemViewItem:
         if (const QStyleOptionViewItemV4 *vopt = qstyleoption_cast<const QStyleOptionViewItemV4 *>(option)) {
-            if (vopt->state & State_Selected) {
-                QLinearGradient gradient;
-                gradient.setStart(option->rect.left(), option->rect.top());
-                gradient.setFinalStop(option->rect.left(), option->rect.bottom());
-                gradient.setColorAt(0, option->palette.highlight().color().lighter(105));
-                gradient.setColorAt(0.5, option->palette.highlight().color().lighter(101));
-                gradient.setColorAt(0.51, option->palette.highlight().color().darker(101));
-                gradient.setColorAt(1, option->palette.highlight().color().darker(105));
-                painter->fillRect(option->rect, gradient);
-            } else {
-                if (vopt->backgroundBrush.style() != Qt::NoBrush) {
-                    QPointF oldBO = painter->brushOrigin();
-                    painter->setBrushOrigin(vopt->rect.topLeft());
-                    painter->fillRect(vopt->rect, vopt->backgroundBrush);
-                    painter->setBrushOrigin(oldBO);
+            if (vopt->backgroundBrush.style() != Qt::NoBrush) {
+                QPointF oldBO = painter->brushOrigin();
+                painter->setBrushOrigin(vopt->rect.topLeft());
+                painter->fillRect(vopt->rect, vopt->backgroundBrush);
+                painter->setBrushOrigin(oldBO);
+                if (!(option->state & State_Selected))
+                    break;
+            }
+            if (GtkWidget *gtkTreeView = d->gtkWidget("GtkTreeView")) {
+                const char *detail = "cell_even_ruled";
+                if (vopt && vopt->features & QStyleOptionViewItemV2::Alternate)
+                    detail = "cell_odd_ruled";
+                bool isActive = option->state & State_Active;
+                QString key;
+                if (isActive ) {
+                    // Required for active/non-active window appearance
+                    key = QLS("a");
+                    GTK_WIDGET_SET_FLAGS(gtkTreeView, GTK_HAS_FOCUS);
                 }
+                gtkPainter.paintFlatBox(gtkTreeView, detail, option->rect,
+                                        option->state & State_Selected ? GTK_STATE_SELECTED :
+                                        option->state & State_Enabled ? GTK_STATE_NORMAL : GTK_STATE_INSENSITIVE,
+                                        GTK_SHADOW_OUT, gtkTreeView->style, key);
+                if (isActive )
+                    GTK_WIDGET_UNSET_FLAGS(gtkTreeView, GTK_HAS_FOCUS);
             }
         }
         break;
diff --git a/src/gui/styles/qplastiquestyle.cpp b/src/gui/styles/qplastiquestyle.cpp
index c8711f6..20d9bd9 100644
--- a/src/gui/styles/qplastiquestyle.cpp
+++ b/src/gui/styles/qplastiquestyle.cpp
@@ -488,7 +488,9 @@ static void qBrushSetAlphaF(QBrush *brush, qreal alpha)
         // Modify the texture - ridiculously expensive.
         QPixmap texture = brush->texture();
         QPixmap pixmap;
-        QString name = QString::fromLatin1("qbrushtexture-alpha-%1-%2").arg(alpha).arg(texture.cacheKey());
+        QString name = QLatin1Literal("qbrushtexture-alpha")
+                       % HexString<qreal>(alpha)
+                       % HexString<qint64>(texture.cacheKey());
         if (!QPixmapCache::find(name, pixmap)) {
             QImage image = texture.toImage();
             QRgb *rgb = reinterpret_cast<QRgb *>(image.bits());
@@ -549,7 +551,10 @@ static QBrush qBrushLight(QBrush brush, int light)
         // Modify the texture - ridiculously expensive.
         QPixmap texture = brush.texture();
         QPixmap pixmap;
-        QString name = QString::fromLatin1("qbrushtexture-light-%1-%2").arg(light).arg(texture.cacheKey());
+        QString name = QLatin1Literal("qbrushtexture-light")
+                       % HexString<int>(light)
+                       % HexString<qint64>(texture.cacheKey());
+
         if (!QPixmapCache::find(name, pixmap)) {
             QImage image = texture.toImage();
             QRgb *rgb = reinterpret_cast<QRgb *>(image.bits());
@@ -608,7 +613,10 @@ static QBrush qBrushDark(QBrush brush, int dark)
         // Modify the texture - ridiculously expensive.
         QPixmap texture = brush.texture();
         QPixmap pixmap;
-        QString name = QString::fromLatin1("qbrushtexture-dark-%1-%2").arg(dark).arg(brush.texture().cacheKey());
+        QString name = QLatin1Literal("qbrushtexture-dark")
+                       % HexString<int>(dark)
+                       % HexString<qint64>(texture.cacheKey());
+
         if (!QPixmapCache::find(name, pixmap)) {
             QImage image = texture.toImage();
             QRgb *rgb = reinterpret_cast<QRgb *>(image.bits());
@@ -732,8 +740,12 @@ static QColor mergedColors(const QColor &colorA, const QColor &colorB, int facto
 static void qt_plastique_draw_gradient(QPainter *painter, const QRect &rect, const QColor &gradientStart,
                                        const QColor &gradientStop)
 {
-    QString gradientName;
-    gradientName.sprintf("%dx%d-%x-%x", rect.width(), rect.height(), gradientStart.rgba(), gradientStop.rgba());
+    QString gradientName = QLatin1Literal("qplastique-g")
+                   % HexString<int>(rect.width())
+                   % HexString<int>(rect.height())
+                   % HexString<QRgb>(gradientStart.rgba())
+                   % HexString<QRgb>(gradientStop.rgba());
+
     QPixmap cache;
     QPainter *p = painter;
     QRect r = rect;
@@ -1092,14 +1104,6 @@ void QPlastiqueStyle::drawPrimitive(PrimitiveElement element, const QStyleOption
     Q_ASSERT(option);
 
     QColor borderColor = option->palette.background().color().darker(178);
-    QColor gradientStartColor = option->palette.button().color().lighter(104);
-    QColor gradientStopColor = option->palette.button().color().darker(105);
-    QColor highlightedGradientStartColor = option->palette.button().color().lighter(101);
-    QColor highlightedGradientStopColor = mergedColors(option->palette.button().color(), option->palette.highlight().color(), 85);
-    QColor highlightedBaseGradientStartColor = option->palette.base().color();
-    QColor highlightedBaseGradientStopColor = mergedColors(option->palette.base().color().darker(105), option->palette.highlight().color(), 70);
-    QColor highlightedDarkInnerBorderColor = mergedColors(option->palette.button().color(), option->palette.highlight().color(), 35);
-    QColor highlightedLightInnerBorderColor = mergedColors(option->palette.button().color(), option->palette.highlight().color(), 58);
     QColor alphaCornerColor;
     if (widget) {
         // ### backgroundrole/foregroundrole should be part of the style option
@@ -1107,13 +1111,7 @@ void QPlastiqueStyle::drawPrimitive(PrimitiveElement element, const QStyleOption
     } else {
         alphaCornerColor = mergedColors(option->palette.background().color(), borderColor);
     }
-    QColor alphaInnerColor = mergedColors(highlightedLightInnerBorderColor, gradientStartColor);
-    QColor alphaInnerColorNoHover = mergedColors(borderColor, gradientStartColor);
     QColor alphaTextColor = mergedColors(option->palette.background().color(), option->palette.text().color());
-    QColor alphaLightTextColor = mergedColors(option->palette.background().color().lighter(250), option->palette.text().color().lighter(250));
-    QColor lightShadow = option->palette.button().color().lighter(105);
-    QColor shadowGradientStartColor = option->palette.button().color().darker(115);
-    QColor shadow = shadowGradientStartColor;
 
     switch (element) {
     case PE_IndicatorButtonDropDown:
@@ -2057,7 +2055,6 @@ void QPlastiqueStyle::drawControl(ControlElement element, const QStyleOption *op
             bool reverse = (tab->direction == Qt::RightToLeft);
 
             int lowerTop = selected ? 0 : 3; // to make the selected tab bigger than the rest
-            QRect adjustedRect;
             bool atEnd = (tab->position == QStyleOptionTab::End) || onlyTab;
             bool atBeginning = ((tab->position == QStyleOptionTab::Beginning) || onlyTab)
                                && !leftCornerWidget;
diff --git a/src/gui/styles/qstylesheetstyle.cpp b/src/gui/styles/qstylesheetstyle.cpp
index 515b6c7..43fa4b9 100644
--- a/src/gui/styles/qstylesheetstyle.cpp
+++ b/src/gui/styles/qstylesheetstyle.cpp
@@ -3190,7 +3190,7 @@ void QStyleSheetStyle::drawComplexControl(ComplexControl cc, const QStyleOptionC
                     subRule2.drawRule(p, r);
                 }
 
-                handleSubRule.drawRule(p, grooveSubRule.boxRect(hr, Margin));
+                handleSubRule.drawRule(p, handleSubRule.boxRect(hr, Margin));
             }
 
             if (slider->subControls & SC_SliderTickmarks) {
diff --git a/src/gui/styles/qwindowsstyle.cpp b/src/gui/styles/qwindowsstyle.cpp
index 0314c6f..579dd0b 100644
--- a/src/gui/styles/qwindowsstyle.cpp
+++ b/src/gui/styles/qwindowsstyle.cpp
@@ -1388,8 +1388,9 @@ void QWindowsStyle::drawPrimitive(PrimitiveElement pe, const QStyleOption *opt,
             QRect r = opt->rect;
             int size = qMin(r.height(), r.width());
             QPixmap pixmap;
-            QString pixmapName = QStyleHelper::uniqueName(QLatin1String("$qt_ia-") + QLatin1String(metaObject()->className()), opt, QSize(size, size))
-                  + QLatin1Char('-') + QString::number(pe);                               
+            QString pixmapName = QStyleHelper::uniqueName(QLatin1String("$qt_ia-")
+                                                          % QLatin1String(metaObject()->className()), opt, QSize(size, size))
+                                 % HexString<uint>(pe);
             if (!QPixmapCache::find(pixmapName, pixmap)) {
                 int border = size/5;
                 int sqsize = 2*(size/2);
diff --git a/src/gui/text/qfontdatabase_s60.cpp b/src/gui/text/qfontdatabase_s60.cpp
index 489b70b..943df7f 100644
--- a/src/gui/text/qfontdatabase_s60.cpp
+++ b/src/gui/text/qfontdatabase_s60.cpp
@@ -49,12 +49,12 @@
 #include <private/qt_s60_p.h>
 #include "qendian.h"
 #include <private/qcore_symbian_p.h>
-#if defined(QT_NO_FREETYPE)
+#ifdef QT_NO_FREETYPE
 #include <openfont.h>
 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
 #include <graphics/openfontrasterizer.h> // COpenFontRasterizer has moved to a new header file
 #endif // SYMBIAN_ENABLE_SPLIT_HEADERS
-#endif
+#endif // QT_NO_FREETYPE
 
 QT_BEGIN_NAMESPACE
 
@@ -91,7 +91,7 @@ QFileInfoList alternativeFilePaths(const QString &path, const QStringList &nameF
     return result;
 }
 
-#if defined(QT_NO_FREETYPE)
+#ifdef QT_NO_FREETYPE
 class QSymbianFontDatabaseExtrasImplementation : public QSymbianFontDatabaseExtras
 {
 public:
@@ -100,16 +100,41 @@ public:
 
     const QSymbianTypeFaceExtras *extras(const QString &typeface, bool bold, bool italic) const;
 
+#ifndef Q_SYMBIAN_HAS_FONTTABLE_API
+    struct CFontFromFontStoreReleaser {
+        static inline void cleanup(CFont *font)
+        {
+            if (!font)
+                return;
+            const QSymbianFontDatabaseExtrasImplementation *dbExtras =
+                    static_cast<const QSymbianFontDatabaseExtrasImplementation*>(privateDb()->symbianExtras);
+            dbExtras->m_store->ReleaseFont(font);
+        }
+    };
+#endif // !Q_SYMBIAN_HAS_FONTTABLE_API
+
+    struct CFontFromScreenDeviceReleaser {
+        static inline void cleanup(CFont *font)
+        {
+            if (!font)
+                return;
+            QS60Data::screenDevice()->ReleaseFont(font);
+        }
+    };
+
 private:
+#ifndef Q_SYMBIAN_HAS_FONTTABLE_API
     RHeap* m_heap;
     CFontStore *m_store;
     COpenFontRasterizer *m_rasterizer;
     mutable QList<const QSymbianTypeFaceExtras *> m_extras;
+#endif // !Q_SYMBIAN_HAS_FONTTABLE_API
     mutable QHash<QString, const QSymbianTypeFaceExtras *> m_extrasHash;
 };
 
 QSymbianFontDatabaseExtrasImplementation::QSymbianFontDatabaseExtrasImplementation()
 {
+#ifndef Q_SYMBIAN_HAS_FONTTABLE_API
     QStringList filters;
     filters.append(QLatin1String("*.ttf"));
     filters.append(QLatin1String("*.ccc"));
@@ -131,10 +156,14 @@ QSymbianFontDatabaseExtrasImplementation::QSymbianFontDatabaseExtrasImplementati
         TPtrC fontFilePtr(qt_QString2TPtrC(fontFile));
         QT_TRAP_THROWING(m_store->AddFileL(fontFilePtr));
     }
+#endif // !Q_SYMBIAN_HAS_FONTTABLE_API
 }
 
 QSymbianFontDatabaseExtrasImplementation::~QSymbianFontDatabaseExtrasImplementation()
 {
+#ifdef Q_SYMBIAN_HAS_FONTTABLE_API
+    qDeleteAll(m_extrasHash);
+#else // Q_SYMBIAN_HAS_FONTTABLE_API
     typedef QList<const QSymbianTypeFaceExtras *>::iterator iterator;
     for (iterator p = m_extras.begin(); p != m_extras.end(); ++p) {
         m_store->ReleaseFont((*p)->fontOwner());
@@ -143,6 +172,7 @@ QSymbianFontDatabaseExtrasImplementation::~QSymbianFontDatabaseExtrasImplementat
 
     delete m_store;
     m_heap->Close();
+#endif // Q_SYMBIAN_HAS_FONTTABLE_API
 }
 
 #ifndef FNTSTORE_H_INLINES_SUPPORT_FMM
@@ -167,26 +197,37 @@ const QSymbianTypeFaceExtras *QSymbianFontDatabaseExtrasImplementation::extras(c
 {
     const QString searchKey = typeface + QString::number(int(bold)) + QString::number(int(italic));
     if (!m_extrasHash.contains(searchKey)) {
-        CFont* font = NULL;
         TFontSpec searchSpec(qt_QString2TPtrC(typeface), 1);
         if (bold)
             searchSpec.iFontStyle.SetStrokeWeight(EStrokeWeightBold);
         if (italic)
             searchSpec.iFontStyle.SetPosture(EPostureItalic);
+
+        CFont* font = NULL;
+#ifdef Q_SYMBIAN_HAS_FONTTABLE_API
+        const TInt err = QS60Data::screenDevice()->GetNearestFontToDesignHeightInPixels(font, searchSpec);
+        Q_ASSERT(err == KErrNone && font);
+        QScopedPointer<CFont, CFontFromScreenDeviceReleaser> sFont(font);
+        QSymbianTypeFaceExtras *extras = new QSymbianTypeFaceExtras(font);
+        sFont.take();
+        m_extrasHash.insert(searchKey, extras);
+#else // Q_SYMBIAN_HAS_FONTTABLE_API
         const TInt err = m_store->GetNearestFontToDesignHeightInPixels(font, searchSpec);
         Q_ASSERT(err == KErrNone && font);
         const CBitmapFont *bitmapFont = static_cast<CBitmapFont*>(font);
         COpenFont *openFont =
 #ifdef FNTSTORE_H_INLINES_SUPPORT_FMM
-            bitmapFont->openFont();
-#else
+            bitmapFont->OpenFont();
+#else // FNTSTORE_H_INLINES_SUPPORT_FMM
             OpenFontFromBitmapFont(bitmapFont);
 #endif // FNTSTORE_H_INLINES_SUPPORT_FMM
         const TOpenFontFaceAttrib* const attrib = openFont->FaceAttrib();
         const QString foundKey =
                 QString((const QChar*)attrib->FullName().Ptr(), attrib->FullName().Length());
         if (!m_extrasHash.contains(foundKey)) {
+            QScopedPointer<CFont, CFontFromFontStoreReleaser> sFont(font);
             QSymbianTypeFaceExtras *extras = new QSymbianTypeFaceExtras(font, openFont);
+            sFont.take();
             m_extras.append(extras);
             m_extrasHash.insert(searchKey, extras);
             m_extrasHash.insert(foundKey, extras);
@@ -194,10 +235,11 @@ const QSymbianTypeFaceExtras *QSymbianFontDatabaseExtrasImplementation::extras(c
             m_store->ReleaseFont(font);
             m_extrasHash.insert(searchKey, m_extrasHash.value(foundKey));
         }
+#endif // Q_SYMBIAN_HAS_FONTTABLE_API
     }
     return m_extrasHash.value(searchKey);
 }
-#else
+#else // QT_NO_FREETYPE
 class QFontEngineFTS60 : public QFontEngineFT
 {
 public:
@@ -209,7 +251,7 @@ QFontEngineFTS60::QFontEngineFTS60(const QFontDef &fd)
 {
     default_hint_style = HintFull;
 }
-#endif // defined(QT_NO_FREETYPE)
+#endif // QT_NO_FREETYPE
 
 /*
  QFontEngineS60::pixelsToPoints, QFontEngineS60::pointsToPixels, QFontEngineMultiS60::QFontEngineMultiS60
@@ -261,12 +303,12 @@ static void initializeDb()
     if(!db || db->count)
         return;
 
-#if defined(QT_NO_FREETYPE)
+#ifdef QT_NO_FREETYPE
     if (!db->symbianExtras)
         db->symbianExtras = new QSymbianFontDatabaseExtrasImplementation;
 
     QSymbianFbsHeapLock lock(QSymbianFbsHeapLock::Unlock);
-    
+
     const int numTypeFaces = QS60Data::screenDevice()->NumTypefaces();
     const QSymbianFontDatabaseExtrasImplementation *dbExtras =
             static_cast<const QSymbianFontDatabaseExtrasImplementation*>(db->symbianExtras);
@@ -278,6 +320,7 @@ static void initializeDb()
         TFontSpec fontSpec(typefaceSupport.iTypeface.iName, 11);
         if (QS60Data::screenDevice()->GetNearestFontInPixels(font, fontSpec) != KErrNone)
             continue;
+        QScopedPointer<CFont, QSymbianFontDatabaseExtrasImplementation::CFontFromScreenDeviceReleaser> sFont(font);
         if (font->TypeUid() == KCFbsFontUid) {
             TOpenFontFaceAttrib faceAttrib;
             const CFbsFont *cfbsFont = static_cast<const CFbsFont *>(font);
@@ -318,14 +361,13 @@ static void initializeDb()
 
             fontAdded = true;
         }
-        QS60Data::screenDevice()->ReleaseFont(font);
     }
 
     Q_ASSERT(fontAdded);
     
-	lock.relock();
+    lock.relock();
 
-#else // defined(QT_NO_FREETYPE)
+#else // QT_NO_FREETYPE
     QDir dir(QDesktopServices::storageLocation(QDesktopServices::FontsLocation));
     dir.setNameFilters(QStringList() << QLatin1String("*.ttf")
                        << QLatin1String("*.ttc") << QLatin1String("*.pfa")
@@ -334,7 +376,7 @@ static void initializeDb()
         const QByteArray file = QFile::encodeName(dir.absoluteFilePath(dir[i]));
         db->addTTFile(file);
     }
-#endif // defined(QT_NO_FREETYPE)
+#endif // QT_NO_FREETYPE
 }
 
 static inline void load(const QString &family = QString(), int script = -1)
@@ -416,13 +458,13 @@ QFontEngine *QFontDatabase::findFont(int script, const QFontPrivate *, const QFo
         const QString fontFamily = desc.family->name;
         QFontDef request = req;
         request.family = fontFamily;
-#if defined(QT_NO_FREETYPE)
+#ifdef QT_NO_FREETYPE
         const QSymbianFontDatabaseExtrasImplementation *dbExtras =
                 static_cast<const QSymbianFontDatabaseExtrasImplementation*>(db->symbianExtras);
         const QSymbianTypeFaceExtras *typeFaceExtras =
                 dbExtras->extras(fontFamily, request.weight > QFont::Normal, request.style != QFont::StyleNormal);
         fe = new QFontEngineS60(request, typeFaceExtras);
-#else
+#else // QT_NO_FREETYPE
         QFontEngine::FaceId faceId;
         const QtFontFamily * const reqQtFontFamily = db->family(fontFamily);
         faceId.filename = reqQtFontFamily->fontFilename;
@@ -433,7 +475,7 @@ QFontEngine *QFontDatabase::findFont(int script, const QFontPrivate *, const QFo
             fe = fte;
         else
             delete fte;
-#endif
+#endif // QT_NO_FREETYPE
 
         Q_ASSERT(fe);
         if (script == QUnicodeTables::Common
diff --git a/src/gui/text/qfontengine_ft.cpp b/src/gui/text/qfontengine_ft.cpp
index 449dffd..9056012 100644
--- a/src/gui/text/qfontengine_ft.cpp
+++ b/src/gui/text/qfontengine_ft.cpp
@@ -58,6 +58,7 @@
 #include <ft2build.h>
 #include FT_FREETYPE_H
 #include FT_OUTLINE_H
+#include FT_SYNTHESIS_H
 #include FT_TRUETYPE_TABLES_H
 #include FT_TYPE1_TABLES_H
 #include FT_GLYPH_H
@@ -617,6 +618,7 @@ QFontEngineFT::QFontEngineFT(const QFontDef &fd)
     cache_cost = 100;
     kerning_pairs_loaded = false;
     transform = false;
+    embolden = false;
     antialias = true;
     freetype = 0;
     default_load_flags = FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH;
@@ -679,10 +681,7 @@ bool QFontEngineFT::init(FaceId faceId, bool antialias, GlyphFormat format)
 
     FT_Face face = lockFace();
 
-    //underline metrics
     if (FT_IS_SCALABLE(face)) {
-        line_thickness =  QFixed::fromFixed(FT_MulFix(face->underline_thickness, face->size->metrics.y_scale));
-        underline_position = QFixed::fromFixed(-FT_MulFix(face->underline_position, face->size->metrics.y_scale));
         bool fake_oblique = (fontDef.style != QFont::StyleNormal) && !(face->style_flags & FT_STYLE_FLAG_ITALIC);
         if (fake_oblique)
             matrix.xy = 0x10000*3/10;
@@ -690,6 +689,12 @@ bool QFontEngineFT::init(FaceId faceId, bool antialias, GlyphFormat format)
         freetype->matrix = matrix;
         if (fake_oblique)
             transform = true;
+        // fake bold
+        if ((fontDef.weight == QFont::Bold) && !(face->style_flags & FT_STYLE_FLAG_BOLD))
+            embolden = true;
+        // underline metrics
+        line_thickness =  QFixed::fromFixed(FT_MulFix(face->underline_thickness, face->size->metrics.y_scale));
+        underline_position = QFixed::fromFixed(-FT_MulFix(face->underline_position, face->size->metrics.y_scale));
     } else {
         // copied from QFontEngineQPF
         // ad hoc algorithm
@@ -789,6 +794,7 @@ QFontEngineFT::Glyph *QFontEngineFT::loadGlyphMetrics(QGlyphSet *set, uint glyph
     }
 
     FT_GlyphSlot slot = face->glyph;
+    if (embolden) FT_GlyphSlot_Embolden(slot);
     int left  = slot->metrics.horiBearingX;
     int right = slot->metrics.horiBearingX + slot->metrics.width;
     int top    = slot->metrics.horiBearingY;
@@ -934,6 +940,7 @@ QFontEngineFT::Glyph *QFontEngineFT::loadGlyph(QGlyphSet *set, uint glyph, Glyph
         return 0;
 
     FT_GlyphSlot slot = face->glyph;
+    if (embolden) FT_GlyphSlot_Embolden(slot);
     FT_Library library = qt_getFreetype();
 
     info.xOff = TRUNC(ROUND(slot->advance.x));
@@ -1209,6 +1216,8 @@ int QFontEngineFT::synthesized() const
     int s = 0;
     if ((fontDef.style != QFont::StyleNormal) && !(freetype->face->style_flags & FT_STYLE_FLAG_ITALIC))
         s = SynthesizedItalic;
+    if ((fontDef.weight == QFont::Bold) && !(freetype->face->style_flags & FT_STYLE_FLAG_BOLD))
+        s |= SynthesizedBold;
     if (fontDef.stretch != 100 && FT_IS_SCALABLE(freetype->face))
         s |= SynthesizedStretch;
     return s;
diff --git a/src/gui/text/qfontengine_ft_p.h b/src/gui/text/qfontengine_ft_p.h
index 12b7da8..2f05a8b 100644
--- a/src/gui/text/qfontengine_ft_p.h
+++ b/src/gui/text/qfontengine_ft_p.h
@@ -304,6 +304,7 @@ protected:
 
     bool antialias;
     bool transform;
+    bool embolden;
     SubpixelAntialiasingType subpixelType;
     int lcdFilterType;
     bool canUploadGlyphsToServer;
diff --git a/src/gui/text/qfontengine_s60.cpp b/src/gui/text/qfontengine_s60.cpp
index 93f02ff..925b3bf 100644
--- a/src/gui/text/qfontengine_s60.cpp
+++ b/src/gui/text/qfontengine_s60.cpp
@@ -50,21 +50,73 @@
 #include <e32std.h>
 #include <eikenv.h>
 #include <gdi.h>
+#if defined(Q_SYMBIAN_HAS_FONTTABLE_API) || defined(Q_SYMBIAN_HAS_GLYPHOUTLINE_API)
+#include <graphics/gdi/gdiplatapi.h>
+#endif // Q_SYMBIAN_HAS_FONTTABLE_API || Q_SYMBIAN_HAS_GLYPHOUTLINE_API
 
 QT_BEGIN_NAMESPACE
 
-QSymbianTypeFaceExtras::QSymbianTypeFaceExtras(CFont* fontOwner, COpenFont *font)
-    : m_font(font)
-    , m_cmap(0)
+#ifdef Q_SYMBIAN_HAS_FONTTABLE_API
+QSymbianTypeFaceExtras::QSymbianTypeFaceExtras(CFont* cFont, COpenFont *openFont)
+    : m_cFont(cFont)
     , m_symbolCMap(false)
-    , m_fontOwner(fontOwner)
+{
+    Q_UNUSED(openFont)
+}
+
+QSymbianTypeFaceExtras::~QSymbianTypeFaceExtras()
+{
+    QS60Data::screenDevice()->ReleaseFont(m_cFont);
+}
+
+QByteArray QSymbianTypeFaceExtras::getSfntTable(uint tag) const
+{
+    RFontTable fontTable;
+    if (fontTable.Open(*m_cFont, tag) != KErrNone)
+        return QByteArray();
+    const QByteArray byteArray(reinterpret_cast<const char *>
+            (fontTable.TableContent()),fontTable.TableLength());
+    fontTable.Close();
+    return byteArray;
+}
+
+bool QSymbianTypeFaceExtras::getSfntTableData(uint tag, uchar *buffer, uint *length) const
+{
+    RFontTable fontTable;
+    if (fontTable.Open(*m_cFont, tag) != KErrNone)
+        return false;
+
+    bool result = true;
+    const TInt tableByteLength = fontTable.TableLength();
+
+    if (*length > 0 && *length < tableByteLength) {
+        result = false; // Caller did not allocate enough memory
+    } else {
+        *length = tableByteLength;
+        if (buffer)
+            qMemCopy(buffer, fontTable.TableContent(), tableByteLength);
+    }
+
+    fontTable.Close();
+    return result;
+}
+
+#else // Q_SYMBIAN_HAS_FONTTABLE_API
+QSymbianTypeFaceExtras::QSymbianTypeFaceExtras(CFont* cFont, COpenFont *openFont)
+    : m_cFont(cFont)
+    , m_symbolCMap(false)
+    , m_openFont(openFont)
 {
     TAny *trueTypeExtension = NULL;
-    m_font->ExtendedInterface(KUidOpenFontTrueTypeExtension, trueTypeExtension);
+    m_openFont->ExtendedInterface(KUidOpenFontTrueTypeExtension, trueTypeExtension);
     m_trueTypeExtension = static_cast<MOpenFontTrueTypeExtension*>(trueTypeExtension);
     Q_ASSERT(m_trueTypeExtension);
 }
 
+QSymbianTypeFaceExtras::~QSymbianTypeFaceExtras()
+{
+}
+
 QByteArray QSymbianTypeFaceExtras::getSfntTable(uint tag) const
 {
     Q_ASSERT(m_trueTypeExtension->HasTrueTypeTable(tag));
@@ -100,23 +152,25 @@ bool QSymbianTypeFaceExtras::getSfntTableData(uint tag, uchar *buffer, uint *len
     m_trueTypeExtension->ReleaseTrueTypeTable(table);
     return result;
 }
+#endif // Q_SYMBIAN_HAS_FONTTABLE_API
 
-const unsigned char *QSymbianTypeFaceExtras::cmap() const
+const uchar *QSymbianTypeFaceExtras::cmap() const
 {
-    if (!m_cmap) {
-        m_cmapTable = getSfntTable(MAKE_TAG('c', 'm', 'a', 'p'));
+    if (m_cmapTable.isNull()) {
+        const QByteArray cmapTable = getSfntTable(MAKE_TAG('c', 'm', 'a', 'p'));
         int size = 0;
-        m_cmap = QFontEngineS60::getCMap(reinterpret_cast<const uchar *>(m_cmapTable.constData()), m_cmapTable.size(), &m_symbolCMap, &size);
+        const uchar *cmap = QFontEngine::getCMap(reinterpret_cast<const uchar *>
+                (cmapTable.constData()), cmapTable.size(), &m_symbolCMap, &size);
+        m_cmapTable = QByteArray(reinterpret_cast<const char *>(cmap), size);
     }
-    return m_cmap;
+    return reinterpret_cast<const uchar *>(m_cmapTable.constData());
 }
 
 CFont *QSymbianTypeFaceExtras::fontOwner() const
 {
-    return m_fontOwner;
+    return m_cFont;
 }
 
-
 // duplicated from qfontengine_xyz.cpp
 static inline unsigned int getChar(const QChar *str, int &i, const int len)
 {
@@ -225,6 +279,35 @@ void QFontEngineS60::recalcAdvances(QGlyphLayout *glyphs, QTextEngine::ShaperFla
     }
 }
 
+#ifdef Q_SYMBIAN_HAS_GLYPHOUTLINE_API
+static bool parseGlyphPathData(const char *dataStr, const char *dataEnd, QPainterPath &path,
+                               qreal fontPixelSize, const QPointF &offset, bool hinted);
+#endif //Q_SYMBIAN_HAS_GLYPHOUTLINE_API
+
+void QFontEngineS60::addGlyphsToPath(glyph_t *glyphs, QFixedPoint *positions,
+                                     int nglyphs, QPainterPath *path,
+                                     QTextItem::RenderFlags flags)
+{
+#ifdef Q_SYMBIAN_HAS_GLYPHOUTLINE_API
+    Q_UNUSED(flags)
+    RGlyphOutlineIterator iterator;
+    const TInt error = iterator.Open(*m_activeFont, glyphs, nglyphs);
+    if (KErrNone != error)
+        return;
+    const qreal fontSizeInPixels = qreal(m_activeFont->HeightInPixels());
+    int count = 0;
+    do {
+        const TUint8* outlineUint8 = iterator.Outline();
+        const char* const outlineChar = reinterpret_cast<const char*>(outlineUint8);
+        const char* const outlineEnd = outlineChar + iterator.OutlineLength();
+        parseGlyphPathData(outlineChar, outlineEnd, *path, fontSizeInPixels,
+                positions[count++].toPointF(), false);
+    } while(KErrNone == iterator.Next() && count <= nglyphs);
+#else // Q_SYMBIAN_HAS_GLYPHOUTLINE_API
+    QFontEngine::addGlyphsToPath(glyphs, positions, nglyphs, path, flags);
+#endif //Q_SYMBIAN_HAS_GLYPHOUTLINE_API
+}
+
 QImage QFontEngineS60::alphaMapForGlyph(glyph_t glyph)
 {
     TOpenFontCharMetrics metrics;
@@ -356,4 +439,69 @@ void QFontEngineS60::getCharacterData(glyph_t glyph, TOpenFontCharMetrics& metri
     }
 }
 
+#ifdef Q_SYMBIAN_HAS_GLYPHOUTLINE_API
+static inline void skipSpacesAndComma(const char* &str, const char* const strEnd)
+{
+    while (str <= strEnd && (*str == ' ' || *str == ','))
+        ++str;
+}
+
+static bool parseGlyphPathData(const char *svgPath, const char *svgPathEnd, QPainterPath &path,
+                               qreal fontPixelSize, const QPointF &offset, bool hinted)
+{
+    Q_UNUSED(hinted)
+    QPointF p1, p2, firstSubPathPoint;
+    qreal *elementValues[] =
+        {&p1.rx(), &p1.ry(), &p2.rx(), &p2.ry()};
+    const int unitsPerEm = 2048; // See: http://en.wikipedia.org/wiki/Em_%28typography%29
+    const qreal resizeFactor = fontPixelSize / unitsPerEm;
+
+    while (svgPath < svgPathEnd) {
+        skipSpacesAndComma(svgPath, svgPathEnd);
+        const char pathElem = *svgPath++;
+        skipSpacesAndComma(svgPath, svgPathEnd);
+
+        if (pathElem != 'Z') {
+            char *endStr = 0;
+            int elementValuesCount = 0;
+            for (int i = 0; i < 4; ++i) { // 4 = size of elementValues[]
+                qreal coordinateValue = strtod(svgPath, &endStr);
+                if (svgPath == endStr)
+                    break;
+                if (i % 2) // Flip vertically
+                    coordinateValue = -coordinateValue;
+                *elementValues[i] = coordinateValue * resizeFactor;
+                elementValuesCount++;
+                svgPath = endStr;
+                skipSpacesAndComma(svgPath, svgPathEnd);
+            }
+            p1 += offset;
+            if (elementValuesCount == 2)
+                p2 = firstSubPathPoint;
+            else
+                p2 += offset;
+        }
+
+        switch (pathElem) {
+        case 'M':
+            firstSubPathPoint = p1;
+            path.moveTo(p1);
+            break;
+        case 'Z':
+            path.closeSubpath();
+            break;
+        case 'L':
+            path.lineTo(p1);
+            break;
+        case 'Q':
+            path.quadTo(p1, p2);
+            break;
+        default:
+            return false;
+        }
+    }
+    return true;
+}
+#endif // Q_SYMBIAN_HAS_GLYPHOUTLINE_API
+
 QT_END_NAMESPACE
diff --git a/src/gui/text/qfontengine_s60_p.h b/src/gui/text/qfontengine_s60_p.h
index 6883730..beeb4cc 100644
--- a/src/gui/text/qfontengine_s60_p.h
+++ b/src/gui/text/qfontengine_s60_p.h
@@ -58,6 +58,14 @@
 #include "qsize.h"
 #include <openfont.h>
 
+#ifdef SYMBIAN_GDI_GLYPHDATA
+#define Q_SYMBIAN_HAS_FONTTABLE_API
+#endif
+
+#ifdef Q_SYMBIAN_HAS_FONTTABLE_API
+#define Q_SYMBIAN_HAS_GLYPHOUTLINE_API
+#endif // Q_SYMBIAN_HAS_FONTTABLE_API
+
 class CFont;
 
 QT_BEGIN_NAMESPACE
@@ -66,20 +74,22 @@ QT_BEGIN_NAMESPACE
 class QSymbianTypeFaceExtras
 {
 public:
-    QSymbianTypeFaceExtras(CFont* fontOwner, COpenFont *font);
+    QSymbianTypeFaceExtras(CFont* cFont, COpenFont *openFont = 0);
+    ~QSymbianTypeFaceExtras();
 
     QByteArray getSfntTable(uint tag) const;
     bool getSfntTableData(uint tag, uchar *buffer, uint *length) const;
-    const unsigned char *cmap() const;
+    const uchar *cmap() const;
     CFont *fontOwner() const;
 
 private:
-    COpenFont *m_font;
-    mutable MOpenFontTrueTypeExtension *m_trueTypeExtension;
-    mutable const unsigned char *m_cmap;
+    CFont* m_cFont;
     mutable bool m_symbolCMap;
     mutable QByteArray m_cmapTable;
-    CFont* m_fontOwner;
+#ifndef Q_SYMBIAN_HAS_FONTTABLE_API
+    COpenFont *m_openFont;
+    mutable MOpenFontTrueTypeExtension *m_trueTypeExtension;
+#endif // Q_SYMBIAN_HAS_FONTTABLE_API
 };
 
 class QFontEngineS60 : public QFontEngine
@@ -91,6 +101,9 @@ public:
     bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, QTextEngine::ShaperFlags flags) const;
     void recalcAdvances(QGlyphLayout *glyphs, QTextEngine::ShaperFlags flags) const;
 
+    void addGlyphsToPath(glyph_t *glyphs, QFixedPoint *positions, int nglyphs,
+                         QPainterPath *path, QTextItem::RenderFlags flags);
+
     QImage alphaMapForGlyph(glyph_t glyph);
 
     glyph_metrics_t boundingBox(const QGlyphLayout &glyphs);
diff --git a/src/gui/text/qfontmetrics.cpp b/src/gui/text/qfontmetrics.cpp
index 5163c94..d02e841 100644
--- a/src/gui/text/qfontmetrics.cpp
+++ b/src/gui/text/qfontmetrics.cpp
@@ -526,6 +526,14 @@ int QFontMetrics::rightBearing(QChar ch) const
 */
 int QFontMetrics::width(const QString &text, int len) const
 {
+    return width(text, len, 0);
+}
+
+/*!
+    \internal
+*/
+int QFontMetrics::width(const QString &text, int len, int flags) const
+{
     int pos = text.indexOf(QLatin1Char('\x9c'));
     if (pos != -1) {
         len = (len < 0) ? pos : qMin(pos, len);
@@ -535,6 +543,23 @@ int QFontMetrics::width(const QString &text, int len) const
     if (len == 0)
         return 0;
 
+    if (flags & Qt::TextBypassShaping) {
+        // Skip harfbuzz complex shaping, only use advances
+        int numGlyphs = len;
+        QVarLengthGlyphLayoutArray glyphs(numGlyphs);
+        QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);
+        if (!engine->stringToCMap(text.data(), len, &glyphs, &numGlyphs, 0)) {
+            glyphs.resize(numGlyphs);
+            if (!engine->stringToCMap(text.data(), len, &glyphs, &numGlyphs, 0))
+                Q_ASSERT_X(false, Q_FUNC_INFO, "stringToCMap shouldn't fail twice");
+        }
+
+        QFixed width;
+        for (int i = 0; i < numGlyphs; ++i)
+            width += glyphs.advances_x[i];
+        return qRound(width);
+    }
+
     QStackTextEngine layout(text, d.data());
     layout.ignoreBidi = true;
     return qRound(layout.width(0, len));
diff --git a/src/gui/text/qfontmetrics.h b/src/gui/text/qfontmetrics.h
index dca4b93..2518b54 100644
--- a/src/gui/text/qfontmetrics.h
+++ b/src/gui/text/qfontmetrics.h
@@ -89,6 +89,7 @@ public:
     int leftBearing(QChar) const;
     int rightBearing(QChar) const;
     int width(const QString &, int len = -1) const;
+    int width(const QString &, int len, int flags) const;
 
     int width(QChar) const;
     int charWidth(const QString &str, int pos) const;
diff --git a/src/gui/text/qstatictext.cpp b/src/gui/text/qstatictext.cpp
index 84c1d96..10870aa 100644
--- a/src/gui/text/qstatictext.cpp
+++ b/src/gui/text/qstatictext.cpp
@@ -115,10 +115,12 @@ QT_BEGIN_NAMESPACE
     Qt::RichText.
 
     If it's the first time the static text is drawn, or if the static text, or the painter's font
-    or matrix have been altered since the last time it was drawn, the text's layout has to be
-    recalculated. This will impose an overhead on the QPainter::drawStaticText() call where the
-    relayout occurs. To avoid this overhead in the paint event, you can call prepare() ahead of
-    time to ensure that the layout is calculated.
+    has been altered since the last time it was drawn, the text's layout has to be
+    recalculated. On some paint engines, changing the matrix of the painter will also cause the
+    layout to be recalculated. In particular, this will happen for any engine except for the
+    OpenGL2 paint engine. Recalculating the layout will impose an overhead on the
+    QPainter::drawStaticText() call where it occurs. To avoid this overhead in the paint event, you
+    can call prepare() ahead of time to ensure that the layout is calculated.
 
     \sa QPainter::drawText(), QPainter::drawStaticText(), QTextLayout, QTextDocument
 */
@@ -188,8 +190,9 @@ void QStaticText::detach()
 
   When drawStaticText() is called, the layout of the QStaticText will be recalculated if any part
   of the QStaticText object has changed since the last time it was drawn. It will also be
-  recalculated if the painter's font or matrix are not the same as when the QStaticText was last
-  drawn.
+  recalculated if the painter's font is not the same as when the QStaticText was last drawn, or,
+  on any other paint engine than the OpenGL2 engine, if the painter's matrix has been altered
+  since the static text was last drawn.
 
   To avoid the overhead of creating the layout the first time you draw the QStaticText after
   making changes, you can use the prepare() function and pass in the \a matrix and \a font you
@@ -364,14 +367,16 @@ QSizeF QStaticText::size() const
 
 QStaticTextPrivate::QStaticTextPrivate()
         : textWidth(-1.0), items(0), itemCount(0), glyphPool(0), positionPool(0), charPool(0),
-          needsRelayout(true), useBackendOptimizations(false), textFormat(Qt::AutoText)
+          needsRelayout(true), useBackendOptimizations(false), textFormat(Qt::AutoText),
+          untransformedCoordinates(false)
 {
 }
 
 QStaticTextPrivate::QStaticTextPrivate(const QStaticTextPrivate &other)
     : text(other.text), font(other.font), textWidth(other.textWidth), matrix(other.matrix),
       items(0), itemCount(0), glyphPool(0), positionPool(0), charPool(0), needsRelayout(true),
-      useBackendOptimizations(other.useBackendOptimizations), textFormat(other.textFormat)
+      useBackendOptimizations(other.useBackendOptimizations), textFormat(other.textFormat),
+      untransformedCoordinates(other.untransformedCoordinates)
 {
 }
 
@@ -396,8 +401,9 @@ namespace {
     class DrawTextItemRecorder: public QPaintEngine
     {
     public:
-        DrawTextItemRecorder(bool useBackendOptimizations, int numChars)
-                : m_dirtyPen(false), m_useBackendOptimizations(useBackendOptimizations)
+        DrawTextItemRecorder(bool untransformedCoordinates, bool useBackendOptimizations, int numChars)
+                : m_dirtyPen(false), m_useBackendOptimizations(useBackendOptimizations),
+                  m_untransformedCoordinates(untransformedCoordinates)
         {
         }
 
@@ -423,7 +429,7 @@ namespace {
             if (m_dirtyPen)
                 currentItem.color = state->pen().color();
 
-            QTransform matrix = state->transform();
+            QTransform matrix = m_untransformedCoordinates ? QTransform() : state->transform();
             matrix.translate(position.x(), position.y());
 
             QVarLengthArray<glyph_t> glyphs;
@@ -486,14 +492,17 @@ namespace {
 
         bool m_dirtyPen;
         bool m_useBackendOptimizations;
+        bool m_untransformedCoordinates;
     };
 
     class DrawTextItemDevice: public QPaintDevice
     {
     public:
-        DrawTextItemDevice(bool useBackendOptimizations, int numChars)
+        DrawTextItemDevice(bool untransformedCoordinates, bool useBackendOptimizations,
+                           int numChars)
         {
-            m_paintEngine = new DrawTextItemRecorder(useBackendOptimizations, numChars);
+            m_paintEngine = new DrawTextItemRecorder(untransformedCoordinates,
+                                                     useBackendOptimizations, numChars);
         }
 
         ~DrawTextItemDevice()
@@ -629,7 +638,7 @@ void QStaticTextPrivate::init()
 
     position = QPointF(0, 0);
 
-    DrawTextItemDevice device(useBackendOptimizations, text.size());
+    DrawTextItemDevice device(untransformedCoordinates, useBackendOptimizations, text.size());
     {
         QPainter painter(&device);
         painter.setFont(font);
diff --git a/src/gui/text/qstatictext_p.h b/src/gui/text/qstatictext_p.h
index 2ab5579..1a96291 100644
--- a/src/gui/text/qstatictext_p.h
+++ b/src/gui/text/qstatictext_p.h
@@ -148,9 +148,10 @@ public:
     QFixedPoint *positionPool;           // 4 bytes per text
     QChar *charPool;                     // 4 bytes per text
 
-    unsigned char needsRelayout : 1;
-    unsigned char useBackendOptimizations : 1; // 1 byte per text
-    unsigned char textFormat              : 2;
+    unsigned char needsRelayout            : 1; // 1 byte per text
+    unsigned char useBackendOptimizations  : 1;
+    unsigned char textFormat               : 2;
+    unsigned char untransformedCoordinates : 1;
                                          // ================
                                          // 167 bytes per text
 
diff --git a/src/gui/text/qtextcursor.cpp b/src/gui/text/qtextcursor.cpp
index c91df3c..23849bc 100644
--- a/src/gui/text/qtextcursor.cpp
+++ b/src/gui/text/qtextcursor.cpp
@@ -64,7 +64,7 @@ enum {
 
 QTextCursorPrivate::QTextCursorPrivate(QTextDocumentPrivate *p)
     : priv(p), x(0), position(0), anchor(0), adjusted_anchor(0),
-      currentCharFormat(-1), visualNavigation(false)
+      currentCharFormat(-1), visualNavigation(false), keepPositionOnInsert(false)
 {
     priv->addCursor(this);
 }
@@ -79,6 +79,7 @@ QTextCursorPrivate::QTextCursorPrivate(const QTextCursorPrivate &rhs)
     x = rhs.x;
     currentCharFormat = rhs.currentCharFormat;
     visualNavigation = rhs.visualNavigation;
+    keepPositionOnInsert = rhs.keepPositionOnInsert;
     priv->addCursor(this);
 }
 
@@ -95,7 +96,7 @@ QTextCursorPrivate::AdjustResult QTextCursorPrivate::adjustPosition(int position
     if (position < positionOfChange
         || (position == positionOfChange
             && (op == QTextUndoCommand::KeepCursor
-                || anchor < position)
+                || keepPositionOnInsert)
             )
          ) {
         result = CursorUnchanged;
@@ -361,7 +362,7 @@ bool QTextCursorPrivate::movePosition(QTextCursor::MoveOperation op, QTextCursor
     QTextBlock blockIt = block();
 
     if (op >= QTextCursor::Left && op <= QTextCursor::WordRight
-        && blockIt.blockFormat().layoutDirection() == Qt::RightToLeft) {
+        && blockIt.textDirection() == Qt::RightToLeft) {
         if (op == QTextCursor::Left)
             op = QTextCursor::NextCharacter;
         else if (op == QTextCursor::Right)
@@ -1276,6 +1277,80 @@ void QTextCursor::setVisualNavigation(bool b)
         d->visualNavigation = b;
 }
 
+
+/*!
+  \since 4.7
+
+  Sets the visual x position for vertical cursor movements.
+
+  The vertical movement x position is cleared automatically when the cursor moves horizontally, and kept
+  unchanged when the cursor moves vertically. The mechanism allows the cursor to move up and down on a
+  visually straight line with proportional fonts, and to gently "jump" over short lines.
+
+  A value of -1 indicates no predefined x position. It will then be set automatically the next time the
+  cursor moves up or down.
+
+  \sa verticalMovementX()
+  */
+void QTextCursor::setVerticalMovementX(int x)
+{
+    if (d)
+        d->x = x;
+}
+
+/*! \since 4.7
+
+  Returns the visual x position for vertical cursor movements.
+
+  A value of -1 indicates no predefined x position. It will then be set automatically the next time the
+  cursor moves up or down.
+
+  \sa setVerticalMovementX()
+  */
+int QTextCursor::verticalMovementX() const
+{
+    return d ? d->x : -1;
+}
+
+/*!
+  \since 4.7
+
+  Returns whether the cursor should keep its current position when text gets inserted at the position of the
+  cursor.
+
+  The default is false;
+
+  \sa setKeepPositionOnInsert()
+ */
+bool QTextCursor::keepPositionOnInsert() const
+{
+    return d ? d->keepPositionOnInsert : false;
+}
+
+/*!
+  \since 4.7
+
+  Defines whether the cursor should keep its current position when text gets inserted at the current position of the
+  cursor.
+
+  If \b is true, the cursor keeps its current position when text gets inserted at the positing of the cursor.
+  If \b is false, the cursor moves along with the inserted text.
+
+  The default is false.
+
+  Note that a cursor always moves when text is inserted before the current position of the cursor, and it
+  always keeps its position when text is inserted after the current position of the cursor.
+
+  \sa keepPositionOnInsert()
+ */
+void QTextCursor::setKeepPositionOnInsert(bool b)
+{
+    if (d)
+        d->keepPositionOnInsert = b;
+}
+
+
+
 /*!
     Inserts \a text at the current position, using the current
     character format.
@@ -1408,16 +1483,16 @@ void QTextCursor::deletePreviousChar()
 {
     if (!d || !d->priv)
         return;
-    
+
     if (d->position != d->anchor) {
         removeSelectedText();
         return;
     }
-    
+
     if (d->anchor < 1 || !d->canDelete(d->anchor-1))
         return;
     d->anchor--;
-    
+
     QTextDocumentPrivate::FragmentIterator fragIt = d->priv->find(d->anchor);
     const QTextFragmentData * const frag = fragIt.value();
     int fpos = fragIt.position();
@@ -1429,7 +1504,7 @@ void QTextCursor::deletePreviousChar()
         if (uc.unicode() >= 0xd800 && uc.unicode() < 0xdc00)
             --d->anchor;
     }
-    
+
     d->adjusted_anchor = d->anchor;
     d->remove();
     d->setX();
diff --git a/src/gui/text/qtextcursor.h b/src/gui/text/qtextcursor.h
index 3e968a3..251cb33 100644
--- a/src/gui/text/qtextcursor.h
+++ b/src/gui/text/qtextcursor.h
@@ -132,6 +132,12 @@ public:
     bool visualNavigation() const;
     void setVisualNavigation(bool b);
 
+    void setVerticalMovementX(int x);
+    int verticalMovementX() const;
+
+    void setKeepPositionOnInsert(bool b);
+    bool keepPositionOnInsert() const;
+
     void deleteChar();
     void deletePreviousChar();
 
diff --git a/src/gui/text/qtextcursor_p.h b/src/gui/text/qtextcursor_p.h
index 1bdfa78..4e36b95 100644
--- a/src/gui/text/qtextcursor_p.h
+++ b/src/gui/text/qtextcursor_p.h
@@ -112,7 +112,8 @@ public:
     int anchor;
     int adjusted_anchor;
     int currentCharFormat;
-    bool visualNavigation;
+    uint visualNavigation : 1;
+    uint keepPositionOnInsert : 1;
 };
 
 QT_END_NAMESPACE
diff --git a/src/gui/text/qtextdocument.cpp b/src/gui/text/qtextdocument.cpp
index c7a9756..48aee8f 100644
--- a/src/gui/text/qtextdocument.cpp
+++ b/src/gui/text/qtextdocument.cpp
@@ -2496,13 +2496,10 @@ void QTextHtmlExporter::emitBlockAttributes(const QTextBlock &block)
     QTextBlockFormat format = block.blockFormat();
     emitAlignment(format.alignment());
 
-    Qt::LayoutDirection dir = format.layoutDirection();
-    if (dir == Qt::LeftToRight) {
-        // assume default to not bloat the html too much
-        // html += QLatin1String(" dir='ltr'");
-    } else {
+    // assume default to not bloat the html too much
+    // html += QLatin1String(" dir='ltr'");
+    if (block.textDirection() == Qt::RightToLeft)
         html += QLatin1String(" dir='rtl'");
-    }
 
     QLatin1String style(" style=\"");
     html += style;
diff --git a/src/gui/text/qtextdocumentlayout.cpp b/src/gui/text/qtextdocumentlayout.cpp
index f12bf0b..ff14490 100644
--- a/src/gui/text/qtextdocumentlayout.cpp
+++ b/src/gui/text/qtextdocumentlayout.cpp
@@ -79,7 +79,7 @@ Q_GUI_EXPORT extern int qt_defaultDpi();
 
 // ################ should probably add frameFormatChange notification!
 
-struct QLayoutStruct;
+struct QTextLayoutStruct;
 
 class QTextFrameData : public QTextFrameLayoutData
 {
@@ -109,7 +109,7 @@ public:
     QFixed minimumWidth;
     QFixed maximumWidth;
 
-    QLayoutStruct *currentLayoutStruct;
+    QTextLayoutStruct *currentLayoutStruct;
 
     bool sizeDirty;
     bool layoutDirty;
@@ -123,8 +123,8 @@ QTextFrameData::QTextFrameData()
 {
 }
 
-struct QLayoutStruct {
-    QLayoutStruct() : maximumWidth(QFIXED_MAX), fullLayout(false)
+struct QTextLayoutStruct {
+    QTextLayoutStruct() : maximumWidth(QFIXED_MAX), fullLayout(false)
     {}
     QTextFrame *frame;
     QFixed x_left;
@@ -477,9 +477,9 @@ public:
     HitPoint hitTest(QTextTable *table, const QFixedPoint &point, int *position, QTextLayout **l, Qt::HitTestAccuracy accuracy) const;
     HitPoint hitTest(QTextBlock bl, const QFixedPoint &point, int *position, QTextLayout **l, Qt::HitTestAccuracy accuracy) const;
 
-    QLayoutStruct layoutCell(QTextTable *t, const QTextTableCell &cell, QFixed width,
-                            int layoutFrom, int layoutTo, QTextTableData *tableData, QFixed absoluteTableY,
-                            bool withPageBreaks);
+    QTextLayoutStruct layoutCell(QTextTable *t, const QTextTableCell &cell, QFixed width,
+                                 int layoutFrom, int layoutTo, QTextTableData *tableData, QFixed absoluteTableY,
+                                 bool withPageBreaks);
     void setCellPosition(QTextTable *t, const QTextTableCell &cell, const QPointF &pos);
     QRectF layoutTable(QTextTable *t, int layoutFrom, int layoutTo, QFixed parentY);
 
@@ -490,13 +490,13 @@ public:
     QRectF layoutFrame(QTextFrame *f, int layoutFrom, int layoutTo, QFixed frameWidth, QFixed frameHeight, QFixed parentY = 0);
 
     void layoutBlock(const QTextBlock &bl, int blockPosition, const QTextBlockFormat &blockFormat,
-                     QLayoutStruct *layoutStruct, int layoutFrom, int layoutTo, const QTextBlockFormat *previousBlockFormat);
-    void layoutFlow(QTextFrame::Iterator it, QLayoutStruct *layoutStruct, int layoutFrom, int layoutTo, QFixed width = 0);
-    void pageBreakInsideTable(QTextTable *table, QLayoutStruct *layoutStruct);
+                     QTextLayoutStruct *layoutStruct, int layoutFrom, int layoutTo, const QTextBlockFormat *previousBlockFormat);
+    void layoutFlow(QTextFrame::Iterator it, QTextLayoutStruct *layoutStruct, int layoutFrom, int layoutTo, QFixed width = 0);
+    void pageBreakInsideTable(QTextTable *table, QTextLayoutStruct *layoutStruct);
 
 
-    void floatMargins(const QFixed &y, const QLayoutStruct *layoutStruct, QFixed *left, QFixed *right) const;
-    QFixed findY(QFixed yFrom, const QLayoutStruct *layoutStruct, QFixed requiredWidth) const;
+    void floatMargins(const QFixed &y, const QTextLayoutStruct *layoutStruct, QFixed *left, QFixed *right) const;
+    QFixed findY(QFixed yFrom, const QTextLayoutStruct *layoutStruct, QFixed requiredWidth) const;
 
     QVector<QCheckPoint> checkPoints;
 
@@ -1369,9 +1369,7 @@ void QTextDocumentLayoutPrivate::drawListItem(const QPointF &offset, QPainter *p
     QTextLine firstLine = layout->lineAt(0);
     Q_ASSERT(firstLine.isValid());
     QPointF pos = (offset + layout->position()).toPoint();
-    Qt::LayoutDirection dir = docPrivate->defaultTextOption.textDirection();
-    if (blockFormat.hasProperty(QTextFormat::LayoutDirection))
-        dir = blockFormat.layoutDirection();
+    Qt::LayoutDirection dir = bl.textDirection();
     {
         QRectF textRect = firstLine.naturalTextRect();
         pos += textRect.topLeft().toPoint();
@@ -1487,12 +1485,12 @@ static QFixed firstChildPos(const QTextFrame *f)
     return flowPosition(f->begin());
 }
 
-QLayoutStruct QTextDocumentLayoutPrivate::layoutCell(QTextTable *t, const QTextTableCell &cell, QFixed width,
-                                                    int layoutFrom, int layoutTo, QTextTableData *td,
-                                                    QFixed absoluteTableY, bool withPageBreaks)
+QTextLayoutStruct QTextDocumentLayoutPrivate::layoutCell(QTextTable *t, const QTextTableCell &cell, QFixed width,
+                                                        int layoutFrom, int layoutTo, QTextTableData *td,
+                                                        QFixed absoluteTableY, bool withPageBreaks)
 {
     LDEBUG << "layoutCell";
-    QLayoutStruct layoutStruct;
+    QTextLayoutStruct layoutStruct;
     layoutStruct.frame = t;
     layoutStruct.minimumWidth = 0;
     layoutStruct.maximumWidth = QFIXED_MAX;
@@ -1641,9 +1639,9 @@ recalc_minmax_widths:
             // to figure out the min and the max width lay out the cell at
             // maximum width. otherwise the maxwidth calculation sometimes
             // returns wrong values
-            QLayoutStruct layoutStruct = layoutCell(table, cell, QFIXED_MAX, layoutFrom,
-                                                    layoutTo, td, absoluteTableY,
-                                                    /*withPageBreaks =*/false);
+            QTextLayoutStruct layoutStruct = layoutCell(table, cell, QFIXED_MAX, layoutFrom,
+                                                        layoutTo, td, absoluteTableY,
+                                                        /*withPageBreaks =*/false);
 
             // distribute the minimum width over all columns the cell spans
             QFixed widthToDistribute = layoutStruct.minimumWidth + widthPadding;
@@ -1868,10 +1866,10 @@ relayout:
             ++rowCellCount;
 
             const QFixed width = td->cellWidth(c, cspan) - widthPadding;
-            QLayoutStruct layoutStruct = layoutCell(table, cell, width,
-                                                    layoutFrom, layoutTo,
-                                                    td, absoluteTableY,
-                                                    /*withPageBreaks =*/true);
+            QTextLayoutStruct layoutStruct = layoutCell(table, cell, width,
+                                                       layoutFrom, layoutTo,
+                                                       td, absoluteTableY,
+                                                       /*withPageBreaks =*/true);
 
             const QFixed height = layoutStruct.y + bottomPadding + topPadding;
 
@@ -1976,7 +1974,7 @@ void QTextDocumentLayoutPrivate::positionFloat(QTextFrame *frame, QTextLine *cur
     QTextFrameData *pd = data(parent);
     Q_ASSERT(pd && pd->currentLayoutStruct);
 
-    QLayoutStruct *layoutStruct = pd->currentLayoutStruct;
+    QTextLayoutStruct *layoutStruct = pd->currentLayoutStruct;
 
     if (!pd->floats.contains(frame))
         pd->floats.append(frame);
@@ -2116,7 +2114,7 @@ QRectF QTextDocumentLayoutPrivate::layoutFrame(QTextFrame *f, int layoutFrom, in
     // function.
     fd->contentsWidth = newContentsWidth;
 
-    QLayoutStruct layoutStruct;
+    QTextLayoutStruct layoutStruct;
     layoutStruct.frame = f;
     layoutStruct.x_left = fd->leftMargin + fd->border + fd->padding;
     layoutStruct.x_right = layoutStruct.x_left + newContentsWidth;
@@ -2179,7 +2177,7 @@ QRectF QTextDocumentLayoutPrivate::layoutFrame(QTextFrame *f, int layoutFrom, in
     return layoutStruct.updateRect;
 }
 
-void QTextDocumentLayoutPrivate::layoutFlow(QTextFrame::Iterator it, QLayoutStruct *layoutStruct,
+void QTextDocumentLayoutPrivate::layoutFlow(QTextFrame::Iterator it, QTextLayoutStruct *layoutStruct,
                                             int layoutFrom, int layoutTo, QFixed width)
 {
     LDEBUG << "layoutFlow from=" << layoutFrom << "to=" << layoutTo;
@@ -2509,7 +2507,7 @@ void QTextDocumentLayoutPrivate::layoutFlow(QTextFrame::Iterator it, QLayoutStru
 }
 
 void QTextDocumentLayoutPrivate::layoutBlock(const QTextBlock &bl, int blockPosition, const QTextBlockFormat &blockFormat,
-                                             QLayoutStruct *layoutStruct, int layoutFrom, int layoutTo, const QTextBlockFormat *previousBlockFormat)
+                                             QTextLayoutStruct *layoutStruct, int layoutFrom, int layoutTo, const QTextBlockFormat *previousBlockFormat)
 {
     Q_Q(QTextDocumentLayout);
 
@@ -2530,9 +2528,7 @@ void QTextDocumentLayoutPrivate::layoutBlock(const QTextBlock &bl, int blockPosi
 
     //QTextFrameData *fd = data(layoutStruct->frame);
 
-    Qt::LayoutDirection dir = docPrivate->defaultTextOption.textDirection();
-    if (blockFormat.hasProperty(QTextFormat::LayoutDirection))
-        dir = blockFormat.layoutDirection();
+    Qt::LayoutDirection dir = bl.textDirection();
 
     QFixed extraMargin;
     if (docPrivate->defaultTextOption.flags() & QTextOption::AddSpaceForLineAndParagraphSeparators) {
@@ -2718,7 +2714,7 @@ void QTextDocumentLayoutPrivate::layoutBlock(const QTextBlock &bl, int blockPosi
     }
 }
 
-void QTextDocumentLayoutPrivate::floatMargins(const QFixed &y, const QLayoutStruct *layoutStruct,
+void QTextDocumentLayoutPrivate::floatMargins(const QFixed &y, const QTextLayoutStruct *layoutStruct,
                                               QFixed *left, QFixed *right) const
 {
 //     qDebug() << "floatMargins y=" << y;
@@ -2740,7 +2736,7 @@ void QTextDocumentLayoutPrivate::floatMargins(const QFixed &y, const QLayoutStru
 //     qDebug() << "floatMargins: left="<<*left<<"right="<<*right<<"y="<<y;
 }
 
-QFixed QTextDocumentLayoutPrivate::findY(QFixed yFrom, const QLayoutStruct *layoutStruct, QFixed requiredWidth) const
+QFixed QTextDocumentLayoutPrivate::findY(QFixed yFrom, const QTextLayoutStruct *layoutStruct, QFixed requiredWidth) const
 {
     QFixed right, left;
     requiredWidth = qMin(requiredWidth, layoutStruct->x_right - layoutStruct->x_left);
diff --git a/src/gui/text/qtextengine.cpp b/src/gui/text/qtextengine.cpp
index d34553f..ac1fffd 100644
--- a/src/gui/text/qtextengine.cpp
+++ b/src/gui/text/qtextengine.cpp
@@ -885,7 +885,7 @@ void QTextEngine::shapeText(int item) const
     QFixed letterSpacing = font.d->letterSpacing;
     QFixed wordSpacing = font.d->wordSpacing;
 
-    if (letterSpacingIsAbsolute)
+    if (letterSpacingIsAbsolute && letterSpacing.value())
         letterSpacing *= font.d->dpi / qt_defaultDpiY();
 
     if (letterSpacing != 0) {
@@ -1404,7 +1404,10 @@ void QTextEngine::itemize() const
 #else
     bool ignore = ignoreBidi;
 #endif
-    if (!ignore && option.textDirection() == Qt::LeftToRight) {
+
+    bool rtl = isRightToLeft();
+
+    if (!ignore && !rtl) {
         ignore = true;
         const QChar *start = layoutData->string.unicode();
         const QChar * const end = start + length;
@@ -1420,7 +1423,7 @@ void QTextEngine::itemize() const
     QVarLengthArray<QScriptAnalysis, 4096> scriptAnalysis(length);
     QScriptAnalysis *analysis = scriptAnalysis.data();
 
-    QBidiControl control(option.textDirection() == Qt::RightToLeft);
+    QBidiControl control(rtl);
 
     if (ignore) {
         memset(analysis, 0, length*sizeof(QScriptAnalysis));
@@ -1515,6 +1518,23 @@ void QTextEngine::itemize() const
     resolveAdditionalFormats();
 }
 
+bool QTextEngine::isRightToLeft() const
+{
+    switch (option.textDirection()) {
+    case Qt::LeftToRight:
+        return false;
+    case Qt::RightToLeft:
+        return true;
+    default:
+        break;
+    }
+    // this places the cursor in the right position depending on the keyboard layout
+    if (layoutData->string.isEmpty())
+        return QApplication::keyboardInputDirection() == Qt::RightToLeft;
+    return layoutData->string.isRightToLeft();
+}
+
+
 int QTextEngine::findItem(int strPos) const
 {
     itemize();
@@ -2511,7 +2531,7 @@ QFixed QTextEngine::calculateTabWidth(int item, QFixed x) const
 
     QList<QTextOption::Tab> tabArray = option.tabs();
     if (!tabArray.isEmpty()) {
-        if (option.textDirection() == Qt::RightToLeft) { // rebase the tabArray positions.
+        if (isRightToLeft()) { // rebase the tabArray positions.
             QList<QTextOption::Tab> newTabs;
             QList<QTextOption::Tab>::Iterator iter = tabArray.begin();
             while(iter != tabArray.end()) {
@@ -2648,6 +2668,12 @@ QTextItemInt::QTextItemInt(const QScriptItem &si, QFont *font, const QTextCharFo
         flags |= QTextItem::StrikeOut;
 }
 
+QTextItemInt::QTextItemInt(const QGlyphLayout &g, QFont *font, QFontEngine *fe)
+    : flags(0), justified(false), underlineStyle(QTextCharFormat::NoUnderline),
+      num_chars(0), chars(0), logClusters(0), f(font), fontEngine(fe), glyphs(g)
+{
+}
+
 QTextItemInt QTextItemInt::midItem(QFontEngine *fontEngine, int firstGlyphIndex, int numGlyphs) const
 {
     QTextItemInt ti = *this;
diff --git a/src/gui/text/qtextengine_p.h b/src/gui/text/qtextengine_p.h
index d92148f..908a0ec 100644
--- a/src/gui/text/qtextengine_p.h
+++ b/src/gui/text/qtextengine_p.h
@@ -311,6 +311,7 @@ public:
           logClusters(0), f(0), fontEngine(0)
     {}
     QTextItemInt(const QScriptItem &si, QFont *font, const QTextCharFormat &format = QTextCharFormat());
+    QTextItemInt(const QGlyphLayout &g, QFont *font, QFontEngine *fe);
 
     /// copy the structure items, adjusting the glyphs arrays to the right subarrays.
     /// the width of the returned QTextItemInt is not adjusted, for speed reasons
@@ -457,6 +458,7 @@ public:
     void validate() const;
     void itemize() const;
 
+    bool isRightToLeft() const;
     static void bidiReorder(int numRuns, const quint8 *levels, int *visualOrder);
 
     const HB_CharAttributes *attributes() const;
diff --git a/src/gui/text/qtextformat.cpp b/src/gui/text/qtextformat.cpp
index 140cf43..46db253 100644
--- a/src/gui/text/qtextformat.cpp
+++ b/src/gui/text/qtextformat.cpp
@@ -900,11 +900,14 @@ bool QTextFormat::boolProperty(int propertyId) const
 */
 int QTextFormat::intProperty(int propertyId) const
 {
+    // required, since the default layout direction has to be LayoutDirectionAuto, which is not integer 0
+    int def = (propertyId == QTextFormat::LayoutDirection) ? int(Qt::LayoutDirectionAuto) : 0;
+
     if (!d)
-        return 0;
+        return def;
     const QVariant prop = d->property(propertyId);
     if (prop.userType() != QVariant::Int)
-        return 0;
+        return def;
     return prop.toInt();
 }
 
diff --git a/src/gui/text/qtextlayout.cpp b/src/gui/text/qtextlayout.cpp
index 3f67408..ddf9411 100644
--- a/src/gui/text/qtextlayout.cpp
+++ b/src/gui/text/qtextlayout.cpp
@@ -69,7 +69,7 @@ static inline QFixed leadingSpaceWidth(QTextEngine *eng, const QScriptLine &line
     if (!line.hasTrailingSpaces
         || (eng->option.flags() & QTextOption::IncludeTrailingSpaces)
         || !(eng->option.alignment() & Qt::AlignRight)
-        || (eng->option.textDirection() != Qt::RightToLeft))
+        || !eng->isRightToLeft())
         return QFixed();
 
     int pos = line.length;
@@ -86,12 +86,12 @@ static QFixed alignLine(QTextEngine *eng, const QScriptLine &line)
     // if width is QFIXED_MAX that means we used setNumColumns() and that implicitly makes this line left aligned.
     if (!line.justified && line.width != QFIXED_MAX) {
         int align = eng->option.alignment();
-        if (align & Qt::AlignJustify && eng->option.textDirection() == Qt::RightToLeft)
+        if (align & Qt::AlignJustify && eng->isRightToLeft())
             align = Qt::AlignRight;
         if (align & Qt::AlignRight)
-            x = line.width - (line.textWidth + leadingSpaceWidth(eng, line));
+            x = line.width - (line.textAdvance + leadingSpaceWidth(eng, line));
         else if (align & Qt::AlignHCenter)
-            x = (line.width - line.textWidth)/2;
+            x = (line.width - line.textAdvance)/2;
     }
     return x;
 }
@@ -1337,7 +1337,7 @@ void QTextLayout::drawCursor(QPainter *p, const QPointF &pos, int cursorPosition
     int itm = d->findItem(cursorPosition - 1);
     QFixed base = sl.base();
     QFixed descent = sl.descent;
-    bool rightToLeft = (d->option.textDirection() == Qt::RightToLeft);
+    bool rightToLeft = d->isRightToLeft();
     if (itm >= 0) {
         const QScriptItem &si = d->layoutData->items.at(itm);
         if (si.ascent > 0)
diff --git a/src/gui/text/qtextlist.cpp b/src/gui/text/qtextlist.cpp
index 2986ee7..a0ff520 100644
--- a/src/gui/text/qtextlist.cpp
+++ b/src/gui/text/qtextlist.cpp
@@ -262,7 +262,7 @@ QString QTextList::itemText(const QTextBlock &blockIt) const
         default:
             Q_ASSERT(false);
     }
-    if (blockFormat.layoutDirection() == Qt::RightToLeft)
+    if (blockIt.textDirection() == Qt::RightToLeft)
         return result.prepend(QLatin1Char('.'));
     return result + QLatin1Char('.');
 }
diff --git a/src/gui/text/qtextobject.cpp b/src/gui/text/qtextobject.cpp
index 088eb98..f386871 100644
--- a/src/gui/text/qtextobject.cpp
+++ b/src/gui/text/qtextobject.cpp
@@ -1140,6 +1140,49 @@ int QTextBlock::charFormatIndex() const
 }
 
 /*!
+  \since 4.7
+
+  Returns the resolved text direction.
+
+  If the block has no explicit direction set, it will resolve the
+  direction from the blocks content. Returns either Qt::LeftToRight
+  or Qt::RightToLeft.
+
+  \sa QTextBlock::layoutDirection(), QString::isRightToLeft(), Qt::LayoutDirection
+*/
+Qt::LayoutDirection QTextBlock::textDirection() const
+{
+    Qt::LayoutDirection dir = blockFormat().layoutDirection();
+    if (dir != Qt::LayoutDirectionAuto)
+        return dir;
+
+    const QString buffer = p->buffer();
+
+    const int pos = position();
+    QTextDocumentPrivate::FragmentIterator it = p->find(pos);
+    QTextDocumentPrivate::FragmentIterator end = p->find(pos + length() - 1); // -1 to omit the block separator char
+    for (; it != end; ++it) {
+        const QTextFragmentData * const frag = it.value();
+        const QChar *p = buffer.constData() + frag->stringPosition;
+        const QChar * const end = p + frag->size_array[0];
+        while (p < end) {
+            switch(QChar::direction(p->unicode()))
+            {
+            case QChar::DirL:
+                return Qt::LeftToRight;
+            case QChar::DirR:
+            case QChar::DirAL:
+                return Qt::RightToLeft;
+            default:
+                break;
+            }
+            ++p;
+        }
+    }
+    return Qt::LeftToRight;
+}
+
+/*!
     Returns the block's contents as plain text.
 
     \sa length() charFormat() blockFormat()
diff --git a/src/gui/text/qtextobject.h b/src/gui/text/qtextobject.h
index 67f67d8..a573a26 100644
--- a/src/gui/text/qtextobject.h
+++ b/src/gui/text/qtextobject.h
@@ -221,6 +221,8 @@ public:
     QTextCharFormat charFormat() const;
     int charFormatIndex() const;
 
+    Qt::LayoutDirection textDirection() const;
+
     QString text() const;
 
     const QTextDocument *document() const;
diff --git a/src/gui/text/qtextoption.cpp b/src/gui/text/qtextoption.cpp
index c1e254c..3b02ebe 100644
--- a/src/gui/text/qtextoption.cpp
+++ b/src/gui/text/qtextoption.cpp
@@ -65,7 +65,7 @@ QTextOption::QTextOption()
       tab(-1),
       d(0)
 {
-    direction = QApplication::layoutDirection();
+    direction = Qt::LayoutDirectionAuto;
 }
 
 /*!
diff --git a/src/gui/text/qtextoption.h b/src/gui/text/qtextoption.h
index 1381ed1..fa8c6f2 100644
--- a/src/gui/text/qtextoption.h
+++ b/src/gui/text/qtextoption.h
@@ -134,8 +134,8 @@ private:
     uint align : 8;
     uint wordWrap : 4;
     uint design : 1;
-    uint direction : 1;
-    uint unused : 19;
+    uint direction : 2;
+    uint unused : 18;
     uint f;
     qreal tab;
     QTextOptionPrivate *d;
diff --git a/src/gui/widgets/qabstractscrollarea.cpp b/src/gui/widgets/qabstractscrollarea.cpp
index 8cffebd..30ce23b 100644
--- a/src/gui/widgets/qabstractscrollarea.cpp
+++ b/src/gui/widgets/qabstractscrollarea.cpp
@@ -295,8 +295,10 @@ void QAbstractScrollAreaPrivate::init()
     q->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
     layoutChildren();
 #ifndef Q_WS_MAC
+#ifndef QT_NO_GESTURES
     viewport->grabGesture(Qt::PanGesture);
 #endif
+#endif
 }
 
 #ifdef Q_WS_WIN
@@ -546,8 +548,10 @@ void QAbstractScrollArea::setViewport(QWidget *widget)
         d->viewport->setFocusProxy(this);
         d->viewport->installEventFilter(d->viewportFilter.data());
 #ifndef Q_WS_MAC
+#ifndef QT_NO_GESTURES
         d->viewport->grabGesture(Qt::PanGesture);
 #endif
+#endif
         d->layoutChildren();
         if (isVisible())
             d->viewport->show();
@@ -960,6 +964,7 @@ bool QAbstractScrollArea::event(QEvent *e)
     case QEvent::TouchUpdate:
     case QEvent::TouchEnd:
         return false;
+#ifndef QT_NO_GESTURES
     case QEvent::Gesture:
     {
         QGestureEvent *ge = static_cast<QGestureEvent *>(e);
@@ -980,6 +985,7 @@ bool QAbstractScrollArea::event(QEvent *e)
         }
         return false;
     }
+#endif // QT_NO_GESTURES
     case QEvent::StyleChange:
     case QEvent::LayoutDirectionChange:
     case QEvent::ApplicationLayoutDirectionChange:
@@ -1036,9 +1042,11 @@ bool QAbstractScrollArea::viewportEvent(QEvent *e)
 #endif
         return QFrame::event(e);
     case QEvent::LayoutRequest:
+#ifndef QT_NO_GESTURES
     case QEvent::Gesture:
     case QEvent::GestureOverride:
         return event(e);
+#endif
     default:
         break;
     }
diff --git a/src/gui/widgets/qlinecontrol_p.h b/src/gui/widgets/qlinecontrol_p.h
index 5da1831..7068f62 100644
--- a/src/gui/widgets/qlinecontrol_p.h
+++ b/src/gui/widgets/qlinecontrol_p.h
@@ -78,7 +78,7 @@ class Q_GUI_EXPORT QLineControl : public QObject
 
 public:
     QLineControl(const QString &txt = QString())
-        : m_cursor(0), m_preeditCursor(0), m_cursorWidth(0), m_layoutDirection(Qt::LeftToRight),
+        : m_cursor(0), m_preeditCursor(0), m_cursorWidth(0), m_layoutDirection(Qt::LayoutDirectionAuto),
         m_hideCursor(false), m_separator(0), m_readOnly(0),
         m_dragEnabled(0), m_echoMode(0), m_textDirty(0), m_selDirty(0),
         m_validInput(1), m_blinkStatus(0), m_blinkPeriod(0), m_blinkTimer(0), m_deleteAllTimer(0),
@@ -272,7 +272,14 @@ public:
     QChar passwordCharacter() const { return m_passwordCharacter; }
     void setPasswordCharacter(const QChar &character) { m_passwordCharacter = character; updateDisplayText(); }
 
-    Qt::LayoutDirection layoutDirection() const { return m_layoutDirection; }
+    Qt::LayoutDirection layoutDirection() const {
+        if (m_layoutDirection == Qt::LayoutDirectionAuto) {
+            if (m_text.isEmpty())
+                return QApplication::keyboardInputDirection();
+            return m_text.isRightToLeft() ? Qt::RightToLeft : Qt::LeftToRight;
+        }
+        return m_layoutDirection;
+    }
     void setLayoutDirection(Qt::LayoutDirection direction)
     {
         if (direction != m_layoutDirection) {
diff --git a/src/gui/widgets/qlineedit.cpp b/src/gui/widgets/qlineedit.cpp
index c1c4abf..1bffde1 100644
--- a/src/gui/widgets/qlineedit.cpp
+++ b/src/gui/widgets/qlineedit.cpp
@@ -1860,7 +1860,7 @@ void QLineEdit::paintEvent(QPaintEvent *)
     p.setClipRect(r);
 
     QFontMetrics fm = fontMetrics();
-    Qt::Alignment va = QStyle::visualAlignment(layoutDirection(), QFlag(d->alignment));
+    Qt::Alignment va = QStyle::visualAlignment(d->control->layoutDirection(), QFlag(d->alignment));
     switch (va & Qt::AlignVertical_Mask) {
      case Qt::AlignBottom:
          d->vscroll = r.y() + r.height() - fm.height() - d->verticalMargin;
@@ -2161,9 +2161,6 @@ void QLineEdit::changeEvent(QEvent *ev)
         }
         update();
         break;
-    case QEvent::LayoutDirectionChange:
-        d->control->setLayoutDirection(layoutDirection());
-        break;
     default:
         break;
     }
diff --git a/src/gui/widgets/qplaintextedit.cpp b/src/gui/widgets/qplaintextedit.cpp
index 2734fba..21c2635 100644
--- a/src/gui/widgets/qplaintextedit.cpp
+++ b/src/gui/widgets/qplaintextedit.cpp
@@ -1476,6 +1476,7 @@ bool QPlainTextEdit::event(QEvent *e)
             d->sendControlEvent(e);
     }
 #endif
+#ifndef QT_NO_GESTURES
     else if (e->type() == QEvent::Gesture) {
         QGestureEvent *ge = static_cast<QGestureEvent *>(e);
         QPanGesture *g = static_cast<QPanGesture *>(ge->gesture(Qt::PanGesture));
@@ -1499,6 +1500,7 @@ bool QPlainTextEdit::event(QEvent *e)
         }
         return true;
     }
+#endif // QT_NO_GESTURES
     return QAbstractScrollArea::event(e);
 }
 
diff --git a/src/gui/widgets/qprogressbar.h b/src/gui/widgets/qprogressbar.h
index b461a21..58bc8b2 100644
--- a/src/gui/widgets/qprogressbar.h
+++ b/src/gui/widgets/qprogressbar.h
@@ -93,9 +93,11 @@ public:
     Qt::Orientation orientation() const;
 
     void setInvertedAppearance(bool invert);
-    bool invertedAppearance();
+    bool invertedAppearance(); //### Qt5 make const
+    bool invertedAppearance() const { return const_cast<QProgressBar *>(this)->invertedAppearance(); }
     void setTextDirection(QProgressBar::Direction textDirection);
-    QProgressBar::Direction textDirection();
+    QProgressBar::Direction textDirection(); //### Qt5 make const
+    QProgressBar::Direction textDirection() const { return const_cast<QProgressBar *>(this)->textDirection(); }
 
     void setFormat(const QString &format);
     QString format() const;
diff --git a/src/gui/widgets/qstackedwidget.cpp b/src/gui/widgets/qstackedwidget.cpp
index 2509a21..de8d3e6 100644
--- a/src/gui/widgets/qstackedwidget.cpp
+++ b/src/gui/widgets/qstackedwidget.cpp
@@ -186,11 +186,11 @@ int QStackedWidget::insertWidget(int index, QWidget *widget)
 }
 
 /*!
-    Removes the given \a widget from the QStackedWidget.
+    Removes \a widget from the QStackedWidget. i.e., \a widget is \e
+    not deleted but simply removed from the stacked layout, causing it
+    to be hidden.
 
-    \bold{Note:} The ownership of \a widget remains the same.
-    The widget is \e not deleted, but simply removed from the widget's
-    stacked layout, causing it to be hidden.
+    \bold{Note:} Ownership of \a widget reverts to the application.
 
     \sa addWidget(), insertWidget(), currentWidget()
 */
diff --git a/src/imports/gestures/plugin.cpp b/src/imports/gestures/plugin.cpp
index 11f2392..1fc23ca 100644
--- a/src/imports/gestures/plugin.cpp
+++ b/src/imports/gestures/plugin.cpp
@@ -53,7 +53,9 @@ public:
     virtual void registerTypes(const char *uri)
     {
         Q_ASSERT(QLatin1String(uri) == QLatin1String("Qt.labs.gestures"));
+#ifndef QT_NO_GESTURES
         qmlRegisterCustomType<QDeclarativeGestureArea>(uri,1,0, "GestureArea", new QDeclarativeGestureAreaParser);
+#endif
     }
 };
 
@@ -62,4 +64,3 @@ QT_END_NAMESPACE
 #include "plugin.moc"
 
 Q_EXPORT_PLUGIN2(qmlgesturesplugin, QT_PREPEND_NAMESPACE(GestureAreaQmlPlugin));
-
diff --git a/src/imports/gestures/qdeclarativegesturearea.cpp b/src/imports/gestures/qdeclarativegesturearea.cpp
index 1b0aeeb..22be2f1 100644
--- a/src/imports/gestures/qdeclarativegesturearea.cpp
+++ b/src/imports/gestures/qdeclarativegesturearea.cpp
@@ -55,6 +55,8 @@
 
 #include <private/qobject_p.h>
 
+#ifndef QT_NO_GESTURES
+
 QT_BEGIN_NAMESPACE
 
 class QDeclarativeGestureAreaPrivate : public QDeclarativeItemPrivate
@@ -267,3 +269,5 @@ bool QDeclarativeGestureAreaPrivate::gestureEvent(QGestureEvent *event)
 }
 
 QT_END_NAMESPACE
+
+#endif // QT_NO_GESTURES
diff --git a/src/imports/gestures/qdeclarativegesturearea_p.h b/src/imports/gestures/qdeclarativegesturearea_p.h
index 0195511..ff89166 100644
--- a/src/imports/gestures/qdeclarativegesturearea_p.h
+++ b/src/imports/gestures/qdeclarativegesturearea_p.h
@@ -50,6 +50,8 @@
 #include <QtCore/qstring.h>
 #include <QtGui/qgesture.h>
 
+#ifndef QT_NO_GESTURES
+
 QT_BEGIN_HEADER
 
 QT_BEGIN_NAMESPACE
@@ -97,4 +99,6 @@ QML_DECLARE_TYPE(QDeclarativeGestureArea)
 
 QT_END_HEADER
 
+#endif // QT_NO_GESTURES
+
 #endif
diff --git a/src/imports/qimportbase.pri b/src/imports/qimportbase.pri
index 91f6552..612ff20 100644
--- a/src/imports/qimportbase.pri
+++ b/src/imports/qimportbase.pri
@@ -1,3 +1,4 @@
+symbian:include(../plugins/qpluginbase.pri)
 TEMPLATE = lib
 CONFIG += qt plugin
 
diff --git a/src/imports/webkit/qdeclarativewebview.cpp b/src/imports/webkit/qdeclarativewebview.cpp
index 050e2b7..9e5647f 100644
--- a/src/imports/webkit/qdeclarativewebview.cpp
+++ b/src/imports/webkit/qdeclarativewebview.cpp
@@ -711,7 +711,7 @@ bool QDeclarativeWebView::sceneEvent(QEvent *event)
     return QDeclarativeItem::sceneEvent(event);
 }
 
-
+#ifndef QT_NO_ACTION
 /*!
     \qmlproperty action WebView::back
     This property holds the action for causing the previous URL in the history to be displayed.
@@ -747,6 +747,7 @@ QAction *QDeclarativeWebView::stopAction() const
 {
     return page()->action(QWebPage::Stop);
 }
+#endif // QT_NO_ACTION
 
 /*!
     \qmlproperty real WebView::title
diff --git a/src/imports/webkit/qdeclarativewebview_p.h b/src/imports/webkit/qdeclarativewebview_p.h
index 87bd938..042237e 100644
--- a/src/imports/webkit/qdeclarativewebview_p.h
+++ b/src/imports/webkit/qdeclarativewebview_p.h
@@ -108,10 +108,12 @@ class QDeclarativeWebView : public QDeclarativeItem
     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)
 
@@ -154,10 +156,12 @@ public:
     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);
diff --git a/src/multimedia/multimedia.pro b/src/multimedia/multimedia.pro
index 93da612..852322d 100644
--- a/src/multimedia/multimedia.pro
+++ b/src/multimedia/multimedia.pro
@@ -13,7 +13,4 @@ include(video/video.pri)
 
 symbian: {
     TARGET.UID3 = 0x2001E627
-    contains(CONFIG, def_files) {
-        DEF_FILE=../../s60installs
-    }
 }
diff --git a/src/network/access/qnetworkaccessmanager.cpp b/src/network/access/qnetworkaccessmanager.cpp
index 42c64fb..837cf66 100644
--- a/src/network/access/qnetworkaccessmanager.cpp
+++ b/src/network/access/qnetworkaccessmanager.cpp
@@ -464,6 +464,15 @@ QNetworkAccessManager::~QNetworkAccessManager()
 #ifndef QT_NO_NETWORKPROXY
     delete d_func()->proxyFactory;
 #endif
+
+    // Delete the QNetworkReply children first.
+    // Else a QAbstractNetworkCache might get deleted in ~QObject
+    // before a QNetworkReply that accesses the QAbstractNetworkCache
+    // object in its destructor.
+    qDeleteAll(findChildren<QNetworkReply *>());
+    // The other children will be deleted in this ~QObject
+    // FIXME instead of this "hack" make the QNetworkReplyImpl
+    // properly watch the cache deletion, e.g. via a QWeakPointer.
 }
 
 #ifndef QT_NO_NETWORKPROXY
diff --git a/src/network/access/qnetworkcookie.cpp b/src/network/access/qnetworkcookie.cpp
index 865d338..d1bdd57 100644
--- a/src/network/access/qnetworkcookie.cpp
+++ b/src/network/access/qnetworkcookie.cpp
@@ -991,6 +991,8 @@ QList<QNetworkCookie> QNetworkCookiePrivate::parseSetCookieHeaderLine(const QByt
                     }
 
                     QString normalizedDomain = QUrl::fromAce(QUrl::toAce(QString::fromUtf8(rawDomain)));
+                    if (normalizedDomain.isEmpty() && !rawDomain.isEmpty())
+                        return result;
                     cookie.setDomain(maybeLeadingDot + normalizedDomain);
                 } else if (field.first == "max-age") {
                     bool ok = false;
diff --git a/src/network/bearer/qnetworkconfigmanager_p.cpp b/src/network/bearer/qnetworkconfigmanager_p.cpp
index 471927a..5d4274f 100644
--- a/src/network/bearer/qnetworkconfigmanager_p.cpp
+++ b/src/network/bearer/qnetworkconfigmanager_p.cpp
@@ -483,8 +483,10 @@ void QNetworkConfigurationManagerPrivate::pollEngines()
     QMutexLocker locker(&mutex);
 
     for (int i = 0; i < sessionEngines.count(); ++i) {
-        if ((forcedPolling && sessionEngines.at(i)->requiresPolling()) ||
-            sessionEngines.at(i)->configurationsInUse()) {
+        if (!sessionEngines.at(i)->requiresPolling())
+            continue;
+
+        if (forcedPolling || sessionEngines.at(i)->configurationsInUse()) {
             pollingEngines.insert(i);
             QMetaObject::invokeMethod(sessionEngines.at(i), "requestUpdate");
         }
diff --git a/src/network/ssl/qsslcertificate.cpp b/src/network/ssl/qsslcertificate.cpp
index fd647e2..31c5ed1 100644
--- a/src/network/ssl/qsslcertificate.cpp
+++ b/src/network/ssl/qsslcertificate.cpp
@@ -259,13 +259,28 @@ QByteArray QSslCertificate::version() const
 
 /*!
     Returns the certificate's serial number string in decimal format.
+    In case the serial number cannot be converted to decimal format
+    (i.e. if it is bigger than 4294967295, which means it does not fit into 4 bytes),
+    its hexadecimal version is returned.
 */
 QByteArray QSslCertificate::serialNumber() const
 {
-    if (d->serialNumberString.isEmpty() && d->x509)
-        d->serialNumberString =
-            QByteArray::number(qlonglong(q_ASN1_INTEGER_get(d->x509->cert_info->serialNumber)));
-
+    if (d->serialNumberString.isEmpty() && d->x509) {
+        ASN1_INTEGER *serialNumber = d->x509->cert_info->serialNumber;
+        // if we cannot convert to a long, just output the hexadecimal number
+        if (serialNumber->length > 4) {
+            QByteArray hexString;
+            hexString.reserve(serialNumber->length * 3);
+            for (int a = 0; a < serialNumber->length; ++a) {
+                hexString += QByteArray::number(serialNumber->data[a], 16).rightJustified(2, '0');
+                hexString += ':';
+            }
+            hexString.chop(1);
+            d->serialNumberString = hexString;
+        } else {
+            d->serialNumberString = QByteArray::number(qlonglong(q_ASN1_INTEGER_get(serialNumber)));
+        }
+    }
     return d->serialNumberString;
 }
 
diff --git a/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp b/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
index 5758b25..ee49a3d 100644
--- a/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
+++ b/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
@@ -1333,8 +1333,16 @@ void QGL2PaintEngineEx::drawStaticTextItem(QStaticTextItem *textItem)
     QFontEngineGlyphCache::Type glyphType = textItem->fontEngine->glyphFormat >= 0
                                             ? QFontEngineGlyphCache::Type(textItem->fontEngine->glyphFormat)
                                             : d->glyphCacheType;
+    if (glyphType == QFontEngineGlyphCache::Raster_RGBMask) {
+        if (d->device->alphaRequested() || state()->matrix.type() > QTransform::TxTranslate
+            || (state()->composition_mode != QPainter::CompositionMode_Source
+            && state()->composition_mode != QPainter::CompositionMode_SourceOver))
+        {
+            glyphType = QFontEngineGlyphCache::Raster_A8;
+        }
+    }
 
-    d->drawCachedGlyphs(glyphType, textItem, true);
+    d->drawCachedGlyphs(glyphType, textItem);
 }
 
 bool QGL2PaintEngineEx::drawTexture(const QRectF &dest, GLuint textureId, const QSize &size, const QRectF &src)
@@ -1408,7 +1416,7 @@ void QGL2PaintEngineEx::drawTextItem(const QPointF &p, const QTextItem &textItem
             staticTextItem.numGlyphs = glyphs.size();
             staticTextItem.glyphPositions = positions.data();
 
-            d->drawCachedGlyphs(glyphType, &staticTextItem, false);
+            d->drawCachedGlyphs(glyphType, &staticTextItem);
         }
         return;
     }
@@ -1439,21 +1447,16 @@ namespace {
 // #define QT_OPENGL_DRAWCACHEDGLYPHS_INDEX_ARRAY_VBO
 
 void QGL2PaintEngineExPrivate::drawCachedGlyphs(QFontEngineGlyphCache::Type glyphType,
-                                                QStaticTextItem *staticTextItem,
-                                                bool includeMatrixInCache)
+                                                QStaticTextItem *staticTextItem)
 {
     Q_Q(QGL2PaintEngineEx);
 
     QOpenGL2PaintEngineState *s = q->state();
 
     QGLTextureGlyphCache *cache =
-        (QGLTextureGlyphCache *) staticTextItem->fontEngine->glyphCache(ctx, glyphType,
-                                                                        includeMatrixInCache
-                                                                          ? s->matrix
-                                                                          : QTransform());
+        (QGLTextureGlyphCache *) staticTextItem->fontEngine->glyphCache(ctx, glyphType, QTransform());
     if (!cache || cache->cacheType() != glyphType) {
-        cache = new QGLTextureGlyphCache(ctx, glyphType,
-                                         includeMatrixInCache ? s->matrix : QTransform());
+        cache = new QGLTextureGlyphCache(ctx, glyphType, QTransform());
         staticTextItem->fontEngine->setGlyphCache(ctx, cache);
     }
 
@@ -1561,13 +1564,6 @@ void QGL2PaintEngineExPrivate::drawCachedGlyphs(QFontEngineGlyphCache::Type glyp
     QBrush pensBrush = q->state()->pen.brush();
     setBrush(pensBrush);
 
-    // When painting a QStaticTextItem, the glyph positions are already in device coordinates,
-    // therefore we temporarily set an identity matrix on the painter for the draw call to
-    // avoid transforming the positions twice.
-    QTransform old = s->matrix;
-    if (includeMatrixInCache)
-        s->matrix = QTransform();
-
     if (glyphType == QFontEngineGlyphCache::Raster_RGBMask) {
 
         // Subpixel antialiasing without gamma correction
@@ -1664,9 +1660,6 @@ void QGL2PaintEngineExPrivate::drawCachedGlyphs(QFontEngineGlyphCache::Type glyp
 #else
     glDrawElements(GL_TRIANGLE_STRIP, 6 * staticTextItem->numGlyphs, GL_UNSIGNED_SHORT, elementIndices.data());
 #endif
-
-    if (includeMatrixInCache)
-        s->matrix = old;
 }
 
 void QGL2PaintEngineEx::drawPixmapFragments(const QPainter::PixmapFragment *fragments, int fragmentCount, const QPixmap &pixmap,
diff --git a/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h b/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h
index 0a046dc..59b90d8 100644
--- a/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h
+++ b/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h
@@ -202,8 +202,7 @@ public:
     void drawTexture(const QGLRect& dest, const QGLRect& src, const QSize &textureSize, bool opaque, bool pattern = false);
     void drawPixmapFragments(const QPainter::PixmapFragment *fragments, int fragmentCount, const QPixmap &pixmap,
                              QPainter::PixmapFragmentHints hints);
-    void drawCachedGlyphs(QFontEngineGlyphCache::Type glyphType, QStaticTextItem *staticTextItem,
-                          bool includeMatrixInCache);
+    void drawCachedGlyphs(QFontEngineGlyphCache::Type glyphType, QStaticTextItem *staticTextItem);
 
     // Calls glVertexAttributePointer if the pointer has changed
     inline void setVertexAttributePointer(unsigned int arrayIndex, const GLfloat *pointer);
diff --git a/src/opengl/gl2paintengineex/qtextureglyphcache_gl.cpp b/src/opengl/gl2paintengineex/qtextureglyphcache_gl.cpp
index 410cf21..5371c5e 100644
--- a/src/opengl/gl2paintengineex/qtextureglyphcache_gl.cpp
+++ b/src/opengl/gl2paintengineex/qtextureglyphcache_gl.cpp
@@ -276,6 +276,11 @@ void QGLTextureGlyphCache::fillTexture(const Coord &c, glyph_t glyph)
     }
 }
 
+int QGLTextureGlyphCache::glyphMargin() const
+{
+    return 1;
+}
+
 int QGLTextureGlyphCache::glyphPadding() const
 {
     return 1;
diff --git a/src/opengl/gl2paintengineex/qtextureglyphcache_gl_p.h b/src/opengl/gl2paintengineex/qtextureglyphcache_gl_p.h
index 6bcd655..84e9021 100644
--- a/src/opengl/gl2paintengineex/qtextureglyphcache_gl_p.h
+++ b/src/opengl/gl2paintengineex/qtextureglyphcache_gl_p.h
@@ -72,6 +72,7 @@ public:
     virtual void createTextureData(int width, int height);
     virtual void resizeTextureData(int width, int height);
     virtual void fillTexture(const Coord &c, glyph_t glyph);
+    virtual int glyphMargin() const;
     virtual int glyphPadding() const;
 
     inline GLuint texture() const { return m_texture; }
diff --git a/src/opengl/qgl.cpp b/src/opengl/qgl.cpp
index 922a96c..5c5d3d1 100644
--- a/src/opengl/qgl.cpp
+++ b/src/opengl/qgl.cpp
@@ -91,6 +91,7 @@
 #include "qcolormap.h"
 #include "qfile.h"
 #include "qlibrary.h"
+#include <qmutex.h>
 
 
 QT_BEGIN_NAMESPACE
@@ -1255,6 +1256,8 @@ QGLFormat::OpenGLVersionFlags Q_AUTOTEST_EXPORT qOpenGLVersionFlagsFromString(co
                             QGLFormat::OpenGL_Version_2_1 |
                             QGLFormat::OpenGL_Version_3_0;
             switch (versionString[2].toAscii()) {
+            case '3':
+                versionFlags |= QGLFormat::OpenGL_Version_3_3;
             case '2':
                 versionFlags |= QGLFormat::OpenGL_Version_3_2;
             case '1':
@@ -1263,9 +1266,23 @@ QGLFormat::OpenGLVersionFlags Q_AUTOTEST_EXPORT qOpenGLVersionFlagsFromString(co
                 break;
             default:
                 versionFlags |= QGLFormat::OpenGL_Version_3_1 |
-                                QGLFormat::OpenGL_Version_3_2;
+                                QGLFormat::OpenGL_Version_3_2 |
+                                QGLFormat::OpenGL_Version_3_3;
                 break;
             }
+        } else if (versionString.startsWith(QLatin1String("4."))) {
+            versionFlags |= QGLFormat::OpenGL_Version_1_1 |
+                            QGLFormat::OpenGL_Version_1_2 |
+                            QGLFormat::OpenGL_Version_1_3 |
+                            QGLFormat::OpenGL_Version_1_4 |
+                            QGLFormat::OpenGL_Version_1_5 |
+                            QGLFormat::OpenGL_Version_2_0 |
+                            QGLFormat::OpenGL_Version_2_1 |
+                            QGLFormat::OpenGL_Version_3_0 |
+                            QGLFormat::OpenGL_Version_3_1 |
+                            QGLFormat::OpenGL_Version_3_2 |
+                            QGLFormat::OpenGL_Version_3_3 |
+                            QGLFormat::OpenGL_Version_4_0;
         } else {
             versionFlags |= QGLFormat::OpenGL_Version_1_1 |
                             QGLFormat::OpenGL_Version_1_2 |
@@ -1276,7 +1293,9 @@ QGLFormat::OpenGLVersionFlags Q_AUTOTEST_EXPORT qOpenGLVersionFlagsFromString(co
                             QGLFormat::OpenGL_Version_2_1 |
                             QGLFormat::OpenGL_Version_3_0 |
                             QGLFormat::OpenGL_Version_3_1 |
-                            QGLFormat::OpenGL_Version_3_2;
+                            QGLFormat::OpenGL_Version_3_2 |
+                            QGLFormat::OpenGL_Version_3_3 |
+                            QGLFormat::OpenGL_Version_4_0;
         }
     }
     return versionFlags;
@@ -1515,10 +1534,33 @@ bool operator!=(const QGLFormat& a, const QGLFormat& b)
     return !(a == b);
 }
 
+struct QGLContextGroupList {
+    void append(QGLContextGroup *group) {
+        QMutexLocker locker(&m_mutex);
+        m_list.append(group);
+    }
+
+    void remove(QGLContextGroup *group) {
+        QMutexLocker locker(&m_mutex);
+        m_list.removeOne(group);
+    }
+
+    QList<QGLContextGroup *> m_list;
+    QMutex m_mutex;
+};
+
+Q_GLOBAL_STATIC(QGLContextGroupList, qt_context_groups)
+
 /*****************************************************************************
   QGLContext implementation
  *****************************************************************************/
 
+QGLContextGroup::QGLContextGroup(const QGLContext *context)
+    : m_context(context), m_guards(0), m_refs(1)
+{
+    qt_context_groups()->append(this);
+}
+
 QGLContextGroup::~QGLContextGroup()
 {
     // Clear any remaining QGLSharedResourceGuard objects on the group.
@@ -1528,6 +1570,7 @@ QGLContextGroup::~QGLContextGroup()
         guard->m_id = 0;
         guard = guard->m_next;
     }
+    qt_context_groups()->remove(this);
 }
 
 void QGLContextGroup::addGuard(QGLSharedResourceGuard *guard)
@@ -1736,7 +1779,7 @@ void QGLTextureCache::insert(QGLContext* ctx, qint64 key, QGLTexture* texture, i
     QWriteLocker locker(&m_lock);
     if (m_cache.totalCost() + cost > m_cache.maxCost()) {
         // the cache is full - make an attempt to remove something
-        const QList<qint64> keys = m_cache.keys();
+        const QList<QGLTextureCacheKey> keys = m_cache.keys();
         int i = 0;
         while (i < m_cache.count()
                && (m_cache.totalCost() + cost > m_cache.maxCost())) {
@@ -1746,13 +1789,26 @@ void QGLTextureCache::insert(QGLContext* ctx, qint64 key, QGLTexture* texture, i
             ++i;
         }
     }
-    m_cache.insert(key, texture, cost);
+    const QGLTextureCacheKey cacheKey = {key, QGLContextPrivate::contextGroup(ctx)};
+    m_cache.insert(cacheKey, texture, cost);
+}
+
+void QGLTextureCache::remove(qint64 key)
+{
+    QWriteLocker locker(&m_lock);
+    QMutexLocker groupLocker(&qt_context_groups()->m_mutex);
+    QList<QGLContextGroup *>::const_iterator it = qt_context_groups()->m_list.constBegin();
+    while (it != qt_context_groups()->m_list.constEnd()) {
+        const QGLTextureCacheKey cacheKey = {key, *it};
+        m_cache.remove(cacheKey);
+        ++it;
+    }
 }
 
 bool QGLTextureCache::remove(QGLContext* ctx, GLuint textureId)
 {
     QWriteLocker locker(&m_lock);
-    QList<qint64> keys = m_cache.keys();
+    QList<QGLTextureCacheKey> keys = m_cache.keys();
     for (int i = 0; i < keys.size(); ++i) {
         QGLTexture *tex = m_cache.object(keys.at(i));
         if (tex->id == textureId && tex->context == ctx) {
@@ -1767,9 +1823,9 @@ bool QGLTextureCache::remove(QGLContext* ctx, GLuint textureId)
 void QGLTextureCache::removeContextTextures(QGLContext* ctx)
 {
     QWriteLocker locker(&m_lock);
-    QList<qint64> keys = m_cache.keys();
+    QList<QGLTextureCacheKey> keys = m_cache.keys();
     for (int i = 0; i < keys.size(); ++i) {
-        const qint64 &key = keys.at(i);
+        const QGLTextureCacheKey &key = keys.at(i);
         if (m_cache.object(key)->context == ctx)
             m_cache.remove(key);
     }
@@ -1782,7 +1838,6 @@ void QGLTextureCache::removeContextTextures(QGLContext* ctx)
 void QGLTextureCache::cleanupTexturesForCacheKey(qint64 cacheKey)
 {
     qt_gl_texture_cache()->remove(cacheKey);
-    Q_ASSERT(qt_gl_texture_cache()->getTexture(cacheKey) == 0);
 }
 
 
@@ -2425,7 +2480,7 @@ QGLTexture* QGLContextPrivate::bindTexture(const QImage &image, GLenum target, G
 QGLTexture *QGLContextPrivate::textureCacheLookup(const qint64 key, GLenum target)
 {
     Q_Q(QGLContext);
-    QGLTexture *texture = QGLTextureCache::instance()->getTexture(key);
+    QGLTexture *texture = QGLTextureCache::instance()->getTexture(q, key);
     if (texture && texture->target == target
         && (texture->context == q || QGLContext::areSharing(q, texture->context)))
     {
diff --git a/src/opengl/qgl.h b/src/opengl/qgl.h
index f297009..f0b36f7 100644
--- a/src/opengl/qgl.h
+++ b/src/opengl/qgl.h
@@ -266,7 +266,9 @@ public:
         OpenGL_ES_Version_2_0             = 0x00000800,
         OpenGL_Version_3_0                = 0x00001000,
         OpenGL_Version_3_1                = 0x00002000,
-        OpenGL_Version_3_2                = 0x00004000
+        OpenGL_Version_3_2                = 0x00004000,
+        OpenGL_Version_3_3                = 0x00008000,
+        OpenGL_Version_4_0                = 0x00010000
     };
     Q_DECLARE_FLAGS(OpenGLVersionFlags, OpenGLVersionFlag)
 
diff --git a/src/opengl/qgl_p.h b/src/opengl/qgl_p.h
index d92f963..16c225f 100644
--- a/src/opengl/qgl_p.h
+++ b/src/opengl/qgl_p.h
@@ -230,7 +230,7 @@ public:
     static void addShare(const QGLContext *context, const QGLContext *share);
     static void removeShare(const QGLContext *context);
 private:
-    QGLContextGroup(const QGLContext *context) : m_context(context), m_guards(0), m_refs(1) { }
+    QGLContextGroup(const QGLContext *context);
 
     QGLExtensionFuncs m_extensionFuncs;
     const QGLContext *m_context; // context group's representative
@@ -522,17 +522,33 @@ public:
     QSize bindCompressedTexturePVR(const char *buf, int len);
 };
 
+struct QGLTextureCacheKey {
+    qint64 key;
+    QGLContextGroup *group;
+};
+
+inline bool operator==(const QGLTextureCacheKey &a, const QGLTextureCacheKey &b)
+{
+    return a.key == b.key && a.group == b.group;
+}
+
+inline uint qHash(const QGLTextureCacheKey &key)
+{
+    return qHash(key.key) ^ qHash(key.group);
+}
+
+
 class Q_AUTOTEST_EXPORT QGLTextureCache {
 public:
     QGLTextureCache();
     ~QGLTextureCache();
 
     void insert(QGLContext *ctx, qint64 key, QGLTexture *texture, int cost);
-    inline void remove(quint64 key);
+    void remove(qint64 key);
     inline int size();
     inline void setMaxCost(int newMax);
     inline int maxCost();
-    inline QGLTexture* getTexture(quint64 key);
+    inline QGLTexture* getTexture(QGLContext *ctx, qint64 key);
 
     bool remove(QGLContext *ctx, GLuint textureId);
     void removeContextTextures(QGLContext *ctx);
@@ -542,7 +558,7 @@ public:
     static void cleanupBeforePixmapDestruction(QPixmapData* pixmap);
 
 private:
-    QCache<qint64, QGLTexture> m_cache;
+    QCache<QGLTextureCacheKey, QGLTexture> m_cache;
     QReadWriteLock m_lock;
 };
 
@@ -563,19 +579,13 @@ int QGLTextureCache::maxCost()
     return m_cache.maxCost();
 }
 
-QGLTexture* QGLTextureCache::getTexture(quint64 key)
+QGLTexture* QGLTextureCache::getTexture(QGLContext *ctx, qint64 key)
 {
     QReadLocker locker(&m_lock);
-    return m_cache.object(key);
+    const QGLTextureCacheKey cacheKey = {key, QGLContextPrivate::contextGroup(ctx)};
+    return m_cache.object(cacheKey);
 }
 
-void QGLTextureCache::remove(quint64 key)
-{
-    QWriteLocker locker(&m_lock);
-    m_cache.remove(key);
-}
-
-
 extern Q_OPENGL_EXPORT QPaintEngine* qt_qgl_paint_engine();
 
 bool qt_gl_preferGL2Engine();
diff --git a/src/opengl/qgl_x11.cpp b/src/opengl/qgl_x11.cpp
index d203646..3e71a48 100644
--- a/src/opengl/qgl_x11.cpp
+++ b/src/opengl/qgl_x11.cpp
@@ -115,6 +115,20 @@ extern const QX11Info *qt_x11Info(const QPaintDevice *pd);
 #define GLX_FRONT_LEFT_EXT                 0x20DE
 #endif
 
+#ifndef GLX_ARB_create_context
+#define GLX_CONTEXT_DEBUG_BIT_ARB          0x00000001
+#define GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x00000002
+#define GLX_CONTEXT_MAJOR_VERSION_ARB      0x2091
+#define GLX_CONTEXT_MINOR_VERSION_ARB      0x2092
+#define GLX_CONTEXT_FLAGS_ARB              0x2094
+#endif
+
+#ifndef GLX_ARB_create_context_profile
+#define GLX_CONTEXT_CORE_PROFILE_BIT_ARB   0x00000001
+#define GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
+#define GLX_CONTEXT_PROFILE_MASK_ARB       0x9126
+#endif
+
 /*
   The qt_gl_choose_cmap function is internal and used by QGLWidget::setContext()
   and GLX (not Windows).  If the application can't find any sharable
@@ -401,6 +415,148 @@ bool QGLFormat::hasOpenGLOverlays()
     return trans_colors.size() > 0;
 }
 
+static bool buildSpec(int* spec, const QGLFormat& f, QPaintDevice* paintDevice,
+                      int bufDepth, bool onlyFBConfig = false)
+{
+    int i = 0;
+    spec[i++] = GLX_LEVEL;
+    spec[i++] = f.plane();
+    const QX11Info *xinfo = qt_x11Info(paintDevice);
+    bool useFBConfig = onlyFBConfig;
+
+#if defined(GLX_VERSION_1_3) && !defined(QT_NO_XRENDER) && !defined(Q_OS_HPUX)
+    /*
+      HPUX defines GLX_VERSION_1_3 but does not implement the corresponding functions.
+      Specifically glXChooseFBConfig and glXGetVisualFromFBConfig are not implemented.
+     */
+    QWidget* widget = 0;
+    if (paintDevice->devType() == QInternal::Widget)
+        widget = static_cast<QWidget*>(paintDevice);
+
+    // Only use glXChooseFBConfig for widgets if we're trying to get an ARGB visual
+    if (widget && widget->testAttribute(Qt::WA_TranslucentBackground) && X11->use_xrender)
+        useFBConfig = true;
+#endif
+
+#if defined(GLX_VERSION_1_1) && defined(GLX_EXT_visual_info)
+    static bool useTranspExt = false;
+    static bool useTranspExtChecked = false;
+    if (f.plane() && !useTranspExtChecked && paintDevice) {
+        QGLExtensionMatcher extensions(glXQueryExtensionsString(xinfo->display(), xinfo->screen()));
+        useTranspExt = extensions.match("GLX_EXT_visual_info");
+        //# (A bit simplistic; that could theoretically be a substring)
+        if (useTranspExt) {
+            QByteArray cstr(glXGetClientString(xinfo->display(), GLX_VENDOR));
+            useTranspExt = !cstr.contains("Xi Graphics"); // bug workaround
+            if (useTranspExt) {
+                // bug workaround - some systems (eg. FireGL) refuses to return an overlay
+                // visual if the GLX_TRANSPARENT_TYPE_EXT attribute is specified, even if
+                // the implementation supports transparent overlays
+                int tmpSpec[] = { GLX_LEVEL, f.plane(), GLX_TRANSPARENT_TYPE_EXT,
+                                  f.rgba() ? GLX_TRANSPARENT_RGB_EXT : GLX_TRANSPARENT_INDEX_EXT,
+                                  XNone };
+                XVisualInfo * vinf = glXChooseVisual(xinfo->display(), xinfo->screen(), tmpSpec);
+                if (!vinf) {
+                    useTranspExt = false;
+                }
+            }
+        }
+
+        useTranspExtChecked = true;
+    }
+    if (f.plane() && useTranspExt && !useFBConfig) {
+        // Required to avoid non-transparent overlay visual(!) on some systems
+        spec[i++] = GLX_TRANSPARENT_TYPE_EXT;
+        spec[i++] = f.rgba() ? GLX_TRANSPARENT_RGB_EXT : GLX_TRANSPARENT_INDEX_EXT;
+    }
+#endif
+
+#if defined(GLX_VERSION_1_3)  && !defined(Q_OS_HPUX)
+    // GLX_RENDER_TYPE is only in glx >=1.3
+    if (useFBConfig) {
+        spec[i++] = GLX_RENDER_TYPE;
+        spec[i++] = f.rgba() ? GLX_RGBA_BIT : GLX_COLOR_INDEX_BIT;
+    }
+#endif
+
+    if (f.doubleBuffer())
+        spec[i++] = GLX_DOUBLEBUFFER;
+        if (useFBConfig)
+            spec[i++] = True;
+    if (f.depth()) {
+        spec[i++] = GLX_DEPTH_SIZE;
+        spec[i++] = f.depthBufferSize() == -1 ? 1 : f.depthBufferSize();
+    }
+    if (f.stereo()) {
+        spec[i++] = GLX_STEREO;
+        if (useFBConfig)
+            spec[i++] = True;
+    }
+    if (f.stencil()) {
+        spec[i++] = GLX_STENCIL_SIZE;
+        spec[i++] = f.stencilBufferSize() == -1 ? 1 : f.stencilBufferSize();
+    }
+    if (f.rgba()) {
+        if (!useFBConfig)
+            spec[i++] = GLX_RGBA;
+        spec[i++] = GLX_RED_SIZE;
+        spec[i++] = f.redBufferSize() == -1 ? 1 : f.redBufferSize();
+        spec[i++] = GLX_GREEN_SIZE;
+        spec[i++] = f.greenBufferSize() == -1 ? 1 : f.greenBufferSize();
+        spec[i++] = GLX_BLUE_SIZE;
+        spec[i++] = f.blueBufferSize() == -1 ? 1 : f.blueBufferSize();
+        if (f.alpha()) {
+            spec[i++] = GLX_ALPHA_SIZE;
+            spec[i++] = f.alphaBufferSize() == -1 ? 1 : f.alphaBufferSize();
+        }
+        if (f.accum()) {
+            spec[i++] = GLX_ACCUM_RED_SIZE;
+            spec[i++] = f.accumBufferSize() == -1 ? 1 : f.accumBufferSize();
+            spec[i++] = GLX_ACCUM_GREEN_SIZE;
+            spec[i++] = f.accumBufferSize() == -1 ? 1 : f.accumBufferSize();
+            spec[i++] = GLX_ACCUM_BLUE_SIZE;
+            spec[i++] = f.accumBufferSize() == -1 ? 1 : f.accumBufferSize();
+            if (f.alpha()) {
+                spec[i++] = GLX_ACCUM_ALPHA_SIZE;
+                spec[i++] = f.accumBufferSize() == -1 ? 1 : f.accumBufferSize();
+            }
+        }
+    } else {
+        spec[i++] = GLX_BUFFER_SIZE;
+        spec[i++] = bufDepth;
+    }
+
+    if (f.sampleBuffers()) {
+        spec[i++] = GLX_SAMPLE_BUFFERS_ARB;
+        spec[i++] = 1;
+        spec[i++] = GLX_SAMPLES_ARB;
+        spec[i++] = f.samples() == -1 ? 4 : f.samples();
+    }
+
+#if defined(GLX_VERSION_1_3) && !defined(Q_OS_HPUX)
+    if (useFBConfig) {
+        spec[i++] = GLX_DRAWABLE_TYPE;
+        switch(paintDevice->devType()) {
+        case QInternal::Pixmap:
+            spec[i++] = GLX_PIXMAP_BIT;
+            break;
+        case QInternal::Pbuffer:
+            spec[i++] = GLX_PBUFFER_BIT;
+            break;
+        default:
+            qWarning("QGLContext: Unknown paint device type %d", paintDevice->devType());
+            // Fall-through & assume it's a window
+        case QInternal::Widget:
+            spec[i++] = GLX_WINDOW_BIT;
+            break;
+        };
+    }
+#endif
+
+    spec[i] = XNone;
+    return useFBConfig;
+}
+
 /*****************************************************************************
   QGLContext UNIX/GLX-specific code
  *****************************************************************************/
@@ -493,21 +649,81 @@ bool QGLContext::chooseContext(const QGLContext* shareContext)
         shareContext = 0;
     }
 
+    const int major = d->reqFormat.majorVersion();
+    const int minor = d->reqFormat.minorVersion();
+    const int profile = d->reqFormat.profile() == QGLFormat::CompatibilityProfile
+        ? GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB
+        : GLX_CONTEXT_CORE_PROFILE_BIT_ARB;
+
     d->cx = 0;
-    if (shareContext) {
+
+#if defined(GLX_VERSION_1_3) && !defined(Q_OS_HPUX)
+    /*
+      HPUX defines GLX_VERSION_1_3 but does not implement the corresponding functions.
+      Specifically glXChooseFBConfig and glXGetVisualFromFBConfig are not implemented.
+     */
+    if ((major == 3 && minor >= 2) || major > 3) {
+        QGLTemporaryContext *tmpContext = 0;
+        if (!QGLContext::currentContext())
+            tmpContext = new QGLTemporaryContext;
+
+        int attributes[] = { GLX_CONTEXT_MAJOR_VERSION_ARB, major,
+                             GLX_CONTEXT_MINOR_VERSION_ARB, minor,
+                             GLX_CONTEXT_PROFILE_MASK_ARB, profile,
+                             0 };
+
+        PFNGLXCREATECONTEXTATTRIBSARBPROC glXCreateContextAttribs =
+            (PFNGLXCREATECONTEXTATTRIBSARBPROC) qglx_getProcAddress("glXCreateContextAttribsARB");
+
+        if (glXCreateContextAttribs) {
+            int spec[45];
+            glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_BUFFER_SIZE, &res);
+            buildSpec(spec, format(), d->paintDevice, res, true);
+
+            GLXFBConfig *configs;
+            int configCount = 0;
+            configs = glXChooseFBConfig(disp, xinfo->screen(), spec, &configCount);
+
+            if (configs && configCount > 0) {
+                d->cx = glXCreateContextAttribs(disp, configs[0],
+                    shareContext ? (GLXContext)shareContext->d_func()->cx : 0, direct, attributes);
+                if (!d->cx && shareContext) {
+                    shareContext = 0;
+                    d->cx = glXCreateContextAttribs(disp, configs[0], 0, direct, attributes);
+                }
+                d->screen = ((XVisualInfo*)d->vi)->screen;
+            }
+            XFree(configs);
+        } else {
+            qWarning("QGLContext::chooseContext(): OpenGL %d.%d is not supported", major, minor);
+        }
+
+        if (tmpContext)
+            delete tmpContext;
+    }
+#else
+    Q_UNUSED(major);
+    Q_UNUSED(minor);
+    Q_UNUSED(profile);
+#endif
+
+    if (!d->cx && shareContext) {
         d->cx = glXCreateContext(disp, (XVisualInfo *)d->vi,
                                (GLXContext)shareContext->d_func()->cx, direct);
         d->screen = ((XVisualInfo*)d->vi)->screen;
-        if (d->cx) {
-            QGLContext *share = const_cast<QGLContext *>(shareContext);
-            d->sharing = true;
-            share->d_func()->sharing = true;
-        }
     }
     if (!d->cx) {
         d->cx = glXCreateContext(disp, (XVisualInfo *)d->vi, NULL, direct);
         d->screen = ((XVisualInfo*)d->vi)->screen;
+        shareContext = 0;
+    }
+
+    if (shareContext && d->cx) {
+        QGLContext *share = const_cast<QGLContext *>(shareContext);
+        d->sharing = true;
+        share->d_func()->sharing = true;
     }
+
     if (!d->cx)
         return false;
     d->glFormat.setDirectRendering(glXIsDirect(disp, (GLXContext)d->cx));
@@ -606,143 +822,8 @@ void *QGLContext::tryVisual(const QGLFormat& f, int bufDepth)
 {
     Q_D(QGLContext);
     int spec[45];
-    int i = 0;
-    spec[i++] = GLX_LEVEL;
-    spec[i++] = f.plane();
     const QX11Info *xinfo = qt_x11Info(d->paintDevice);
-    bool useFBConfig = false;
-
-#if defined(GLX_VERSION_1_3) && !defined(QT_NO_XRENDER) && !defined(Q_OS_HPUX)
-    /*
-      HPUX defines GLX_VERSION_1_3 but does not implement the corresponding functions.
-      Specifically glXChooseFBConfig and glXGetVisualFromFBConfig are not implemented.
-     */
-    QWidget* widget = 0;
-    if (d->paintDevice->devType() == QInternal::Widget)
-        widget = static_cast<QWidget*>(d->paintDevice);
-
-    // Only use glXChooseFBConfig for widgets if we're trying to get an ARGB visual
-    if (widget && widget->testAttribute(Qt::WA_TranslucentBackground) && X11->use_xrender)
-        useFBConfig = true;
-#endif
-
-#if defined(GLX_VERSION_1_1) && defined(GLX_EXT_visual_info)
-    static bool useTranspExt = false;
-    static bool useTranspExtChecked = false;
-    if (f.plane() && !useTranspExtChecked && d->paintDevice) {
-        QGLExtensionMatcher extensions(glXQueryExtensionsString(xinfo->display(), xinfo->screen()));
-        useTranspExt = extensions.match("GLX_EXT_visual_info");
-        //# (A bit simplistic; that could theoretically be a substring)
-        if (useTranspExt) {
-            QByteArray cstr(glXGetClientString(xinfo->display(), GLX_VENDOR));
-            useTranspExt = !cstr.contains("Xi Graphics"); // bug workaround
-            if (useTranspExt) {
-                // bug workaround - some systems (eg. FireGL) refuses to return an overlay
-                // visual if the GLX_TRANSPARENT_TYPE_EXT attribute is specified, even if
-                // the implementation supports transparent overlays
-                int tmpSpec[] = { GLX_LEVEL, f.plane(), GLX_TRANSPARENT_TYPE_EXT,
-                                  f.rgba() ? GLX_TRANSPARENT_RGB_EXT : GLX_TRANSPARENT_INDEX_EXT,
-                                  XNone };
-                XVisualInfo * vinf = glXChooseVisual(xinfo->display(), xinfo->screen(), tmpSpec);
-                if (!vinf) {
-                    useTranspExt = false;
-                }
-            }
-        }
-
-        useTranspExtChecked = true;
-    }
-    if (f.plane() && useTranspExt && !useFBConfig) {
-        // Required to avoid non-transparent overlay visual(!) on some systems
-        spec[i++] = GLX_TRANSPARENT_TYPE_EXT;
-        spec[i++] = f.rgba() ? GLX_TRANSPARENT_RGB_EXT : GLX_TRANSPARENT_INDEX_EXT;
-    }
-#endif
-
-#if defined(GLX_VERSION_1_3)  && !defined(Q_OS_HPUX)
-    // GLX_RENDER_TYPE is only in glx >=1.3
-    if (useFBConfig) {
-        spec[i++] = GLX_RENDER_TYPE;
-        spec[i++] = f.rgba() ? GLX_RGBA_BIT : GLX_COLOR_INDEX_BIT;
-    }
-#endif
-
-    if (f.doubleBuffer())
-        spec[i++] = GLX_DOUBLEBUFFER;
-        if (useFBConfig)
-            spec[i++] = True;
-    if (f.depth()) {
-        spec[i++] = GLX_DEPTH_SIZE;
-        spec[i++] = f.depthBufferSize() == -1 ? 1 : f.depthBufferSize();
-    }
-    if (f.stereo()) {
-        spec[i++] = GLX_STEREO;
-        if (useFBConfig)
-            spec[i++] = True;
-    }
-    if (f.stencil()) {
-        spec[i++] = GLX_STENCIL_SIZE;
-        spec[i++] = f.stencilBufferSize() == -1 ? 1 : f.stencilBufferSize();
-    }
-    if (f.rgba()) {
-        if (!useFBConfig)
-            spec[i++] = GLX_RGBA;
-        spec[i++] = GLX_RED_SIZE;
-        spec[i++] = f.redBufferSize() == -1 ? 1 : f.redBufferSize();
-        spec[i++] = GLX_GREEN_SIZE;
-        spec[i++] = f.greenBufferSize() == -1 ? 1 : f.greenBufferSize();
-        spec[i++] = GLX_BLUE_SIZE;
-        spec[i++] = f.blueBufferSize() == -1 ? 1 : f.blueBufferSize();
-        if (f.alpha()) {
-            spec[i++] = GLX_ALPHA_SIZE;
-            spec[i++] = f.alphaBufferSize() == -1 ? 1 : f.alphaBufferSize();
-        }
-        if (f.accum()) {
-            spec[i++] = GLX_ACCUM_RED_SIZE;
-            spec[i++] = f.accumBufferSize() == -1 ? 1 : f.accumBufferSize();
-            spec[i++] = GLX_ACCUM_GREEN_SIZE;
-            spec[i++] = f.accumBufferSize() == -1 ? 1 : f.accumBufferSize();
-            spec[i++] = GLX_ACCUM_BLUE_SIZE;
-            spec[i++] = f.accumBufferSize() == -1 ? 1 : f.accumBufferSize();
-            if (f.alpha()) {
-                spec[i++] = GLX_ACCUM_ALPHA_SIZE;
-                spec[i++] = f.accumBufferSize() == -1 ? 1 : f.accumBufferSize();
-            }
-        }
-    } else {
-        spec[i++] = GLX_BUFFER_SIZE;
-        spec[i++] = bufDepth;
-    }
-
-    if (f.sampleBuffers()) {
-        spec[i++] = GLX_SAMPLE_BUFFERS_ARB;
-        spec[i++] = 1;
-        spec[i++] = GLX_SAMPLES_ARB;
-        spec[i++] = f.samples() == -1 ? 4 : f.samples();
-    }
-
-#if defined(GLX_VERSION_1_3) && !defined(Q_OS_HPUX)
-    if (useFBConfig) {
-        spec[i++] = GLX_DRAWABLE_TYPE;
-        switch(d->paintDevice->devType()) {
-        case QInternal::Pixmap:
-            spec[i++] = GLX_PIXMAP_BIT;
-            break;
-        case QInternal::Pbuffer:
-            spec[i++] = GLX_PBUFFER_BIT;
-            break;
-        default:
-            qWarning("QGLContext: Unknown paint device type %d", d->paintDevice->devType());
-            // Fall-through & assume it's a window
-        case QInternal::Widget:
-            spec[i++] = GLX_WINDOW_BIT;
-            break;
-        };
-    }
-#endif
-
-    spec[i] = XNone;
-
+    bool useFBConfig = buildSpec(spec, f, d->paintDevice, bufDepth, false);
 
     XVisualInfo* chosenVisualInfo = 0;
 
@@ -755,7 +836,7 @@ void *QGLContext::tryVisual(const QGLFormat& f, int bufDepth)
         if (!configs)
             break; // fallback to trying glXChooseVisual
 
-        for (i = 0; i < configCount; ++i) {
+        for (int i = 0; i < configCount; ++i) {
             XVisualInfo* vi;
             vi = glXGetVisualFromFBConfig(xinfo->display(), configs[i]);
             if (!vi)
@@ -1773,6 +1854,9 @@ QGLTexture *QGLContextPrivate::bindTextureFromNativePixmap(QPixmap *pixmap, cons
     glXBindTexImageEXT(x11Info.display(), (GLXPixmap)pixmapData->gl_surface, GLX_FRONT_LEFT_EXT, 0);
 
     glBindTexture(GL_TEXTURE_2D, textureId);
+    GLuint filtering = (options & QGLContext::LinearFilteringBindOption) ? GL_LINEAR : GL_NEAREST;
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filtering);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filtering);
 
     if (!((hasAlpha && RGBAConfigInverted) || (!hasAlpha && RGBConfigInverted)))
         options &= ~QGLContext::InvertedYBindOption;
diff --git a/src/opengl/qglframebufferobject.cpp b/src/opengl/qglframebufferobject.cpp
index 890b029..deffc20 100644
--- a/src/opengl/qglframebufferobject.cpp
+++ b/src/opengl/qglframebufferobject.cpp
@@ -1024,6 +1024,36 @@ QPaintEngine *QGLFramebufferObject::paintEngine() const
 }
 
 /*!
+    \fn bool QGLFramebufferObject::bindDefault()
+    \internal
+
+    Switches rendering back to the default, windowing system provided
+    framebuffer.
+    Returns true upon success, false otherwise.
+
+    \sa bind(), release()
+*/
+bool QGLFramebufferObject::bindDefault()
+{
+    QGLContext *ctx = const_cast<QGLContext *>(QGLContext::currentContext());
+
+    if (ctx) {
+        bool ext_detected = (QGLExtensions::glExtensions() & QGLExtensions::FramebufferObject);
+        if (!ext_detected || (ext_detected && !qt_resolve_framebufferobject_extensions(ctx)))
+            return false;
+
+        ctx->d_ptr->current_fbo = ctx->d_ptr->default_fbo;
+        glBindFramebuffer(GL_FRAMEBUFFER_EXT, ctx->d_ptr->default_fbo);
+#ifdef QT_DEBUG
+    } else {
+        qWarning("QGLFramebufferObject::bindDefault() called without current context.");
+#endif
+    }
+
+    return ctx != 0;
+}
+
+/*!
     \fn bool QGLFramebufferObject::hasOpenGLFramebufferObjects()
 
     Returns true if the OpenGL \c{GL_EXT_framebuffer_object} extension
diff --git a/src/opengl/qglframebufferobject.h b/src/opengl/qglframebufferobject.h
index 306b6ff..6ff6645 100644
--- a/src/opengl/qglframebufferobject.h
+++ b/src/opengl/qglframebufferobject.h
@@ -108,6 +108,8 @@ public:
     QPaintEngine *paintEngine() const;
     GLuint handle() const;
 
+    static bool bindDefault();
+
     static bool hasOpenGLFramebufferObjects();
 
     void drawTexture(const QRectF &target, GLuint textureId, GLenum textureTarget = GL_TEXTURE_2D);
diff --git a/src/openvg/qpaintengine_vg.cpp b/src/openvg/qpaintengine_vg.cpp
index 76a605a..4b22d5e 100644
--- a/src/openvg/qpaintengine_vg.cpp
+++ b/src/openvg/qpaintengine_vg.cpp
@@ -1622,11 +1622,48 @@ void QVGPaintEngine::clip(const QVectorPath &path, Qt::ClipOperation op)
         QRectF rect(points[0], points[1], points[2] - points[0],
                     points[5] - points[1]);
         clip(rect.toRect(), op);
-    } else {
-        // The best we can do is clip to the bounding rectangle
-        // of all control points.
-        clip(path.controlPointRect().toRect(), op);
+        return;
+    }
+
+    // Try converting the path into a QRegion that tightly follows
+    // the outline of the path we want to clip with.
+    QRegion region(path.convertToPainterPath().toFillPolygon(QTransform()).toPolygon());
+    switch (op) {
+        case Qt::NoClip:
+        {
+            region = defaultClipRegion();
+        }
+        break;
+
+        case Qt::ReplaceClip:
+        {
+            region = d->transform.map(region);
+        }
+        break;
+
+        case Qt::IntersectClip:
+        {
+            region = s->clipRegion.intersect(d->transform.map(region));
+        }
+        break;
+
+        case Qt::UniteClip:
+        {
+            region = s->clipRegion.unite(d->transform.map(region));
+        }
+        break;
     }
+    if (region.numRects() <= d->maxScissorRects) {
+        // We haven't reached the maximum scissor count yet, so we can
+        // still make use of this region.
+        s->clipRegion = region;
+        updateScissor();
+        return;
+    }
+
+    // The best we can do is clip to the bounding rectangle
+    // of all control points.
+    clip(path.controlPointRect().toRect(), op);
 }
 
 void QVGPaintEngine::clip(const QRect &rect, Qt::ClipOperation op)
diff --git a/src/plugins/bearer/symbian/qnetworksession_impl.cpp b/src/plugins/bearer/symbian/qnetworksession_impl.cpp
index 3cd18fb..e08d135 100644
--- a/src/plugins/bearer/symbian/qnetworksession_impl.cpp
+++ b/src/plugins/bearer/symbian/qnetworksession_impl.cpp
@@ -122,19 +122,10 @@ void QNetworkSessionPrivateImpl::configurationRemoved(QNetworkConfigurationPriva
     if (!publicConfig.isValid())
         return;
 
-    SymbianNetworkConfigurationPrivate *symbianConfig = toSymbianConfig(config);
-    
-    symbianConfig->mutex.lock();
-    TUint32 configNumericId = symbianConfig->numericId;
-    symbianConfig->mutex.unlock();
-
-    symbianConfig = toSymbianConfig(privateConfiguration(publicConfig));
-
-    symbianConfig->mutex.lock();
-    TUint32 publicNumericId = symbianConfig->numericId;
-    symbianConfig->mutex.unlock();
+    TUint32 publicNumericId =
+        toSymbianConfig(privateConfiguration(publicConfig))->numericIdentifier();
 
-    if (configNumericId == publicNumericId) {
+    if (toSymbianConfig(config)->numericIdentifier() == publicNumericId) {
 #ifdef QT_BEARERMGMT_SYMBIAN_DEBUG
         qDebug() << "QNS this : " << QString::number((uint)this) << " - "
                  << "configurationRemoved IAP: " << QString::number(publicNumericId) << " : going to State: Invalid";
@@ -380,13 +371,11 @@ void QNetworkSessionPrivateImpl::open()
                     SymbianNetworkConfigurationPrivate *symbianConfig =
                         toSymbianConfig(privateConfiguration(publicConfig));
 
-                    QMutexLocker configLocker(&symbianConfig->mutex);
-
-                    if (connInfo().iIapId == symbianConfig->numericId) {
+                    if (connInfo().iIapId == symbianConfig->numericIdentifier()) {
                         if (iConnection.Attach(connInfo, RConnection::EAttachTypeNormal) == KErrNone) {
                             activeConfig = publicConfig;
 #ifndef QT_NO_NETWORKINTERFACE
-                            activeInterface = interface(symbianConfig->numericId);
+                            activeInterface = interface(symbianConfig->numericIdentifier());
 #endif
                             connected = ETrue;
                             startTime = QDateTime::currentDateTime();
@@ -416,9 +405,7 @@ void QNetworkSessionPrivateImpl::open()
             TConnPrefList pref;
             TExtendedConnPref prefs;
 
-            symbianConfig->mutex.lock();
-            prefs.SetIapId(symbianConfig->numericId);
-            symbianConfig->mutex.unlock();
+            prefs.SetIapId(symbianConfig->numericIdentifier());
             if (iConnectInBackground) {
                 prefs.SetNoteBehaviour( TExtendedConnPref::ENoteBehaviourConnSilent );
             }
@@ -427,9 +414,7 @@ void QNetworkSessionPrivateImpl::open()
             TCommDbConnPref pref;
             pref.SetDialogPreference(ECommDbDialogPrefDoNotPrompt);
 
-            symbianConfig->mutex.lock();
-            pref.SetIapId(symbianConfig->numericId);
-            symbianConfig->mutex.unlock();
+            pref.SetIapId(symbianConfig->numericIdentifier());
 #endif
             iConnection.Start(pref, iStatus);
             if (!IsActive()) {
@@ -444,17 +429,13 @@ void QNetworkSessionPrivateImpl::open()
 #ifdef OCC_FUNCTIONALITY_AVAILABLE
         TConnPrefList snapPref;
         TExtendedConnPref prefs;
-        symbianConfig->mutex.lock();
-        prefs.SetSnapId(symbianConfig->numericId);
-        symbianConfig->mutex.unlock();
+        prefs.SetSnapId(symbianConfig->numericIdentifier());
         if (iConnectInBackground) {
             prefs.SetNoteBehaviour( TExtendedConnPref::ENoteBehaviourConnSilent );
         }
         snapPref.AppendL(&prefs);
 #else
-        symbianConfig->mutex.lock();
-        TConnSnapPref snapPref(symbianConfig->numericId);
-        symbianConfig->mutex.unlock();
+        TConnSnapPref snapPref(symbianConfig->numericIdentifier());
 #endif
         iConnection.Start(snapPref, iStatus);
         if (!IsActive()) {
@@ -592,10 +573,8 @@ void QNetworkSessionPrivateImpl::stop()
                 SymbianNetworkConfigurationPrivate *symbianConfig =
                     toSymbianConfig(privateConfiguration(publicConfig));
 
-                QMutexLocker configLocker(&symbianConfig->mutex);
-
                 // See if connection Id matches with our Id. If so, stop() it.
-                if (symbianConfig->connectionId == connectionId) {
+                if (symbianConfig->connectionIdentifier() == connectionId) {
                     ret = iConnectionMonitor.SetBoolAttribute(connectionId,
                                                               0, // subConnectionId don't care
                                                               KConnectionStop,
@@ -715,12 +694,8 @@ void QNetworkSessionPrivateImpl::PreferredCarrierAvailable(TAccessPointInfo aOld
             SymbianNetworkConfigurationPrivate *symbianConfig =
                 toSymbianConfig(privateConfiguration(configs[i]));
 
-            QMutexLocker configLocker(&symbianConfig->mutex);
-
-            if (symbianConfig->numericId == aNewAPInfo.AccessPoint()) {
-                configLocker.unlock();
+            if (symbianConfig->numericIdentifier() == aNewAPInfo.AccessPoint())
                 emit preferredConfigurationChanged(configs[i], aIsSeamless);
-            }
         }
     } else {
         migrate();
@@ -854,9 +829,7 @@ quint64 QNetworkSessionPrivateImpl::transferredData(TUint dataType) const
                         SymbianNetworkConfigurationPrivate *symbianConfig =
                             toSymbianConfig(privateConfiguration(configs[i]));
 
-                        QMutexLocker configLocker(&symbianConfig->mutex);
-
-                        if (symbianConfig->numericId == apId) {
+                        if (symbianConfig->numericIdentifier() == apId) {
                             configFound = true;
                             break;
                         }
@@ -865,10 +838,8 @@ quint64 QNetworkSessionPrivateImpl::transferredData(TUint dataType) const
                     SymbianNetworkConfigurationPrivate *symbianConfig =
                         toSymbianConfig(privateConfiguration(config));
 
-                    symbianConfig->mutex.lock();
-                    if (symbianConfig->numericId == apId)
+                    if (symbianConfig->numericIdentifier() == apId)
                         configFound = true;
-                    symbianConfig->mutex.unlock();
                 }
                 if (configFound) {
                     TUint tData;
@@ -908,8 +879,7 @@ QNetworkConfiguration QNetworkSessionPrivateImpl::activeConfiguration(TUint32 ia
             SymbianNetworkConfigurationPrivate *childConfig =
                 toSymbianConfig(privateConfiguration(children[i]));
 
-            QMutexLocker childLocker(&childConfig->mutex);
-            if (childConfig->numericId == iapId)
+            if (childConfig->numericIdentifier() == iapId)
                 return children[i];
         }
 
@@ -928,15 +898,11 @@ QNetworkConfiguration QNetworkSessionPrivateImpl::activeConfiguration(TUint32 ia
         SymbianNetworkConfigurationPrivate *symbianConfig =
             toSymbianConfig(privateConfiguration(pt));
         if (symbianConfig) {
-            QMutexLocker configLocker(&symbianConfig->mutex);
-
             for (int i=0; i < children.count(); i++) {
                 SymbianNetworkConfigurationPrivate *childConfig =
                     toSymbianConfig(privateConfiguration(children[i]));
 
-                QMutexLocker childLocker(&childConfig->mutex);
-
-                if (childConfig->mappingName == symbianConfig->mappingName) {
+                if (childConfig->configMappingName() == symbianConfig->configMappingName()) {
                     return children[i];
                 }
             }
@@ -1034,15 +1000,13 @@ void QNetworkSessionPrivateImpl::RunL()
             SymbianNetworkConfigurationPrivate *symbianConfig =
                 toSymbianConfig(privateConfiguration(activeConfig));
 
-            symbianConfig->mutex.lock();
 #ifndef QT_NO_NETWORKINTERFACE
-            activeInterface = interface(symbianConfig->numericId);
+            activeInterface = interface(symbianConfig->numericIdentifier());
 #endif
             if (publicConfig.type() == QNetworkConfiguration::UserChoice) {
                 serviceConfig = QNetworkConfigurationManager()
-                    .configurationFromIdentifier(symbianConfig->id);
+                    .configurationFromIdentifier(activeConfig.identifier());
             }
-            symbianConfig->mutex.unlock();
 
             startTime = QDateTime::currentDateTime();
 
@@ -1105,13 +1069,11 @@ bool QNetworkSessionPrivateImpl::newState(QNetworkSession::State newState, TUint
         newState == QNetworkSession::Connected) {
         activeConfig = activeConfiguration(accessPointId);
 
+#ifndef QT_NO_NETWORKINTERFACE
         SymbianNetworkConfigurationPrivate *symbianConfig =
             toSymbianConfig(privateConfiguration(activeConfig));
 
-#ifndef QT_NO_NETWORKINTERFACE
-        symbianConfig->mutex.lock();
-        activeInterface = interface(symbianConfig->numericId);
-        symbianConfig->mutex.unlock();
+        activeInterface = interface(symbianConfig->numericIdentifier());
 #endif
 
 #ifdef SNAP_FUNCTIONALITY_AVAILABLE
@@ -1187,10 +1149,7 @@ bool QNetworkSessionPrivateImpl::newState(QNetworkSession::State newState, TUint
             SymbianNetworkConfigurationPrivate *symbianConfig =
                 toSymbianConfig(privateConfiguration(publicConfig));
 
-            QMutexLocker configLocker(&symbianConfig->mutex);
-            if (symbianConfig->numericId == accessPointId) {
-                configLocker.unlock();
-
+            if (symbianConfig->numericIdentifier() == accessPointId) {
                 state = newState;
 #ifdef QT_BEARERMGMT_SYMBIAN_DEBUG
                 qDebug() << "QNS this : " << QString::number((uint)this) << " - " << "===> EMIT State changed B to: " << state;
@@ -1202,10 +1161,7 @@ bool QNetworkSessionPrivateImpl::newState(QNetworkSession::State newState, TUint
             SymbianNetworkConfigurationPrivate *symbianConfig =
                 toSymbianConfig(privateConfiguration(activeConfig));
 
-            QMutexLocker configLocker(&symbianConfig->mutex);
-            if (symbianConfig->numericId == accessPointId) {
-                configLocker.unlock();
-
+            if (symbianConfig->numericIdentifier() == accessPointId) {
                 state = newState;
 #ifdef QT_BEARERMGMT_SYMBIAN_DEBUG
                 qDebug() << "QNS this : " << QString::number((uint)this) << " - " << "===> EMIT State changed C to: " << state;
@@ -1219,9 +1175,7 @@ bool QNetworkSessionPrivateImpl::newState(QNetworkSession::State newState, TUint
                 SymbianNetworkConfigurationPrivate *symbianConfig =
                     toSymbianConfig(privateConfiguration(subConfigurations[i]));
 
-                QMutexLocker configLocker(&symbianConfig->mutex);
-
-                if (symbianConfig->numericId == accessPointId) {
+                if (symbianConfig->numericIdentifier() == accessPointId) {
                     if (newState != QNetworkSession::Disconnected) {
                         state = newState;
 #ifdef QT_BEARERMGMT_SYMBIAN_DEBUG
@@ -1234,8 +1188,6 @@ bool QNetworkSessionPrivateImpl::newState(QNetworkSession::State newState, TUint
                         if ((config.state() == QNetworkConfiguration::Defined) ||
                             (config.state() == QNetworkConfiguration::Discovered)) {
 
-                            configLocker.unlock();
-
                             state = newState;
 #ifdef QT_BEARERMGMT_SYMBIAN_DEBUG
                             qDebug() << "QNS this : " << QString::number((uint)this) << " - " << "===> EMIT State changed E  to: " << state;
@@ -1271,9 +1223,7 @@ bool QNetworkSessionPrivateImpl::newState(QNetworkSession::State newState, TUint
         SymbianNetworkConfigurationPrivate *symbianConfig =
             toSymbianConfig(privateConfiguration(publicConfig));
 
-        symbianConfig->mutex.lock();
-        iDeprecatedConnectionId = symbianConfig->connectionId;
-        symbianConfig->mutex.unlock();
+        iDeprecatedConnectionId = symbianConfig->connectionIdentifier();
     }
 
     return retVal;
@@ -1369,7 +1319,11 @@ void QNetworkSessionPrivateImpl::handleSymbianConnectionStatusChange(TInt aConne
             qDebug() << "QNS this : " << QString::number((uint)this) << " - " << "reporting disconnection to manager.";
 #endif
             if (publicConfig.isValid()) {
-                engine->configurationStateChangeReport(toSymbianConfig(privateConfiguration(publicConfig))->numericId, QNetworkSession::Disconnected);
+                SymbianNetworkConfigurationPrivate *symbianConfig =
+                    toSymbianConfig(privateConfiguration(publicConfig));
+
+                engine->configurationStateChangeReport(symbianConfig->numericIdentifier(),
+                                                       QNetworkSession::Disconnected);
             }
             break;
         // Unhandled state
diff --git a/src/plugins/bearer/symbian/symbianengine.cpp b/src/plugins/bearer/symbian/symbianengine.cpp
index cea8b67..ab1ba28 100644
--- a/src/plugins/bearer/symbian/symbianengine.cpp
+++ b/src/plugins/bearer/symbian/symbianengine.cpp
@@ -115,13 +115,18 @@ QString SymbianNetworkConfigurationPrivate::bearerName() const
 
 SymbianEngine::SymbianEngine(QObject *parent)
 :   QBearerEngine(parent), CActive(CActive::EPriorityIdle), iFirstUpdate(true), iInitOk(true),
-    iIgnoringUpdates(false), iTimeToWait(0), iIgnoreEventLoop(0)
+    iIgnoringUpdates(false)
 {
+}
+
+void SymbianEngine::initialize()
+{
+    QMutexLocker locker(&mutex);
+
     CActiveScheduler::Add(this);
 
     // Seed the randomgenerator
     qsrand(QTime(0,0,0).secsTo(QTime::currentTime()) + QCoreApplication::applicationPid());
-    iIgnoreEventLoop = new QEventLoop(this);
 
     TRAPD(error, ipCommsDB = CCommsDatabase::NewL(EDatabaseTypeIAP));
     if (error != KErrNone) {
@@ -132,18 +137,13 @@ SymbianEngine::SymbianEngine(QObject *parent)
     TRAP_IGNORE(iConnectionMonitor.ConnectL());
     TRAP_IGNORE(iConnectionMonitor.NotifyEventL(*this));
 
-#ifdef SNAP_FUNCTIONALITY_AVAILABLE    
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
     TRAP(error, iCmManager.OpenL());
     if (error != KErrNone) {
         iInitOk = false;
         return;
     }
 #endif
-}
-
-void SymbianEngine::initialize()
-{
-    QMutexLocker locker(&mutex);
 
     SymbianNetworkConfigurationPrivate *cpPriv = new SymbianNetworkConfigurationPrivate;
     cpPriv->name = "UserChoice";
@@ -238,19 +238,14 @@ void SymbianEngine::requestUpdate()
 
 void SymbianEngine::updateConfigurations()
 {
-    QMutexLocker locker(&mutex);
-
-    if (!iInitOk) {
+    if (!iInitOk)
         return;
-    }
 
     TRAP_IGNORE(updateConfigurationsL());
 }
 
 void SymbianEngine::updateConfigurationsL()
 {
-    QMutexLocker locker(&mutex);
-
     QList<QString> knownConfigs = accessPointConfigurations.keys();
     QList<QString> knownSnapConfigs = snapConfigurations.keys();
 
@@ -276,9 +271,9 @@ void SymbianEngine::updateConfigurationsL()
                 QNetworkConfigurationPrivatePointer ptr(cpPriv);
                 accessPointConfigurations.insert(ptr->id, ptr);
 
-                locker.unlock();
+                mutex.unlock();
                 emit configurationAdded(ptr);
-                locker.relock();
+                mutex.lock();
             }
         }
         CleanupStack::PopAndDestroy(&connectionMethod);
@@ -317,9 +312,9 @@ void SymbianEngine::updateConfigurationsL()
             QNetworkConfigurationPrivatePointer ptr(cpPriv);
             snapConfigurations.insert(ident, ptr);
 
-            locker.unlock();
+            mutex.unlock();
             emit configurationAdded(ptr);
-            locker.relock();
+            mutex.lock();
             
             CleanupStack::Pop(cpPriv);
         }
@@ -338,34 +333,35 @@ void SymbianEngine::updateConfigurationsL()
                 TRAP(error, cpPriv = configFromConnectionMethodL(connectionMethod));
                 if (error == KErrNone) {
                     QNetworkConfigurationPrivatePointer ptr(cpPriv);
-                    toSymbianConfig(ptr)->serviceNetworkPtr = privSNAP;
                     accessPointConfigurations.insert(ptr->id, ptr);
 
-                    locker.unlock();
+                    mutex.unlock();
                     emit configurationAdded(ptr);
-                    locker.relock();
+                    mutex.lock();
 
+                    QMutexLocker configLocker(&privSNAP->mutex);
                     privSNAP->serviceNetworkMembers.append(ptr);
                 }
             } else {
                 knownConfigs.removeOne(iface);
                 // Check that IAP can be found from related SNAP's configuration list
                 bool iapFound = false;
+                QMutexLocker snapConfigLocker(&privSNAP->mutex);
                 for (int i = 0; i < privSNAP->serviceNetworkMembers.count(); i++) {
-                    if (toSymbianConfig(privSNAP->serviceNetworkMembers[i])->numericId == iapId) {
+                    if (toSymbianConfig(privSNAP->serviceNetworkMembers[i])->numericIdentifier() ==
+                        iapId) {
                         iapFound = true;
                         break;
                     }
                 }
-                if (!iapFound) {
-                    toSymbianConfig(priv)->serviceNetworkPtr = privSNAP;
+                if (!iapFound)
                     privSNAP->serviceNetworkMembers.append(priv);
-                }
             }
             
             CleanupStack::PopAndDestroy(&connectionMethod);
         }
         
+        QMutexLocker snapConfigLocker(&privSNAP->mutex);
         if (privSNAP->serviceNetworkMembers.count() > 1) {
             // Roaming is supported only if SNAP contains more than one IAP
             privSNAP->roamingSupported = true;
@@ -393,9 +389,9 @@ void SymbianEngine::updateConfigurationsL()
                 QNetworkConfigurationPrivatePointer ptr(cpPriv);
                 accessPointConfigurations.insert(ident, ptr);
 
-                locker.unlock();
+                mutex.unlock();
                 emit configurationAdded(ptr);
-                locker.relock();
+                mutex.lock();
             } else {
                 delete cpPriv;
             }
@@ -410,17 +406,18 @@ void SymbianEngine::updateConfigurationsL()
         //remove non existing IAP
         QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.take(oldIface);
 
-        locker.unlock();
+        mutex.unlock();
         emit configurationRemoved(ptr);
-        locker.relock();
+        mutex.lock();
 
         // Remove non existing IAP from SNAPs
         foreach (const QString &iface, snapConfigurations.keys()) {
             QNetworkConfigurationPrivatePointer ptr2 = snapConfigurations.value(iface);
             // => Check if one of the IAPs of the SNAP is active
+            QMutexLocker snapConfigLocker(&ptr2->mutex);
             for (int i = 0; i < ptr2->serviceNetworkMembers.count(); ++i) {
-                if (toSymbianConfig(ptr2->serviceNetworkMembers[i])->numericId ==
-                    toSymbianConfig(ptr)->numericId) {
+                if (toSymbianConfig(ptr2->serviceNetworkMembers[i])->numericIdentifier() ==
+                    toSymbianConfig(ptr)->numericIdentifier()) {
                     ptr2->serviceNetworkMembers.removeAt(i);
                     break;
                 }
@@ -432,18 +429,21 @@ void SymbianEngine::updateConfigurationsL()
         //remove non existing SNAPs
         QNetworkConfigurationPrivatePointer ptr = snapConfigurations.take(oldIface);
 
-        locker.unlock();
+        mutex.unlock();
         emit configurationRemoved(ptr);
-        locker.relock();
+        mutex.lock();
     }
+
+    // find default configuration.
+    stopCommsDatabaseNotifications();
+    TRAP_IGNORE(defaultConfig = defaultConfigurationL());
+    startCommsDatabaseNotifications();
 }
 
 #ifdef SNAP_FUNCTIONALITY_AVAILABLE
 SymbianNetworkConfigurationPrivate *SymbianEngine::configFromConnectionMethodL(
         RCmConnectionMethod& connectionMethod)
 {
-    QMutexLocker locker(&mutex);
-
     SymbianNetworkConfigurationPrivate *cpPriv = new SymbianNetworkConfigurationPrivate;
     CleanupStack::PushL(cpPriv);
     
@@ -526,8 +526,6 @@ SymbianNetworkConfigurationPrivate *SymbianEngine::configFromConnectionMethodL(
 bool SymbianEngine::readNetworkConfigurationValuesFromCommsDb(
         TUint32 aApId, SymbianNetworkConfigurationPrivate *apNetworkConfiguration)
 {
-    QMutexLocker locker(&mutex);
-
     TRAPD(error, readNetworkConfigurationValuesFromCommsDbL(aApId,apNetworkConfiguration));
     if (error != KErrNone) {
         return false;        
@@ -538,8 +536,6 @@ bool SymbianEngine::readNetworkConfigurationValuesFromCommsDb(
 void SymbianEngine::readNetworkConfigurationValuesFromCommsDbL(
         TUint32 aApId, SymbianNetworkConfigurationPrivate *apNetworkConfiguration)
 {
-    QMutexLocker locker(&mutex);
-
     CApDataHandler* pDataHandler = CApDataHandler::NewLC(*ipCommsDB); 
     CApAccessPointItem* pAPItem = CApAccessPointItem::NewLC(); 
     TBuf<KCommsDbSvrMaxColumnNameLength> name;
@@ -602,15 +598,7 @@ QNetworkConfigurationPrivatePointer SymbianEngine::defaultConfiguration()
 {
     QMutexLocker locker(&mutex);
 
-    QNetworkConfigurationPrivatePointer ptr;
-
-    if (iInitOk) {
-        stopCommsDatabaseNotifications();
-        TRAP_IGNORE(ptr = defaultConfigurationL());
-        startCommsDatabaseNotifications();
-    }
-
-    return ptr;
+    return defaultConfig;
 }
 
 QStringList SymbianEngine::accessPointConfigurationIdentifiers()
@@ -622,8 +610,6 @@ QStringList SymbianEngine::accessPointConfigurationIdentifiers()
 
 QNetworkConfigurationPrivatePointer SymbianEngine::defaultConfigurationL()
 {
-    QMutexLocker locker(&mutex);
-
     QNetworkConfigurationPrivatePointer ptr;
 
 #ifdef SNAP_FUNCTIONALITY_AVAILABLE
@@ -639,18 +625,18 @@ QNetworkConfigurationPrivatePointer SymbianEngine::defaultConfigurationL()
     }
 #endif
     
-    if (!ptr || !ptr->isValid) {
-        QString iface = QString::number(qHash(KUserChoiceIAPId));
-        ptr = userChoiceConfigurations.value(iface);
+    if (ptr) {
+        QMutexLocker configLocker(&ptr->mutex);
+        if (ptr->isValid)
+            return ptr;
     }
-    
-    return ptr;
+
+    QString iface = QString::number(qHash(KUserChoiceIAPId));
+    return userChoiceConfigurations.value(iface);
 }
 
 void SymbianEngine::updateActiveAccessPoints()
 {
-    QMutexLocker locker(&mutex);
-
     bool online = false;
     QList<QString> inactiveConfigs = accessPointConfigurations.keys();
 
@@ -681,8 +667,9 @@ void SymbianEngine::updateActiveAccessPoints()
                     online = true;
                     inactiveConfigs.removeOne(ident);
 
-                    QMutexLocker configLocker(&ptr->mutex);
+                    ptr->mutex.lock();
                     toSymbianConfig(ptr)->connectionId = connectionId;
+                    ptr->mutex.unlock();
 
                     // Configuration is Active
                     changeConfigurationStateTo(ptr, QNetworkConfiguration::Active);
@@ -702,16 +689,14 @@ void SymbianEngine::updateActiveAccessPoints()
 
     if (iOnline != online) {
         iOnline = online;
-        locker.unlock();
+        mutex.unlock();
         emit this->onlineStateChanged(iOnline);
-        locker.relock();
+        mutex.lock();
     }
 }
 
 void SymbianEngine::updateAvailableAccessPoints()
 {
-    QMutexLocker locker(&mutex);
-
     if (!ipAccessPointsAvailabilityScanner) {
         ipAccessPointsAvailabilityScanner = new AccessPointsAvailabilityScanner(*this, iConnectionMonitor);
     }
@@ -723,8 +708,6 @@ void SymbianEngine::updateAvailableAccessPoints()
 
 void SymbianEngine::accessPointScanningReady(TBool scanSuccessful, TConnMonIapInfo iapInfo)
 {
-    QMutexLocker locker(&mutex);
-
     iUpdateGoingOn = false;
     if (scanSuccessful) {
         QList<QString> unavailableConfigs = accessPointConfigurations.keys();
@@ -736,6 +719,8 @@ void SymbianEngine::accessPointScanningReady(TBool scanSuccessful, TConnMonIapIn
             QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(ident);
             if (ptr) {
                 unavailableConfigs.removeOne(ident);
+
+                QMutexLocker configLocker(&ptr->mutex);
                 if (ptr->state < QNetworkConfiguration::Active) {
                     // Configuration is either Discovered or Active
                     changeConfigurationStateAtMinTo(ptr, QNetworkConfiguration::Discovered);
@@ -757,25 +742,28 @@ void SymbianEngine::accessPointScanningReady(TBool scanSuccessful, TConnMonIapIn
     
     if (!iFirstUpdate) {
         startCommsDatabaseNotifications();
-        locker.unlock();
+        mutex.unlock();
         emit updateCompleted();
-        locker.relock();
+        mutex.lock();
     }
 }
 
 void SymbianEngine::updateStatesToSnaps()
 {
-    QMutexLocker locker(&mutex);
-
     // Go through SNAPs and set correct state to SNAPs
     foreach (const QString &iface, snapConfigurations.keys()) {
         bool discovered = false;
         bool active = false;
         QNetworkConfigurationPrivatePointer ptr = snapConfigurations.value(iface);
+
+        QMutexLocker snapConfigLocker(&ptr->mutex);
+
         // => Check if one of the IAPs of the SNAP is discovered or active
         //    => If one of IAPs is active, also SNAP is active
         //    => If one of IAPs is discovered but none of the IAPs is active, SNAP is discovered
         for (int i=0; i<ptr->serviceNetworkMembers.count(); i++) {
+            QMutexLocker configLocker(&ptr->serviceNetworkMembers[i]->mutex);
+
             if ((ptr->serviceNetworkMembers[i]->state & QNetworkConfiguration::Active)
                     == QNetworkConfiguration::Active) {
                 active = true;
@@ -798,16 +786,14 @@ void SymbianEngine::updateStatesToSnaps()
 bool SymbianEngine::changeConfigurationStateTo(QNetworkConfigurationPrivatePointer ptr,
                                                QNetworkConfiguration::StateFlags newState)
 {
-    QMutexLocker locker(&mutex);
-
     ptr->mutex.lock();
     if (newState != ptr->state) {
         ptr->state = newState;
         ptr->mutex.unlock();
 
-        locker.unlock();
+        mutex.unlock();
         emit configurationChanged(ptr);
-        locker.relock();
+        mutex.lock();
 
         return true;
     } else {
@@ -823,16 +809,14 @@ bool SymbianEngine::changeConfigurationStateTo(QNetworkConfigurationPrivatePoint
 bool SymbianEngine::changeConfigurationStateAtMinTo(QNetworkConfigurationPrivatePointer ptr,
                                                     QNetworkConfiguration::StateFlags newState)
 {
-    QMutexLocker locker(&mutex);
-
     ptr->mutex.lock();
     if ((newState | ptr->state) != ptr->state) {
         ptr->state = (ptr->state | newState);
         ptr->mutex.unlock();
 
-        locker.unlock();
+        mutex.unlock();
         emit configurationChanged(ptr);
-        locker.relock();
+        mutex.lock();
 
         return true;
     } else {
@@ -849,16 +833,14 @@ bool SymbianEngine::changeConfigurationStateAtMinTo(QNetworkConfigurationPrivate
 bool SymbianEngine::changeConfigurationStateAtMaxTo(QNetworkConfigurationPrivatePointer ptr,
                                                     QNetworkConfiguration::StateFlags newState)
 {
-    QMutexLocker locker(&mutex);
-
     ptr->mutex.lock();
     if ((newState & ptr->state) != ptr->state) {
         ptr->state = (newState & ptr->state);
         ptr->mutex.unlock();
 
-        locker.unlock();
+        mutex.unlock();
         emit configurationChanged(ptr);
-        locker.relock();
+        mutex.lock();
 
         return true;
     } else {
@@ -869,8 +851,6 @@ bool SymbianEngine::changeConfigurationStateAtMaxTo(QNetworkConfigurationPrivate
 
 void SymbianEngine::startCommsDatabaseNotifications()
 {
-    QMutexLocker locker(&mutex);
-
     if (!iWaitingCommsDatabaseNotifications) {
         iWaitingCommsDatabaseNotifications = ETrue;
         if (!IsActive()) {
@@ -883,19 +863,9 @@ void SymbianEngine::startCommsDatabaseNotifications()
 
 void SymbianEngine::stopCommsDatabaseNotifications()
 {
-    QMutexLocker locker(&mutex);
-
     if (iWaitingCommsDatabaseNotifications) {
         iWaitingCommsDatabaseNotifications = EFalse;
-        if (!IsActive()) {
-            SetActive();
-            // Make sure that notifier recorded events will not be returned
-            // as soon as the client issues the next RequestNotification() request.
-            ipCommsDB->RequestNotification(iStatus);
-            ipCommsDB->CancelRequestNotification();
-        } else {
-            ipCommsDB->CancelRequestNotification();
-        }
+        Cancel();
     }
 }
 
@@ -910,46 +880,48 @@ void SymbianEngine::RunL()
         return;
     }
 
-    if (iStatus != KErrCancel) {
-        RDbNotifier::TEvent event = STATIC_CAST(RDbNotifier::TEvent, iStatus.Int());
+    RDbNotifier::TEvent event = STATIC_CAST(RDbNotifier::TEvent, iStatus.Int());
 
-        switch (event) {
-        case RDbNotifier::EUnlock:   /** All read locks have been removed.  */
-        case RDbNotifier::ECommit:   /** A transaction has been committed.  */ 
-        case RDbNotifier::ERollback: /** A transaction has been rolled back */
-        case RDbNotifier::ERecover:  /** The database has been recovered    */
+    switch (event) {
+    case RDbNotifier::EUnlock:   /** All read locks have been removed.  */
+    case RDbNotifier::ECommit:   /** A transaction has been committed.  */
+    case RDbNotifier::ERollback: /** A transaction has been rolled back */
+    case RDbNotifier::ERecover:  /** The database has been recovered    */
 #ifdef QT_BEARERMGMT_SYMBIAN_DEBUG
-            qDebug("QNCM CommsDB event (of type RDbNotifier::TEvent) received: %d", iStatus.Int());
+        qDebug("QNCM CommsDB event (of type RDbNotifier::TEvent) received: %d", iStatus.Int());
 #endif
-            iIgnoringUpdates = true;
-            // Other events than ECommit get lower priority. In practice with those events,
-            // we delay_before_updating methods, whereas
-            // with ECommit we _update_before_delaying the reaction to next event.
-            // Few important notes: 1) listening to only ECommit does not seem to be adequate,
-            // but updates will be missed. Hence other events are reacted upon too.
-            // 2) RDbNotifier records the most significant event, and that will be returned once
-            // we issue new RequestNotification, and hence updates will not be missed even
-            // when we are 'not reacting to them' for few seconds.
-            if (event == RDbNotifier::ECommit) {
-                TRAPD(error, updateConfigurationsL());
-                if (error == KErrNone) {
-                    updateStatesToSnaps();
-                }
-                waitRandomTime();
-            } else {
-                waitRandomTime();
-                TRAPD(error, updateConfigurationsL());
-                if (error == KErrNone) {
-                    updateStatesToSnaps();
-                }   
+        iIgnoringUpdates = true;
+        // Other events than ECommit get lower priority. In practice with those events,
+        // we delay_before_updating methods, whereas
+        // with ECommit we _update_before_delaying the reaction to next event.
+        // Few important notes: 1) listening to only ECommit does not seem to be adequate,
+        // but updates will be missed. Hence other events are reacted upon too.
+        // 2) RDbNotifier records the most significant event, and that will be returned once
+        // we issue new RequestNotification, and hence updates will not be missed even
+        // when we are 'not reacting to them' for few seconds.
+        if (event == RDbNotifier::ECommit) {
+            TRAPD(error, updateConfigurationsL());
+            if (error == KErrNone) {
+                updateStatesToSnaps();
+            }
+            locker.unlock();
+            waitRandomTime();
+            locker.relock();
+        } else {
+            locker.unlock();
+            waitRandomTime();
+            locker.relock();
+            TRAPD(error, updateConfigurationsL());
+            if (error == KErrNone) {
+                updateStatesToSnaps();
             }
-            iIgnoringUpdates = false; // Wait time done, allow updating again
-            iWaitingCommsDatabaseNotifications = true;
-            break;
-        default:
-            // Do nothing
-            break;
         }
+        iIgnoringUpdates = false; // Wait time done, allow updating again
+        iWaitingCommsDatabaseNotifications = true;
+        break;
+    default:
+        // Do nothing
+        break;
     }
 
     if (iWaitingCommsDatabaseNotifications) {
@@ -991,9 +963,11 @@ void SymbianEngine::EventL(const CConnMonEventBase& aEvent)
             QString ident = QString::number(qHash(apId));
             QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(ident);
             if (ptr) {
-                QMutexLocker configLocker(&ptr->mutex);
+                ptr->mutex.lock();
                 toSymbianConfig(ptr)->connectionId = connectionId;
-                emit this->configurationStateChanged(toSymbianConfig(ptr)->numericId, connectionId, QNetworkSession::Connecting);
+                ptr->mutex.unlock();
+                emit configurationStateChanged(toSymbianConfig(ptr)->numericIdentifier(),
+                                               connectionId, QNetworkSession::Connecting);
             }
         } else if (connectionStatus == KLinkLayerOpen) {
             // Connection has been successfully opened
@@ -1006,13 +980,17 @@ void SymbianEngine::EventL(const CConnMonEventBase& aEvent)
             QString ident = QString::number(qHash(apId));
             QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(ident);
             if (ptr) {
-                QMutexLocker configLocker(&ptr->mutex);
+                ptr->mutex.lock();
                 toSymbianConfig(ptr)->connectionId = connectionId;
+                ptr->mutex.unlock();
+
                 // Configuration is Active
                 if (changeConfigurationStateTo(ptr, QNetworkConfiguration::Active)) {
                     updateStatesToSnaps();
                 }
-                emit this->configurationStateChanged(toSymbianConfig(ptr)->numericId, connectionId, QNetworkSession::Connected);
+                emit configurationStateChanged(toSymbianConfig(ptr)->numericIdentifier(),
+                                               connectionId, QNetworkSession::Connected);
+
                 if (!iOnline) {
                     iOnline = true;
                     emit this->onlineStateChanged(iOnline);
@@ -1022,8 +1000,8 @@ void SymbianEngine::EventL(const CConnMonEventBase& aEvent)
             TUint connectionId = realEvent->ConnectionId();
             QNetworkConfigurationPrivatePointer ptr = dataByConnectionId(connectionId);
             if (ptr) {
-                QMutexLocker configLocker(&ptr->mutex);
-                emit this->configurationStateChanged(toSymbianConfig(ptr)->numericId, connectionId, QNetworkSession::Closing);
+                emit configurationStateChanged(toSymbianConfig(ptr)->numericIdentifier(),
+                                               connectionId, QNetworkSession::Closing);
             }
         } else if (connectionStatus == KLinkLayerClosed ||
                    connectionStatus == KConnectionClosed) {
@@ -1037,8 +1015,8 @@ void SymbianEngine::EventL(const CConnMonEventBase& aEvent)
                     updateStatesToSnaps();
                 }
 
-                QMutexLocker configLocker(&ptr->mutex);
-                emit this->configurationStateChanged(toSymbianConfig(ptr)->numericId, connectionId, QNetworkSession::Disconnected);
+                emit configurationStateChanged(toSymbianConfig(ptr)->numericIdentifier(),
+                                               connectionId, QNetworkSession::Disconnected);
             }
             
             bool online = false;
@@ -1121,6 +1099,8 @@ void SymbianEngine::EventL(const CConnMonEventBase& aEvent)
 // manager). Currently only 'Disconnected' state is of interest because it has proven to be troublesome.
 void SymbianEngine::configurationStateChangeReport(TUint32 accessPointId, QNetworkSession::State newState)
 {
+    QMutexLocker locker(&mutex);
+
 #ifdef QT_BEARERMGMT_SYMBIAN_DEBUG
     qDebug() << "QNCM A session reported state change for IAP ID: " << accessPointId << " whose new state is: " << newState;
 #endif
@@ -1135,10 +1115,11 @@ void SymbianEngine::configurationStateChangeReport(TUint32 accessPointId, QNetwo
                     updateStatesToSnaps();
                 }
 
-                QMutexLocker configLocker(&ptr->mutex);
-                emit this->configurationStateChanged(toSymbianConfig(ptr)->numericId,
-                                                     toSymbianConfig(ptr)->connectionId,
-                                                     QNetworkSession::Disconnected);
+                locker.unlock();
+                emit configurationStateChanged(toSymbianConfig(ptr)->numericIdentifier(),
+                                               toSymbianConfig(ptr)->connectionIdentifier(),
+                                               QNetworkSession::Disconnected);
+                locker.relock();
             }
         }
         break;
@@ -1150,28 +1131,23 @@ void SymbianEngine::configurationStateChangeReport(TUint32 accessPointId, QNetwo
 // Waits for 2..6 seconds.
 void SymbianEngine::waitRandomTime()
 {
-    iTimeToWait = (qAbs(qrand()) % 7) * 1000;
-    if (iTimeToWait < 2000) {
-        iTimeToWait = 2000;
-    }
+    int iTimeToWait = qMax(2000, (qAbs(qrand()) % 7) * 1000);
 #ifdef QT_BEARERMGMT_SYMBIAN_DEBUG
     qDebug("QNCM waiting random time: %d ms", iTimeToWait);
 #endif
-    QTimer::singleShot(iTimeToWait, iIgnoreEventLoop, SLOT(quit()));
-    iIgnoreEventLoop->exec();
+    QEventLoop loop;
+    QTimer::singleShot(iTimeToWait, &loop, SLOT(quit()));
+    loop.exec();
 }
 
 QNetworkConfigurationPrivatePointer SymbianEngine::dataByConnectionId(TUint aConnectionId)
 {
-    QMutexLocker locker(&mutex);
-
     QNetworkConfiguration item;
     QHash<QString, QNetworkConfigurationPrivatePointer>::const_iterator i =
             accessPointConfigurations.constBegin();
     while (i != accessPointConfigurations.constEnd()) {
         QNetworkConfigurationPrivatePointer ptr = i.value();
-        QMutexLocker configLocker(&ptr->mutex);
-        if (toSymbianConfig(ptr)->connectionId == aConnectionId)
+        if (toSymbianConfig(ptr)->connectionIdentifier() == aConnectionId)
             return ptr;
 
         ++i;
@@ -1218,6 +1194,8 @@ void AccessPointsAvailabilityScanner::StartScanning()
 
 void AccessPointsAvailabilityScanner::RunL()
 {
+    QMutexLocker locker(&iOwner.mutex);
+
     if (iStatus.Int() != KErrNone) {
         iIapBuf().iCount = 0;
         iOwner.accessPointScanningReady(false,iIapBuf());
diff --git a/src/plugins/bearer/symbian/symbianengine.h b/src/plugins/bearer/symbian/symbianengine.h
index 7d565db..18fd249 100644
--- a/src/plugins/bearer/symbian/symbianengine.h
+++ b/src/plugins/bearer/symbian/symbianengine.h
@@ -87,7 +87,23 @@ public:
 
     QString bearerName() const;
 
-    QNetworkConfigurationPrivatePointer serviceNetworkPtr;
+    inline TUint32 numericIdentifier() const
+    {
+        QMutexLocker locker(&mutex);
+        return numericId;
+    }
+
+    inline TUint connectionIdentifier() const
+    {
+        QMutexLocker locker(&mutex);
+        return connectionId;
+    }
+
+    inline QString configMappingName() const
+    {
+        QMutexLocker locker(&mutex);
+        return mappingName;
+    }
 
     QString mappingName;
 
@@ -196,11 +212,11 @@ private: // Data
     TBool              iInitOk;
     TBool              iUpdateGoingOn;
     TBool              iIgnoringUpdates;
-    TUint              iTimeToWait;
-    QEventLoop*        iIgnoreEventLoop;
 
     AccessPointsAvailabilityScanner* ipAccessPointsAvailabilityScanner;
-    
+
+    QNetworkConfigurationPrivatePointer defaultConfig;
+
     friend class QNetworkSessionPrivate;
     friend class AccessPointsAvailabilityScanner;
     friend class QNetworkSessionPrivateImpl;
diff --git a/src/plugins/s60/s60pluginbase.pri b/src/plugins/s60/s60pluginbase.pri
index 1a6f4a2..4e15102 100644
--- a/src/plugins/s60/s60pluginbase.pri
+++ b/src/plugins/s60/s60pluginbase.pri
@@ -8,11 +8,16 @@ QTDIR_build:DESTDIR	 = $$QT_BUILD_TREE/plugins/s60
 
 MMP_RULES += NOEXPORTLIBRARY
 
-defBlock = \
-    "$${LITERAL_HASH}ifdef WINSCW" \
-    "DEFFILE ../bwins/qts60plugin.def" \
-    "$${LITERAL_HASH}else" \
-    "DEFFILE ../eabi/qts60plugin.def" \
-    "$${LITERAL_HASH}endif"
+symbian-abld|symbian-sbsv2 {
+    defBlock = \
+        "$${LITERAL_HASH}ifdef WINSCW" \
+        "DEFFILE ../bwins/qts60plugin.def" \
+        "$${LITERAL_HASH}else" \
+        "DEFFILE ../eabi/qts60plugin.def" \
+        "$${LITERAL_HASH}endif"
+} else {
+    CONFIG *= def_files
+    DEF_FILE = ../eabi/qts60pluginu.def
+}
 
 MMP_RULES += defBlock
 \ No newline at end of file
diff --git a/src/qbase.pri b/src/qbase.pri
index 4a75565..83ae069 100644
--- a/src/qbase.pri
+++ b/src/qbase.pri
@@ -1,4 +1,4 @@
-isEmpty(TARGET):error(You must set TARGET before include()'ing $${_FILE_})
+isEmpty(TARGET):error("You must set TARGET before include()'ing $${_FILE_}")
 INCLUDEPATH *= $$QMAKE_INCDIR_QT/$$TARGET #just for today to have some compat
 !isEmpty(RCC_DIR): INCLUDEPATH += $$RCC_DIR
 isEmpty(QT_ARCH):!isEmpty(ARCH):QT_ARCH=$$ARCH #another compat that will rot for change #215700
diff --git a/src/s60installs/bwins/QtDeclarativeu.def b/src/s60installs/bwins/QtDeclarativeu.def
index c960614..3df0f47 100644
--- a/src/s60installs/bwins/QtDeclarativeu.def
+++ b/src/s60installs/bwins/QtDeclarativeu.def
@@ -86,7 +86,7 @@ EXPORTS
 	??0QDeclarativeError@@QAE@XZ @ 85 NONAME ; QDeclarativeError::QDeclarativeError(void)
 	??0QDeclarativeExpression@@IAE@PAVQDeclarativeContext@@ABVQString@@PAVQObject@@AAVQDeclarativeExpressionPrivate@@@Z @ 86 NONAME ABSENT ; QDeclarativeExpression::QDeclarativeExpression(class QDeclarativeContext *, class QString const &, class QObject *, class QDeclarativeExpressionPrivate &)
 	??0QDeclarativeExpression@@IAE@PAVQDeclarativeContext@@PAXPAVQDeclarativeRefCount@@PAVQObject@@ABVQString@@HAAVQDeclarativeExpressionPrivate@@@Z @ 87 NONAME ABSENT ; QDeclarativeExpression::QDeclarativeExpression(class QDeclarativeContext *, void *, class QDeclarativeRefCount *, class QObject *, class QString const &, int, class QDeclarativeExpressionPrivate &)
-	??0QDeclarativeExpression@@QAE@PAVQDeclarativeContext@@ABVQString@@PAVQObject@@@Z @ 88 NONAME ; QDeclarativeExpression::QDeclarativeExpression(class QDeclarativeContext *, class QString const &, class QObject *)
+	??0QDeclarativeExpression@@QAE@PAVQDeclarativeContext@@ABVQString@@PAVQObject@@@Z @ 88 NONAME ABSENT ; QDeclarativeExpression::QDeclarativeExpression(class QDeclarativeContext *, class QString const &, class QObject *)
 	??0QDeclarativeExpression@@QAE@XZ @ 89 NONAME ; QDeclarativeExpression::QDeclarativeExpression(void)
 	??0QDeclarativeExtensionPlugin@@QAE@PAVQObject@@@Z @ 90 NONAME ; QDeclarativeExtensionPlugin::QDeclarativeExtensionPlugin(class QObject *)
 	??0QDeclarativeFlickable@@IAE@AAVQDeclarativeFlickablePrivate@@PAVQDeclarativeItem@@@Z @ 91 NONAME ; QDeclarativeFlickable::QDeclarativeFlickable(class QDeclarativeFlickablePrivate &, class QDeclarativeItem *)
@@ -861,7 +861,7 @@ EXPORTS
 	?cursorPosition@QDeclarativeTextInput@@QBEHXZ @ 860 NONAME ; int QDeclarativeTextInput::cursorPosition(void) const
 	?cursorPositionChanged@QDeclarativeTextEdit@@IAEXXZ @ 861 NONAME ; void QDeclarativeTextEdit::cursorPositionChanged(void)
 	?cursorPositionChanged@QDeclarativeTextInput@@IAEXXZ @ 862 NONAME ; void QDeclarativeTextInput::cursorPositionChanged(void)
-	?cursorRect@QDeclarativeTextEdit@@QBE?AVQRect@@XZ @ 863 NONAME ; class QRect QDeclarativeTextEdit::cursorRect(void) const
+	?cursorRect@QDeclarativeTextEdit@@QBE?AVQRect@@XZ @ 863 NONAME ABSENT ; class QRect QDeclarativeTextEdit::cursorRect(void) const
 	?cursorRect@QDeclarativeTextInput@@QBE?AVQRect@@XZ @ 864 NONAME ; class QRect QDeclarativeTextInput::cursorRect(void) const
 	?cursorVisibleChanged@QDeclarativeTextEdit@@IAEX_N@Z @ 865 NONAME ; void QDeclarativeTextEdit::cursorVisibleChanged(bool)
 	?cursorVisibleChanged@QDeclarativeTextInput@@IAEX_N@Z @ 866 NONAME ; void QDeclarativeTextInput::cursorVisibleChanged(bool)
@@ -1086,7 +1086,7 @@ EXPORTS
 	?errors@QDeclarativeCustomParser@@QBE?AV?$QList@VQDeclarativeError@@@@XZ @ 1085 NONAME ; class QList<class QDeclarativeError> QDeclarativeCustomParser::errors(void) const
 	?errors@QDeclarativeDomDocument@@QBE?AV?$QList@VQDeclarativeError@@@@XZ @ 1086 NONAME ; class QList<class QDeclarativeError> QDeclarativeDomDocument::errors(void) const
 	?errors@QDeclarativeView@@QBE?AV?$QList@VQDeclarativeError@@@@XZ @ 1087 NONAME ; class QList<class QDeclarativeError> QDeclarativeView::errors(void) const
-	?errorsString@QDeclarativeComponent@@QBE?AVQString@@XZ @ 1088 NONAME ; class QString QDeclarativeComponent::errorsString(void) const
+	?errorsString@QDeclarativeComponent@@QBE?AVQString@@XZ @ 1088 NONAME ABSENT ; class QString QDeclarativeComponent::errorsString(void) const
 	?eval@QDeclarativeBind@@AAEXXZ @ 1089 NONAME ; void QDeclarativeBind::eval(void)
 	?evaluate@QDeclarativeVisualDataModel@@UAE?AVQVariant@@HABVQString@@PAVQObject@@@Z @ 1090 NONAME ; class QVariant QDeclarativeVisualDataModel::evaluate(int, class QString const &, class QObject *)
 	?evaluate@QDeclarativeVisualItemModel@@UAE?AVQVariant@@HABVQString@@PAVQObject@@@Z @ 1091 NONAME ; class QVariant QDeclarativeVisualItemModel::evaluate(int, class QString const &, class QObject *)
@@ -1299,7 +1299,7 @@ EXPORTS
 	?hasStdCppSet@QMetaPropertyBuilder@@QBE_NXZ @ 1298 NONAME ; bool QMetaPropertyBuilder::hasStdCppSet(void) const
 	?header@QDeclarativeListView@@QBEPAVQDeclarativeComponent@@XZ @ 1299 NONAME ; class QDeclarativeComponent * QDeclarativeListView::header(void) const
 	?height@QDeclarativeItem@@QBEMXZ @ 1300 NONAME ; float QDeclarativeItem::height(void) const
-	?height@QDeclarativeParentChange@@QBEMXZ @ 1301 NONAME ; float QDeclarativeParentChange::height(void) const
+	?height@QDeclarativeParentChange@@QBEMXZ @ 1301 NONAME ABSENT ; float QDeclarativeParentChange::height(void) const
 	?heightChange@QDeclarativeFlickable@@IAEXXZ @ 1302 NONAME ABSENT ; void QDeclarativeFlickable::heightChange(void)
 	?heightChanged@QDeclarativeItem@@IAEXXZ @ 1303 NONAME ABSENT ; void QDeclarativeItem::heightChanged(void)
 	?heightIsSet@QDeclarativeParentChange@@QBE_NXZ @ 1304 NONAME ; bool QDeclarativeParentChange::heightIsSet(void) const
@@ -1813,8 +1813,8 @@ EXPORTS
 	?orientation@QDeclarativeListView@@QBE?AW4Orientation@1@XZ @ 1812 NONAME ; enum QDeclarativeListView::Orientation QDeclarativeListView::orientation(void) const
 	?orientationChanged@QDeclarativeListView@@IAEXXZ @ 1813 NONAME ; void QDeclarativeListView::orientationChanged(void)
 	?originalParent@QDeclarativeParentChange@@QBEPAVQDeclarativeItem@@XZ @ 1814 NONAME ; class QDeclarativeItem * QDeclarativeParentChange::originalParent(void) const
-	?overShoot@QDeclarativeFlickable@@QBE_NXZ @ 1815 NONAME ; bool QDeclarativeFlickable::overShoot(void) const
-	?overShootChanged@QDeclarativeFlickable@@IAEXXZ @ 1816 NONAME ; void QDeclarativeFlickable::overShootChanged(void)
+	?overShoot@QDeclarativeFlickable@@QBE_NXZ @ 1815 NONAME ABSENT ; bool QDeclarativeFlickable::overShoot(void) const
+	?overShootChanged@QDeclarativeFlickable@@IAEXXZ @ 1816 NONAME ABSENT ; void QDeclarativeFlickable::overShootChanged(void)
 	?override@QDeclarativeAnchorChanges@@UAE_NPAVQDeclarativeActionEvent@@@Z @ 1817 NONAME ; bool QDeclarativeAnchorChanges::override(class QDeclarativeActionEvent *)
 	?override@QDeclarativeParentChange@@UAE_NPAVQDeclarativeActionEvent@@@Z @ 1818 NONAME ; bool QDeclarativeParentChange::override(class QDeclarativeActionEvent *)
 	?pace@QDeclarativeParticleMotionWander@@QBEMXZ @ 1819 NONAME ABSENT ; float QDeclarativeParticleMotionWander::pace(void) const
@@ -2247,7 +2247,7 @@ EXPORTS
 	?rootIndexChanged@QDeclarativeVisualDataModel@@IAEXXZ @ 2246 NONAME ; void QDeclarativeVisualDataModel::rootIndexChanged(void)
 	?rootObject@QDeclarativeDomDocument@@QBE?AVQDeclarativeDomObject@@XZ @ 2247 NONAME ; class QDeclarativeDomObject QDeclarativeDomDocument::rootObject(void) const
 	?rootObject@QDeclarativeView@@QBEPAVQGraphicsObject@@XZ @ 2248 NONAME ; class QGraphicsObject * QDeclarativeView::rootObject(void) const
-	?rotation@QDeclarativeParentChange@@QBEMXZ @ 2249 NONAME ; float QDeclarativeParentChange::rotation(void) const
+	?rotation@QDeclarativeParentChange@@QBEMXZ @ 2249 NONAME ABSENT ; float QDeclarativeParentChange::rotation(void) const
 	?rotationIsSet@QDeclarativeParentChange@@QBE_NXZ @ 2250 NONAME ; bool QDeclarativeParentChange::rotationIsSet(void) const
 	?rows@QDeclarativeGrid@@QBEHXZ @ 2251 NONAME ; int QDeclarativeGrid::rows(void) const
 	?rowsChanged@QDeclarativeGrid@@IAEXXZ @ 2252 NONAME ; void QDeclarativeGrid::rowsChanged(void)
@@ -2257,7 +2257,7 @@ EXPORTS
 	?saveCurrentValues@QDeclarativeParentChange@@UAEXXZ @ 2256 NONAME ; void QDeclarativeParentChange::saveCurrentValues(void)
 	?saveOriginals@QDeclarativeAnchorChanges@@UAEXXZ @ 2257 NONAME ; void QDeclarativeAnchorChanges::saveOriginals(void)
 	?saveOriginals@QDeclarativeParentChange@@UAEXXZ @ 2258 NONAME ; void QDeclarativeParentChange::saveOriginals(void)
-	?scale@QDeclarativeParentChange@@QBEMXZ @ 2259 NONAME ; float QDeclarativeParentChange::scale(void) const
+	?scale@QDeclarativeParentChange@@QBEMXZ @ 2259 NONAME ABSENT ; float QDeclarativeParentChange::scale(void) const
 	?scaleIsSet@QDeclarativeParentChange@@QBE_NXZ @ 2260 NONAME ; bool QDeclarativeParentChange::scaleIsSet(void) const
 	?sceneEvent@QDeclarativeFocusPanel@@MAE_NPAVQEvent@@@Z @ 2261 NONAME ; bool QDeclarativeFocusPanel::sceneEvent(class QEvent *)
 	?sceneEvent@QDeclarativeItem@@MAE_NPAVQEvent@@@Z @ 2262 NONAME ; bool QDeclarativeItem::sceneEvent(class QEvent *)
@@ -2346,7 +2346,7 @@ EXPORTS
 	?setColumn@QDeclarativeError@@QAEXH@Z @ 2345 NONAME ; void QDeclarativeError::setColumn(int)
 	?setColumnNumber@QDeclarativeDebugFileReference@@QAEXH@Z @ 2346 NONAME ; void QDeclarativeDebugFileReference::setColumnNumber(int)
 	?setColumns@QDeclarativeGrid@@QAEXH@Z @ 2347 NONAME ; void QDeclarativeGrid::setColumns(int)
-	?setConsistentTime@QDeclarativeItemPrivate@@SAXH@Z @ 2348 NONAME ; void QDeclarativeItemPrivate::setConsistentTime(int)
+	?setConsistentTime@QDeclarativeItemPrivate@@SAXH@Z @ 2348 NONAME ABSENT ; void QDeclarativeItemPrivate::setConsistentTime(int)
 	?setContent@QDeclarativeWebView@@QAEXABVQByteArray@@ABVQString@@ABVQUrl@@@Z @ 2349 NONAME ABSENT ; void QDeclarativeWebView::setContent(class QByteArray const &, class QString const &, class QUrl const &)
 	?setContentHeight@QDeclarativeFlickable@@QAEXM@Z @ 2350 NONAME ; void QDeclarativeFlickable::setContentHeight(float)
 	?setContentWidth@QDeclarativeFlickable@@QAEXM@Z @ 2351 NONAME ; void QDeclarativeFlickable::setContentWidth(float)
@@ -2437,7 +2437,7 @@ EXPORTS
 	?setHAlign@QDeclarativeTextInput@@QAEXW4HAlignment@1@@Z @ 2436 NONAME ; void QDeclarativeTextInput::setHAlign(enum QDeclarativeTextInput::HAlignment)
 	?setHeader@QDeclarativeListView@@QAEXPAVQDeclarativeComponent@@@Z @ 2437 NONAME ; void QDeclarativeListView::setHeader(class QDeclarativeComponent *)
 	?setHeight@QDeclarativeItem@@QAEXM@Z @ 2438 NONAME ; void QDeclarativeItem::setHeight(float)
-	?setHeight@QDeclarativeParentChange@@QAEXM@Z @ 2439 NONAME ; void QDeclarativeParentChange::setHeight(float)
+	?setHeight@QDeclarativeParentChange@@QAEXM@Z @ 2439 NONAME ABSENT ; void QDeclarativeParentChange::setHeight(float)
 	?setHighlight@QDeclarativeGridView@@QAEXPAVQDeclarativeComponent@@@Z @ 2440 NONAME ; void QDeclarativeGridView::setHighlight(class QDeclarativeComponent *)
 	?setHighlight@QDeclarativeListView@@QAEXPAVQDeclarativeComponent@@@Z @ 2441 NONAME ; void QDeclarativeListView::setHighlight(class QDeclarativeComponent *)
 	?setHighlightFollowsCurrentItem@QDeclarativeGridView@@QAEX_N@Z @ 2442 NONAME ; void QDeclarativeGridView::setHighlightFollowsCurrentItem(bool)
@@ -2506,7 +2506,7 @@ EXPORTS
 	?setOfflineStoragePath@QDeclarativeEngine@@QAEXABVQString@@@Z @ 2505 NONAME ; void QDeclarativeEngine::setOfflineStoragePath(class QString const &)
 	?setOffset@QDeclarativePathView@@QAEXM@Z @ 2506 NONAME ; void QDeclarativePathView::setOffset(float)
 	?setOrientation@QDeclarativeListView@@QAEXW4Orientation@1@@Z @ 2507 NONAME ; void QDeclarativeListView::setOrientation(enum QDeclarativeListView::Orientation)
-	?setOverShoot@QDeclarativeFlickable@@QAEX_N@Z @ 2508 NONAME ; void QDeclarativeFlickable::setOverShoot(bool)
+	?setOverShoot@QDeclarativeFlickable@@QAEX_N@Z @ 2508 NONAME ABSENT ; void QDeclarativeFlickable::setOverShoot(bool)
 	?setPace@QDeclarativeParticleMotionWander@@QAEXM@Z @ 2509 NONAME ABSENT ; void QDeclarativeParticleMotionWander::setPace(float)
 	?setPage@QDeclarativeWebView@@QAEXPAVQWebPage@@@Z @ 2510 NONAME ABSENT ; void QDeclarativeWebView::setPage(class QWebPage *)
 	?setParameterNames@QMetaMethodBuilder@@QAEXABV?$QList@VQByteArray@@@@@Z @ 2511 NONAME ; void QMetaMethodBuilder::setParameterNames(class QList<class QByteArray> const &)
@@ -2555,10 +2555,10 @@ EXPORTS
 	?setRightMargin@QDeclarativeAnchors@@QAEXM@Z @ 2554 NONAME ; void QDeclarativeAnchors::setRightMargin(float)
 	?setRootIndex@QDeclarativeVisualDataModel@@QAEXABVQModelIndex@@@Z @ 2555 NONAME ABSENT ; void QDeclarativeVisualDataModel::setRootIndex(class QModelIndex const &)
 	?setRootObject@QDeclarativeView@@MAEXPAVQObject@@@Z @ 2556 NONAME ; void QDeclarativeView::setRootObject(class QObject *)
-	?setRotation@QDeclarativeParentChange@@QAEXM@Z @ 2557 NONAME ; void QDeclarativeParentChange::setRotation(float)
+	?setRotation@QDeclarativeParentChange@@QAEXM@Z @ 2557 NONAME ABSENT ; void QDeclarativeParentChange::setRotation(float)
 	?setRows@QDeclarativeGrid@@QAEXH@Z @ 2558 NONAME ; void QDeclarativeGrid::setRows(int)
 	?setRunning@QDeclarativeTimer@@QAEX_N@Z @ 2559 NONAME ; void QDeclarativeTimer::setRunning(bool)
-	?setScale@QDeclarativeParentChange@@QAEXM@Z @ 2560 NONAME ; void QDeclarativeParentChange::setScale(float)
+	?setScale@QDeclarativeParentChange@@QAEXM@Z @ 2560 NONAME ABSENT ; void QDeclarativeParentChange::setScale(float)
 	?setScopeObject@QDeclarativeScriptString@@QAEXPAVQObject@@@Z @ 2561 NONAME ; void QDeclarativeScriptString::setScopeObject(class QObject *)
 	?setScript@QDeclarativeScriptString@@QAEXABVQString@@@Z @ 2562 NONAME ; void QDeclarativeScriptString::setScript(class QString const &)
 	?setScript@QDeclarativeStateChangeScript@@QAEXABVQDeclarativeScriptString@@@Z @ 2563 NONAME ; void QDeclarativeStateChangeScript::setScript(class QDeclarativeScriptString const &)
@@ -2651,7 +2651,7 @@ EXPORTS
 	?setWhen@QDeclarativeBind@@QAEX_N@Z @ 2650 NONAME ; void QDeclarativeBind::setWhen(bool)
 	?setWhen@QDeclarativeState@@QAEXPAVQDeclarativeBinding@@@Z @ 2651 NONAME ; void QDeclarativeState::setWhen(class QDeclarativeBinding *)
 	?setWidth@QDeclarativeItem@@QAEXM@Z @ 2652 NONAME ; void QDeclarativeItem::setWidth(float)
-	?setWidth@QDeclarativeParentChange@@QAEXM@Z @ 2653 NONAME ; void QDeclarativeParentChange::setWidth(float)
+	?setWidth@QDeclarativeParentChange@@QAEXM@Z @ 2653 NONAME ABSENT ; void QDeclarativeParentChange::setWidth(float)
 	?setWidth@QDeclarativePen@@QAEXH@Z @ 2654 NONAME ; void QDeclarativePen::setWidth(int)
 	?setWrap@QDeclarativeText@@QAEX_N@Z @ 2655 NONAME ABSENT ; void QDeclarativeText::setWrap(bool)
 	?setWrap@QDeclarativeTextEdit@@QAEX_N@Z @ 2656 NONAME ABSENT ; void QDeclarativeTextEdit::setWrap(bool)
@@ -2659,14 +2659,14 @@ EXPORTS
 	?setWrapEnabled@QDeclarativeListView@@QAEX_N@Z @ 2658 NONAME ; void QDeclarativeListView::setWrapEnabled(bool)
 	?setWritable@QMetaPropertyBuilder@@QAEX_N@Z @ 2659 NONAME ; void QMetaPropertyBuilder::setWritable(bool)
 	?setX@QDeclarativeCurve@@QAEXM@Z @ 2660 NONAME ; void QDeclarativeCurve::setX(float)
-	?setX@QDeclarativeParentChange@@QAEXM@Z @ 2661 NONAME ; void QDeclarativeParentChange::setX(float)
+	?setX@QDeclarativeParentChange@@QAEXM@Z @ 2661 NONAME ABSENT ; void QDeclarativeParentChange::setX(float)
 	?setXAttractor@QDeclarativeParticleMotionGravity@@QAEXM@Z @ 2662 NONAME ABSENT ; void QDeclarativeParticleMotionGravity::setXAttractor(float)
 	?setXVariance@QDeclarativeParticleMotionWander@@QAEXM@Z @ 2663 NONAME ABSENT ; void QDeclarativeParticleMotionWander::setXVariance(float)
 	?setXmax@QDeclarativeDrag@@QAEXM@Z @ 2664 NONAME ; void QDeclarativeDrag::setXmax(float)
 	?setXmin@QDeclarativeDrag@@QAEXM@Z @ 2665 NONAME ; void QDeclarativeDrag::setXmin(float)
 	?setXml@QDeclarativeXmlListModel@@QAEXABVQString@@@Z @ 2666 NONAME ; void QDeclarativeXmlListModel::setXml(class QString const &)
 	?setY@QDeclarativeCurve@@QAEXM@Z @ 2667 NONAME ; void QDeclarativeCurve::setY(float)
-	?setY@QDeclarativeParentChange@@QAEXM@Z @ 2668 NONAME ; void QDeclarativeParentChange::setY(float)
+	?setY@QDeclarativeParentChange@@QAEXM@Z @ 2668 NONAME ABSENT ; void QDeclarativeParentChange::setY(float)
 	?setYAttractor@QDeclarativeParticleMotionGravity@@QAEXM@Z @ 2669 NONAME ABSENT ; void QDeclarativeParticleMotionGravity::setYAttractor(float)
 	?setYVariance@QDeclarativeParticleMotionWander@@QAEXM@Z @ 2670 NONAME ABSENT ; void QDeclarativeParticleMotionWander::setYVariance(float)
 	?setYmax@QDeclarativeDrag@@QAEXM@Z @ 2671 NONAME ; void QDeclarativeDrag::setYmax(float)
@@ -3298,7 +3298,7 @@ EXPORTS
 	?when@QDeclarativeBind@@QBE_NXZ @ 3297 NONAME ; bool QDeclarativeBind::when(void) const
 	?when@QDeclarativeState@@QBEPAVQDeclarativeBinding@@XZ @ 3298 NONAME ; class QDeclarativeBinding * QDeclarativeState::when(void) const
 	?width@QDeclarativeItem@@QBEMXZ @ 3299 NONAME ; float QDeclarativeItem::width(void) const
-	?width@QDeclarativeParentChange@@QBEMXZ @ 3300 NONAME ; float QDeclarativeParentChange::width(void) const
+	?width@QDeclarativeParentChange@@QBEMXZ @ 3300 NONAME ABSENT ; float QDeclarativeParentChange::width(void) const
 	?width@QDeclarativePen@@QBEHXZ @ 3301 NONAME ; int QDeclarativePen::width(void) const
 	?widthChange@QDeclarativeFlickable@@IAEXXZ @ 3302 NONAME ABSENT ; void QDeclarativeFlickable::widthChange(void)
 	?widthChanged@QDeclarativeItem@@IAEXXZ @ 3303 NONAME ABSENT ; void QDeclarativeItem::widthChanged(void)
@@ -3317,7 +3317,7 @@ EXPORTS
 	?write@QDeclarativeProperty@@SA_NPAVQObject@@ABVQString@@ABVQVariant@@PAVQDeclarativeContext@@@Z @ 3316 NONAME ; bool QDeclarativeProperty::write(class QObject *, class QString const &, class QVariant const &, class QDeclarativeContext *)
 	?write@QDeclarativeProperty@@SA_NPAVQObject@@ABVQString@@ABVQVariant@@PAVQDeclarativeEngine@@@Z @ 3317 NONAME ; bool QDeclarativeProperty::write(class QObject *, class QString const &, class QVariant const &, class QDeclarativeEngine *)
 	?x@QDeclarativeCurve@@QBEMXZ @ 3318 NONAME ; float QDeclarativeCurve::x(void) const
-	?x@QDeclarativeParentChange@@QBEMXZ @ 3319 NONAME ; float QDeclarativeParentChange::x(void) const
+	?x@QDeclarativeParentChange@@QBEMXZ @ 3319 NONAME ABSENT ; float QDeclarativeParentChange::x(void) const
 	?xAttractor@QDeclarativeParticleMotionGravity@@QBEMXZ @ 3320 NONAME ABSENT ; float QDeclarativeParticleMotionGravity::xAttractor(void) const
 	?xIsSet@QDeclarativeParentChange@@QBE_NXZ @ 3321 NONAME ; bool QDeclarativeParentChange::xIsSet(void) const
 	?xToPos@QDeclarativeTextInput@@QAEHH@Z @ 3322 NONAME ABSENT ; int QDeclarativeTextInput::xToPos(int)
@@ -3329,7 +3329,7 @@ EXPORTS
 	?xml@QDeclarativeXmlListModel@@QBE?AVQString@@XZ @ 3328 NONAME ; class QString QDeclarativeXmlListModel::xml(void) const
 	?xvarianceChanged@QDeclarativeParticleMotionWander@@IAEXXZ @ 3329 NONAME ABSENT ; void QDeclarativeParticleMotionWander::xvarianceChanged(void)
 	?y@QDeclarativeCurve@@QBEMXZ @ 3330 NONAME ; float QDeclarativeCurve::y(void) const
-	?y@QDeclarativeParentChange@@QBEMXZ @ 3331 NONAME ; float QDeclarativeParentChange::y(void) const
+	?y@QDeclarativeParentChange@@QBEMXZ @ 3331 NONAME ABSENT ; float QDeclarativeParentChange::y(void) const
 	?yAttractor@QDeclarativeParticleMotionGravity@@QBEMXZ @ 3332 NONAME ABSENT ; float QDeclarativeParticleMotionGravity::yAttractor(void) const
 	?yIsSet@QDeclarativeParentChange@@QBE_NXZ @ 3333 NONAME ; bool QDeclarativeParentChange::yIsSet(void) const
 	?yVariance@QDeclarativeParticleMotionWander@@QBEMXZ @ 3334 NONAME ABSENT ; float QDeclarativeParticleMotionWander::yVariance(void) const
@@ -3500,8 +3500,8 @@ EXPORTS
 	??0QDeclarativeBinding@@QAE@PAXPAVQDeclarativeRefCount@@PAVQObject@@PAVQDeclarativeContextData@@ABVQString@@H2@Z @ 3499 NONAME ; QDeclarativeBinding::QDeclarativeBinding(void *, class QDeclarativeRefCount *, class QObject *, class QDeclarativeContextData *, class QString const &, int, class QObject *)
 	??0QDeclarativeContext@@AAE@PAVQDeclarativeContextData@@@Z @ 3500 NONAME ; QDeclarativeContext::QDeclarativeContext(class QDeclarativeContextData *)
 	??0QDeclarativeCustomParser@@QAE@XZ @ 3501 NONAME ; QDeclarativeCustomParser::QDeclarativeCustomParser(void)
-	??0QDeclarativeExpression@@AAE@PAVQDeclarativeContextData@@ABVQString@@PAVQObject@@@Z @ 3502 NONAME ; QDeclarativeExpression::QDeclarativeExpression(class QDeclarativeContextData *, class QString const &, class QObject *)
-	??0QDeclarativeExpression@@IAE@PAVQDeclarativeContextData@@ABVQString@@PAVQObject@@AAVQDeclarativeExpressionPrivate@@@Z @ 3503 NONAME ; QDeclarativeExpression::QDeclarativeExpression(class QDeclarativeContextData *, class QString const &, class QObject *, class QDeclarativeExpressionPrivate &)
+	??0QDeclarativeExpression@@AAE@PAVQDeclarativeContextData@@ABVQString@@PAVQObject@@@Z @ 3502 NONAME ABSENT ; QDeclarativeExpression::QDeclarativeExpression(class QDeclarativeContextData *, class QString const &, class QObject *)
+	??0QDeclarativeExpression@@IAE@PAVQDeclarativeContextData@@ABVQString@@PAVQObject@@AAVQDeclarativeExpressionPrivate@@@Z @ 3503 NONAME ABSENT ; QDeclarativeExpression::QDeclarativeExpression(class QDeclarativeContextData *, class QString const &, class QObject *, class QDeclarativeExpressionPrivate &)
 	??0QDeclarativeExpression@@IAE@PAVQDeclarativeContextData@@PAXPAVQDeclarativeRefCount@@PAVQObject@@ABVQString@@HAAVQDeclarativeExpressionPrivate@@@Z @ 3504 NONAME ; QDeclarativeExpression::QDeclarativeExpression(class QDeclarativeContextData *, void *, class QDeclarativeRefCount *, class QObject *, class QString const &, int, class QDeclarativeExpressionPrivate &)
 	??0QDeclarativeItemPrivate@@QAE@XZ @ 3505 NONAME ; QDeclarativeItemPrivate::QDeclarativeItemPrivate(void)
 	??0QDeclarativeListModel@@AAE@_NPAVQObject@@@Z @ 3506 NONAME ; QDeclarativeListModel::QDeclarativeListModel(bool, class QObject *)
@@ -3567,7 +3567,7 @@ EXPORTS
 	?countChanged@QDeclarativeListModel@@IAEXXZ @ 3566 NONAME ; void QDeclarativeListModel::countChanged(void)
 	?countChanged@QDeclarativePathView@@IAEXXZ @ 3567 NONAME ; void QDeclarativePathView::countChanged(void)
 	?create@QDeclarativeType@@QBEXPAPAVQObject@@PAPAXI@Z @ 3568 NONAME ; void QDeclarativeType::create(class QObject * *, void * *, unsigned int) const
-	?currentTime@QDeclarativeItemPrivate@@SA?AVQTime@@XZ @ 3569 NONAME ; class QTime QDeclarativeItemPrivate::currentTime(void)
+	?currentTime@QDeclarativeItemPrivate@@SA?AVQTime@@XZ @ 3569 NONAME ABSENT ; class QTime QDeclarativeItemPrivate::currentTime(void)
 	?d_func@QDeclarativeFocusPanel@@AAEPAVQDeclarativeItemPrivate@@XZ @ 3570 NONAME ; class QDeclarativeItemPrivate * QDeclarativeFocusPanel::d_func(void)
 	?d_func@QDeclarativeFocusPanel@@ABEPBVQDeclarativeItemPrivate@@XZ @ 3571 NONAME ; class QDeclarativeItemPrivate const * QDeclarativeFocusPanel::d_func(void) const
 	?d_func@QDeclarativeFocusScope@@AAEPAVQDeclarativeItemPrivate@@XZ @ 3572 NONAME ; class QDeclarativeItemPrivate * QDeclarativeFocusScope::d_func(void)
@@ -3588,7 +3588,7 @@ EXPORTS
 	?doPositioning@QDeclarativeRow@@MAEXPAVQSizeF@@@Z @ 3587 NONAME ; void QDeclarativeRow::doPositioning(class QSizeF *)
 	?dragMarginChanged@QDeclarativePathView@@IAEXXZ @ 3588 NONAME ; void QDeclarativePathView::dragMarginChanged(void)
 	?duration@QDeclarativeSmoothedAnimation@@UBEHXZ @ 3589 NONAME ; int QDeclarativeSmoothedAnimation::duration(void) const
-	?elapsed@QDeclarativeItemPrivate@@SAHAAVQTime@@@Z @ 3590 NONAME ; int QDeclarativeItemPrivate::elapsed(class QTime &)
+	?elapsed@QDeclarativeItemPrivate@@SAHAAVQTime@@@Z @ 3590 NONAME ABSENT ; int QDeclarativeItemPrivate::elapsed(class QTime &)
 	?evaluateEnum@QDeclarativeCompiler@@QBEHABVQByteArray@@@Z @ 3591 NONAME ; int QDeclarativeCompiler::evaluateEnum(class QByteArray const &) const
 	?evaluateEnum@QDeclarativeCustomParser@@IBEHABVQByteArray@@@Z @ 3592 NONAME ; int QDeclarativeCustomParser::evaluateEnum(class QByteArray const &) const
 	?event@QDeclarativeGridView@@MAE_NPAVQEvent@@@Z @ 3593 NONAME ; bool QDeclarativeGridView::event(class QEvent *)
@@ -3711,7 +3711,7 @@ EXPORTS
 	?resources_append@QDeclarativeItemPrivate@@SAXPAV?$QDeclarativeListProperty@VQObject@@@@PAVQObject@@@Z @ 3710 NONAME ; void QDeclarativeItemPrivate::resources_append(class QDeclarativeListProperty<class QObject> *, class QObject *)
 	?resources_at@QDeclarativeItemPrivate@@SAPAVQObject@@PAV?$QDeclarativeListProperty@VQObject@@@@H@Z @ 3711 NONAME ; class QObject * QDeclarativeItemPrivate::resources_at(class QDeclarativeListProperty<class QObject> *, int)
 	?resources_count@QDeclarativeItemPrivate@@SAHPAV?$QDeclarativeListProperty@VQObject@@@@@Z @ 3712 NONAME ; int QDeclarativeItemPrivate::resources_count(class QDeclarativeListProperty<class QObject> *)
-	?restart@QDeclarativeItemPrivate@@SAHAAVQTime@@@Z @ 3713 NONAME ; int QDeclarativeItemPrivate::restart(class QTime &)
+	?restart@QDeclarativeItemPrivate@@SAHAAVQTime@@@Z @ 3713 NONAME ABSENT ; int QDeclarativeItemPrivate::restart(class QTime &)
 	?restore@QDeclarativePropertyPrivate@@SA?AVQDeclarativeProperty@@ABVQByteArray@@PAVQObject@@PAVQDeclarativeContextData@@@Z @ 3714 NONAME ; class QDeclarativeProperty QDeclarativePropertyPrivate::restore(class QByteArray const &, class QObject *, class QDeclarativeContextData *)
 	?reversibleChanged@QDeclarativeTransition@@IAEXXZ @ 3715 NONAME ; void QDeclarativeTransition::reversibleChanged(void)
 	?reversingMode@QDeclarativeSmoothedAnimation@@QBE?AW4ReversingMode@1@XZ @ 3716 NONAME ; enum QDeclarativeSmoothedAnimation::ReversingMode QDeclarativeSmoothedAnimation::reversingMode(void) const
@@ -3768,7 +3768,7 @@ EXPORTS
 	?sourceChanged@QDeclarativeXmlListModel@@IAEXXZ @ 3767 NONAME ; void QDeclarativeXmlListModel::sourceChanged(void)
 	?sourceSize@QDeclarativeImageBase@@QBE?AVQSize@@XZ @ 3768 NONAME ; class QSize QDeclarativeImageBase::sourceSize(void) const
 	?sourceSizeChanged@QDeclarativeImageBase@@IAEXXZ @ 3769 NONAME ; void QDeclarativeImageBase::sourceSizeChanged(void)
-	?start@QDeclarativeItemPrivate@@SAXAAVQTime@@@Z @ 3770 NONAME ; void QDeclarativeItemPrivate::start(class QTime &)
+	?start@QDeclarativeItemPrivate@@SAXAAVQTime@@@Z @ 3770 NONAME ABSENT ; void QDeclarativeItemPrivate::start(class QTime &)
 	?startXChanged@QDeclarativePath@@IAEXXZ @ 3771 NONAME ; void QDeclarativePath::startXChanged(void)
 	?startYChanged@QDeclarativePath@@IAEXXZ @ 3772 NONAME ; void QDeclarativePath::startYChanged(void)
 	?states@QDeclarativeItem@@QAE?AV?$QDeclarativeListProperty@VQDeclarativeState@@@@XZ @ 3773 NONAME ABSENT ; class QDeclarativeListProperty<class QDeclarativeState> QDeclarativeItem::states(void)
@@ -3817,7 +3817,7 @@ EXPORTS
 	?staticMetaObject@QDeclarativeWorkerScript@@2UQMetaObject@@B @ 3816 NONAME ; struct QMetaObject const QDeclarativeWorkerScript::staticMetaObject
 	?staticMetaObject@QDeclarativeSmoothedAnimation@@2UQMetaObject@@B @ 3817 NONAME ; struct QMetaObject const QDeclarativeSmoothedAnimation::staticMetaObject
 	?staticMetaObject@QDeclarativeTranslate@@2UQMetaObject@@B @ 3818 NONAME ; struct QMetaObject const QDeclarativeTranslate::staticMetaObject
-	?consistentTime@QDeclarativeItemPrivate@@2HA @ 3819 NONAME ; int QDeclarativeItemPrivate::consistentTime
+	?consistentTime@QDeclarativeItemPrivate@@2HA @ 3819 NONAME ABSENT ; int QDeclarativeItemPrivate::consistentTime
 	??0QDeclarativeAction@@QAE@PAVQObject@@ABVQString@@PAVQDeclarativeContext@@ABVQVariant@@@Z @ 3820 NONAME ; QDeclarativeAction::QDeclarativeAction(class QObject *, class QString const &, class QDeclarativeContext *, class QVariant const &)
 	??0QDeclarativeSmoothedFollow@@QAE@PAVQObject@@@Z @ 3821 NONAME ; QDeclarativeSmoothedFollow::QDeclarativeSmoothedFollow(class QObject *)
 	??1QDeclarativeSmoothedFollow@@UAE@XZ @ 3822 NONAME ; QDeclarativeSmoothedFollow::~QDeclarativeSmoothedFollow(void)
@@ -4020,4 +4020,58 @@ EXPORTS
 	?keyReleasePreHandler@QDeclarativeItem@@IAEXPAVQKeyEvent@@@Z @ 4019 NONAME ; void QDeclarativeItem::keyReleasePreHandler(class QKeyEvent *)
 	?loaded@QDeclarativeLoader@@IAEXXZ @ 4020 NONAME ; void QDeclarativeLoader::loaded(void)
 	?needsCopy@QDeclarativeAnchorChanges@@UAE_NXZ @ 4021 NONAME ; bool QDeclarativeAnchorChanges::needsCopy(void)
+	?closeSoftwareInputPanel@QDeclarativeTextEdit@@QAEXXZ @ 4022 NONAME ; void QDeclarativeTextEdit::closeSoftwareInputPanel(void)
+	?restart@QDeclarativeItemPrivate@@SA_JAAVQElapsedTimer@@@Z @ 4023 NONAME ; long long QDeclarativeItemPrivate::restart(class QElapsedTimer &)
+	?get@QDeclarativeXmlListModel@@QBE?AVQScriptValue@@H@Z @ 4024 NONAME ; class QScriptValue QDeclarativeXmlListModel::get(int) const
+	?setScale@QDeclarativeParentChange@@QAEXVQDeclarativeScriptString@@@Z @ 4025 NONAME ; void QDeclarativeParentChange::setScale(class QDeclarativeScriptString)
+	?showInputPanelOnFocusChanged@QDeclarativeTextEdit@@IAEX_N@Z @ 4026 NONAME ; void QDeclarativeTextEdit::showInputPanelOnFocusChanged(bool)
+	?focusOutEvent@QDeclarativeTextInput@@MAEXPAVQFocusEvent@@@Z @ 4027 NONAME ; void QDeclarativeTextInput::focusOutEvent(class QFocusEvent *)
+	?height@QDeclarativeParentChange@@QBE?AVQDeclarativeScriptString@@XZ @ 4028 NONAME ; class QDeclarativeScriptString QDeclarativeParentChange::height(void) const
+	?showInputPanelOnFocus@QDeclarativeTextEdit@@QBE_NXZ @ 4029 NONAME ; bool QDeclarativeTextEdit::showInputPanelOnFocus(void) const
+	?errorString@QDeclarativeComponent@@QBE?AVQString@@XZ @ 4030 NONAME ; class QString QDeclarativeComponent::errorString(void) const
+	?elapsed@QDeclarativeItemPrivate@@SA_JAAVQElapsedTimer@@@Z @ 4031 NONAME ; long long QDeclarativeItemPrivate::elapsed(class QElapsedTimer &)
+	?focusInEvent@QDeclarativeTextInput@@MAEXPAVQFocusEvent@@@Z @ 4032 NONAME ; void QDeclarativeTextInput::focusInEvent(class QFocusEvent *)
+	?setX@QDeclarativeParentChange@@QAEXVQDeclarativeScriptString@@@Z @ 4033 NONAME ; void QDeclarativeParentChange::setX(class QDeclarativeScriptString)
+	?rotation@QDeclarativeParentChange@@QBE?AVQDeclarativeScriptString@@XZ @ 4034 NONAME ; class QDeclarativeScriptString QDeclarativeParentChange::rotation(void) const
+	?paintedHeight@QDeclarativeTextEdit@@QBEMXZ @ 4035 NONAME ; float QDeclarativeTextEdit::paintedHeight(void) const
+	?paintedWidth@QDeclarativeTextEdit@@QBEMXZ @ 4036 NONAME ; float QDeclarativeTextEdit::paintedWidth(void) const
+	?focusOutEvent@QDeclarativeTextEdit@@MAEXPAVQFocusEvent@@@Z @ 4037 NONAME ; void QDeclarativeTextEdit::focusOutEvent(class QFocusEvent *)
+	??0QDeclarativeExpression@@IAE@PAVQDeclarativeContextData@@PAVQObject@@ABVQString@@AAVQDeclarativeExpressionPrivate@@@Z @ 4038 NONAME ; QDeclarativeExpression::QDeclarativeExpression(class QDeclarativeContextData *, class QObject *, class QString const &, class QDeclarativeExpressionPrivate &)
+	??0QDeclarativeExpression@@QAE@PAVQDeclarativeContext@@PAVQObject@@ABVQString@@1@Z @ 4039 NONAME ; QDeclarativeExpression::QDeclarativeExpression(class QDeclarativeContext *, class QObject *, class QString const &, class QObject *)
+	?queryError@QDeclarativeXmlListModel@@AAEXPAXABVQString@@@Z @ 4040 NONAME ; void QDeclarativeXmlListModel::queryError(void *, class QString const &)
+	?errorString@QDeclarativeXmlListModel@@QBE?AVQString@@XZ @ 4041 NONAME ; class QString QDeclarativeXmlListModel::errorString(void) const
+	?consistentTime@QDeclarativeItemPrivate@@2_JA @ 4042 NONAME ; long long QDeclarativeItemPrivate::consistentTime
+	?scale@QDeclarativeParentChange@@QBE?AVQDeclarativeScriptString@@XZ @ 4043 NONAME ; class QDeclarativeScriptString QDeclarativeParentChange::scale(void) const
+	?showInputPanelOnFocus@QDeclarativeTextInput@@QBE_NXZ @ 4044 NONAME ; bool QDeclarativeTextInput::showInputPanelOnFocus(void) const
+	?focusInEvent@QDeclarativeTextEdit@@MAEXPAVQFocusEvent@@@Z @ 4045 NONAME ; void QDeclarativeTextEdit::focusInEvent(class QFocusEvent *)
+	?y@QDeclarativeParentChange@@QBE?AVQDeclarativeScriptString@@XZ @ 4046 NONAME ; class QDeclarativeScriptString QDeclarativeParentChange::y(void) const
+	?setY@QDeclarativeParentChange@@QAEXVQDeclarativeScriptString@@@Z @ 4047 NONAME ; void QDeclarativeParentChange::setY(class QDeclarativeScriptString)
+	?setShowInputPanelOnFocus@QDeclarativeTextEdit@@QAEX_N@Z @ 4048 NONAME ; void QDeclarativeTextEdit::setShowInputPanelOnFocus(bool)
+	?paintedSizeChanged@QDeclarativeText@@IAEXXZ @ 4049 NONAME ; void QDeclarativeText::paintedSizeChanged(void)
+	?selectByMouseChanged@QDeclarativeTextEdit@@IAEX_N@Z @ 4050 NONAME ; void QDeclarativeTextEdit::selectByMouseChanged(bool)
+	?openSoftwareInputPanel@QDeclarativeTextInput@@QAEXXZ @ 4051 NONAME ; void QDeclarativeTextInput::openSoftwareInputPanel(void)
+	?setShowInputPanelOnFocus@QDeclarativeTextInput@@QAEX_N@Z @ 4052 NONAME ; void QDeclarativeTextInput::setShowInputPanelOnFocus(bool)
+	?boundingRect@QDeclarativePaintedItem@@MBE?AVQRectF@@XZ @ 4053 NONAME ; class QRectF QDeclarativePaintedItem::boundingRect(void) const
+	?closeSoftwareInputPanel@QDeclarativeTextInput@@QAEXXZ @ 4054 NONAME ; void QDeclarativeTextInput::closeSoftwareInputPanel(void)
+	?setWidth@QDeclarativeParentChange@@QAEXVQDeclarativeScriptString@@@Z @ 4055 NONAME ; void QDeclarativeParentChange::setWidth(class QDeclarativeScriptString)
+	?selectByMouse@QDeclarativeTextInput@@QBE_NXZ @ 4056 NONAME ; bool QDeclarativeTextInput::selectByMouse(void) const
+	?setRotation@QDeclarativeParentChange@@QAEXVQDeclarativeScriptString@@@Z @ 4057 NONAME ; void QDeclarativeParentChange::setRotation(class QDeclarativeScriptString)
+	?paintedWidth@QDeclarativeText@@QBEMXZ @ 4058 NONAME ; float QDeclarativeText::paintedWidth(void) const
+	?paintedSizeChanged@QDeclarativeTextEdit@@IAEXXZ @ 4059 NONAME ; void QDeclarativeTextEdit::paintedSizeChanged(void)
+	?setConsistentTime@QDeclarativeItemPrivate@@SAX_J@Z @ 4060 NONAME ; void QDeclarativeItemPrivate::setConsistentTime(long long)
+	??0QDeclarativeExpression@@AAE@PAVQDeclarativeContextData@@PAVQObject@@ABVQString@@@Z @ 4061 NONAME ; QDeclarativeExpression::QDeclarativeExpression(class QDeclarativeContextData *, class QObject *, class QString const &)
+	?event@QDeclarativePathView@@MAE_NPAVQEvent@@@Z @ 4062 NONAME ; bool QDeclarativePathView::event(class QEvent *)
+	?paintedHeight@QDeclarativeText@@QBEMXZ @ 4063 NONAME ; float QDeclarativeText::paintedHeight(void) const
+	?setSelectByMouse@QDeclarativeTextInput@@QAEX_N@Z @ 4064 NONAME ; void QDeclarativeTextInput::setSelectByMouse(bool)
+	?setSelectByMouse@QDeclarativeTextEdit@@QAEX_N@Z @ 4065 NONAME ; void QDeclarativeTextEdit::setSelectByMouse(bool)
+	?selectByMouse@QDeclarativeTextEdit@@QBE_NXZ @ 4066 NONAME ; bool QDeclarativeTextEdit::selectByMouse(void) const
+	?setHeight@QDeclarativeParentChange@@QAEXVQDeclarativeScriptString@@@Z @ 4067 NONAME ; void QDeclarativeParentChange::setHeight(class QDeclarativeScriptString)
+	?start@QDeclarativeItemPrivate@@SAXAAVQElapsedTimer@@@Z @ 4068 NONAME ; void QDeclarativeItemPrivate::start(class QElapsedTimer &)
+	?showInputPanelOnFocusChanged@QDeclarativeTextInput@@IAEX_N@Z @ 4069 NONAME ; void QDeclarativeTextInput::showInputPanelOnFocusChanged(bool)
+	?x@QDeclarativeParentChange@@QBE?AVQDeclarativeScriptString@@XZ @ 4070 NONAME ; class QDeclarativeScriptString QDeclarativeParentChange::x(void) const
+	?selectByMouseChanged@QDeclarativeTextInput@@IAEX_N@Z @ 4071 NONAME ; void QDeclarativeTextInput::selectByMouseChanged(bool)
+	?width@QDeclarativeParentChange@@QBE?AVQDeclarativeScriptString@@XZ @ 4072 NONAME ; class QDeclarativeScriptString QDeclarativeParentChange::width(void) const
+	?openSoftwareInputPanel@QDeclarativeTextEdit@@QAEXXZ @ 4073 NONAME ; void QDeclarativeTextEdit::openSoftwareInputPanel(void)
+	?cursorRectangleChanged@QDeclarativeTextEdit@@IAEXXZ @ 4074 NONAME ; void QDeclarativeTextEdit::cursorRectangleChanged(void)
+	?cursorRectangle@QDeclarativeTextEdit@@QBE?AVQRect@@XZ @ 4075 NONAME ; class QRect QDeclarativeTextEdit::cursorRectangle(void) const
 
diff --git a/src/s60installs/bwins/QtGuiu.def b/src/s60installs/bwins/QtGuiu.def
index 15addf6..a1e05e2 100644
--- a/src/s60installs/bwins/QtGuiu.def
+++ b/src/s60installs/bwins/QtGuiu.def
@@ -12548,274 +12548,261 @@ EXPORTS
 	?timerEvent@QS60Style@@MAEXPAVQTimerEvent@@@Z @ 12547 NONAME ; void QS60Style::timerEvent(class QTimerEvent *)
 	?updateAncestorFlags@QGraphicsItemPrivate@@QAEXXZ @ 12548 NONAME ; void QGraphicsItemPrivate::updateAncestorFlags(void)
 	?updateChildWithGraphicsEffectFlagRecursively@QGraphicsItemPrivate@@QAEXXZ @ 12549 NONAME ; void QGraphicsItemPrivate::updateChildWithGraphicsEffectFlagRecursively(void)
-	?isOpacityNull@QGraphicsItemPrivate@@SA_NM@Z @ 12550 NONAME ; bool QGraphicsItemPrivate::isOpacityNull(float)
-	?isOpacityNull@QGraphicsItemPrivate@@QBE_NXZ @ 12551 NONAME ; bool QGraphicsItemPrivate::isOpacityNull(void) const
-	?api@QEglContext@@QBE?AW4API@QEgl@@XZ @ 12552 NONAME ABSENT ; enum QEgl::API QEglContext::api(void) const
+	?api@QEglContext@@QBE?AW4API@QEgl@@XZ @ 12550 NONAME ; enum QEgl::API QEglContext::api(void) const
+	?display@QEglContext@@SAHXZ @ 12551 NONAME ABSENT ; int QEglContext::display(void)
+	?isOpacityNull@QGraphicsItemPrivate@@SA_NM@Z @ 12552 NONAME ; bool QGraphicsItemPrivate::isOpacityNull(float)
 	?chooseConfig@QEglContext@@QAE_NABVQEglProperties@@W4PixelFormatMatch@QEgl@@@Z @ 12553 NONAME ; bool QEglContext::chooseConfig(class QEglProperties const &, enum QEgl::PixelFormatMatch)
 	?destroySurface@QEglContext@@QAEXH@Z @ 12554 NONAME ; void QEglContext::destroySurface(int)
 	?lazyDoneCurrent@QEglContext@@QAE_NXZ @ 12555 NONAME ; bool QEglContext::lazyDoneCurrent(void)
 	?waitNative@QEglContext@@QAEXXZ @ 12556 NONAME ABSENT ; void QEglContext::waitNative(void)
-	?context@QEglContext@@QBEHXZ @ 12557 NONAME ABSENT ; int QEglContext::context(void) const
+	?context@QEglContext@@QBEHXZ @ 12557 NONAME ; int QEglContext::context(void) const
 	?configAttrib@QEglContext@@QBE_NHPAH@Z @ 12558 NONAME ABSENT ; bool QEglContext::configAttrib(int, int *) const
 	??0QEglProperties@@QAE@ABV0@@Z @ 12559 NONAME ; QEglProperties::QEglProperties(class QEglProperties const &)
-	?config@QEglContext@@QBEHXZ @ 12560 NONAME ABSENT ; int QEglContext::config(void) const
-	?openDisplay@QEglContext@@QAE_NPAVQPaintDevice@@@Z @ 12561 NONAME ABSENT ; bool QEglContext::openDisplay(class QPaintDevice *)
+	?config@QEglContext@@QBEHXZ @ 12560 NONAME ; int QEglContext::config(void) const
+	?clearFocusHelper@QGraphicsItemPrivate@@QAEX_N@Z @ 12561 NONAME ; void QGraphicsItemPrivate::clearFocusHelper(bool)
 	?error@QEglContext@@SAHXZ @ 12562 NONAME ABSENT ; int QEglContext::error(void)
 	?swapBuffers@QEglContext@@QAE_NH@Z @ 12563 NONAME ; bool QEglContext::swapBuffers(int)
-	?setApi@QEglContext@@QAEXW4API@QEgl@@@Z @ 12564 NONAME ; void QEglContext::setApi(enum QEgl::API)
-	?makeCurrent@QEglContext@@QAE_NH@Z @ 12565 NONAME ; bool QEglContext::makeCurrent(int)
-	?createSurface@QEglContext@@QAEHPAVQPaintDevice@@PBVQEglProperties@@@Z @ 12566 NONAME ; int QEglContext::createSurface(class QPaintDevice *, class QEglProperties const *)
-	?dumpAllConfigs@QEglContext@@QAEXXZ @ 12567 NONAME ABSENT ; void QEglContext::dumpAllConfigs(void)
-	?reduceConfiguration@QEglProperties@@QAE_NXZ @ 12568 NONAME ; bool QEglProperties::reduceConfiguration(void)
-	?removeValue@QEglProperties@@QAE_NH@Z @ 12569 NONAME ; bool QEglProperties::removeValue(int)
-	?toString@QEglProperties@@QBE?AVQString@@XZ @ 12570 NONAME ; class QString QEglProperties::toString(void) const
-	?dumpAllConfigs@QEglProperties@@SAXXZ @ 12571 NONAME ABSENT ; void QEglProperties::dumpAllConfigs(void)
-	?defaultDisplay@QEglContext@@SAHPAVQPaintDevice@@@Z @ 12572 NONAME ABSENT ; int QEglContext::defaultDisplay(class QPaintDevice *)
-	?configProperties@QEglContext@@QBE?AVQEglProperties@@H@Z @ 12573 NONAME ABSENT ; class QEglProperties QEglContext::configProperties(int) const
-	?properties@QEglProperties@@QBEPBHXZ @ 12574 NONAME ; int const * QEglProperties::properties(void) const
-	??0QEglContext@@QAE@XZ @ 12575 NONAME ; QEglContext::QEglContext(void)
-	??1QEglContext@@QAE@XZ @ 12576 NONAME ; QEglContext::~QEglContext(void)
-	?isValid@QEglContext@@QBE_NXZ @ 12577 NONAME ; bool QEglContext::isValid(void) const
-	?value@QEglProperties@@QBEHH@Z @ 12578 NONAME ; int QEglProperties::value(int) const
-	?clearError@QEglContext@@SAXXZ @ 12579 NONAME ABSENT ; void QEglContext::clearError(void)
-	??0QEglProperties@@QAE@H@Z @ 12580 NONAME ; QEglProperties::QEglProperties(int)
-	?setValue@QEglProperties@@QAEXHH@Z @ 12581 NONAME ; void QEglProperties::setValue(int, int)
-	?setPaintDeviceFormat@QEglProperties@@QAEXPAVQPaintDevice@@@Z @ 12582 NONAME ; void QEglProperties::setPaintDeviceFormat(class QPaintDevice *)
-	?destroy@QEglContext@@QAEXXZ @ 12583 NONAME ABSENT ; void QEglContext::destroy(void)
-	?setRenderableType@QEglProperties@@QAEXW4API@QEgl@@@Z @ 12584 NONAME ; void QEglProperties::setRenderableType(enum QEgl::API)
-	?setContext@QEglContext@@QAEXH@Z @ 12585 NONAME ; void QEglContext::setContext(int)
-	?waitClient@QEglContext@@QAEXXZ @ 12586 NONAME ABSENT ; void QEglContext::waitClient(void)
-	?isEmpty@QEglProperties@@QBE_NXZ @ 12587 NONAME ; bool QEglProperties::isEmpty(void) const
-	?getDisplay@QEglContext@@CAHPAVQPaintDevice@@@Z @ 12588 NONAME ABSENT ; int QEglContext::getDisplay(class QPaintDevice *)
-	?isSharing@QEglContext@@QBE_NXZ @ 12589 NONAME ; bool QEglContext::isSharing(void) const
-	?isCurrent@QEglContext@@QBE_NXZ @ 12590 NONAME ; bool QEglContext::isCurrent(void) const
-	??0QEglProperties@@QAE@XZ @ 12591 NONAME ; QEglProperties::QEglProperties(void)
-	?extensions@QEglContext@@SA?AVQString@@XZ @ 12592 NONAME ABSENT ; class QString QEglContext::extensions(void)
-	?setCurrentContext@QEglContext@@CAXW4API@QEgl@@PAV1@@Z @ 12593 NONAME ; void QEglContext::setCurrentContext(enum QEgl::API, class QEglContext *)
-	??1QEglProperties@@QAE@XZ @ 12594 NONAME ; QEglProperties::~QEglProperties(void)
-	?createContext@QEglContext@@QAE_NPAV1@PBVQEglProperties@@@Z @ 12595 NONAME ; bool QEglContext::createContext(class QEglContext *, class QEglProperties const *)
-	?setConfig@QEglContext@@QAEXH@Z @ 12596 NONAME ; void QEglContext::setConfig(int)
-	?hasExtension@QEglContext@@SA_NPBD@Z @ 12597 NONAME ABSENT ; bool QEglContext::hasExtension(char const *)
-	?doneCurrent@QEglContext@@QAE_NXZ @ 12598 NONAME ; bool QEglContext::doneCurrent(void)
-	?display@QEglContext@@QBEHXZ @ 12599 NONAME ABSENT ; int QEglContext::display(void) const
-	?setPixelFormat@QEglProperties@@QAEXW4Format@QImage@@@Z @ 12600 NONAME ; void QEglProperties::setPixelFormat(enum QImage::Format)
-	?currentContext@QEglContext@@CAPAV1@W4API@QEgl@@@Z @ 12601 NONAME ; class QEglContext * QEglContext::currentContext(enum QEgl::API)
-	?errorString@QEglContext@@SA?AVQString@@H@Z @ 12602 NONAME ABSENT ; class QString QEglContext::errorString(int)
-	?removeAllApplicationFonts@QFontDatabase@@SA_NXZ @ 12603 NONAME ; bool QFontDatabase::removeAllApplicationFonts()
-	??0FileInfo@QZipReader@@QAE@XZ @ 12604 NONAME ; QZipReader::FileInfo::FileInfo(void)
-	??0QAbstractScrollAreaPrivate@@QAE@XZ @ 12605 NONAME ; QAbstractScrollAreaPrivate::QAbstractScrollAreaPrivate(void)
-	??0QGraphicsViewPrivate@@QAE@XZ @ 12606 NONAME ; QGraphicsViewPrivate::QGraphicsViewPrivate(void)
-	??0QKeySequence@@QAE@ABVQString@@W4SequenceFormat@0@@Z @ 12607 NONAME ; QKeySequence::QKeySequence(class QString const &, enum QKeySequence::SequenceFormat)
-	??0QStaticText@@QAE@ABV0@@Z @ 12608 NONAME ; QStaticText::QStaticText(class QStaticText const &)
-	??0QStaticText@@QAE@ABVQString@@ABVQSizeF@@@Z @ 12609 NONAME ABSENT ; QStaticText::QStaticText(class QString const &, class QSizeF const &)
-	??0QStaticText@@QAE@XZ @ 12610 NONAME ; QStaticText::QStaticText(void)
-	??0QStaticTextItem@@QAE@XZ @ 12611 NONAME ; QStaticTextItem::QStaticTextItem(void)
-	??0QZipReader@@QAE@ABVQString@@V?$QFlags@W4OpenModeFlag@QIODevice@@@@@Z @ 12612 NONAME ; QZipReader::QZipReader(class QString const &, class QFlags<enum QIODevice::OpenModeFlag>)
-	??0QZipReader@@QAE@PAVQIODevice@@@Z @ 12613 NONAME ; QZipReader::QZipReader(class QIODevice *)
-	??1FileInfo@QZipReader@@QAE@XZ @ 12614 NONAME ; QZipReader::FileInfo::~FileInfo(void)
-	??1QAbstractScrollAreaPrivate@@UAE@XZ @ 12615 NONAME ; QAbstractScrollAreaPrivate::~QAbstractScrollAreaPrivate(void)
-	??1QGraphicsViewPrivate@@UAE@XZ @ 12616 NONAME ; QGraphicsViewPrivate::~QGraphicsViewPrivate(void)
-	??1QStaticText@@QAE@XZ @ 12617 NONAME ; QStaticText::~QStaticText(void)
-	??1QStaticTextItem@@QAE@XZ @ 12618 NONAME ; QStaticTextItem::~QStaticTextItem(void)
-	??1QZipReader@@QAE@XZ @ 12619 NONAME ; QZipReader::~QZipReader(void)
-	??4FileInfo@QZipReader@@QAEAAU01@ABU01@@Z @ 12620 NONAME ; struct QZipReader::FileInfo & QZipReader::FileInfo::operator=(struct QZipReader::FileInfo const &)
-	??4QStaticText@@QAEAAV0@ABV0@@Z @ 12621 NONAME ; class QStaticText & QStaticText::operator=(class QStaticText const &)
-	??8QStaticText@@QBE_NABV0@@Z @ 12622 NONAME ; bool QStaticText::operator==(class QStaticText const &) const
-	??9QStaticText@@QBE_NABV0@@Z @ 12623 NONAME ; bool QStaticText::operator!=(class QStaticText const &) const
-	??_EQAbstractScrollAreaPrivate@@UAE@I@Z @ 12624 NONAME ; QAbstractScrollAreaPrivate::~QAbstractScrollAreaPrivate(unsigned int)
-	??_EQGraphicsViewPrivate@@UAE@I@Z @ 12625 NONAME ; QGraphicsViewPrivate::~QGraphicsViewPrivate(unsigned int)
-	?_q_hslide@QAbstractScrollAreaPrivate@@QAEXH@Z @ 12626 NONAME ; void QAbstractScrollAreaPrivate::_q_hslide(int)
+	?canKeypadNavigate@QWidgetPrivate@@SA_NW4Orientation@Qt@@@Z @ 12564 NONAME ; bool QWidgetPrivate::canKeypadNavigate(enum Qt::Orientation)
+	?removeAllApplicationFonts@QFontDatabase@@SA_NXZ @ 12565 NONAME ; bool QFontDatabase::removeAllApplicationFonts(void)
+	?setApi@QEglContext@@QAEXW4API@QEgl@@@Z @ 12566 NONAME ; void QEglContext::setApi(enum QEgl::API)
+	?updateDisplayText@QLineControl@@AAEX_N@Z @ 12567 NONAME ; void QLineControl::updateDisplayText(bool)
+	?makeCurrent@QEglContext@@QAE_NH@Z @ 12568 NONAME ; bool QEglContext::makeCurrent(int)
+	?isPixmapCached@QImagePixmapCleanupHooks@@SA_NABVQPixmap@@@Z @ 12569 NONAME ; bool QImagePixmapCleanupHooks::isPixmapCached(class QPixmap const &)
+	?createSurface@QEglContext@@QAEHPAVQPaintDevice@@PBVQEglProperties@@@Z @ 12570 NONAME ; int QEglContext::createSurface(class QPaintDevice *, class QEglProperties const *)
+	?dumpAllConfigs@QEglContext@@QAEXXZ @ 12571 NONAME ABSENT ; void QEglContext::dumpAllConfigs(void)
+	?reduceConfiguration@QEglProperties@@QAE_NXZ @ 12572 NONAME ; bool QEglProperties::reduceConfiguration(void)
+	?nativeDisplay@QEglContext@@CAHXZ @ 12573 NONAME ABSENT ; int QEglContext::nativeDisplay(void)
+	?getGlyphBearings@QFontEngine@@UAEXIPAM0@Z @ 12574 NONAME ; void QFontEngine::getGlyphBearings(unsigned int, float *, float *)
+	?removeValue@QEglProperties@@QAE_NH@Z @ 12575 NONAME ; bool QEglProperties::removeValue(int)
+	?toString@QEglProperties@@QBE?AVQString@@XZ @ 12576 NONAME ; class QString QEglProperties::toString(void) const
+	?isOpacityNull@QGraphicsItemPrivate@@QBE_NXZ @ 12577 NONAME ; bool QGraphicsItemPrivate::isOpacityNull(void) const
+	?dumpAllConfigs@QEglProperties@@SAXXZ @ 12578 NONAME ABSENT ; void QEglProperties::dumpAllConfigs(void)
+	?inTabWidget@QWidgetPrivate@@SA_NPAVQWidget@@@Z @ 12579 NONAME ; bool QWidgetPrivate::inTabWidget(class QWidget *)
+	?configProperties@QEglContext@@QBE?AVQEglProperties@@H@Z @ 12580 NONAME ABSENT ; class QEglProperties QEglContext::configProperties(int) const
+	?properties@QEglProperties@@QBEPBHXZ @ 12581 NONAME ; int const * QEglProperties::properties(void) const
+	?destroyContext@QEglContext@@QAEXXZ @ 12582 NONAME ; void QEglContext::destroyContext(void)
+	??0QEglContext@@QAE@XZ @ 12583 NONAME ; QEglContext::QEglContext(void)
+	??1QEglContext@@QAE@XZ @ 12584 NONAME ; QEglContext::~QEglContext(void)
+	?isValid@QEglContext@@QBE_NXZ @ 12585 NONAME ; bool QEglContext::isValid(void) const
+	?value@QEglProperties@@QBEHH@Z @ 12586 NONAME ; int QEglProperties::value(int) const
+	?clearError@QEglContext@@SAXXZ @ 12587 NONAME ABSENT ; void QEglContext::clearError(void)
+	??0QEglProperties@@QAE@H@Z @ 12588 NONAME ; QEglProperties::QEglProperties(int)
+	?setValue@QEglProperties@@QAEXHH@Z @ 12589 NONAME ; void QEglProperties::setValue(int, int)
+	?setPaintDeviceFormat@QEglProperties@@QAEXPAVQPaintDevice@@@Z @ 12590 NONAME ; void QEglProperties::setPaintDeviceFormat(class QPaintDevice *)
+	?isImageCached@QImagePixmapCleanupHooks@@SA_NABVQImage@@@Z @ 12591 NONAME ; bool QImagePixmapCleanupHooks::isImageCached(class QImage const &)
+	?setRenderableType@QEglProperties@@QAEXW4API@QEgl@@@Z @ 12592 NONAME ; void QEglProperties::setRenderableType(enum QEgl::API)
+	?setContext@QEglContext@@QAEXH@Z @ 12593 NONAME ; void QEglContext::setContext(int)
+	?waitClient@QEglContext@@QAEXXZ @ 12594 NONAME ABSENT ; void QEglContext::waitClient(void)
+	?isEmpty@QEglProperties@@QBE_NXZ @ 12595 NONAME ; bool QEglProperties::isEmpty(void) const
+	?dpy@QEglContext@@0HA @ 12596 NONAME ABSENT ; int QEglContext::dpy
+	?isSharing@QEglContext@@QBE_NXZ @ 12597 NONAME ; bool QEglContext::isSharing(void) const
+	?isCurrent@QEglContext@@QBE_NXZ @ 12598 NONAME ; bool QEglContext::isCurrent(void) const
+	??0QEglProperties@@QAE@XZ @ 12599 NONAME ; QEglProperties::QEglProperties(void)
+	?extensions@QEglContext@@SA?AVQString@@XZ @ 12600 NONAME ABSENT ; class QString QEglContext::extensions(void)
+	?setCurrentContext@QEglContext@@CAXW4API@QEgl@@PAV1@@Z @ 12601 NONAME ; void QEglContext::setCurrentContext(enum QEgl::API, class QEglContext *)
+	??1QEglProperties@@QAE@XZ @ 12602 NONAME ; QEglProperties::~QEglProperties(void)
+	?createContext@QEglContext@@QAE_NPAV1@PBVQEglProperties@@@Z @ 12603 NONAME ; bool QEglContext::createContext(class QEglContext *, class QEglProperties const *)
+	?setConfig@QEglContext@@QAEXH@Z @ 12604 NONAME ; void QEglContext::setConfig(int)
+	?hasExtension@QEglContext@@SA_NPBD@Z @ 12605 NONAME ABSENT ; bool QEglContext::hasExtension(char const *)
+	?doneCurrent@QEglContext@@QAE_NXZ @ 12606 NONAME ; bool QEglContext::doneCurrent(void)
+	?setPixelFormat@QEglProperties@@QAEXW4Format@QImage@@@Z @ 12607 NONAME ; void QEglProperties::setPixelFormat(enum QImage::Format)
+	?currentContext@QEglContext@@CAPAV1@W4API@QEgl@@@Z @ 12608 NONAME ; class QEglContext * QEglContext::currentContext(enum QEgl::API)
+	?setFocusHelper@QGraphicsItemPrivate@@QAEXW4FocusReason@Qt@@_N1@Z @ 12609 NONAME ; void QGraphicsItemPrivate::setFocusHelper(enum Qt::FocusReason, bool, bool)
+	?errorString@QEglContext@@SA?AVQString@@H@Z @ 12610 NONAME ABSENT ; class QString QEglContext::errorString(int)
+	?positionInBlock@QTextCursor@@QBEHXZ @ 12611 NONAME ; int QTextCursor::positionInBlock(void) const
+	?height@QGraphicsItemPrivate@@UBEMXZ @ 12612 NONAME ; float QGraphicsItemPrivate::height(void) const
+	?clearUndoRedoStacks@QTextDocument@@QAEXW4Stacks@1@@Z @ 12613 NONAME ; void QTextDocument::clearUndoRedoStacks(enum QTextDocument::Stacks)
+	?mapToViewRect@QGraphicsViewPrivate@@QBE?AVQRect@@PBVQGraphicsItem@@ABVQRectF@@@Z @ 12614 NONAME ; class QRect QGraphicsViewPrivate::mapToViewRect(class QGraphicsItem const *, class QRectF const &) const
+	?findItems@QGraphicsViewPrivate@@QBE?AV?$QList@PAVQGraphicsItem@@@@ABVQRegion@@PA_NABVQTransform@@@Z @ 12615 NONAME ; class QList<class QGraphicsItem *> QGraphicsViewPrivate::findItems(class QRegion const &, bool *, class QTransform const &) const
+	?constScanLine@QImage@@QBEPBEH@Z @ 12616 NONAME ; unsigned char const * QImage::constScanLine(int) const
+	?text@QStaticText@@QBE?AVQString@@XZ @ 12617 NONAME ; class QString QStaticText::text(void) const
+	?updateLastCenterPoint@QGraphicsViewPrivate@@QAEXXZ @ 12618 NONAME ; void QGraphicsViewPrivate::updateLastCenterPoint(void)
+	?sideWidget@QWizard@@QBEPAVQWidget@@XZ @ 12619 NONAME ; class QWidget * QWizard::sideWidget(void) const
+	?verticalScroll@QGraphicsViewPrivate@@QBE_JXZ @ 12620 NONAME ; long long QGraphicsViewPrivate::verticalScroll(void) const
+	?fileInfoList@QZipReader@@QBE?AV?$QList@UFileInfo@QZipReader@@@@XZ @ 12621 NONAME ; class QList<struct QZipReader::FileInfo> QZipReader::fileInfoList(void) const
+	?setSideWidget@QWizard@@QAEXPAVQWidget@@@Z @ 12622 NONAME ; void QWizard::setSideWidget(class QWidget *)
+	?paste@QLineControl@@QAEXW4Mode@QClipboard@@@Z @ 12623 NONAME ; void QLineControl::paste(enum QClipboard::Mode)
+	?performanceHint@QStaticText@@QBE?AW4PerformanceHint@1@XZ @ 12624 NONAME ; enum QStaticText::PerformanceHint QStaticText::performanceHint(void) const
+	?frameStartIndex@QPaintBuffer@@QBEHH@Z @ 12625 NONAME ; int QPaintBuffer::frameStartIndex(int) const
+	??0QAbstractScrollAreaPrivate@@QAE@XZ @ 12626 NONAME ; QAbstractScrollAreaPrivate::QAbstractScrollAreaPrivate(void)
 	?_q_setViewportCursor@QGraphicsViewPrivate@@QAEXABVQCursor@@@Z @ 12627 NONAME ; void QGraphicsViewPrivate::_q_setViewportCursor(class QCursor const &)
-	?_q_showOrHideScrollBars@QAbstractScrollAreaPrivate@@QAEXXZ @ 12628 NONAME ; void QAbstractScrollAreaPrivate::_q_showOrHideScrollBars(void)
-	?_q_unsetViewportCursor@QGraphicsViewPrivate@@QAEXXZ @ 12629 NONAME ; void QGraphicsViewPrivate::_q_unsetViewportCursor(void)
-	?_q_vslide@QAbstractScrollAreaPrivate@@QAEXH@Z @ 12630 NONAME ; void QAbstractScrollAreaPrivate::_q_vslide(int)
-	?allocStyleOptionsArray@QGraphicsViewPrivate@@QAEPAVQStyleOptionGraphicsItem@@H@Z @ 12631 NONAME ; class QStyleOptionGraphicsItem * QGraphicsViewPrivate::allocStyleOptionsArray(int)
-	?anchorAt@QPlainTextEdit@@QBE?AVQString@@ABVQPoint@@@Z @ 12632 NONAME ; class QString QPlainTextEdit::anchorAt(class QPoint const &) const
-	?assign@QKeySequence@@AAEHABVQString@@W4SequenceFormat@1@@Z @ 12633 NONAME ; int QKeySequence::assign(class QString const &, enum QKeySequence::SequenceFormat)
-	?autoFillBackground@QGraphicsWidget@@QBE_NXZ @ 12634 NONAME ; bool QGraphicsWidget::autoFillBackground(void) const
-	?canKeypadNavigate@QWidgetPrivate@@SA_NW4Orientation@Qt@@@Z @ 12635 NONAME ; bool QWidgetPrivate::canKeypadNavigate(enum Qt::Orientation)
-	?centerView@QGraphicsViewPrivate@@QAEXW4ViewportAnchor@QGraphicsView@@@Z @ 12636 NONAME ; void QGraphicsViewPrivate::centerView(enum QGraphicsView::ViewportAnchor)
-	?clearUndoRedoStacks@QTextDocument@@QAEXW4Stacks@1@@Z @ 12637 NONAME ; void QTextDocument::clearUndoRedoStacks(enum QTextDocument::Stacks)
-	?close@QZipReader@@QAEXXZ @ 12638 NONAME ; void QZipReader::close(void)
-	?constBits@QImage@@QBEPBEXZ @ 12639 NONAME ; unsigned char const * QImage::constBits(void) const
-	?constScanLine@QImage@@QBEPBEH@Z @ 12640 NONAME ; unsigned char const * QImage::constScanLine(int) const
-	?contentsOffset@QAbstractScrollAreaPrivate@@UBE?AVQPoint@@XZ @ 12641 NONAME ; class QPoint QAbstractScrollAreaPrivate::contentsOffset(void) const
-	?convertFromImage@QPixmap@@QAE_NABVQImage@@V?$QFlags@W4ImageConversionFlag@Qt@@@@@Z @ 12642 NONAME ; bool QPixmap::convertFromImage(class QImage const &, class QFlags<enum Qt::ImageConversionFlag>)
-	?count@QZipReader@@QBEHXZ @ 12643 NONAME ; int QZipReader::count(void) const
-	?create@Fragment@QPainter@@SA?AV12@ABVQPointF@@ABVQRectF@@MMMM@Z @ 12644 NONAME ABSENT ; class QPainter::Fragment QPainter::Fragment::create(class QPointF const &, class QRectF const &, float, float, float, float)
-	?detach@QStaticText@@AAEXXZ @ 12645 NONAME ; void QStaticText::detach(void)
-	?directoryLoaded@QFileSystemModel@@IAEXABVQString@@@Z @ 12646 NONAME ; void QFileSystemModel::directoryLoaded(class QString const &)
-	?dispatchPendingUpdateRequests@QGraphicsViewPrivate@@QAEXXZ @ 12647 NONAME ; void QGraphicsViewPrivate::dispatchPendingUpdateRequests(void)
-	?drawPixmapFragments@QPaintEngineEx@@UAEXPBVFragment@QPainter@@HABVQPixmap@@V?$QFlags@W4FragmentHint@QPainter@@@@@Z @ 12648 NONAME ABSENT ; void QPaintEngineEx::drawPixmapFragments(class QPainter::Fragment const *, int, class QPixmap const &, class QFlags<enum QPainter::FragmentHint>)
-	?drawPixmapFragments@QPainter@@QAEXPBVFragment@1@HABVQPixmap@@V?$QFlags@W4FragmentHint@QPainter@@@@@Z @ 12649 NONAME ABSENT ; void QPainter::drawPixmapFragments(class QPainter::Fragment const *, int, class QPixmap const &, class QFlags<enum QPainter::FragmentHint>)
-	?drawStaticText@QPainter@@QAEXABVQPoint@@ABVQStaticText@@@Z @ 12650 NONAME ; void QPainter::drawStaticText(class QPoint const &, class QStaticText const &)
-	?drawStaticText@QPainter@@QAEXABVQPointF@@ABVQStaticText@@@Z @ 12651 NONAME ; void QPainter::drawStaticText(class QPointF const &, class QStaticText const &)
-	?drawStaticText@QPainter@@QAEXHHABVQStaticText@@@Z @ 12652 NONAME ; void QPainter::drawStaticText(int, int, class QStaticText const &)
-	?entryInfoAt@QZipReader@@QBE?AUFileInfo@1@H@Z @ 12653 NONAME ; struct QZipReader::FileInfo QZipReader::entryInfoAt(int) const
-	?exists@QZipReader@@QBE_NXZ @ 12654 NONAME ; bool QZipReader::exists(void) const
-	?extractAll@QZipReader@@QBE_NABVQString@@@Z @ 12655 NONAME ; bool QZipReader::extractAll(class QString const &) const
-	?fileData@QZipReader@@QBE?AVQByteArray@@ABVQString@@@Z @ 12656 NONAME ; class QByteArray QZipReader::fileData(class QString const &) const
-	?fileInfoList@QZipReader@@QBE?AV?$QList@UFileInfo@QZipReader@@@@XZ @ 12657 NONAME ; class QList<struct QZipReader::FileInfo> QZipReader::fileInfoList(void) const
-	?findItems@QGraphicsViewPrivate@@QBE?AV?$QList@PAVQGraphicsItem@@@@ABVQRegion@@PA_NABVQTransform@@@Z @ 12658 NONAME ; class QList<class QGraphicsItem *> QGraphicsViewPrivate::findItems(class QRegion const &, bool *, class QTransform const &) const
-	?fixup@QIntValidator@@UBEXAAVQString@@@Z @ 12659 NONAME ; void QIntValidator::fixup(class QString &) const
-	?freeStyleOptionsArray@QGraphicsViewPrivate@@QAEXPAVQStyleOptionGraphicsItem@@@Z @ 12660 NONAME ; void QGraphicsViewPrivate::freeStyleOptionsArray(class QStyleOptionGraphicsItem *)
-	?getPixmapCursor@QApplicationPrivate@@QAE?AVQPixmap@@W4CursorShape@Qt@@@Z @ 12661 NONAME ; class QPixmap QApplicationPrivate::getPixmapCursor(enum Qt::CursorShape)
-	?getSubRange@QBezier@@QBE?AV1@MM@Z @ 12662 NONAME ; class QBezier QBezier::getSubRange(float, float) const
-	?hasSelectedText@QLabel@@QBE_NXZ @ 12663 NONAME ; bool QLabel::hasSelectedText(void) const
-	?horizontalScroll@QGraphicsViewPrivate@@QBE_JXZ @ 12664 NONAME ; long long QGraphicsViewPrivate::horizontalScroll(void) const
-	?inTabWidget@QWidgetPrivate@@SA_NPAVQWidget@@@Z @ 12665 NONAME ; bool QWidgetPrivate::inTabWidget(class QWidget *)
-	?init@QAbstractScrollAreaPrivate@@QAEXXZ @ 12666 NONAME ; void QAbstractScrollAreaPrivate::init(void)
-	?isImageCached@QImagePixmapCleanupHooks@@SA_NABVQImage@@@Z @ 12667 NONAME ; bool QImagePixmapCleanupHooks::isImageCached(class QImage const &)
-	?isPixmapCached@QImagePixmapCleanupHooks@@SA_NABVQPixmap@@@Z @ 12668 NONAME ; bool QImagePixmapCleanupHooks::isPixmapCached(class QPixmap const &)
-	?isReadable@QZipReader@@QBE_NXZ @ 12669 NONAME ; bool QZipReader::isReadable(void) const
-	?isValidColor@QColor@@SA_NABVQString@@@Z @ 12670 NONAME ; bool QColor::isValidColor(class QString const &)
-	?layoutChildren@QAbstractScrollAreaPrivate@@QAEXXZ @ 12671 NONAME ; void QAbstractScrollAreaPrivate::layoutChildren(void)
-	?mapBy@QBezier@@QBE?AV1@ABVQTransform@@@Z @ 12672 NONAME ; class QBezier QBezier::mapBy(class QTransform const &) const
-	?mapRectFromScene@QGraphicsViewPrivate@@QBE?AVQRectF@@ABV2@@Z @ 12673 NONAME ; class QRectF QGraphicsViewPrivate::mapRectFromScene(class QRectF const &) const
-	?mapRectToScene@QGraphicsViewPrivate@@QBE?AVQRectF@@ABVQRect@@@Z @ 12674 NONAME ; class QRectF QGraphicsViewPrivate::mapRectToScene(class QRect const &) const
-	?mapToScene@QGraphicsViewPrivate@@QBE?AVQPointF@@ABV2@@Z @ 12675 NONAME ; class QPointF QGraphicsViewPrivate::mapToScene(class QPointF const &) const
-	?mapToScene@QGraphicsViewPrivate@@QBE?AVQRectF@@ABV2@@Z @ 12676 NONAME ; class QRectF QGraphicsViewPrivate::mapToScene(class QRectF const &) const
-	?mapToViewRect@QGraphicsViewPrivate@@QBE?AVQRect@@PBVQGraphicsItem@@ABVQRectF@@@Z @ 12677 NONAME ; class QRect QGraphicsViewPrivate::mapToViewRect(class QGraphicsItem const *, class QRectF const &) const
-	?mapToViewRegion@QGraphicsViewPrivate@@QBE?AVQRegion@@PBVQGraphicsItem@@ABVQRectF@@@Z @ 12678 NONAME ; class QRegion QGraphicsViewPrivate::mapToViewRegion(class QGraphicsItem const *, class QRectF const &) const
-	?maximumSize@QStaticText@@QBE?AVQSizeF@@XZ @ 12679 NONAME ABSENT ; class QSizeF QStaticText::maximumSize(void) const
-	?mouseMoveEventHandler@QGraphicsViewPrivate@@QAEXPAVQMouseEvent@@@Z @ 12680 NONAME ; void QGraphicsViewPrivate::mouseMoveEventHandler(class QMouseEvent *)
-	?performanceHint@QStaticText@@QBE?AW4PerformanceHint@1@XZ @ 12681 NONAME ; enum QStaticText::PerformanceHint QStaticText::performanceHint(void) const
-	?populate@QTextureGlyphCache@@QAEXPAVQFontEngine@@HPBIPBUQFixedPoint@@@Z @ 12682 NONAME ; void QTextureGlyphCache::populate(class QFontEngine *, int, unsigned int const *, struct QFixedPoint const *)
-	?populateSceneDragDropEvent@QGraphicsViewPrivate@@QAEXPAVQGraphicsSceneDragDropEvent@@PAVQDropEvent@@@Z @ 12683 NONAME ; void QGraphicsViewPrivate::populateSceneDragDropEvent(class QGraphicsSceneDragDropEvent *, class QDropEvent *)
-	?positionInBlock@QTextCursor@@QBEHXZ @ 12684 NONAME ; int QTextCursor::positionInBlock(void) const
-	?prepare@QStaticText@@QAEXABVQTransform@@ABVQFont@@@Z @ 12685 NONAME ; void QStaticText::prepare(class QTransform const &, class QFont const &)
-	?processPendingUpdates@QGraphicsViewPrivate@@QAEXXZ @ 12686 NONAME ; void QGraphicsViewPrivate::processPendingUpdates(void)
-	?q_func@QAbstractScrollAreaPrivate@@AAEPAVQAbstractScrollArea@@XZ @ 12687 NONAME ; class QAbstractScrollArea * QAbstractScrollAreaPrivate::q_func(void)
-	?q_func@QAbstractScrollAreaPrivate@@ABEPBVQAbstractScrollArea@@XZ @ 12688 NONAME ; class QAbstractScrollArea const * QAbstractScrollAreaPrivate::q_func(void) const
-	?q_func@QGraphicsViewPrivate@@AAEPAVQGraphicsView@@XZ @ 12689 NONAME ; class QGraphicsView * QGraphicsViewPrivate::q_func(void)
-	?q_func@QGraphicsViewPrivate@@ABEPBVQGraphicsView@@XZ @ 12690 NONAME ; class QGraphicsView const * QGraphicsViewPrivate::q_func(void) const
-	?qt_draw_glyphs@@YAXPAVQPainter@@PBIPBVQPointF@@H@Z @ 12691 NONAME ; void qt_draw_glyphs(class QPainter *, unsigned int const *, class QPointF const *, int)
-	?recalculateContentSize@QGraphicsViewPrivate@@QAEXXZ @ 12692 NONAME ; void QGraphicsViewPrivate::recalculateContentSize(void)
-	?render@QWidgetPrivate@@QAEXPAVQPaintDevice@@ABVQPoint@@ABVQRegion@@V?$QFlags@W4RenderFlag@QWidget@@@@_N@Z @ 12693 NONAME ; void QWidgetPrivate::render(class QPaintDevice *, class QPoint const &, class QRegion const &, class QFlags<enum QWidget::RenderFlag>, bool)
-	?replaceScrollBar@QAbstractScrollAreaPrivate@@QAEXPAVQScrollBar@@W4Orientation@Qt@@@Z @ 12694 NONAME ; void QAbstractScrollAreaPrivate::replaceScrollBar(class QScrollBar *, enum Qt::Orientation)
-	?replayLastMouseEvent@QGraphicsViewPrivate@@QAEXXZ @ 12695 NONAME ; void QGraphicsViewPrivate::replayLastMouseEvent(void)
-	?rubberBandRegion@QGraphicsViewPrivate@@QBE?AVQRegion@@PBVQWidget@@ABVQRect@@@Z @ 12696 NONAME ; class QRegion QGraphicsViewPrivate::rubberBandRegion(class QWidget const *, class QRect const &) const
-	?scrollBarPolicyChanged@QAbstractScrollAreaPrivate@@UAEXW4Orientation@Qt@@W4ScrollBarPolicy@3@@Z @ 12697 NONAME ; void QAbstractScrollAreaPrivate::scrollBarPolicyChanged(enum Qt::Orientation, enum Qt::ScrollBarPolicy)
-	?selectedText@QLabel@@QBE?AVQString@@XZ @ 12698 NONAME ; class QString QLabel::selectedText(void) const
-	?selectionStart@QLabel@@QBEHXZ @ 12699 NONAME ; int QLabel::selectionStart(void) const
-	?setAutoFillBackground@QGraphicsWidget@@QAEX_N@Z @ 12700 NONAME ; void QGraphicsWidget::setAutoFillBackground(bool)
-	?setColorFromString@QColor@@AAE_NABVQString@@@Z @ 12701 NONAME ; bool QColor::setColorFromString(class QString const &)
-	?setMaximumSize@QStaticText@@QAEXABVQSizeF@@@Z @ 12702 NONAME ABSENT ; void QStaticText::setMaximumSize(class QSizeF const &)
-	?setPerformanceHint@QStaticText@@QAEXW4PerformanceHint@1@@Z @ 12703 NONAME ; void QStaticText::setPerformanceHint(enum QStaticText::PerformanceHint)
-	?setSelection@QLabel@@QAEXHH@Z @ 12704 NONAME ; void QLabel::setSelection(int, int)
-	?setText@QStaticText@@QAEXABVQString@@@Z @ 12705 NONAME ; void QStaticText::setText(class QString const &)
-	?setTextFormat@QStaticText@@QAEXW4TextFormat@Qt@@@Z @ 12706 NONAME ; void QStaticText::setTextFormat(enum Qt::TextFormat)
-	?setUserData@QStaticTextItem@@QAEXPAVQStaticTextUserData@@@Z @ 12707 NONAME ; void QStaticTextItem::setUserData(class QStaticTextUserData *)
-	?size@QStaticText@@QBE?AVQSizeF@@XZ @ 12708 NONAME ; class QSizeF QStaticText::size(void) const
-	?status@QZipReader@@QBE?AW4Status@1@XZ @ 12709 NONAME ; enum QZipReader::Status QZipReader::status(void) const
-	?storeDragDropEvent@QGraphicsViewPrivate@@QAEXPBVQGraphicsSceneDragDropEvent@@@Z @ 12710 NONAME ; void QGraphicsViewPrivate::storeDragDropEvent(class QGraphicsSceneDragDropEvent const *)
-	?storeMouseEvent@QGraphicsViewPrivate@@QAEXPAVQMouseEvent@@@Z @ 12711 NONAME ; void QGraphicsViewPrivate::storeMouseEvent(class QMouseEvent *)
-	?text@QStaticText@@QBE?AVQString@@XZ @ 12712 NONAME ; class QString QStaticText::text(void) const
-	?textFormat@QStaticText@@QBE?AW4TextFormat@Qt@@XZ @ 12713 NONAME ; enum Qt::TextFormat QStaticText::textFormat(void) const
-	?translateTouchEvent@QGraphicsViewPrivate@@SAXPAV1@PAVQTouchEvent@@@Z @ 12714 NONAME ; void QGraphicsViewPrivate::translateTouchEvent(class QGraphicsViewPrivate *, class QTouchEvent *)
-	?updateAll@QGraphicsViewPrivate@@QAEXXZ @ 12715 NONAME ; void QGraphicsViewPrivate::updateAll(void)
-	?updateInputMethodSensitivity@QGraphicsViewPrivate@@QAEXXZ @ 12716 NONAME ; void QGraphicsViewPrivate::updateInputMethodSensitivity(void)
-	?updateLastCenterPoint@QGraphicsViewPrivate@@QAEXXZ @ 12717 NONAME ; void QGraphicsViewPrivate::updateLastCenterPoint(void)
-	?updateRect@QGraphicsViewPrivate@@QAE_NABVQRect@@@Z @ 12718 NONAME ; bool QGraphicsViewPrivate::updateRect(class QRect const &)
-	?updateRegion@QGraphicsViewPrivate@@QAE_NABVQRegion@@@Z @ 12719 NONAME ABSENT ; bool QGraphicsViewPrivate::updateRegion(class QRegion const &)
-	?updateScroll@QGraphicsViewPrivate@@QAEXXZ @ 12720 NONAME ; void QGraphicsViewPrivate::updateScroll(void)
-	?verticalScroll@QGraphicsViewPrivate@@QBE_JXZ @ 12721 NONAME ; long long QGraphicsViewPrivate::verticalScroll(void) const
-	?viewportEvent@QAbstractScrollAreaPrivate@@QAE_NPAVQEvent@@@Z @ 12722 NONAME ; bool QAbstractScrollAreaPrivate::viewportEvent(class QEvent *)
-	?visibilityChanged@QToolBar@@IAEX_N@Z @ 12723 NONAME ; void QToolBar::visibilityChanged(bool)
-	??0FileInfo@QZipReader@@QAE@ABU01@@Z @ 12724 NONAME ; QZipReader::FileInfo::FileInfo(struct QZipReader::FileInfo const &)
-	??0QStaticText@@QAE@ABVQString@@@Z @ 12725 NONAME ; QStaticText::QStaticText(class QString const &)
-	?append@QGraphicsItemPrivate@@SAXPAV?$QDeclarativeListProperty@VQGraphicsObject@@@@PAVQGraphicsObject@@@Z @ 12726 NONAME ABSENT ; void QGraphicsItemPrivate::append(class QDeclarativeListProperty<class QGraphicsObject> *, class QGraphicsObject *)
-	?bitPlaneCount@QImage@@QBEHXZ @ 12727 NONAME ; int QImage::bitPlaneCount(void) const
-	?childrenChanged@QGraphicsObject@@IAEXXZ @ 12728 NONAME ; void QGraphicsObject::childrenChanged(void)
-	?childrenList@QGraphicsItemPrivate@@QAE?AV?$QDeclarativeListProperty@VQGraphicsObject@@@@XZ @ 12729 NONAME ; class QDeclarativeListProperty<class QGraphicsObject> QGraphicsItemPrivate::childrenList(void)
-	?clearFocusHelper@QGraphicsItemPrivate@@QAEX_N@Z @ 12730 NONAME ; void QGraphicsItemPrivate::clearFocusHelper(bool)
-	?commandDescription@QPaintBuffer@@QBE?AVQString@@H@Z @ 12731 NONAME ; class QString QPaintBuffer::commandDescription(int) const
-	?create@PixmapFragment@QPainter@@SA?AV12@ABVQPointF@@ABVQRectF@@MMMM@Z @ 12732 NONAME ; class QPainter::PixmapFragment QPainter::PixmapFragment::create(class QPointF const &, class QRectF const &, float, float, float, float)
-	?device@QZipReader@@QBEPAVQIODevice@@XZ @ 12733 NONAME ; class QIODevice * QZipReader::device(void) const
-	?drawPixmapFragments@QPaintEngineEx@@UAEXPBVPixmapFragment@QPainter@@HABVQPixmap@@V?$QFlags@W4PixmapFragmentHint@QPainter@@@@@Z @ 12734 NONAME ; void QPaintEngineEx::drawPixmapFragments(class QPainter::PixmapFragment const *, int, class QPixmap const &, class QFlags<enum QPainter::PixmapFragmentHint>)
-	?drawPixmapFragments@QPainter@@QAEXPBVPixmapFragment@1@HABVQPixmap@@V?$QFlags@W4PixmapFragmentHint@QPainter@@@@@Z @ 12735 NONAME ; void QPainter::drawPixmapFragments(class QPainter::PixmapFragment const *, int, class QPixmap const &, class QFlags<enum QPainter::PixmapFragmentHint>)
-	?frameEndIndex@QPaintBuffer@@QBEHH@Z @ 12736 NONAME ; int QPaintBuffer::frameEndIndex(int) const
-	?frameStartIndex@QPaintBuffer@@QBEHH@Z @ 12737 NONAME ; int QPaintBuffer::frameStartIndex(int) const
-	?geometryChanged@QGraphicsWidget@@IAEXXZ @ 12738 NONAME ; void QGraphicsWidget::geometryChanged(void)
-	?getGlyphBearings@QFontEngine@@UAEXIPAM0@Z @ 12739 NONAME ; void QFontEngine::getGlyphBearings(unsigned int, float *, float *)
-	?height@QGraphicsItemPrivate@@UBEMXZ @ 12740 NONAME ; float QGraphicsItemPrivate::height(void) const
-	?heightChanged@QGraphicsObject@@IAEXXZ @ 12741 NONAME ; void QGraphicsObject::heightChanged(void)
-	?horizontalAdvance@QTextLine@@QBEMXZ @ 12742 NONAME ; float QTextLine::horizontalAdvance(void) const
-	?isValid@FileInfo@QZipReader@@QBE_NXZ @ 12743 NONAME ; bool QZipReader::FileInfo::isValid(void) const
-	?layoutChanged@QGraphicsWidget@@IAEXXZ @ 12744 NONAME ; void QGraphicsWidget::layoutChanged(void)
-	?pageAdded@QWizard@@IAEXH@Z @ 12745 NONAME ; void QWizard::pageAdded(int)
-	?pageRemoved@QWizard@@IAEXH@Z @ 12746 NONAME ; void QWizard::pageRemoved(int)
-	?paste@QLineControl@@QAEXW4Mode@QClipboard@@@Z @ 12747 NONAME ; void QLineControl::paste(enum QClipboard::Mode)
-	?paste@QTextControl@@QAEXW4Mode@QClipboard@@@Z @ 12748 NONAME ; void QTextControl::paste(enum QClipboard::Mode)
-	?placeholderText@QLineEdit@@QBE?AVQString@@XZ @ 12749 NONAME ; class QString QLineEdit::placeholderText(void) const
-	?prependGraphicsTransform@QGraphicsItemPrivate@@QAEXPAVQGraphicsTransform@@@Z @ 12750 NONAME ; void QGraphicsItemPrivate::prependGraphicsTransform(class QGraphicsTransform *)
-	?processCommands@QPaintBuffer@@QBEHPAVQPainter@@HH@Z @ 12751 NONAME ; int QPaintBuffer::processCommands(class QPainter *, int, int) const
-	?processCommands@QPainterReplayer@@QAEXABVQPaintBuffer@@PAVQPainter@@HH@Z @ 12752 NONAME ; void QPainterReplayer::processCommands(class QPaintBuffer const &, class QPainter *, int, int)
-	?resetHeight@QGraphicsItemPrivate@@UAEXXZ @ 12753 NONAME ; void QGraphicsItemPrivate::resetHeight(void)
-	?resetWidth@QGraphicsItemPrivate@@UAEXXZ @ 12754 NONAME ; void QGraphicsItemPrivate::resetWidth(void)
-	?resizeEvent@QSplitterHandle@@MAEXPAVQResizeEvent@@@Z @ 12755 NONAME ; void QSplitterHandle::resizeEvent(class QResizeEvent *)
-	?setFocusHelper@QGraphicsItemPrivate@@QAEXW4FocusReason@Qt@@_N1@Z @ 12756 NONAME ; void QGraphicsItemPrivate::setFocusHelper(enum Qt::FocusReason, bool, bool)
-	?setHeight@QGraphicsItemPrivate@@UAEXM@Z @ 12757 NONAME ; void QGraphicsItemPrivate::setHeight(float)
-	?setPlaceholderText@QLineEdit@@QAEXABVQString@@@Z @ 12758 NONAME ; void QLineEdit::setPlaceholderText(class QString const &)
-	?setSideWidget@QWizard@@QAEXPAVQWidget@@@Z @ 12759 NONAME ; void QWizard::setSideWidget(class QWidget *)
-	?setTextWidth@QStaticText@@QAEXM@Z @ 12760 NONAME ; void QStaticText::setTextWidth(float)
-	?setWidth@QGraphicsItemPrivate@@UAEXM@Z @ 12761 NONAME ; void QGraphicsItemPrivate::setWidth(float)
-	?sideWidget@QWizard@@QBEPAVQWidget@@XZ @ 12762 NONAME ; class QWidget * QWizard::sideWidget(void) const
-	?textWidth@QStaticText@@QBEMXZ @ 12763 NONAME ; float QStaticText::textWidth(void) const
-	?updateDisplayText@QLineControl@@AAEX_N@Z @ 12764 NONAME ; void QLineControl::updateDisplayText(bool)
-	?updateMicroFocus@QGraphicsItem@@IAEXXZ @ 12765 NONAME ; void QGraphicsItem::updateMicroFocus(void)
-	?updateMicroFocus@QGraphicsObject@@IAEXXZ @ 12766 NONAME ; void QGraphicsObject::updateMicroFocus(void)
-	?width@QGraphicsItemPrivate@@UBEMXZ @ 12767 NONAME ; float QGraphicsItemPrivate::width(void) const
-	?widthChanged@QGraphicsObject@@IAEXXZ @ 12768 NONAME ; void QGraphicsObject::widthChanged(void)
-	?children_append@QGraphicsItemPrivate@@SAXPAV?$QDeclarativeListProperty@VQGraphicsObject@@@@PAVQGraphicsObject@@@Z @ 12769 NONAME ; void QGraphicsItemPrivate::children_append(class QDeclarativeListProperty<class QGraphicsObject> *, class QGraphicsObject *)
-	?children_at@QGraphicsItemPrivate@@SAPAVQGraphicsObject@@PAV?$QDeclarativeListProperty@VQGraphicsObject@@@@H@Z @ 12770 NONAME ; class QGraphicsObject * QGraphicsItemPrivate::children_at(class QDeclarativeListProperty<class QGraphicsObject> *, int)
-	?children_count@QGraphicsItemPrivate@@SAHPAV?$QDeclarativeListProperty@VQGraphicsObject@@@@@Z @ 12771 NONAME ; int QGraphicsItemPrivate::children_count(class QDeclarativeListProperty<class QGraphicsObject> *)
-	?display@QEglContext@@QAEHXZ @ 12772 NONAME ; int QEglContext::display(void)
-	?defaultConfig@QEgl@@YAHHW4API@1@V?$QFlags@W4ConfigOption@QEgl@@@@@Z @ 12773 NONAME ; int QEgl::defaultConfig(int, enum QEgl::API, class QFlags<enum QEgl::ConfigOption>)
-	?configAttrib@QEglContext@@QBEHH@Z @ 12774 NONAME ; int QEglContext::configAttrib(int) const
-	?error@QEgl@@YAHXZ @ 12775 NONAME ABSENT ; int QEgl::error(void)
-	?errorString@QEgl@@YA?AVQString@@XZ @ 12776 NONAME ABSENT ; class QString QEgl::errorString(void)
-	?configProperties@QEglContext@@QBE?AVQEglProperties@@XZ @ 12777 NONAME ABSENT ; class QEglProperties QEglContext::configProperties(void) const
-	?extensions@QEgl@@YA?AVQString@@XZ @ 12778 NONAME ; class QString QEgl::extensions(void)
-	?nativePixmap@QEgl@@YAPAXPAVQPixmap@@@Z @ 12779 NONAME ; void * QEgl::nativePixmap(class QPixmap *)
-	?display@QEgl@@YAHXZ @ 12780 NONAME ; int QEgl::display(void)
-	?eglCreateImageKHR@QEgl@@YAHHHHHPBH@Z @ 12781 NONAME ; int QEgl::eglCreateImageKHR(int, int, int, int, int const *)
-	?hasExtension@QEgl@@YA_NPBD@Z @ 12782 NONAME ; bool QEgl::hasExtension(char const *)
-	?destroyContext@QEglContext@@QAEXXZ @ 12783 NONAME ; void QEglContext::destroyContext(void)
-	?nativeWindow@QEgl@@YAPAXPAVQWidget@@@Z @ 12784 NONAME ; void * QEgl::nativeWindow(class QWidget *)
-	?errorString@QEgl@@YA?AVQString@@H@Z @ 12785 NONAME ; class QString QEgl::errorString(int)
-	?chooseConfig@QEgl@@YAHPBVQEglProperties@@W4PixelFormatMatch@1@@Z @ 12786 NONAME ; int QEgl::chooseConfig(class QEglProperties const *, enum QEgl::PixelFormatMatch)
-	?eglDestroyImageKHR@QEgl@@YAHHH@Z @ 12787 NONAME ; int QEgl::eglDestroyImageKHR(int, int)
-	?isEmpty@QItemSelectionRange@@QBE_NXZ @ 12788 NONAME ; bool QItemSelectionRange::isEmpty(void) const
-	?clearError@QEgl@@YAXXZ @ 12789 NONAME ABSENT ; void QEgl::clearError(void)
-	?nativeDisplay@QEgl@@YAHXZ @ 12790 NONAME ; int QEgl::nativeDisplay(void)
-	?dumpAllConfigs@QEgl@@YAXXZ @ 12791 NONAME ; void QEgl::dumpAllConfigs(void)
-	?setDeviceType@QEglProperties@@QAEXH@Z @ 12792 NONAME ; void QEglProperties::setDeviceType(int)
-	?glyphPadding@QTextureGlyphCache@@UBEHXZ @ 12793 NONAME ; int QTextureGlyphCache::glyphPadding(void) const
-	?createSurface@QEgl@@YAHPAVQPaintDevice@@HPBVQEglProperties@@@Z @ 12794 NONAME ; int QEgl::createSurface(class QPaintDevice *, int, class QEglProperties const *)
-	?setPartialUpdateSupport@QWindowSurface@@IAEX_N@Z @ 12795 NONAME ; void QWindowSurface::setPartialUpdateSupport(bool)
-	?transformChanged@QGraphicsItemPrivate@@UAEXXZ @ 12796 NONAME ; void QGraphicsItemPrivate::transformChanged(void)
-	?hasPartialUpdateSupport@QWindowSurface@@QBE_NXZ @ 12797 NONAME ; bool QWindowSurface::hasPartialUpdateSupport(void) const
-	?name@QIcon@@QBE?AVQString@@XZ @ 12798 NONAME ; class QString QIcon::name(void) const
-	?iconName@QIconEngineV2@@QAE?AVQString@@XZ @ 12799 NONAME ; class QString QIconEngineV2::iconName(void)
-	?updateRectF@QGraphicsViewPrivate@@QAE_NABVQRectF@@@Z @ 12800 NONAME ; bool QGraphicsViewPrivate::updateRectF(class QRectF const &)
-	?updateRegion@QGraphicsViewPrivate@@QAE_NABVQRectF@@ABVQTransform@@@Z @ 12801 NONAME ; bool QGraphicsViewPrivate::updateRegion(class QRectF const &, class QTransform const &)
-	?totalUsed@QPixmapCache@@SAHXZ @ 12802 NONAME ; int QPixmapCache::totalUsed(void)
-	?allPixmaps@QPixmapCache@@SA?AV?$QList@U?$QPair@VQString@@VQPixmap@@@@@@XZ @ 12803 NONAME ; class QList<struct QPair<class QString, class QPixmap> > QPixmapCache::allPixmaps(void)
-	?flushDetachedPixmaps@QPixmapCache@@SAXXZ @ 12804 NONAME ; void QPixmapCache::flushDetachedPixmaps(void)
-	??0QImageTextureGlyphCache@@QAE@W4Type@QFontEngineGlyphCache@@ABVQTransform@@@Z @ 12805 NONAME ; QImageTextureGlyphCache::QImageTextureGlyphCache(enum QFontEngineGlyphCache::Type, class QTransform const &)
-	??1QImageTextureGlyphCache@@UAE@XZ @ 12806 NONAME ; QImageTextureGlyphCache::~QImageTextureGlyphCache(void)
-	??_EQImageTextureGlyphCache@@UAE@I@Z @ 12807 NONAME ; QImageTextureGlyphCache::~QImageTextureGlyphCache(unsigned int)
-	?addToPolygon@QBezier@@QBEXPAVQPolygonF@@M@Z @ 12808 NONAME ; void QBezier::addToPolygon(class QPolygonF *, float) const
-	?createTextureData@QImageTextureGlyphCache@@UAEXHH@Z @ 12809 NONAME ; void QImageTextureGlyphCache::createTextureData(int, int)
-	?curveThreshold@QStrokerOps@@QBEMXZ @ 12810 NONAME ; float QStrokerOps::curveThreshold(void) const
-	?fillTexture@QImageTextureGlyphCache@@UAEXABUCoord@QTextureGlyphCache@@I@Z @ 12811 NONAME ; void QImageTextureGlyphCache::fillTexture(struct QTextureGlyphCache::Coord const &, unsigned int)
-	?glyphMargin@QImageTextureGlyphCache@@UBEHXZ @ 12812 NONAME ; int QImageTextureGlyphCache::glyphMargin(void) const
-	?image@QImageTextureGlyphCache@@QBEABVQImage@@XZ @ 12813 NONAME ; class QImage const & QImageTextureGlyphCache::image(void) const
-	?resizeTextureData@QImageTextureGlyphCache@@UAEXHH@Z @ 12814 NONAME ; void QImageTextureGlyphCache::resizeTextureData(int, int)
-	?setCurveThreshold@QStrokerOps@@QAEXM@Z @ 12815 NONAME ; void QStrokerOps::setCurveThreshold(float)
-	?setCurveThresholdFromTransform@QStrokerOps@@QAEXABVQTransform@@@Z @ 12816 NONAME ; void QStrokerOps::setCurveThresholdFromTransform(class QTransform const &)
-	?setUpdateClip@QGraphicsViewPrivate@@QAEXPAVQGraphicsItem@@@Z @ 12817 NONAME ; void QGraphicsViewPrivate::setUpdateClip(class QGraphicsItem *)
-	?toPolygon@QBezier@@QBE?AVQPolygonF@@M@Z @ 12818 NONAME ; class QPolygonF QBezier::toPolygon(float) const
-	?updatePaintedViewBoundingRects@QGraphicsItemPrivate@@QAEX_N@Z @ 12819 NONAME ; void QGraphicsItemPrivate::updatePaintedViewBoundingRects(bool)
+	?display@QEglContext@@QAEHXZ @ 12628 NONAME ; int QEglContext::display(void)
+	?setPartialUpdateSupport@QWindowSurface@@IAEX_N@Z @ 12629 NONAME ; void QWindowSurface::setPartialUpdateSupport(bool)
+	?transformChanged@QGraphicsItemPrivate@@UAEXXZ @ 12630 NONAME ; void QGraphicsItemPrivate::transformChanged(void)
+	?setUserData@QStaticTextItem@@QAEXPAVQStaticTextUserData@@@Z @ 12631 NONAME ; void QStaticTextItem::setUserData(class QStaticTextUserData *)
+	?isValid@FileInfo@QZipReader@@QBE_NXZ @ 12632 NONAME ; bool QZipReader::FileInfo::isValid(void) const
+	?hasSelectedText@QLabel@@QBE_NXZ @ 12633 NONAME ; bool QLabel::hasSelectedText(void) const
+	?size@QStaticText@@QBE?AVQSizeF@@XZ @ 12634 NONAME ; class QSizeF QStaticText::size(void) const
+	?processCommands@QPainterReplayer@@QAEXABVQPaintBuffer@@PAVQPainter@@HH@Z @ 12635 NONAME ; void QPainterReplayer::processCommands(class QPaintBuffer const &, class QPainter *, int, int)
+	?defaultConfig@QEgl@@YAHHW4API@1@V?$QFlags@W4ConfigOption@QEgl@@@@@Z @ 12636 NONAME ; int QEgl::defaultConfig(int, enum QEgl::API, class QFlags<enum QEgl::ConfigOption>)
+	??0QZipReader@@QAE@PAVQIODevice@@@Z @ 12637 NONAME ; QZipReader::QZipReader(class QIODevice *)
+	?configAttrib@QEglContext@@QBEHH@Z @ 12638 NONAME ; int QEglContext::configAttrib(int) const
+	?setAutoFillBackground@QGraphicsWidget@@QAEX_N@Z @ 12639 NONAME ; void QGraphicsWidget::setAutoFillBackground(bool)
+	??4QStaticText@@QAEAAV0@ABV0@@Z @ 12640 NONAME ; class QStaticText & QStaticText::operator=(class QStaticText const &)
+	?updateRegion@QGraphicsViewPrivate@@QAE_NABVQRectF@@ABVQTransform@@@Z @ 12641 NONAME ; bool QGraphicsViewPrivate::updateRegion(class QRectF const &, class QTransform const &)
+	??9QStaticText@@QBE_NABV0@@Z @ 12642 NONAME ; bool QStaticText::operator!=(class QStaticText const &) const
+	??_EQGraphicsViewPrivate@@UAE@I@Z @ 12643 NONAME ; QGraphicsViewPrivate::~QGraphicsViewPrivate(unsigned int)
+	?status@QZipReader@@QBE?AW4Status@1@XZ @ 12644 NONAME ; enum QZipReader::Status QZipReader::status(void) const
+	?autoFillBackground@QGraphicsWidget@@QBE_NXZ @ 12645 NONAME ; bool QGraphicsWidget::autoFillBackground(void) const
+	?createTextureData@QImageTextureGlyphCache@@UAEXHH@Z @ 12646 NONAME ; void QImageTextureGlyphCache::createTextureData(int, int)
+	?image@QImageTextureGlyphCache@@QBEABVQImage@@XZ @ 12647 NONAME ; class QImage const & QImageTextureGlyphCache::image(void) const
+	?extensions@QEgl@@YA?AVQString@@XZ @ 12648 NONAME ; class QString QEgl::extensions(void)
+	?pageRemoved@QWizard@@IAEXH@Z @ 12649 NONAME ; void QWizard::pageRemoved(int)
+	?init@QAbstractScrollAreaPrivate@@QAEXXZ @ 12650 NONAME ; void QAbstractScrollAreaPrivate::init(void)
+	?mapRectToScene@QGraphicsViewPrivate@@QBE?AVQRectF@@ABVQRect@@@Z @ 12651 NONAME ; class QRectF QGraphicsViewPrivate::mapRectToScene(class QRect const &) const
+	?width@QGraphicsItemPrivate@@UBEMXZ @ 12652 NONAME ; float QGraphicsItemPrivate::width(void) const
+	?toPolygon@QBezier@@QBE?AVQPolygonF@@M@Z @ 12653 NONAME ; class QPolygonF QBezier::toPolygon(float) const
+	?freeStyleOptionsArray@QGraphicsViewPrivate@@QAEXPAVQStyleOptionGraphicsItem@@@Z @ 12654 NONAME ; void QGraphicsViewPrivate::freeStyleOptionsArray(class QStyleOptionGraphicsItem *)
+	?visibilityChanged@QToolBar@@IAEX_N@Z @ 12655 NONAME ; void QToolBar::visibilityChanged(bool)
+	?updateInputMethodSensitivity@QGraphicsViewPrivate@@QAEXXZ @ 12656 NONAME ; void QGraphicsViewPrivate::updateInputMethodSensitivity(void)
+	?glyphMargin@QImageTextureGlyphCache@@UBEHXZ @ 12657 NONAME ; int QImageTextureGlyphCache::glyphMargin(void) const
+	?setTextFormat@QStaticText@@QAEXW4TextFormat@Qt@@@Z @ 12658 NONAME ; void QStaticText::setTextFormat(enum Qt::TextFormat)
+	?storeDragDropEvent@QGraphicsViewPrivate@@QAEXPBVQGraphicsSceneDragDropEvent@@@Z @ 12659 NONAME ; void QGraphicsViewPrivate::storeDragDropEvent(class QGraphicsSceneDragDropEvent const *)
+	?updateRect@QGraphicsViewPrivate@@QAE_NABVQRect@@@Z @ 12660 NONAME ; bool QGraphicsViewPrivate::updateRect(class QRect const &)
+	?fileData@QZipReader@@QBE?AVQByteArray@@ABVQString@@@Z @ 12661 NONAME ; class QByteArray QZipReader::fileData(class QString const &) const
+	?translateTouchEvent@QGraphicsViewPrivate@@SAXPAV1@PAVQTouchEvent@@@Z @ 12662 NONAME ; void QGraphicsViewPrivate::translateTouchEvent(class QGraphicsViewPrivate *, class QTouchEvent *)
+	?dispatchPendingUpdateRequests@QGraphicsViewPrivate@@QAEXXZ @ 12663 NONAME ; void QGraphicsViewPrivate::dispatchPendingUpdateRequests(void)
+	?updatePaintedViewBoundingRects@QGraphicsItemPrivate@@QAEX_N@Z @ 12664 NONAME ; void QGraphicsItemPrivate::updatePaintedViewBoundingRects(bool)
+	?setHeight@QGraphicsItemPrivate@@UAEXM@Z @ 12665 NONAME ; void QGraphicsItemPrivate::setHeight(float)
+	?isValidColor@QColor@@SA_NABVQString@@@Z @ 12666 NONAME ; bool QColor::isValidColor(class QString const &)
+	??0QStaticTextItem@@QAE@XZ @ 12667 NONAME ; QStaticTextItem::QStaticTextItem(void)
+	?updateMicroFocus@QGraphicsItem@@IAEXXZ @ 12668 NONAME ; void QGraphicsItem::updateMicroFocus(void)
+	??1QStaticText@@QAE@XZ @ 12669 NONAME ; QStaticText::~QStaticText(void)
+	?nativePixmap@QEgl@@YAPAXPAVQPixmap@@@Z @ 12670 NONAME ; void * QEgl::nativePixmap(class QPixmap *)
+	?render@QWidgetPrivate@@QAEXPAVQPaintDevice@@ABVQPoint@@ABVQRegion@@V?$QFlags@W4RenderFlag@QWidget@@@@_N@Z @ 12671 NONAME ; void QWidgetPrivate::render(class QPaintDevice *, class QPoint const &, class QRegion const &, class QFlags<enum QWidget::RenderFlag>, bool)
+	?constBits@QImage@@QBEPBEXZ @ 12672 NONAME ; unsigned char const * QImage::constBits(void) const
+	??8QStaticText@@QBE_NABV0@@Z @ 12673 NONAME ; bool QStaticText::operator==(class QStaticText const &) const
+	??0FileInfo@QZipReader@@QAE@XZ @ 12674 NONAME ; QZipReader::FileInfo::FileInfo(void)
+	?q_func@QGraphicsViewPrivate@@ABEPBVQGraphicsView@@XZ @ 12675 NONAME ; class QGraphicsView const * QGraphicsViewPrivate::q_func(void) const
+	?textFormat@QStaticText@@QBE?AW4TextFormat@Qt@@XZ @ 12676 NONAME ; enum Qt::TextFormat QStaticText::textFormat(void) const
+	?isReadable@QZipReader@@QBE_NXZ @ 12677 NONAME ; bool QZipReader::isReadable(void) const
+	?getPixmapCursor@QApplicationPrivate@@QAE?AVQPixmap@@W4CursorShape@Qt@@@Z @ 12678 NONAME ; class QPixmap QApplicationPrivate::getPixmapCursor(enum Qt::CursorShape)
+	?entryInfoAt@QZipReader@@QBE?AUFileInfo@1@H@Z @ 12679 NONAME ; struct QZipReader::FileInfo QZipReader::entryInfoAt(int) const
+	?children_append@QGraphicsItemPrivate@@SAXPAV?$QDeclarativeListProperty@VQGraphicsObject@@@@PAVQGraphicsObject@@@Z @ 12680 NONAME ; void QGraphicsItemPrivate::children_append(class QDeclarativeListProperty<class QGraphicsObject> *, class QGraphicsObject *)
+	?hasPartialUpdateSupport@QWindowSurface@@QBE_NXZ @ 12681 NONAME ; bool QWindowSurface::hasPartialUpdateSupport(void) const
+	?storeMouseEvent@QGraphicsViewPrivate@@QAEXPAVQMouseEvent@@@Z @ 12682 NONAME ; void QGraphicsViewPrivate::storeMouseEvent(class QMouseEvent *)
+	?mapToScene@QGraphicsViewPrivate@@QBE?AVQPointF@@ABV2@@Z @ 12683 NONAME ; class QPointF QGraphicsViewPrivate::mapToScene(class QPointF const &) const
+	?display@QEgl@@YAHXZ @ 12684 NONAME ; int QEgl::display(void)
+	?drawStaticText@QPainter@@QAEXABVQPoint@@ABVQStaticText@@@Z @ 12685 NONAME ; void QPainter::drawStaticText(class QPoint const &, class QStaticText const &)
+	?fillTexture@QImageTextureGlyphCache@@UAEXABUCoord@QTextureGlyphCache@@I@Z @ 12686 NONAME ; void QImageTextureGlyphCache::fillTexture(struct QTextureGlyphCache::Coord const &, unsigned int)
+	?addToPolygon@QBezier@@QBEXPAVQPolygonF@@M@Z @ 12687 NONAME ; void QBezier::addToPolygon(class QPolygonF *, float) const
+	?eglCreateImageKHR@QEgl@@YAHHHHHPBH@Z @ 12688 NONAME ; int QEgl::eglCreateImageKHR(int, int, int, int, int const *)
+	?resetWidth@QGraphicsItemPrivate@@UAEXXZ @ 12689 NONAME ; void QGraphicsItemPrivate::resetWidth(void)
+	?detach@QStaticText@@AAEXXZ @ 12690 NONAME ; void QStaticText::detach(void)
+	?totalUsed@QPixmapCache@@SAHXZ @ 12691 NONAME ; int QPixmapCache::totalUsed(void)
+	??0QKeySequence@@QAE@ABVQString@@W4SequenceFormat@0@@Z @ 12692 NONAME ; QKeySequence::QKeySequence(class QString const &, enum QKeySequence::SequenceFormat)
+	?device@QZipReader@@QBEPAVQIODevice@@XZ @ 12693 NONAME ; class QIODevice * QZipReader::device(void) const
+	?hasExtension@QEgl@@YA_NPBD@Z @ 12694 NONAME ; bool QEgl::hasExtension(char const *)
+	?mapRectFromScene@QGraphicsViewPrivate@@QBE?AVQRectF@@ABV2@@Z @ 12695 NONAME ; class QRectF QGraphicsViewPrivate::mapRectFromScene(class QRectF const &) const
+	?commandDescription@QPaintBuffer@@QBE?AVQString@@H@Z @ 12696 NONAME ; class QString QPaintBuffer::commandDescription(int) const
+	?layoutChanged@QGraphicsWidget@@IAEXXZ @ 12697 NONAME ; void QGraphicsWidget::layoutChanged(void)
+	??0QGraphicsViewPrivate@@QAE@XZ @ 12698 NONAME ; QGraphicsViewPrivate::QGraphicsViewPrivate(void)
+	?anchorAt@QPlainTextEdit@@QBE?AVQString@@ABVQPoint@@@Z @ 12699 NONAME ; class QString QPlainTextEdit::anchorAt(class QPoint const &) const
+	?getSubRange@QBezier@@QBE?AV1@MM@Z @ 12700 NONAME ; class QBezier QBezier::getSubRange(float, float) const
+	?replaceScrollBar@QAbstractScrollAreaPrivate@@QAEXPAVQScrollBar@@W4Orientation@Qt@@@Z @ 12701 NONAME ; void QAbstractScrollAreaPrivate::replaceScrollBar(class QScrollBar *, enum Qt::Orientation)
+	?mapToViewRegion@QGraphicsViewPrivate@@QBE?AVQRegion@@PBVQGraphicsItem@@ABVQRectF@@@Z @ 12702 NONAME ; class QRegion QGraphicsViewPrivate::mapToViewRegion(class QGraphicsItem const *, class QRectF const &) const
+	?allPixmaps@QPixmapCache@@SA?AV?$QList@U?$QPair@VQString@@VQPixmap@@@@@@XZ @ 12703 NONAME ; class QList<struct QPair<class QString, class QPixmap> > QPixmapCache::allPixmaps(void)
+	??_EQAbstractScrollAreaPrivate@@UAE@I@Z @ 12704 NONAME ; QAbstractScrollAreaPrivate::~QAbstractScrollAreaPrivate(unsigned int)
+	?pageAdded@QWizard@@IAEXH@Z @ 12705 NONAME ; void QWizard::pageAdded(int)
+	?populate@QTextureGlyphCache@@QAEXPAVQFontEngine@@HPBIPBUQFixedPoint@@@Z @ 12706 NONAME ; void QTextureGlyphCache::populate(class QFontEngine *, int, unsigned int const *, struct QFixedPoint const *)
+	??1QStaticTextItem@@QAE@XZ @ 12707 NONAME ; QStaticTextItem::~QStaticTextItem(void)
+	?populateSceneDragDropEvent@QGraphicsViewPrivate@@QAEXPAVQGraphicsSceneDragDropEvent@@PAVQDropEvent@@@Z @ 12708 NONAME ; void QGraphicsViewPrivate::populateSceneDragDropEvent(class QGraphicsSceneDragDropEvent *, class QDropEvent *)
+	?updateAll@QGraphicsViewPrivate@@QAEXXZ @ 12709 NONAME ; void QGraphicsViewPrivate::updateAll(void)
+	?nativeWindow@QEgl@@YAPAXPAVQWidget@@@Z @ 12710 NONAME ; void * QEgl::nativeWindow(class QWidget *)
+	?children_count@QGraphicsItemPrivate@@SAHPAV?$QDeclarativeListProperty@VQGraphicsObject@@@@@Z @ 12711 NONAME ; int QGraphicsItemPrivate::children_count(class QDeclarativeListProperty<class QGraphicsObject> *)
+	?allocStyleOptionsArray@QGraphicsViewPrivate@@QAEPAVQStyleOptionGraphicsItem@@H@Z @ 12712 NONAME ; class QStyleOptionGraphicsItem * QGraphicsViewPrivate::allocStyleOptionsArray(int)
+	?resizeTextureData@QImageTextureGlyphCache@@UAEXHH@Z @ 12713 NONAME ; void QImageTextureGlyphCache::resizeTextureData(int, int)
+	?drawPixmapFragments@QPainter@@QAEXPBVPixmapFragment@1@HABVQPixmap@@V?$QFlags@W4PixmapFragmentHint@QPainter@@@@@Z @ 12714 NONAME ; void QPainter::drawPixmapFragments(class QPainter::PixmapFragment const *, int, class QPixmap const &, class QFlags<enum QPainter::PixmapFragmentHint>)
+	?setColorFromString@QColor@@AAE_NABVQString@@@Z @ 12715 NONAME ; bool QColor::setColorFromString(class QString const &)
+	??1QAbstractScrollAreaPrivate@@UAE@XZ @ 12716 NONAME ; QAbstractScrollAreaPrivate::~QAbstractScrollAreaPrivate(void)
+	?setText@QStaticText@@QAEXABVQString@@@Z @ 12717 NONAME ; void QStaticText::setText(class QString const &)
+	?bitPlaneCount@QImage@@QBEHXZ @ 12718 NONAME ; int QImage::bitPlaneCount(void) const
+	?_q_unsetViewportCursor@QGraphicsViewPrivate@@QAEXXZ @ 12719 NONAME ; void QGraphicsViewPrivate::_q_unsetViewportCursor(void)
+	?setUpdateClip@QGraphicsViewPrivate@@QAEXPAVQGraphicsItem@@@Z @ 12720 NONAME ; void QGraphicsViewPrivate::setUpdateClip(class QGraphicsItem *)
+	?resetHeight@QGraphicsItemPrivate@@UAEXXZ @ 12721 NONAME ; void QGraphicsItemPrivate::resetHeight(void)
+	?runtimeData@QPixmapData@@UBEPAV1@XZ @ 12722 NONAME ; class QPixmapData * QPixmapData::runtimeData(void) const
+	?selectedText@QLabel@@QBE?AVQString@@XZ @ 12723 NONAME ; class QString QLabel::selectedText(void) const
+	?childrenList@QGraphicsItemPrivate@@QAE?AV?$QDeclarativeListProperty@VQGraphicsObject@@@@XZ @ 12724 NONAME ; class QDeclarativeListProperty<class QGraphicsObject> QGraphicsItemPrivate::childrenList(void)
+	?childrenChanged@QGraphicsObject@@IAEXXZ @ 12725 NONAME ; void QGraphicsObject::childrenChanged(void)
+	?recalculateContentSize@QGraphicsViewPrivate@@QAEXXZ @ 12726 NONAME ; void QGraphicsViewPrivate::recalculateContentSize(void)
+	?heightChanged@QGraphicsObject@@IAEXXZ @ 12727 NONAME ; void QGraphicsObject::heightChanged(void)
+	?name@QIcon@@QBE?AVQString@@XZ @ 12728 NONAME ; class QString QIcon::name(void) const
+	?errorString@QEgl@@YA?AVQString@@H@Z @ 12729 NONAME ; class QString QEgl::errorString(int)
+	??4FileInfo@QZipReader@@QAEAAU01@ABU01@@Z @ 12730 NONAME ; struct QZipReader::FileInfo & QZipReader::FileInfo::operator=(struct QZipReader::FileInfo const &)
+	??1QGraphicsViewPrivate@@UAE@XZ @ 12731 NONAME ; QGraphicsViewPrivate::~QGraphicsViewPrivate(void)
+	?chooseConfig@QEgl@@YAHPBVQEglProperties@@W4PixelFormatMatch@1@@Z @ 12732 NONAME ; int QEgl::chooseConfig(class QEglProperties const *, enum QEgl::PixelFormatMatch)
+	?prependGraphicsTransform@QGraphicsItemPrivate@@QAEXPAVQGraphicsTransform@@@Z @ 12733 NONAME ; void QGraphicsItemPrivate::prependGraphicsTransform(class QGraphicsTransform *)
+	?eglDestroyImageKHR@QEgl@@YAHHH@Z @ 12734 NONAME ; int QEgl::eglDestroyImageKHR(int, int)
+	?qt_draw_glyphs@@YAXPAVQPainter@@PBIPBVQPointF@@H@Z @ 12735 NONAME ; void qt_draw_glyphs(class QPainter *, unsigned int const *, class QPointF const *, int)
+	?isEmpty@QItemSelectionRange@@QBE_NXZ @ 12736 NONAME ; bool QItemSelectionRange::isEmpty(void) const
+	?count@QZipReader@@QBEHXZ @ 12737 NONAME ; int QZipReader::count(void) const
+	?centerView@QGraphicsViewPrivate@@QAEXW4ViewportAnchor@QGraphicsView@@@Z @ 12738 NONAME ; void QGraphicsViewPrivate::centerView(enum QGraphicsView::ViewportAnchor)
+	?contentsOffset@QAbstractScrollAreaPrivate@@UBE?AVQPoint@@XZ @ 12739 NONAME ; class QPoint QAbstractScrollAreaPrivate::contentsOffset(void) const
+	?_q_vslide@QAbstractScrollAreaPrivate@@QAEXH@Z @ 12740 NONAME ; void QAbstractScrollAreaPrivate::_q_vslide(int)
+	??1QZipReader@@QAE@XZ @ 12741 NONAME ; QZipReader::~QZipReader(void)
+	??_EQImageTextureGlyphCache@@UAE@I@Z @ 12742 NONAME ; QImageTextureGlyphCache::~QImageTextureGlyphCache(unsigned int)
+	?drawPixmapFragments@QPaintEngineEx@@UAEXPBVPixmapFragment@QPainter@@HABVQPixmap@@V?$QFlags@W4PixmapFragmentHint@QPainter@@@@@Z @ 12743 NONAME ; void QPaintEngineEx::drawPixmapFragments(class QPainter::PixmapFragment const *, int, class QPixmap const &, class QFlags<enum QPainter::PixmapFragmentHint>)
+	?nativeDisplay@QEgl@@YAHXZ @ 12744 NONAME ; int QEgl::nativeDisplay(void)
+	?layoutChildren@QAbstractScrollAreaPrivate@@QAEXXZ @ 12745 NONAME ; void QAbstractScrollAreaPrivate::layoutChildren(void)
+	?horizontalScroll@QGraphicsViewPrivate@@QBE_JXZ @ 12746 NONAME ; long long QGraphicsViewPrivate::horizontalScroll(void) const
+	?updateRectF@QGraphicsViewPrivate@@QAE_NABVQRectF@@@Z @ 12747 NONAME ; bool QGraphicsViewPrivate::updateRectF(class QRectF const &)
+	?setPlaceholderText@QLineEdit@@QAEXABVQString@@@Z @ 12748 NONAME ; void QLineEdit::setPlaceholderText(class QString const &)
+	?resizeEvent@QSplitterHandle@@MAEXPAVQResizeEvent@@@Z @ 12749 NONAME ; void QSplitterHandle::resizeEvent(class QResizeEvent *)
+	?drawStaticText@QPainter@@QAEXHHABVQStaticText@@@Z @ 12750 NONAME ; void QPainter::drawStaticText(int, int, class QStaticText const &)
+	?setSelection@QLabel@@QAEXHH@Z @ 12751 NONAME ; void QLabel::setSelection(int, int)
+	?q_func@QAbstractScrollAreaPrivate@@AAEPAVQAbstractScrollArea@@XZ @ 12752 NONAME ; class QAbstractScrollArea * QAbstractScrollAreaPrivate::q_func(void)
+	?updateMicroFocus@QGraphicsObject@@IAEXXZ @ 12753 NONAME ; void QGraphicsObject::updateMicroFocus(void)
+	?drawStaticText@QPainter@@QAEXABVQPointF@@ABVQStaticText@@@Z @ 12754 NONAME ; void QPainter::drawStaticText(class QPointF const &, class QStaticText const &)
+	?processPendingUpdates@QGraphicsViewPrivate@@QAEXXZ @ 12755 NONAME ; void QGraphicsViewPrivate::processPendingUpdates(void)
+	?rubberBandRegion@QGraphicsViewPrivate@@QBE?AVQRegion@@PBVQWidget@@ABVQRect@@@Z @ 12756 NONAME ; class QRegion QGraphicsViewPrivate::rubberBandRegion(class QWidget const *, class QRect const &) const
+	?children_at@QGraphicsItemPrivate@@SAPAVQGraphicsObject@@PAV?$QDeclarativeListProperty@VQGraphicsObject@@@@H@Z @ 12757 NONAME ; class QGraphicsObject * QGraphicsItemPrivate::children_at(class QDeclarativeListProperty<class QGraphicsObject> *, int)
+	?widthChanged@QGraphicsObject@@IAEXXZ @ 12758 NONAME ; void QGraphicsObject::widthChanged(void)
+	?_q_showOrHideScrollBars@QAbstractScrollAreaPrivate@@QAEXXZ @ 12759 NONAME ; void QAbstractScrollAreaPrivate::_q_showOrHideScrollBars(void)
+	?mouseMoveEventHandler@QGraphicsViewPrivate@@QAEXPAVQMouseEvent@@@Z @ 12760 NONAME ; void QGraphicsViewPrivate::mouseMoveEventHandler(class QMouseEvent *)
+	?replayLastMouseEvent@QGraphicsViewPrivate@@QAEXXZ @ 12761 NONAME ; void QGraphicsViewPrivate::replayLastMouseEvent(void)
+	??0QStaticText@@QAE@ABVQString@@@Z @ 12762 NONAME ; QStaticText::QStaticText(class QString const &)
+	?close@QZipReader@@QAEXXZ @ 12763 NONAME ; void QZipReader::close(void)
+	?geometryChanged@QGraphicsWidget@@IAEXXZ @ 12764 NONAME ; void QGraphicsWidget::geometryChanged(void)
+	?setCurveThreshold@QStrokerOps@@QAEXM@Z @ 12765 NONAME ; void QStrokerOps::setCurveThreshold(float)
+	?_q_hslide@QAbstractScrollAreaPrivate@@QAEXH@Z @ 12766 NONAME ; void QAbstractScrollAreaPrivate::_q_hslide(int)
+	?selectionStart@QLabel@@QBEHXZ @ 12767 NONAME ; int QLabel::selectionStart(void) const
+	??0QStaticText@@QAE@XZ @ 12768 NONAME ; QStaticText::QStaticText(void)
+	?curveThreshold@QStrokerOps@@QBEMXZ @ 12769 NONAME ; float QStrokerOps::curveThreshold(void) const
+	?iconName@QIconEngineV2@@QAE?AVQString@@XZ @ 12770 NONAME ; class QString QIconEngineV2::iconName(void)
+	?mapBy@QBezier@@QBE?AV1@ABVQTransform@@@Z @ 12771 NONAME ; class QBezier QBezier::mapBy(class QTransform const &) const
+	??0QZipReader@@QAE@ABVQString@@V?$QFlags@W4OpenModeFlag@QIODevice@@@@@Z @ 12772 NONAME ; QZipReader::QZipReader(class QString const &, class QFlags<enum QIODevice::OpenModeFlag>)
+	?flushDetachedPixmaps@QPixmapCache@@SAXXZ @ 12773 NONAME ; void QPixmapCache::flushDetachedPixmaps(void)
+	?exists@QZipReader@@QBE_NXZ @ 12774 NONAME ; bool QZipReader::exists(void) const
+	?prepare@QStaticText@@QAEXABVQTransform@@ABVQFont@@@Z @ 12775 NONAME ; void QStaticText::prepare(class QTransform const &, class QFont const &)
+	?paste@QTextControl@@QAEXW4Mode@QClipboard@@@Z @ 12776 NONAME ; void QTextControl::paste(enum QClipboard::Mode)
+	?horizontalAdvance@QTextLine@@QBEMXZ @ 12777 NONAME ; float QTextLine::horizontalAdvance(void) const
+	?setCurveThresholdFromTransform@QStrokerOps@@QAEXABVQTransform@@@Z @ 12778 NONAME ; void QStrokerOps::setCurveThresholdFromTransform(class QTransform const &)
+	?textWidth@QStaticText@@QBEMXZ @ 12779 NONAME ; float QStaticText::textWidth(void) const
+	?create@PixmapFragment@QPainter@@SA?AV12@ABVQPointF@@ABVQRectF@@MMMM@Z @ 12780 NONAME ; class QPainter::PixmapFragment QPainter::PixmapFragment::create(class QPointF const &, class QRectF const &, float, float, float, float)
+	?extractAll@QZipReader@@QBE_NABVQString@@@Z @ 12781 NONAME ; bool QZipReader::extractAll(class QString const &) const
+	??0FileInfo@QZipReader@@QAE@ABU01@@Z @ 12782 NONAME ; QZipReader::FileInfo::FileInfo(struct QZipReader::FileInfo const &)
+	?setTextWidth@QStaticText@@QAEXM@Z @ 12783 NONAME ; void QStaticText::setTextWidth(float)
+	?fixup@QIntValidator@@UBEXAAVQString@@@Z @ 12784 NONAME ; void QIntValidator::fixup(class QString &) const
+	?dumpAllConfigs@QEgl@@YAXXZ @ 12785 NONAME ; void QEgl::dumpAllConfigs(void)
+	?assign@QKeySequence@@AAEHABVQString@@W4SequenceFormat@1@@Z @ 12786 NONAME ; int QKeySequence::assign(class QString const &, enum QKeySequence::SequenceFormat)
+	?q_func@QAbstractScrollAreaPrivate@@ABEPBVQAbstractScrollArea@@XZ @ 12787 NONAME ; class QAbstractScrollArea const * QAbstractScrollAreaPrivate::q_func(void) const
+	?mapToScene@QGraphicsViewPrivate@@QBE?AVQRectF@@ABV2@@Z @ 12788 NONAME ; class QRectF QGraphicsViewPrivate::mapToScene(class QRectF const &) const
+	?updateScroll@QGraphicsViewPrivate@@QAEXXZ @ 12789 NONAME ; void QGraphicsViewPrivate::updateScroll(void)
+	?directoryLoaded@QFileSystemModel@@IAEXABVQString@@@Z @ 12790 NONAME ; void QFileSystemModel::directoryLoaded(class QString const &)
+	?placeholderText@QLineEdit@@QBE?AVQString@@XZ @ 12791 NONAME ; class QString QLineEdit::placeholderText(void) const
+	?setWidth@QGraphicsItemPrivate@@UAEXM@Z @ 12792 NONAME ; void QGraphicsItemPrivate::setWidth(float)
+	?q_func@QGraphicsViewPrivate@@AAEPAVQGraphicsView@@XZ @ 12793 NONAME ; class QGraphicsView * QGraphicsViewPrivate::q_func(void)
+	?setDeviceType@QEglProperties@@QAEXH@Z @ 12794 NONAME ; void QEglProperties::setDeviceType(int)
+	?convertFromImage@QPixmap@@QAE_NABVQImage@@V?$QFlags@W4ImageConversionFlag@Qt@@@@@Z @ 12795 NONAME ; bool QPixmap::convertFromImage(class QImage const &, class QFlags<enum Qt::ImageConversionFlag>)
+	?processCommands@QPaintBuffer@@QBEHPAVQPainter@@HH@Z @ 12796 NONAME ; int QPaintBuffer::processCommands(class QPainter *, int, int) const
+	?glyphPadding@QTextureGlyphCache@@UBEHXZ @ 12797 NONAME ; int QTextureGlyphCache::glyphPadding(void) const
+	??1FileInfo@QZipReader@@QAE@XZ @ 12798 NONAME ; QZipReader::FileInfo::~FileInfo(void)
+	?scrollBarPolicyChanged@QAbstractScrollAreaPrivate@@UAEXW4Orientation@Qt@@W4ScrollBarPolicy@3@@Z @ 12799 NONAME ; void QAbstractScrollAreaPrivate::scrollBarPolicyChanged(enum Qt::Orientation, enum Qt::ScrollBarPolicy)
+	?createSurface@QEgl@@YAHPAVQPaintDevice@@HPBVQEglProperties@@@Z @ 12800 NONAME ; int QEgl::createSurface(class QPaintDevice *, int, class QEglProperties const *)
+	?viewportEvent@QAbstractScrollAreaPrivate@@QAE_NPAVQEvent@@@Z @ 12801 NONAME ; bool QAbstractScrollAreaPrivate::viewportEvent(class QEvent *)
+	?frameEndIndex@QPaintBuffer@@QBEHH@Z @ 12802 NONAME ; int QPaintBuffer::frameEndIndex(int) const
+	??1QImageTextureGlyphCache@@UAE@XZ @ 12803 NONAME ; QImageTextureGlyphCache::~QImageTextureGlyphCache(void)
+	?setPerformanceHint@QStaticText@@QAEXW4PerformanceHint@1@@Z @ 12804 NONAME ; void QStaticText::setPerformanceHint(enum QStaticText::PerformanceHint)
+	??0QStaticText@@QAE@ABV0@@Z @ 12805 NONAME ; QStaticText::QStaticText(class QStaticText const &)
+	??0QImageTextureGlyphCache@@QAE@W4Type@QFontEngineGlyphCache@@ABVQTransform@@@Z @ 12806 NONAME ; QImageTextureGlyphCache::QImageTextureGlyphCache(enum QFontEngineGlyphCache::Type, class QTransform const &)
 
diff --git a/src/s60installs/eabi/QtCoreu.def b/src/s60installs/eabi/QtCoreu.def
index 48ba8d2..0590d39 100644
--- a/src/s60installs/eabi/QtCoreu.def
+++ b/src/s60installs/eabi/QtCoreu.def
@@ -3652,59 +3652,57 @@ EXPORTS
 	_Z40QBasicAtomicPointer_fetchAndStoreAcquirePVPvS_ @ 3651 NONAME
 	_Z40QBasicAtomicPointer_fetchAndStoreRelaxedPVPvS_ @ 3652 NONAME
 	_Z40QBasicAtomicPointer_fetchAndStoreReleasePVPvS_ @ 3653 NONAME
-	_Z14qDecodeDataUrlRK4QUrl @ 3654 NONAME
-	_Z18qDetectCPUFeaturesv @ 3655 NONAME
-	_ZN10QByteArray7replaceEiiPKci @ 3656 NONAME
-	_ZN12QTextDecoderC1EPK10QTextCodec6QFlagsINS0_14ConversionFlagEE @ 3657 NONAME
-	_ZN12QTextDecoderC2EPK10QTextCodec6QFlagsINS0_14ConversionFlagEE @ 3658 NONAME
-	_ZN12QTextEncoderC1EPK10QTextCodec6QFlagsINS0_14ConversionFlagEE @ 3659 NONAME
-	_ZN12QTextEncoderC2EPK10QTextCodec6QFlagsINS0_14ConversionFlagEE @ 3660 NONAME
-	_ZN13QElapsedTimer10invalidateEv @ 3661 NONAME
-	_ZN13QElapsedTimer11isMonotonicEv @ 3662 NONAME
-	_ZN13QElapsedTimer5startEv @ 3663 NONAME
-	_ZN13QElapsedTimer7restartEv @ 3664 NONAME
-	_ZN13QElapsedTimer9clockTypeEv @ 3665 NONAME
-	_ZN20QStateMachinePrivate12clearHistoryEv @ 3666 NONAME
-	_ZN7QStringC1EPK5QChar @ 3667 NONAME
-	_ZN7QStringC2EPK5QChar @ 3668 NONAME
-	_ZN8QVariantC1ERK12QEasingCurve @ 3669 NONAME
-	_ZN8QVariantC2ERK12QEasingCurve @ 3670 NONAME
-	_ZN9QDateTime18currentDateTimeUtcEv @ 3671 NONAME
-	_ZN9QDateTime22currentMSecsSinceEpochEv @ 3672 NONAME
-	_ZN9QListData11detach_growEPii @ 3673 NONAME
-	_ZN9QListData6appendEi @ 3674 NONAME
-	_ZN9QListData6detachEi @ 3675 NONAME
-	_ZN9QMetaType15registerTypedefEPKci @ 3676 NONAME
-	_ZN9QMetaType23registerStreamOperatorsEiPFvR11QDataStreamPKvEPFvS1_PvE @ 3677 NONAME
-	_ZNK10QTextCodec11makeDecoderE6QFlagsINS_14ConversionFlagEE @ 3678 NONAME
-	_ZNK10QTextCodec11makeEncoderE6QFlagsINS_14ConversionFlagEE @ 3679 NONAME
-	_ZNK13QElapsedTimer10hasExpiredEx @ 3680 NONAME
-	_ZNK13QElapsedTimer19msecsSinceReferenceEv @ 3681 NONAME
-	_ZNK13QElapsedTimer6secsToERKS_ @ 3682 NONAME
-	_ZNK13QElapsedTimer7elapsedEv @ 3683 NONAME
-	_ZNK13QElapsedTimer7isValidEv @ 3684 NONAME
-	_ZNK13QElapsedTimer7msecsToERKS_ @ 3685 NONAME
-	_ZNK6QState11transitionsEv @ 3686 NONAME
-	_ZNK8QVariant13toEasingCurveEv @ 3687 NONAME
-	_ZlsR11QDataStreamRK12QEasingCurve @ 3688 NONAME
-	_ZltRK13QElapsedTimerS1_ @ 3689 NONAME
-	_ZrsR11QDataStreamR12QEasingCurve @ 3690 NONAME
-	_ZN9QDateTime18setMSecsSinceEpochEx @ 3691 NONAME
-	_ZN9QDateTime19fromMSecsSinceEpochEx @ 3692 NONAME
-	_ZNK9QDateTime17toMSecsSinceEpochEv @ 3693 NONAME
-	_ZN10QTextCodec11validCodecsEv @ 3694 NONAME
-	_ZN16QDeclarativeData13parentChangedE @ 3695 NONAME DATA 4 ABSENT
-	_ZN16QDeclarativeData9destroyedE @ 3696 NONAME DATA 4 ABSENT
-	_ZN24QAbstractDeclarativeData13parentChangedE @ 3697 NONAME DATA 4
-	_ZN24QAbstractDeclarativeData9destroyedE @ 3698 NONAME DATA 4
-	_ZN23QEventDispatcherSymbian12selectThreadEv @ 3699 NONAME
-	_ZN10QByteArray10setRawDataEPKcj @ 3700 NONAME
-	_ZN7QString10setRawDataEPK5QChari @ 3701 NONAME
-	_ZN23QCoreApplicationPrivate11symbianInitEv @ 3702 NONAME
-	_ZN23QEventDispatcherSymbian11qt_metacallEN11QMetaObject4CallEiPPv @ 3703 NONAME
-	_ZN23QEventDispatcherSymbian11qt_metacastEPKc @ 3704 NONAME
-	_ZN23QEventDispatcherSymbian16staticMetaObjectE @ 3705 NONAME DATA 16
-	_ZN23QEventDispatcherSymbian19getStaticMetaObjectEv @ 3706 NONAME
-	_ZNK23QEventDispatcherSymbian10metaObjectEv @ 3707 NONAME
-	_ZNK9QDateTime7msecsToERKS_ @ 3708 NONAME
+	_ZN10QTextCodec11validCodecsEv @ 3654 NONAME
+	_ZN20QStateMachinePrivate12clearHistoryEv @ 3655 NONAME
+	_Z14qDecodeDataUrlRK4QUrl @ 3656 NONAME
+	_Z18qDetectCPUFeaturesv @ 3657 NONAME
+	_ZN10QByteArray10setRawDataEPKcj @ 3658 NONAME
+	_ZN10QByteArray7replaceEiiPKci @ 3659 NONAME
+	_ZN12QTextDecoderC1EPK10QTextCodec6QFlagsINS0_14ConversionFlagEE @ 3660 NONAME
+	_ZN12QTextDecoderC2EPK10QTextCodec6QFlagsINS0_14ConversionFlagEE @ 3661 NONAME
+	_ZN12QTextEncoderC1EPK10QTextCodec6QFlagsINS0_14ConversionFlagEE @ 3662 NONAME
+	_ZN12QTextEncoderC2EPK10QTextCodec6QFlagsINS0_14ConversionFlagEE @ 3663 NONAME
+	_ZN13QElapsedTimer10invalidateEv @ 3664 NONAME
+	_ZN13QElapsedTimer11isMonotonicEv @ 3665 NONAME
+	_ZN13QElapsedTimer5startEv @ 3666 NONAME
+	_ZN13QElapsedTimer7restartEv @ 3667 NONAME
+	_ZN13QElapsedTimer9clockTypeEv @ 3668 NONAME
+	_ZN23QCoreApplicationPrivate11symbianInitEv @ 3669 NONAME
+	_ZN23QEventDispatcherSymbian11qt_metacallEN11QMetaObject4CallEiPPv @ 3670 NONAME
+	_ZN23QEventDispatcherSymbian11qt_metacastEPKc @ 3671 NONAME
+	_ZN23QEventDispatcherSymbian12selectThreadEv @ 3672 NONAME
+	_ZN23QEventDispatcherSymbian16staticMetaObjectE @ 3673 NONAME DATA 16
+	_ZN23QEventDispatcherSymbian19getStaticMetaObjectEv @ 3674 NONAME
+	_ZN24QAbstractDeclarativeData13parentChangedE @ 3675 NONAME DATA 4
+	_ZN24QAbstractDeclarativeData9destroyedE @ 3676 NONAME DATA 4
+	_ZN7QString10setRawDataEPK5QChari @ 3677 NONAME
+	_ZN7QStringC1EPK5QChar @ 3678 NONAME
+	_ZN7QStringC2EPK5QChar @ 3679 NONAME
+	_ZN8QVariantC1ERK12QEasingCurve @ 3680 NONAME
+	_ZN8QVariantC2ERK12QEasingCurve @ 3681 NONAME
+	_ZN9QDateTime18currentDateTimeUtcEv @ 3682 NONAME
+	_ZN9QDateTime18setMSecsSinceEpochEx @ 3683 NONAME
+	_ZN9QDateTime19fromMSecsSinceEpochEx @ 3684 NONAME
+	_ZN9QDateTime22currentMSecsSinceEpochEv @ 3685 NONAME
+	_ZN9QListData11detach_growEPii @ 3686 NONAME
+	_ZN9QListData6appendEi @ 3687 NONAME
+	_ZN9QListData6detachEi @ 3688 NONAME
+	_ZN9QMetaType15registerTypedefEPKci @ 3689 NONAME
+	_ZN9QMetaType23registerStreamOperatorsEiPFvR11QDataStreamPKvEPFvS1_PvE @ 3690 NONAME
+	_ZNK10QTextCodec11makeDecoderE6QFlagsINS_14ConversionFlagEE @ 3691 NONAME
+	_ZNK10QTextCodec11makeEncoderE6QFlagsINS_14ConversionFlagEE @ 3692 NONAME
+	_ZNK13QElapsedTimer10hasExpiredEx @ 3693 NONAME
+	_ZNK13QElapsedTimer19msecsSinceReferenceEv @ 3694 NONAME
+	_ZNK13QElapsedTimer6secsToERKS_ @ 3695 NONAME
+	_ZNK13QElapsedTimer7elapsedEv @ 3696 NONAME
+	_ZNK13QElapsedTimer7isValidEv @ 3697 NONAME
+	_ZNK13QElapsedTimer7msecsToERKS_ @ 3698 NONAME
+	_ZNK23QEventDispatcherSymbian10metaObjectEv @ 3699 NONAME
+	_ZNK6QState11transitionsEv @ 3700 NONAME
+	_ZNK8QVariant13toEasingCurveEv @ 3701 NONAME
+	_ZNK9QDateTime17toMSecsSinceEpochEv @ 3702 NONAME
+	_ZNK9QDateTime7msecsToERKS_ @ 3703 NONAME
+	_ZlsR11QDataStreamRK12QEasingCurve @ 3704 NONAME
+	_ZltRK13QElapsedTimerS1_ @ 3705 NONAME
+	_ZrsR11QDataStreamR12QEasingCurve @ 3706 NONAME
 
diff --git a/src/s60installs/eabi/QtDeclarativeu.def b/src/s60installs/eabi/QtDeclarativeu.def
index a26e193..320a780 100644
--- a/src/s60installs/eabi/QtDeclarativeu.def
+++ b/src/s60installs/eabi/QtDeclarativeu.def
@@ -1019,7 +1019,7 @@ EXPORTS
 	_ZN21QDeclarativeFlickable11setContentYEf @ 1018 NONAME
 	_ZN21QDeclarativeFlickable11visibleAreaEv @ 1019 NONAME
 	_ZN21QDeclarativeFlickable12flickStartedEv @ 1020 NONAME
-	_ZN21QDeclarativeFlickable12setOverShootEb @ 1021 NONAME
+	_ZN21QDeclarativeFlickable12setOverShootEb @ 1021 NONAME ABSENT
 	_ZN21QDeclarativeFlickable13flickableDataEv @ 1022 NONAME
 	_ZN21QDeclarativeFlickable13movementEndedEv @ 1023 NONAME
 	_ZN21QDeclarativeFlickable13movingChangedEv @ 1024 NONAME
@@ -1037,7 +1037,7 @@ EXPORTS
 	_ZN21QDeclarativeFlickable15movementStartedEv @ 1036 NONAME
 	_ZN21QDeclarativeFlickable15setContentWidthEf @ 1037 NONAME
 	_ZN21QDeclarativeFlickable16movementStartingEv @ 1038 NONAME
-	_ZN21QDeclarativeFlickable16overShootChangedEv @ 1039 NONAME
+	_ZN21QDeclarativeFlickable16overShootChangedEv @ 1039 NONAME ABSENT
 	_ZN21QDeclarativeFlickable16sceneEventFilterEP13QGraphicsItemP6QEvent @ 1040 NONAME
 	_ZN21QDeclarativeFlickable16setContentHeightEf @ 1041 NONAME
 	_ZN21QDeclarativeFlickable16staticMetaObjectE @ 1042 NONAME DATA 16
@@ -1294,15 +1294,15 @@ EXPORTS
 	_ZN22QDeclarativeExpression19getStaticMetaObjectEv @ 1293 NONAME
 	_ZN22QDeclarativeExpression23setNotifyOnValueChangedEb @ 1294 NONAME
 	_ZN22QDeclarativeExpression5valueEPb @ 1295 NONAME ABSENT
-	_ZN22QDeclarativeExpressionC1EP19QDeclarativeContextRK7QStringP7QObject @ 1296 NONAME
+	_ZN22QDeclarativeExpressionC1EP19QDeclarativeContextRK7QStringP7QObject @ 1296 NONAME ABSENT
 	_ZN22QDeclarativeExpressionC1EP23QDeclarativeContextDataPvP20QDeclarativeRefCountP7QObjectRK7QStringiR29QDeclarativeExpressionPrivate @ 1297 NONAME
-	_ZN22QDeclarativeExpressionC1EP23QDeclarativeContextDataRK7QStringP7QObject @ 1298 NONAME
-	_ZN22QDeclarativeExpressionC1EP23QDeclarativeContextDataRK7QStringP7QObjectR29QDeclarativeExpressionPrivate @ 1299 NONAME
+	_ZN22QDeclarativeExpressionC1EP23QDeclarativeContextDataRK7QStringP7QObject @ 1298 NONAME ABSENT
+	_ZN22QDeclarativeExpressionC1EP23QDeclarativeContextDataRK7QStringP7QObjectR29QDeclarativeExpressionPrivate @ 1299 NONAME ABSENT
 	_ZN22QDeclarativeExpressionC1Ev @ 1300 NONAME
-	_ZN22QDeclarativeExpressionC2EP19QDeclarativeContextRK7QStringP7QObject @ 1301 NONAME
+	_ZN22QDeclarativeExpressionC2EP19QDeclarativeContextRK7QStringP7QObject @ 1301 NONAME ABSENT
 	_ZN22QDeclarativeExpressionC2EP23QDeclarativeContextDataPvP20QDeclarativeRefCountP7QObjectRK7QStringiR29QDeclarativeExpressionPrivate @ 1302 NONAME
-	_ZN22QDeclarativeExpressionC2EP23QDeclarativeContextDataRK7QStringP7QObject @ 1303 NONAME
-	_ZN22QDeclarativeExpressionC2EP23QDeclarativeContextDataRK7QStringP7QObjectR29QDeclarativeExpressionPrivate @ 1304 NONAME
+	_ZN22QDeclarativeExpressionC2EP23QDeclarativeContextDataRK7QStringP7QObject @ 1303 NONAME ABSENT
+	_ZN22QDeclarativeExpressionC2EP23QDeclarativeContextDataRK7QStringP7QObjectR29QDeclarativeExpressionPrivate @ 1304 NONAME ABSENT
 	_ZN22QDeclarativeExpressionC2Ev @ 1305 NONAME
 	_ZN22QDeclarativeExpressionD0Ev @ 1306 NONAME
 	_ZN22QDeclarativeExpressionD1Ev @ 1307 NONAME
@@ -1457,7 +1457,7 @@ EXPORTS
 	_ZN23QDeclarativeEngineDebugC1EP27QDeclarativeDebugConnectionP7QObject @ 1456 NONAME
 	_ZN23QDeclarativeEngineDebugC2EP27QDeclarativeDebugConnectionP7QObject @ 1457 NONAME
 	_ZN23QDeclarativeItemPrivate10resetWidthEv @ 1458 NONAME
-	_ZN23QDeclarativeItemPrivate11currentTimeEv @ 1459 NONAME
+	_ZN23QDeclarativeItemPrivate11currentTimeEv @ 1459 NONAME ABSENT
 	_ZN23QDeclarativeItemPrivate11data_appendEP24QDeclarativeListPropertyI7QObjectEPS1_ @ 1460 NONAME
 	_ZN23QDeclarativeItemPrivate11resetHeightEv @ 1461 NONAME
 	_ZN23QDeclarativeItemPrivate12focusChangedEb @ 1462 NONAME
@@ -1470,12 +1470,12 @@ EXPORTS
 	_ZN23QDeclarativeItemPrivate15transform_countEP24QDeclarativeListPropertyI18QGraphicsTransformE @ 1469 NONAME
 	_ZN23QDeclarativeItemPrivate16resources_appendEP24QDeclarativeListPropertyI7QObjectEPS1_ @ 1470 NONAME
 	_ZN23QDeclarativeItemPrivate16transform_appendEP24QDeclarativeListPropertyI18QGraphicsTransformEPS1_ @ 1471 NONAME
-	_ZN23QDeclarativeItemPrivate17setConsistentTimeEi @ 1472 NONAME
+	_ZN23QDeclarativeItemPrivate17setConsistentTimeEi @ 1472 NONAME ABSENT
 	_ZN23QDeclarativeItemPrivate24removeItemChangeListenerEP30QDeclarativeItemChangeListener6QFlagsINS_10ChangeTypeEE @ 1473 NONAME
-	_ZN23QDeclarativeItemPrivate5startER5QTime @ 1474 NONAME
+	_ZN23QDeclarativeItemPrivate5startER5QTime @ 1474 NONAME ABSENT
 	_ZN23QDeclarativeItemPrivate6statesEv @ 1475 NONAME
-	_ZN23QDeclarativeItemPrivate7elapsedER5QTime @ 1476 NONAME
-	_ZN23QDeclarativeItemPrivate7restartER5QTime @ 1477 NONAME
+	_ZN23QDeclarativeItemPrivate7elapsedER5QTime @ 1476 NONAME ABSENT
+	_ZN23QDeclarativeItemPrivate7restartER5QTime @ 1477 NONAME ABSENT
 	_ZN23QDeclarativeItemPrivate8setWidthEf @ 1478 NONAME
 	_ZN23QDeclarativeItemPrivate9setHeightEf @ 1479 NONAME
 	_ZN23QDeclarativePaintedItem10clearCacheEv @ 1480 NONAME
@@ -1600,23 +1600,23 @@ EXPORTS
 	_ZN24QDeclarativeListAccessorD2Ev @ 1599 NONAME
 	_ZN24QDeclarativeParentChange11qt_metacallEN11QMetaObject4CallEiPPv @ 1600 NONAME
 	_ZN24QDeclarativeParentChange11qt_metacastEPKc @ 1601 NONAME
-	_ZN24QDeclarativeParentChange11setRotationEf @ 1602 NONAME
+	_ZN24QDeclarativeParentChange11setRotationEf @ 1602 NONAME ABSENT
 	_ZN24QDeclarativeParentChange12isReversableEv @ 1603 NONAME
 	_ZN24QDeclarativeParentChange13copyOriginalsEP23QDeclarativeActionEvent @ 1604 NONAME ABSENT
 	_ZN24QDeclarativeParentChange13saveOriginalsEv @ 1605 NONAME
 	_ZN24QDeclarativeParentChange16staticMetaObjectE @ 1606 NONAME DATA 16
 	_ZN24QDeclarativeParentChange17saveCurrentValuesEv @ 1607 NONAME
 	_ZN24QDeclarativeParentChange19getStaticMetaObjectEv @ 1608 NONAME
-	_ZN24QDeclarativeParentChange4setXEf @ 1609 NONAME
-	_ZN24QDeclarativeParentChange4setYEf @ 1610 NONAME
+	_ZN24QDeclarativeParentChange4setXEf @ 1609 NONAME ABSENT
+	_ZN24QDeclarativeParentChange4setYEf @ 1610 NONAME ABSENT
 	_ZN24QDeclarativeParentChange6rewindEv @ 1611 NONAME
 	_ZN24QDeclarativeParentChange7actionsEv @ 1612 NONAME
 	_ZN24QDeclarativeParentChange7executeEv @ 1613 NONAME ABSENT
 	_ZN24QDeclarativeParentChange7reverseEv @ 1614 NONAME ABSENT
 	_ZN24QDeclarativeParentChange8overrideEP23QDeclarativeActionEvent @ 1615 NONAME
-	_ZN24QDeclarativeParentChange8setScaleEf @ 1616 NONAME
-	_ZN24QDeclarativeParentChange8setWidthEf @ 1617 NONAME
-	_ZN24QDeclarativeParentChange9setHeightEf @ 1618 NONAME
+	_ZN24QDeclarativeParentChange8setScaleEf @ 1616 NONAME ABSENT
+	_ZN24QDeclarativeParentChange8setWidthEf @ 1617 NONAME ABSENT
+	_ZN24QDeclarativeParentChange9setHeightEf @ 1618 NONAME ABSENT
 	_ZN24QDeclarativeParentChange9setObjectEP16QDeclarativeItem @ 1619 NONAME
 	_ZN24QDeclarativeParentChange9setParentEP16QDeclarativeItem @ 1620 NONAME
 	_ZN24QDeclarativeParentChangeC1EP7QObject @ 1621 NONAME
@@ -2496,7 +2496,7 @@ EXPORTS
 	_ZNK20QDeclarativeRepeater5countEv @ 2495 NONAME
 	_ZNK20QDeclarativeRepeater5modelEv @ 2496 NONAME
 	_ZNK20QDeclarativeRepeater8delegateEv @ 2497 NONAME
-	_ZNK20QDeclarativeTextEdit10cursorRectEv @ 2498 NONAME
+	_ZNK20QDeclarativeTextEdit10cursorRectEv @ 2498 NONAME ABSENT
 	_ZNK20QDeclarativeTextEdit10isReadOnlyEv @ 2499 NONAME
 	_ZNK20QDeclarativeTextEdit10metaObjectEv @ 2500 NONAME
 	_ZNK20QDeclarativeTextEdit10textFormatEv @ 2501 NONAME
@@ -2536,7 +2536,7 @@ EXPORTS
 	_ZNK20QMetaPropertyBuilder8isStoredEv @ 2535 NONAME
 	_ZNK20QMetaPropertyBuilder9isDynamicEv @ 2536 NONAME
 	_ZNK21QDeclarativeComponent10metaObjectEv @ 2537 NONAME
-	_ZNK21QDeclarativeComponent12errorsStringEv @ 2538 NONAME
+	_ZNK21QDeclarativeComponent12errorsStringEv @ 2538 NONAME ABSENT
 	_ZNK21QDeclarativeComponent15creationContextEv @ 2539 NONAME
 	_ZNK21QDeclarativeComponent3urlEv @ 2540 NONAME
 	_ZNK21QDeclarativeComponent6errorsEv @ 2541 NONAME
@@ -2593,7 +2593,7 @@ EXPORTS
 	_ZNK21QDeclarativeFlickable8isAtXEndEv @ 2592 NONAME
 	_ZNK21QDeclarativeFlickable8isAtYEndEv @ 2593 NONAME
 	_ZNK21QDeclarativeFlickable8isMovingEv @ 2594 NONAME
-	_ZNK21QDeclarativeFlickable9overShootEv @ 2595 NONAME
+	_ZNK21QDeclarativeFlickable9overShootEv @ 2595 NONAME ABSENT
 	_ZNK21QDeclarativeImageBase10metaObjectEv @ 2596 NONAME
 	_ZNK21QDeclarativeImageBase10sourceSizeEv @ 2597 NONAME
 	_ZNK21QDeclarativeImageBase12asynchronousEv @ 2598 NONAME
@@ -3602,4 +3602,59 @@ EXPORTS
 	_ZNK21QDeclarativeFlickable20isMovingHorizontallyEv @ 3601 NONAME
 	_ZNK21QDeclarativeFlickable22isFlickingHorizontallyEv @ 3602 NONAME
 	_ZThn16_N18QDeclarativeLoader17componentCompleteEv @ 3603 NONAME
+	_ZN16QDeclarativeText18paintedSizeChangedEv @ 3604 NONAME
+	_ZN20QDeclarativePathView5eventEP6QEvent @ 3605 NONAME
+	_ZN20QDeclarativeTextEdit12focusInEventEP11QFocusEvent @ 3606 NONAME
+	_ZN20QDeclarativeTextEdit13focusOutEventEP11QFocusEvent @ 3607 NONAME
+	_ZN20QDeclarativeTextEdit16setSelectByMouseEb @ 3608 NONAME
+	_ZN20QDeclarativeTextEdit18paintedSizeChangedEv @ 3609 NONAME
+	_ZN20QDeclarativeTextEdit20selectByMouseChangedEb @ 3610 NONAME
+	_ZN20QDeclarativeTextEdit22cursorRectangleChangedEv @ 3611 NONAME
+	_ZN20QDeclarativeTextEdit22openSoftwareInputPanelEv @ 3612 NONAME
+	_ZN20QDeclarativeTextEdit23closeSoftwareInputPanelEv @ 3613 NONAME
+	_ZN20QDeclarativeTextEdit24setShowInputPanelOnFocusEb @ 3614 NONAME
+	_ZN20QDeclarativeTextEdit28showInputPanelOnFocusChangedEb @ 3615 NONAME
+	_ZN21QDeclarativeTextInput12focusInEventEP11QFocusEvent @ 3616 NONAME
+	_ZN21QDeclarativeTextInput13focusOutEventEP11QFocusEvent @ 3617 NONAME
+	_ZN21QDeclarativeTextInput16setSelectByMouseEb @ 3618 NONAME
+	_ZN21QDeclarativeTextInput20selectByMouseChangedEb @ 3619 NONAME
+	_ZN21QDeclarativeTextInput22openSoftwareInputPanelEv @ 3620 NONAME
+	_ZN21QDeclarativeTextInput23closeSoftwareInputPanelEv @ 3621 NONAME
+	_ZN21QDeclarativeTextInput24setShowInputPanelOnFocusEb @ 3622 NONAME
+	_ZN21QDeclarativeTextInput28showInputPanelOnFocusChangedEb @ 3623 NONAME
+	_ZN22QDeclarativeExpressionC1EP19QDeclarativeContextP7QObjectRK7QStringS3_ @ 3624 NONAME
+	_ZN22QDeclarativeExpressionC1EP23QDeclarativeContextDataP7QObjectRK7QString @ 3625 NONAME
+	_ZN22QDeclarativeExpressionC1EP23QDeclarativeContextDataP7QObjectRK7QStringR29QDeclarativeExpressionPrivate @ 3626 NONAME
+	_ZN22QDeclarativeExpressionC2EP19QDeclarativeContextP7QObjectRK7QStringS3_ @ 3627 NONAME
+	_ZN22QDeclarativeExpressionC2EP23QDeclarativeContextDataP7QObjectRK7QString @ 3628 NONAME
+	_ZN22QDeclarativeExpressionC2EP23QDeclarativeContextDataP7QObjectRK7QStringR29QDeclarativeExpressionPrivate @ 3629 NONAME
+	_ZN23QDeclarativeItemPrivate17setConsistentTimeEx @ 3630 NONAME
+	_ZN23QDeclarativeItemPrivate5startER13QElapsedTimer @ 3631 NONAME
+	_ZN23QDeclarativeItemPrivate7elapsedER13QElapsedTimer @ 3632 NONAME
+	_ZN23QDeclarativeItemPrivate7restartER13QElapsedTimer @ 3633 NONAME
+	_ZN24QDeclarativeParentChange11setRotationE24QDeclarativeScriptString @ 3634 NONAME
+	_ZN24QDeclarativeParentChange4setXE24QDeclarativeScriptString @ 3635 NONAME
+	_ZN24QDeclarativeParentChange4setYE24QDeclarativeScriptString @ 3636 NONAME
+	_ZN24QDeclarativeParentChange8setScaleE24QDeclarativeScriptString @ 3637 NONAME
+	_ZN24QDeclarativeParentChange8setWidthE24QDeclarativeScriptString @ 3638 NONAME
+	_ZN24QDeclarativeParentChange9setHeightE24QDeclarativeScriptString @ 3639 NONAME
+	_ZN24QDeclarativeXmlListModel10queryErrorEPvRK7QString @ 3640 NONAME
+	_ZNK16QDeclarativeText12paintedWidthEv @ 3641 NONAME
+	_ZNK16QDeclarativeText13paintedHeightEv @ 3642 NONAME
+	_ZNK20QDeclarativeTextEdit12paintedWidthEv @ 3643 NONAME
+	_ZNK20QDeclarativeTextEdit13paintedHeightEv @ 3644 NONAME
+	_ZNK20QDeclarativeTextEdit13selectByMouseEv @ 3645 NONAME
+	_ZNK20QDeclarativeTextEdit15cursorRectangleEv @ 3646 NONAME
+	_ZNK20QDeclarativeTextEdit21showInputPanelOnFocusEv @ 3647 NONAME
+	_ZNK21QDeclarativeComponent11errorStringEv @ 3648 NONAME
+	_ZNK21QDeclarativeTextInput13selectByMouseEv @ 3649 NONAME
+	_ZNK21QDeclarativeTextInput21showInputPanelOnFocusEv @ 3650 NONAME
+	_ZNK23QDeclarativePaintedItem12boundingRectEv @ 3651 NONAME
+	_ZNK24QDeclarativeXmlListModel11errorStringEv @ 3652 NONAME
+	_ZNK24QDeclarativeXmlListModel3getEi @ 3653 NONAME
+	_ZThn8_N20QDeclarativeTextEdit12focusInEventEP11QFocusEvent @ 3654 NONAME
+	_ZThn8_N20QDeclarativeTextEdit13focusOutEventEP11QFocusEvent @ 3655 NONAME
+	_ZThn8_N21QDeclarativeTextInput12focusInEventEP11QFocusEvent @ 3656 NONAME
+	_ZThn8_N21QDeclarativeTextInput13focusOutEventEP11QFocusEvent @ 3657 NONAME
+	_ZThn8_NK23QDeclarativePaintedItem12boundingRectEv @ 3658 NONAME
 
diff --git a/src/s60installs/eabi/QtGuiu.def b/src/s60installs/eabi/QtGuiu.def
index 6b05e9b..8aafde9 100644
--- a/src/s60installs/eabi/QtGuiu.def
+++ b/src/s60installs/eabi/QtGuiu.def
@@ -11805,211 +11805,205 @@ EXPORTS
 	_ZN24QImagePixmapCleanupHooks34executePixmapDataModificationHooksEP11QPixmapData @ 11804 NONAME
 	_ZN9QS60Style10timerEventEP11QTimerEvent @ 11805 NONAME
 	_ZN9QS60Style11eventFilterEP7QObjectP6QEvent @ 11806 NONAME
-	_ZN13QFontDatabase25removeAllApplicationFontsEv @ 11807 NONAME
-	_ZN10QZipReader5closeEv @ 11808 NONAME
-	_ZN10QZipReader8FileInfoC1ERKS0_ @ 11809 NONAME
-	_ZN10QZipReader8FileInfoC1Ev @ 11810 NONAME
-	_ZN10QZipReader8FileInfoC2ERKS0_ @ 11811 NONAME
-	_ZN10QZipReader8FileInfoC2Ev @ 11812 NONAME
-	_ZN10QZipReader8FileInfoD1Ev @ 11813 NONAME
-	_ZN10QZipReader8FileInfoD2Ev @ 11814 NONAME
-	_ZN10QZipReader8FileInfoaSERKS0_ @ 11815 NONAME
-	_ZN10QZipReaderC1EP9QIODevice @ 11816 NONAME
-	_ZN10QZipReaderC1ERK7QString6QFlagsIN9QIODevice12OpenModeFlagEE @ 11817 NONAME
-	_ZN10QZipReaderC2EP9QIODevice @ 11818 NONAME
-	_ZN10QZipReaderC2ERK7QString6QFlagsIN9QIODevice12OpenModeFlagEE @ 11819 NONAME
-	_ZN10QZipReaderD1Ev @ 11820 NONAME
-	_ZN10QZipReaderD2Ev @ 11821 NONAME
-	_ZN11QStaticText13setTextFormatEN2Qt10TextFormatE @ 11822 NONAME
-	_ZN11QStaticText14setMaximumSizeERK6QSizeF @ 11823 NONAME ABSENT
-	_ZN11QStaticText18setPerformanceHintENS_15PerformanceHintE @ 11824 NONAME
-	_ZN11QStaticText6detachEv @ 11825 NONAME
-	_ZN11QStaticText7prepareERK10QTransformRK5QFont @ 11826 NONAME
-	_ZN11QStaticText7setTextERK7QString @ 11827 NONAME
-	_ZN11QStaticTextC1ERK7QString @ 11828 NONAME
-	_ZN11QStaticTextC1ERKS_ @ 11829 NONAME
-	_ZN11QStaticTextC1Ev @ 11830 NONAME
-	_ZN11QStaticTextC2ERK7QString @ 11831 NONAME
-	_ZN11QStaticTextC2ERKS_ @ 11832 NONAME
-	_ZN11QStaticTextC2Ev @ 11833 NONAME
-	_ZN11QStaticTextD1Ev @ 11834 NONAME
-	_ZN11QStaticTextD2Ev @ 11835 NONAME
-	_ZN11QStaticTextaSERKS_ @ 11836 NONAME
-	_ZN12QKeySequence6assignERK7QStringNS_14SequenceFormatE @ 11837 NONAME
-	_ZN12QKeySequenceC1ERK7QStringNS_14SequenceFormatE @ 11838 NONAME
-	_ZN12QKeySequenceC2ERK7QStringNS_14SequenceFormatE @ 11839 NONAME
-	_ZN13QTextDocument19clearUndoRedoStacksENS_6StacksE @ 11840 NONAME
-	_ZN14QPaintEngineEx19drawPixmapFragmentsEPKN8QPainter8FragmentEiRK7QPixmap6QFlagsINS0_12FragmentHintEE @ 11841 NONAME ABSENT
-	_ZN14QWidgetPrivate11inTabWidgetEP7QWidget @ 11842 NONAME
-	_ZN14QWidgetPrivate17canKeypadNavigateEN2Qt11OrientationE @ 11843 NONAME
-	_ZN14QWidgetPrivate6renderEP12QPaintDeviceRK6QPointRK7QRegion6QFlagsIN7QWidget10RenderFlagEEb @ 11844 NONAME
-	_ZN15QGraphicsWidget21setAutoFillBackgroundEb @ 11845 NONAME
-	_ZN16QFileSystemModel15directoryLoadedERK7QString @ 11846 NONAME
-	_ZN18QTextureGlyphCache8populateEP11QFontEngineiPKjPK11QFixedPoint @ 11847 NONAME
-	_ZN19QApplicationPrivate15getPixmapCursorEN2Qt11CursorShapeE @ 11848 NONAME
-	_ZN20QGraphicsViewPrivate10centerViewEN13QGraphicsView14ViewportAnchorE @ 11849 NONAME
-	_ZN20QGraphicsViewPrivate10updateRectERK5QRect @ 11850 NONAME
-	_ZN20QGraphicsViewPrivate12updateRegionERK7QRegion @ 11851 NONAME ABSENT
-	_ZN20QGraphicsViewPrivate12updateScrollEv @ 11852 NONAME
-	_ZN20QGraphicsViewPrivate15storeMouseEventEP11QMouseEvent @ 11853 NONAME
-	_ZN20QGraphicsViewPrivate18storeDragDropEventEPK27QGraphicsSceneDragDropEvent @ 11854 NONAME
-	_ZN20QGraphicsViewPrivate19translateTouchEventEPS_P11QTouchEvent @ 11855 NONAME
-	_ZN20QGraphicsViewPrivate20_q_setViewportCursorERK7QCursor @ 11856 NONAME
-	_ZN20QGraphicsViewPrivate20replayLastMouseEventEv @ 11857 NONAME
-	_ZN20QGraphicsViewPrivate21freeStyleOptionsArrayEP24QStyleOptionGraphicsItem @ 11858 NONAME
-	_ZN20QGraphicsViewPrivate21mouseMoveEventHandlerEP11QMouseEvent @ 11859 NONAME
-	_ZN20QGraphicsViewPrivate21processPendingUpdatesEv @ 11860 NONAME
-	_ZN20QGraphicsViewPrivate21updateLastCenterPointEv @ 11861 NONAME
-	_ZN20QGraphicsViewPrivate22_q_unsetViewportCursorEv @ 11862 NONAME
-	_ZN20QGraphicsViewPrivate22allocStyleOptionsArrayEi @ 11863 NONAME
-	_ZN20QGraphicsViewPrivate22recalculateContentSizeEv @ 11864 NONAME
-	_ZN20QGraphicsViewPrivate26populateSceneDragDropEventEP27QGraphicsSceneDragDropEventP10QDropEvent @ 11865 NONAME
-	_ZN20QGraphicsViewPrivate28updateInputMethodSensitivityEv @ 11866 NONAME
-	_ZN20QGraphicsViewPrivateC1Ev @ 11867 NONAME
-	_ZN20QGraphicsViewPrivateC2Ev @ 11868 NONAME
-	_ZN24QImagePixmapCleanupHooks13isImageCachedERK6QImage @ 11869 NONAME
-	_ZN24QImagePixmapCleanupHooks14isPixmapCachedERK7QPixmap @ 11870 NONAME
-	_ZN26QAbstractScrollAreaPrivate14layoutChildrenEv @ 11871 NONAME
-	_ZN26QAbstractScrollAreaPrivate16replaceScrollBarEP10QScrollBarN2Qt11OrientationE @ 11872 NONAME
-	_ZN26QAbstractScrollAreaPrivate23_q_showOrHideScrollBarsEv @ 11873 NONAME
-	_ZN26QAbstractScrollAreaPrivate4initEv @ 11874 NONAME
-	_ZN26QAbstractScrollAreaPrivate9_q_hslideEi @ 11875 NONAME
-	_ZN26QAbstractScrollAreaPrivate9_q_vslideEi @ 11876 NONAME
-	_ZN26QAbstractScrollAreaPrivateC1Ev @ 11877 NONAME
-	_ZN26QAbstractScrollAreaPrivateC2Ev @ 11878 NONAME
-	_ZN6QColor12isValidColorERK7QString @ 11879 NONAME
-	_ZN6QColor18setColorFromStringERK7QString @ 11880 NONAME
-	_ZN6QLabel12setSelectionEii @ 11881 NONAME
-	_ZN7QPixmap16convertFromImageERK6QImage6QFlagsIN2Qt19ImageConversionFlagEE @ 11882 NONAME
-	_ZN8QPainter14drawStaticTextERK7QPointFRK11QStaticText @ 11883 NONAME
-	_ZN8QPainter19drawPixmapFragmentsEPKNS_8FragmentEiRK7QPixmap6QFlagsINS_12FragmentHintEE @ 11884 NONAME ABSENT
-	_ZN8QPainter8Fragment6createERK7QPointFRK6QRectFffff @ 11885 NONAME ABSENT
-	_ZN8QToolBar17visibilityChangedEb @ 11886 NONAME
-	_ZNK10QZipReader10extractAllERK7QString @ 11887 NONAME
-	_ZNK10QZipReader10isReadableEv @ 11888 NONAME
-	_ZNK10QZipReader11entryInfoAtEi @ 11889 NONAME
-	_ZNK10QZipReader12fileInfoListEv @ 11890 NONAME
-	_ZNK10QZipReader5countEv @ 11891 NONAME
-	_ZNK10QZipReader6existsEv @ 11892 NONAME
-	_ZNK10QZipReader6statusEv @ 11893 NONAME
-	_ZNK10QZipReader8fileDataERK7QString @ 11894 NONAME
-	_ZNK11QStaticText10textFormatEv @ 11895 NONAME
-	_ZNK11QStaticText11maximumSizeEv @ 11896 NONAME ABSENT
-	_ZNK11QStaticText15performanceHintEv @ 11897 NONAME
-	_ZNK11QStaticText4sizeEv @ 11898 NONAME
-	_ZNK11QStaticText4textEv @ 11899 NONAME
-	_ZNK11QStaticTexteqERKS_ @ 11900 NONAME
-	_ZNK11QStaticTextneERKS_ @ 11901 NONAME
-	_ZNK11QTextCursor15positionInBlockEv @ 11902 NONAME
-	_ZNK13QIntValidator5fixupER7QString @ 11903 NONAME
-	_ZNK14QPlainTextEdit8anchorAtERK6QPoint @ 11904 NONAME
-	_ZNK15QGraphicsWidget18autoFillBackgroundEv @ 11905 NONAME
-	_ZNK20QGraphicsViewPrivate10mapToSceneERK6QRectF @ 11906 NONAME
-	_ZNK20QGraphicsViewPrivate10mapToSceneERK7QPointF @ 11907 NONAME
-	_ZNK20QGraphicsViewPrivate13mapToViewRectEPK13QGraphicsItemRK6QRectF @ 11908 NONAME
-	_ZNK20QGraphicsViewPrivate14mapRectToSceneERK5QRect @ 11909 NONAME
-	_ZNK20QGraphicsViewPrivate14verticalScrollEv @ 11910 NONAME
-	_ZNK20QGraphicsViewPrivate15mapToViewRegionEPK13QGraphicsItemRK6QRectF @ 11911 NONAME
-	_ZNK20QGraphicsViewPrivate16horizontalScrollEv @ 11912 NONAME
-	_ZNK20QGraphicsViewPrivate16mapRectFromSceneERK6QRectF @ 11913 NONAME
-	_ZNK20QGraphicsViewPrivate16rubberBandRegionEPK7QWidgetRK5QRect @ 11914 NONAME
-	_ZNK20QGraphicsViewPrivate9findItemsERK7QRegionPbRK10QTransform @ 11915 NONAME
-	_ZNK26QAbstractScrollAreaPrivate14contentsOffsetEv @ 11916 NONAME
-	_ZNK6QImage13constScanLineEi @ 11917 NONAME
-	_ZNK6QImage9constBitsEv @ 11918 NONAME
-	_ZNK6QLabel12selectedTextEv @ 11919 NONAME
-	_ZNK6QLabel14selectionStartEv @ 11920 NONAME
-	_ZNK6QLabel15hasSelectedTextEv @ 11921 NONAME
-	_ZNK7QBezier11getSubRangeEff @ 11922 NONAME
-	_ZNK7QBezier5mapByERK10QTransform @ 11923 NONAME
-	_ZTI20QGraphicsViewPrivate @ 11924 NONAME
-	_ZTI26QAbstractScrollAreaPrivate @ 11925 NONAME
-	_ZTV20QGraphicsViewPrivate @ 11926 NONAME
-	_ZTV26QAbstractScrollAreaPrivate @ 11927 NONAME
-	_Z14qt_draw_glyphsP8QPainterPKjPK7QPointFi @ 11928 NONAME
-	_ZN11QFontEngine16getGlyphBearingsEjPfS0_ @ 11929 NONAME
-	_ZN12QLineControl17updateDisplayTextEb @ 11930 NONAME
-	_ZN12QLineControl5pasteEN10QClipboard4ModeE @ 11931 NONAME
-	_ZN12QTextControl5pasteEN10QClipboard4ModeE @ 11932 NONAME
-	_ZN14QPaintEngineEx19drawPixmapFragmentsEPKN8QPainter14PixmapFragmentEiRK7QPixmap6QFlagsINS0_18PixmapFragmentHintEE @ 11933 NONAME
-	_ZN15QGraphicsObject12widthChangedEv @ 11934 NONAME
-	_ZN15QGraphicsObject13heightChangedEv @ 11935 NONAME
-	_ZN15QGraphicsObject15childrenChangedEv @ 11936 NONAME
-	_ZN15QGraphicsWidget15geometryChangedEv @ 11937 NONAME
-	_ZN15QSplitterHandle11resizeEventEP12QResizeEvent @ 11938 NONAME
-	_ZN20QGraphicsItemPrivate10resetWidthEv @ 11939 NONAME
-	_ZN20QGraphicsItemPrivate11resetHeightEv @ 11940 NONAME
-	_ZN20QGraphicsItemPrivate12childrenListEv @ 11941 NONAME
-	_ZN20QGraphicsItemPrivate14setFocusHelperEN2Qt11FocusReasonEbb @ 11942 NONAME
-	_ZN20QGraphicsItemPrivate16clearFocusHelperEb @ 11943 NONAME
-	_ZN20QGraphicsItemPrivate24prependGraphicsTransformEP18QGraphicsTransform @ 11944 NONAME
-	_ZN20QGraphicsItemPrivate6appendEP24QDeclarativeListPropertyI15QGraphicsObjectEPS1_ @ 11945 NONAME ABSENT
-	_ZN20QGraphicsItemPrivate8setWidthEf @ 11946 NONAME
-	_ZN20QGraphicsItemPrivate9setHeightEf @ 11947 NONAME
-	_ZN7QWizard11pageRemovedEi @ 11948 NONAME
-	_ZN7QWizard13setSideWidgetEP7QWidget @ 11949 NONAME
-	_ZN7QWizard9pageAddedEi @ 11950 NONAME
-	_ZN8QPainter14PixmapFragment6createERK7QPointFRK6QRectFffff @ 11951 NONAME
-	_ZN8QPainter19drawPixmapFragmentsEPKNS_14PixmapFragmentEiRK7QPixmap6QFlagsINS_18PixmapFragmentHintEE @ 11952 NONAME
-	_ZN9QLineEdit18setPlaceholderTextERK7QString @ 11953 NONAME
-	_ZNK10QZipReader6deviceEv @ 11954 NONAME
-	_ZNK10QZipReader8FileInfo7isValidEv @ 11955 NONAME
-	_ZNK20QGraphicsItemPrivate5widthEv @ 11956 NONAME
-	_ZNK20QGraphicsItemPrivate6heightEv @ 11957 NONAME
-	_ZNK6QImage13bitPlaneCountEv @ 11958 NONAME
-	_ZNK7QWizard10sideWidgetEv @ 11959 NONAME
-	_ZNK9QLineEdit15placeholderTextEv @ 11960 NONAME
-	_ZNK9QTextLine17horizontalAdvanceEv @ 11961 NONAME
-	_ZN11QStaticText12setTextWidthEf @ 11962 NONAME
-	_ZN13QGraphicsItem16updateMicroFocusEv @ 11963 NONAME
-	_ZN15QGraphicsObject16updateMicroFocusEv @ 11964 NONAME
-	_ZN15QGraphicsWidget13layoutChangedEv @ 11965 NONAME
-	_ZN16QPainterReplayer15processCommandsERK12QPaintBufferP8QPainterii @ 11966 NONAME
-	_ZNK11QStaticText9textWidthEv @ 11967 NONAME
-	_ZNK12QPaintBuffer13frameEndIndexEi @ 11968 NONAME
-	_ZNK12QPaintBuffer15frameStartIndexEi @ 11969 NONAME
-	_ZNK12QPaintBuffer15processCommandsEP8QPainterii @ 11970 NONAME
-	_ZNK12QPaintBuffer18commandDescriptionEi @ 11971 NONAME
-	_ZN20QGraphicsItemPrivate11children_atEP24QDeclarativeListPropertyI15QGraphicsObjectEi @ 11972 NONAME
-	_ZN20QGraphicsItemPrivate14children_countEP24QDeclarativeListPropertyI15QGraphicsObjectE @ 11973 NONAME
-	_ZN20QGraphicsItemPrivate15children_appendEP24QDeclarativeListPropertyI15QGraphicsObjectEPS1_ @ 11974 NONAME
-	_ZN11QEglContext14destroyContextEv @ 11975 NONAME
-	_ZN14QEglProperties13setDeviceTypeEi @ 11976 NONAME
-	_ZN4QEgl10clearErrorEv @ 11977 NONAME ABSENT
-	_ZN4QEgl10extensionsEv @ 11978 NONAME
-	_ZN4QEgl11errorStringEi @ 11979 NONAME
-	_ZN4QEgl11errorStringEv @ 11980 NONAME ABSENT
-	_ZN4QEgl12chooseConfigEPK14QEglPropertiesNS_16PixelFormatMatchE @ 11981 NONAME
-	_ZN4QEgl12hasExtensionEPKc @ 11982 NONAME
-	_ZN4QEgl12nativePixmapEP7QPixmap @ 11983 NONAME
-	_ZN4QEgl12nativeWindowEP7QWidget @ 11984 NONAME
-	_ZN4QEgl13createSurfaceEP12QPaintDeviceiPK14QEglProperties @ 11985 NONAME
-	_ZN4QEgl13defaultConfigEiNS_3APIE6QFlagsINS_12ConfigOptionEE @ 11986 NONAME
-	_ZN4QEgl13nativeDisplayEv @ 11987 NONAME
-	_ZN4QEgl14dumpAllConfigsEv @ 11988 NONAME
-	_ZN4QEgl17eglCreateImageKHREiiiiPKi @ 11989 NONAME
-	_ZN4QEgl18eglDestroyImageKHREii @ 11990 NONAME
-	_ZN4QEgl5errorEv @ 11991 NONAME ABSENT
-	_ZN4QEgl7displayEv @ 11992 NONAME
-	_ZNK11QEglContext12configAttribEi @ 11993 NONAME
-	_ZNK11QEglContext16configPropertiesEv @ 11994 NONAME ABSENT
-	_ZNK19QItemSelectionRange7isEmptyEv @ 11995 NONAME
-	_ZN13QIconEngineV28iconNameEv @ 11996 NONAME
-	_ZN14QWindowSurface23setPartialUpdateSupportEb @ 11997 NONAME
-	_ZNK14QWindowSurface23hasPartialUpdateSupportEv @ 11998 NONAME
-	_ZNK5QIcon4nameEv @ 11999 NONAME
-	_ZN20QGraphicsViewPrivate12updateRegionERK6QRectFRK10QTransform @ 12000 NONAME
-	_ZN12QPixmapCache10allPixmapsEv @ 12001 NONAME
-	_ZN12QPixmapCache20flushDetachedPixmapsEv @ 12002 NONAME
-	_ZN12QPixmapCache9totalUsedEv @ 12003 NONAME
-	_ZN20QGraphicsItemPrivate30updatePaintedViewBoundingRectsEb @ 12004 NONAME
-	_ZN20QGraphicsViewPrivate13setUpdateClipEP13QGraphicsItem @ 12005 NONAME
-	_ZN23QImageTextureGlyphCache11fillTextureERKN18QTextureGlyphCache5CoordEj @ 12006 NONAME
-	_ZN23QImageTextureGlyphCache17createTextureDataEii @ 12007 NONAME
-	_ZN23QImageTextureGlyphCache17resizeTextureDataEii @ 12008 NONAME
-	_ZNK23QImageTextureGlyphCache11glyphMarginEv @ 12009 NONAME
-	_ZNK7QBezier12addToPolygonEP9QPolygonFf @ 12010 NONAME
-	_ZNK7QBezier9toPolygonEf @ 12011 NONAME
-	_ZTI23QImageTextureGlyphCache @ 12012 NONAME
-	_ZTV23QImageTextureGlyphCache @ 12013 NONAME
+	_ZN11QEglContext10clearErrorEv @ 11807 NONAME ABSENT
+	_ZN11QEglContext13nativeDisplayEv @ 11808 NONAME ABSENT
+	_ZN11QEglContext14destroyContextEv @ 11809 NONAME
+	_ZN11QEglContext3dpyE @ 11810 NONAME DATA 4 ABSENT
+	_ZN11QEglContext5errorEv @ 11811 NONAME ABSENT
+	_ZN11QEglContext7displayEv @ 11812 NONAME ABSENT
+	_ZN11QFontEngine16getGlyphBearingsEjPfS0_ @ 11813 NONAME
+	_ZN12QLineControl17updateDisplayTextEb @ 11814 NONAME
+	_ZN13QFontDatabase25removeAllApplicationFontsEv @ 11815 NONAME
+	_ZN14QWidgetPrivate11inTabWidgetEP7QWidget @ 11816 NONAME
+	_ZN14QWidgetPrivate17canKeypadNavigateEN2Qt11OrientationE @ 11817 NONAME
+	_ZN20QGraphicsItemPrivate14setFocusHelperEN2Qt11FocusReasonEbb @ 11818 NONAME
+	_ZN20QGraphicsItemPrivate16clearFocusHelperEb @ 11819 NONAME
+	_ZN24QImagePixmapCleanupHooks13isImageCachedERK6QImage @ 11820 NONAME
+	_ZN24QImagePixmapCleanupHooks14isPixmapCachedERK7QPixmap @ 11821 NONAME
+	_Z14qt_draw_glyphsP8QPainterPKjPK7QPointFi @ 11822 NONAME
+	_ZN10QZipReader5closeEv @ 11823 NONAME
+	_ZN10QZipReader8FileInfoC1ERKS0_ @ 11824 NONAME
+	_ZN10QZipReader8FileInfoC1Ev @ 11825 NONAME
+	_ZN10QZipReader8FileInfoC2ERKS0_ @ 11826 NONAME
+	_ZN10QZipReader8FileInfoC2Ev @ 11827 NONAME
+	_ZN10QZipReader8FileInfoD1Ev @ 11828 NONAME
+	_ZN10QZipReader8FileInfoD2Ev @ 11829 NONAME
+	_ZN10QZipReader8FileInfoaSERKS0_ @ 11830 NONAME
+	_ZN10QZipReaderC1EP9QIODevice @ 11831 NONAME
+	_ZN10QZipReaderC1ERK7QString6QFlagsIN9QIODevice12OpenModeFlagEE @ 11832 NONAME
+	_ZN10QZipReaderC2EP9QIODevice @ 11833 NONAME
+	_ZN10QZipReaderC2ERK7QString6QFlagsIN9QIODevice12OpenModeFlagEE @ 11834 NONAME
+	_ZN10QZipReaderD1Ev @ 11835 NONAME
+	_ZN10QZipReaderD2Ev @ 11836 NONAME
+	_ZN11QStaticText12setTextWidthEf @ 11837 NONAME
+	_ZN11QStaticText13setTextFormatEN2Qt10TextFormatE @ 11838 NONAME
+	_ZN11QStaticText18setPerformanceHintENS_15PerformanceHintE @ 11839 NONAME
+	_ZN11QStaticText6detachEv @ 11840 NONAME
+	_ZN11QStaticText7prepareERK10QTransformRK5QFont @ 11841 NONAME
+	_ZN11QStaticText7setTextERK7QString @ 11842 NONAME
+	_ZN11QStaticTextC1ERK7QString @ 11843 NONAME
+	_ZN11QStaticTextC1ERKS_ @ 11844 NONAME
+	_ZN11QStaticTextC1Ev @ 11845 NONAME
+	_ZN11QStaticTextC2ERK7QString @ 11846 NONAME
+	_ZN11QStaticTextC2ERKS_ @ 11847 NONAME
+	_ZN11QStaticTextC2Ev @ 11848 NONAME
+	_ZN11QStaticTextD1Ev @ 11849 NONAME
+	_ZN11QStaticTextD2Ev @ 11850 NONAME
+	_ZN11QStaticTextaSERKS_ @ 11851 NONAME
+	_ZN12QKeySequence6assignERK7QStringNS_14SequenceFormatE @ 11852 NONAME
+	_ZN12QKeySequenceC1ERK7QStringNS_14SequenceFormatE @ 11853 NONAME
+	_ZN12QKeySequenceC2ERK7QStringNS_14SequenceFormatE @ 11854 NONAME
+	_ZN12QLineControl5pasteEN10QClipboard4ModeE @ 11855 NONAME
+	_ZN12QPixmapCache10allPixmapsEv @ 11856 NONAME
+	_ZN12QPixmapCache20flushDetachedPixmapsEv @ 11857 NONAME
+	_ZN12QPixmapCache9totalUsedEv @ 11858 NONAME
+	_ZN12QTextControl5pasteEN10QClipboard4ModeE @ 11859 NONAME
+	_ZN13QGraphicsItem16updateMicroFocusEv @ 11860 NONAME
+	_ZN13QIconEngineV28iconNameEv @ 11861 NONAME
+	_ZN13QTextDocument19clearUndoRedoStacksENS_6StacksE @ 11862 NONAME
+	_ZN14QEglProperties13setDeviceTypeEi @ 11863 NONAME
+	_ZN14QPaintEngineEx19drawPixmapFragmentsEPKN8QPainter14PixmapFragmentEiRK7QPixmap6QFlagsINS0_18PixmapFragmentHintEE @ 11864 NONAME
+	_ZN14QWidgetPrivate6renderEP12QPaintDeviceRK6QPointRK7QRegion6QFlagsIN7QWidget10RenderFlagEEb @ 11865 NONAME
+	_ZN14QWindowSurface23setPartialUpdateSupportEb @ 11866 NONAME
+	_ZN15QGraphicsObject12widthChangedEv @ 11867 NONAME
+	_ZN15QGraphicsObject13heightChangedEv @ 11868 NONAME
+	_ZN15QGraphicsObject15childrenChangedEv @ 11869 NONAME
+	_ZN15QGraphicsObject16updateMicroFocusEv @ 11870 NONAME
+	_ZN15QGraphicsWidget13layoutChangedEv @ 11871 NONAME
+	_ZN15QGraphicsWidget15geometryChangedEv @ 11872 NONAME
+	_ZN15QGraphicsWidget21setAutoFillBackgroundEb @ 11873 NONAME
+	_ZN15QSplitterHandle11resizeEventEP12QResizeEvent @ 11874 NONAME
+	_ZN16QFileSystemModel15directoryLoadedERK7QString @ 11875 NONAME
+	_ZN16QPainterReplayer15processCommandsERK12QPaintBufferP8QPainterii @ 11876 NONAME
+	_ZN18QTextureGlyphCache8populateEP11QFontEngineiPKjPK11QFixedPoint @ 11877 NONAME
+	_ZN19QApplicationPrivate15getPixmapCursorEN2Qt11CursorShapeE @ 11878 NONAME
+	_ZN20QGraphicsItemPrivate10resetWidthEv @ 11879 NONAME
+	_ZN20QGraphicsItemPrivate11children_atEP24QDeclarativeListPropertyI15QGraphicsObjectEi @ 11880 NONAME
+	_ZN20QGraphicsItemPrivate11resetHeightEv @ 11881 NONAME
+	_ZN20QGraphicsItemPrivate12childrenListEv @ 11882 NONAME
+	_ZN20QGraphicsItemPrivate14children_countEP24QDeclarativeListPropertyI15QGraphicsObjectE @ 11883 NONAME
+	_ZN20QGraphicsItemPrivate15children_appendEP24QDeclarativeListPropertyI15QGraphicsObjectEPS1_ @ 11884 NONAME
+	_ZN20QGraphicsItemPrivate24prependGraphicsTransformEP18QGraphicsTransform @ 11885 NONAME
+	_ZN20QGraphicsItemPrivate30updatePaintedViewBoundingRectsEb @ 11886 NONAME
+	_ZN20QGraphicsItemPrivate8setWidthEf @ 11887 NONAME
+	_ZN20QGraphicsItemPrivate9setHeightEf @ 11888 NONAME
+	_ZN20QGraphicsViewPrivate10centerViewEN13QGraphicsView14ViewportAnchorE @ 11889 NONAME
+	_ZN20QGraphicsViewPrivate10updateRectERK5QRect @ 11890 NONAME
+	_ZN20QGraphicsViewPrivate12updateRegionERK6QRectFRK10QTransform @ 11891 NONAME
+	_ZN20QGraphicsViewPrivate12updateScrollEv @ 11892 NONAME
+	_ZN20QGraphicsViewPrivate13setUpdateClipEP13QGraphicsItem @ 11893 NONAME
+	_ZN20QGraphicsViewPrivate15storeMouseEventEP11QMouseEvent @ 11894 NONAME
+	_ZN20QGraphicsViewPrivate18storeDragDropEventEPK27QGraphicsSceneDragDropEvent @ 11895 NONAME
+	_ZN20QGraphicsViewPrivate19translateTouchEventEPS_P11QTouchEvent @ 11896 NONAME
+	_ZN20QGraphicsViewPrivate20_q_setViewportCursorERK7QCursor @ 11897 NONAME
+	_ZN20QGraphicsViewPrivate20replayLastMouseEventEv @ 11898 NONAME
+	_ZN20QGraphicsViewPrivate21freeStyleOptionsArrayEP24QStyleOptionGraphicsItem @ 11899 NONAME
+	_ZN20QGraphicsViewPrivate21mouseMoveEventHandlerEP11QMouseEvent @ 11900 NONAME
+	_ZN20QGraphicsViewPrivate21processPendingUpdatesEv @ 11901 NONAME
+	_ZN20QGraphicsViewPrivate21updateLastCenterPointEv @ 11902 NONAME
+	_ZN20QGraphicsViewPrivate22_q_unsetViewportCursorEv @ 11903 NONAME
+	_ZN20QGraphicsViewPrivate22allocStyleOptionsArrayEi @ 11904 NONAME
+	_ZN20QGraphicsViewPrivate22recalculateContentSizeEv @ 11905 NONAME
+	_ZN20QGraphicsViewPrivate26populateSceneDragDropEventEP27QGraphicsSceneDragDropEventP10QDropEvent @ 11906 NONAME
+	_ZN20QGraphicsViewPrivate28updateInputMethodSensitivityEv @ 11907 NONAME
+	_ZN20QGraphicsViewPrivateC1Ev @ 11908 NONAME
+	_ZN20QGraphicsViewPrivateC2Ev @ 11909 NONAME
+	_ZN23QImageTextureGlyphCache11fillTextureERKN18QTextureGlyphCache5CoordEj @ 11910 NONAME
+	_ZN23QImageTextureGlyphCache17createTextureDataEii @ 11911 NONAME
+	_ZN23QImageTextureGlyphCache17resizeTextureDataEii @ 11912 NONAME
+	_ZN26QAbstractScrollAreaPrivate14layoutChildrenEv @ 11913 NONAME
+	_ZN26QAbstractScrollAreaPrivate16replaceScrollBarEP10QScrollBarN2Qt11OrientationE @ 11914 NONAME
+	_ZN26QAbstractScrollAreaPrivate23_q_showOrHideScrollBarsEv @ 11915 NONAME
+	_ZN26QAbstractScrollAreaPrivate4initEv @ 11916 NONAME
+	_ZN26QAbstractScrollAreaPrivate9_q_hslideEi @ 11917 NONAME
+	_ZN26QAbstractScrollAreaPrivate9_q_vslideEi @ 11918 NONAME
+	_ZN26QAbstractScrollAreaPrivateC1Ev @ 11919 NONAME
+	_ZN26QAbstractScrollAreaPrivateC2Ev @ 11920 NONAME
+	_ZN4QEgl10extensionsEv @ 11921 NONAME
+	_ZN4QEgl11errorStringEi @ 11922 NONAME
+	_ZN4QEgl12chooseConfigEPK14QEglPropertiesNS_16PixelFormatMatchE @ 11923 NONAME
+	_ZN4QEgl12hasExtensionEPKc @ 11924 NONAME
+	_ZN4QEgl12nativePixmapEP7QPixmap @ 11925 NONAME
+	_ZN4QEgl12nativeWindowEP7QWidget @ 11926 NONAME
+	_ZN4QEgl13createSurfaceEP12QPaintDeviceiPK14QEglProperties @ 11927 NONAME
+	_ZN4QEgl13defaultConfigEiNS_3APIE6QFlagsINS_12ConfigOptionEE @ 11928 NONAME
+	_ZN4QEgl13nativeDisplayEv @ 11929 NONAME
+	_ZN4QEgl14dumpAllConfigsEv @ 11930 NONAME
+	_ZN4QEgl17eglCreateImageKHREiiiiPKi @ 11931 NONAME
+	_ZN4QEgl18eglDestroyImageKHREii @ 11932 NONAME
+	_ZN4QEgl7displayEv @ 11933 NONAME
+	_ZN6QColor12isValidColorERK7QString @ 11934 NONAME
+	_ZN6QColor18setColorFromStringERK7QString @ 11935 NONAME
+	_ZN6QLabel12setSelectionEii @ 11936 NONAME
+	_ZN7QPixmap16convertFromImageERK6QImage6QFlagsIN2Qt19ImageConversionFlagEE @ 11937 NONAME
+	_ZN7QWizard11pageRemovedEi @ 11938 NONAME
+	_ZN7QWizard13setSideWidgetEP7QWidget @ 11939 NONAME
+	_ZN7QWizard9pageAddedEi @ 11940 NONAME
+	_ZN8QPainter14PixmapFragment6createERK7QPointFRK6QRectFffff @ 11941 NONAME
+	_ZN8QPainter14drawStaticTextERK7QPointFRK11QStaticText @ 11942 NONAME
+	_ZN8QPainter19drawPixmapFragmentsEPKNS_14PixmapFragmentEiRK7QPixmap6QFlagsINS_18PixmapFragmentHintEE @ 11943 NONAME
+	_ZN8QToolBar17visibilityChangedEb @ 11944 NONAME
+	_ZN9QLineEdit18setPlaceholderTextERK7QString @ 11945 NONAME
+	_ZNK10QZipReader10extractAllERK7QString @ 11946 NONAME
+	_ZNK10QZipReader10isReadableEv @ 11947 NONAME
+	_ZNK10QZipReader11entryInfoAtEi @ 11948 NONAME
+	_ZNK10QZipReader12fileInfoListEv @ 11949 NONAME
+	_ZNK10QZipReader5countEv @ 11950 NONAME
+	_ZNK10QZipReader6deviceEv @ 11951 NONAME
+	_ZNK10QZipReader6existsEv @ 11952 NONAME
+	_ZNK10QZipReader6statusEv @ 11953 NONAME
+	_ZNK10QZipReader8FileInfo7isValidEv @ 11954 NONAME
+	_ZNK10QZipReader8fileDataERK7QString @ 11955 NONAME
+	_ZNK11QEglContext12configAttribEi @ 11956 NONAME
+	_ZNK11QStaticText10textFormatEv @ 11957 NONAME
+	_ZNK11QStaticText15performanceHintEv @ 11958 NONAME
+	_ZNK11QStaticText4sizeEv @ 11959 NONAME
+	_ZNK11QStaticText4textEv @ 11960 NONAME
+	_ZNK11QStaticText9textWidthEv @ 11961 NONAME
+	_ZNK11QStaticTexteqERKS_ @ 11962 NONAME
+	_ZNK11QStaticTextneERKS_ @ 11963 NONAME
+	_ZNK11QTextCursor15positionInBlockEv @ 11964 NONAME
+	_ZNK12QPaintBuffer13frameEndIndexEi @ 11965 NONAME
+	_ZNK12QPaintBuffer15frameStartIndexEi @ 11966 NONAME
+	_ZNK12QPaintBuffer15processCommandsEP8QPainterii @ 11967 NONAME
+	_ZNK12QPaintBuffer18commandDescriptionEi @ 11968 NONAME
+	_ZNK13QIntValidator5fixupER7QString @ 11969 NONAME
+	_ZNK14QPlainTextEdit8anchorAtERK6QPoint @ 11970 NONAME
+	_ZNK14QWindowSurface23hasPartialUpdateSupportEv @ 11971 NONAME
+	_ZNK15QGraphicsWidget18autoFillBackgroundEv @ 11972 NONAME
+	_ZNK19QItemSelectionRange7isEmptyEv @ 11973 NONAME
+	_ZNK20QGraphicsItemPrivate5widthEv @ 11974 NONAME
+	_ZNK20QGraphicsItemPrivate6heightEv @ 11975 NONAME
+	_ZNK20QGraphicsViewPrivate10mapToSceneERK6QRectF @ 11976 NONAME
+	_ZNK20QGraphicsViewPrivate10mapToSceneERK7QPointF @ 11977 NONAME
+	_ZNK20QGraphicsViewPrivate13mapToViewRectEPK13QGraphicsItemRK6QRectF @ 11978 NONAME
+	_ZNK20QGraphicsViewPrivate14mapRectToSceneERK5QRect @ 11979 NONAME
+	_ZNK20QGraphicsViewPrivate14verticalScrollEv @ 11980 NONAME
+	_ZNK20QGraphicsViewPrivate15mapToViewRegionEPK13QGraphicsItemRK6QRectF @ 11981 NONAME
+	_ZNK20QGraphicsViewPrivate16horizontalScrollEv @ 11982 NONAME
+	_ZNK20QGraphicsViewPrivate16mapRectFromSceneERK6QRectF @ 11983 NONAME
+	_ZNK20QGraphicsViewPrivate16rubberBandRegionEPK7QWidgetRK5QRect @ 11984 NONAME
+	_ZNK20QGraphicsViewPrivate9findItemsERK7QRegionPbRK10QTransform @ 11985 NONAME
+	_ZNK23QImageTextureGlyphCache11glyphMarginEv @ 11986 NONAME
+	_ZNK26QAbstractScrollAreaPrivate14contentsOffsetEv @ 11987 NONAME
+	_ZNK5QIcon4nameEv @ 11988 NONAME
+	_ZNK6QImage13bitPlaneCountEv @ 11989 NONAME
+	_ZNK6QImage13constScanLineEi @ 11990 NONAME
+	_ZNK6QImage9constBitsEv @ 11991 NONAME
+	_ZNK6QLabel12selectedTextEv @ 11992 NONAME
+	_ZNK6QLabel14selectionStartEv @ 11993 NONAME
+	_ZNK6QLabel15hasSelectedTextEv @ 11994 NONAME
+	_ZNK7QBezier11getSubRangeEff @ 11995 NONAME
+	_ZNK7QBezier12addToPolygonEP9QPolygonFf @ 11996 NONAME
+	_ZNK7QBezier5mapByERK10QTransform @ 11997 NONAME
+	_ZNK7QBezier9toPolygonEf @ 11998 NONAME
+	_ZNK7QWizard10sideWidgetEv @ 11999 NONAME
+	_ZNK9QLineEdit15placeholderTextEv @ 12000 NONAME
+	_ZNK9QTextLine17horizontalAdvanceEv @ 12001 NONAME
+	_ZTI20QGraphicsViewPrivate @ 12002 NONAME
+	_ZTI23QImageTextureGlyphCache @ 12003 NONAME
+	_ZTI26QAbstractScrollAreaPrivate @ 12004 NONAME
+	_ZTV20QGraphicsViewPrivate @ 12005 NONAME
+	_ZTV23QImageTextureGlyphCache @ 12006 NONAME
+	_ZTV26QAbstractScrollAreaPrivate @ 12007 NONAME
 
diff --git a/src/s60installs/eabi/QtNetworku.def b/src/s60installs/eabi/QtNetworku.def
index 87e0805..3cc3644 100644
--- a/src/s60installs/eabi/QtNetworku.def
+++ b/src/s60installs/eabi/QtNetworku.def
@@ -993,179 +993,175 @@ EXPORTS
 	_ZN10QSslSocket15setSocketOptionEN15QAbstractSocket12SocketOptionERK8QVariant @ 992 NONAME
 	_ZN15QNetworkRequest20setOriginatingObjectEP7QObject @ 993 NONAME
 	_ZNK15QNetworkRequest17originatingObjectEv @ 994 NONAME
-	_Z35qNetworkConfigurationManagerPrivatev @ 995 NONAME
-	_ZN13QBearerEngine11qt_metacallEN11QMetaObject4CallEiPPv @ 996 NONAME
-	_ZN13QBearerEngine11qt_metacastEPKc @ 997 NONAME
-	_ZN13QBearerEngine15updateCompletedEv @ 998 NONAME
-	_ZN13QBearerEngine16staticMetaObjectE @ 999 NONAME DATA 16
-	_ZN13QBearerEngine18configurationAddedE28QExplicitlySharedDataPointerI28QNetworkConfigurationPrivateE @ 1000 NONAME
-	_ZN13QBearerEngine19getStaticMetaObjectEv @ 1001 NONAME
-	_ZN13QBearerEngine20configurationChangedE28QExplicitlySharedDataPointerI28QNetworkConfigurationPrivateE @ 1002 NONAME
-	_ZN13QBearerEngine20configurationRemovedE28QExplicitlySharedDataPointerI28QNetworkConfigurationPrivateE @ 1003 NONAME
-	_ZN13QBearerEngineC2EP7QObject @ 1004 NONAME
-	_ZN13QBearerEngineD0Ev @ 1005 NONAME
-	_ZN13QBearerEngineD1Ev @ 1006 NONAME
-	_ZN13QBearerEngineD2Ev @ 1007 NONAME
-	_ZN15QNetworkRequest11setPriorityENS_8PriorityE @ 1008 NONAME
-	_ZN15QNetworkSession11qt_metacallEN11QMetaObject4CallEiPPv @ 1009 NONAME
-	_ZN15QNetworkSession11qt_metacastEPKc @ 1010 NONAME
-	_ZN15QNetworkSession12stateChangedENS_5StateE @ 1011 NONAME
-	_ZN15QNetworkSession13connectNotifyEPKc @ 1012 NONAME
-	_ZN15QNetworkSession13waitForOpenedEi @ 1013 NONAME
-	_ZN15QNetworkSession16disconnectNotifyEPKc @ 1014 NONAME
-	_ZN15QNetworkSession16staticMetaObjectE @ 1015 NONAME DATA 16
-	_ZN15QNetworkSession18setSessionPropertyERK7QStringRK8QVariant @ 1016 NONAME
-	_ZN15QNetworkSession19getStaticMetaObjectEv @ 1017 NONAME
-	_ZN15QNetworkSession25newConfigurationActivatedEv @ 1018 NONAME
-	_ZN15QNetworkSession29preferredConfigurationChangedERK21QNetworkConfigurationb @ 1019 NONAME
-	_ZN15QNetworkSession4openEv @ 1020 NONAME
-	_ZN15QNetworkSession4stopEv @ 1021 NONAME
-	_ZN15QNetworkSession5closeEv @ 1022 NONAME
-	_ZN15QNetworkSession5errorENS_12SessionErrorE @ 1023 NONAME
-	_ZN15QNetworkSession6acceptEv @ 1024 NONAME
-	_ZN15QNetworkSession6closedEv @ 1025 NONAME
-	_ZN15QNetworkSession6ignoreEv @ 1026 NONAME
-	_ZN15QNetworkSession6openedEv @ 1027 NONAME
-	_ZN15QNetworkSession6rejectEv @ 1028 NONAME
-	_ZN15QNetworkSession7migrateEv @ 1029 NONAME
-	_ZN15QNetworkSessionC1ERK21QNetworkConfigurationP7QObject @ 1030 NONAME
-	_ZN15QNetworkSessionC2ERK21QNetworkConfigurationP7QObject @ 1031 NONAME
-	_ZN15QNetworkSessionD0Ev @ 1032 NONAME
-	_ZN15QNetworkSessionD1Ev @ 1033 NONAME
-	_ZN15QNetworkSessionD2Ev @ 1034 NONAME
-	_ZN19QBearerEnginePlugin11qt_metacallEN11QMetaObject4CallEiPPv @ 1035 NONAME
-	_ZN19QBearerEnginePlugin11qt_metacastEPKc @ 1036 NONAME
-	_ZN19QBearerEnginePlugin16staticMetaObjectE @ 1037 NONAME DATA 16
-	_ZN19QBearerEnginePlugin19getStaticMetaObjectEv @ 1038 NONAME
-	_ZN19QBearerEnginePluginC2EP7QObject @ 1039 NONAME
-	_ZN19QBearerEnginePluginD0Ev @ 1040 NONAME
-	_ZN19QBearerEnginePluginD1Ev @ 1041 NONAME
-	_ZN19QBearerEnginePluginD2Ev @ 1042 NONAME
-	_ZN21QNetworkAccessManager16setConfigurationERK21QNetworkConfiguration @ 1043 NONAME
-	_ZN21QNetworkAccessManager17sendCustomRequestERK15QNetworkRequestRK10QByteArrayP9QIODevice @ 1044 NONAME
-	_ZN21QNetworkAccessManager20networkAccessChangedEb @ 1045 NONAME ABSENT
-	_ZN21QNetworkAccessManager20networkSessionOnlineEv @ 1046 NONAME ABSENT
-	_ZN21QNetworkAccessManager23setNetworkAccessEnabledEb @ 1047 NONAME ABSENT
-	_ZN21QNetworkConfigurationC1ERKS_ @ 1048 NONAME
-	_ZN21QNetworkConfigurationC1Ev @ 1049 NONAME
-	_ZN21QNetworkConfigurationC2ERKS_ @ 1050 NONAME
-	_ZN21QNetworkConfigurationC2Ev @ 1051 NONAME
-	_ZN21QNetworkConfigurationD1Ev @ 1052 NONAME
-	_ZN21QNetworkConfigurationD2Ev @ 1053 NONAME
-	_ZN21QNetworkConfigurationaSERKS_ @ 1054 NONAME
-	_ZN22QNetworkSessionPrivate11qt_metacallEN11QMetaObject4CallEiPPv @ 1055 NONAME
-	_ZN22QNetworkSessionPrivate11qt_metacastEPKc @ 1056 NONAME
-	_ZN22QNetworkSessionPrivate12stateChangedEN15QNetworkSession5StateE @ 1057 NONAME
-	_ZN22QNetworkSessionPrivate16staticMetaObjectE @ 1058 NONAME DATA 16
-	_ZN22QNetworkSessionPrivate19getStaticMetaObjectEv @ 1059 NONAME
-	_ZN22QNetworkSessionPrivate25newConfigurationActivatedEv @ 1060 NONAME
-	_ZN22QNetworkSessionPrivate25quitPendingWaitsForOpenedEv @ 1061 NONAME
-	_ZN22QNetworkSessionPrivate29preferredConfigurationChangedERK21QNetworkConfigurationb @ 1062 NONAME
-	_ZN22QNetworkSessionPrivate5errorEN15QNetworkSession12SessionErrorE @ 1063 NONAME
-	_ZN22QNetworkSessionPrivate6closedEv @ 1064 NONAME
-	_ZN28QNetworkConfigurationManager11qt_metacallEN11QMetaObject4CallEiPPv @ 1065 NONAME
-	_ZN28QNetworkConfigurationManager11qt_metacastEPKc @ 1066 NONAME
-	_ZN28QNetworkConfigurationManager15updateCompletedEv @ 1067 NONAME
-	_ZN28QNetworkConfigurationManager16staticMetaObjectE @ 1068 NONAME DATA 16
-	_ZN28QNetworkConfigurationManager18configurationAddedERK21QNetworkConfiguration @ 1069 NONAME
-	_ZN28QNetworkConfigurationManager18onlineStateChangedEb @ 1070 NONAME
-	_ZN28QNetworkConfigurationManager19getStaticMetaObjectEv @ 1071 NONAME
-	_ZN28QNetworkConfigurationManager20configurationChangedERK21QNetworkConfiguration @ 1072 NONAME
-	_ZN28QNetworkConfigurationManager20configurationRemovedERK21QNetworkConfiguration @ 1073 NONAME
-	_ZN28QNetworkConfigurationManager20updateConfigurationsEv @ 1074 NONAME
-	_ZN28QNetworkConfigurationManagerC1EP7QObject @ 1075 NONAME
-	_ZN28QNetworkConfigurationManagerC2EP7QObject @ 1076 NONAME
-	_ZN28QNetworkConfigurationManagerD0Ev @ 1077 NONAME
-	_ZN28QNetworkConfigurationManagerD1Ev @ 1078 NONAME
-	_ZN28QNetworkConfigurationManagerD2Ev @ 1079 NONAME
-	_ZN35QNetworkConfigurationManagerPrivate11qt_metacallEN11QMetaObject4CallEiPPv @ 1080 NONAME
-	_ZN35QNetworkConfigurationManagerPrivate11qt_metacastEPKc @ 1081 NONAME
-	_ZN35QNetworkConfigurationManagerPrivate16staticMetaObjectE @ 1082 NONAME DATA 16
-	_ZN35QNetworkConfigurationManagerPrivate18configurationAddedE28QExplicitlySharedDataPointerI28QNetworkConfigurationPrivateE @ 1083 NONAME
-	_ZN35QNetworkConfigurationManagerPrivate18configurationAddedERK21QNetworkConfiguration @ 1084 NONAME
-	_ZN35QNetworkConfigurationManagerPrivate18onlineStateChangedEb @ 1085 NONAME
-	_ZN35QNetworkConfigurationManagerPrivate19getStaticMetaObjectEv @ 1086 NONAME
-	_ZN35QNetworkConfigurationManagerPrivate20configurationChangedE28QExplicitlySharedDataPointerI28QNetworkConfigurationPrivateE @ 1087 NONAME
-	_ZN35QNetworkConfigurationManagerPrivate20configurationChangedERK21QNetworkConfiguration @ 1088 NONAME
-	_ZN35QNetworkConfigurationManagerPrivate20configurationRemovedE28QExplicitlySharedDataPointerI28QNetworkConfigurationPrivateE @ 1089 NONAME
-	_ZN35QNetworkConfigurationManagerPrivate20configurationRemovedERK21QNetworkConfiguration @ 1090 NONAME
-	_ZN35QNetworkConfigurationManagerPrivate20updateConfigurationsEv @ 1091 NONAME
-	_ZN35QNetworkConfigurationManagerPrivate27configurationUpdateCompleteEv @ 1092 NONAME
-	_ZN35QNetworkConfigurationManagerPrivate31performAsyncConfigurationUpdateEv @ 1093 NONAME
-	_ZN35QNetworkConfigurationManagerPrivate5abortEv @ 1094 NONAME
-	_ZN35QNetworkConfigurationManagerPrivate7enginesEv @ 1095 NONAME
-	_ZN35QNetworkConfigurationManagerPrivateC1Ev @ 1096 NONAME
-	_ZN35QNetworkConfigurationManagerPrivateC2Ev @ 1097 NONAME
-	_ZN35QNetworkConfigurationManagerPrivateD0Ev @ 1098 NONAME
-	_ZN35QNetworkConfigurationManagerPrivateD1Ev @ 1099 NONAME
-	_ZN35QNetworkConfigurationManagerPrivateD2Ev @ 1100 NONAME
-	_ZNK13QBearerEngine10metaObjectEv @ 1101 NONAME
-	_ZNK13QNetworkReply14rawHeaderPairsEv @ 1102 NONAME
-	_ZNK15QNetworkRequest8priorityEv @ 1103 NONAME
-	_ZNK15QNetworkSession10activeTimeEv @ 1104 NONAME
-	_ZNK15QNetworkSession10metaObjectEv @ 1105 NONAME
-	_ZNK15QNetworkSession11errorStringEv @ 1106 NONAME
-	_ZNK15QNetworkSession12bytesWrittenEv @ 1107 NONAME
-	_ZNK15QNetworkSession13bytesReceivedEv @ 1108 NONAME
-	_ZNK15QNetworkSession13configurationEv @ 1109 NONAME
-	_ZNK15QNetworkSession15sessionPropertyERK7QString @ 1110 NONAME
-	_ZNK15QNetworkSession5errorEv @ 1111 NONAME
-	_ZNK15QNetworkSession5stateEv @ 1112 NONAME
-	_ZNK15QNetworkSession6isOpenEv @ 1113 NONAME
-	_ZNK15QNetworkSession9interfaceEv @ 1114 NONAME
-	_ZNK19QBearerEnginePlugin10metaObjectEv @ 1115 NONAME
-	_ZNK21QNetworkAccessManager13configurationEv @ 1116 NONAME
-	_ZNK21QNetworkAccessManager19activeConfigurationEv @ 1117 NONAME
-	_ZNK21QNetworkAccessManager20networkAccessEnabledEv @ 1118 NONAME ABSENT
-	_ZNK21QNetworkConfiguration10bearerNameEv @ 1119 NONAME
-	_ZNK21QNetworkConfiguration10identifierEv @ 1120 NONAME
-	_ZNK21QNetworkConfiguration18isRoamingAvailableEv @ 1121 NONAME
-	_ZNK21QNetworkConfiguration4nameEv @ 1122 NONAME
-	_ZNK21QNetworkConfiguration4typeEv @ 1123 NONAME
-	_ZNK21QNetworkConfiguration5stateEv @ 1124 NONAME
-	_ZNK21QNetworkConfiguration7isValidEv @ 1125 NONAME
-	_ZNK21QNetworkConfiguration7purposeEv @ 1126 NONAME
-	_ZNK21QNetworkConfiguration8childrenEv @ 1127 NONAME
-	_ZNK21QNetworkConfigurationeqERKS_ @ 1128 NONAME
-	_ZNK22QNetworkSessionPrivate10metaObjectEv @ 1129 NONAME
-	_ZNK28QNetworkConfigurationManager10metaObjectEv @ 1130 NONAME
-	_ZNK28QNetworkConfigurationManager12capabilitiesEv @ 1131 NONAME
-	_ZNK28QNetworkConfigurationManager17allConfigurationsE6QFlagsIN21QNetworkConfiguration9StateFlagEE @ 1132 NONAME
-	_ZNK28QNetworkConfigurationManager20defaultConfigurationEv @ 1133 NONAME
-	_ZNK28QNetworkConfigurationManager27configurationFromIdentifierERK7QString @ 1134 NONAME
-	_ZNK28QNetworkConfigurationManager8isOnlineEv @ 1135 NONAME
-	_ZNK35QNetworkConfigurationManagerPrivate10metaObjectEv @ 1136 NONAME
-	_ZTI13QBearerEngine @ 1137 NONAME
-	_ZTI15QNetworkSession @ 1138 NONAME
-	_ZTI19QBearerEnginePlugin @ 1139 NONAME
-	_ZTI22QNetworkSessionPrivate @ 1140 NONAME
-	_ZTI28QNetworkConfigurationManager @ 1141 NONAME
-	_ZTI29QBearerEngineFactoryInterface @ 1142 NONAME
-	_ZTI35QNetworkConfigurationManagerPrivate @ 1143 NONAME
-	_ZTV13QBearerEngine @ 1144 NONAME
-	_ZTV15QNetworkSession @ 1145 NONAME
-	_ZTV19QBearerEnginePlugin @ 1146 NONAME
-	_ZTV22QNetworkSessionPrivate @ 1147 NONAME
-	_ZTV28QNetworkConfigurationManager @ 1148 NONAME
-	_ZTV35QNetworkConfigurationManagerPrivate @ 1149 NONAME
-	_ZThn8_N19QBearerEnginePluginD0Ev @ 1150 NONAME
-	_ZThn8_N19QBearerEnginePluginD1Ev @ 1151 NONAME
-	_Z19qt_qhostinfo_lookupRK7QStringP7QObjectPKcPbPi @ 1152 NONAME
-	_Z24qt_qhostinfo_clear_cachev @ 1153 NONAME ABSENT
-	_ZN21QNetworkAccessManager20setNetworkAccessibleENS_20NetworkAccessibilityE @ 1154 NONAME
-	_ZN21QNetworkAccessManager23networkSessionConnectedEv @ 1155 NONAME
-	_ZN21QNetworkAccessManager24networkAccessibleChangedENS_20NetworkAccessibilityE @ 1156 NONAME
-	_ZN35QNetworkConfigurationManagerPrivate11pollEnginesEv @ 1157 NONAME
-	_ZN35QNetworkConfigurationManagerPrivate12startPollingEv @ 1158 NONAME
-	_ZN35QNetworkConfigurationManagerPrivate13enablePollingEv @ 1159 NONAME
-	_ZN35QNetworkConfigurationManagerPrivate14disablePollingEv @ 1160 NONAME
-	_ZN35QNetworkConfigurationManagerPrivate17allConfigurationsE6QFlagsIN21QNetworkConfiguration9StateFlagEE @ 1161 NONAME
-	_ZN35QNetworkConfigurationManagerPrivate20defaultConfigurationEv @ 1162 NONAME
-	_ZN35QNetworkConfigurationManagerPrivate27configurationFromIdentifierERK7QString @ 1163 NONAME
-	_ZN35QNetworkConfigurationManagerPrivate8isOnlineEv @ 1164 NONAME
-	_ZNK13QBearerEngine15requiresPollingEv @ 1165 NONAME
-	_ZNK13QBearerEngine19configurationsInUseEv @ 1166 NONAME
-	_ZNK21QNetworkAccessManager17networkAccessibleEv @ 1167 NONAME
-	_ZN35QNetworkConfigurationManagerPrivate12capabilitiesEv @ 1168 NONAME
-	_ZN10QTcpServer20addPendingConnectionEP10QTcpSocket @ 1169 NONAME
+	_Z19qt_qhostinfo_lookupRK7QStringP7QObjectPKcPbPi @ 995 NONAME
+	_Z24qt_qhostinfo_clear_cachev @ 996 NONAME ABSENT
+	_Z35qNetworkConfigurationManagerPrivatev @ 997 NONAME
+	_ZN10QTcpServer20addPendingConnectionEP10QTcpSocket @ 998 NONAME
+	_ZN13QBearerEngine11qt_metacallEN11QMetaObject4CallEiPPv @ 999 NONAME
+	_ZN13QBearerEngine11qt_metacastEPKc @ 1000 NONAME
+	_ZN13QBearerEngine15updateCompletedEv @ 1001 NONAME
+	_ZN13QBearerEngine16staticMetaObjectE @ 1002 NONAME DATA 16
+	_ZN13QBearerEngine18configurationAddedE28QExplicitlySharedDataPointerI28QNetworkConfigurationPrivateE @ 1003 NONAME
+	_ZN13QBearerEngine19getStaticMetaObjectEv @ 1004 NONAME
+	_ZN13QBearerEngine20configurationChangedE28QExplicitlySharedDataPointerI28QNetworkConfigurationPrivateE @ 1005 NONAME
+	_ZN13QBearerEngine20configurationRemovedE28QExplicitlySharedDataPointerI28QNetworkConfigurationPrivateE @ 1006 NONAME
+	_ZN13QBearerEngineC2EP7QObject @ 1007 NONAME
+	_ZN13QBearerEngineD0Ev @ 1008 NONAME
+	_ZN13QBearerEngineD1Ev @ 1009 NONAME
+	_ZN13QBearerEngineD2Ev @ 1010 NONAME
+	_ZN15QNetworkRequest11setPriorityENS_8PriorityE @ 1011 NONAME
+	_ZN15QNetworkSession11qt_metacallEN11QMetaObject4CallEiPPv @ 1012 NONAME
+	_ZN15QNetworkSession11qt_metacastEPKc @ 1013 NONAME
+	_ZN15QNetworkSession12stateChangedENS_5StateE @ 1014 NONAME
+	_ZN15QNetworkSession13connectNotifyEPKc @ 1015 NONAME
+	_ZN15QNetworkSession13waitForOpenedEi @ 1016 NONAME
+	_ZN15QNetworkSession16disconnectNotifyEPKc @ 1017 NONAME
+	_ZN15QNetworkSession16staticMetaObjectE @ 1018 NONAME DATA 16
+	_ZN15QNetworkSession18setSessionPropertyERK7QStringRK8QVariant @ 1019 NONAME
+	_ZN15QNetworkSession19getStaticMetaObjectEv @ 1020 NONAME
+	_ZN15QNetworkSession25newConfigurationActivatedEv @ 1021 NONAME
+	_ZN15QNetworkSession29preferredConfigurationChangedERK21QNetworkConfigurationb @ 1022 NONAME
+	_ZN15QNetworkSession4openEv @ 1023 NONAME
+	_ZN15QNetworkSession4stopEv @ 1024 NONAME
+	_ZN15QNetworkSession5closeEv @ 1025 NONAME
+	_ZN15QNetworkSession5errorENS_12SessionErrorE @ 1026 NONAME
+	_ZN15QNetworkSession6acceptEv @ 1027 NONAME
+	_ZN15QNetworkSession6closedEv @ 1028 NONAME
+	_ZN15QNetworkSession6ignoreEv @ 1029 NONAME
+	_ZN15QNetworkSession6openedEv @ 1030 NONAME
+	_ZN15QNetworkSession6rejectEv @ 1031 NONAME
+	_ZN15QNetworkSession7migrateEv @ 1032 NONAME
+	_ZN15QNetworkSessionC1ERK21QNetworkConfigurationP7QObject @ 1033 NONAME
+	_ZN15QNetworkSessionC2ERK21QNetworkConfigurationP7QObject @ 1034 NONAME
+	_ZN15QNetworkSessionD0Ev @ 1035 NONAME
+	_ZN15QNetworkSessionD1Ev @ 1036 NONAME
+	_ZN15QNetworkSessionD2Ev @ 1037 NONAME
+	_ZN19QBearerEnginePlugin11qt_metacallEN11QMetaObject4CallEiPPv @ 1038 NONAME
+	_ZN19QBearerEnginePlugin11qt_metacastEPKc @ 1039 NONAME
+	_ZN19QBearerEnginePlugin16staticMetaObjectE @ 1040 NONAME DATA 16
+	_ZN19QBearerEnginePlugin19getStaticMetaObjectEv @ 1041 NONAME
+	_ZN19QBearerEnginePluginC2EP7QObject @ 1042 NONAME
+	_ZN19QBearerEnginePluginD0Ev @ 1043 NONAME
+	_ZN19QBearerEnginePluginD1Ev @ 1044 NONAME
+	_ZN19QBearerEnginePluginD2Ev @ 1045 NONAME
+	_ZN21QNetworkAccessManager16setConfigurationERK21QNetworkConfiguration @ 1046 NONAME
+	_ZN21QNetworkAccessManager17sendCustomRequestERK15QNetworkRequestRK10QByteArrayP9QIODevice @ 1047 NONAME
+	_ZN21QNetworkAccessManager20setNetworkAccessibleENS_20NetworkAccessibilityE @ 1048 NONAME
+	_ZN21QNetworkAccessManager23networkSessionConnectedEv @ 1049 NONAME
+	_ZN21QNetworkAccessManager24networkAccessibleChangedENS_20NetworkAccessibilityE @ 1050 NONAME
+	_ZN21QNetworkConfigurationC1ERKS_ @ 1051 NONAME
+	_ZN21QNetworkConfigurationC1Ev @ 1052 NONAME
+	_ZN21QNetworkConfigurationC2ERKS_ @ 1053 NONAME
+	_ZN21QNetworkConfigurationC2Ev @ 1054 NONAME
+	_ZN21QNetworkConfigurationD1Ev @ 1055 NONAME
+	_ZN21QNetworkConfigurationD2Ev @ 1056 NONAME
+	_ZN21QNetworkConfigurationaSERKS_ @ 1057 NONAME
+	_ZN22QNetworkSessionPrivate11qt_metacallEN11QMetaObject4CallEiPPv @ 1058 NONAME
+	_ZN22QNetworkSessionPrivate11qt_metacastEPKc @ 1059 NONAME
+	_ZN22QNetworkSessionPrivate12stateChangedEN15QNetworkSession5StateE @ 1060 NONAME
+	_ZN22QNetworkSessionPrivate16staticMetaObjectE @ 1061 NONAME DATA 16
+	_ZN22QNetworkSessionPrivate19getStaticMetaObjectEv @ 1062 NONAME
+	_ZN22QNetworkSessionPrivate25newConfigurationActivatedEv @ 1063 NONAME
+	_ZN22QNetworkSessionPrivate25quitPendingWaitsForOpenedEv @ 1064 NONAME
+	_ZN22QNetworkSessionPrivate29preferredConfigurationChangedERK21QNetworkConfigurationb @ 1065 NONAME
+	_ZN22QNetworkSessionPrivate5errorEN15QNetworkSession12SessionErrorE @ 1066 NONAME
+	_ZN22QNetworkSessionPrivate6closedEv @ 1067 NONAME
+	_ZN28QNetworkConfigurationManager11qt_metacallEN11QMetaObject4CallEiPPv @ 1068 NONAME
+	_ZN28QNetworkConfigurationManager11qt_metacastEPKc @ 1069 NONAME
+	_ZN28QNetworkConfigurationManager15updateCompletedEv @ 1070 NONAME
+	_ZN28QNetworkConfigurationManager16staticMetaObjectE @ 1071 NONAME DATA 16
+	_ZN28QNetworkConfigurationManager18configurationAddedERK21QNetworkConfiguration @ 1072 NONAME
+	_ZN28QNetworkConfigurationManager18onlineStateChangedEb @ 1073 NONAME
+	_ZN28QNetworkConfigurationManager19getStaticMetaObjectEv @ 1074 NONAME
+	_ZN28QNetworkConfigurationManager20configurationChangedERK21QNetworkConfiguration @ 1075 NONAME
+	_ZN28QNetworkConfigurationManager20configurationRemovedERK21QNetworkConfiguration @ 1076 NONAME
+	_ZN28QNetworkConfigurationManager20updateConfigurationsEv @ 1077 NONAME
+	_ZN28QNetworkConfigurationManagerC1EP7QObject @ 1078 NONAME
+	_ZN28QNetworkConfigurationManagerC2EP7QObject @ 1079 NONAME
+	_ZN28QNetworkConfigurationManagerD0Ev @ 1080 NONAME
+	_ZN28QNetworkConfigurationManagerD1Ev @ 1081 NONAME
+	_ZN28QNetworkConfigurationManagerD2Ev @ 1082 NONAME
+	_ZN35QNetworkConfigurationManagerPrivate11pollEnginesEv @ 1083 NONAME
+	_ZN35QNetworkConfigurationManagerPrivate11qt_metacallEN11QMetaObject4CallEiPPv @ 1084 NONAME
+	_ZN35QNetworkConfigurationManagerPrivate11qt_metacastEPKc @ 1085 NONAME
+	_ZN35QNetworkConfigurationManagerPrivate12capabilitiesEv @ 1086 NONAME
+	_ZN35QNetworkConfigurationManagerPrivate12startPollingEv @ 1087 NONAME
+	_ZN35QNetworkConfigurationManagerPrivate13enablePollingEv @ 1088 NONAME
+	_ZN35QNetworkConfigurationManagerPrivate14disablePollingEv @ 1089 NONAME
+	_ZN35QNetworkConfigurationManagerPrivate16staticMetaObjectE @ 1090 NONAME DATA 16
+	_ZN35QNetworkConfigurationManagerPrivate17allConfigurationsE6QFlagsIN21QNetworkConfiguration9StateFlagEE @ 1091 NONAME
+	_ZN35QNetworkConfigurationManagerPrivate18configurationAddedE28QExplicitlySharedDataPointerI28QNetworkConfigurationPrivateE @ 1092 NONAME
+	_ZN35QNetworkConfigurationManagerPrivate18configurationAddedERK21QNetworkConfiguration @ 1093 NONAME
+	_ZN35QNetworkConfigurationManagerPrivate18onlineStateChangedEb @ 1094 NONAME
+	_ZN35QNetworkConfigurationManagerPrivate19getStaticMetaObjectEv @ 1095 NONAME
+	_ZN35QNetworkConfigurationManagerPrivate20configurationChangedE28QExplicitlySharedDataPointerI28QNetworkConfigurationPrivateE @ 1096 NONAME
+	_ZN35QNetworkConfigurationManagerPrivate20configurationChangedERK21QNetworkConfiguration @ 1097 NONAME
+	_ZN35QNetworkConfigurationManagerPrivate20configurationRemovedE28QExplicitlySharedDataPointerI28QNetworkConfigurationPrivateE @ 1098 NONAME
+	_ZN35QNetworkConfigurationManagerPrivate20configurationRemovedERK21QNetworkConfiguration @ 1099 NONAME
+	_ZN35QNetworkConfigurationManagerPrivate20defaultConfigurationEv @ 1100 NONAME
+	_ZN35QNetworkConfigurationManagerPrivate20updateConfigurationsEv @ 1101 NONAME
+	_ZN35QNetworkConfigurationManagerPrivate27configurationFromIdentifierERK7QString @ 1102 NONAME
+	_ZN35QNetworkConfigurationManagerPrivate27configurationUpdateCompleteEv @ 1103 NONAME
+	_ZN35QNetworkConfigurationManagerPrivate31performAsyncConfigurationUpdateEv @ 1104 NONAME
+	_ZN35QNetworkConfigurationManagerPrivate5abortEv @ 1105 NONAME
+	_ZN35QNetworkConfigurationManagerPrivate7enginesEv @ 1106 NONAME
+	_ZN35QNetworkConfigurationManagerPrivate8isOnlineEv @ 1107 NONAME
+	_ZN35QNetworkConfigurationManagerPrivateC1Ev @ 1108 NONAME
+	_ZN35QNetworkConfigurationManagerPrivateC2Ev @ 1109 NONAME
+	_ZN35QNetworkConfigurationManagerPrivateD0Ev @ 1110 NONAME
+	_ZN35QNetworkConfigurationManagerPrivateD1Ev @ 1111 NONAME
+	_ZN35QNetworkConfigurationManagerPrivateD2Ev @ 1112 NONAME
+	_ZNK13QBearerEngine10metaObjectEv @ 1113 NONAME
+	_ZNK13QBearerEngine15requiresPollingEv @ 1114 NONAME
+	_ZNK13QBearerEngine19configurationsInUseEv @ 1115 NONAME
+	_ZNK13QNetworkReply14rawHeaderPairsEv @ 1116 NONAME
+	_ZNK15QNetworkRequest8priorityEv @ 1117 NONAME
+	_ZNK15QNetworkSession10activeTimeEv @ 1118 NONAME
+	_ZNK15QNetworkSession10metaObjectEv @ 1119 NONAME
+	_ZNK15QNetworkSession11errorStringEv @ 1120 NONAME
+	_ZNK15QNetworkSession12bytesWrittenEv @ 1121 NONAME
+	_ZNK15QNetworkSession13bytesReceivedEv @ 1122 NONAME
+	_ZNK15QNetworkSession13configurationEv @ 1123 NONAME
+	_ZNK15QNetworkSession15sessionPropertyERK7QString @ 1124 NONAME
+	_ZNK15QNetworkSession5errorEv @ 1125 NONAME
+	_ZNK15QNetworkSession5stateEv @ 1126 NONAME
+	_ZNK15QNetworkSession6isOpenEv @ 1127 NONAME
+	_ZNK15QNetworkSession9interfaceEv @ 1128 NONAME
+	_ZNK19QBearerEnginePlugin10metaObjectEv @ 1129 NONAME
+	_ZNK21QNetworkAccessManager13configurationEv @ 1130 NONAME
+	_ZNK21QNetworkAccessManager17networkAccessibleEv @ 1131 NONAME
+	_ZNK21QNetworkAccessManager19activeConfigurationEv @ 1132 NONAME
+	_ZNK21QNetworkConfiguration10bearerNameEv @ 1133 NONAME
+	_ZNK21QNetworkConfiguration10identifierEv @ 1134 NONAME
+	_ZNK21QNetworkConfiguration18isRoamingAvailableEv @ 1135 NONAME
+	_ZNK21QNetworkConfiguration4nameEv @ 1136 NONAME
+	_ZNK21QNetworkConfiguration4typeEv @ 1137 NONAME
+	_ZNK21QNetworkConfiguration5stateEv @ 1138 NONAME
+	_ZNK21QNetworkConfiguration7isValidEv @ 1139 NONAME
+	_ZNK21QNetworkConfiguration7purposeEv @ 1140 NONAME
+	_ZNK21QNetworkConfiguration8childrenEv @ 1141 NONAME
+	_ZNK21QNetworkConfigurationeqERKS_ @ 1142 NONAME
+	_ZNK22QNetworkSessionPrivate10metaObjectEv @ 1143 NONAME
+	_ZNK28QNetworkConfigurationManager10metaObjectEv @ 1144 NONAME
+	_ZNK28QNetworkConfigurationManager12capabilitiesEv @ 1145 NONAME
+	_ZNK28QNetworkConfigurationManager17allConfigurationsE6QFlagsIN21QNetworkConfiguration9StateFlagEE @ 1146 NONAME
+	_ZNK28QNetworkConfigurationManager20defaultConfigurationEv @ 1147 NONAME
+	_ZNK28QNetworkConfigurationManager27configurationFromIdentifierERK7QString @ 1148 NONAME
+	_ZNK28QNetworkConfigurationManager8isOnlineEv @ 1149 NONAME
+	_ZNK35QNetworkConfigurationManagerPrivate10metaObjectEv @ 1150 NONAME
+	_ZTI13QBearerEngine @ 1151 NONAME
+	_ZTI15QNetworkSession @ 1152 NONAME
+	_ZTI19QBearerEnginePlugin @ 1153 NONAME
+	_ZTI22QNetworkSessionPrivate @ 1154 NONAME
+	_ZTI28QNetworkConfigurationManager @ 1155 NONAME
+	_ZTI29QBearerEngineFactoryInterface @ 1156 NONAME
+	_ZTI35QNetworkConfigurationManagerPrivate @ 1157 NONAME
+	_ZTV13QBearerEngine @ 1158 NONAME
+	_ZTV15QNetworkSession @ 1159 NONAME
+	_ZTV19QBearerEnginePlugin @ 1160 NONAME
+	_ZTV22QNetworkSessionPrivate @ 1161 NONAME
+	_ZTV28QNetworkConfigurationManager @ 1162 NONAME
+	_ZTV35QNetworkConfigurationManagerPrivate @ 1163 NONAME
+	_ZThn8_N19QBearerEnginePluginD0Ev @ 1164 NONAME
+	_ZThn8_N19QBearerEnginePluginD1Ev @ 1165 NONAME
 
diff --git a/src/s60installs/eabi/QtOpenVGu.def b/src/s60installs/eabi/QtOpenVGu.def
index 04f7876..15fda9a 100644
--- a/src/s60installs/eabi/QtOpenVGu.def
+++ b/src/s60installs/eabi/QtOpenVGu.def
@@ -196,9 +196,9 @@ EXPORTS
 	_ZN13QVGPixmapData19detachImageFromPoolEv @ 195 NONAME
 	_ZTI12QVGImagePool @ 196 NONAME
 	_ZTV12QVGImagePool @ 197 NONAME
-	_ZN14QVGPaintEngine16drawCachedGlyphsEiPKjRK5QFontP11QFontEngineRK7QPointF @ 198 NONAME ABSENT
-	_ZN14QVGPaintEngine18drawStaticTextItemEP15QStaticTextItem @ 199 NONAME
-	_ZN14QVGPaintEngine19drawPixmapFragmentsEPKN8QPainter14PixmapFragmentEiRK7QPixmap6QFlagsINS0_18PixmapFragmentHintEE @ 200 NONAME
-	_ZN25QVGEGLWindowSurfaceDirect6scrollEP7QWidgetRK7QRegionii @ 201 NONAME
-	_ZNK25QVGEGLWindowSurfaceDirect22supportsStaticContentsEv @ 202 NONAME
+	_ZN25QVGEGLWindowSurfaceDirect6scrollEP7QWidgetRK7QRegionii @ 198 NONAME
+	_ZNK25QVGEGLWindowSurfaceDirect22supportsStaticContentsEv @ 199 NONAME
+	_ZN14QVGPaintEngine16drawCachedGlyphsEiPKjRK5QFontP11QFontEngineRK7QPointFPK11QFixedPoint @ 200 NONAME
+	_ZN14QVGPaintEngine18drawStaticTextItemEP15QStaticTextItem @ 201 NONAME
+	_ZN14QVGPaintEngine19drawPixmapFragmentsEPKN8QPainter14PixmapFragmentEiRK7QPixmap6QFlagsINS0_18PixmapFragmentHintEE @ 202 NONAME
 
diff --git a/src/s60installs/qt.iby b/src/s60installs/qt.iby
index ec019e2..f43f344 100644
--- a/src/s60installs/qt.iby
+++ b/src/s60installs/qt.iby
@@ -74,6 +74,21 @@ data=\epoc32\data\z\resource\qt\plugins\codecs\qtwcodecs.qtplugin          resou
 // iconengines stubs
 data=\epoc32\data\z\resource\qt\plugins\iconengines\qsvgicon.qtplugin      resource\qt\plugins\iconengines\qsvgicon.qtplugin
 
+// qml import plugins
+file=ABI_DIR\BUILD_DIR\qmlwebkitplugin.dll      SHARED_LIB_DIR\qmlwebkitplugin.dll
+file=ABI_DIR\BUILD_DIR\qmlfolderlistmodelplugin.dll      SHARED_LIB_DIR\qmlfolderlistmodelplugin.dll
+file=ABI_DIR\BUILD_DIR\qmlgesturesplugin.dll      SHARED_LIB_DIR\qmlgesturesplugin.dll
+file=ABI_DIR\BUILD_DIR\qmlparticlesplugin.dll      SHARED_LIB_DIR\qmlparticlesplugin.dll
+
+data=\epoc32\data\z\resource\qt\imports\org\webkit\qmlwebkitplugin.qtplugin    resource\qt\imports\org\webkit\qmlwebkitplugin.qtplugin
+data=\epoc32\data\z\resource\qt\imports\Qt\labs\folderlistmodel\qmlfolderlistmodelplugin.qtplugin    resource\qt\imports\Qt\labs\folderlistmodel\qmlfolderlistmodelplugin.qtplugin
+data=\epoc32\data\z\resource\qt\imports\Qt\labs\gestures\qmlgesturesplugin.qtplugin    resource\qt\imports\Qt\labs\gestures\qmlgesturesplugin.qtplugin
+data=\epoc32\data\z\resource\qt\imports\Qt\labs\particles\qmlparticlesplugin.qtplugin    resource\qt\imports\Qt\labs\particles\qmlparticlesplugin.qtplugin
+
+data=\epoc32\data\z\resource\qt\imports\org\webkit\qmldir    resource\qt\imports\org\webkit\qmldir
+data=\epoc32\data\z\resource\qt\imports\Qt\labs\folderlistmodel\qmldir    resource\qt\imports\Qt\labs\folderlistmodel\qmldir
+data=\epoc32\data\z\resource\qt\imports\Qt\labs\gestures\qmldir    resource\qt\imports\Qt\labs\gestures\qmldir
+data=\epoc32\data\z\resource\qt\imports\Qt\labs\particles\qmldir    resource\qt\imports\Qt\labs\particles\qmldir
 
 // QtMultimedia audio backend
 data=\epoc32\data\qt\qtlibspluginstubs\qaudio.qtplugin resource\qt\plugins\audio\qaudio.qtplugin
diff --git a/src/s60installs/qt.svg b/src/s60installs/qt.svg
index 6230ada..566acfa 100644
--- a/src/s60installs/qt.svg
+++ b/src/s60installs/qt.svg
@@ -1,17 +1,93 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1 Tiny//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11-tiny.dtd">
-<svg xmlns="http://www.w3.org/2000/svg" baseProfile="tiny" height="146.3063" version="1.0" viewBox="0 0 122 146" width="121.60006">
-<g transform="translate(-376.34283,-407.78046)">
-<g transform="matrix(0.697424,0,0,0.697424,376.34283,407.78046)">
-<path d="M 43.086,0.358597 C 40.9414,0.00358582 38.8399,-0.0824127 36.8086,0.0775909 L 36.8047,0.0735931 C 36.8047,0.0735931 22.9219,1.01859 22.2891,1.0696 C 9.6211,2.08159 0,12.5036 0,26.8896 L 0,196.554 L 14.1914,209.781 L 156.789,185.816 C 166.606,184.113 174.356,172.538 174.356,160.038 L 174.356,21.8786 L 43.086,0.358597 z" style="fill:#006225;fill-rule:evenodd;stroke:none"/>
-<path d="M 174.356,160.042 C 174.356,172.538 166.606,184.113 156.789,185.816 L 14.1914,209.781 L 14.1914,25.9916 C 14.1914,9.2726 27.5313,-2.20741 43.086,0.358597 L 174.356,21.8786 L 174.356,160.042 z" style="fill:#80c342;fill-rule:evenodd;stroke:none"/>
-<path d="M 130.422,45.9136 L 141.938,47.1516 L 141.938,67.3626 L 154.899,68.2766 L 154.899,80.9566 L 141.938,80.3586 L 141.938,126.691 C 141.938,130.723 142.383,133.316 143.278,134.48 C 144.078,135.547 145.324,136.074 146.988,136.074 C 147.149,136.074 147.317,136.07 147.485,136.058 C 150.035,135.91 152.805,135.125 155.828,133.75 L 155.828,145.398 C 150.692,147.656 145.653,148.996 140.703,149.418 C 139.985,149.473 139.293,149.504 138.625,149.504 C 134.145,149.504 130.719,148.203 128.379,145.57 C 125.649,142.519 124.289,137.621 124.289,130.898 L 124.289,79.5426 L 118.063,79.2576 L 118.063,65.6716 L 125.649,66.2186 L 130.422,45.9136 z" style="fill:#ffffff;fill-rule:evenodd;stroke:none"/>
-<path d="M 154.899,80.9566 L 141.938,80.3586 L 141.938,80.6366 L 148.883,80.9566 L 154.899,80.9566 z" style="fill:#006225;fill-rule:evenodd;stroke:none"/>
-<path d="M 144.637,135.598 C 145.297,135.926 146.067,136.074 146.988,136.074 C 147.149,136.074 147.317,136.07 147.485,136.058 C 150.035,135.91 152.805,135.125 155.828,133.75 L 149.813,133.75 C 147.992,134.582 146.281,135.207 144.637,135.598 z" style="fill:#006225;fill-rule:evenodd;stroke:none"/>
-<path d="M 128.379,145.57 C 125.649,142.519 124.289,137.621 124.289,130.898 L 124.289,79.5426 L 118.063,79.2576 L 118.063,65.6716 L 112.047,65.6716 L 112.047,68.7066 C 112.918,71.9796 113.602,75.5266 114.11,79.3506 L 118.274,79.5426 L 118.274,130.898 C 118.274,137.621 119.641,142.519 122.364,145.57 C 124.707,148.203 128.129,149.504 132.61,149.504 L 138.625,149.504 C 134.145,149.504 130.719,148.203 128.379,145.57 z M 130.422,45.9136 L 124.406,45.9136 L 119.738,65.7966 L 125.649,66.2186 L 130.422,45.9136 z" style="fill:#006225;fill-rule:evenodd;stroke:none"/>
-<path d="M 91.1528,132.406 C 93.5038,126.355 94.6638,114.492 94.6638,96.7886 C 94.6638,80.8976 93.5158,69.9726 91.1798,63.9756 C 88.8438,57.9486 85.3478,54.6946 80.6598,54.2846 C 80.3008,54.2536 79.9458,54.2336 79.6018,54.2336 C 75.2618,54.2336 71.9218,56.7686 69.5938,61.8586 C 67.0738,67.4016 65.8008,78.8976 65.8008,96.2966 C 65.8008,113.113 67.0388,125.047 69.5348,132.051 C 71.8908,138.723 75.4138,142.027 80.0388,142.027 C 80.2458,142.027 80.4488,142.019 80.6598,142.008 C 85.2928,141.715 88.7808,138.512 91.1528,132.406 M 109.129,136.156 C 105.012,145.863 98.7348,152.214 90.1408,155.156 C 91.0078,159.605 92.3168,162.597 94.0628,164.175 C 95.4138,165.386 97.4958,165.996 100.285,165.996 C 101.09,165.996 101.953,165.941 102.875,165.839 L 102.875,178.964 L 96.9138,179.746 C 95.1558,179.976 93.4878,180.089 91.9098,180.089 C 86.6918,180.089 82.4648,178.824 79.2888,176.265 C 75.0818,172.886 71.9808,166.371 69.9918,156.73 C 60.8555,154.785 53.7344,148.976 48.8008,139.226 C 43.7969,129.324 41.25,114.836 41.25,95.8866 C 41.25,75.4566 44.7344,60.3786 51.5938,50.8156 C 57.3828,42.7456 65.4568,38.7766 75.6168,38.7766 C 77.2458,38.7766 78.9258,38.8786 80.6598,39.0816 C 92.6138,40.4566 101.278,46.0976 106.918,55.8706 C 112.453,65.4326 115.172,79.1366 115.172,97.1326 C 115.172,113.617 113.172,126.582 109.129,136.156 z" style="fill:#ffffff;fill-rule:evenodd;stroke:none"/>
-<path d="M 100.281,165.996 C 101.09,165.996 101.953,165.941 102.871,165.839 L 98.0348,165.839 C 98.7108,165.945 99.4878,165.996 100.281,165.996 z" style="fill:#006225;fill-rule:evenodd;stroke:none"/>
-<path d="M 84.8518,63.9756 C 87.1878,69.9726 88.3358,80.8976 88.3358,96.7886 C 88.3358,114.492 87.1758,126.355 84.8238,132.406 C 82.9298,137.285 80.2968,140.308 76.9608,141.476 C 77.9258,141.844 78.9528,142.027 80.0388,142.027 C 80.2458,142.027 80.4488,142.019 80.6598,142.008 C 85.2928,141.715 88.7808,138.512 91.1528,132.406 C 93.5038,126.355 94.6638,114.492 94.6638,96.7886 C 94.6638,80.8976 93.5158,69.9726 91.1798,63.9756 C 88.8438,57.9486 85.3478,54.6946 80.6598,54.2846 C 80.3008,54.2536 79.9458,54.2336 79.6018,54.2336 C 78.5118,54.2336 77.4848,54.3936 76.5198,54.7146 L 76.5198,54.7146 L 76.5158,54.7146 C 80.1168,55.8356 82.8948,58.9296 84.8518,63.9756 z M 82.5078,178.253 C 82.3948,178.203 82.2808,178.148 82.1718,178.093 C 82.1598,178.089 82.1488,178.081 82.1368,178.078 C 82.0348,178.027 81.9298,177.972 81.8278,177.921 C 81.8088,177.91 81.7888,177.902 81.7698,177.89 C 81.6798,177.839 81.5858,177.792 81.4918,177.742 C 81.4648,177.726 81.4378,177.706 81.4058,177.691 C 81.3238,177.648 81.2418,177.601 81.1638,177.554 C 81.1248,177.531 81.0858,177.507 81.0508,177.484 C 80.9808,177.445 80.9058,177.402 80.8358,177.359 C 80.7888,177.328 80.7418,177.3 80.6958,177.269 C 80.6368,177.23 80.5778,177.195 80.5198,177.156 C 80.4608,177.117 80.4058,177.081 80.3518,177.042 C 80.3008,177.011 80.2498,176.976 80.2028,176.945 C 80.1368,176.898 80.0708,176.851 80.0078,176.808 C 79.9688,176.781 79.9298,176.753 79.8948,176.726 C 79.8168,176.671 79.7418,176.613 79.6638,176.554 C 79.6408,176.538 79.6138,176.519 79.5858,176.499 C 79.4878,176.421 79.3868,176.343 79.2888,176.265 C 75.0818,172.886 71.9808,166.371 69.9918,156.73 C 60.8555,154.785 53.7344,148.976 48.8008,139.226 C 43.7969,129.324 41.25,114.836 41.25,95.8866 C 41.25,75.4566 44.7344,60.3786 51.5938,50.8156 C 57.3828,42.7456 65.4568,38.7766 75.6168,38.7766 C 75.6528,38.7766 69.2658,38.7766 69.2658,38.7766 L 69.2658,38.7766 C 59.1172,38.7846 51.0508,42.7536 45.2656,50.8156 C 38.4102,60.3786 34.9219,75.4566 34.9219,95.8866 C 34.9219,114.836 37.4688,129.324 42.4727,139.226 C 47.4063,148.976 54.5274,154.785 63.6638,156.73 C 65.6528,166.371 68.7538,172.886 72.9608,176.265 C 76.1368,178.824 80.3638,180.089 85.5858,180.089 C 85.6838,180.089 85.7848,180.089 85.8828,180.085 L 91.4218,180.085 C 88.0158,180.035 85.0388,179.425 82.5158,178.257 C 82.5158,178.257 82.5118,178.257 82.5078,178.253 z" style="fill:#006225;fill-rule:evenodd;stroke:none"/>
-</g>
-</g>
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   height="44px"
+   version="1.1"
+   viewBox="0 0 44 44"
+   width="44px"
+   x="0px"
+   y="0px"
+   id="svg2"
+   inkscape:version="0.47 r22583"
+   sodipodi:docname="qt.svg">
+  <metadata
+     id="metadata18">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <defs
+     id="defs16">
+    <inkscape:perspective
+       sodipodi:type="inkscape:persp3d"
+       inkscape:vp_x="0 : 22 : 1"
+       inkscape:vp_y="0 : 1000 : 0"
+       inkscape:vp_z="44 : 22 : 1"
+       inkscape:persp3d-origin="22 : 14.666667 : 1"
+       id="perspective2836" />
+  </defs>
+  <sodipodi:namedview
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1"
+     objecttolerance="10"
+     gridtolerance="10"
+     guidetolerance="10"
+     inkscape:pageopacity="0"
+     inkscape:pageshadow="2"
+     inkscape:window-width="1920"
+     inkscape:window-height="1020"
+     id="namedview14"
+     showgrid="false"
+     inkscape:zoom="21.454545"
+     inkscape:cx="49.412871"
+     inkscape:cy="21.894358"
+     inkscape:window-x="-4"
+     inkscape:window-y="-4"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="g3" />
+  <g
+     transform="matrix(0.18308778,0,0,0.18308778,6.6100946,3.2385199)"
+     id="g3">
+    <path
+       d="M 43.09,0.3586 C 40.94,0.0036 38.84,-0.0824 36.81,0.0776 31.968136,0.39505671 27.122677,0.73638425 22.28,1.0696 9.62,2.0816 0,12.4996 0,26.8896 l 0,169.7 14.19,13.2 28.87,-209.42 0.03,-0.011 z"
+       style="fill:#006225"
+       id="path5"
+       sodipodi:nodetypes="cccccccc" />
+    <path
+       d="m 174.4,160 c 0,12.5 -7.75,24.07 -17.57,25.77 L 14.23,209.73 V 25.93 C 14.23,9.21 27.57,-2.27 43.12,0.3 l 131.3,21.52 v 138.2 z"
+       style="fill:#80c342"
+       id="path7" />
+    <path
+       d="m 154.9,80.96 -12.96,-0.598 0,0.278 6.945,0.32 6.016,0 z"
+       style="fill:#006225"
+       id="path11" />
+    <path
+       d="m 144.6,135.6 c 0.66,0.328 1.43,0.476 2.351,0.476 0.161,0 0.329,-0.004 0.497,-0.016 2.55,-0.148 5.32,-0.933 8.343,-2.308 h -6.015 c -1.821,0.832 -3.532,1.457 -5.176,1.848 z"
+       style="fill:#006225"
+       id="path13" />
+    <path
+       id="path17"
+       style="fill:#ffffff"
+       d="m 91.15,132.4 c 2.351,-6.051 3.511,-17.91 3.511,-35.62 0,-15.89 -1.148,-26.82 -3.484,-32.81 -2.336,-6.027 -5.832,-9.281 -10.52,-9.691 -0.359,-0.031 -0.714,-0.051 -1.058,-0.051 -4.34,0 -7.68,2.535 -10.01,7.625 -2.52,5.543 -3.793,17.04 -3.793,34.44 0,16.82 1.238,28.75 3.734,35.75 2.356,6.672 5.879,9.976 10.5,9.976 0.207,0 0.41,-0.008 0.621,-0.019 4.633,-0.293 8.121,-3.496 10.49,-9.602 m 17.98,3.75 c -4.117,9.707 -10.39,16.06 -18.99,19 0.867,4.449 2.176,7.441 3.922,9.019 1.351,1.211 3.433,1.821 6.222,1.821 0.805,0 1.668,-0.055 2.59,-0.157 v 13.12 l -5.961,0.782 c -1.758,0.23 -3.426,0.343 -5.004,0.343 -5.218,0 -9.445,-1.265 -12.62,-3.824 -4.207,-3.379 -7.308,-9.894 -9.297,-19.54 -9.136,-1.945 -16.26,-7.754 -21.19,-17.5 -5.004,-9.902 -7.551,-24.39 -7.551,-43.34 0,-20.43 3.484,-35.51 10.34,-45.07 5.789,-8.07 13.86,-12.04 24.02,-12.04 1.629,0 3.309,0.102 5.043,0.305 11.95,1.375 20.62,7.016 26.26,16.79 5.535,9.562 8.254,23.27 8.254,41.26 0,16.48 -2,29.45 -6.043,39.02 z M 130.4,45.91 l 11.52,1.238 0,20.21 12.96,0.914 0,12.68 -12.96,-0.598 0,46.33 c 0,4.032 0.445,6.625 1.34,7.789 0.8,1.067 2.046,1.594 3.71,1.594 0.161,0 0.329,-0.004 0.497,-0.016 2.55,-0.148 5.32,-0.933 8.343,-2.308 v 11.65 c -5.136,2.258 -10.18,3.598 -15.12,4.02 -0.718,0.055 -1.41,0.086 -2.078,0.086 -4.48,0 -7.906,-1.301 -10.25,-3.934 -2.73,-3.051 -4.09,-7.949 -4.09,-14.67 V 79.535 L 118.046,79.25 V 65.66 l 7.586,0.547 4.773,-20.3 z" />
+    <path
+       d="m 100.3,166 c 0.809,0 1.672,-0.055 2.59,-0.157 H 98.054 C 98.73,165.949 99.507,166 100.3,166 z"
+       style="fill:#006225"
+       id="path19" />
+    <path
+       id="path21"
+       style="fill:#006225"
+       d="m 84.85,63.98 c 2.336,5.997 3.484,16.92 3.484,32.81 0,17.7 -1.16,29.57 -3.512,35.62 -1.894,4.879 -4.527,7.902 -7.863,9.07 0.965,0.368 1.992,0.551 3.078,0.551 0.207,0 0.41,-0.008 0.621,-0.019 4.633,-0.293 8.121,-3.496 10.49,-9.602 2.351,-6.051 3.511,-17.91 3.511,-35.62 0,-15.89 -1.148,-26.82 -3.484,-32.81 -2.336,-6.027 -5.832,-9.281 -10.52,-9.691 -0.359,-0.031 -0.714,-0.051 -1.058,-0.051 -1.09,0 -2.117,0.16 -3.082,0.481 h -0.004 c 3.601,1.121 6.379,4.215 8.336,9.261 z m -2.344,114.3 c -0.113,-0.05 -0.227,-0.105 -0.336,-0.16 -0.012,-0.004 -0.023,-0.012 -0.035,-0.015 -0.102,-0.051 -0.207,-0.106 -0.309,-0.157 -0.019,-0.011 -0.039,-0.019 -0.058,-0.031 -0.09,-0.051 -0.184,-0.098 -0.278,-0.148 -0.027,-0.016 -0.054,-0.036 -0.086,-0.051 -0.082,-0.043 -0.164,-0.09 -0.242,-0.137 -0.039,-0.023 -0.078,-0.047 -0.113,-0.07 -0.07,-0.039 -0.145,-0.082 -0.215,-0.125 -0.047,-0.031 -0.094,-0.059 -0.14,-0.09 -0.059,-0.039 -0.118,-0.074 -0.176,-0.113 -0.059,-0.039 -0.114,-0.075 -0.168,-0.114 -0.051,-0.031 -0.102,-0.066 -0.149,-0.097 -0.066,-0.047 -0.132,-0.094 -0.195,-0.137 -0.039,-0.027 -0.078,-0.055 -0.113,-0.082 -0.078,-0.055 -0.153,-0.113 -0.231,-0.172 -0.023,-0.016 -0.05,-0.035 -0.078,-0.055 -0.098,-0.078 -0.199,-0.156 -0.297,-0.234 -4.207,-3.379 -7.308,-9.894 -9.297,-19.54 -9.136,-1.945 -16.26,-7.754 -21.19,-17.5 -5.004,-9.902 -7.551,-24.39 -7.551,-43.34 0,-20.43 3.484,-35.51 10.34,-45.07 5.789,-8.07 13.86,-12.04 24.02,-12.04 h -6.351 c -10.15,0.008 -18.22,3.977 -24,12.04 -6.855,9.563 -10.34,24.64 -10.34,45.07 0,18.95 2.547,33.44 7.551,43.34 4.934,9.75 12.05,15.56 21.19,17.5 1.989,9.641 5.09,16.16 9.297,19.54 3.176,2.559 7.403,3.824 12.62,3.824 0.098,0 0.199,0 0.297,-0.004 h 5.539 c -3.406,-0.05 -6.383,-0.66 -8.906,-1.828 L 82.498,178.28 z M 128.4,145.6 c -2.73,-3.051 -4.09,-7.949 -4.09,-14.67 V 79.57 l -6.226,-0.285 v -13.59 h -6.016 v 3.035 c 0.871,3.273 1.555,6.82 2.063,10.64 l 4.164,0.192 v 51.36 c 0,6.723 1.367,11.62 4.09,14.67 2.343,2.633 5.765,3.934 10.25,3.934 h 6.015 c -4.48,0 -7.906,-1.301 -10.25,-3.934 z m 2.043,-99.66 -6.016,0 -4.668,19.88 5.911,0.422 4.773,-20.3 z" />
+  </g>
 </svg>
diff --git a/src/s60installs/s60installs.pro b/src/s60installs/s60installs.pro
index 90c362b..d751134 100644
--- a/src/s60installs/s60installs.pro
+++ b/src/s60installs/s60installs.pro
@@ -11,21 +11,24 @@ symbian: {
 
     isEmpty(QT_LIBINFIX) {
         TARGET.UID3 = 0x2001E61C
-
-        # sqlite3 is expected to be already found on phone if infixed configuration is built.
-        BLD_INF_RULES.prj_exports += \
-            "sqlite3.sis $${EPOCROOT}epoc32/data/qt/sis/sqlite3.sis" \
-            "sqlite3_selfsigned.sis $${EPOCROOT}epoc32/data/qt/sis/sqlite3_selfsigned.sis"
-        symbian-abld|symbian-sbsv2 {
-            sqlitedeployment = \
-                "; Deploy sqlite onto phone that does not have it already" \
-                "@\"$${EPOCROOT}epoc32/data/qt/sis/sqlite3.sis\", (0x2002af5f)"
-        } else {
-            sqlitedeployment = \
-                "; Deploy sqlite onto phone that does not have it already" \
-                "@\"$${PWD}/sqlite3.sis\", (0x2002af5f)"
+        
+        # Sqlite3 is expected to be already found on phone if infixed configuration is built.
+        # It is also expected that devices newer than those based on S60 5.0 all have sqlite3.dll.
+        contains(S60_VERSION, 3.1)|contains(S60_VERSION, 3.2)|contains(S60_VERSION, 5.0) {            
+            BLD_INF_RULES.prj_exports += \
+                "sqlite3.sis $${EPOCROOT}epoc32/data/qt/sis/sqlite3.sis" \
+                "sqlite3_selfsigned.sis $${EPOCROOT}epoc32/data/qt/sis/sqlite3_selfsigned.sis"
+            symbian-abld|symbian-sbsv2 {
+                sqlitedeployment = \
+                    "; Deploy sqlite onto phone that does not have it already" \
+                    "@\"$${EPOCROOT}epoc32/data/qt/sis/sqlite3.sis\", (0x2002af5f)"
+            } else {
+                sqlitedeployment = \
+                    "; Deploy sqlite onto phone that does not have it already" \
+                    "@\"$${PWD}/sqlite3.sis\", (0x2002af5f)"
+            }
+            qtlibraries.pkg_postrules += sqlitedeployment
         }
-        qtlibraries.pkg_postrules += sqlitedeployment
     } else {
         # Always use experimental UID for infixed configuration to avoid UID clash
         TARGET.UID3 = 0xE001E61C
@@ -81,12 +84,16 @@ symbian: {
 
     qtlibraries.pkg_prerules = vendorinfo
     qtlibraries.pkg_prerules += "; Dependencies of Qt libraries"
-    qtlibraries.pkg_prerules += "(0x20013851), 1, 5, 1, {\"PIPS Installer\"}"
-    contains(QT_CONFIG, openssl) | contains(QT_CONFIG, openssl-linked) {
-        qtlibraries.pkg_prerules += "(0x200110CB), 1, 5, 1, {\"Open C LIBSSL Common\"}"
-    }
-    contains(CONFIG, stl) {
-        qtlibraries.pkg_prerules += "(0x2000F866), 1, 0, 0, {\"Standard C++ Library Common\"}"
+    
+    # It is expected that Symbian^3 and newer phones will have sufficiently new OpenC already installed
+    contains(S60_VERSION, 3.1)|contains(S60_VERSION, 3.2)|contains(S60_VERSION, 5.0) {                
+        qtlibraries.pkg_prerules += "(0x20013851), 1, 5, 1, {\"PIPS Installer\"}"
+        contains(QT_CONFIG, openssl) | contains(QT_CONFIG, openssl-linked) {
+            qtlibraries.pkg_prerules += "(0x200110CB), 1, 5, 1, {\"Open C LIBSSL Common\"}"
+        }
+        contains(CONFIG, stl) {
+            qtlibraries.pkg_prerules += "(0x2000F866), 1, 0, 0, {\"Standard C++ Library Common\"}"
+        }
     }
     qtlibraries.pkg_prerules += "(0x2002af5f), 0, 5, 0, {\"sqlite3\"}"
 
@@ -143,12 +150,39 @@ symbian: {
 
     contains(QT_CONFIG, declarative): {
         qtlibraries.sources += $$QMAKE_LIBDIR_QT/QtDeclarative$${QT_LIBINFIX}.dll
+
+        folderlistmodelImport.sources = $$QT_BUILD_TREE/imports/Qt/labs/folderlistmodel/qmlfolderlistmodelplugin$${QT_LIBINFIX}.dll
+        gesturesImport.sources = $$QT_BUILD_TREE/imports/Qt/labs/gestures/qmlgesturesplugin$${QT_LIBINFIX}.dll
+        particlesImport.sources = $$QT_BUILD_TREE/imports/Qt/labs/particles/qmlparticlesplugin$${QT_LIBINFIX}.dll
+
+        folderlistmodelImport.sources += $$QT_SOURCE_TREE/src/imports/folderlistmodel/qmldir
+        gesturesImport.sources += $$QT_SOURCE_TREE/src/imports/gestures/qmldir
+        particlesImport.sources += $$QT_SOURCE_TREE/src/imports/particles/qmldir
+
+        folderlistmodelImport.path = c:$$QT_IMPORTS_BASE_DIR/Qt/labs/folderlistmodel
+        gesturesImport.path = c:$$QT_IMPORTS_BASE_DIR/Qt/labs/gestures
+        particlesImport.path = c:$$QT_IMPORTS_BASE_DIR/Qt/labs/particles
+
+        DEPLOYMENT += folderlistmodelImport gesturesImport particlesImport
+
+        contains(QT_CONFIG, webkit): {
+            webkitImport.sources = $$QT_BUILD_TREE/imports/org/webkit/qmlwebkitplugin$${QT_LIBINFIX}.dll
+            webkitImport.sources += $$QT_SOURCE_TREE/src/imports/webkit/qmldir
+            webkitImport.path = c:$$QT_IMPORTS_BASE_DIR/org/webkit
+            DEPLOYMENT += webkitImport
+        }
     }
 
     graphicssystems_plugins.path = c:$$QT_PLUGINS_BASE_DIR/graphicssystems
     contains(QT_CONFIG, openvg) {
         qtlibraries.sources += $$QMAKE_LIBDIR_QT/QtOpenVG$${QT_LIBINFIX}.dll
         graphicssystems_plugins.sources += $$QT_BUILD_TREE/plugins/graphicssystems/qvggraphicssystem$${QT_LIBINFIX}.dll
+        # OpenVG requires Symbian^3 or later
+        pkg_platform_dependencies -= \
+            "[0x101F7961],0,0,0,{\"S60ProductID\"}" \
+            "[0x102032BE],0,0,0,{\"S60ProductID\"}" \
+            "[0x102752AE],0,0,0,{\"S60ProductID\"}" \
+            "[0x1028315F],0,0,0,{\"S60ProductID\"}"
     }
 
     contains(QT_CONFIG, multimedia){
diff --git a/src/script/api/qscriptengine.cpp b/src/script/api/qscriptengine.cpp
index 86915bb..f02ea52 100644
--- a/src/script/api/qscriptengine.cpp
+++ b/src/script/api/qscriptengine.cpp
@@ -1525,7 +1525,7 @@ void QScriptEnginePrivate::detachAllRegisteredScriptStrings()
 
 #ifndef QT_NO_REGEXP
 
-Q_DECL_IMPORT extern QString qt_regexp_toCanonical(const QString &, QRegExp::PatternSyntax);
+Q_CORE_EXPORT QString qt_regexp_toCanonical(const QString &, QRegExp::PatternSyntax);
 
 JSC::JSValue QScriptEnginePrivate::newRegExp(JSC::ExecState *exec, const QRegExp &regexp)
 {
@@ -2020,8 +2020,6 @@ QScriptValue QScriptEngine::newFunction(QScriptEngine::FunctionSignature fun,
 
 #ifndef QT_NO_REGEXP
 
-Q_DECL_IMPORT extern QString qt_regexp_toCanonical(const QString &, QRegExp::PatternSyntax);
-
 /*!
   Creates a QtScript object of class RegExp with the given
   \a regexp.
diff --git a/src/script/parser/qscriptlexer.cpp b/src/script/parser/qscriptlexer.cpp
index ca64776..3ddc3aa 100644
--- a/src/script/parser/qscriptlexer.cpp
+++ b/src/script/parser/qscriptlexer.cpp
@@ -31,7 +31,7 @@
 
 QT_BEGIN_NAMESPACE
 
-Q_DECL_IMPORT extern double qstrtod(const char *s00, char const **se, bool *ok);
+Q_CORE_EXPORT double qstrtod(const char *s00, char const **se, bool *ok);
 
 #define shiftWindowsLineBreak() \
     do { \
diff --git a/src/sql/drivers/odbc/qsql_odbc.cpp b/src/sql/drivers/odbc/qsql_odbc.cpp
index 6fd1725..9a35ac5 100644
--- a/src/sql/drivers/odbc/qsql_odbc.cpp
+++ b/src/sql/drivers/odbc/qsql_odbc.cpp
@@ -259,14 +259,14 @@ static QString qWarnODBCHandle(int handleType, SQLHANDLE handle, int *nativeCode
 
 static QString qODBCWarn(const QODBCPrivate* odbc, int *nativeCode = 0)
 {
-    return (qWarnODBCHandle(SQL_HANDLE_ENV, odbc->dpEnv()) + QLatin1Char(' ')
+    return QString(qWarnODBCHandle(SQL_HANDLE_ENV, odbc->dpEnv()) + QLatin1Char(' ')
              + qWarnODBCHandle(SQL_HANDLE_DBC, odbc->dpDbc()) + QLatin1Char(' ')
              + qWarnODBCHandle(SQL_HANDLE_STMT, odbc->hStmt, nativeCode)).simplified();
 }
 
 static QString qODBCWarn(const QODBCDriverPrivate* odbc, int *nativeCode = 0)
 {
-    return (qWarnODBCHandle(SQL_HANDLE_ENV, odbc->hEnv) + QLatin1Char(' ')
+    return QString(qWarnODBCHandle(SQL_HANDLE_ENV, odbc->hEnv) + QLatin1Char(' ')
              + qWarnODBCHandle(SQL_HANDLE_DBC, odbc->hDbc, nativeCode)).simplified();
 }
 
diff --git a/src/svg/qgraphicssvgitem.cpp b/src/svg/qgraphicssvgitem.cpp
index 69ff7a3..e035e1d 100644
--- a/src/svg/qgraphicssvgitem.cpp
+++ b/src/svg/qgraphicssvgitem.cpp
@@ -124,8 +124,10 @@ public:
 
     \snippet doc/src/snippets/code/src_svg_qgraphicssvgitem.cpp 0
 
-    Size of the item can be set via the setSize() method or via
-    direct manipulation of the items transformation matrix.
+    Size of the item can be set via the \l{QRectF::setSize()}
+    {setSize()} method of the \l{QGraphicsSvgItem::boundingRect()}
+    {bounding rectangle} or via direct manipulation of the items
+    transformation matrix.
 
     By default the SVG rendering is cached using QGraphicsItem::DeviceCoordinateCache
     mode to speedup the display of items. Caching can be disabled by passing
diff --git a/src/xmlpatterns/data/qdecimal_p.h b/src/xmlpatterns/data/qdecimal_p.h
index d17b647..2a5e0b3 100644
--- a/src/xmlpatterns/data/qdecimal_p.h
+++ b/src/xmlpatterns/data/qdecimal_p.h
@@ -61,7 +61,7 @@ QT_BEGIN_NAMESPACE
 /**
  * Defined in QtCore's qlocale.cpp.
  */
-Q_DECL_IMPORT extern char *qdtoa(double d, int mode, int ndigits, int *decpt, int *sign, char **rve, char **resultp);
+Q_CORE_EXPORT char *qdtoa(double d, int mode, int ndigits, int *decpt, int *sign, char **rve, char **resultp);
 
 namespace QPatternist
 {
author	David Boddie <dboddie@trolltech.com>	2010-06-10 12:56:11 (GMT)
committer	David Boddie <dboddie@trolltech.com>	2010-06-10 12:56:11 (GMT)
commit	19e19142d8a56ba880dca869c5721ea8f72fea16 (patch)
tree	ba18b0ac8ec954bc905af5a9adb1be00b6da1bbc /src
parent	95fcfccf3c6d9d102fa1c5481e6be52a21749af6 (diff)
parent	7101ae5a0e90d97acf86a444c4d51ca45e7863fe (diff)
download	Qt-19e19142d8a56ba880dca869c5721ea8f72fea16.zip Qt-19e19142d8a56ba880dca869c5721ea8f72fea16.tar.gz Qt-19e19142d8a56ba880dca869c5721ea8f72fea16.tar.bz2