Merge commit 'qt-mainline/master'

32 files changed, 2625 insertions, 1476 deletions

diff --git a/src/corelib/tools/qbytearray.cpp b/src/corelib/tools/qbytearray.cpp
index 6aa35f3..49dd52d 100644
--- a/src/corelib/tools/qbytearray.cpp
+++ b/src/corelib/tools/qbytearray.cpp
@@ -579,7 +579,7 @@ static inline char qToLower(char c)
         return c;
 }
 
-Q_CORE_EXPORT QByteArray::Data QByteArray::shared_null = {Q_BASIC_ATOMIC_INITIALIZER(1),
+QByteArray::Data QByteArray::shared_null = {Q_BASIC_ATOMIC_INITIALIZER(1),
                                                           0, 0, shared_null.array, {0} };
 QByteArray::Data QByteArray::shared_empty = { Q_BASIC_ATOMIC_INITIALIZER(1),
                                               0, 0, shared_empty.array, {0} };
diff --git a/src/corelib/tools/qbytearraymatcher.h b/src/corelib/tools/qbytearraymatcher.h
index 633e92c..970cbcc 100644
--- a/src/corelib/tools/qbytearraymatcher.h
+++ b/src/corelib/tools/qbytearraymatcher.h
@@ -70,7 +70,7 @@ public:
     inline QByteArray pattern() const
     {
         if (q_pattern.isNull())
-            return QByteArray((const char*)p.p, p.l);
+            return QByteArray(reinterpret_cast<const char*>(p.p), p.l);
         return q_pattern;
     }
 
diff --git a/src/corelib/tools/qcontiguouscache.cpp b/src/corelib/tools/qcontiguouscache.cpp
new file mode 100644
index 0000000..996ac18
--- /dev/null
+++ b/src/corelib/tools/qcontiguouscache.cpp
@@ -0,0 +1,439 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qcontiguouscache.h"
+#ifdef QT_QCONTIGUOUSCACHE_DEBUG
+#include <QDebug>
+#endif
+
+QT_BEGIN_NAMESPACE
+
+#ifdef QT_QCONTIGUOUSCACHE_DEBUG
+void QContiguousCacheData::dump() const
+{
+    qDebug() << "capacity:" << alloc;
+    qDebug() << "count:" << count;
+    qDebug() << "start:" << start;
+    qDebug() << "offset:" << offset;
+}
+#endif
+
+/*! \class QContiguousCache
+    \brief The QContiguousCache class is a template class that provides a contiguous cache.
+    \ingroup tools
+    \ingroup shared
+    \reentrant
+
+    The QContiguousCache class provides an efficient way of caching items for
+    display in a user interface view.  Unlike QCache, it adds a restriction
+    that elements within the cache are contiguous.  This has the advantage
+    of matching how user interface views most commonly request data, as
+    a set of rows localized around the current scrolled position.  This
+    restriction allows the cache to consume less memory and processor
+    cycles than QCache.  The QContiguousCache class also can provide
+    an upper bound on memory usage via setCapacity().
+
+    The simplest way of using a contiguous cache is to use the append()
+    and prepend().
+
+\code
+MyRecord record(int row) const
+{
+    Q_ASSERT(row >= 0 && row < count());
+
+    while(row > cache.lastIndex())
+        cache.append(slowFetchRecord(cache.lastIndex()+1));
+    while(row < cache.firstIndex())
+        cache.prepend(slowFetchRecord(cache.firstIndex()-1));
+
+    return cache.at(row);
+}
+\endcode
+
+    If the cache is full then the item at the opposite end of the cache from
+    where the new item is appended or prepended will be removed.
+
+    This usage can be further optimized by using the insert() function
+    in the case where the requested row is a long way from the currently cached
+    items. If there is a gap between where the new item is inserted and the currently
+    cached items then the existing cached items are first removed to retain
+    the contiguous nature of the cache.  Hence it is important to take some care then
+    when using insert() in order to avoid unwanted clearing of the cache.
+
+    The range of valid indexes for the QContiguousCache class are from
+    0 to INT_MAX.  Calling prepend() such that the first index would become less
+    than 0 or append() such that the last index would become greater
+    than INT_MAX can result in the indexes of the cache being invalid.
+    When the cache indexes are invalid it is important to call
+    normalizeIndexes() before calling any of containsIndex(), firstIndex(),
+    lastIndex(), at() or the [] operator.  Calling these
+    functions when the cache has invalid indexes will result in undefined
+    behavior.  The indexes can be checked by using areIndexesValid()
+
+    In most cases the indexes will not exceed 0 to INT_MAX, and
+    normalizeIndexes() will not need to be used.
+
+    See the \l{Contiguous Cache Example}{Contiguous Cache} example.
+*/
+
+/*! \fn QContiguousCache::QContiguousCache(int capacity)
+
+    Constructs a cache with the given \a capacity.
+
+    \sa setCapacity()
+*/
+
+/*! \fn QContiguousCache::QContiguousCache(const QContiguousCache<T> &other)
+
+    Constructs a copy of \a other.
+
+    This operation takes \l{constant time}, because QContiguousCache is
+    \l{implicitly shared}.  This makes returning a QContiguousCache from a
+    function very fast.  If a shared instance is modified, it will be
+    copied (copy-on-write), and that takes \l{linear time}.
+
+    \sa operator=()
+*/
+
+/*! \fn QContiguousCache::~QContiguousCache()
+
+    Destroys the cache.
+*/
+
+/*! \fn void QContiguousCache::detach()
+
+    \internal
+*/
+
+/*! \fn bool QContiguousCache::isDetached() const
+
+    \internal
+*/
+
+/*! \fn void QContiguousCache::setSharable(bool sharable)
+
+    \internal
+*/
+
+/*! \fn QContiguousCache<T> &QContiguousCache::operator=(const QContiguousCache<T> &other)
+
+    Assigns \a other to this cache and returns a reference to this cache.
+*/
+
+/*! \fn bool QContiguousCache::operator==(const QContiguousCache<T> &other) const
+
+    Returns true if \a other is equal to this cache; otherwise returns false.
+
+    Two caches are considered equal if they contain the same values at the same
+    indexes.  This function requires the value type to implement the \c operator==().
+
+    \sa operator!=()
+*/
+
+/*! \fn bool QContiguousCache::operator!=(const QContiguousCache<T> &other) const
+
+    Returns true if \a other is not equal to this cache; otherwise
+    returns false.
+
+    Two caches are considered equal if they contain the same values at the same
+    indexes.  This function requires the value type to implement the \c operator==().
+
+    \sa operator==()
+*/
+
+/*! \fn int QContiguousCache::capacity() const
+
+    Returns the number of items the cache can store before it is full.
+    When a cache contains a number of items equal to its capacity, adding new
+    items will cause items farthest from the added item to be removed.
+
+    \sa setCapacity(), size()
+*/
+
+/*! \fn int QContiguousCache::count() const
+
+    \overload
+
+    Same as size().
+*/
+
+/*! \fn int QContiguousCache::size() const
+
+    Returns the number of items contained within the cache.
+
+    \sa capacity()
+*/
+
+/*! \fn bool QContiguousCache::isEmpty() const
+
+    Returns true if no items are stored within the cache.
+
+    \sa size(), capacity()
+*/
+
+/*! \fn bool QContiguousCache::isFull() const
+
+    Returns true if the number of items stored within the cache is equal
+    to the capacity of the cache.
+
+    \sa size(), capacity()
+*/
+
+/*! \fn int QContiguousCache::available() const
+
+    Returns the number of items that can be added to the cache before it becomes full.
+
+    \sa size(), capacity(), isFull()
+*/
+
+/*! \fn void QContiguousCache::clear()
+
+    Removes all items from the cache.  The capacity is unchanged.
+*/
+
+/*! \fn void QContiguousCache::setCapacity(int size)
+
+    Sets the capacity of the cache to the given \a size.  A cache can hold a
+    number of items equal to its capacity.  When inserting, appending or prepending
+    items to the cache, if the cache is already full then the item farthest from
+    the added item will be removed.
+
+    If the given \a size is smaller than the current count of items in the cache
+    then only the last \a size items from the cache will remain.
+
+    \sa capacity(), isFull()
+*/
+
+/*! \fn const T &QContiguousCache::at(int i) const
+
+    Returns the item at index position \a i in the cache.  \a i must
+    be a valid index position in the cache (i.e, firstIndex() <= \a i <= lastIndex()).
+
+    The indexes in the cache refer to the number of positions the item is from the
+    first item appended into the cache.  That is to say a cache with a capacity of
+    100, that has had 150 items appended will have a valid index range of
+    50 to 149.  This allows inserting and retrieving items into the cache based
+    on a theoretical infinite list
+
+    \sa firstIndex(), lastIndex(), insert(), operator[]()
+*/
+
+/*! \fn T &QContiguousCache::operator[](int i)
+
+    Returns the item at index position \a i as a modifiable reference.  If
+    the cache does not contain an item at the given index position \a i
+    then it will first insert an empty item at that position.
+
+    In most cases it is better to use either at() or insert().
+
+    Note that using non-const operators can cause QContiguousCache to do a deep
+    copy.
+
+    \sa insert(), at()
+*/
+
+/*! \fn const T &QContiguousCache::operator[](int i) const
+
+    \overload
+
+    Same as at(\a i).
+*/
+
+/*! \fn void QContiguousCache::append(const T &value)
+
+    Inserts \a value at the end of the cache.  If the cache is already full
+    the item at the start of the cache will be removed.
+
+    \sa prepend(), insert(), isFull()
+*/
+
+/*! \fn void QContiguousCache::prepend(const T &value)
+
+    Inserts \a value at the start of the cache.  If the cache is already full
+    the item at the end of the cache will be removed.
+
+    \sa append(), insert(), isFull()
+*/
+
+/*! \fn void QContiguousCache::insert(int i, const T &value)
+
+    Inserts the \a value at the index position \a i.  If the cache already contains
+    an item at \a i then that value is replaced.  If \a i is either one more than
+    lastIndex() or one less than firstIndex() it is the equivalent to an append()
+    or a prepend().
+
+    If the given index \a i is not within the current range of the cache nor adjacent
+    to the bounds of the cache's index range, the cache is first cleared before
+    inserting the item.  At this point the cache will have a size of 1.  It is
+    worthwhile taking effort to insert items in an order that starts adjacent
+    to the current index range for the cache.
+
+    The range of valid indexes for the QContiguousCache class are from
+    0 to INT_MAX. Inserting outside of this range has undefined behavior.
+
+
+    \sa prepend(), append(), isFull(), firstIndex(), lastIndex()
+*/
+
+/*! \fn bool QContiguousCache::containsIndex(int i) const
+
+    Returns true if the cache's index range includes the given index \a i.
+
+    \sa firstIndex(), lastIndex()
+*/
+
+/*! \fn int QContiguousCache::firstIndex() const
+
+    Returns the first valid index in the cache.  The index will be invalid if the
+    cache is empty.
+
+    \sa capacity(), size(), lastIndex()
+*/
+
+/*! \fn int QContiguousCache::lastIndex() const
+
+    Returns the last valid index in the cache.  The index will be invalid if the cache is empty.
+
+    \sa capacity(), size(), firstIndex()
+*/
+
+
+/*! \fn T &QContiguousCache::first()
+
+    Returns a reference to the first item in the cache.  This function
+    assumes that the cache isn't empty.
+
+    \sa last(), isEmpty()
+*/
+
+/*! \fn T &QContiguousCache::last()
+
+    Returns a reference to the last item in the cache.  This function
+    assumes that the cache isn't empty.
+
+    \sa first(), isEmpty()
+*/
+
+/*! \fn const T& QContiguousCache::first() const
+
+    \overload
+*/
+
+/*! \fn const T& QContiguousCache::last() const
+
+    \overload
+*/
+
+/*! \fn void QContiguousCache::removeFirst()
+
+    Removes the first item from the cache.  This function assumes that
+    the cache isn't empty.
+
+    \sa removeLast()
+*/
+
+/*! \fn void QContiguousCache::removeLast()
+
+    Removes the last item from the cache.  This function assumes that
+    the cache isn't empty.
+
+    \sa removeFirst()
+*/
+
+/*! \fn T QContiguousCache::takeFirst()
+
+    Removes the first item in the cache and returns it.  This function
+    assumes that the cache isn't empty.
+
+    If you don't use the return value, removeFirst() is more efficient.
+
+    \sa takeLast(), removeFirst()
+*/
+
+/*! \fn T QContiguousCache::takeLast()
+
+    Removes the last item in the cache and returns it. This function
+    assumes that the cache isn't empty.
+
+    If you don't use the return value, removeLast() is more efficient.
+
+    \sa takeFirst(), removeLast()
+*/
+
+/*! \fn void QContiguousCache::normalizeIndexes()
+
+    Moves the first index and last index of the cache
+    such that they point to valid indexes.  The function does not modify
+    the contents of the cache or the ordering of elements within the cache.
+
+    It is provided so that index overflows can be corrected when using the
+    cache as a circular buffer.
+
+    \code
+    QContiguousCache<int> cache(10);
+    cache.insert(INT_MAX, 1); // cache contains one value and has valid indexes, INT_MAX to INT_MAX
+    cache.append(2); // cache contains two values but does not have valid indexes.
+    cache.normalizeIndexes(); // cache has two values, 1 and 2.  New first index will be in the range of 0 to capacity().
+    \endcode
+
+    \sa areIndexesValid(), append(), prepend()
+*/
+
+/*! \fn bool QContiguousCache::areIndexesValid() const
+
+    Returns whether the indexes for items stored in the cache are valid.
+    Indexes can become invalid if items are appended after the index position
+    INT_MAX or prepended before the index position 0.  This is only expected
+    to occur in very long lived circular buffer style usage of the
+    contiguous cache.  Indexes can be made valid again by calling
+    normalizeIndexs().
+
+    \sa normalizeIndexes(), append(), prepend()
+*/
+
+/*! \fn void QContiguousCache::dump() const
+
+    \internal
+
+    Sends information about the cache's internal structure to qDebug()
+*/
+
+QT_END_NAMESPACE
diff --git a/src/corelib/tools/qcontiguouscache.h b/src/corelib/tools/qcontiguouscache.h
new file mode 100644
index 0000000..2437f63
--- /dev/null
+++ b/src/corelib/tools/qcontiguouscache.h
@@ -0,0 +1,430 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QCONTIGUOUSCACHE_H
+#define QCONTIGUOUSCACHE_H
+
+#include <QtCore/qatomic.h>
+#include <limits.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+#undef QT_QCONTIGUOUSCACHE_DEBUG
+QT_MODULE(Core)
+
+
+struct Q_CORE_EXPORT QContiguousCacheData
+{
+    QBasicAtomicInt ref;
+    int alloc;
+    int count;
+    int start;
+    int offset;
+    uint sharable : 1;
+
+#ifdef QT_QCONTIGUOUSCACHE_DEBUG
+    void dump() const;
+#endif
+};
+
+template <typename T>
+struct QContiguousCacheTypedData
+{
+    QBasicAtomicInt ref;
+    int alloc;
+    int count;
+    int start;
+    int offset;
+    uint sharable : 1;
+
+    T array[1];
+};
+
+template<typename T>
+class QContiguousCache {
+    typedef QContiguousCacheTypedData<T> Data;
+    union { QContiguousCacheData *p; QContiguousCacheTypedData<T> *d; };
+public:
+    explicit QContiguousCache(int capacity = 0);
+    QContiguousCache(const QContiguousCache<T> &v) : d(v.d) { d->ref.ref(); if (!d->sharable) detach_helper(); }
+
+    inline ~QContiguousCache() { if (!d) return; if (!d->ref.deref()) free(d); }
+
+    inline void detach() { if (d->ref != 1) detach_helper(); }
+    inline bool isDetached() const { return d->ref == 1; }
+    inline void setSharable(bool sharable) { if (!sharable) detach(); d->sharable = sharable; }
+
+    QContiguousCache<T> &operator=(const QContiguousCache<T> &other);
+    bool operator==(const QContiguousCache<T> &other) const;
+    inline bool operator!=(const QContiguousCache<T> &other) const { return !(*this == other); }
+
+    inline int capacity() const {return d->alloc; }
+    inline int count() const { return d->count; }
+    inline int size() const { return d->count; }
+
+    inline bool isEmpty() const { return d->count == 0; }
+    inline bool isFull() const { return d->count == d->alloc; }
+    inline int available() const { return d->alloc - d->count; }
+
+    void clear();
+    void setCapacity(int size);
+
+    const T &at(int pos) const;
+    T &operator[](int i);
+    const T &operator[](int i) const;
+
+    void append(const T &value);
+    void prepend(const T &value);
+    void insert(int pos, const T &value);
+
+    inline bool containsIndex(int pos) const { return pos >= d->offset && pos - d->offset < d->count; }
+    inline int firstIndex() const { return d->offset; }
+    inline int lastIndex() const { return d->offset + d->count - 1; }
+
+    inline const T &first() const { Q_ASSERT(!isEmpty()); return d->array[d->start]; }
+    inline const T &last() const { Q_ASSERT(!isEmpty()); return d->array[(d->start + d->count -1) % d->alloc]; }
+    inline T &first() { Q_ASSERT(!isEmpty()); detach(); return d->array[d->start]; }
+    inline T &last() { Q_ASSERT(!isEmpty()); detach(); return d->array[(d->start + d->count -1) % d->alloc]; }
+
+    void removeFirst();
+    T takeFirst();
+    void removeLast();
+    T takeLast();
+
+    inline bool areIndexesValid() const
+    { return d->offset >= 0 && d->offset < INT_MAX - d->count && (d->offset % d->alloc) == d->start; }
+
+    inline void normalizeIndexes() { d->offset = d->start; }
+
+#ifdef QT_QCONTIGUOUSCACHE_DEBUG
+    void dump() const { p->dump(); }
+#endif
+private:
+    void detach_helper();
+
+    QContiguousCacheData *malloc(int aalloc);
+    void free(Data *x);
+    int sizeOfTypedData() {
+        // this is more or less the same as sizeof(Data), except that it doesn't
+        // count the padding at the end
+        return reinterpret_cast<const char *>(&(reinterpret_cast<const Data *>(this))->array[1]) - reinterpret_cast<const char *>(this);
+    }
+};
+
+template <typename T>
+void QContiguousCache<T>::detach_helper()
+{
+    union { QContiguousCacheData *p; QContiguousCacheTypedData<T> *d; } x;
+
+    x.p = malloc(d->alloc);
+    x.d->ref = 1;
+    x.d->count = d->count;
+    x.d->start = d->start;
+    x.d->offset = d->offset;
+    x.d->alloc = d->alloc;
+    x.d->sharable = true;
+
+    T *dest = x.d->array + x.d->start;
+    T *src = d->array + d->start;
+    int count = x.d->count;
+    while (count--) {
+        if (QTypeInfo<T>::isComplex) {
+            new (dest) T(*src);
+        } else {
+            *dest = *src;
+        }
+        dest++;
+        if (dest == x.d->array + x.d->alloc)
+            dest = x.d->array;
+        src++;
+        if (src == d->array + d->alloc)
+            src = d->array;
+    }
+
+    if (!d->ref.deref())
+        free(d);
+    d = x.d;
+}
+
+template <typename T>
+void QContiguousCache<T>::setCapacity(int asize)
+{
+    if (asize == d->alloc)
+        return;
+    detach();
+    union { QContiguousCacheData *p; QContiguousCacheTypedData<T> *d; } x;
+    x.p = malloc(asize);
+    x.d->alloc = asize;
+    x.d->count = qMin(d->count, asize);
+    x.d->offset = d->offset + d->count - x.d->count;
+    x.d->start = x.d->offset % x.d->alloc;
+    T *dest = x.d->array + (x.d->start + x.d->count-1) % x.d->alloc;
+    T *src = d->array + (d->start + d->count-1) % d->alloc;
+    int count = x.d->count;
+    while (count--) {
+        if (QTypeInfo<T>::isComplex) {
+            new (dest) T(*src);
+        } else {
+            *dest = *src;
+        }
+        if (dest == x.d->array)
+            dest = x.d->array + x.d->alloc;
+        dest--;
+        if (src == d->array)
+            src = d->array + d->alloc;
+        src--;
+    }
+    /* free old */
+    free(d);
+    d = x.d;
+}
+
+template <typename T>
+void QContiguousCache<T>::clear()
+{
+    if (d->ref == 1) {
+        if (QTypeInfo<T>::isComplex) {
+            int count = d->count;
+            T * i = d->array + d->start;
+            T * e = d->array + d->alloc;
+            while (count--) {
+                i->~T();
+                i++;
+                if (i == e)
+                    i = d->array;
+            }
+        }
+        d->count = d->start = d->offset = 0;
+    } else {
+        union { QContiguousCacheData *p; QContiguousCacheTypedData<T> *d; } x;
+        x.p = malloc(d->alloc);
+        x.d->ref = 1;
+        x.d->alloc = d->alloc;
+        x.d->count = x.d->start = x.d->offset = 0;
+        x.d->sharable = true;
+        if (!d->ref.deref()) free(d);
+        d = x.d;
+    }
+}
+
+template <typename T>
+inline QContiguousCacheData *QContiguousCache<T>::malloc(int aalloc)
+{
+    return static_cast<QContiguousCacheData *>(qMalloc(sizeOfTypedData() + (aalloc - 1) * sizeof(T)));
+}
+
+template <typename T>
+QContiguousCache<T>::QContiguousCache(int capacity)
+{
+    p = malloc(capacity);
+    d->ref = 1;
+    d->alloc = capacity;
+    d->count = d->start = d->offset = 0;
+    d->sharable = true;
+}
+
+template <typename T>
+QContiguousCache<T> &QContiguousCache<T>::operator=(const QContiguousCache<T> &other)
+{
+    other.d->ref.ref();
+    if (!d->ref.deref())
+        free(d);
+    d = other.d;
+    if (!d->sharable)
+        detach_helper();
+    return *this;
+}
+
+template <typename T>
+bool QContiguousCache<T>::operator==(const QContiguousCache<T> &other) const
+{
+    if (other.d == d)
+        return true;
+    if (other.d->start != d->start
+            || other.d->count != d->count
+            || other.d->offset != d->offset
+            || other.d->alloc != d->alloc)
+        return false;
+    for (int i = firstIndex(); i <= lastIndex(); ++i)
+        if (!(at(i) == other.at(i)))
+            return false;
+    return true;
+}
+
+template <typename T>
+void QContiguousCache<T>::free(Data *x)
+{
+    if (QTypeInfo<T>::isComplex) {
+        int count = d->count;
+        T * i = d->array + d->start;
+        T * e = d->array + d->alloc;
+        while (count--) {
+            i->~T();
+            i++;
+            if (i == e)
+                i = d->array;
+        }
+    }
+    qFree(x);
+}
+template <typename T>
+void QContiguousCache<T>::append(const T &value)
+{
+    detach();
+    if (QTypeInfo<T>::isComplex) {
+        if (d->count == d->alloc)
+            (d->array + (d->start+d->count) % d->alloc)->~T();
+        new (d->array + (d->start+d->count) % d->alloc) T(value);
+    } else {
+        d->array[(d->start+d->count) % d->alloc] = value;
+    }
+
+    if (d->count == d->alloc) {
+        d->start++;
+        d->start %= d->alloc;
+        d->offset++;
+    } else {
+        d->count++;
+    }
+}
+
+template<typename T>
+void QContiguousCache<T>::prepend(const T &value)
+{
+    detach();
+    if (d->start)
+        d->start--;
+    else
+        d->start = d->alloc-1;
+    d->offset--;
+
+    if (d->count != d->alloc)
+        d->count++;
+    else
+        if (d->count == d->alloc)
+            (d->array + d->start)->~T();
+
+    if (QTypeInfo<T>::isComplex)
+        new (d->array + d->start) T(value);
+    else
+        d->array[d->start] = value;
+}
+
+template<typename T>
+void QContiguousCache<T>::insert(int pos, const T &value)
+{
+    Q_ASSERT_X(pos >= 0 && pos < INT_MAX, "QContiguousCache<T>::insert", "index out of range");
+    detach();
+    if (containsIndex(pos)) {
+        if(QTypeInfo<T>::isComplex)
+            new (d->array + pos % d->alloc) T(value);
+        else
+            d->array[pos % d->alloc] = value;
+    } else if (pos == d->offset-1)
+        prepend(value);
+    else if (pos == d->offset+d->count)
+        append(value);
+    else {
+        // we don't leave gaps.
+        clear();
+        d->offset = pos;
+        d->start = pos % d->alloc;
+        d->count = 1;
+        if (QTypeInfo<T>::isComplex)
+            new (d->array + d->start) T(value);
+        else
+            d->array[d->start] = value;
+    }
+}
+
+template <typename T>
+inline const T &QContiguousCache<T>::at(int pos) const
+{ Q_ASSERT_X(pos >= d->offset && pos - d->offset < d->count, "QContiguousCache<T>::at", "index out of range"); return d->array[pos % d->alloc]; }
+template <typename T>
+inline const T &QContiguousCache<T>::operator[](int pos) const
+{ Q_ASSERT_X(pos >= d->offset && pos - d->offset < d->count, "QContiguousCache<T>::at", "index out of range"); return d->array[pos % d->alloc]; }
+
+template <typename T>
+inline T &QContiguousCache<T>::operator[](int pos)
+{
+    detach();
+    if (!containsIndex(pos))
+        insert(pos, T());
+    return d->array[pos % d->alloc];
+}
+
+template <typename T>
+inline void QContiguousCache<T>::removeFirst()
+{
+    Q_ASSERT(d->count > 0);
+    detach();
+    d->count--;
+    if (QTypeInfo<T>::isComplex)
+        (d->array + d->start)->~T();
+    d->start = (d->start + 1) % d->alloc;
+    d->offset++;
+}
+
+template <typename T>
+inline void QContiguousCache<T>::removeLast()
+{
+    Q_ASSERT(d->count > 0);
+    detach();
+    d->count--;
+    if (QTypeInfo<T>::isComplex)
+        (d->array + (d->start + d->count) % d->alloc)->~T();
+}
+
+template <typename T>
+inline T QContiguousCache<T>::takeFirst()
+{ T t = first(); removeFirst(); return t; }
+
+template <typename T>
+inline T QContiguousCache<T>::takeLast()
+{ T t = last(); removeLast(); return t; }
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/corelib/tools/qcryptographichash.cpp b/src/corelib/tools/qcryptographichash.cpp
index 7232626..e438179 100644
--- a/src/corelib/tools/qcryptographichash.cpp
+++ b/src/corelib/tools/qcryptographichash.cpp
@@ -74,7 +74,7 @@ public:
 
   QCryptographicHash can be used to generate cryptographic hashes of binary or text data.
 
-  Currently MD4, MD5, and SHA1 are supported.
+  Currently MD4, MD5, and SHA-1 are supported.
 */
 
 /*!
diff --git a/src/corelib/tools/qdatetime.cpp b/src/corelib/tools/qdatetime.cpp
index 781514c..de41360 100644
--- a/src/corelib/tools/qdatetime.cpp
+++ b/src/corelib/tools/qdatetime.cpp
@@ -3833,19 +3833,19 @@ void QDateTimePrivate::getUTC(QDate &outDate, QTime &outTime) const
 #if !defined(QT_NO_DEBUG_STREAM) && !defined(QT_NO_DATESTRING)
 QDebug operator<<(QDebug dbg, const QDate &date)
 {
-    dbg.nospace() << "QDate(" << date.toString() << ")";
+    dbg.nospace() << "QDate(" << date.toString() << ')';
     return dbg.space();
 }
 
 QDebug operator<<(QDebug dbg, const QTime &time)
 {
-    dbg.nospace() << "QTime(" << time.toString() << ")";
+    dbg.nospace() << "QTime(" << time.toString() << ')';
     return dbg.space();
 }
 
 QDebug operator<<(QDebug dbg, const QDateTime &date)
 {
-    dbg.nospace() << "QDateTime(" << date.toString() << ")";
+    dbg.nospace() << "QDateTime(" << date.toString() << ')';
     return dbg.space();
 }
 #endif
@@ -4688,7 +4688,7 @@ QDateTimeParser::StateNode QDateTimeParser::parse(QString &input, int &cursorPos
             if (fixup && tmpstate == Intermediate && used < sn.count) {
                 const FieldInfo fi = fieldInfo(index);
                 if ((fi & (Numeric|FixedWidth)) == (Numeric|FixedWidth)) {
-                    const QString newText = QString(QLatin1String("%1")).arg(num, sn.count, 10, QLatin1Char('0'));
+                    const QString newText = QString::fromLatin1("%1").arg(num, sn.count, 10, QLatin1Char('0'));
                     input.replace(pos, used, newText);
                     used = sn.count;
                 }
diff --git a/src/corelib/tools/qdumper.cpp b/src/corelib/tools/qdumper.cpp
deleted file mode 100644
index c3b8524..0000000
--- a/src/corelib/tools/qdumper.cpp
+++ /dev/null
@@ -1,1157 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information (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 qt-sales@nokia.com.
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include <qdatetime.h>
-#include <qdebug.h>
-#include <qdir.h>
-#include <qfileinfo.h>
-#include <qhash.h>
-#include <qmap.h>
-#include <qmetaobject.h>
-#include <qobject.h>
-#include <qstring.h>
-#include <qvariant.h>
-#include <qvector.h>
-
-#if !defined(Q_OS_WINCE) && !defined(QT_NO_DUMPER)
-
-#include <stdlib.h>
-#include <stdio.h>
-
-#ifdef Q_OS_WIN
-#   include <windows.h>
-#endif
-
-QT_BEGIN_NAMESPACE
-
-namespace {
-
-// This is used to abort evaluation of custom data dumpers in a "coordinated"
-// way. Abortion will happen anyway when we try to access a non-initialized
-// non-trivial object, so there is no way to prevent this from occuring at all
-// conceptionally.  Gdb will catch SIGSEGV and return to the calling frame.
-// This is just fine provided we only _read_ memory in the custom handlers
-// below.
-
-volatile int qProvokeSegFaultHelper;
-
-static void qCheckAccess(const void *d)
-{
-    // provoke segfault when address is not readable
-    qProvokeSegFaultHelper = *(char*)d;
-}
-
-static void qCheckPointer(const void *d)
-{
-    if (!d)
-        return;
-    qProvokeSegFaultHelper = *(char*)d;
-}
-
-static void qProvokeSegFault()
-{
-    // provoke segfault unconditionally
-    qCheckAccess(0);
-}
-
-static char qDumpInBuffer[100];
-static char qDumpBuffer[1000];
-#ifdef Q_OS_WIN
-static char qDumpBuffer2[sizeof(qDumpBuffer) + 100];
-#endif
-
-static char toHex(int n)
-{
-    return n < 10 ? '0' + n : 'a' - 10 + n;
-}
-
-
-struct QDumper
-{
-    explicit QDumper();
-    ~QDumper();
-    void flush();
-    QDumper &operator<<(long c);
-    QDumper &operator<<(int i);
-    QDumper &operator<<(unsigned long c);
-    QDumper &operator<<(unsigned int i);
-    QDumper &operator<<(const void *p);
-    void put(char c);
-    void addCommaIfNeeded();
-    void putEncoded(unsigned c);
-    QDumper &operator<<(const char *str);
-    QDumper &operator<<(const QString &str);
-    void disarm();
-
-    void beginHash(); // start of data hash output
-    void endHash(); // start of data hash output
-
-    // the dumper arguments
-    int protocolVersion;   // dumper protocol version
-    int token;             // some token to show on success
-    const char *outertype; // object type
-    const char *iname;     // object name used for display
-    const char *exp;       // object expression
-    const char *innertype; // 'inner type' for class templates
-    const void *data;      // pointer to raw data
-    bool dumpChildren;     // do we want to see children?
-
-    // handling of nested templates
-    void setupTemplateParameters();
-    enum { maxTemplateParameters = 10 };
-    const char *templateParameters[maxTemplateParameters + 1];
-    int templateParametersCount;
-
-    // internal state
-    bool success;          // are we finished?
-    size_t pos;
-};
-
-
-QDumper::QDumper()
-{
-    success = false;
-    pos = 0;
-}
-
-QDumper::~QDumper()
-{
-    flush();
-    put(0); // our end marker
-#ifdef Q_OS_WIN
-    sprintf(qDumpBuffer2, "@@CDD/%d/done\n", token);
-    OutputDebugStringA(qDumpBuffer2);
-#else
-    fprintf(stderr, "%d/done\n", token);
-#endif
-    qDumpInBuffer[0] = 0;
-}
-
-void QDumper::flush()
-{
-    qDumpBuffer[pos++] = 0;
-#ifdef Q_OS_WIN
-    sprintf(qDumpBuffer2, "@@CDD#%d#%d,%s\n", token, int(pos - 1), qDumpBuffer);
-    OutputDebugStringA(qDumpBuffer2);
-#else
-    fprintf(stderr, "%d#%d,%s\n", token, int(pos - 1), qDumpBuffer);
-#endif
-    pos = 0;
-}
-
-void QDumper::setupTemplateParameters()
-{
-    char *s = const_cast<char *>(innertype);
-
-    templateParametersCount = 1;
-    templateParameters[0] = s;
-    for (int i = 1; i != maxTemplateParameters + 1; ++i)
-        templateParameters[i] = 0;
-
-    while (*s) {
-        while (*s && *s != '@')
-            ++s;
-        if (*s) {
-            *s = '\0';
-            ++s;
-            templateParameters[templateParametersCount++] = s;
-        }
-    }
-}
-
-QDumper &QDumper::operator<<(unsigned long c)
-{
-    static char buf[100];
-    sprintf(buf, "%lu", c);
-    return (*this) << buf;
-}
-
-QDumper &QDumper::operator<<(unsigned int i)
-{
-    static char buf[100];
-    sprintf(buf, "%u", i);
-    return (*this) << buf;
-}
-
-QDumper &QDumper::operator<<(long c)
-{
-    static char buf[100];
-    sprintf(buf, "%ld", c);
-    return (*this) << buf;
-}
-
-QDumper &QDumper::operator<<(int i)
-{
-    static char buf[100];
-    sprintf(buf, "%d", i);
-    return (*this) << buf;
-}
-
-QDumper &QDumper::operator<<(const void *p)
-{
-    static char buf[100];
-    sprintf(buf, "%p", p);
-    // we get a '0x' prefix only on some implementations.
-    // if it isn't there, write it out manually.
-    if (buf[1] != 'x') {
-        put('0');
-        put('x');
-    }
-    return (*this) << buf;
-}
-
-void QDumper::put(char c)
-{
-    if (pos >= sizeof(qDumpBuffer) - 100)
-        flush();
-    qDumpBuffer[pos++] = c;
-}
-
-void QDumper::addCommaIfNeeded()
-{
-    if (pos == 0)
-        return;
-    if (qDumpBuffer[pos - 1] == '}' || qDumpBuffer[pos - 1] == '"')
-        put(',');
-}
-
-void QDumper::putEncoded(unsigned c)
-{
-    if (c >= 32 && c <= 126 && c != '"' && c != '\\') {
-        put(c);
-    } else {
-        put('\\');
-        put('u');
-        put(toHex((c >> 12) & 0xf));
-        put(toHex((c >>  8) & 0xf));
-        put(toHex((c >>  4) & 0xf));
-        put(toHex( c        & 0xf));
-    }
-}
-
-QDumper &QDumper::operator<<(const char *str)
-{
-    while (*str)
-        put(*(str++));
-    return *this;
-}
-
-QDumper &QDumper::operator<<(const QString &str)
-{
-    int n = str.size();
-    if (n < 0) {
-        qProvokeSegFault();
-    } else {
-        //(*this) << "[" << n << "]";
-        if (n > 1000000)
-            n = 1000000;
-        //put(' ');
-        put('\\');
-        put('"');
-        for (int i = 0; i != n; ++i)
-            putEncoded(str[i].unicode());
-        put('\\');
-        put('"');
-        if (n < str.size())
-            (*this) << "<incomplete string>";
-    }
-    return *this;
-}
-
-void QDumper::disarm()
-{
-    flush();
-    success = true;
-}
-
-void QDumper::beginHash()
-{
-    addCommaIfNeeded();
-    put('{');
-}
-
-void QDumper::endHash()
-{
-    put('}');
-}
-
-
-//
-// Some helpers to keep the dumper code short
-//
-
-// dump property=value pair
-#undef P
-#define P(dumper,name,value) \
-    do { \
-        dumper.addCommaIfNeeded(); \
-        dumper << (name) << "=\"" << value << "\""; \
-    } while (0)
-
-// simple string property
-#undef S
-#define S(dumper, name, value) \
-    dumper.beginHash(); \
-    P(dumper, "name", name); \
-    P(dumper, "value", value); \
-    P(dumper, "type", "QString"); \
-    P(dumper, "numchild", "0"); \
-    dumper.endHash();
-
-// simple integer property
-#undef I
-#define I(dumper, name, value) \
-    dumper.beginHash(); \
-    P(dumper, "name", name); \
-    P(dumper, "value", value); \
-    P(dumper, "type", "int"); \
-    P(dumper, "numchild", "0"); \
-    dumper.endHash();
-
-// simple boolean property
-#undef BL
-#define BL(dumper, name, value) \
-    dumper.beginHash(); \
-    P(dumper, "name", name); \
-    P(dumper, "value", (value ? "true" : "false")); \
-    P(dumper, "type", "bool"); \
-    P(dumper, "numchild", "0"); \
-    dumper.endHash();
-
-#undef TT
-#define TT(type, value) \
-    "<tr><td>" << type << "</td><td> : </td><td>" << value << "</td></tr>"
-
-static void qDumpUnknown(QDumper &d)
-{
-    P(d, "iname", d.iname);
-    P(d, "addr", d.data);
-    P(d, "value", "<internal error>");
-    P(d, "type", d.outertype);
-    P(d, "numchild", "0");
-    d.disarm();
-}
-
-static void qDumpQPropertyList(QDumper &d)
-{
-    const QObject *ob = (const QObject *)d.data;
-    const QMetaObject *mo = ob->metaObject();
-    P(d, "iname", d.iname);
-    P(d, "addr", "<synthetic>");
-    P(d, "type", "QObject");
-    P(d, "numchild", mo->propertyCount());
-    if (d.dumpChildren) {
-        d << ",children=[";
-        for (int i = mo->propertyCount(); --i >= 0; ) {
-            const QMetaProperty & prop = mo->property(i);
-            d.beginHash();
-            P(d, "name", prop.name());
-            if (QLatin1String(prop.typeName()) == QLatin1String("QString")) {
-                P(d, "value", prop.read(ob).toString());
-                P(d, "numchild", "0");
-            } else if (QLatin1String(prop.typeName()) == QLatin1String("bool")) {
-                P(d, "value", (prop.read(ob).toBool() ? "true" : "false"));
-                P(d, "numchild", "0");
-            } else if (QLatin1String(prop.typeName()) == QLatin1String("int")) {
-                P(d, "value", prop.read(ob).toInt());
-                P(d, "numchild", "0");
-            } else {
-                P(d, "exp", "((" << mo->className() << "*)" << ob
-                            << ")->" << prop.name() << "()");
-            }
-            P(d, "type", prop.typeName());
-            P(d, "numchild", "1");
-            d.endHash();
-        }
-        d << "]";
-    }
-    d.disarm();
-}
-
-static void qDumpQObject(QDumper &d)
-{
-    const QObject *ob = reinterpret_cast<const QObject *>(d.data);
-    P(d, "iname", d.iname);
-    P(d, "addr", d.data);
-    P(d, "value", (void*)d.data);
-    P(d, "type", "QObject");
-    P(d, "numchild", 4);
-    if (d.dumpChildren) {
-        const QMetaObject *mo = ob->metaObject();
-        const QObjectList &children = ob->children();
-        d << ",children=[";
-        S(d, "objectName", ob->objectName());
-        d.beginHash();
-            P(d, "name", "properties");
-            // FIXME: Note that when simply using '(QObject*)'
-            // in the cast below, Gdb/MI _sometimes misparses
-            // expressions further down in the tree.
-            P(d, "exp", "*(class QObject*)" << d.data);
-            P(d, "type", "QPropertyList");
-            P(d, "value", "<" << mo->propertyCount() << " items>");
-            P(d, "numchild", mo->propertyCount());
-        d.endHash();
-        d.beginHash();
-            P(d, "name", "children");
-            P(d, "exp", "((class QObject*)" << d.data << ")->children()");
-            P(d, "type", "QList<QObject *>");
-            P(d, "value", "<" << children.size() << " items>");
-            P(d, "numchild", children.size());
-        d.endHash();
-        d.beginHash();
-            P(d, "name", "parent");
-            P(d, "exp", "((class QObject*)" << d.data << ")->parent()");
-            P(d, "type", "QObject *");
-            P(d, "numchild", (ob->parent() ? "1" : "0"));
-        d.endHash();
-        d << "]";
-    }
-    d.disarm();
-}
-
-static void qDumpQDir(QDumper &d)
-{
-    const QDir &dir = *reinterpret_cast<const QDir *>(d.data);
-    P(d, "iname", d.iname);
-    P(d, "addr", d.data);
-    P(d, "value", dir.path());
-    P(d, "type", "QDir");
-    P(d, "numchild", "3");
-    if (d.dumpChildren) {
-        d << ",children=[";
-        S(d, "absolutePath", dir.absolutePath());
-        S(d, "canonicalPath", dir.canonicalPath());
-        d << "]";
-    }
-    d.disarm();
-}
-
-static void qDumpQFileInfo(QDumper &d)
-{
-    const QFileInfo &info = *reinterpret_cast<const QFileInfo *>(d.data);
-    P(d, "iname", d.iname);
-    P(d, "addr", d.data);
-    P(d, "value", info.filePath());
-    P(d, "type", "QDir");
-    P(d, "numchild", "3");
-    if (d.dumpChildren) {
-        d << ",children=[";
-        S(d, "absolutePath", info.absolutePath());
-        S(d, "absoluteFilePath", info.absoluteFilePath());
-        S(d, "canonicalPath", info.canonicalPath());
-        S(d, "canonicalFilePath", info.canonicalFilePath());
-        S(d, "completeBaseName", info.completeBaseName());
-        S(d, "completeSuffix", info.completeSuffix());
-        S(d, "baseName", info.baseName());
-#ifdef Q_OS_MACX
-        BL(d, "isBundle", info.isBundle());
-        S(d, "bundleName", info.bundleName());
-#endif
-        S(d, "completeSuffix", info.completeSuffix());
-        S(d, "fileName", info.fileName());
-        S(d, "filePath", info.filePath());
-        S(d, "group", info.group());
-        S(d, "owner", info.owner());
-        S(d, "path", info.path());
-
-        I(d, "groupid", (long)info.groupId());
-        I(d, "ownerid", (long)info.ownerId());
-        //QFile::Permissions permissions () const
-        I(d, "permissions", info.permissions());
-
-        //QDir absoluteDir () const
-        //QDir dir () const
-
-        BL(d, "caching", info.caching());
-        BL(d, "exists", info.exists());
-        BL(d, "isAbsolute", info.isAbsolute());
-        BL(d, "isDir", info.isDir());
-        BL(d, "isExecutable", info.isExecutable());
-        BL(d, "isFile", info.isFile());
-        BL(d, "isHidden", info.isHidden());
-        BL(d, "isReadable", info.isReadable());
-        BL(d, "isRelative", info.isRelative());
-        BL(d, "isRoot", info.isRoot());
-        BL(d, "isSymLink", info.isSymLink());
-        BL(d, "isWritable", info.isWritable());
-
-#ifndef QT_NO_DATESTRING
-        d.beginHash();
-        P(d, "name", "created");
-        P(d, "value", info.created().toString());
-        P(d, "exp", "((QFileInfo*)" << d.data << ")->created()");
-        P(d, "type", "QDateTime");
-        P(d, "numchild", "1");
-        d.endHash();
-
-        d.beginHash();
-        P(d, "name", "lastModified");
-        P(d, "value", info.lastModified().toString());
-        P(d, "exp", "((QFileInfo*)" << d.data << ")->lastModified()");
-        P(d, "type", "QDateTime");
-        P(d, "numchild", "1");
-        d.endHash();
-
-        d.beginHash();
-        P(d, "name", "lastRead");
-        P(d, "value", info.lastRead().toString());
-        P(d, "exp", "((QFileInfo*)" << d.data << ")->lastRead()");
-        P(d, "type", "QDateTime");
-        P(d, "numchild", "1");
-        d.endHash();
-#endif
-
-        d << "]";
-    }
-    d.disarm();
-}
-
-static void qDumpQDateTime(QDumper &d)
-{
-#ifdef QT_NO_DATESTRING
-    qDumpUnknown(d);
-#else
-    const QDateTime &date = *reinterpret_cast<const QDateTime *>(d.data);
-    P(d, "iname", d.iname);
-    P(d, "addr", d.data);
-    P(d, "value", date.toString());
-    P(d, "type", "QDateTime");
-    P(d, "numchild", "3");
-    if (d.dumpChildren) {
-        d << ",children=[";
-        BL(d, "isNull", date.isNull());
-        I(d, "toTime_t", (long)date.toTime_t());
-        S(d, "toString", date.toString());
-        S(d, "toString_(ISO)", date.toString(Qt::ISODate));
-        S(d, "toString_(SystemLocale)", date.toString(Qt::SystemLocaleDate));
-        S(d, "toString_(Locale)", date.toString(Qt::LocaleDate));
-        S(d, "toString", date.toString());
-
-        d.beginHash();
-        P(d, "name", "toUTC");
-        P(d, "exp", "((QDateTime*)" << d.data << ")->toTimeSpec(Qt::UTC)");
-        P(d, "type", "QDateTime");
-        P(d, "numchild", "1");
-        d.endHash();
-
-        d.beginHash();
-        P(d, "name", "toLocalTime");
-        P(d, "exp", "((QDateTime*)" << d.data << ")->toTimeSpec(Qt::LocalTime)");
-        P(d, "type", "QDateTime");
-        P(d, "numchild", "1");
-        d.endHash();
-
-        d << "]";
-    }
-    d.disarm();
-#endif // ifdef QT_NO_DATESTRING
-}
-
-static void qDumpQString(QDumper &d)
-{
-    const QString &str = *reinterpret_cast<const QString *>(d.data);
-
-    // Try to provoke segfaults early to prevent the frontend
-    // from asking for unavailable child details
-    if (!str.isEmpty()) {
-        volatile ushort dummy = 0;
-        dummy += str.at(0).unicode();
-        dummy += str.at(str.size() - 1).unicode();
-    }
-
-    P(d, "iname", d.iname);
-    P(d, "addr", d.data);
-    P(d, "value", str);
-    P(d, "type", "QString");
-    P(d, "numchild", "0");
-    d.disarm();
-}
-
-static void qDumpQStringList(QDumper &d)
-{
-    const QStringList &list = *reinterpret_cast<const QStringList *>(d.data);
-    int n = list.size();
-    if (n < 0)
-        qProvokeSegFault();
-    if (n > 0) {
-        qCheckAccess(&list.front());
-        qCheckAccess(&list.back());
-    }
-
-    P(d, "iname", d.iname);
-    P(d, "addr", d.data);
-    P(d, "value", "<" << n << " items>");
-    P(d, "valuedisabled", "true");
-    P(d, "numchild", n);
-    if (d.dumpChildren) {
-        if (n > 100)
-            n = 100;
-        d << ",children=[";
-        for (int i = 0; i != n; ++i) {
-            S(d, "[" << i << "]", list[i]);
-        }
-        if (n < list.size()) {
-            d.beginHash();
-            P(d, "value", "<incomplete>");
-            P(d, "type", " ");
-            P(d, "numchild", "0");
-            d.endHash();
-        }
-        d << "]";
-    }
-    d.disarm();
-}
-
-static void qDumpQVariantHelper(const void *data, QString *value,
-    QString *exp, int *numchild)
-{
-    const QVariant &v = *reinterpret_cast<const QVariant *>(data);
-    switch (v.type()) {
-    case QVariant::Invalid:
-        *value = QLatin1String("<invalid>");
-        *numchild = 0;
-        break;
-    case QVariant::String:
-        *value = QLatin1Char('"') + v.toString() + QLatin1Char('"');
-        *numchild = 0;
-        break;
-    case QVariant::StringList:
-        *exp = QString(QLatin1String("((QVariant*)%1)->d.data.c"))
-                    .arg((qulonglong)data);
-        *numchild = v.toStringList().size();
-        break;
-    case QVariant::Int:
-        *value = QString::number(v.toInt());
-        *numchild= 0;
-        break;
-    case QVariant::Double:
-        *value = QString::number(v.toDouble());
-        *numchild = 0;
-        break;
-    default:
-        // FIXME
-        //*exp = QString("qVariantValue<" << v.typeName() << ">"
-        //             << "(*(QVariant*)" << data << ")");
-        break;
-    }
-}
-
-static void qDumpQVariant(QDumper &d)
-{
-    const QVariant &v = *reinterpret_cast<const QVariant *>(d.data);
-    QString value;
-    QString exp;
-    int numchild = 0;
-    qDumpQVariantHelper(d.data, &value, &exp, &numchild);
-    P(d, "iname", d.iname);
-    P(d, "addr", d.data);
-    P(d, "value", "(" << v.typeName() << ") " << qPrintable(value));
-    P(d, "type", "QVariant");
-    P(d, "numchild", 1);
-    if (d.dumpChildren) {
-        d << ",children=[";
-        d.beginHash();
-        P(d, "name", "value");
-        if (!exp.isEmpty())
-            P(d, "exp", qPrintable(exp));
-        if (!value.isEmpty())
-            P(d, "value", qPrintable(value));
-        P(d, "type", v.typeName());
-        P(d, "numchild", numchild);
-        d.endHash();
-        d << "]";
-    }
-    d.disarm();
-}
-
-static void qDumpQList(QDumper &d)
-{
-    // This uses the knowledge that QList<T> has only a single member
-    // of type  union { QListData p; QListData::Data *d; };
-    const QListData &ldata = *reinterpret_cast<const QListData*>(d.data);
-    const QListData::Data *pdata = *reinterpret_cast<const QListData::Data* const*>(d.data);
-    int nn = ldata.size();
-    if (nn < 0)
-        qProvokeSegFault();
-    if (nn > 0) {
-        qCheckAccess(ldata.d->array);
-        //qCheckAccess(ldata.d->array[0]);
-        //qCheckAccess(ldata.d->array[nn - 1]);
-    }
-
-    int n = nn;
-    P(d, "iname", d.iname);
-    P(d, "value", "<" << n << " items>");
-    P(d, "valuedisabled", "true");
-    P(d, "numchild", n);
-    if (d.dumpChildren) {
-        if (n > 100)
-            n = 100;
-        d << ",children=[";
-        for (int i = 0; i != n; ++i) {
-            d.beginHash();
-            P(d, "name", "[" << i << "]");
-            // The exact condition here is:
-            //  QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic
-            // but this data is not available in the compiled binary.
-            // So as first approximation only do the 'isLarge' check:
-            void *p = &(ldata.d->array[i + pdata->begin]);
-            unsigned long voidpsize = sizeof(void*);
-            P(d, "exp", "(sizeof(" << d.innertype << ")>" << voidpsize <<
-                "?(**(" << d.innertype << "**)(" << p << "))" 
-                ":(*(" << d.innertype << "*)(" << p << ")))");
-            P(d, "type", d.innertype);
-            d.endHash();
-        }
-        if (n < nn) {
-            d << ",{";
-            P(d, "value", "<incomplete>");
-            d.endHash();
-        }
-        d << "]";
-    }
-    d.disarm();
-}
-
-static void qDumpQVector(QDumper &d)
-{
-    // Use 'int' as representative value. No way (and no need)
-    // to deduce proper type here.
-    const QVector<int> &vec = *reinterpret_cast<const QVector<int> *>(d.data);
-    const int nn = vec.size();
-
-    // Try to provoke segfaults early to prevent the frontend
-    // from asking for unavailable child details
-    if (nn < 0)
-        qProvokeSegFault();
-    if (nn > 0) {
-        qCheckAccess(&vec.front());
-        qCheckAccess(&vec.back());
-    }
-
-    //int innersize = 0;
-    //scanf(qDumpInBuffer, "%d", &innersize);
-    
-    int n = nn;
-    P(d, "iname", d.iname);
-    P(d, "addr", d.data);
-    P(d, "value", "<" << n << " items>");
-    P(d, "valuedisabled", "true");
-    P(d, "numchild", n);
-    if (d.dumpChildren) {
-        if (n > 100)
-            n = 100;
-        d << ",children=[";
-        for (int i = 0; i != n; ++i) {
-            if (i)
-                d << ",";
-            d.beginHash();
-            P(d, "name", "[" << i << "]");
-            P(d, "exp", "(" << d.exp << ".d->array[" << i << "])");
-            P(d, "type", d.innertype);
-            d.endHash();
-        }
-        if (n < nn) {
-            d << ",{";
-            P(d, "value", "<incomplete>");
-            d.endHash();
-        }
-        d << "]";
-    }
-    d.disarm();
-}
-
-static void qDumpQHashNode(QDumper &d)
-{
-    struct NodeOS { void *next; uint k; uint  v; } nodeOS; // int-key optimization, small value
-    struct NodeOL { void *next; uint k; void *v; } nodeOL; // int-key optimiatzion, large value
-    struct NodeNS { void *next; uint h; uint  k; uint  v; } nodeNS; // no optimization, small value
-    struct NodeNL { void *next; uint h; uint  k; void *v; } nodeNL; // no optimization, large value
-    struct NodeL  { void *next; uint h; void *k; void *v; } nodeL; // complex key
-
-    // offsetof(...,...) not yet in Standard C++
-    const ulong nodeOSk ( (char *)&nodeOS.k - (char *)&nodeOS );
-    const ulong nodeOSv ( (char *)&nodeOS.v - (char *)&nodeOS );
-    const ulong nodeOLk ( (char *)&nodeOL.k - (char *)&nodeOL );
-    const ulong nodeOLv ( (char *)&nodeOL.v - (char *)&nodeOL );
-    const ulong nodeNSk ( (char *)&nodeNS.k - (char *)&nodeNS );
-    const ulong nodeNSv ( (char *)&nodeNS.v - (char *)&nodeNS );
-    const ulong nodeNLk ( (char *)&nodeNL.k - (char *)&nodeNL );
-    const ulong nodeNLv ( (char *)&nodeNL.v - (char *)&nodeNL );
-    const ulong nodeLk  ( (char *)&nodeL.k  - (char *)&nodeL );
-    const ulong nodeLv  ( (char *)&nodeL.v  - (char *)&nodeL );
-
-    const QHashData *h = reinterpret_cast<const QHashData *>(d.data);
-    const char *keyType   = d.templateParameters[0];
-    const char *valueType = d.templateParameters[1];
-
-    P(d, "iname", d.iname);
-    P(d, "addr", d.data);
-    P(d, "value", "");
-    P(d, "numchild", 2);
-    if (d.dumpChildren) {
-        // there is a hash specialization in cast the key are integers or shorts
-        bool isOptimizedIntKey = qstrcmp(keyType, "int") == 0
-#if defined(Q_BYTE_ORDER) && Q_BYTE_ORDER == Q_LITTLE_ENDIAN
-            || qstrcmp(keyType, "short") == 0
-            || qstrcmp(keyType, "ushort") == 0
-#endif
-            || qstrcmp(keyType, "uint") == 0;
-
-        d << ",children=[";
-        d.beginHash();
-        P(d, "name", "key");
-        P(d, "type", keyType);
-        unsigned long intsize = sizeof(int);
-        if (isOptimizedIntKey) {
-            P(d, "exp", "*(" << keyType << "*)"
-                "(((sizeof(" << valueType << ")>" << intsize << ")?"
-              << nodeOLk << ":" << nodeOSk <<
-                ")+(char*)" << h << ")");
-        } else {
-            P(d, "exp", "*(" << keyType << "*)"
-              "(((sizeof(" << keyType << ")>" << intsize << ")?"
-                << nodeLk << ":"
-                    "((sizeof(" << valueType << ")>" << intsize << ")?"
-              << nodeNLk << ":" << nodeNSk << "))+(char*)" << h << ")");
-        }
-        d.endHash();
-        d.beginHash();
-        P(d, "name", "value");
-        P(d, "type", valueType);
-        if (isOptimizedIntKey) {
-            P(d, "exp", "*(" << valueType << "*)"
-                "(((sizeof(" << valueType << ")>" << intsize << ")?"
-              << nodeOLv << ":" << nodeOSv << ")+(char*)" << h << ")");
-        } else {
-            P(d, "exp", "*(" << valueType << "*)"
-              "(((sizeof(" << keyType << ")>" << intsize << ")?" << nodeLv << ":"
-                    "((sizeof(" << valueType << ")>" << intsize << ")?"
-              << nodeNLv << ":" << nodeNSv << "))+(char*)" << h << ")");
-        }
-        d.endHash();
-        d << "]";
-    }
-    d.disarm();
-}
-
-static void qDumpQHash(QDumper &d)
-{
-    QHashData *h = *reinterpret_cast<QHashData *const*>(d.data);
-    const char *keyType   = d.templateParameters[0];
-    const char *valueType = d.templateParameters[1];
-
-    qCheckPointer(h->fakeNext);
-    qCheckPointer(h->buckets);
-
-    int n = h->size;
-
-    if (n < 0)
-        qProvokeSegFault();
-    if (n > 0) {
-        qCheckPointer(h->fakeNext);
-        qCheckPointer(*h->buckets);
-    }
-    
-    P(d, "iname", d.iname);
-    P(d, "addr", d.data);
-    P(d, "value", "<" << n << " items>");
-    P(d, "numchild", n);
-    if (d.dumpChildren) {
-        if (n > 100)
-            n = 100;
-        d << ",children=[";
-
-        QHashData::Node *node = h->firstNode();
-        QHashData::Node *end = reinterpret_cast<QHashData::Node *>(h);
-        int i = 0;
-
-        while (node != end) {
-            d.beginHash();
-                P(d, "name", "[" << i << "]");
-                P(d, "type", "QHashNode<" << keyType << "," << valueType << " >");
-                P(d, "exp", "*(QHashNode<" << keyType << "," << valueType << " >*)" << node);
-            d.endHash();
-
-            ++i;
-            node = QHashData::nextNode(node);
-        }
-        d << "]";
-    }
-    d.disarm();
-}
-
-static void qDumpQMapNode(QDumper &d)
-{
-    const QMapData *h = reinterpret_cast<const QMapData *>(d.data);
-    const char *keyType   = d.templateParameters[0];
-    const char *valueType = d.templateParameters[1];
- 
-    qCheckAccess(h->backward);
-    qCheckAccess(h->forward[0]);
-
-    P(d, "iname", d.iname);
-    P(d, "addr", d.data);
-    P(d, "value", "");
-    P(d, "numchild", 2);
-    if (d.dumpChildren) {
-        unsigned long voidpsize = sizeof(void*);
-        d << ",children=[";
-        d.beginHash();
-        P(d, "name", "key");
-        P(d, "type", keyType);
-        P(d, "exp", "*(" << keyType << "*)"
-            << "("
-            << 2 * voidpsize
-            << "-sizeof('QMap<" << keyType << "," << valueType << ">::Node')"
-            << "+(char*)" << h
-            << ")");
-        d.endHash();
-        d.beginHash();
-        P(d, "name", "value");
-        P(d, "type", valueType);
-        P(d, "exp", "*(" << valueType << "*)"
-            << "("
-            << "(size_t)&(('QMap<" << keyType << "," << valueType << ">::Node'*)0)->value"
-            << "+" << 2 * voidpsize
-            << "-sizeof('QMap<" << keyType << "," << valueType << ">::Node')"
-            << "+(char*)" << h
-            << ")");
-        d.endHash();
-        d << "]";
-    }
-
-    d.disarm();
-}
-
-static void qDumpQMap(QDumper &d)
-{ 
-    QMapData *h = *reinterpret_cast<QMapData *const*>(d.data);
-    const char *keyType   = d.templateParameters[0];
-    const char *valueType = d.templateParameters[1];
-
-    int n = h->size;
-
-    if (n < 0)
-        qProvokeSegFault();
-    if (n > 0) {
-        qCheckAccess(h->backward);
-        qCheckAccess(h->forward[0]);
-        qCheckPointer(h->backward->backward);
-        qCheckPointer(h->forward[0]->backward);
-    }
-
-    P(d, "iname", d.iname);
-    P(d, "addr", d.data);
-    P(d, "value", "<" << n << " items>");
-    P(d, "numchild", n);
-    if (d.dumpChildren) {
-        if (n > 100)
-            n = 100;
-        d << ",children=[";
-
-        QMapData::Node *node = reinterpret_cast<QMapData::Node *>(h->forward[0]);
-        QMapData::Node *end = reinterpret_cast<QMapData::Node *>(h);
-        int i = 0;
-
-        while (node != end) {
-            d.beginHash();
-                P(d, "name", "[" << i << "]");
-                P(d, "type", "QMap<" << keyType << "," << valueType << ">::Node");
-                P(d, "exp", "*('QMap<" << keyType << "," << valueType << ">::Node'*)" << node);
-            d.endHash();
-
-            ++i;
-            node = node->forward[0];
-        }
-        d << "]";
-    }
-
-    d.disarm();
-}
-
-static void qDumpQSet(QDumper &d)
-{
-    // This uses the knowledge that QHash<T> has only a single member
-    // of  union { QHashData *d; QHashNode<Key, T> *e; };
-    QHashData *hd = *(QHashData**)d.data;
-    QHashData::Node *node = hd->firstNode();
-
-    int n = hd->size;
-    if (n < 0)
-        qProvokeSegFault();
-    if (n > 0) {
-        qCheckAccess(node);
-        qCheckPointer(node->next);
-    }
-
-    P(d, "iname", d.iname);
-    P(d, "addr", d.data);
-    P(d, "value", "<" << n << " items>");
-    P(d, "valuedisabled", "true");
-    P(d, "numchild", 2 * n);
-    if (d.dumpChildren) {
-        if (n > 100)
-            n = 100;
-        d << ",children=[";
-        int i = 0;
-        for (int bucket = 0; bucket != hd->numBuckets; ++bucket) {
-            for (node = hd->buckets[bucket]; node->next; node = node->next) {
-                d.beginHash();
-                P(d, "name", "[" << i << "]");
-                P(d, "type", d.innertype);
-                P(d, "exp", "(('QHashNode<" << d.innertype
-                    << ",QHashDummyValue>'*)"
-                    << static_cast<const void*>(node) << ")->key"
-                );
-                d.endHash();
-                ++i;
-            }
-        }
-        d << "]";
-    }
-    d.disarm();
-}
-
-static void handleProtocolVersion2(QDumper & d)
-{
-    if (!d.outertype[0]) {
-        qDumpUnknown(d);
-        return;
-    }
-
-    d.setupTemplateParameters();
-    // d.outertype[0] is usally 'Q', so don't use it
-    switch (d.outertype[1]) {
-        case 'D':
-            if (qstrcmp(d.outertype, "QDateTime") == 0)
-                qDumpQDateTime(d);
-            else if (qstrcmp(d.outertype, "QDir") == 0)
-                qDumpQDir(d);
-            break;
-        case 'F':
-            if (qstrcmp(d.outertype, "QFileInfo") == 0)
-                qDumpQFileInfo(d);
-            break;
-        case 'H':
-            if (qstrcmp(d.outertype, "QHash") == 0)
-                qDumpQHash(d);
-            else if (qstrcmp(d.outertype, "QHashNode") == 0)
-                qDumpQHashNode(d);
-            break;
-        case 'L':
-            if (qstrcmp(d.outertype, "QList") == 0)
-                qDumpQList(d);
-            break;
-        case 'M':
-            if (qstrcmp(d.outertype, "QMap") == 0)
-                qDumpQMap(d);
-            else if (qstrcmp(d.outertype, "QMap::Node") == 0)
-                qDumpQMapNode(d);
-            break;
-        case 'O':
-            if (qstrcmp(d.outertype, "QObject") == 0)
-                qDumpQObject(d);
-            break;
-        case 'P':
-            if (qstrcmp(d.outertype, "QPropertyList") == 0)
-                qDumpQPropertyList(d);
-            break;
-        case 'S':
-            if (qstrcmp(d.outertype, "QSet") == 0)
-                qDumpQSet(d);
-            else if (qstrcmp(d.outertype, "QString") == 0)
-                qDumpQString(d);
-            else if (qstrcmp(d.outertype, "QStringList") == 0)
-                qDumpQStringList(d);
-            break;
-        case 'V':
-            if (qstrcmp(d.outertype, "QVariant") == 0)
-                qDumpQVariant(d);
-            else if (qstrcmp(d.outertype, "QVector") == 0)
-                qDumpQVector(d);
-            break;
-    }
-
-    if (!d.success)
-        qDumpUnknown(d);
-}
-
-} // anonymous namespace
-
-
-extern "C" Q_CORE_EXPORT void qDumpObjectData(
-    int protocolVersion,
-    int token,
-    const char *outertype,
-    const char *iname,
-    const char *exp,
-    const char *innertype,
-    const void *data,
-    bool dumpChildren)
-{
-    if (protocolVersion == 1) {
-        // used to test whether error output gets through
-        //fprintf(stderr, "using stderr, qDebug follows: %d\n", token);
-        //qDebug() << "using qDebug, stderr already used: " << token;
-    }
-
-    else if (protocolVersion == 2) {
-        QDumper d;
-        d.protocolVersion = protocolVersion;
-        d.token           = token;
-        d.outertype       = outertype ? outertype : "";
-        d.iname           = iname ? iname : "";
-        d.exp             = exp ? exp : "";
-        d.innertype       = innertype ? innertype : "";
-        d.data            = data ? data : "";
-        d.dumpChildren    = dumpChildren;
-        handleProtocolVersion2(d);
-    }
-
-    else {
-        qDebug() << "Unsupported protocol version" << protocolVersion;
-    }
-}
-
-QT_END_NAMESPACE
-
-#endif // !Q_OS_WINCE && !QT_NO_QDUMPER
diff --git a/src/corelib/tools/qeasingcurve.cpp b/src/corelib/tools/qeasingcurve.cpp
new file mode 100644
index 0000000..2b027fc
--- /dev/null
+++ b/src/corelib/tools/qeasingcurve.cpp
@@ -0,0 +1,846 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*
+
+| *property* | *Used for type* |
+| period     | QEasingCurve::{In,Out,InOut,OutIn}Elastic |
+| amplitude  | QEasingCurve::{In,Out,InOut,OutIn}Bounce, QEasingCurve::{In,Out,InOut,OutIn}Elastic |
+| overshoot  | QEasingCurve::{In,Out,InOut,OutIn}Back   |
+
+*/
+
+
+
+
+/*!
+    \class QEasingCurve
+    \since 4.6
+    \ingroup animation
+    \brief The QEasingCurve class provides easing curves for controlling animation.
+
+    Easing curves describe a function that controls how the speed of the interpolation
+    between 0 and 1 should be. Easing curves allow transitions from
+    one value to another to appear more natural than a simple constant speed would allow.
+    The QEasingCurve class is usually used in conjunction with the QAnimation class,
+    but can be used on its own.
+
+    To calculate the speed of the interpolation, the easing curve provides the function
+    valueForProgress(), where the \a progress argument specifies the progress of the
+    interpolation: 0 is the start value of the interpolation, 1 is the end value of the
+    interpolation. The returned value is the effective progress of the interpolation.
+    If the returned value is the same as the input value for all input values the easing
+    curve is a linear curve. This is the default behaviour.
+
+    For example,
+    \code
+    QEasingCurve easing(QEasingCurve::InOutQuad);
+
+    for(qreal t = 0.0; t < 1.0; t+=0.1)
+        qWarning() << "Effective progress" << t << " is
+                   << easing.valueForProgress(t);
+    \endcode
+    will print the effective progress of the interpolation between 0 and 1.
+
+    When using a QAnimation, the easing curve will be used to control the
+    progress of the interpolation between startValue and endValue:
+    \code
+    QAnimation animation;
+    animation.setStartValue(0);
+    animation.setEndValue(1000);
+    animation.setDuration(1000);
+    animation.setEasingCurve(QEasingCurve::InOutQuad);
+    \endcode
+ */
+
+/*!
+    \enum QEasingCurve::Type
+
+    The type of easing curve.
+
+    \value Linear       \inlineimage qeasingcurve-linear.png
+                        \br
+                        Easing equation function for a simple linear tweening,
+                        with no easing.
+    \value InQuad       \inlineimage qeasingcurve-inquad.png
+                        \br
+                        Easing equation function for a quadratic (t^2) easing
+                        in: accelerating from zero velocity.
+    \value OutQuad      \inlineimage qeasingcurve-outquad.png
+                        \br
+                        Easing equation function for a quadratic (t^2) easing
+                        out: decelerating to zero velocity.
+    \value InOutQuad    \inlineimage qeasingcurve-inoutquad.png
+                        \br
+                        Easing equation function for a quadratic (t^2) easing
+                        in/out: acceleration until halfway, then deceleration.
+    \value OutInQuad    \inlineimage qeasingcurve-outinquad.png
+                        \br
+                        Easing equation function for a quadratic (t^2) easing
+                        out/in: deceleration until halfway, then acceleration.
+    \value InCubic      \inlineimage qeasingcurve-incubic.png
+                        \br
+                        Easing equation function for a cubic (t^3) easing
+                        in: accelerating from zero velocity.
+    \value OutCubic     \inlineimage qeasingcurve-outcubic.png
+                        \br
+                        Easing equation function for a cubic (t^3) easing
+                        out: decelerating from zero velocity.
+    \value InOutCubic   \inlineimage qeasingcurve-inoutcubic.png
+                        \br
+                        Easing equation function for a cubic (t^3) easing
+                        in/out: acceleration until halfway, then deceleration.
+    \value OutInCubic   \inlineimage qeasingcurve-outincubic.png
+                        \br
+                        Easing equation function for a cubic (t^3) easing
+                        out/in: deceleration until halfway, then acceleration.
+    \value InQuart      \inlineimage qeasingcurve-inquart.png
+                        \br
+                        Easing equation function for a quartic (t^4) easing
+                        in: accelerating from zero velocity.
+    \value OutQuart     \inlineimage qeasingcurve-outquart.png
+                        \br
+                        Easing equation function for a quartic (t^4) easing
+                        out: decelerating from zero velocity.
+    \value InOutQuart   \inlineimage qeasingcurve-inoutquart.png
+                        \br
+                        Easing equation function for a quartic (t^4) easing
+                        in/out: acceleration until halfway, then deceleration.
+    \value OutInQuart   \inlineimage qeasingcurve-outinquart.png
+                        \br
+                        Easing equation function for a quartic (t^4) easing
+                        out/in: deceleration until halfway, then acceleration.
+    \value InQuint      \inlineimage qeasingcurve-inquint.png
+                        \br
+                        Easing equation function for a quintic (t^5) easing
+                        in: accelerating from zero velocity.
+    \value OutQuint     \inlineimage qeasingcurve-outquint.png
+                        \br
+                        Easing equation function for a quintic (t^5) easing
+                        out: decelerating from zero velocity.
+    \value InOutQuint   \inlineimage qeasingcurve-inoutquint.png
+                        \br
+                        Easing equation function for a quintic (t^5) easing
+                        in/out: acceleration until halfway, then deceleration.
+    \value OutInQuint   \inlineimage qeasingcurve-outinquint.png
+                        \br
+                        Easing equation function for a quintic (t^5) easing
+                        out/in: deceleration until halfway, then acceleration.
+    \value InSine       \inlineimage qeasingcurve-insine.png
+                        \br
+                        Easing equation function for a sinusoidal (sin(t)) easing
+                        in: accelerating from zero velocity.
+    \value OutSine      \inlineimage qeasingcurve-outsine.png
+                        \br
+                        Easing equation function for a sinusoidal (sin(t)) easing
+                        out: decelerating from zero velocity.
+    \value InOutSine    \inlineimage qeasingcurve-inoutsine.png
+                        \br
+                        Easing equation function for a sinusoidal (sin(t)) easing
+                        in/out: acceleration until halfway, then deceleration.
+    \value OutInSine    \inlineimage qeasingcurve-outinsine.png
+                        \br
+                        Easing equation function for a sinusoidal (sin(t)) easing
+                        out/in: deceleration until halfway, then acceleration.
+    \value InExpo       \inlineimage qeasingcurve-inexpo.png
+                        \br
+                        Easing equation function for an exponential (2^t) easing
+                        in: accelerating from zero velocity.
+    \value OutExpo      \inlineimage qeasingcurve-outexpo.png
+                        \br
+                        Easing equation function for an exponential (2^t) easing
+                        out: decelerating from zero velocity.
+    \value InOutExpo    \inlineimage qeasingcurve-inoutexpo.png
+                        \br
+                        Easing equation function for an exponential (2^t) easing
+                        in/out: acceleration until halfway, then deceleration.
+    \value OutInExpo    \inlineimage qeasingcurve-outinexpo.png
+                        \br
+                        Easing equation function for an exponential (2^t) easing
+                        out/in: deceleration until halfway, then acceleration.
+    \value InCirc       \inlineimage qeasingcurve-incirc.png
+                        \br
+                        Easing equation function for a circular (sqrt(1-t^2)) easing
+                        in: accelerating from zero velocity.
+    \value OutCirc      \inlineimage qeasingcurve-outcirc.png
+                        \br
+                        Easing equation function for a circular (sqrt(1-t^2)) easing
+                        out: decelerating from zero velocity.
+    \value InOutCirc    \inlineimage qeasingcurve-inoutcirc.png
+                        \br
+                        Easing equation function for a circular (sqrt(1-t^2)) easing
+                        in/out: acceleration until halfway, then deceleration.
+    \value OutInCirc    \inlineimage qeasingcurve-outincirc.png
+                        \br
+                        Easing equation function for a circular (sqrt(1-t^2)) easing
+                        out/in: deceleration until halfway, then acceleration.
+    \value InElastic    \inlineimage qeasingcurve-inelastic.png
+                        \br
+                        Easing equation function for an elastic
+                        (exponentially decaying sine wave) easing in:
+                        accelerating from zero velocity.  The peak amplitude
+                        can be set with the \e amplitude parameter, and the
+                        period of decay by the \e period parameter.
+    \value OutElastic   \inlineimage qeasingcurve-outelastic.png
+                        \br
+                        Easing equation function for an elastic
+                        (exponentially decaying sine wave) easing out:
+                        decelerating from zero velocity.  The peak amplitude
+                        can be set with the \e amplitude parameter, and the
+                        period of decay by the \e period parameter.
+    \value InOutElastic \inlineimage qeasingcurve-inoutelastic.png
+                        \br
+                        Easing equation function for an elastic
+                        (exponentially decaying sine wave) easing in/out:
+                        acceleration until halfway, then deceleration.
+    \value OutInElastic \inlineimage qeasingcurve-outinelastic.png
+                        \br
+                        Easing equation function for an elastic
+                        (exponentially decaying sine wave) easing out/in:
+                        deceleration until halfway, then acceleration.
+    \value InBack       \inlineimage qeasingcurve-inback.png
+                        \br
+                        Easing equation function for a back (overshooting
+                        cubic easing: (s+1)*t^3 - s*t^2) easing in:
+                        accelerating from zero velocity.
+    \value OutBack      \inlineimage qeasingcurve-outback.png
+                        \br
+                        Easing equation function for a back (overshooting
+                        cubic easing: (s+1)*t^3 - s*t^2) easing out:
+                        decelerating from zero velocity.
+    \value InOutBack    \inlineimage qeasingcurve-inoutback.png
+                        \br
+                        Easing equation function for a back (overshooting
+                        cubic easing: (s+1)*t^3 - s*t^2) easing in/out:
+                        acceleration until halfway, then deceleration.
+    \value OutInBack    \inlineimage qeasingcurve-outinback.png
+                        \br
+                        Easing equation function for a back (overshooting
+                        cubic easing: (s+1)*t^3 - s*t^2) easing out/in:
+                        deceleration until halfway, then acceleration.
+    \value InBounce     \inlineimage qeasingcurve-inbounce.png
+                        \br
+                        Easing equation function for a bounce (exponentially
+                        decaying parabolic bounce) easing in: accelerating
+                        from zero velocity.
+    \value OutBounce    \inlineimage qeasingcurve-outbounce.png
+                        \br
+                        Easing equation function for a bounce (exponentially
+                        decaying parabolic bounce) easing out: decelerating
+                        from zero velocity.
+    \value InOutBounce  \inlineimage qeasingcurve-inoutbounce.png
+                        \br
+                        Easing equation function for a bounce (exponentially
+                        decaying parabolic bounce) easing in/out:
+                        acceleration until halfway, then deceleration.
+    \value OutInBounce  \inlineimage qeasingcurve-outinbounce.png
+                        \br
+                        Easing equation function for a bounce (exponentially
+                        decaying parabolic bounce) easing out/in:
+                        deceleration until halfway, then acceleration.
+    \omitvalue InCurve
+    \omitvalue OutCurve
+    \omitvalue SineCurve
+    \omitvalue CosineCurve
+    \value Custom       This is returned if the user have specified a custom curve type with setCustomType(). Note that you cannot call setType() with this value, but type() can return it.
+    \omitvalue NCurveTypes
+*/
+
+/*!
+    \typedef QEasingCurve::EasingFunction
+
+    This is a typedef for a pointer to a function with the following
+    signature:
+
+    \snippet doc/src/snippets/code/src_corelib_tools_qeasingcurve.cpp 0
+*/
+
+#include "qeasingcurve.h"
+
+#ifndef QT_NO_DEBUG_STREAM
+#include <QtCore/qdebug.h>
+#include <QtCore/QString>
+#endif
+
+QT_BEGIN_NAMESPACE
+
+static bool isConfigFunction(QEasingCurve::Type type)
+{
+    return type >= QEasingCurve::InElastic
+            && type <= QEasingCurve::OutInBounce;
+}
+
+class QEasingCurveFunction
+{
+public:
+    enum Type { In, Out, InOut, OutIn };
+
+    QEasingCurveFunction(QEasingCurveFunction::Type type = In, qreal period = 0.3, qreal amplitude = 1.0,
+        qreal overshoot = 1.70158f)
+        : _t(type), _p(period), _a(amplitude), _o(overshoot)
+    { }
+    virtual ~QEasingCurveFunction() {}
+    virtual qreal value(qreal t);
+    virtual QEasingCurveFunction *copy() const;
+    bool operator==(const QEasingCurveFunction& other);
+
+    Type _t;
+    qreal _p;
+    qreal _a;
+    qreal _o;
+};
+
+qreal QEasingCurveFunction::value(qreal t)
+{
+    return t;
+}
+
+QEasingCurveFunction *QEasingCurveFunction::copy() const
+{
+    return new QEasingCurveFunction(_t, _p, _a, _o);
+}
+
+bool QEasingCurveFunction::operator==(const QEasingCurveFunction& other)
+{
+    return _t == other._t &&
+           _p == other._p &&
+           _a == other._a &&
+           _o == other._o;
+}
+
+QT_BEGIN_INCLUDE_NAMESPACE
+#include "../../3rdparty/easing/easing.cpp"
+QT_END_INCLUDE_NAMESPACE
+
+class QEasingCurvePrivate
+{
+public:
+    QEasingCurvePrivate()
+        : type(QEasingCurve::Linear),
+          config(0),
+          func(&easeNone)
+    { }
+    ~QEasingCurvePrivate() { delete config; }
+    void setType_helper(QEasingCurve::Type);
+
+    QEasingCurve::Type type;
+    QEasingCurveFunction *config;
+    QEasingCurve::EasingFunction func;
+};
+
+struct ElasticEase : public QEasingCurveFunction
+{
+    ElasticEase(Type type)
+        : QEasingCurveFunction(type, qreal(0.3), qreal(1.0))
+    { }
+
+    QEasingCurveFunction *copy() const
+    {
+        ElasticEase *rv = new ElasticEase(_t);
+        rv->_p = _p;
+        rv->_a = _a;
+        return rv;
+    }
+
+    qreal value(qreal t)
+    {
+        qreal p = (_p < 0) ? 0.3f : _p;
+        qreal a = (_a < 0) ? 1.0f : _a;
+        switch(_t) {
+        case In:
+            return easeInElastic(t, a, p);
+        case Out:
+            return easeOutElastic(t, a, p);
+        case InOut:
+            return easeInOutElastic(t, a, p);
+        case OutIn:
+            return easeOutInElastic(t, a, p);
+        default:
+            return t;
+        }
+    }
+};
+
+struct BounceEase : public QEasingCurveFunction
+{
+    BounceEase(Type type)
+        : QEasingCurveFunction(type, 0.3f, 1.0f)
+    { }
+
+    QEasingCurveFunction *copy() const
+    {
+        BounceEase *rv = new BounceEase(_t);
+        rv->_a = _a;
+        return rv;
+    }
+
+    qreal value(qreal t)
+    {
+        qreal a = (_a < 0) ? 1.0f : _a;
+        switch(_t) {
+        case In:
+            return easeInBounce(t, a);
+        case Out:
+            return easeOutBounce(t, a);
+        case InOut:
+            return easeInOutBounce(t, a);
+        case OutIn:
+            return easeOutInBounce(t, a);
+        default:
+            return t;
+        }
+    }
+};
+
+struct BackEase : public QEasingCurveFunction
+{
+    BackEase(Type type)
+        : QEasingCurveFunction(type, 0.3f, 1.0f, 1.70158f)
+    { }
+
+    QEasingCurveFunction *copy() const
+    {
+        BackEase *rv = new BackEase(_t);
+        rv->_o = _o;
+        return rv;
+    }
+
+    qreal value(qreal t)
+    {
+        qreal o = (_o < 0) ? 1.70158f : _o;
+        switch(_t) {
+        case In:
+            return easeInBack(t, o);
+        case Out:
+            return easeOutBack(t, o);
+        case InOut:
+            return easeInOutBack(t, o);
+        case OutIn:
+            return easeOutInBack(t, o);
+        default:
+            return t;
+        }
+    }
+};
+
+static QEasingCurve::EasingFunction curveToFunc(QEasingCurve::Type curve)
+{
+    switch(curve) {
+    case QEasingCurve::Linear:
+        return &easeNone;
+    case QEasingCurve::InQuad:
+        return &easeInQuad;
+    case QEasingCurve::OutQuad:
+        return &easeOutQuad;
+    case QEasingCurve::InOutQuad:
+        return &easeInOutQuad;
+    case QEasingCurve::OutInQuad:
+        return &easeOutInQuad;
+    case QEasingCurve::InCubic:
+        return &easeInCubic;
+    case QEasingCurve::OutCubic:
+        return &easeOutCubic;
+    case QEasingCurve::InOutCubic:
+        return &easeInOutCubic;
+    case QEasingCurve::OutInCubic:
+        return &easeOutInCubic;
+    case QEasingCurve::InQuart:
+        return &easeInQuart;
+    case QEasingCurve::OutQuart:
+        return &easeOutQuart;
+    case QEasingCurve::InOutQuart:
+        return &easeInOutQuart;
+    case QEasingCurve::OutInQuart:
+        return &easeOutInQuart;
+    case QEasingCurve::InQuint:
+        return &easeInQuint;
+    case QEasingCurve::OutQuint:
+        return &easeOutQuint;
+    case QEasingCurve::InOutQuint:
+        return &easeInOutQuint;
+    case QEasingCurve::OutInQuint:
+        return &easeOutInQuint;
+    case QEasingCurve::InSine:
+        return &easeInSine;
+    case QEasingCurve::OutSine:
+        return &easeOutSine;
+    case QEasingCurve::InOutSine:
+        return &easeInOutSine;
+    case QEasingCurve::OutInSine:
+        return &easeOutInSine;
+    case QEasingCurve::InExpo:
+        return &easeInExpo;
+    case QEasingCurve::OutExpo:
+        return &easeOutExpo;
+    case QEasingCurve::InOutExpo:
+        return &easeInOutExpo;
+    case QEasingCurve::OutInExpo:
+        return &easeOutInExpo;
+    case QEasingCurve::InCirc:
+        return &easeInCirc;
+    case QEasingCurve::OutCirc:
+        return &easeOutCirc;
+    case QEasingCurve::InOutCirc:
+        return &easeInOutCirc;
+    case QEasingCurve::OutInCirc:
+        return &easeOutInCirc;
+    // Internal for, compatibility with QTimeLine only ??
+    case QEasingCurve::InCurve:
+        return &easeInCurve;
+    case QEasingCurve::OutCurve:
+        return &easeOutCurve;
+    case QEasingCurve::SineCurve:
+        return &easeSineCurve;
+    case QEasingCurve::CosineCurve:
+        return &easeCosineCurve;
+    default:
+        return 0;
+    };
+}
+
+static QEasingCurveFunction *curveToFunctionObject(QEasingCurve::Type type)
+{
+    QEasingCurveFunction *curveFunc = 0;
+    switch(type) {
+    case QEasingCurve::InElastic:
+        curveFunc = new ElasticEase(ElasticEase::In);
+        break;
+    case QEasingCurve::OutElastic:
+        curveFunc = new ElasticEase(ElasticEase::Out);
+        break;
+    case QEasingCurve::InOutElastic:
+        curveFunc = new ElasticEase(ElasticEase::InOut);
+        break;
+    case QEasingCurve::OutInElastic:
+        curveFunc = new ElasticEase(ElasticEase::OutIn);
+        break;
+    case QEasingCurve::OutBounce:
+        curveFunc = new BounceEase(BounceEase::Out);
+        break;
+    case QEasingCurve::InBounce:
+        curveFunc = new BounceEase(BounceEase::In);
+        break;
+    case QEasingCurve::OutInBounce:
+        curveFunc = new BounceEase(BounceEase::OutIn);
+        break;
+    case QEasingCurve::InOutBounce:
+        curveFunc = new BounceEase(BounceEase::InOut);
+        break;
+    case QEasingCurve::InBack:
+        curveFunc = new BackEase(BackEase::In);
+        break;
+    case QEasingCurve::OutBack:
+        curveFunc = new BackEase(BackEase::Out);
+        break;
+    case QEasingCurve::InOutBack:
+        curveFunc = new BackEase(BackEase::InOut);
+        break;
+    case QEasingCurve::OutInBack:
+        curveFunc = new BackEase(BackEase::OutIn);
+        break;
+    default:
+        curveFunc = new QEasingCurveFunction(QEasingCurveFunction::In, 0.3f, 1.0f, 1.70158f);     // ###
+    }
+
+    return curveFunc;
+}
+
+/*!
+    Constructs an easing curve of the given \a type.
+ */
+QEasingCurve::QEasingCurve(Type type)
+    : d_ptr(new QEasingCurvePrivate)
+{
+    setType(type);
+}
+
+/*!
+    Construct a copy of \a other.
+ */
+QEasingCurve::QEasingCurve(const QEasingCurve &other)
+: d_ptr(new QEasingCurvePrivate)
+{
+    // ### non-atomic, requires malloc on shallow copy
+    *d_ptr = *other.d_ptr;
+    if(other.d_ptr->config)
+        d_ptr->config = other.d_ptr->config->copy();
+}
+
+/*!
+    Destructor.
+ */
+
+QEasingCurve::~QEasingCurve()
+{
+    delete d_ptr;
+}
+
+/*!
+    Copy \a other.
+ */
+QEasingCurve &QEasingCurve::operator=(const QEasingCurve &other)
+{
+    // ### non-atomic, requires malloc on shallow copy
+    if (d_ptr->config) {
+        delete d_ptr->config;
+        d_ptr->config = 0;
+    }
+
+    *d_ptr = *other.d_ptr;
+    if(other.d_ptr->config)
+        d_ptr->config = other.d_ptr->config->copy();
+
+    return *this;
+}
+
+/*!
+    Compare this easing curve with \a other and returns true if they are
+    equal. It will also compare the properties of a curve.
+ */
+bool QEasingCurve::operator==(const QEasingCurve &other) const
+{
+    bool res = d_ptr->func == other.d_ptr->func
+            && d_ptr->type == other.d_ptr->type;
+    if (res && d_ptr->config && other.d_ptr->config) {
+        // catch the config content
+        res = d_ptr->config->operator==(*(other.d_ptr->config));
+    }
+    return res;
+}
+
+/*!
+    \fn bool QEasingCurve::operator!=(const QEasingCurve &other) const
+    Compare this easing curve with \a other and returns true if they are not equal.
+    It will also compare the properties of a curve.
+
+    \sa operator==()
+*/
+
+/*!
+    Returns the amplitude. This is not applicable for all curve types.
+    It is only applicable for bounce and elastic curves (curves of type()
+    QEasingCurve::InBounce, QEasingCurve::OutBounce, QEasingCurve::InOutBounce,
+    QEasingCurve::OutInBounce, QEasingCurve::InElastic, QEasingCurve::OutElastic,
+    QEasingCurve::InOutElastic or QEasingCurve::OutInElastic).
+ */
+qreal QEasingCurve::amplitude() const
+{
+    return d_ptr->config ? d_ptr->config->_a : 1.0;
+}
+
+/*!
+    Sets the amplitude to \a amplitude.
+
+    This will set the amplitude of the bounce or the amplitude of the
+    elastic "spring" effect. The higher the number, the higher the amplitude.
+    \sa amplitude()
+*/
+void QEasingCurve::setAmplitude(qreal amplitude)
+{
+    if (!d_ptr->config)
+        d_ptr->config = curveToFunctionObject(d_ptr->type);
+    d_ptr->config->_a = amplitude;
+}
+
+/*!
+    Returns the period. This is not applicable for all curve types.
+    It is only applicable if type() is QEasingCurve::InElastic, QEasingCurve::OutElastic,
+    QEasingCurve::InOutElastic or QEasingCurve::OutInElastic.
+ */
+qreal QEasingCurve::period() const
+{
+    return d_ptr->config ? d_ptr->config->_p : 0.3;
+}
+
+/*!
+    Sets the period to \a period.
+    Setting a small period value will give a high frequency of the curve. A
+    large period will give it a small frequency.
+
+    \sa period()
+*/
+void QEasingCurve::setPeriod(qreal period)
+{
+    if (!d_ptr->config)
+        d_ptr->config = curveToFunctionObject(d_ptr->type);
+    d_ptr->config->_p = period;
+}
+
+/*!
+    Returns the overshoot. This is not applicable for all curve types.
+    It is only applicable if type() is QEasingCurve::InBack, QEasingCurve::OutBack,
+    QEasingCurve::InOutBack or QEasingCurve::OutInBack.
+ */
+qreal QEasingCurve::overshoot() const
+{
+    return d_ptr->config ? d_ptr->config->_o : 1.70158f;
+}
+
+/*!
+    Sets the overshoot to \a overshoot.
+
+    0 produces no overshoot, and the default value of 1.70158 produces an overshoot of 10 percent.
+
+    \sa overshoot()
+*/
+void QEasingCurve::setOvershoot(qreal overshoot)
+{
+    if (!d_ptr->config)
+        d_ptr->config = curveToFunctionObject(d_ptr->type);
+    d_ptr->config->_o = overshoot;
+}
+
+/*!
+    Returns the type of the easing curve.
+*/
+QEasingCurve::Type QEasingCurve::type() const
+{
+    return d_ptr->type;
+}
+
+void QEasingCurvePrivate::setType_helper(QEasingCurve::Type newType)
+{
+    qreal amp = -1.0;
+    qreal period = -1.0;
+    qreal overshoot = -1.0;
+
+    if (config) {
+        amp = config->_a;
+        period = config->_p;
+        overshoot = config->_o;
+        delete config;
+        config = 0;
+    }
+
+    if (isConfigFunction(newType) || (amp != -1.0) || (period != -1.0) || (overshoot != -1.0)) {
+        config = curveToFunctionObject(newType);
+        if (amp != -1.0)
+            config->_a = amp;
+        if (period != -1.0)
+            config->_p = period;
+        if (overshoot != -1.0)
+            config->_o = overshoot;
+        func = 0;
+    } else if (newType != QEasingCurve::Custom) {
+        func = curveToFunc(newType);
+    }
+    Q_ASSERT((func == 0) == (config != 0));
+    type = newType;
+}
+
+/*!
+    Sets the type of the easing curve to \a type.
+*/
+void QEasingCurve::setType(Type type)
+{
+    if (d_ptr->type == type)
+        return;
+    if (type < Linear || type >= NCurveTypes - 1) {
+        qWarning("QEasingCurve: Invalid curve type %d", type);
+        return;
+    }
+
+    d_ptr->setType_helper(type);
+}
+
+/*!
+    Sets a custom easing curve that is defined by the user in the function \a func.
+    The signature of the function is qreal myEasingFunction(qreal progress),
+    where \e progress and the return value is considered to be normalized between 0 and 1.
+    (In some cases the return value can be outside that range)
+    After calling this function type() will return QEasingCurve::Custom.
+    \a func cannot be zero.
+
+    \sa customType()
+    \sa valueForProgress()
+*/
+void QEasingCurve::setCustomType(EasingFunction func)
+{
+    if (!func) {
+        qWarning("Function pointer must not be null");
+        return;
+    }
+    d_ptr->func = func;
+    d_ptr->setType_helper(Custom);
+}
+
+/*!
+    Returns the function pointer to the custom easing curve.
+    If type() does not return QEasingCurve::Custom, this function
+    will return 0.
+*/
+QEasingCurve::EasingFunction QEasingCurve::customType() const
+{
+    return d_ptr->type == Custom ? d_ptr->func : 0;
+}
+
+/*!
+    Return the effective progress for the easing curve at \a progress.
+    While  \a progress must be between 0 and 1, the returned effective progress
+    can be outside those bounds. For instance, QEasingCurve::InBack will
+    return negative values in the beginning of the function.
+ */
+qreal QEasingCurve::valueForProgress(qreal progress) const
+{
+    progress = qBound<qreal>(0, progress, 1);
+    if (d_ptr->func)
+        return d_ptr->func(progress);
+    else if (d_ptr->config)
+        return d_ptr->config->value(progress);
+    else
+        return progress;
+}
+
+#ifndef QT_NO_DEBUG_STREAM
+QDebug operator<<(QDebug debug, const QEasingCurve &item)
+{
+    debug << "type:" << item.d_ptr->type
+          << "func:" << item.d_ptr->func;
+    if (item.d_ptr->config) {
+        debug << QString::fromAscii("period:%1").arg(item.d_ptr->config->_p, 0, 'f', 20)
+              << QString::fromAscii("amp:%1").arg(item.d_ptr->config->_a, 0, 'f', 20)
+              << QString::fromAscii("overshoot:%1").arg(item.d_ptr->config->_o, 0, 'f', 20);
+    }
+    return debug;
+}
+#endif
+
+QT_END_NAMESPACE
diff --git a/src/corelib/tools/qeasingcurve.h b/src/corelib/tools/qeasingcurve.h
new file mode 100644
index 0000000..a240bc0
--- /dev/null
+++ b/src/corelib/tools/qeasingcurve.h
@@ -0,0 +1,114 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QEASINGCURVE_H
+#define QEASINGCURVE_H
+
+#include <QtCore/qglobal.h>
+#include <QtCore/qobjectdefs.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QEasingCurvePrivate;
+class Q_CORE_EXPORT QEasingCurve
+{
+    Q_GADGET
+    Q_ENUMS(Type)
+public:
+    enum Type {
+        Linear,
+        InQuad, OutQuad, InOutQuad, OutInQuad,
+        InCubic, OutCubic, InOutCubic, OutInCubic,
+        InQuart, OutQuart, InOutQuart, OutInQuart,
+        InQuint, OutQuint, InOutQuint, OutInQuint,
+        InSine, OutSine, InOutSine, OutInSine,
+        InExpo, OutExpo, InOutExpo, OutInExpo,
+        InCirc, OutCirc, InOutCirc, OutInCirc,
+        InElastic, OutElastic, InOutElastic, OutInElastic,
+        InBack, OutBack, InOutBack, OutInBack,
+        InBounce, OutBounce, InOutBounce, OutInBounce,
+        InCurve, OutCurve, SineCurve, CosineCurve,
+        Custom, NCurveTypes
+    };
+
+    QEasingCurve(Type type = Linear);
+    QEasingCurve(const QEasingCurve &other);
+    ~QEasingCurve();
+
+    QEasingCurve &operator=(const QEasingCurve &other);
+    bool operator==(const QEasingCurve &other) const;
+    inline bool operator!=(const QEasingCurve &other) const
+    { return !(this->operator==(other)); }
+
+    qreal amplitude() const;
+    void setAmplitude(qreal amplitude);
+
+    qreal period() const;
+    void setPeriod(qreal period);
+
+    qreal overshoot() const;
+    void setOvershoot(qreal overshoot);
+
+    Type type() const;
+    void setType(Type type);
+    typedef qreal (*EasingFunction)(qreal progress);
+    void setCustomType(EasingFunction func);
+    EasingFunction customType() const;
+
+    qreal valueForProgress(qreal progress) const;
+private:
+    QEasingCurvePrivate *d_ptr;
+    friend Q_CORE_EXPORT QDebug operator<<(QDebug debug, const QEasingCurve &item);
+};
+
+#ifndef QT_NO_DEBUG_STREAM
+Q_CORE_EXPORT QDebug operator<<(QDebug debug, const QEasingCurve &item);
+#endif
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/corelib/tools/qhash.cpp b/src/corelib/tools/qhash.cpp
index 21d98b5..2313e0e 100644
--- a/src/corelib/tools/qhash.cpp
+++ b/src/corelib/tools/qhash.cpp
@@ -379,6 +379,107 @@ void QHashData::checkSanity()
 #endif
 
 /*!
+    \fn uint qHash(const QPair<T1, T2> &key)
+    \since 4.3
+    \relates QHash
+    
+    Returns the hash value for the \a key.
+
+    Types \c T1 and \c T2 must be supported by qHash().
+*/
+
+/*! \fn uint qHash(char key)
+    \relates QHash
+
+    Returns the hash value for the \a key.
+*/
+
+/*! \fn uint qHash(uchar key)
+    \relates QHash
+
+    Returns the hash value for the \a key.
+*/
+
+/*! \fn uint qHash(signed char key)
+    \relates QHash
+
+    Returns the hash value for the \a key.
+*/
+
+/*! \fn uint qHash(ushort key)
+    \relates QHash
+
+    Returns the hash value for the \a key.
+*/
+
+/*! \fn uint qHash(short key)
+    \relates QHash
+
+    Returns the hash value for the \a key.
+*/
+
+/*! \fn uint qHash(uint key)
+    \relates QHash
+
+    Returns the hash value for the \a key.
+*/
+
+/*! \fn uint qHash(int key)
+    \relates QHash
+
+    Returns the hash value for the \a key.
+*/
+
+/*! \fn uint qHash(ulong key)
+    \relates QHash
+
+    Returns the hash value for the \a key.
+*/
+
+/*! \fn uint qHash(long key)
+    \relates QHash
+
+    Returns the hash value for the \a key.
+*/
+
+/*! \fn uint qHash(quint64 key)
+    \relates QHash
+
+    Returns the hash value for the \a key.
+*/
+
+/*! \fn uint qHash(qint64 key)
+    \relates QHash
+
+    Returns the hash value for the \a key.
+*/
+
+/*! \fn uint qHash(QChar key)
+    \relates QHash
+
+    Returns the hash value for the \a key.
+*/
+
+/*! \fn uint qHash(const QByteArray &key)
+    \fn uint qHash(const QBitArray &key)
+    \relates QHash
+
+    Returns the hash value for the \a key.
+*/
+
+/*! \fn uint qHash(const QString &key)
+    \relates QHash
+
+    Returns the hash value for the \a key.
+*/
+
+/*! \fn uint qHash(const T *key)
+    \relates QHash
+
+    Returns the hash value for the \a key.
+*/
+
+/*!
     \class QHash
     \brief The QHash class is a template class that provides a hash-table-based dictionary.
 
@@ -401,7 +502,8 @@ void QHashData::checkSanity()
        key. With QHash, the items are arbitrarily ordered.
     \i The key type of a QMap must provide operator<(). The key
        type of a QHash must provide operator==() and a global
-       \l{qHash()}{qHash}(Key) function.
+       hash function called qHash() (see the related non-member
+       functions).
     \endlist
 
     Here's an example QHash with QString keys and \c int values:
@@ -732,7 +834,6 @@ void QHashData::checkSanity()
 */
 
 /*! \fn const T QHash::value(const Key &key, const T &defaultValue) const
-
     \overload
 
     If the hash contains no item with the given \a key, the function returns
@@ -1490,121 +1591,6 @@ void QHashData::checkSanity()
     \sa operator+=(), operator-()
 */
 
-/*! \fn uint qHash(char key)
-    \relates QHash
-
-    Returns the hash value for the \a key.
-*/
-
-/*! \fn uint qHash(uchar key)
-    \relates QHash
-    \overload
-
-    Returns the hash value for the \a key.
-*/
-
-/*! \fn uint qHash(signed char key)
-    \relates QHash
-    \overload
-
-    Returns the hash value for the \a key.
-*/
-
-/*! \fn uint qHash(ushort key)
-    \relates QHash
-    \overload
-
-    Returns the hash value for the \a key.
-*/
-
-/*! \fn uint qHash(short key)
-    \relates QHash
-    \overload
-
-    Returns the hash value for the \a key.
-*/
-
-/*! \fn uint qHash(uint key)
-    \relates QHash
-    \overload
-
-    Returns the hash value for the \a key.
-*/
-
-/*! \fn uint qHash(int key)
-    \relates QHash
-    \overload
-
-    Returns the hash value for the \a key.
-*/
-
-/*! \fn uint qHash(ulong key)
-    \relates QHash
-    \overload
-
-    Returns the hash value for the \a key.
-*/
-
-/*! \fn uint qHash(long key)
-    \relates QHash
-    \overload
-
-    Returns the hash value for the \a key.
-*/
-
-/*! \fn uint qHash(quint64 key)
-    \relates QHash
-    \overload
-
-    Returns the hash value for the \a key.
-*/
-
-/*! \fn uint qHash(qint64 key)
-    \relates QHash
-    \overload
-
-    Returns the hash value for the \a key.
-*/
-
-/*! \fn uint qHash(QChar key)
-    \relates QHash
-    \overload
-
-    Returns the hash value for the \a key.
-*/
-
-/*! \fn uint qHash(const QByteArray &key)
-    \fn uint qHash(const QBitArray &key)
-    \relates QHash
-    \overload
-
-    Returns the hash value for the \a key.
-*/
-
-/*! \fn uint qHash(const QString &key)
-    \relates QHash
-    \overload
-
-    Returns the hash value for the \a key.
-*/
-
-/*! \fn uint qHash(const T *key)
-    \relates QHash
-    \overload
-
-    Returns the hash value for the \a key.
-*/
-
-/*!
-    \fn uint qHash(const QPair<T1, T2> &key)
-    \relates QHash
-    \since 4.3
-
-    Returns the hash value for the \a key.
-
-    Types \c T1 and \c T2 must be supported by qHash().
-*/
-
 /*! \fn QDataStream &operator<<(QDataStream &out, const QHash<Key, T>& hash)
     \relates QHash
 
diff --git a/src/corelib/tools/qhash.h b/src/corelib/tools/qhash.h
index a18b531..632c422 100644
--- a/src/corelib/tools/qhash.h
+++ b/src/corelib/tools/qhash.h
@@ -97,10 +97,7 @@ Q_CORE_EXPORT uint qHash(const QBitArray &key);
 #endif
 template <class T> inline uint qHash(const T *key)
 {
-    if (sizeof(const T *) > sizeof(uint))
-        return qHash(reinterpret_cast<quint64>(key));
-    else
-        return uint(reinterpret_cast<ulong>(key));
+    return qHash(reinterpret_cast<quintptr>(key));
 }
 #if defined(Q_CC_MSVC)
 #pragma warning( pop )
diff --git a/src/corelib/tools/qline.cpp b/src/corelib/tools/qline.cpp
index f615dcd..88825a3 100644
--- a/src/corelib/tools/qline.cpp
+++ b/src/corelib/tools/qline.cpp
@@ -260,7 +260,7 @@ QT_BEGIN_NAMESPACE
 #ifndef QT_NO_DEBUG_STREAM
 QDebug operator<<(QDebug d, const QLine &p)
 {
-    d << "QLine(" << p.p1() << "," << p.p2() << ")";
+    d << "QLine(" << p.p1() << ',' << p.p2() << ')';
     return d;
 }
 #endif
@@ -822,7 +822,7 @@ qreal QLineF::angle(const QLineF &l) const
 #ifndef QT_NO_DEBUG_STREAM
 QDebug operator<<(QDebug d, const QLineF &p)
 {
-    d << "QLineF(" << p.p1() << "," << p.p2() << ")";
+    d << "QLineF(" << p.p1() << ',' << p.p2() << ')';
     return d;
 }
 #endif
diff --git a/src/corelib/tools/qlistdata.cpp b/src/corelib/tools/qlistdata.cpp
index d40b6b6..34a5d80 100644
--- a/src/corelib/tools/qlistdata.cpp
+++ b/src/corelib/tools/qlistdata.cpp
@@ -1173,7 +1173,8 @@ void **QListData::erase(void **xi)
 
 /*! \typedef QList::iterator::iterator_category
 
-    \internal
+  A synonym for \e {std::random_access_iterator_tag} indicating
+  this iterator is a random access iterator.
 */
 
 /*! \typedef QList::iterator::difference_type
@@ -1432,7 +1433,8 @@ void **QListData::erase(void **xi)
 
 /*! \typedef QList::const_iterator::iterator_category
 
-    \internal
+  A synonym for \e {std::random_access_iterator_tag} indicating
+  this iterator is a random access iterator.
 */
 
 /*! \typedef QList::const_iterator::difference_type
diff --git a/src/corelib/tools/qlocale.cpp b/src/corelib/tools/qlocale.cpp
index a2154a9..8c740bd 100644
--- a/src/corelib/tools/qlocale.cpp
+++ b/src/corelib/tools/qlocale.cpp
@@ -42,7 +42,6 @@
 #include "qglobal.h"
 
 #ifndef QT_NO_SYSTEMLOCALE
-#define QLOCALE_CPP
 QT_BEGIN_NAMESPACE
 class QSystemLocale;
 static QSystemLocale *QSystemLocale_globalSystemLocale();
@@ -120,7 +119,7 @@ static char *_qdtoa( NEEDS_VOLATILE double d, int mode, int ndigits, int *decpt,
 Q_CORE_EXPORT char *qdtoa(double d, int mode, int ndigits, int *decpt,
                         int *sign, char **rve, char **digits_str);
 Q_CORE_EXPORT double qstrtod(const char *s00, char const **se, bool *ok);
-Q_CORE_EXPORT qlonglong qstrtoll(const char *nptr, const char **endptr, register int base, bool *ok);
+static qlonglong qstrtoll(const char *nptr, const char **endptr, register int base, bool *ok);
 static qulonglong qstrtoull(const char *nptr, const char **endptr, register int base, bool *ok);
 
 /******************************************************************************
@@ -321,7 +320,7 @@ static QString readEscapedFormatString(const QString &format, int *idx)
 {
     int &i = *idx;
 
-    Q_ASSERT(format.at(i).unicode() == '\'');
+    Q_ASSERT(format.at(i) == QLatin1Char('\''));
     ++i;
     if (i == format.size())
         return QString();
@@ -635,7 +634,7 @@ static QLocale::MeasurementSystem winSystemMeasurementSystem()
         QString iMeasure = QT_WA_INLINE(
                 QString::fromUtf16(reinterpret_cast<ushort*>(output)),
                 QString::fromLocal8Bit(reinterpret_cast<char*>(output)));
-        if (iMeasure == QString::fromLatin1("1")) {
+        if (iMeasure == QLatin1String("1")) {
             return QLocale::ImperialSystem;
         }
     }
@@ -1136,7 +1135,7 @@ static QString macToQtFormat(const QString &sys_fmt)
                 break;
             case 'S': // fractional second
                 if (repeat < 3)
-                    result += QLatin1String("z");
+                    result += QLatin1Char('z');
                 else
                     result += QLatin1String("zzz");
                 break;
@@ -1150,7 +1149,7 @@ static QString macToQtFormat(const QString &sys_fmt)
                 if (repeat >= 2)
                     result += QLatin1String("dd");
                 else
-                    result += QLatin1String("d");
+                    result += QLatin1Char('d');
                 break;
             case 'a':
                 result += QLatin1String("AP");
@@ -1589,7 +1588,7 @@ QDataStream &operator>>(QDataStream &ds, QLocale &l)
        defaults to the default locale (see setDefault()).
     \endlist
 
-    The "C" locale is identical to \l{English}/\l{UnitedStates}.
+    The "C" locale is identical in behavior to \l{English}/\l{UnitedStates}.
 
     Use language() and country() to determine the actual language and
     country values used.
@@ -1602,6 +1601,8 @@ QDataStream &operator>>(QDataStream &ds, QLocale &l)
     This constructor converts the locale name to a language/country
     pair; it does not use the system locale database.
 
+    QLocale's data is based on Common Locale Data Repository v1.6.1.
+
     The double-to-string and string-to-double conversion functions are
     covered by the following licenses:
 
@@ -1622,8 +1623,6 @@ QDataStream &operator>>(QDataStream &ds, QLocale &l)
     This product includes software developed by the University of
     California, Berkeley and its contributors.
 
-    QLocale's data is based on Common Locale Data Repository v1.6.1.
-
     \sa QString::arg(), QString::toInt(), QString::toDouble()
 */
 
@@ -1632,7 +1631,7 @@ QDataStream &operator>>(QDataStream &ds, QLocale &l)
 
     This enumerated type is used to specify a language.
 
-    \value C The "C" locale is English/UnitedStates.
+    \value C The "C" locale is identical in behavior to English/UnitedStates.
     \value Abkhazian
     \value Afan
     \value Afar
@@ -4671,7 +4670,7 @@ static qulonglong qstrtoull(const char *nptr, const char **endptr, register int
  * Ignores `locale' stuff.  Assumes that the upper and lower case
  * alphabets and digits are each contiguous.
  */
-Q_CORE_EXPORT qlonglong qstrtoll(const char *nptr, const char **endptr, register int base, bool *ok)
+static qlonglong qstrtoll(const char *nptr, const char **endptr, register int base, bool *ok)
 {
     register const char *s;
     register qulonglong acc;
diff --git a/src/corelib/tools/qlocale.h b/src/corelib/tools/qlocale.h
index 5b611eb..987ab4e 100644
--- a/src/corelib/tools/qlocale.h
+++ b/src/corelib/tools/qlocale.h
@@ -99,11 +99,9 @@ public:
     virtual QVariant query(QueryType type, QVariant in) const;
     virtual QLocale fallbackLocale() const;
 
-#ifdef QLOCALE_CPP
 private:
     QSystemLocale(bool);
     friend QSystemLocale *QSystemLocale_globalSystemLocale();
-#endif
 };
 #endif
 
diff --git a/src/corelib/tools/qlocale_p.h b/src/corelib/tools/qlocale_p.h
index 9d36a83..b07b948 100644
--- a/src/corelib/tools/qlocale_p.h
+++ b/src/corelib/tools/qlocale_p.h
@@ -96,7 +96,7 @@ public:
 
         ShowBase            = 0x80,
         UppercaseBase       = 0x100,
-        ForcePoint          = Alternate,
+        ForcePoint          = Alternate
     };
 
     enum GroupSeparatorMode {
diff --git a/src/corelib/tools/qmap.cpp b/src/corelib/tools/qmap.cpp
index 0699400..07df28d 100644
--- a/src/corelib/tools/qmap.cpp
+++ b/src/corelib/tools/qmap.cpp
@@ -902,7 +902,8 @@ void QMapData::dump()
 
 /*! \typedef QMap::iterator::iterator_category
 
-    \internal
+  A synonym for \e {std::bidirectional_iterator_tag} indicating
+  this iterator is a bidirectional iterator.
 */
 
 /*! \typedef QMap::iterator::pointer
@@ -1123,7 +1124,8 @@ void QMapData::dump()
 
 /*! \typedef QMap::const_iterator::iterator_category
 
-    \internal
+  A synonym for \e {std::bidirectional_iterator_tag} indicating
+  this iterator is a bidirectional iterator.
 */
 
 /*! \typedef QMap::const_iterator::pointer
diff --git a/src/corelib/tools/qmap.h b/src/corelib/tools/qmap.h
index 5f13e5a..32c8d17 100644
--- a/src/corelib/tools/qmap.h
+++ b/src/corelib/tools/qmap.h
@@ -990,7 +990,7 @@ Q_INLINE_TEMPLATE int QMultiMap<Key, T>::remove(const Key &key, const T &value)
 {
     int n = 0;
     typename QMap<Key, T>::iterator i(find(key));
-    typename QMap<Key, T>::const_iterator end(QMap<Key, T>::constEnd());
+    typename QMap<Key, T>::iterator end(QMap<Key, T>::end());
     while (i != end && !qMapLessThanKey<Key>(key, i.key())) {
         if (i.value() == value) {
             i = erase(i);
diff --git a/src/corelib/tools/qpoint.cpp b/src/corelib/tools/qpoint.cpp
index 5cc71d6..90b44b1 100644
--- a/src/corelib/tools/qpoint.cpp
+++ b/src/corelib/tools/qpoint.cpp
@@ -373,7 +373,7 @@ QDebug operator<<(QDebug dbg, const QPoint &p) {
 
 QDebug operator<<(QDebug d, const QPointF &p)
 {
-    d.nospace() << "QPointF(" << p.x() << ", " << p.y() << ")";
+    d.nospace() << "QPointF(" << p.x() << ", " << p.y() << ')';
     return d;
 }
 #endif
diff --git a/src/corelib/tools/qrect.cpp b/src/corelib/tools/qrect.cpp
index 3930a0d..5602170 100644
--- a/src/corelib/tools/qrect.cpp
+++ b/src/corelib/tools/qrect.cpp
@@ -901,7 +901,7 @@ void QRect::moveCenter(const QPoint &p)
 /*!
     \fn bool QRect::contains(const QPoint &point, bool proper) const
 
-    Returns true if the the given \a point is inside or on the edge of
+    Returns true if the given \a point is inside or on the edge of
     the rectangle, otherwise returns false. If \a proper is true, this
     function only returns true if the given \a point is \e inside the
     rectangle (i.e., not on the edge).
diff --git a/src/corelib/tools/qringbuffer_p.h b/src/corelib/tools/qringbuffer_p.h
index eed4ba9..02cc497 100644
--- a/src/corelib/tools/qringbuffer_p.h
+++ b/src/corelib/tools/qringbuffer_p.h
@@ -74,6 +74,52 @@ public:
         return buffers.isEmpty() ? 0 : (buffers.first().constData() + head);
     }
 
+    // access the bytes at a specified position
+    // the out-variable length will contain the amount of bytes readable
+    // from there, e.g. the amount still the same QByteArray
+    inline const char *readPointerAtPosition(qint64 pos, qint64 &length) const {
+        if (buffers.isEmpty()) {
+            length = 0;
+            return 0;
+        }
+
+        if (pos >= bufferSize) {
+            length = 0;
+            return 0;
+        }
+
+        // special case: it is in the first buffer
+        int nextDataBlockSizeValue = nextDataBlockSize();
+        if (pos - head < nextDataBlockSizeValue) {
+            length = nextDataBlockSizeValue - pos;
+            return buffers.at(0).constData() + head + pos;
+        }
+
+        // special case: we only had one buffer and tried to read over it
+        if (buffers.length() == 1) {
+            length = 0;
+            return 0;
+        }
+
+        // skip the first
+        pos -= nextDataBlockSizeValue;
+
+        // normal case: it is somewhere in the second to the-one-before-the-tailBuffer
+        for (int i = 1; i < tailBuffer; i++) {
+            if (pos >= buffers[i].size()) {
+                pos -= buffers[i].size();
+                continue;
+            }
+
+            length = buffers[i].length() - pos;
+            return buffers[i].constData() + pos;
+        }
+
+        // it is in the tail buffer
+        length = tail - pos;
+        return buffers[tailBuffer].constData() + pos;
+    }
+
     inline void free(int bytes) {
         bufferSize -= bytes;
         if (bufferSize < 0)
diff --git a/src/corelib/tools/qsharedpointer_impl.h b/src/corelib/tools/qsharedpointer_impl.h
index f1b35ee..ad2d9f2 100644
--- a/src/corelib/tools/qsharedpointer_impl.h
+++ b/src/corelib/tools/qsharedpointer_impl.h
@@ -238,6 +238,7 @@ namespace QtSharedPointer {
         template <class X> friend class ExternalRefCount;
         template <class X> friend class QWeakPointer;
         template <class X, class Y> friend QSharedPointer<X> qSharedPointerCastHelper(const QSharedPointer<Y> &src, X *);
+        template <class X, class Y> friend QSharedPointer<X> qSharedPointerDynamicCastHelper(const QSharedPointer<Y> &src, X *);
         template <class X, class Y> friend QSharedPointer<X> qSharedPointerConstCastHelper(const QSharedPointer<Y> &src, X *);
         template <class X, class Y> friend QSharedPointer<X> QtSharedPointer::qStrongRefFromWeakHelper(const QWeakPointer<Y> &src, X *);
 #endif
@@ -509,6 +510,14 @@ namespace QtSharedPointer {
         return result;
     }
     template <class X, class T>
+    Q_INLINE_TEMPLATE QSharedPointer<X> qSharedPointerDynamicCastHelper(const QSharedPointer<T> &src, X *)
+    {
+        QSharedPointer<X> result;
+        register T *ptr = src.data();
+        result.internalSet(src.d, dynamic_cast<X *>(ptr));
+        return result;
+    }
+    template <class X, class T>
     Q_INLINE_TEMPLATE QSharedPointer<X> qSharedPointerConstCastHelper(const QSharedPointer<T> &src, X *)
     {
         QSharedPointer<X> result;
@@ -544,9 +553,7 @@ template <class X, class T>
 Q_INLINE_TEMPLATE QSharedPointer<X> qSharedPointerDynamicCast(const QSharedPointer<T> &src)
 {
     X *x = 0;
-    if (QtSharedPointer::qVerifyDynamicCast(src.data(), x))
-        return QtSharedPointer::qSharedPointerCastHelper(src, x);
-    return QSharedPointer<X>();
+    return QtSharedPointer::qSharedPointerDynamicCastHelper(src, x);
 }
 template <class X, class T>
 Q_INLINE_TEMPLATE QSharedPointer<X> qSharedPointerDynamicCast(const QWeakPointer<T> &src)
@@ -558,17 +565,13 @@ template <class X, class T>
 Q_INLINE_TEMPLATE QSharedPointer<X> qSharedPointerConstCast(const QSharedPointer<T> &src)
 {
     X *x = 0;
-    if (QtSharedPointer::qVerifyConstCast(src.data(), x))
-        return QtSharedPointer::qSharedPointerConstCastHelper(src, x);
-    return QSharedPointer<X>();
+    return QtSharedPointer::qSharedPointerConstCastHelper(src, x);
 }
 template <class X, class T>
 Q_INLINE_TEMPLATE QSharedPointer<X> qSharedPointerConstCast(const QWeakPointer<T> &src)
 {
     X *x = 0;
-    if (QtSharedPointer::qVerifyConstCast(src.data(), x))
-        return QtSharedPointer::qSharedPointerCastHelper(src, x);
-    return QSharedPointer<X>();
+    return QtSharedPointer::qSharedPointerConstCastHelper(src, x);
 }
 
 template <class X, class T>
diff --git a/src/corelib/tools/qsize.cpp b/src/corelib/tools/qsize.cpp
index 76a5484..bbf6c2a 100644
--- a/src/corelib/tools/qsize.cpp
+++ b/src/corelib/tools/qsize.cpp
@@ -781,7 +781,7 @@ void QSizeF::scale(const QSizeF &s, Qt::AspectRatioMode mode)
     \fn QDataStream &operator<<(QDataStream &stream, const QSizeF &size)
     \relates QSizeF
 
-    Writes the the given \a size to the given \a stream and returns a
+    Writes the given \a size to the given \a stream and returns a
     reference to the stream.
 
     \sa {Format of the QDataStream Operators}
diff --git a/src/corelib/tools/qstring.cpp b/src/corelib/tools/qstring.cpp
index 375d672..c64e1d6 100644
--- a/src/corelib/tools/qstring.cpp
+++ b/src/corelib/tools/qstring.cpp
@@ -195,6 +195,68 @@ static int ucstrnicmp(const ushort *a, const ushort *b, int l)
     return ucstricmp(a, a + l, b, b + l);
 }
 
+static bool qMemEquals(const quint16 *a, const quint16 *b, int length)
+{
+    // Benchmarking indicates that doing memcmp is much slower than
+    // executing the comparison ourselves.
+    // To make it even faster, we do a 32-bit comparison, comparing
+    // twice the amount of data as a normal word-by-word comparison.
+    //
+    // Benchmarking results on a 2.33 GHz Core2 Duo, with a 64-QChar
+    // block of data, with 4194304 iterations (per iteration):
+    //    operation             usec            cpu ticks
+    //     memcmp                330               710
+    //     16-bit                 79             167-171
+    //  32-bit aligned            49             105-109
+    //
+    // Testing also indicates that unaligned 32-bit loads are as
+    // performant as 32-bit aligned.
+    if (a == b || !length)
+        return true;
+
+    register union {
+        const quint16 *w;
+        const quint32 *d;
+        quintptr value;
+    } sa, sb;
+    sa.w = a;
+    sb.w = b;
+
+    // check alignment
+    if ((sa.value & 2) == (sb.value & 2)) {
+        // both addresses have the same alignment
+        if (sa.value & 2) {
+            // both addresses are not aligned to 4-bytes boundaries
+            // compare the first character
+            if (*sa.w != *sb.w)
+                return false;
+            --length;
+            ++sa.w;
+            ++sb.w;
+
+            // now both addresses are 4-bytes aligned
+        }
+
+        // both addresses are 4-bytes aligned
+        // do a fast 32-bit comparison
+        register const quint32 *e = sa.d + (length >> 1);
+        for ( ; sa.d != e; ++sa.d, ++sb.d) {
+            if (*sa.d != *sb.d)
+                return false;
+        }
+
+        // do we have a tail?
+        return (length & 1) ? *sa.w == *sb.w : true;
+    } else {
+        // one of the addresses isn't 4-byte aligned but the other is
+        register const quint16 *e = sa.w + length;
+        for ( ; sa.w != e; ++sa.w, ++sb.w) {
+            if (*sa.w != *sb.w)
+                return false;
+        }
+    }
+    return true;
+}
 
 /*!
     \internal
@@ -743,7 +805,9 @@ int QString::grow(int size)
 /*!
     \since 4.2
 
-    Returns a copy of the \a string string encoded in ucs4.
+    Returns a copy of the \a string, where the encoding of \a string depends on 
+    the size of wchar. If wchar is 4 bytes, the \a string is interpreted as ucs-4,
+    if wchar is 2 bytes it is interpreted as ucs-2.
 
     If \a size is -1 (default), the \a string has to be 0 terminated.
 
@@ -880,6 +944,23 @@ QString::QString(int size, QChar ch)
     }
 }
 
+/*!
+    Constructs a string of the given \a size without initializing the
+    characters. This is only used in \c QStringBuilder::toString().
+
+    \internal
+*/
+
+QString::QString(int size, Uninitialized)
+{
+    d = (Data*) qMalloc(sizeof(Data)+size*sizeof(QChar));
+    d->ref = 1;
+    d->alloc = d->size = size;
+    d->clean = d->asciiCache = d->simpletext = d->righttoleft = d->capacity = 0;
+    d->data = d->array;
+    d->array[size] = '\0';
+}
+
 /*! \fn QString::QString(const QLatin1String &str)
 
     Constructs a copy of the Latin-1 string \a str.
@@ -1906,8 +1987,10 @@ QString &QString::replace(QChar c, const QLatin1String &after, Qt::CaseSensitivi
 */
 bool QString::operator==(const QString &other) const
 {
-    return (size() == other.size()) &&
-        (memcmp((char*)unicode(),(char*)other.unicode(), size()*sizeof(QChar))==0);
+    if (d->size != other.d->size)
+        return false;
+
+    return qMemEquals(d->data, other.d->data, d->size);
 }
 
 /*!
@@ -3134,7 +3217,7 @@ bool QString::startsWith(const QString& s, Qt::CaseSensitivity cs) const
     if (s.d->size > d->size)
         return false;
     if (cs == Qt::CaseSensitive) {
-        return memcmp((char*)d->data, (char*)s.d->data, s.d->size*sizeof(QChar)) == 0;
+        return qMemEquals(d->data, s.d->data, s.d->size);
     } else {
         uint last = 0;
         uint olast = 0;
@@ -3205,7 +3288,7 @@ bool QString::endsWith(const QString& s, Qt::CaseSensitivity cs) const
     if (pos < 0)
         return false;
     if (cs == Qt::CaseSensitive) {
-        return memcmp((char*)&d->data[pos], (char*)s.d->data, s.d->size*sizeof(QChar)) == 0;
+        return qMemEquals(d->data + pos, s.d->data, s.d->size);
     } else {
         uint last = 0;
         uint olast = 0;
@@ -7690,7 +7773,8 @@ QString QStringRef::toString() const {
 */
 bool operator==(const QStringRef &s1,const QStringRef &s2)
 { return (s1.size() == s2.size() &&
-          (memcmp((char*)s1.unicode(), (char*)s2.unicode(), s1.size()*sizeof(QChar))==0)); }
+          qMemEquals((const ushort *)s1.unicode(), (const ushort *)s2.unicode(), s1.size()));
+}
 
 /*! \relates QStringRef
 
@@ -7699,7 +7783,8 @@ bool operator==(const QStringRef &s1,const QStringRef &s2)
 */
 bool operator==(const QString &s1,const QStringRef &s2)
 { return (s1.size() == s2.size() &&
-          (memcmp((char*)s1.unicode(), (char*)s2.unicode(), s1.size()*sizeof(QChar))==0)); }
+          qMemEquals((const ushort *)s1.unicode(), (const ushort *)s2.unicode(), s1.size()));
+}
 
 /*! \relates QStringRef
 
diff --git a/src/corelib/tools/qstring.h b/src/corelib/tools/qstring.h
index 69c4f2f..7c0d6a3 100644
--- a/src/corelib/tools/qstring.h
+++ b/src/corelib/tools/qstring.h
@@ -579,6 +579,9 @@ public:
     bool isSimpleText() const { if (!d->clean) updateProperties(); return d->simpletext; }
     bool isRightToLeft() const { if (!d->clean) updateProperties(); return d->righttoleft; }
 
+    struct Uninitialized {};
+    QString(int size, Uninitialized);
+
 private:
 #if defined(QT_NO_CAST_FROM_ASCII) && !defined(Q_NO_DECLARED_NOT_DEFINED)
     QString &operator+=(const char *s);
@@ -1001,13 +1004,15 @@ inline int QByteArray::findRev(const QString &s, int from) const
 #  endif // QT3_SUPPORT
 #endif // QT_NO_CAST_TO_ASCII
 
+#ifndef QT_USE_FAST_OPERATOR_PLUS
+# ifndef QT_USE_FAST_CONCATENATION
 inline const QString operator+(const QString &s1, const QString &s2)
 { QString t(s1); t += s2; return t; }
 inline const QString operator+(const QString &s1, QChar s2)
 { QString t(s1); t += s2; return t; }
 inline const QString operator+(QChar s1, const QString &s2)
 { QString t(s1); t += s2; return t; }
-#ifndef QT_NO_CAST_FROM_ASCII
+#  ifndef QT_NO_CAST_FROM_ASCII
 inline QT_ASCII_CAST_WARN const QString operator+(const QString &s1, const char *s2)
 { QString t(s1); t += QString::fromAscii(s2); return t; }
 inline QT_ASCII_CAST_WARN const QString operator+(const char *s1, const QString &s2)
@@ -1020,7 +1025,9 @@ inline QT_ASCII_CAST_WARN const QString operator+(const QByteArray &ba, const QS
 { QString t = QString::fromAscii(ba.constData(), qstrnlen(ba.constData(), ba.size())); t += s; return t; }
 inline QT_ASCII_CAST_WARN const QString operator+(const QString &s, const QByteArray &ba)
 { QString t(s); t += QString::fromAscii(ba.constData(), qstrnlen(ba.constData(), ba.size())); return t; }
-#endif
+#  endif // QT_NO_CAST_FROM_ASCII
+# endif // QT_USE_FAST_CONCATENATION
+#endif // QT_USE_FAST_OPERATOR_PLUS
 
 #ifndef QT_NO_STL
 inline std::string QString::toStdString() const
@@ -1229,6 +1236,8 @@ inline int QStringRef::localeAwareCompare(const QStringRef &s1, const QStringRef
 
 QT_END_NAMESPACE
 
-QT_END_HEADER
+#ifdef QT_USE_FAST_CONCATENATION
+#include <QtCore/qstringbuilder.h>
+#endif
 
 #endif // QSTRING_H
diff --git a/src/corelib/tools/qstringbuilder.cpp b/src/corelib/tools/qstringbuilder.cpp
new file mode 100644
index 0000000..4f24f76
--- /dev/null
+++ b/src/corelib/tools/qstringbuilder.cpp
@@ -0,0 +1,135 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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 qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qstringbuilder.h"
+
+/*!
+    \class QLatin1Literal
+    \reentrant
+    \since 4.6
+
+    \brief The QLatin1Literal class provides a thin wrapper around string
+    literals used in source code.
+
+    \ingroup tools
+    \ingroup shared
+    \ingroup text
+    \mainclass
+
+    Unlike \c QLatin1String, a \c QLatin1Literal can retrieve its size
+    without iterating over the literal.
+
+    The main use of \c QLatin1Literal is in conjunction with \c QStringBuilder
+    to reduce the number of reallocations needed to build up a string from
+    smaller chunks.
+
+    \sa QStringBuilder, QLatin1String, QString, QStringRef
+*/
+
+/*! \fn QLatin1Literal::QLatin1Literal(const char(&string)[N])
+ 
+    Constructs a new literal from the given \a string.
+*/
+
+/*! \fn int QLatin1Literal::size() const
+ 
+    Returns the number of characters in the literal \e{excluding} the trailing
+    NULL char.
+*/
+
+/*! \fn char *QLatin1Literal::data() const
+ 
+    Returns a pointer to the first character of the string literal.
+    The string literal is terminated by a NUL character.
+*/
+
+/*! \fn QLatin1Literal::operator QString() const
+ 
+    Converts the \c QLatin1Literal into a \c QString object.
+*/
+
+
+
+/*!
+    \class QStringBuilder
+    \reentrant
+    \since 4.6
+
+    \brief The QStringBuilder class is a template class that provides a facility to build
+    up QStrings from smaller chunks.
+
+    \ingroup tools
+    \ingroup shared
+    \ingroup text
+    \mainclass
+
+    When creating strings from smaller chunks, typically \c QString::operator+()
+    is used, resulting in \e{n - 1} reallocations when operating on \e{n} chunks.
+
+    QStringBuilder uses expression templates to collect the individual parts,
+    compute the total size, allocate memory for the resulting QString object,
+    and copy the contents of the chunks into the result.
+
+    The QStringBuilder class is not to be used explicitly in user code.
+    Instances of the class are created as return values of the operator%()
+    function, acting on objects of type \c QString, \c QLatin1String,
+    \c QLatin1Literal, \c \QStringRef, \c QChar,
+    \c QLatin1Char, and \c char.
+
+    Concatenating strings with operator%() generally yields better
+    performance then using \c QString::operator+() on the same chunks
+    if there are three or more of them, and performs equally well in other
+    cases.
+
+    \sa QLatin1Literal, QString
+*/
+
+/* \fn template <class A, class B> QStringBuilder<A, B> operator%(const A &a, const B &b)
+
+    Returns a \c QStringBuilder object that is converted to a QString object
+    when assigned to a variable of QString type or passed to a function that
+    takes a QString parameter.
+
+    This function is usable with arguments of type \c QString,
+    \c QLatin1String, \c QLatin1Literal, \c QStringRef, 
+    \c QChar, \c QLatin1Char, and \c char.
+*/
+
diff --git a/src/corelib/tools/qstringbuilder.h b/src/corelib/tools/qstringbuilder.h
new file mode 100644
index 0000000..1e67b7d
--- /dev/null
+++ b/src/corelib/tools/qstringbuilder.h
@@ -0,0 +1,207 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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 qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSTRINGBUILDER_H
+#define QSTRINGBUILDER_H
+
+#include <QtCore/qstring.h>
+
+#include <string.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+// ### Qt 5: merge with QLatin1String
+class QLatin1Literal
+{
+public:
+    template <int N>
+    QLatin1Literal(const char (&str)[N]) : m_size(N - 1), m_data(str) {}
+
+    inline int size() const { return m_size; }
+    inline const char *data() const { return m_data; }
+
+private:
+    const int m_size;
+    const char *m_data;
+};
+
+
+template <typename T> class QConcatenable {};
+
+template <typename A, typename B>
+class QStringBuilder
+{
+public:
+    QStringBuilder(const A &a_, const B &b_) : a(a_), b(b_) {}
+
+    operator QString() const
+    {
+        QString s(QConcatenable< QStringBuilder<A, B> >::size(*this),
+            QString::Uninitialized());
+        
+        QChar *d = s.data();
+        QConcatenable< QStringBuilder<A, B> >::appendTo(*this, d);
+        return s;
+    }
+    QByteArray toLatin1() const { return QString(*this).toLatin1(); }
+
+    const A &a;
+    const B &b;
+};
+
+
+template <> struct QConcatenable<char>
+{
+    typedef char type;
+    static int size(const char) { return 1; }
+    static inline void appendTo(const char c, QChar *&out)
+    {
+        *out++ = QLatin1Char(c);
+    }
+};
+
+template <> struct QConcatenable<QLatin1Char>
+{
+    typedef QLatin1Char type;
+    static int size(const QLatin1Char) { return 1; }
+    static inline void appendTo(const QLatin1Char c, QChar *&out)
+    {
+        *out++ = c;
+    }
+};
+
+template <> struct QConcatenable<QChar>
+{
+    typedef QChar type;
+    static int size(const QChar) { return 1; }
+    static inline void appendTo(const QChar c, QChar *&out)
+    {
+        *out++ = c;
+    }
+};
+
+template <> struct QConcatenable<QLatin1String>
+{
+    typedef QLatin1String type;
+    static int size(const QLatin1String &a) { return qstrlen(a.latin1()); }
+    static inline void appendTo(const QLatin1String &a, QChar *&out)
+    {
+        for (const char *s = a.latin1(); *s; )
+            *out++ = QLatin1Char(*s++);
+    }
+
+};
+
+template <> struct QConcatenable<QLatin1Literal>
+{
+    typedef QLatin1Literal type;
+    static int size(const QLatin1Literal &a) { return a.size(); }
+    static inline void appendTo(const QLatin1Literal &a, QChar *&out)
+    {
+        for (const char *s = a.data(); *s; )
+            *out++ = QLatin1Char(*s++);
+    }
+};
+
+template <> struct QConcatenable<QString>
+{
+    typedef QString type;
+    static int size(const QString &a) { return a.size(); }
+    static inline void appendTo(const QString &a, QChar *&out)
+    {
+        const int n = a.size();
+        memcpy(out, (char*)a.constData(), sizeof(QChar) * n);
+        out += n; 
+    }
+};
+
+template <> struct QConcatenable<QStringRef>
+{
+    typedef QStringRef type;
+    static int size(const QStringRef &a) { return a.size(); }
+    static inline void appendTo(QStringRef a, QChar *&out)
+    {
+        const int n = a.size();
+        memcpy(out, (char*)a.constData(), sizeof(QChar) * n);
+        out += n; 
+    }
+};
+
+template <typename A, typename B>
+struct QConcatenable< QStringBuilder<A, B> >
+{
+    typedef QStringBuilder<A, B> type;
+    static int size(const type &p) 
+    {
+        return QConcatenable<A>::size(p.a) + QConcatenable<B>::size(p.b);
+    }
+    static inline void appendTo(const QStringBuilder<A, B> &p, QChar *&out)
+    {
+        QConcatenable<A>::appendTo(p.a, out);
+        QConcatenable<B>::appendTo(p.b, out);
+    }
+};
+
+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);
+}
+
+#ifdef QT_USE_FAST_OPERATOR_PLUS
+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);
+}
+#endif
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QSTRINGBUILDER_H
diff --git a/src/corelib/tools/qstringlist.cpp b/src/corelib/tools/qstringlist.cpp
index 386321f1..cf1bff8 100644
--- a/src/corelib/tools/qstringlist.cpp
+++ b/src/corelib/tools/qstringlist.cpp
@@ -397,7 +397,7 @@ void QtPrivate::QStringList_replaceInStrings(QStringList *that, const QRegExp &r
     \fn QString QStringList::join(const QString &separator) const
 
     Joins all the string list's strings into a single string with each
-    element separated by the the given \a separator (which can be an
+    element separated by the given \a separator (which can be an
     empty string).
 
     \sa QString::split()
@@ -621,8 +621,6 @@ int QtPrivate::QStringList_lastIndexOf(const QStringList *that, QRegExp &rx, int
     the list, searching forward from index position \a from. Returns
     -1 if no item matched.
 
-    By default, this function is case sensitive.
-
     \sa lastIndexOf(), contains(), QList::indexOf()
 */
 
diff --git a/src/corelib/tools/qtimeline.cpp b/src/corelib/tools/qtimeline.cpp
index 2979a09..ee4f73c 100644
--- a/src/corelib/tools/qtimeline.cpp
+++ b/src/corelib/tools/qtimeline.cpp
@@ -48,20 +48,6 @@
 
 QT_BEGIN_NAMESPACE
 
-static const qreal pi = qreal(3.14159265359);
-static const qreal halfPi = pi / qreal(2.0);
-
-
-static inline qreal qt_sinProgress(qreal value)
-{
-    return qSin((value * pi) - halfPi) / 2 + qreal(0.5);
-}
-
-static inline qreal qt_smoothBeginEndMixFactor(qreal value)
-{
-    return qMin(qMax(1 - value * 2 + qreal(0.3), qreal(0.0)), qreal(1.0));
-}
-
 class QTimeLinePrivate : public QObjectPrivate
 {
     Q_DECLARE_PUBLIC(QTimeLine)
@@ -70,7 +56,7 @@ public:
         : startTime(0), duration(1000), startFrame(0), endFrame(0),
           updateInterval(1000 / 25),
           totalLoopCount(1), currentLoopCount(0), currentTime(0), timerId(0),
-          direction(QTimeLine::Forward), curveShape(QTimeLine::EaseInOutCurve),
+          direction(QTimeLine::Forward), easingCurve(QEasingCurve::InOutSine),
           state(QTimeLine::NotRunning)
     { }
 
@@ -88,7 +74,7 @@ public:
     QTime timer;
 
     QTimeLine::Direction direction;
-    QTimeLine::CurveShape curveShape;
+    QEasingCurve easingCurve;
     QTimeLine::State state;
     inline void setState(QTimeLine::State newState)
     {
@@ -225,7 +211,9 @@ void QTimeLinePrivate::setCurrentTime(int msecs)
     valueForTime() and emitting valueChanged(). By default, valueForTime()
     applies an interpolation algorithm to generate these value. You can choose
     from a set of predefined timeline algorithms by calling
-    setCurveShape(). By default, QTimeLine uses the EaseInOut curve shape,
+    setCurveShape().
+   
+    Note that by default, QTimeLine uses the EaseInOut curve shape,
     which provides a value that grows slowly, then grows steadily, and
     finally grows slowly. For a custom timeline, you can reimplement
     valueForTime(), in which case QTimeLine's curveShape property is ignored.
@@ -521,12 +509,68 @@ void QTimeLine::setUpdateInterval(int interval)
 QTimeLine::CurveShape QTimeLine::curveShape() const
 {
     Q_D(const QTimeLine);
-    return d->curveShape;
+    switch (d->easingCurve.type()) {
+    default:
+    case QEasingCurve::InOutSine:
+        return EaseInOutCurve;
+    case QEasingCurve::InCurve:
+        return EaseInCurve;
+    case QEasingCurve::OutCurve:
+        return EaseOutCurve;
+    case QEasingCurve::Linear:
+        return LinearCurve;
+    case QEasingCurve::SineCurve:
+        return SineCurve;
+    case QEasingCurve::CosineCurve:
+        return CosineCurve;
+    }
+    return EaseInOutCurve;
 }
+
 void QTimeLine::setCurveShape(CurveShape shape)
 {
+    switch (shape) {
+    default:
+    case EaseInOutCurve:
+        setEasingCurve(QEasingCurve(QEasingCurve::InOutSine));
+        break;
+    case EaseInCurve:
+        setEasingCurve(QEasingCurve(QEasingCurve::InCurve));
+        break;
+    case EaseOutCurve:
+        setEasingCurve(QEasingCurve(QEasingCurve::OutCurve));
+        break;
+    case LinearCurve:
+        setEasingCurve(QEasingCurve(QEasingCurve::Linear));
+        break;
+    case SineCurve:
+        setEasingCurve(QEasingCurve(QEasingCurve::SineCurve));
+        break;
+    case CosineCurve:
+        setEasingCurve(QEasingCurve(QEasingCurve::CosineCurve));
+        break;
+    } 
+}
+
+/*!
+    \property QTimeLine::easingCurve
+
+    Specifies the easing curve that the timeline will use.
+    If both easing curve and curveShape are set, the last set property will
+    override the previous one. (If valueForTime() is reimplemented it will 
+    override both)
+*/
+
+QEasingCurve QTimeLine::easingCurve() const
+{
+    Q_D(const QTimeLine);
+    return d->easingCurve;
+}
+
+void QTimeLine::setEasingCurve(const QEasingCurve& curve)
+{
     Q_D(QTimeLine);
-    d->curveShape = shape;
+    d->easingCurve = curve;
 }
 
 /*!
@@ -606,42 +650,8 @@ qreal QTimeLine::valueForTime(int msec) const
     Q_D(const QTimeLine);
     msec = qMin(qMax(msec, 0), d->duration);
 
-    // Simple linear interpolation
     qreal value = msec / qreal(d->duration);
-
-    switch (d->curveShape) {
-    case EaseInOutCurve:
-        value = qt_sinProgress(value);
-        break;
-        // SmoothBegin blends Smooth and Linear Interpolation.
-        // Progress 0 - 0.3      : Smooth only
-        // Progress 0.3 - ~ 0.5  : Mix of Smooth and Linear
-        // Progress ~ 0.5  - 1   : Linear only
-    case EaseInCurve: {
-        const qreal sinProgress = qt_sinProgress(value);
-        const qreal linearProgress = value;
-        const qreal mix = qt_smoothBeginEndMixFactor(value);
-        value = sinProgress * mix + linearProgress * (1 - mix);
-        break;
-    }
-    case EaseOutCurve: {
-        const qreal sinProgress = qt_sinProgress(value);
-        const qreal linearProgress = value;
-        const qreal mix = qt_smoothBeginEndMixFactor(1 - value);
-        value = sinProgress * mix + linearProgress * (1 - mix);
-        break;
-    }
-    case SineCurve:
-        value = (qSin(((msec * pi * 2) / d->duration) - pi/2) + 1) / 2;
-        break;
-    case CosineCurve:
-        value = (qCos(((msec * pi * 2) / d->duration) - pi/2) + 1) / 2;
-        break;
-    default:
-        break;
-    }
-
-    return value;
+    return d->easingCurve.valueForProgress(value);
 }
 
 /*!
diff --git a/src/corelib/tools/qtimeline.h b/src/corelib/tools/qtimeline.h
index 18c3980..48c9232 100644
--- a/src/corelib/tools/qtimeline.h
+++ b/src/corelib/tools/qtimeline.h
@@ -42,6 +42,7 @@
 #ifndef QTIMELINE_H
 #define QTIMELINE_H
 
+#include <QtCore/qeasingcurve.h>
 #include <QtCore/qobject.h>
 
 QT_BEGIN_HEADER
@@ -60,6 +61,7 @@ class Q_CORE_EXPORT QTimeLine : public QObject
     Q_PROPERTY(Direction direction READ direction WRITE setDirection)
     Q_PROPERTY(int loopCount READ loopCount WRITE setLoopCount)
     Q_PROPERTY(CurveShape curveShape READ curveShape WRITE setCurveShape)
+    Q_PROPERTY(QEasingCurve easingCurve READ easingCurve WRITE setEasingCurve)
 public:
     enum State {
         NotRunning,
@@ -105,6 +107,9 @@ public:
     CurveShape curveShape() const;
     void setCurveShape(CurveShape shape);
 
+    QEasingCurve easingCurve() const;
+    void setEasingCurve(const QEasingCurve &curve);
+
     int currentTime() const;
     int currentFrame() const;
     qreal currentValue() const;
diff --git a/src/corelib/tools/qvector.h b/src/corelib/tools/qvector.h
index 1f047b8..7bdcba0 100644
--- a/src/corelib/tools/qvector.h
+++ b/src/corelib/tools/qvector.h
@@ -82,19 +82,9 @@ struct Q_CORE_EXPORT QVectorData
 };
 
 template <typename T>
-struct QVectorTypedData
-{
-    QBasicAtomicInt ref;
-    int alloc;
-    int size;
-#if defined(QT_ARCH_SPARC) && defined(Q_CC_GNU) && defined(__LP64__) && defined(QT_BOOTSTRAPPED)
-    // workaround for bug in gcc 3.4.2
-    uint sharable;
-    uint capacity;
-#else
-    uint sharable : 1;
-    uint capacity : 1;
-#endif
+struct QVectorTypedData : private QVectorData
+{ // private inheritance as we must not access QVectorData member thought QVectorTypedData
+  // as this would break strict aliasing rules. (in the case of shared_null)
     T array[1];
 };
 
@@ -104,14 +94,14 @@ template <typename T>
 class QVector
 {
     typedef QVectorTypedData<T> Data;
-    union { QVectorData *p; QVectorTypedData<T> *d; };
+    union { QVectorData *d; Data *p; };
 
 public:
-    inline QVector() : p(&QVectorData::shared_null) { d->ref.ref(); }
+    inline QVector() : d(&QVectorData::shared_null) { d->ref.ref(); }
     explicit QVector(int size);
     QVector(int size, const T &t);
     inline QVector(const QVector<T> &v) : d(v.d) { d->ref.ref(); if (!d->sharable) detach_helper(); }
-    inline ~QVector() { if (!d) return; if (!d->ref.deref()) free(d); }
+    inline ~QVector() { if (!d) return; if (!d->ref.deref()) free(p); }
     QVector<T> &operator=(const QVector<T> &v);
     bool operator==(const QVector<T> &v) const;
     inline bool operator!=(const QVector<T> &v) const { return !(*this == v); }
@@ -130,9 +120,9 @@ public:
     inline bool isDetached() const { return d->ref == 1; }
     inline void setSharable(bool sharable) { if (!sharable) detach(); d->sharable = sharable; }
 
-    inline T *data() { detach(); return d->array; }
-    inline const T *data() const { return d->array; }
-    inline const T *constData() const { return d->array; }
+    inline T *data() { detach(); return p->array; }
+    inline const T *data() const { return p->array; }
+    inline const T *constData() const { return p->array; }
     void clear();
 
     const T &at(int i) const;
@@ -225,12 +215,12 @@ public:
     typedef T* iterator;
     typedef const T* const_iterator;
 #endif
-    inline iterator begin() { detach(); return d->array; }
-    inline const_iterator begin() const { return d->array; }
-    inline const_iterator constBegin() const { return d->array; }
-    inline iterator end() { detach(); return d->array + d->size; }
-    inline const_iterator end() const { return d->array + d->size; }
-    inline const_iterator constEnd() const { return d->array + d->size; }
+    inline iterator begin() { detach(); return p->array; }
+    inline const_iterator begin() const { return p->array; }
+    inline const_iterator constBegin() const { return p->array; }
+    inline iterator end() { detach(); return p->array + d->size; }
+    inline const_iterator end() const { return p->array + d->size; }
+    inline const_iterator constEnd() const { return p->array + d->size; }
     iterator insert(iterator before, int n, const T &x);
     inline iterator insert(iterator before, const T &x) { return insert(before, 1, x); }
     iterator erase(iterator begin, iterator end);
@@ -327,11 +317,11 @@ inline void QVector<T>::clear()
 template <typename T>
 inline const T &QVector<T>::at(int i) const
 { Q_ASSERT_X(i >= 0 && i < d->size, "QVector<T>::at", "index out of range");
-  return d->array[i]; }
+  return p->array[i]; }
 template <typename T>
 inline const T &QVector<T>::operator[](int i) const
 { Q_ASSERT_X(i >= 0 && i < d->size, "QVector<T>::operator[]", "index out of range");
-  return d->array[i]; }
+  return p->array[i]; }
 template <typename T>
 inline T &QVector<T>::operator[](int i)
 { Q_ASSERT_X(i >= 0 && i < d->size, "QVector<T>::operator[]", "index out of range");
@@ -369,7 +359,7 @@ QVector<T> &QVector<T>::operator=(const QVector<T> &v)
 {
     v.d->ref.ref();
     if (!d->ref.deref())
-        free(d);
+        free(p);
     d = v.d;
     if (!d->sharable)
         detach_helper();
@@ -385,31 +375,31 @@ inline QVectorData *QVector<T>::malloc(int aalloc)
 template <typename T>
 QVector<T>::QVector(int asize)
 {
-    p = malloc(asize);
+    d = malloc(asize);
     d->ref = 1;
     d->alloc = d->size = asize;
     d->sharable = true;
     d->capacity = false;
     if (QTypeInfo<T>::isComplex) {
-        T* b = d->array;
-        T* i = d->array + d->size;
+        T* b = p->array;
+        T* i = p->array + d->size;
         while (i != b)
             new (--i) T;
     } else {
-        qMemSet(d->array, 0, asize * sizeof(T));
+        qMemSet(p->array, 0, asize * sizeof(T));
     }
 }
 
 template <typename T>
 QVector<T>::QVector(int asize, const T &t)
 {
-    p = malloc(asize);
+    d = malloc(asize);
     d->ref = 1;
     d->alloc = d->size = asize;
     d->sharable = true;
     d->capacity = false;
-    T* i = d->array + d->size;
-    while (i != d->array)
+    T* i = p->array + d->size;
+    while (i != p->array)
         new (--i) T(t);
 }
 
@@ -418,7 +408,7 @@ void QVector<T>::free(Data *x)
 {
     if (QTypeInfo<T>::isComplex) {
         T* b = x->array;
-        T* i = b + x->size;
+        T* i = b + reinterpret_cast<QVectorData *>(x)->size;
         while (i-- != b)
              i->~T();
     }
@@ -429,13 +419,13 @@ template <typename T>
 void QVector<T>::realloc(int asize, int aalloc)
 {
     T *j, *i, *b;
-    union { QVectorData *p; Data *d; } x;
+    union { QVectorData *d; Data *p; } x;
     x.d = d;
 
     if (QTypeInfo<T>::isComplex && aalloc == d->alloc && d->ref == 1) {
         // pure resize
-        i = d->array + d->size;
-        j = d->array + asize;
+        i = p->array + d->size;
+        j = p->array + asize;
         if (i > j) {
             while (i-- != j)
                 i->~T();
@@ -450,22 +440,22 @@ void QVector<T>::realloc(int asize, int aalloc)
     if (aalloc != d->alloc || d->ref != 1) {
         // (re)allocate memory
         if (QTypeInfo<T>::isStatic) {
-            x.p = malloc(aalloc);
+            x.d = malloc(aalloc);
         } else if (d->ref != 1) {
-            x.p = QVectorData::malloc(sizeOfTypedData(), aalloc, sizeof(T), p);
+            x.d = QVectorData::malloc(sizeOfTypedData(), aalloc, sizeof(T), d);
         } else {
             if (QTypeInfo<T>::isComplex) {
                 // call the destructor on all objects that need to be
                 // destroyed when shrinking
                 if (asize < d->size) {
-                    j = d->array + asize;
-                    i = d->array + d->size;
+                    j = p->array + asize;
+                    i = p->array + d->size;
                     while (i-- != j)
                         i->~T();
-                    i = d->array + asize;
+                    i = p->array + asize;
                 }
             }
-            x.p = p = static_cast<QVectorData *>(qRealloc(p, sizeOfTypedData() + (aalloc - 1) * sizeof(T)));
+            x.d = d = static_cast<QVectorData *>(qRealloc(d, sizeOfTypedData() + (aalloc - 1) * sizeof(T)));
         }
         x.d->ref = 1;
         x.d->sharable = true;
@@ -474,31 +464,31 @@ void QVector<T>::realloc(int asize, int aalloc)
     }
     if (QTypeInfo<T>::isComplex) {
         if (asize < d->size) {
-            j = d->array + asize;
-            i = x.d->array + asize;
+            j = p->array + asize;
+            i = x.p->array + asize;
         } else {
             // construct all new objects when growing
-            i = x.d->array + asize;
-            j = x.d->array + d->size;
+            i = x.p->array + asize;
+            j = x.p->array + d->size;
             while (i != j)
                 new (--i) T;
-            j = d->array + d->size;
+            j = p->array + d->size;
         }
         if (i != j) {
             // copy objects from the old array into the new array
-            b = x.d->array;
+            b = x.p->array;
             while (i != b)
                 new (--i) T(*--j);
         }
     } else if (asize > d->size) {
         // initialize newly allocated memory to 0
-        qMemSet(x.d->array + d->size, 0, (asize - d->size) * sizeof(T));
+        qMemSet(x.p->array + d->size, 0, (asize - d->size) * sizeof(T));
     }
     x.d->size = asize;
     x.d->alloc = aalloc;
     if (d != x.d) {
         if (!d->ref.deref())
-            free(d);
+            free(p);
         d = x.d;
     }
 }
@@ -506,15 +496,15 @@ void QVector<T>::realloc(int asize, int aalloc)
 template<typename T>
 Q_OUTOFLINE_TEMPLATE T QVector<T>::value(int i) const
 {
-    if (i < 0 || i >= p->size) {
+    if (i < 0 || i >= d->size) {
         return T();
     }
-    return d->array[i];
+    return p->array[i];
 }
 template<typename T>
 Q_OUTOFLINE_TEMPLATE T QVector<T>::value(int i, const T &defaultValue) const
 {
-    return ((i < 0 || i >= p->size) ? defaultValue : d->array[i]);
+    return ((i < 0 || i >= d->size) ? defaultValue : p->array[i]);
 }
 
 template <typename T>
@@ -525,14 +515,14 @@ void QVector<T>::append(const T &t)
         realloc(d->size, QVectorData::grow(sizeOfTypedData(), d->size + 1, sizeof(T),
                                            QTypeInfo<T>::isStatic));
         if (QTypeInfo<T>::isComplex)
-            new (d->array + d->size) T(copy);
+            new (p->array + d->size) T(copy);
         else
-            d->array[d->size] = copy;
+            p->array[d->size] = copy;
     } else {
         if (QTypeInfo<T>::isComplex)
-            new (d->array + d->size) T(t);
+            new (p->array + d->size) T(t);
         else
-            d->array[d->size] = t;
+            p->array[d->size] = t;
     }
     ++d->size;
 }
@@ -540,27 +530,27 @@ void QVector<T>::append(const T &t)
 template <typename T>
 Q_TYPENAME QVector<T>::iterator QVector<T>::insert(iterator before, size_type n, const T &t)
 {
-    int offset = before - d->array;
+    int offset = before - p->array;
     if (n != 0) {
         const T copy(t);
         if (d->ref != 1 || d->size + n > d->alloc)
             realloc(d->size, QVectorData::grow(sizeOfTypedData(), d->size + n, sizeof(T),
                                                QTypeInfo<T>::isStatic));
         if (QTypeInfo<T>::isStatic) {
-            T *b = d->array + d->size;
-            T *i = d->array + d->size + n;
+            T *b = p->array + d->size;
+            T *i = p->array + d->size + n;
             while (i != b)
                 new (--i) T;
-            i = d->array + d->size;
+            i = p->array + d->size;
             T *j = i + n;
-            b = d->array + offset;
+            b = p->array + offset;
             while (i != b)
                 *--j = *--i;
             i = b+n;
             while (i != b)
                 *--i = copy;
         } else {
-            T *b = d->array + offset;
+            T *b = p->array + offset;
             T *i = b + n;
             memmove(i, b, (d->size - offset) * sizeof(T));
             while (i != b)
@@ -568,29 +558,29 @@ Q_TYPENAME QVector<T>::iterator QVector<T>::insert(iterator before, size_type n,
         }
         d->size += n;
     }
-    return d->array + offset;
+    return p->array + offset;
 }
 
 template <typename T>
 Q_TYPENAME QVector<T>::iterator QVector<T>::erase(iterator abegin, iterator aend)
 {
-    int f = abegin - d->array;
-    int l = aend - d->array;
+    int f = abegin - p->array;
+    int l = aend - p->array;
     int n = l - f;
     detach();
     if (QTypeInfo<T>::isComplex) {
-        qCopy(d->array+l, d->array+d->size, d->array+f);
-        T *i = d->array+d->size;
-        T* b = d->array+d->size-n;
+        qCopy(p->array+l, p->array+d->size, p->array+f);
+        T *i = p->array+d->size;
+        T* b = p->array+d->size-n;
         while (i != b) {
             --i;
             i->~T();
         }
     } else {
-        memmove(d->array + f, d->array + l, (d->size-l)*sizeof(T));
+        memmove(p->array + f, p->array + l, (d->size-l)*sizeof(T));
     }
     d->size -= n;
-    return d->array + f;
+    return p->array + f;
 }
 
 template <typename T>
@@ -600,9 +590,9 @@ bool QVector<T>::operator==(const QVector<T> &v) const
         return false;
     if (d == v.d)
         return true;
-    T* b = d->array;
+    T* b = p->array;
     T* i = b + d->size;
-    T* j = v.d->array + d->size;
+    T* j = v.p->array + d->size;
     while (i != b)
         if (!(*--i == *--j))
             return false;
@@ -615,8 +605,8 @@ QVector<T> &QVector<T>::fill(const T &from, int asize)
     const T copy(from);
     resize(asize < 0 ? d->size : asize);
     if (d->size) {
-        T *i = d->array + d->size;
-        T *b = d->array;
+        T *i = p->array + d->size;
+        T *b = p->array;
         while (i != b)
             *--i = copy;
     }
@@ -629,9 +619,9 @@ QVector<T> &QVector<T>::operator+=(const QVector &l)
     int newSize = d->size + l.d->size;
     realloc(d->size, newSize);
 
-    T *w = d->array + newSize;
-    T *i = l.d->array + l.d->size;
-    T *b = l.d->array;
+    T *w = p->array + newSize;
+    T *i = l.p->array + l.d->size;
+    T *b = l.p->array;
     while (i != b) {
         if (QTypeInfo<T>::isComplex)
             new (--w) T(*--i);
@@ -648,11 +638,11 @@ int QVector<T>::indexOf(const T &t, int from) const
     if (from < 0)
         from = qMax(from + d->size, 0);
     if (from < d->size) {
-        T* n = d->array + from - 1;
-        T* e = d->array + d->size;
+        T* n = p->array + from - 1;
+        T* e = p->array + d->size;
         while (++n != e)
             if (*n == t)
-                return n - d->array;
+                return n - p->array;
     }
     return -1;
 }
@@ -665,8 +655,8 @@ int QVector<T>::lastIndexOf(const T &t, int from) const
     else if (from >= d->size)
         from = d->size-1;
     if (from >= 0) {
-        T* b = d->array;
-        T* n = d->array + from + 1;
+        T* b = p->array;
+        T* n = p->array + from + 1;
         while (n != b) {
             if (*--n == t)
                 return n - b;
@@ -678,8 +668,8 @@ int QVector<T>::lastIndexOf(const T &t, int from) const
 template <typename T>
 bool QVector<T>::contains(const T &t) const
 {
-    T* b = d->array;
-    T* i = d->array + d->size;
+    T* b = p->array;
+    T* i = p->array + d->size;
     while (i != b)
         if (*--i == t)
             return true;
@@ -690,8 +680,8 @@ template <typename T>
 int QVector<T>::count(const T &t) const
 {
     int c = 0;
-    T* b = d->array;
-    T* i = d->array + d->size;
+    T* b = p->array;
+    T* i = p->array + d->size;
     while (i != b)
         if (*--i == t)
             ++c;
diff --git a/src/corelib/tools/tools.pri b/src/corelib/tools/tools.pri
index e5bf7e4..aea0c6c 100644
--- a/src/corelib/tools/tools.pri
+++ b/src/corelib/tools/tools.pri
@@ -11,6 +11,7 @@ HEADERS +=  \
 	tools/qcryptographichash.h \
 	tools/qdatetime.h \
 	tools/qdatetime_p.h \
+        tools/qeasingcurve.h \
 	tools/qhash.h \
         tools/qline.h \
 	tools/qlinkedlist.h \
@@ -19,6 +20,7 @@ HEADERS +=  \
 	tools/qlocale_p.h \
 	tools/qlocale_data_p.h \
 	tools/qmap.h \
+        tools/qcontiguouscache.h \
         tools/qpodlist_p.h \
         tools/qpoint.h \
 	tools/qqueue.h \
@@ -30,6 +32,7 @@ HEADERS +=  \
         tools/qsize.h \
 	tools/qstack.h \
 	tools/qstring.h \
+	tools/qstringbuilder.h \
 	tools/qstringlist.h \
 	tools/qstringmatcher.h \
 	tools/qtextboundaryfinder.h \
@@ -45,7 +48,7 @@ SOURCES += \
 	tools/qbytearraymatcher.cpp \
 	tools/qcryptographichash.cpp \
 	tools/qdatetime.cpp \
-	tools/qdumper.cpp \
+        tools/qeasingcurve.cpp \
 	tools/qhash.cpp \
         tools/qline.cpp \
 	tools/qlinkedlist.cpp \
@@ -53,12 +56,14 @@ SOURCES += \
 	tools/qlocale.cpp \
         tools/qpoint.cpp \
 	tools/qmap.cpp \
+	tools/qcontiguouscache.cpp \
         tools/qrect.cpp \
 	tools/qregexp.cpp \
 	tools/qshareddata.cpp \
 	tools/qsharedpointer.cpp \
         tools/qsize.cpp \
 	tools/qstring.cpp \
+	tools/qstringbuilder.cpp \
 	tools/qstringlist.cpp \
 	tools/qtextboundaryfinder.cpp \
 	tools/qtimeline.cpp \