Merge branch 'master' of git@scm.dev.nokia.troll.no:qt/qt

17 files changed, 481 insertions, 287 deletions

diff --git a/src/corelib/animation/qabstractanimation.cpp b/src/corelib/animation/qabstractanimation.cpp
index 75decf8..cf3e62d 100644
--- a/src/corelib/animation/qabstractanimation.cpp
+++ b/src/corelib/animation/qabstractanimation.cpp
@@ -620,8 +620,8 @@ void QAbstractAnimation::start(DeletionPolicy policy)
     Q_D(QAbstractAnimation);
     if (d->state == Running)
         return;
-    d->setState(Running);
     d->deleteWhenStopped = policy;
+    d->setState(Running);
 }
 
 /*!
diff --git a/src/corelib/codecs/qtextcodec_p.h b/src/corelib/codecs/qtextcodec_p.h
index 499c0f9..5c82735 100644
--- a/src/corelib/codecs/qtextcodec_p.h
+++ b/src/corelib/codecs/qtextcodec_p.h
@@ -77,6 +77,33 @@ struct QTextCodecUnalignedPointer
     }
 };
 
+#else
+
+class QTextCodec
+{
+public:
+    enum ConversionFlag {
+        DefaultConversion,
+        ConvertInvalidToNull = 0x80000000,
+        IgnoreHeader = 0x1,
+        FreeFunction = 0x2
+    };
+    Q_DECLARE_FLAGS(ConversionFlags, ConversionFlag)
+
+    struct ConverterState {
+        ConverterState(ConversionFlags f = DefaultConversion)
+            : flags(f), remainingChars(0), invalidChars(0), d(0) { state_data[0] = state_data[1] = state_data[2] = 0; }
+        ~ConverterState() { }
+        ConversionFlags flags;
+        int remainingChars;
+        int invalidChars;
+        uint state_data[3];
+        void *d;
+    private:
+        Q_DISABLE_COPY(ConverterState)
+    };
+};
+
 #endif //QT_NO_TEXTCODEC
 
 QT_END_NAMESPACE
diff --git a/src/corelib/codecs/qutfcodec.cpp b/src/corelib/codecs/qutfcodec.cpp
index abae6f7..abcc07c 100644
--- a/src/corelib/codecs/qutfcodec.cpp
+++ b/src/corelib/codecs/qutfcodec.cpp
@@ -44,23 +44,19 @@
 #include "qendian.h"
 #include "qchar.h"
 
-#ifndef QT_NO_TEXTCODEC
-
 QT_BEGIN_NAMESPACE
 
-QUtf8Codec::~QUtf8Codec()
-{
-}
+enum { Endian = 0, Data = 1 };
 
-QByteArray QUtf8Codec::convertFromUnicode(const QChar *uc, int len, ConverterState *state) const
+QByteArray QUtf8::convertFromUnicode(const QChar *uc, int len, QTextCodec::ConverterState *state)
 {
     uchar replacement = '?';
     int rlen = 3*len;
     int surrogate_high = -1;
     if (state) {
-        if (state->flags & ConvertInvalidToNull)
+        if (state->flags & QTextCodec::ConvertInvalidToNull)
             replacement = 0;
-        if (!(state->flags & IgnoreHeader))
+        if (!(state->flags & QTextCodec::IgnoreHeader))
             rlen += 3;
         if (state->remainingChars)
             surrogate_high = state->state_data[0];
@@ -71,7 +67,7 @@ QByteArray QUtf8Codec::convertFromUnicode(const QChar *uc, int len, ConverterSta
     uchar* cursor = (uchar*)rstr.data();
     const QChar *ch = uc;
     int invalid = 0;
-    if (state && !(state->flags & IgnoreHeader)) {
+    if (state && !(state->flags & QTextCodec::IgnoreHeader)) {
         *cursor++ = 0xef;
         *cursor++ = 0xbb;
         *cursor++ = 0xbf;
@@ -133,7 +129,7 @@ QByteArray QUtf8Codec::convertFromUnicode(const QChar *uc, int len, ConverterSta
     rstr.resize(cursor - (const uchar*)rstr.constData());
     if (state) {
         state->invalidChars += invalid;
-        state->flags |= IgnoreHeader;
+        state->flags |= QTextCodec::IgnoreHeader;
         state->remainingChars = 0;
         if (surrogate_high >= 0) {
             state->remainingChars = 1;
@@ -143,18 +139,18 @@ QByteArray QUtf8Codec::convertFromUnicode(const QChar *uc, int len, ConverterSta
     return rstr;
 }
 
-void QUtf8Codec::convertToUnicode(QString *target, const char *chars, int len, ConverterState *state) const
+QString QUtf8::convertToUnicode(const char *chars, int len, QTextCodec::ConverterState *state)
 {
     bool headerdone = false;
-    QChar replacement = QChar::ReplacementCharacter;
+    ushort replacement = QChar::ReplacementCharacter;
     int need = 0;
     int error = -1;
     uint uc = 0;
     uint min_uc = 0;
     if (state) {
-        if (state->flags & IgnoreHeader)
+        if (state->flags & QTextCodec::IgnoreHeader)
             headerdone = true;
-        if (state->flags & ConvertInvalidToNull)
+        if (state->flags & QTextCodec::ConvertInvalidToNull)
             replacement = QChar::Null;
         need = state->remainingChars;
         if (need) {
@@ -170,40 +166,28 @@ void QUtf8Codec::convertToUnicode(QString *target, const char *chars, int len, C
         headerdone = true;
     }
 
-    int originalLength = target->length();
-    QString &result = *target;
-    result.resize(originalLength + len + 1); // worst case
-    QChar *qch = result.data() + originalLength;
+    QString result(need + len + 1, Qt::Uninitialized); // worst case
+    ushort *qch = (ushort *)result.unicode();
     uchar ch;
     int invalid = 0;
 
-    for (int i=0; i<len; i++) {
+    for (int i = 0; i < len; ++i) {
         ch = chars[i];
         if (need) {
             if ((ch&0xc0) == 0x80) {
                 uc = (uc << 6) | (ch & 0x3f);
-                need--;
+                --need;
                 if (!need) {
                     // utf-8 bom composes into 0xfeff code point
                     if (!headerdone && uc == 0xfeff) {
                         // dont do anything, just skip the BOM
                     } else if (uc > 0xffff && uc < 0x110000) {
                         // surrogate pair
-                        uc -= 0x10000;
-                        unsigned short high = uc/0x400 + 0xd800;
-                        unsigned short low = uc%0x400 + 0xdc00;
-
-                        // resize if necessary
-                        long where = qch - result.unicode();
-                        if (where + 2 >= result.length()) {
-                            result.resize(where + 2);
-                            qch = result.data() + where;
-                        }
-
-                        *qch++ = QChar(high);
-                        *qch++ = QChar(low);
+                        Q_ASSERT((qch - (ushort*)result.unicode()) + 2 < result.length());
+                        *qch++ = QChar::highSurrogate(uc);
+                        *qch++ = QChar::lowSurrogate(uc);
                     } else if ((uc < min_uc) || (uc >= 0xd800 && uc <= 0xdfff) || (uc >= 0xfffe)) {
-                        // error
+                        // error: overlong sequence, UTF16 surrogate or BOM
                         *qch++ = replacement;
                         ++invalid;
                     } else {
@@ -221,7 +205,7 @@ void QUtf8Codec::convertToUnicode(QString *target, const char *chars, int len, C
             }
         } else {
             if (ch < 128) {
-                *qch++ = QLatin1Char(ch);
+                *qch++ = ushort(ch);
                 headerdone = true;
             } else if ((ch & 0xe0) == 0xc0) {
                 uc = ch & 0x1f;
@@ -255,57 +239,35 @@ void QUtf8Codec::convertToUnicode(QString *target, const char *chars, int len, C
             ++invalid;
         }
     }
-    result.truncate(qch - result.unicode());
+    result.truncate(qch - (ushort *)result.unicode());
     if (state) {
         state->invalidChars += invalid;
         state->remainingChars = need;
         if (headerdone)
-            state->flags |= IgnoreHeader;
+            state->flags |= QTextCodec::IgnoreHeader;
         state->state_data[0] = need ? uc : 0;
         state->state_data[1] = need ? min_uc : 0;
     }
-}
-
-QString QUtf8Codec::convertToUnicode(const char *chars, int len, ConverterState *state) const
-{
-    QString result;
-    convertToUnicode(&result, chars, len, state);
     return result;
 }
 
-QByteArray QUtf8Codec::name() const
-{
-    return "UTF-8";
-}
-
-int QUtf8Codec::mibEnum() const
-{
-    return 106;
-}
-
-enum { Endian = 0, Data = 1 };
-
-QUtf16Codec::~QUtf16Codec()
-{
-}
-
-QByteArray QUtf16Codec::convertFromUnicode(const QChar *uc, int len, ConverterState *state) const
+QByteArray QUtf16::convertFromUnicode(const QChar *uc, int len, QTextCodec::ConverterState *state, DataEndianness e)
 {
-    Endianness endian = e;
+    DataEndianness endian = e;
     int length =  2*len;
-    if (!state || (!(state->flags & IgnoreHeader))) {
+    if (!state || (!(state->flags & QTextCodec::IgnoreHeader))) {
         length += 2;
     }
-    if (e == Detect) {
-        endian = (QSysInfo::ByteOrder == QSysInfo::BigEndian) ? BE : LE;
+    if (e == DetectEndianness) {
+        endian = (QSysInfo::ByteOrder == QSysInfo::BigEndian) ? BigEndianness : LittleEndianness;
     }
 
     QByteArray d;
     d.resize(length);
     char *data = d.data();
-    if (!state || !(state->flags & IgnoreHeader)) {
+    if (!state || !(state->flags & QTextCodec::IgnoreHeader)) {
         QChar bom(QChar::ByteOrderMark);
-        if (endian == BE) {
+        if (endian == BigEndianness) {
             data[0] = bom.row();
             data[1] = bom.cell();
         } else {
@@ -314,7 +276,7 @@ QByteArray QUtf16Codec::convertFromUnicode(const QChar *uc, int len, ConverterSt
         }
         data += 2;
     }
-    if (endian == BE) {
+    if (endian == BigEndianness) {
         for (int i = 0; i < len; ++i) {
             *(data++) = uc[i].row();
             *(data++) = uc[i].cell();
@@ -328,35 +290,35 @@ QByteArray QUtf16Codec::convertFromUnicode(const QChar *uc, int len, ConverterSt
 
     if (state) {
         state->remainingChars = 0;
-        state->flags |= IgnoreHeader;
+        state->flags |= QTextCodec::IgnoreHeader;
     }
     return d;
 }
 
-QString QUtf16Codec::convertToUnicode(const char *chars, int len, ConverterState *state) const
+QString QUtf16::convertToUnicode(const char *chars, int len, QTextCodec::ConverterState *state, DataEndianness e)
 {
-    Endianness endian = e;
+    DataEndianness endian = e;
     bool half = false;
     uchar buf = 0;
     bool headerdone = false;
     if (state) {
-        headerdone = state->flags & IgnoreHeader;
-        if (endian == Detect)
-            endian = (Endianness)state->state_data[Endian];
+        headerdone = state->flags & QTextCodec::IgnoreHeader;
+        if (endian == DetectEndianness)
+            endian = (DataEndianness)state->state_data[Endian];
         if (state->remainingChars) {
             half = true;
             buf = state->state_data[Data];
         }
     }
-    if (headerdone && endian == Detect)
-        endian = (QSysInfo::ByteOrder == QSysInfo::BigEndian) ? BE : LE;
+    if (headerdone && endian == DetectEndianness)
+        endian = (QSysInfo::ByteOrder == QSysInfo::BigEndian) ? BigEndianness : LittleEndianness;
 
     QString result(len, Qt::Uninitialized); // worst case
     QChar *qch = (QChar *)result.unicode();
     while (len--) {
         if (half) {
             QChar ch;
-            if (endian == LE) {
+            if (endian == LittleEndianness) {
                 ch.setRow(*chars++);
                 ch.setCell(buf);
             } else {
@@ -364,17 +326,17 @@ QString QUtf16Codec::convertToUnicode(const char *chars, int len, ConverterState
                 ch.setCell(*chars++);
             }
             if (!headerdone) {
-                if (endian == Detect) {
-                    if (ch == QChar::ByteOrderSwapped && endian != BE) {
-                        endian = LE;
-                    } else if (ch == QChar::ByteOrderMark && endian != LE) {
+                if (endian == DetectEndianness) {
+                    if (ch == QChar::ByteOrderSwapped && endian != BigEndianness) {
+                        endian = LittleEndianness;
+                    } else if (ch == QChar::ByteOrderMark && endian != LittleEndianness) {
                         // ignore BOM
-                        endian = BE;
+                        endian = BigEndianness;
                     } else {
                         if (QSysInfo::ByteOrder == QSysInfo::BigEndian) {
-                            endian = BE;
+                            endian = BigEndianness;
                         } else {
-                            endian = LE;
+                            endian = LittleEndianness;
                             ch = QChar((ch.unicode() >> 8) | ((ch.unicode() & 0xff) << 8));
                         }
                         *qch++ = ch;
@@ -396,7 +358,7 @@ QString QUtf16Codec::convertToUnicode(const char *chars, int len, ConverterState
 
     if (state) {
         if (headerdone)
-            state->flags |= IgnoreHeader;
+            state->flags |= QTextCodec::IgnoreHeader;
         state->state_data[Endian] = endian;
         if (half) {
             state->remainingChars = 1;
@@ -409,72 +371,21 @@ QString QUtf16Codec::convertToUnicode(const char *chars, int len, ConverterState
     return result;
 }
 
-int QUtf16Codec::mibEnum() const
-{
-    return 1015;
-}
-
-QByteArray QUtf16Codec::name() const
-{
-    return "UTF-16";
-}
-
-QList<QByteArray> QUtf16Codec::aliases() const
-{
-    return QList<QByteArray>();
-}
-
-int QUtf16BECodec::mibEnum() const
-{
-    return 1013;
-}
-
-QByteArray QUtf16BECodec::name() const
-{
-    return "UTF-16BE";
-}
-
-QList<QByteArray> QUtf16BECodec::aliases() const
-{
-    QList<QByteArray> list;
-    return list;
-}
-
-int QUtf16LECodec::mibEnum() const
-{
-    return 1014;
-}
-
-QByteArray QUtf16LECodec::name() const
-{
-    return "UTF-16LE";
-}
-
-QList<QByteArray> QUtf16LECodec::aliases() const
-{
-    QList<QByteArray> list;
-    return list;
-}
-
-QUtf32Codec::~QUtf32Codec()
-{
-}
-
-QByteArray QUtf32Codec::convertFromUnicode(const QChar *uc, int len, ConverterState *state) const
+QByteArray QUtf32::convertFromUnicode(const QChar *uc, int len, QTextCodec::ConverterState *state, DataEndianness e)
 {
-    Endianness endian = e;
+    DataEndianness endian = e;
     int length =  4*len;
-    if (!state || (!(state->flags & IgnoreHeader))) {
+    if (!state || (!(state->flags & QTextCodec::IgnoreHeader))) {
         length += 4;
     }
-    if (e == Detect) {
-        endian = (QSysInfo::ByteOrder == QSysInfo::BigEndian) ? BE : LE;
+    if (e == DetectEndianness) {
+        endian = (QSysInfo::ByteOrder == QSysInfo::BigEndian) ? BigEndianness : LittleEndianness;
     }
 
     QByteArray d(length, Qt::Uninitialized);
     char *data = d.data();
-    if (!state || !(state->flags & IgnoreHeader)) {
-        if (endian == BE) {
+    if (!state || !(state->flags & QTextCodec::IgnoreHeader)) {
+        if (endian == BigEndianness) {
             data[0] = 0;
             data[1] = 0;
             data[2] = (char)0xfe;
@@ -487,7 +398,7 @@ QByteArray QUtf32Codec::convertFromUnicode(const QChar *uc, int len, ConverterSt
         }
         data += 4;
     }
-    if (endian == BE) {
+    if (endian == BigEndianness) {
         for (int i = 0; i < len; ++i) {
             uint cp = uc[i].unicode();
             if (uc[i].isHighSurrogate() && i < len - 1)
@@ -511,59 +422,59 @@ QByteArray QUtf32Codec::convertFromUnicode(const QChar *uc, int len, ConverterSt
 
     if (state) {
         state->remainingChars = 0;
-        state->flags |= IgnoreHeader;
+        state->flags |= QTextCodec::IgnoreHeader;
     }
     return d;
 }
 
-QString QUtf32Codec::convertToUnicode(const char *chars, int len, ConverterState *state) const
+QString QUtf32::convertToUnicode(const char *chars, int len, QTextCodec::ConverterState *state, DataEndianness e)
 {
-    Endianness endian = e;
+    DataEndianness endian = e;
     uchar tuple[4];
     int num = 0;
     bool headerdone = false;
     if (state) {
-        headerdone = state->flags & IgnoreHeader;
-        if (endian == Detect) {
-            endian = (Endianness)state->state_data[Endian];
+        headerdone = state->flags & QTextCodec::IgnoreHeader;
+        if (endian == DetectEndianness) {
+            endian = (DataEndianness)state->state_data[Endian];
         }
         num = state->remainingChars;
         memcpy(tuple, &state->state_data[Data], 4);
     }
-    if (headerdone && endian == Detect)
-        endian = (QSysInfo::ByteOrder == QSysInfo::BigEndian) ? BE : LE;
+    if (headerdone && endian == DetectEndianness)
+        endian = (QSysInfo::ByteOrder == QSysInfo::BigEndian) ? BigEndianness : LittleEndianness;
 
     QString result;
     result.resize((num + len) >> 2 << 1); // worst case
     QChar *qch = (QChar *)result.unicode();
-    
+
     const char *end = chars + len;
     while (chars < end) {
         tuple[num++] = *chars++;
         if (num == 4) {
             if (!headerdone) {
-                if (endian == Detect) {
-                    if (endian == Detect) {
-                        if (tuple[0] == 0xff && tuple[1] == 0xfe && tuple[2] == 0 && tuple[3] == 0 && endian != BE) {
-                            endian = LE;
+                if (endian == DetectEndianness) {
+                    if (endian == DetectEndianness) {
+                        if (tuple[0] == 0xff && tuple[1] == 0xfe && tuple[2] == 0 && tuple[3] == 0 && endian != BigEndianness) {
+                            endian = LittleEndianness;
                             num = 0;
                             continue;
-                        } else if (tuple[0] == 0 && tuple[1] == 0 && tuple[2] == 0xfe && tuple[3] == 0xff && endian != LE) {
-                            endian = BE;
+                        } else if (tuple[0] == 0 && tuple[1] == 0 && tuple[2] == 0xfe && tuple[3] == 0xff && endian != LittleEndianness) {
+                            endian = BigEndianness;
                             num = 0;
                             continue;
                         } else if (QSysInfo::ByteOrder == QSysInfo::BigEndian) {
-                            endian = BE;
+                            endian = BigEndianness;
                         } else {
-                            endian = LE;
+                            endian = LittleEndianness;
                         }
                     }
-                } else if (((endian == BE) ? qFromBigEndian<quint32>(tuple) : qFromLittleEndian<quint32>(tuple)) == QChar::ByteOrderMark) {
+                } else if (((endian == BigEndianness) ? qFromBigEndian<quint32>(tuple) : qFromLittleEndian<quint32>(tuple)) == QChar::ByteOrderMark) {
                     num = 0;
                     continue;
                 }
             }
-            uint code = (endian == BE) ? qFromBigEndian<quint32>(tuple) : qFromLittleEndian<quint32>(tuple);
+            uint code = (endian == BigEndianness) ? qFromBigEndian<quint32>(tuple) : qFromLittleEndian<quint32>(tuple);
             if (code >= 0x10000) {
                 *qch++ = QChar::highSurrogate(code);
                 *qch++ = QChar::lowSurrogate(code);
@@ -574,10 +485,10 @@ QString QUtf32Codec::convertToUnicode(const char *chars, int len, ConverterState
         }
     }
     result.truncate(qch - result.unicode());
-    
+
     if (state) {
         if (headerdone)
-            state->flags |= IgnoreHeader;
+            state->flags |= QTextCodec::IgnoreHeader;
         state->state_data[Endian] = endian;
         state->remainingChars = num;
         memcpy(&state->state_data[Data], tuple, 4);
@@ -585,6 +496,113 @@ QString QUtf32Codec::convertToUnicode(const char *chars, int len, ConverterState
     return result;
 }
 
+
+#ifndef QT_NO_TEXTCODEC
+
+QUtf8Codec::~QUtf8Codec()
+{
+}
+
+QByteArray QUtf8Codec::convertFromUnicode(const QChar *uc, int len, ConverterState *state) const
+{
+    return QUtf8::convertFromUnicode(uc, len, state);
+}
+
+void QUtf8Codec::convertToUnicode(QString *target, const char *chars, int len, ConverterState *state) const
+{
+    *target += QUtf8::convertToUnicode(chars, len, state);
+}
+
+QString QUtf8Codec::convertToUnicode(const char *chars, int len, ConverterState *state) const
+{
+    return QUtf8::convertToUnicode(chars, len, state);
+}
+
+QByteArray QUtf8Codec::name() const
+{
+    return "UTF-8";
+}
+
+int QUtf8Codec::mibEnum() const
+{
+    return 106;
+}
+
+QUtf16Codec::~QUtf16Codec()
+{
+}
+
+QByteArray QUtf16Codec::convertFromUnicode(const QChar *uc, int len, ConverterState *state) const
+{
+    return QUtf16::convertFromUnicode(uc, len, state, e);
+}
+
+QString QUtf16Codec::convertToUnicode(const char *chars, int len, ConverterState *state) const
+{
+    return QUtf16::convertToUnicode(chars, len, state, e);
+}
+
+int QUtf16Codec::mibEnum() const
+{
+    return 1015;
+}
+
+QByteArray QUtf16Codec::name() const
+{
+    return "UTF-16";
+}
+
+QList<QByteArray> QUtf16Codec::aliases() const
+{
+    return QList<QByteArray>();
+}
+
+int QUtf16BECodec::mibEnum() const
+{
+    return 1013;
+}
+
+QByteArray QUtf16BECodec::name() const
+{
+    return "UTF-16BE";
+}
+
+QList<QByteArray> QUtf16BECodec::aliases() const
+{
+    QList<QByteArray> list;
+    return list;
+}
+
+int QUtf16LECodec::mibEnum() const
+{
+    return 1014;
+}
+
+QByteArray QUtf16LECodec::name() const
+{
+    return "UTF-16LE";
+}
+
+QList<QByteArray> QUtf16LECodec::aliases() const
+{
+    QList<QByteArray> list;
+    return list;
+}
+
+QUtf32Codec::~QUtf32Codec()
+{
+}
+
+QByteArray QUtf32Codec::convertFromUnicode(const QChar *uc, int len, ConverterState *state) const
+{
+    return QUtf32::convertFromUnicode(uc, len, state, e);
+}
+
+QString QUtf32Codec::convertToUnicode(const char *chars, int len, ConverterState *state) const
+{
+    return QUtf32::convertToUnicode(chars, len, state, e);
+}
+
 int QUtf32Codec::mibEnum() const
 {
     return 1017;
@@ -633,7 +651,6 @@ QList<QByteArray> QUtf32LECodec::aliases() const
     return list;
 }
 
+#endif //QT_NO_TEXTCODEC
 
 QT_END_NAMESPACE
-
-#endif //QT_NO_TEXTCODEC
diff --git a/src/corelib/codecs/qutfcodec_p.h b/src/corelib/codecs/qutfcodec_p.h
index 749f5be..4f8f92e 100644
--- a/src/corelib/codecs/qutfcodec_p.h
+++ b/src/corelib/codecs/qutfcodec_p.h
@@ -54,9 +54,35 @@
 //
 
 #include "QtCore/qtextcodec.h"
+#include "private/qtextcodec_p.h"
 
 QT_BEGIN_NAMESPACE
 
+enum DataEndianness
+{
+    DetectEndianness,
+    BigEndianness,
+    LittleEndianness
+};
+
+struct QUtf8
+{
+    static QString convertToUnicode(const char *, int, QTextCodec::ConverterState *);
+    static QByteArray convertFromUnicode(const QChar *, int, QTextCodec::ConverterState *);
+};
+
+struct QUtf16
+{
+    static QString convertToUnicode(const char *, int, QTextCodec::ConverterState *, DataEndianness = DetectEndianness);
+    static QByteArray convertFromUnicode(const QChar *, int, QTextCodec::ConverterState *, DataEndianness = DetectEndianness);
+};
+
+struct QUtf32
+{
+    static QString convertToUnicode(const char *, int, QTextCodec::ConverterState *, DataEndianness = DetectEndianness);
+    static QByteArray convertFromUnicode(const QChar *, int, QTextCodec::ConverterState *, DataEndianness = DetectEndianness);
+};
+
 #ifndef QT_NO_TEXTCODEC
 
 class QUtf8Codec : public QTextCodec {
@@ -73,13 +99,8 @@ public:
 
 class QUtf16Codec : public QTextCodec {
 protected:
-    enum Endianness {
-        Detect,
-        BE,
-        LE
-    };
 public:
-    QUtf16Codec() { e = Detect; }
+    QUtf16Codec() { e = DetectEndianness; }
     ~QUtf16Codec();
 
     QByteArray name() const;
@@ -90,12 +111,12 @@ public:
     QByteArray convertFromUnicode(const QChar *, int, ConverterState *) const;
 
 protected:
-    Endianness e;
+    DataEndianness e;
 };
 
 class QUtf16BECodec : public QUtf16Codec {
 public:
-    QUtf16BECodec() : QUtf16Codec() { e = BE; }
+    QUtf16BECodec() : QUtf16Codec() { e = BigEndianness; }
     QByteArray name() const;
     QList<QByteArray> aliases() const;
     int mibEnum() const;
@@ -103,21 +124,15 @@ public:
 
 class QUtf16LECodec : public QUtf16Codec {
 public:
-    QUtf16LECodec() : QUtf16Codec() { e = LE; }
+    QUtf16LECodec() : QUtf16Codec() { e = LittleEndianness; }
     QByteArray name() const;
     QList<QByteArray> aliases() const;
     int mibEnum() const;
 };
 
 class QUtf32Codec : public QTextCodec {
-protected:
-    enum Endianness {
-        Detect,
-        BE,
-        LE
-    };
 public:
-    QUtf32Codec() { e = Detect; }
+    QUtf32Codec() { e = DetectEndianness; }
     ~QUtf32Codec();
 
     QByteArray name() const;
@@ -128,12 +143,12 @@ public:
     QByteArray convertFromUnicode(const QChar *, int, ConverterState *) const;
 
 protected:
-    Endianness e;
+    DataEndianness e;
 };
 
 class QUtf32BECodec : public QUtf32Codec {
 public:
-    QUtf32BECodec() : QUtf32Codec() { e = BE; }
+    QUtf32BECodec() : QUtf32Codec() { e = BigEndianness; }
     QByteArray name() const;
     QList<QByteArray> aliases() const;
     int mibEnum() const;
@@ -141,7 +156,7 @@ public:
 
 class QUtf32LECodec : public QUtf32Codec {
 public:
-    QUtf32LECodec() : QUtf32Codec() { e = LE; }
+    QUtf32LECodec() : QUtf32Codec() { e = LittleEndianness; }
     QByteArray name() const;
     QList<QByteArray> aliases() const;
     int mibEnum() const;
diff --git a/src/corelib/global/qnamespace.h b/src/corelib/global/qnamespace.h
index e0584e5..077e4ef 100644
--- a/src/corelib/global/qnamespace.h
+++ b/src/corelib/global/qnamespace.h
@@ -1410,7 +1410,8 @@ public:
         ToolButtonIconOnly,
         ToolButtonTextOnly,
         ToolButtonTextBesideIcon,
-        ToolButtonTextUnderIcon
+        ToolButtonTextUnderIcon,
+        ToolButtonSystemDefault
     };
 
     enum LayoutDirection {
diff --git a/src/corelib/io/qfsfileengine.cpp b/src/corelib/io/qfsfileengine.cpp
index beafe72..3a43ec7 100644
--- a/src/corelib/io/qfsfileengine.cpp
+++ b/src/corelib/io/qfsfileengine.cpp
@@ -44,6 +44,7 @@
 #include "qdatetime.h"
 #include "qdiriterator.h"
 #include "qset.h"
+#include <QtCore/qdebug.h>
 
 #ifndef QT_NO_FSFILEENGINE
 
@@ -571,7 +572,7 @@ bool QFSFileEnginePrivate::seekFdFh(qint64 pos)
     } else {
         // Unbuffered stdio mode.
         if (QT_LSEEK(fd, pos, SEEK_SET) == -1) {
-            qWarning("QFile::at: Cannot set file position %lld", pos);
+            qWarning() << "QFile::at: Cannot set file position" << pos;
             q->setError(QFile::PositionError, qt_error_string(errno));
             return false;
         }
diff --git a/src/corelib/kernel/qcore_unix.cpp b/src/corelib/kernel/qcore_unix.cpp
index b04abae..c5b0fc7 100644
--- a/src/corelib/kernel/qcore_unix.cpp
+++ b/src/corelib/kernel/qcore_unix.cpp
@@ -34,7 +34,7 @@
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
-** contact the sales department at qt-sales@nokia.com.
+** contact the sales department at http://www.qtsoftware.com/contact.
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/
diff --git a/src/corelib/kernel/qcoreevent.cpp b/src/corelib/kernel/qcoreevent.cpp
index c636716..a682fad9 100644
--- a/src/corelib/kernel/qcoreevent.cpp
+++ b/src/corelib/kernel/qcoreevent.cpp
@@ -219,6 +219,7 @@ QT_BEGIN_NAMESPACE
     \value WindowStateChange                The \l{QWidget::windowState()}{window's state} (minimized, maximized or full-screen) has changed (QWindowStateChangeEvent).
     \value WindowTitleChange                The window title has changed.
     \value WindowUnblocked                  The window is unblocked after a modal dialog exited.
+    \value Wrapped                          The event is a wrapper for, i.e., contains, another event (QWrappedEvent).
     \value ZOrderChange                     The widget's z-order has changed. This event is never sent to top level windows.
     \value KeyboardLayoutChange             The keyboard layout has changed.
     \value DynamicPropertyChange            A dynamic property was added, changed or removed from the object.
@@ -267,7 +268,6 @@ QT_BEGIN_NAMESPACE
     \omitvalue NetworkReplyUpdated
     \omitvalue FutureCallOut
     \omitvalue CocoaRequestModal
-    \omitvalue Wrapped
     \omitvalue Signal
     \omitvalue WinGesture
 */
