Merge branch '4.6'

Conflicts:
	src/corelib/io/qdatastream.h

16 files changed, 462 insertions, 68 deletions

diff --git a/src/corelib/global/qnamespace.h b/src/corelib/global/qnamespace.h
index 741c06f..473398b 100644
--- a/src/corelib/global/qnamespace.h
+++ b/src/corelib/global/qnamespace.h
@@ -1627,6 +1627,11 @@ public:
         NavigationModeCursorAuto,
         NavigationModeCursorForceVisible
     };
+
+    enum RenderHint {
+        QualityHint,
+        PerformanceHint
+    };
 }
 #ifdef Q_MOC_RUN
  ;
diff --git a/src/corelib/global/qnamespace.qdoc b/src/corelib/global/qnamespace.qdoc
index 40dd1d2..684ebca 100644
--- a/src/corelib/global/qnamespace.qdoc
+++ b/src/corelib/global/qnamespace.qdoc
@@ -2776,6 +2776,19 @@
 */
 
 /*!
+    \enum Qt::CoordinateSystem
+    \since 4.6
+
+    This enum specifies the coordinate system.
+
+    \value DeviceCoordinates Coordinates are relative to the upper-left corner
+    of the object's paint device.
+
+    \value LogicalCoordinates Coordinates are relative to the upper-left corner
+    of the object.
+*/
+
+/*!
     \enum Qt::GestureState
     \since 4.6
 
@@ -2814,3 +2827,18 @@
     \sa QApplication::setNavigationMode()
     \sa QApplication::navigationMode()
 */
+
+/*!
+    \enum Qt::RenderHint
+    \since 4.6
+
+    This enum describes the possible hints that can be used to control various
+    rendering operations.
+
+    \value QualityHint Indicates that rendering quality is the most important factor,
+    at the potential cost of lower performance.
+
+    \value PerformanceHint Indicates that rendering performance is the most important factor,
+    at the potential cost of lower quality.
+*/
+
diff --git a/src/corelib/io/io.pri b/src/corelib/io/io.pri
index e58e4ad..02a1586 100644
--- a/src/corelib/io/io.pri
+++ b/src/corelib/io/io.pri
@@ -5,6 +5,7 @@ HEADERS +=  \
         io/qabstractfileengine_p.h \
         io/qbuffer.h \
         io/qdatastream.h \
+        io/qdatastream_p.h \
         io/qdebug.h \
         io/qdir.h \
         io/qdiriterator.h \
@@ -89,6 +90,7 @@ win32 {
         symbian {
             SOURCES += io/qfilesystemwatcher_symbian.cpp
             HEADERS += io/qfilesystemwatcher_symbian_p.h
+            INCLUDEPATH += $$MW_LAYER_SYSTEMINCLUDE
             contains(QT_CONFIG, s60): LIBS += -lplatformenv
         }
 }
diff --git a/src/corelib/io/qdatastream.cpp b/src/corelib/io/qdatastream.cpp
index 9339b8e..cc62201 100644
--- a/src/corelib/io/qdatastream.cpp
+++ b/src/corelib/io/qdatastream.cpp
@@ -40,6 +40,7 @@
 ****************************************************************************/
 
 #include "qdatastream.h"
+#include "qdatastream_p.h"
 
 #ifndef QT_NO_DATASTREAM
 #include "qbuffer.h"
@@ -193,6 +194,21 @@ QT_BEGIN_NAMESPACE
 */
 
 /*!
+  \enum QDataStream::FloatingPointPrecision
+
+  The precision of floating point numbers used for reading/writing the data. This will only have
+  an effect if the version of the data stream is Qt_4_6 or higher.
+
+  \warning The floating point precision must be set to the same value on the object that writes
+  and the object that reads the data stream.
+
+  \value SinglePrecision All floating point numbers in the data stream have 32-bit precision.
+  \value DoublePrecision All floating point numbers in the data stream have 64-bit precision.
+
+  \sa setFloatingPointPrecision(), floatingPointPrecision()
+*/
+
+/*!
     \enum QDataStream::Status
 
     This enum describes the current status of the data stream.
@@ -222,7 +238,7 @@ QT_BEGIN_NAMESPACE
 #endif
 
 enum {
-    DefaultStreamVersion = QDataStream::Qt_4_5
+    DefaultStreamVersion = QDataStream::Qt_4_6
 };
 
 // ### 5.0: when streaming invalid QVariants, just the type should
@@ -414,6 +430,42 @@ bool QDataStream::atEnd() const
 }
 
 /*!
+    Returns the floating point precision of the data stream.
+
+    \since 4.6
+
+    \sa FloatingPointPrecision setFloatingPointPrecision()
+*/
+QDataStream::FloatingPointPrecision QDataStream::floatingPointPrecision() const
+{
+    return d == 0 ? QDataStream::DoublePrecision : d->floatingPointPrecision;
+}
+
+/*!
+    Sets the floating point precision of the data stream. If the floating point precision is
+    DoublePrecision and the version of the data stream is Qt_4_6 or higher, all floating point
+    numbers will be written and read with 64-bit precision. If the floating point precision is
+    SinglePrecision and the version is Qt_4_6 or higher, all floating point numbers will be written
+    and read with 32-bit precision.
+
+    For versions prior to Qt_4_6, the precision of floating point numbers in the data stream depends
+    on the stream operator called.
+
+    The default is DoublePrecision.
+
+    \warning This property must be set to the same value on the object that writes and the object
+    that reads the data stream.
+
+    \since 4.6
+*/
+void QDataStream::setFloatingPointPrecision(QDataStream::FloatingPointPrecision precision)
+{
+    if (d == 0)
+        d.reset(new QDataStreamPrivate());
+    d->floatingPointPrecision = precision;
+}
+
+/*!
     Returns the status of the data stream.
 
     \sa Status setStatus() resetStatus()
@@ -517,7 +569,7 @@ void QDataStream::setByteOrder(ByteOrder bo)
     \value Qt_4_3 Version 9 (Qt 4.3)
     \value Qt_4_4 Version 10 (Qt 4.4)
     \value Qt_4_5 Version 11 (Qt 4.5)
-    \omitvalue Qt_4_6
+    \value Qt_4_6 Version 12 (Qt 4.6)
 
     \sa setVersion(), version()
 */
@@ -754,13 +806,23 @@ QDataStream &QDataStream::operator>>(bool &i)
 /*!
     \overload
 
-    Reads a 32-bit floating point number from the stream into \a f,
+    Reads a floating point number from the stream into \a f,
     using the standard IEEE 754 format. Returns a reference to the
     stream.
+
+    \sa setFloatingPointPrecision()
 */
 
 QDataStream &QDataStream::operator>>(float &f)