diff --git a/src/corelib/kernel/qmetatype.cpp b/src/corelib/kernel/qmetatype.cpp
index 91266db..6d9daec 100644
--- a/src/corelib/kernel/qmetatype.cpp
+++ b/src/corelib/kernel/qmetatype.cpp
@@ -430,16 +430,15 @@ int QMetaType::registerType(const char *typeName, Destructor destructor,
 #endif
 
     QWriteLocker locker(customTypesLock());
-    static int currentIdx = User;
     int idx = qMetaTypeType_unlocked(normalizedTypeName);
 
     if (!idx) {
-        idx = currentIdx++;
-        ct->resize(ct->count() + 1);
-        QCustomTypeInfo &inf = (*ct)[idx - User];
+        QCustomTypeInfo inf;
         inf.typeName = normalizedTypeName;
         inf.constr = constructor;
         inf.destr = destructor;
+        idx = ct->size() + User;
+        ct->append(inf);
     }
     return idx;
 }
diff --git a/src/corelib/kernel/qsharedmemory_unix.cpp b/src/corelib/kernel/qsharedmemory_unix.cpp
index 04739ff..05369c4 100644
--- a/src/corelib/kernel/qsharedmemory_unix.cpp
+++ b/src/corelib/kernel/qsharedmemory_unix.cpp
@@ -85,7 +85,7 @@ void QSharedMemoryPrivate::setErrorString(const QString &function)
         error = QSharedMemory::AlreadyExists;
         break;
     case ENOENT:
-        errorString = QSharedMemory::tr("%1: doesn't exists").arg(function);
+        errorString = QSharedMemory::tr("%1: doesn't exist").arg(function);
         error = QSharedMemory::NotFound;
         break;
     case EMFILE:
@@ -124,7 +124,7 @@ key_t QSharedMemoryPrivate::handle()
     // ftok requires that an actual file exists somewhere
     QString fileName = makePlatformSafeKey(key);
     if (!QFile::exists(fileName)) {
-        errorString = QSharedMemory::tr("%1: unix key file doesn't exists").arg(QLatin1String("QSharedMemory::handle:"));
+        errorString = QSharedMemory::tr("%1: UNIX key file doesn't exist").arg(QLatin1String("QSharedMemory::handle:"));
         error = QSharedMemory::NotFound;
         return 0;
     }
diff --git a/src/corelib/kernel/qsharedmemory_win.cpp b/src/corelib/kernel/qsharedmemory_win.cpp
index c88149a..ae64806 100644
--- a/src/corelib/kernel/qsharedmemory_win.cpp
+++ b/src/corelib/kernel/qsharedmemory_win.cpp
@@ -71,7 +71,7 @@ void QSharedMemoryPrivate::setErrorString(const QString &function)
     case ERROR_INVALID_PARAMETER:
 #endif
         error = QSharedMemory::NotFound;