-{
+{    
+    if (version() >= QDataStream::Qt_4_6
+        && floatingPointPrecision() == QDataStream::DoublePrecision) {
+        double d;
+        *this >> d;
+        f = d;
+        return *this;
+    }
+
     f = 0.0f;
     CHECK_STREAM_PRECOND(*this)
     if (noswap) {
@@ -796,13 +858,23 @@ QDataStream &QDataStream::operator>>(float &f)
 /*!
     \overload
 
-    Reads a 64-bit floating point number from the stream into \a f,
+    Reads a floating point number from the stream into \a f,
     using the standard IEEE 754 format. Returns a reference to the
     stream.
+
+    \sa setFloatingPointPrecision()
 */
 
 QDataStream &QDataStream::operator>>(double &f)
 {
+    if (version() >= QDataStream::Qt_4_6
+        && floatingPointPrecision() == QDataStream::SinglePrecision) {
+        float d;
+        *this >> d;
+        f = d;
+        return *this;
+    }
+
     f = 0.0;
     CHECK_STREAM_PRECOND(*this)
 #ifndef Q_DOUBLE_FORMAT
@@ -1115,12 +1187,20 @@ QDataStream &QDataStream::operator<<(bool i)
 /*!
     \overload
 
-    Writes a 32-bit floating point number, \a f, to the stream using
+    Writes a floating point number, \a f, to the stream using
     the standard IEEE 754 format. Returns a reference to the stream.
+
+    \sa setFloatingPointPrecision()
 */
 
 QDataStream &QDataStream::operator<<(float f)
 {
+    if (version() >= QDataStream::Qt_4_6
+        && floatingPointPrecision() == QDataStream::DoublePrecision) {
+        *this << double(f);
+        return *this;
+    }
+
     CHECK_STREAM_PRECOND(*this)
     float g = f;                                // fixes float-on-stack problem
     if (noswap) {                                // no conversion needed
@@ -1146,12 +1226,20 @@ QDataStream &QDataStream::operator<<(float f)
 /*!
     \overload
 
-    Writes a 64-bit floating point number, \a f, to the stream using
+    Writes a floating point number, \a f, to the stream using
     the standard IEEE 754 format. Returns a reference to the stream.
+
+    \sa setFloatingPointPrecision()
 */
 
 QDataStream &QDataStream::operator<<(double f)
 {
+    if (version() >= QDataStream::Qt_4_6
+        && floatingPointPrecision() == QDataStream::SinglePrecision) {
+        *this << float(f);
+        return *this;
+    }
+
     CHECK_STREAM_PRECOND(*this)
 #ifndef Q_DOUBLE_FORMAT
     if (noswap) {
diff --git a/src/corelib/io/qdatastream.h b/src/corelib/io/qdatastream.h
index 7a930c4..f8e0608 100644
--- a/src/corelib/io/qdatastream.h
+++ b/src/corelib/io/qdatastream.h
@@ -42,6 +42,7 @@
 #ifndef QDATASTREAM_H
 #define QDATASTREAM_H
 
+#include <QtCore/qscopedpointer.h>
 #include <QtCore/qiodevice.h>
 #include <QtCore/qglobal.h>
 
@@ -83,7 +84,7 @@ public:
         Qt_4_3 = 9,
         Qt_4_4 = 10,
         Qt_4_5 = 11,
-        Qt_4_6 = Qt_4_5,
+        Qt_4_6 = 12,
         Qt_4_7 = Qt_4_6
 #if QT_VERSION >= 0x040800
 #error Add the datastream version for this Qt version
@@ -102,6 +103,11 @@ public:
 	ReadCorruptData
     };
 
+    enum FloatingPointPrecision {
+        SinglePrecision,
+        DoublePrecision
+    };
+
     QDataStream();
     explicit QDataStream(QIODevice *);
 #ifdef QT3_SUPPORT
@@ -124,6 +130,9 @@ public:
     void setStatus(Status status);
     void resetStatus();
 
+    FloatingPointPrecision floatingPointPrecision() const;
+    void setFloatingPointPrecision(FloatingPointPrecision precision);
+
     ByteOrder byteOrder() const;
     void setByteOrder(ByteOrder);
 
@@ -177,7 +186,7 @@ public:
 private:
     Q_DISABLE_COPY(QDataStream)
 
-    QDataStreamPrivate *d;
+    QScopedPointer<QDataStreamPrivate> d;
 
     QIODevice *dev;
     bool owndev;
diff --git a/src/corelib/io/qdatastream_p.h b/src/corelib/io/qdatastream_p.h
new file mode 100644
index 0000000..157fee9
--- /dev/null
+++ b/src/corelib/io/qdatastream_p.h
@@ -0,0 +1,72 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtCore 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$
+**
+****************************************************************************/
+
+#ifndef QDATASTREAM_P_H
+#define QDATASTREAM_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <qdatastream.h>
+
+QT_BEGIN_NAMESPACE
+
+#ifndef QT_NO_DATASTREAM
+class QDataStreamPrivate
+{
+public:
+    QDataStreamPrivate() : floatingPointPrecision(QDataStream::DoublePrecision) { }
+
+    QDataStream::FloatingPointPrecision floatingPointPrecision;
+};
+#endif
+
+QT_END_NAMESPACE
+
+#endif // QDATASTREAM_P_H
diff --git a/src/corelib/io/qfsfileengine_unix.cpp b/src/corelib/io/qfsfileengine_unix.cpp
index 4ec5772..114da3b 100644
--- a/src/corelib/io/qfsfileengine_unix.cpp
+++ b/src/corelib/io/qfsfileengine_unix.cpp
@@ -595,7 +595,7 @@ QString QFSFileEngine::rootPath()
     return QDir::cleanPath(QDir::fromNativeSeparators(qt_TDesC2QString(symbianPath)));
 # else
 # warning No fallback implementation of QFSFileEngine::rootPath()
-    return QLatin1String();
+    return QString();
 # endif
 #else
     return QLatin1String("/");
@@ -614,7 +614,7 @@ QString QFSFileEngine::tempPath()
     QT_MKDIR(QFile::encodeName(temp), 0777);
 # else
 # warning No fallback implementation of QFSFileEngine::tempPath()
-    return QString();
+    QString temp;
 # endif
 #else
     QString temp = QFile::decodeName(qgetenv("TMPDIR"));
diff --git a/src/corelib/io/qtextstream.cpp b/src/corelib/io/qtextstream.cpp
index 5931267..594718e 100644
--- a/src/corelib/io/qtextstream.cpp
+++ b/src/corelib/io/qtextstream.cpp
@@ -241,6 +241,7 @@ static const int QTEXTSTREAM_BUFFERSIZE = 16384;
 #include "private/qlocale_p.h"
 
 #include <stdlib.h>
+#include <limits.h>
 #include <new>
 
 #if defined QTEXTSTREAM_DEBUG
@@ -375,10 +376,10 @@ public:
     enum TokenDelimiter {
         Space,
         NotSpace,
-        EndOfLine,
-        EndOfFile
+        EndOfLine
     };
 
+    QString read(int maxlen);
     bool scan(const QChar **ptr, int *tokenLength,
               int maxlen, TokenDelimiter delimiter);
     inline const QChar *readPtr() const;
@@ -704,6 +705,25 @@ bool QTextStreamPrivate::flushWriteBuffer()
     return flushed && bytesWritten == qint64(data.size());
 }
 
+QString QTextStreamPrivate::read(int maxlen)
+{
+    QString ret;
+    if (string) {
+        lastTokenSize = qMin(maxlen, string->size() - stringOffset);
+        ret = string->mid(stringOffset, lastTokenSize);
+    } else {
+        while (readBuffer.size() - readBufferOffset < maxlen && fillReadBuffer()) ;
+        lastTokenSize = qMin(maxlen, readBuffer.size() - readBufferOffset);
+        ret = readBuffer.mid(readBufferOffset, lastTokenSize);
+    }
+    consumeLastToken();
+
+#if defined (QTEXTSTREAM_DEBUG)
+    qDebug("QTextStreamPrivate::read() maxlen = %d, token length = %d", maxlen, ret.length());
+#endif
+    return ret;
+}
+
 /*! \internal
 
     Scans no more than \a maxlen QChars in the current buffer for the
@@ -736,19 +756,28 @@ bool QTextStreamPrivate::scan(const QChar **ptr, int *length, int maxlen, TokenD
             const QChar ch = *chPtr++;
             ++totalSize;
 
-            if (delimiter == Space && ch.isSpace()) {
-                foundToken = true;
-                delimSize = 1;
-            } else if (delimiter == NotSpace && !ch.isSpace()) {
-                foundToken = true;
-                delimSize = 1;
-            } else if (delimiter == EndOfLine && ch == QLatin1Char('\n')) {
-                foundToken = true;
-                delimSize = (lastChar == QLatin1Char('\r')) ? 2 : 1;
-                consumeDelimiter = true;
+            switch (delimiter) {
+            case Space:
+                if (ch.isSpace()) {
+                    foundToken = true;
+                    delimSize = 1;
+                }
+                break;
+            case NotSpace:
+                if (!ch.isSpace()) {
+                    foundToken = true;
+                    delimSize = 1;
+                }
+                break;
+            case EndOfLine:
+                if (ch == QLatin1Char('\n')) {
+                    foundToken = true;
+                    delimSize = (lastChar == QLatin1Char('\r')) ? 2 : 1;
+                    consumeDelimiter = true;
+                }
+                lastChar = ch;
+                break;
             }
-
-            lastChar = ch;
         }
     } while (!foundToken
              && (!maxlen || totalSize < maxlen)
@@ -769,7 +798,7 @@ bool QTextStreamPrivate::scan(const QChar **ptr, int *length, int maxlen, TokenD
 
     // if we find a '\r' at the end of the data when reading lines,
     // don't make it part of the line.
-    if (totalSize > 0 && !foundToken && delimiter == EndOfLine) {
+    if (delimiter == EndOfLine && totalSize > 0 && !foundToken) {
         if (((string && stringOffset + totalSize == string->size()) || (device && device->atEnd()))
             && lastChar == QLatin1Char('\r')) {
             consumeDelimiter = true;
@@ -1603,14 +1632,7 @@ QString QTextStream::readAll()
     Q_D(QTextStream);
     CHECK_VALID_STREAM(QString());
 
-    const QChar *readPtr;
-    int length;
-    if (!d->scan(&readPtr, &length, /* maxlen = */ 0, QTextStreamPrivate::EndOfFile))
-        return QString();
-
-    QString tmp = QString(readPtr, length);
-    d->consumeLastToken();
-    return tmp;
+    return d->read(INT_MAX);
 }
 
 /*!
@@ -1662,14 +1684,7 @@ QString QTextStream::read(qint64 maxlen)
     if (maxlen <= 0)
         return QString::fromLatin1("");     // empty, not null
 
-    const QChar *readPtr;
-    int length;
-    if (!d->scan(&readPtr, &length, int(maxlen), QTextStreamPrivate::EndOfFile))
-        return QString();
-
-    QString tmp = QString(readPtr, length);
-    d->consumeLastToken();
-    return tmp;
+    return d->read(int(maxlen));
 }
 
 /*! \internal
diff --git a/src/corelib/io/qurl.cpp b/src/corelib/io/qurl.cpp
index face923..c9a4cf1 100644
--- a/src/corelib/io/qurl.cpp
+++ b/src/corelib/io/qurl.cpp
@@ -172,6 +172,8 @@
 #include "private/qunicodetables_p.h"
 #include "qatomic.h"
 #include "qbytearray.h"
+#include "qdir.h"
+#include "qfile.h"
 #include "qlist.h"
 #ifndef QT_NO_REGEXP
 #include "qregexp.h"
@@ -5547,6 +5549,79 @@ QUrl QUrl::fromEncoded(const QByteArray &input, ParsingMode parsingMode)
 }
 
 /*!
+    Returns a valid URL from a user supplied \a userInput string if one can be
+    deducted. In the case that is not possible, an invalid QUrl() is returned.
+
+    \since 4.6
+
+    Most applications that can browse the web, allow the user to input a URL
+    in the form of a plain string. This string can be manually typed into
+    a location bar, obtained from the clipboard, or passed in via command
+    line arguments.
+
+    When the string is not already a valid URL, a best guess is performed,
+    making various web related assumptions.
+
+    In the case the string corresponds to a valid file path on the system,
+    a file:// URL is constructed, using QUrl::fromLocalFile().
+
+    If that is not the case, an attempt is made to turn the string into a
+    http:// or ftp:// URL. The latter in the case the string starts with
+    'ftp'. The result is then passed through QUrl's tolerant parser, and
+    in the case or success, a valid QUrl is returned, or else a QUrl().
+
+    \section1 Examples:
+
+    \list
+    \o qt.nokia.com becomes http://qt.nokia.com
+    \o ftp.qt.nokia.com becomes ftp://ftp.qt.nokia.com
+    \o localhost becomes http://localhost
+    \o /home/user/test.html becomes file:///home/user/test.html (if exists)
+    \endlist
+
+    \section2 Tips to avoid erroneous character conversion when dealing with
+    URLs and strings:
+
+    \list
+    \o When creating an URL QString from a QByteArray or a char*, always use
+       QString::fromUtf8().
+    \o Favor the use of QUrl::fromEncoded() and QUrl::toEncoded() instead of
+       QUrl(string) and QUrl::toString() when converting QUrl to/from string.
+    \endlist
+*/
+QUrl QUrl::fromUserInput(const QString &userInput)
+{
+    QString trimmedString = userInput.trimmed();
+
+    // Absolute files
+    if (QDir::isAbsolutePath(trimmedString))
+        return QUrl::fromLocalFile(trimmedString);
+
+    // Check the most common case of a valid url with scheme and host first
+    QUrl url = QUrl::fromEncoded(trimmedString.toUtf8(), QUrl::TolerantMode);
+    if (url.isValid() && !url.scheme().isEmpty() && !url.host().isEmpty())
+        return url;
+
+    // If the string is missing the scheme or the scheme is not valid, prepend a scheme
+    QString scheme = url.scheme();
+    if (scheme.isEmpty() || scheme.contains(QLatin1Char('.')) || scheme == QLatin1String("localhost")) {
+        // Do not do anything for strings such as "foo", only "foo.com"
+        int dotIndex = trimmedString.indexOf(QLatin1Char('.'));
+        if (dotIndex != -1 || trimmedString.startsWith(QLatin1String("localhost"))) {
+            const QString hostscheme = trimmedString.left(dotIndex).toLower();
+            QByteArray scheme = (hostscheme == QLatin1String("ftp")) ? "ftp" : "http";
+            trimmedString = QLatin1String(scheme) + QLatin1String("://") + trimmedString;
+        }
+        url = QUrl::fromEncoded(trimmedString.toUtf8(), QUrl::TolerantMode);
+    }
+
+    if (url.isValid())
+        return url;
+
+    return QUrl();
+}
+
+/*!
     Returns a decoded copy of \a input. \a input is first decoded from
     percent encoding, then converted from UTF-8 to unicode.
 */
diff --git a/src/corelib/io/qurl.h b/src/corelib/io/qurl.h
index b00074a..f76d345 100644
--- a/src/corelib/io/qurl.h
+++ b/src/corelib/io/qurl.h
@@ -189,6 +189,8 @@ public:
     static QUrl fromEncoded(const QByteArray &url, ParsingMode mode);
     // ### Qt 5: merge the two fromEncoded() functions, with mode = TolerantMode
 
+    static QUrl fromUserInput(const QString &userInput);
+
     void detach();
     bool isDetached() const;
 
diff --git a/src/corelib/kernel/qcoreevent.cpp b/src/corelib/kernel/qcoreevent.cpp
index 185c305..3bef0d4 100644
--- a/src/corelib/kernel/qcoreevent.cpp
+++ b/src/corelib/kernel/qcoreevent.cpp
@@ -270,7 +270,6 @@ QT_BEGIN_NAMESPACE
     \omitvalue NetworkReplyUpdated
     \omitvalue FutureCallOut
     \omitvalue CocoaRequestModal
-    \omitvalue SymbianDeferredFocusChanged
     \omitvalue UpdateSoftKeys
     \omitvalue NativeGesture
 */
diff --git a/src/corelib/kernel/qcoreevent.h b/src/corelib/kernel/qcoreevent.h
index bc96918..be25b41 100644
--- a/src/corelib/kernel/qcoreevent.h
+++ b/src/corelib/kernel/qcoreevent.h
@@ -281,9 +281,7 @@ public:
         RequestSoftwareInputPanel = 199,
         CloseSoftwareInputPanel = 200,
 
-        SymbianDeferredFocusChanged = 201,       // Internal for generating asynchronous focus events on Symbian
-
-        UpdateSoftKeys = 202,                   // Internal for compressing soft key updates
+        UpdateSoftKeys = 201,                   // Internal for compressing soft key updates
 
         // 512 reserved for Qt Jambi's MetaCall event
         // 513 reserved for Qt Jambi's DeleteOnMainThread event
diff --git a/src/corelib/statemachine/qstatemachine.cpp b/src/corelib/statemachine/qstatemachine.cpp
index 8d50870c..c7144e4 100644
--- a/src/corelib/statemachine/qstatemachine.cpp
+++ b/src/corelib/statemachine/qstatemachine.cpp
@@ -1265,11 +1265,13 @@ void QStateMachinePrivate::_q_process()
         break;
     case Finished:
         state = NotRunning;
+        cancelAllDelayedEvents();
         unregisterAllTransitions();
         emit q->finished();
         break;
     case Stopped:
         state = NotRunning;
+        cancelAllDelayedEvents();
         unregisterAllTransitions();
         emit q->stopped();
         break;
@@ -1291,6 +1293,19 @@ void QStateMachinePrivate::processEvents(EventProcessingMode processingMode)
     }
 }
 
+void QStateMachinePrivate::cancelAllDelayedEvents()
+{
+    Q_Q(QStateMachine);
+    QHash<int, QEvent*>::const_iterator it;
+    for (it = delayedEvents.constBegin(); it != delayedEvents.constEnd(); ++it) {
+        int id = it.key();
+        QEvent *e = it.value();
+        q->killTimer(id);
+        delete e;
+    }
+    delayedEvents.clear();
+}
+
 namespace {
 
 class GoToStateTransition : public QAbstractTransition
@@ -1587,6 +1602,18 @@ QStateMachine::~QStateMachine()
 {
 }
 
+/*!
+  \enum QStateMachine::EventPriority
+
+  This enum type specifies the priority of an event posted to the state
+  machine using postEvent().
+
+  Events of high priority are processed before events of normal priority.
+
+  \value NormalPriority The event has normal priority.
+  \value HighPriority The event has high priority.
+*/
+
 /*! \enum QStateMachine::Error 
 
     This enum type defines errors that can occur in the state machine at run time. When the state
@@ -1798,47 +1825,99 @@ void QStateMachine::stop()
 }
 
 /*!
-  Posts the given \a event for processing by this state machine, with a delay
-  of \a delay milliseconds.
+  Posts the given \a event of the given \a priority for processing by this
+  state machine.
 
   This function returns immediately. The event is added to the state machine's
   event queue. Events are processed in the order posted. The state machine
   takes ownership of the event and deletes it once it has been processed.
 
   You can only post events when the state machine is running.
+
+  \sa postDelayedEvent()
 */
-void QStateMachine::postEvent(QEvent *event, int delay)
+void QStateMachine::postEvent(QEvent *event, EventPriority priority)
 {
     Q_D(QStateMachine);
     if (d->state != QStateMachinePrivate::Running) {
         qWarning("QStateMachine::postEvent: cannot post event when the state machine is not running");
         return;
     }
+    if (!event) {
+        qWarning("QStateMachine::postEvent: cannot post null event");
+        return;
+    }
 #ifdef QSTATEMACHINE_DEBUG
-    qDebug() << this << ": posting external event" << event << "with delay" << delay;
+    qDebug() << this << ": posting event" << event;
 #endif
-    if (delay) {
-        int tid = startTimer(delay);
-        d->delayedEvents[tid] = event;
-    } else {
+    switch (priority) {
+    case NormalPriority:
         d->externalEventQueue.append(event);
-        d->processEvents(QStateMachinePrivate::QueuedProcessing);
+        break;
+    case HighPriority:
+        d->internalEventQueue.append(event);
+        break;
     }
+    d->processEvents(QStateMachinePrivate::QueuedProcessing);
 }
 
 /*!
-  \internal
+  Posts the given \a event for processing by this state machine, with the
+  given \a delay in milliseconds. Returns an identifier associated with the
+  delayed event, or -1 if the event could not be posted.
 
-  Posts the given internal \a event for processing by this state machine.
+  This function returns immediately. When the delay has expired, the event
+  will be added to the state machine's event queue for processing. The state
+  machine takes ownership of the event and deletes it once it has been
+  processed.
+
+  You can only post events when the state machine is running.
+
+  \sa cancelDelayedEvent(), postEvent()
 */
-void QStateMachine::postInternalEvent(QEvent *event)
+int QStateMachine::postDelayedEvent(QEvent *event, int delay)
 {
     Q_D(QStateMachine);
+    if (d->state != QStateMachinePrivate::Running) {
+        qWarning("QStateMachine::postDelayedEvent: cannot post event when the state machine is not running");
+        return -1;
+    }
+    if (!event) {
+        qWarning("QStateMachine::postDelayedEvent: cannot post null event");
+        return -1;
+    }
+    if (delay < 0) {
+        qWarning("QStateMachine::postDelayedEvent: delay cannot be negative");
+        return -1;
+    }
 #ifdef QSTATEMACHINE_DEBUG
-    qDebug() << this << ": posting internal event" << event;
+    qDebug() << this << ": posting event" << event << "with delay" << delay;
 #endif
-    d->internalEventQueue.append(event);
-    d->processEvents(QStateMachinePrivate::QueuedProcessing);
+    int tid = startTimer(delay);
+    d->delayedEvents[tid] = event;
+    return tid;
+}
+
+/*!
+  Cancels the delayed event identified by the given \a id. The id should be a
+  value returned by a call to postDelayedEvent(). Returns true if the event
+  was successfully cancelled, otherwise returns false.
+
+  \sa postDelayedEvent()
+*/
+bool QStateMachine::cancelDelayedEvent(int id)
+{
+    Q_D(QStateMachine);
+    if (d->state != QStateMachinePrivate::Running) {
+        qWarning("QStateMachine::cancelDelayedEvent: the machine is not running");
+        return false;
+    }
+    QEvent *e = d->delayedEvents.take(id);
+    if (!e)
+        return false;
+    killTimer(id);
+    delete e;
+    return true;
 }
 
 /*!
@@ -1882,9 +1961,14 @@ bool QStateMachine::event(QEvent *e)
     if (e->type() == QEvent::Timer) {
         QTimerEvent *te = static_cast<QTimerEvent*>(e);
         int tid = te->timerId();
-        if (d->delayedEvents.contains(tid)) {
+        if (d->state != QStateMachinePrivate::Running) {
+            // This event has been cancelled already
+            Q_ASSERT(!d->delayedEvents.contains(tid));
+            return true;
+        }
+        QEvent *ee = d->delayedEvents.take(tid);
+        if (ee != 0) {
             killTimer(tid);
-            QEvent *ee = d->delayedEvents.take(tid);
             d->externalEventQueue.append(ee);
             d->processEvents(QStateMachinePrivate::DirectProcessing);
             return true;
diff --git a/src/corelib/statemachine/qstatemachine.h b/src/corelib/statemachine/qstatemachine.h
index a0b2b14..321a05c 100644
--- a/src/corelib/statemachine/qstatemachine.h
+++ b/src/corelib/statemachine/qstatemachine.h
@@ -102,6 +102,11 @@ public:
         QEvent *m_event;
     };
 
+    enum EventPriority {
+        NormalPriority,
+        HighPriority
+    };
+
     enum RestorePolicy {
         DoNotRestoreProperties,
         RestoreProperties
@@ -138,7 +143,9 @@ public:
     QStateMachine::RestorePolicy globalRestorePolicy() const;
     void setGlobalRestorePolicy(QStateMachine::RestorePolicy restorePolicy);
 
-    void postEvent(QEvent *event, int delay = 0);
+    void postEvent(QEvent *event, EventPriority priority = NormalPriority);
+    int postDelayedEvent(QEvent *event, int delay);
+    bool cancelDelayedEvent(int id);
 
     QSet<QAbstractState*> configuration() const;
 
@@ -158,8 +165,6 @@ protected:
     void onEntry(QEvent *event);
     void onExit(QEvent *event);
 
-    void postInternalEvent(QEvent *event);
-
     virtual void beginSelectTransitions(QEvent *event);
     virtual void endSelectTransitions(QEvent *event);
 
diff --git a/src/corelib/statemachine/qstatemachine_p.h b/src/corelib/statemachine/qstatemachine_p.h
index 141bc5c..cf7a073 100644
--- a/src/corelib/statemachine/qstatemachine_p.h
+++ b/src/corelib/statemachine/qstatemachine_p.h
@@ -160,6 +160,7 @@ public:
     void handleTransitionSignal(QObject *sender, int signalIndex,
                                 void **args);    
     void processEvents(EventProcessingMode processingMode);
+    void cancelAllDelayedEvents();
     
 #ifndef QT_NO_PROPERTIES
     typedef QPair<QObject *, QByteArray> RestorableId;
diff --git a/src/corelib/tools/qstringbuilder.h b/src/corelib/tools/qstringbuilder.h
index e1a0e06..efa39b5 100644
--- a/src/corelib/tools/qstringbuilder.h
+++ b/src/corelib/tools/qstringbuilder.h
@@ -198,6 +198,17 @@ template <int N> struct QConcatenable<char[N]>
     }
 };
 
+template <int N> struct QConcatenable<const char[N]>
+{
+    typedef const char type[N];
+    static int size(const char[N]) { return N - 1; }
+    static inline void appendTo(const char a[N], QChar *&out)
+    {
+        for (int i = 0; i < N - 1; ++i)
+            *out++ = QLatin1Char(a[i]);
+    }
+};
+
 template <> struct QConcatenable<const char *>
 {
     typedef char const *type;
@@ -241,7 +252,7 @@ template <typename A, typename B>
 QStringBuilder<typename QConcatenable<A>::type, typename QConcatenable<B>::type>
 operator%(const A &a, const B &b)
 {
-   return QStringBuilder<A, B>(a, b);
+   return QStringBuilder<typename QConcatenable<A>::type, typename QConcatenable<B>::type>(a, b);
 }
 
 #ifdef QT_USE_FAST_OPERATOR_PLUS
@@ -249,7 +260,7 @@ template <typename A, typename B>
 QStringBuilder<typename QConcatenable<A>::type, typename QConcatenable<B>::type>
 operator+(const A &a, const B &b)
 {
-   return QStringBuilder<A, B>(a, b);
+   return QStringBuilder<typename QConcatenable<A>::type, typename QConcatenable<B>::type>(a, b);
 }
 #endif