-        errorString = QSharedMemory::tr("%1: doesn't exists").arg(function);
+        errorString = QSharedMemory::tr("%1: doesn't exist").arg(function);
         break;
     case ERROR_COMMITMENT_LIMIT:
         error = QSharedMemory::InvalidSize;
diff --git a/src/corelib/statemachine/qabstracttransition.cpp b/src/corelib/statemachine/qabstracttransition.cpp
index 670aa7d..c040c58 100644
--- a/src/corelib/statemachine/qabstracttransition.cpp
+++ b/src/corelib/statemachine/qabstracttransition.cpp
@@ -330,6 +330,18 @@ QList<QAbstractAnimation*> QAbstractTransition::animations() const
   This function is called to determine whether the given \a event should cause
   this transition to trigger. Reimplement this function and return true if the
   event should trigger the transition, otherwise return false.
+
+
+  Note that \a event is a QWrappedEvent, which contains a clone of 
+  the event generated by Qt. For instance, if you want to check a
+  key press event, do the following:
+
+  \snippet doc/src/snippets/statemachine/eventtest.cpp 0
+
+  You need to check if \a event is a QWrappedEvent because Qt also
+  uses other events for internal reasons; you don't need to concern
+  yourself with these in any case.
+
 */
 
 /*!
diff --git a/src/corelib/tools/qbytedata_p.h b/src/corelib/tools/qbytedata_p.h
new file mode 100644
index 0000000..e8a4ddd
--- /dev/null
+++ b/src/corelib/tools/qbytedata_p.h
@@ -0,0 +1,200 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** 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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at http://www.qtsoftware.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QBYTEDATA_H
+#define QBYTEDATA_H
+
+#include <qbytearray.h>
+
+
+// this class handles a list of QByteArrays. It is a variant of QRingBuffer
+// that avoid malloc/realloc/memcpy.
+class QByteDataBuffer
+{
+private:
+    QList<QByteArray> buffers;
+    qint64 bufferCompleteSize;
+public:
+    QByteDataBuffer() : bufferCompleteSize(0)
+    {
+    }
+
+    ~QByteDataBuffer()
+    {
+        clear();
+    }
+
+    inline void append(QByteDataBuffer& other)
+    {
+        if (other.isEmpty())
+            return;
+
+        buffers.append(other.buffers);
+        bufferCompleteSize += other.byteAmount();
+    }
+
+
+    inline void append(QByteArray& bd)
+    {
+        if (bd.isEmpty())
+            return;
+
+        buffers.append(bd);
+        bufferCompleteSize += bd.size();
+    }
+
+    inline void prepend(QByteArray& bd)
+    {
+        if (bd.isEmpty())
+            return;
+
+        buffers.prepend(bd);
+        bufferCompleteSize += bd.size();
+    }
+
+    // return the first QByteData. User of this function has to qFree() its .data!
+    // preferably use this function to read data.
+    inline QByteArray read()
+    {
+        bufferCompleteSize -= buffers.first().size();
+        return buffers.takeFirst();
+    }
+
+    // return everything. User of this function has to qFree() its .data!
+    // avoid to use this, it might malloc and memcpy.
+    inline QByteArray readAll()
+    {
+        return read(byteAmount());
+    }
+
+    // return amount. User of this function has to qFree() its .data!
+    // avoid to use this, it might malloc and memcpy.
+    inline QByteArray read(qint64 amount)
+    {
+        amount = qMin(byteAmount(), amount);
+        QByteArray byteData;
+        byteData.resize(amount);
+        read(byteData.data(), byteData.size());
+        return byteData;
+    }
+
+    // return amount bytes. User of this function has to qFree() its .data!
+    // avoid to use this, it will memcpy.
+    qint64 read(char* dst, qint64 amount)
+    {
+        amount = qMin(amount, byteAmount());
+        qint64 originalAmount = amount;
+        char *writeDst = dst;
+
+        while (amount > 0) {
+            QByteArray first = buffers.takeFirst();
+            if (amount >= first.size()) {
+                // take it completely
+                bufferCompleteSize -= first.size();
+                amount -= first.size();
+                memcpy(writeDst, first.constData(), first.size());
+                writeDst += first.size();
+                first.clear();
+            } else {
+                // take a part of it & it is the last one to take
+                bufferCompleteSize -= amount;
+                memcpy(writeDst, first.constData(), amount);
+
+                qint64 newFirstSize = first.size() - amount;
+                QByteArray newFirstData;
+                newFirstData.resize(newFirstSize);
+                memcpy(newFirstData.data(), first.constData() + amount, newFirstSize);
+                buffers.prepend(newFirstData);
+
+                amount = 0;
+                first.clear();
+            }
+        }
+
+        return originalAmount;
+    }
+
+    inline char getChar()
+    {
+        char c;
+        read(&c, 1);
+        return c;
+    }
+
+    inline void clear()
+    {
+        buffers.clear();
+        bufferCompleteSize = 0;
+    }
+
+    // The byte count of all QByteArrays
+    inline qint64 byteAmount() const
+    {
+        return bufferCompleteSize;
+    }
+
+    // the number of QByteArrays
+    inline qint64 bufferCount() const
+    {
+        return buffers.length();
+    }
+
+    inline bool isEmpty() const
+    {
+        return byteAmount() == 0;
+    }
+
+    inline qint64 sizeNextBlock() const
+    {
+        if(buffers.isEmpty())
+            return 0;
+        else
+            return buffers.first().size();
+    }
+
+    inline QByteArray& operator[](int i)
+    {
+        return buffers[i];
+    }
+};
+
+
+#endif // QBYTEDATA_H
diff --git a/src/corelib/tools/qregexp.cpp b/src/corelib/tools/qregexp.cpp
index d43be3e..1e502ff 100644
--- a/src/corelib/tools/qregexp.cpp
+++ b/src/corelib/tools/qregexp.cpp
@@ -1488,9 +1488,8 @@ int QRegExpEngine::anchorAlternation(int a, int b)
         return Anchor_Alternation | (n - 1);
 #endif
 
-    aa.resize(n + 1);
-    aa[n].a = a;
-    aa[n].b = b;
+    QRegExpAnchorAlternation element = {a, b};
+    aa.append(element);
     return Anchor_Alternation | n;
 }
 
diff --git a/src/corelib/tools/qstring.cpp b/src/corelib/tools/qstring.cpp
index 7cca339..b97ba45 100644
--- a/src/corelib/tools/qstring.cpp
+++ b/src/corelib/tools/qstring.cpp
@@ -45,6 +45,7 @@
 #ifndef QT_NO_TEXTCODEC
 #include <qtextcodec.h>
 #endif
+#include <private/qutfcodec_p.h>
 #include <qdatastream.h>
 #include <qlist.h>
 #include "qlocale.h"
@@ -964,7 +965,8 @@ int QString::toWCharArray(wchar_t *array) const
     Constructs a string initialized with the first \a size characters
     of the QChar array \a unicode.
 
-    QString makes a deep copy of the string data.
+    QString makes a deep copy of the string data. The unicode data is copied as
+    is and the Byte Order Mark is preserved if present.
 */
 QString::QString(const QChar *unicode, int size)
 {
@@ -3843,74 +3845,7 @@ QString QString::fromUtf8(const char *str, int size)
     if (size < 0)
         size = qstrlen(str);
 
-    QString result(size, Qt::Uninitialized); // worst case
-    ushort *qch = result.d->data;
-    uint uc = 0;
-    uint min_uc = 0;
-    int need = 0;
-    int error = -1;
-    uchar ch;
-    int i = 0;
-
-    // skip utf8-encoded byte order mark
-    if (size >= 3
-        && (uchar)str[0] == 0xef && (uchar)str[1] == 0xbb && (uchar)str[2] == 0xbf)
-        i += 3;
-
-    for (; i < size; ++i) {
-        ch = str[i];
-        if (need) {
-            if ((ch&0xc0) == 0x80) {
-                uc = (uc << 6) | (ch & 0x3f);
-                need--;
-                if (!need) {
-                    if (uc > 0xffffU && uc < 0x110000U) {
-                        // surrogate pair
-                        *qch++ = QChar::highSurrogate(uc);
-                        uc = QChar::lowSurrogate(uc);
-                    } else if ((uc < min_uc) || (uc >= 0xd800 && uc <= 0xdfff) || (uc >= 0xfffe)) {
-			// overlong seqence, UTF16 surrogate or BOM
-                        uc = QChar::ReplacementCharacter;
-                    }
-                    *qch++ = uc;
-                }
-            } else {
-                i = error;
-                need = 0;
-                *qch++ = QChar::ReplacementCharacter;
-            }
-        } else {
-            if (ch < 128) {
-                *qch++ = ch;
-            } else if ((ch & 0xe0) == 0xc0) {
-                uc = ch & 0x1f;
-                need = 1;
-                error = i;
-                min_uc = 0x80;
-            } else if ((ch & 0xf0) == 0xe0) {
-                uc = ch & 0x0f;
-                need = 2;
-                error = i;
-                min_uc = 0x800;
-            } else if ((ch&0xf8) == 0xf0) {
-                uc = ch & 0x07;
-                need = 3;
-                error = i;
-                min_uc = 0x10000;
-            } else {
-                // Error
-                *qch++ = QChar::ReplacementCharacter;
-            }
-        }
-    }
-    if (need) {
-        // we have some invalid characters remaining we need to add to the string
-        for (int i = error; i < size; ++i)
-            *qch++ = QChar::ReplacementCharacter;
-    }
-
-    result.truncate(qch - result.d->data);
-    return result;
+    return QUtf8::convertToUnicode(str, size, 0);
 }
 
 /*!
@@ -3933,7 +3868,7 @@ QString QString::fromUtf16(const ushort *unicode, int size)
         while (unicode[size] != 0)
             ++size;
     }
-    return QString((const QChar *)unicode, size);
+    return QUtf16::convertToUnicode((const char *)unicode, size*2, 0);
 }
 
 
@@ -3957,20 +3892,7 @@ QString QString::fromUcs4(const uint *unicode, int size)
         while (unicode[size] != 0)
             ++size;
     }
-
-    QString s(size * 2, Qt::Uninitialized); // worst case
-    ushort *uc = s.d->data;
-    for (int i = 0; i < size; ++i) {
-        uint u = unicode[i];
-        if (u > 0xffff) {
-            // decompose into a surrogate pair
-            *uc++ = QChar::highSurrogate(u);
-            u = QChar::lowSurrogate(u);
-        }
-        *uc++ = u;
-    }
-    s.resize(uc - s.d->data);
-    return s;
+    return QUtf32::convertToUnicode((const char *)unicode, size*4, 0);
 }
 
 /*!
@@ -6551,7 +6473,7 @@ QString QString::arg(qlonglong a, int fieldWidth, int base, const QChar &fillCha
     ArgEscapeData d = findArgEscapes(*this);
 
     if (d.occurrences == 0) {
-        qWarning("QString::arg: Argument missing: %s, %lld", toLocal8Bit().data(), a);
+        qWarning() << "QString::arg: Argument missing:" << *this << ',' << a;
         return *this;
     }
 
@@ -6594,7 +6516,7 @@ QString QString::arg(qulonglong a, int fieldWidth, int base, const QChar &fillCh
     ArgEscapeData d = findArgEscapes(*this);
 
     if (d.occurrences == 0) {
-        qWarning("QString::arg: Argument missing: %s, %llu", toLocal8Bit().data(), a);
+        qWarning() << "QString::arg: Argument missing:" << *this << ',' << a;
         return *this;
     }
 
diff --git a/src/corelib/tools/tools.pri b/src/corelib/tools/tools.pri
index c93a065..08c94ac 100644
--- a/src/corelib/tools/tools.pri
+++ b/src/corelib/tools/tools.pri
@@ -5,6 +5,7 @@ HEADERS +=  \
 	tools/qbitarray.h \
 	tools/qbytearray.h \
 	tools/qbytearraymatcher.h \
+        tools/qbytedata_p.h \
 	tools/qcache.h \
 	tools/qchar.h \
 	tools/qcontainerfwd.h \
diff --git a/src/corelib/xml/qxmlstream.cpp b/src/corelib/xml/qxmlstream.cpp
index 1fc2a9f..42ed04e 100644
--- a/src/corelib/xml/qxmlstream.cpp
+++ b/src/corelib/xml/qxmlstream.cpp
@@ -568,7 +568,7 @@ bool QXmlStreamReader::atEnd() const
   returns true, hasError() returns true, and this function returns
   QXmlStreamReader::Invalid.
 
-  The exception is when error() return PrematureEndOfDocumentError.
+  The exception is when error() returns PrematureEndOfDocumentError.
   This error is reported when the end of an otherwise well-formed
   chunk of XML is reached, but the chunk doesn't represent a complete
   XML document.  In that case, parsing \e can be resumed by calling