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

* 'master' of scm.dev.nokia.troll.no:qt/oslo-staging-2:
  Fix LeftToRight + setSpacing + setWrapping when drag-and-dropping
  Remove tst_QStringRef::localeAwareCompare
  Itemviews:  use localeAwareCompare for comparing in the widget classes
  tst_qstringref.cpp: Fix licence header and compilation on windows
  Add some convenience functions for QStringRef

6 files changed, 886 insertions, 130 deletions

diff --git a/src/corelib/kernel/qabstractitemmodel.cpp b/src/corelib/kernel/qabstractitemmodel.cpp
index b0e2f48..2b0eff6 100644
--- a/src/corelib/kernel/qabstractitemmodel.cpp
+++ b/src/corelib/kernel/qabstractitemmodel.cpp
@@ -532,7 +532,7 @@ bool QAbstractItemModelPrivate::variantLessThan(const QVariant &v1, const QVaria
     case 1: //floating point
         return v1.toReal() < v2.toReal();
     default:
-        return v1.toString() < v2.toString();
+        return v1.toString().localeAwareCompare(v2.toString()) < 0;
     }
 }
 
diff --git a/src/corelib/tools/qstring.cpp b/src/corelib/tools/qstring.cpp
index 6acbcec..e1167fa 100644
--- a/src/corelib/tools/qstring.cpp
+++ b/src/corelib/tools/qstring.cpp
@@ -107,7 +107,23 @@ int qFindString(const QChar *haystack, int haystackLen, int from,
     const QChar *needle, int needleLen, Qt::CaseSensitivity cs);
 int qFindStringBoyerMoore(const QChar *haystack, int haystackLen, int from,
     const QChar *needle, int needleLen, Qt::CaseSensitivity cs);
-
+static inline int qt_last_index_of(const QChar *haystack, int haystackLen, const QChar &needle,
+                                   int from, Qt::CaseSensitivity cs);
+static inline int qt_string_count(const QChar *haystack, int haystackLen,
+                                  const QChar *needle, int needleLen,
+                                  Qt::CaseSensitivity cs);
+static inline int qt_string_count(const QChar *haystack, int haystackLen,
+                                  const QChar &needle, Qt::CaseSensitivity cs);
+static inline int qt_find_latin1_string(const QChar *hay, int size, const QLatin1String &needle,
+                                        int from, Qt::CaseSensitivity cs);
+static inline bool qt_starts_with(const QChar *haystack, int haystackLen,
+                                  const QChar *needle, int needleLen, Qt::CaseSensitivity cs);
+static inline bool qt_starts_with(const QChar *haystack, int haystackLen,
+                                  const QLatin1String &needle, Qt::CaseSensitivity cs);
+static inline bool qt_ends_with(const QChar *haystack, int haystackLen,
+                                const QChar *needle, int needleLen, Qt::CaseSensitivity cs);
+static inline bool qt_ends_with(const QChar *haystack, int haystackLen,
+                                const QLatin1String &needle, Qt::CaseSensitivity cs);
 
 // Unicode case-insensitive comparison
 static int ucstricmp(const ushort *a, const ushort *ae, const ushort *b, const ushort *be)
@@ -2446,14 +2462,10 @@ int QString::indexOf(const QString &str, int from, Qt::CaseSensitivity cs) const
 
   \sa lastIndexOf(), contains(), count()
 */
+
 int QString::indexOf(const QLatin1String &str, int from, Qt::CaseSensitivity cs) const
 {
-    int len = qstrlen(str.latin1());
-    QVarLengthArray<ushort> s(len);
-    for (int i = 0; i < len; ++i)
-        s[i] = str.latin1()[i];
-
-    return qFindString(unicode(), length(), from, (const QChar *)s.data(), len, cs);
+    return qt_find_latin1_string(unicode(), size(), str, from, cs);
 }
 
 int qFindString(
@@ -2543,6 +2555,23 @@ int QString::indexOf(QChar ch, int from, Qt::CaseSensitivity cs) const
     return findChar(unicode(), length(), ch, from, cs);
 }
 
+/*!
+    \since 4.8
+
+    \overload indexOf()
+
+    Returns the index position of the first occurrence of the string
+    reference \a str in this string, searching forward from index
+    position \a from. Returns -1 if \a str is not found.
+
+    If \a cs is Qt::CaseSensitive (default), the search is case
+    sensitive; otherwise the search is case insensitive.
+*/
+int QString::indexOf(const QStringRef &str, int from, Qt::CaseSensitivity cs) const
+{
+    return qFindString(unicode(), length(), from, str.unicode(), str.length(), cs);
+}
+
 static int lastIndexOfHelper(const ushort *haystack, int from, const ushort *needle, int sl, Qt::CaseSensitivity cs)
 {
     /*
@@ -2622,12 +2651,13 @@ int QString::lastIndexOf(const QString &str, int from, Qt::CaseSensitivity cs) c
     if (from > delta)
         from = delta;
 
-
     return lastIndexOfHelper(d->data, from, str.d->data, str.d->size, cs);
 }
 
 /*!
   \since 4.5
+  \overload lastIndexOf()
+
   Returns the index position of the last occurrence of the string \a
   str in this string, searching backward from index position \a
   from. If \a from is -1 (default), the search starts at the last
@@ -2675,26 +2705,43 @@ int QString::lastIndexOf(const QLatin1String &str, int from, Qt::CaseSensitivity
 */
 int QString::lastIndexOf(QChar ch, int from, Qt::CaseSensitivity cs) const
 {
-    ushort c = ch.unicode();
-    if (from < 0)
-        from += d->size;
-    if (from < 0 || from >= d->size)
-        return -1;
-    if (from >= 0) {
-        const ushort *n = d->data + from;
-        const ushort *b = d->data;
-        if (cs == Qt::CaseSensitive) {
-            for (; n >= b; --n)
-                if (*n == c)
-                    return n - b;
-        } else {
-            c = foldCase(c);
-            for (; n >= b; --n)
-                if (foldCase(*n) == c)
-                    return n - b;
-        }
+    return qt_last_index_of(unicode(), size(), ch, from, cs);
     }
+
+/*!
+  \since 4.8
+  \overload lastIndexOf()
+
+  Returns the index position of the last occurrence of the string
+  reference \a str in this string, searching backward from index
+  position \a from. If \a from is -1 (default), the search starts at
+  the last character; if \a from is -2, at the next to last character
+  and so on. Returns -1 if \a str is not found.
+
+  If \a cs is Qt::CaseSensitive (default), the search is case
+  sensitive; otherwise the search is case insensitive.
+
+  \sa indexOf(), contains(), count()
+*/
+int QString::lastIndexOf(const QStringRef &str, int from, Qt::CaseSensitivity cs) const
+{
+    const int sl = str.size();
+    if (sl == 1)
+        return lastIndexOf(str.at(0), from, cs);
+
+    const int l = d->size;
+    if (from < 0)
+        from += l;
+    int delta = l - sl;
+    if (from == l && sl == 0)
+        return from;
+    if (from < 0 || from >= l || delta < 0)
     return -1;
+    if (from > delta)
+        from = delta;
+
+    return lastIndexOfHelper(d->data, from, reinterpret_cast<const ushort*>(str.unicode()),
+                             str.size(), cs);
 }
 
 #ifndef QT_NO_REGEXP
@@ -2869,19 +2916,10 @@ QString& QString::replace(const QRegExp &rx, const QString &after)
 
     \sa contains(), indexOf()
 */
+
 int QString::count(const QString &str, Qt::CaseSensitivity cs) const
 {
-    int num = 0;
-    int i = -1;
-    if (d->size > 500 && str.d->size > 5) {
-        QStringMatcher matcher(str, cs);
-        while ((i = matcher.indexIn(*this, i + 1)) != -1)
-            ++num;
-    } else {
-        while ((i = indexOf(str, i + 1, cs)) != -1)
-            ++num;
-    }
-    return num;
+    return qt_string_count(unicode(), size(), str.unicode(), str.size(), cs);
 }
 
 /*!
@@ -2889,25 +2927,29 @@ int QString::count(const QString &str, Qt::CaseSensitivity cs) const
 
   Returns the number of occurrences of character \a ch in the string.
 */
+
 int QString::count(QChar ch, Qt::CaseSensitivity cs) const
 {
-    ushort c = ch.unicode();
-    int num = 0;
-    const ushort *i = d->data + d->size;
-    const ushort *b = d->data;
-    if (cs == Qt::CaseSensitive) {
-        while (i != b)
-            if (*--i == c)
-                ++num;
-    } else {
-        c = foldCase(c);
-        while (i != b)
-            if (foldCase(*(--i)) == c)
-                ++num;
+    return qt_string_count(unicode(), size(), ch, cs);
     }
-    return num;
+
+/*!
+    \since 4.8
+    \overload count()
+    Returns the number of (potentially overlapping) occurrences of the
+    string reference \a str in this string.
+
+    If \a cs is Qt::CaseSensitive (default), the search is
+    case sensitive; otherwise the search is case insensitive.
+
+    \sa contains(), indexOf()
+*/
+int QString::count(const QStringRef &str, Qt::CaseSensitivity cs) const
+{
+    return qt_string_count(unicode(), size(), str.unicode(), str.size(), cs);
 }
 
+
 /*! \fn bool QString::contains(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
 
     Returns true if this string contains an occurrence of the string
@@ -2930,6 +2972,18 @@ int QString::count(QChar ch, Qt::CaseSensitivity cs) const
     character \a ch; otherwise returns false.
 */
 
+/*! \fn bool QString::contains(const QStringRef &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
+    \since 4.8
+
+    Returns true if this string contains an occurrence of the string
+    reference \a str; otherwise returns false.
+
+    If \a cs is Qt::CaseSensitive (default), the search is
+    case sensitive; otherwise the search is case insensitive.
+
+    \sa indexOf(), count()
+*/
+
 /*! \fn bool QString::contains(const QRegExp &rx) const
 
     \overload contains()
@@ -3331,22 +3385,8 @@ QString QString::mid(int position, int n) const
 */
 bool QString::startsWith(const QString& s, Qt::CaseSensitivity cs) const
 {
-    if (d == &shared_null)
-        return (s.d == &shared_null);
-    if (d->size == 0)
-        return s.d->size == 0;
-    if (s.d->size > d->size)
-        return false;
-    if (cs == Qt::CaseSensitive) {
-        return qMemEquals(d->data, s.d->data, s.d->size);
-    } else {
-        uint last = 0;
-        uint olast = 0;
-        for (int i = 0; i < s.d->size; ++i)
-            if (foldCase(d->data[i], last) != foldCase(s.d->data[i], olast))
-                return false;
-    }
-    return true;
+    return qt_starts_with(isNull() ? 0 : unicode(), size(),
+                          s.isNull() ? 0 : s.unicode(), s.size(), cs);
 }
 
 /*!
@@ -3354,24 +3394,7 @@ bool QString::startsWith(const QString& s, Qt::CaseSensitivity cs) const
  */
 bool QString::startsWith(const QLatin1String& s, Qt::CaseSensitivity cs) const
 {
-    if (d == &shared_null)
-        return (s.latin1() == 0);
-    if (d->size == 0)
-        return !s.latin1() || *s.latin1() == 0;
-    int slen = qstrlen(s.latin1());
-    if (slen > d->size)
-        return false;
-    const uchar *latin = (const uchar *)s.latin1();
-    if (cs == Qt::CaseSensitive) {
-        for (int i = 0; i < slen; ++i)
-            if (d->data[i] != latin[i])
-                return false;
-    } else {
-        for (int i = 0; i < slen; ++i)
-            if (foldCase(d->data[i]) != foldCase((ushort)latin[i]))
-                return false;
-    }
-    return true;
+    return qt_starts_with(isNull() ? 0 : unicode(), size(), s, cs);
 }
 
 /*!
@@ -3389,6 +3412,23 @@ bool QString::startsWith(const QChar &c, Qt::CaseSensitivity cs) const
 }
 
 /*!
+    \since 4.8
+    \overload
+    Returns true if the string starts with the string reference \a s;
+    otherwise returns false.
+
+    If \a cs is Qt::CaseSensitive (default), the search is case
+    sensitive; otherwise the search is case insensitive.
+
+    \sa endsWith()
+*/
+bool QString::startsWith(const QStringRef &s, Qt::CaseSensitivity cs) const
+{
+    return qt_starts_with(isNull() ? 0 : unicode(), size(),
+                          s.isNull() ? 0 : s.unicode(), s.size(), cs);
+}
+
+/*!
     Returns true if the string ends with \a s; otherwise returns
     false.
 
@@ -3401,49 +3441,34 @@ bool QString::startsWith(const QChar &c, Qt::CaseSensitivity cs) const
 */
 bool QString::endsWith(const QString& s, Qt::CaseSensitivity cs) const
 {
-    if (d == &shared_null)
-        return (s.d == &shared_null);
-    if (d->size == 0)
-        return s.d->size == 0;
-    int pos = d->size - s.d->size;
-    if (pos < 0)
-        return false;
-    if (cs == Qt::CaseSensitive) {
-        return qMemEquals(d->data + pos, s.d->data, s.d->size);
-    } else {
-        uint last = 0;
-        uint olast = 0;
-        for (int i = 0; i < s.length(); i++)
-            if (foldCase(d->data[pos+i], last) != foldCase(s.d->data[i], olast))
-                return false;
+    return qt_ends_with(isNull() ? 0 : unicode(), size(),
+                        s.isNull() ? 0 : s.unicode(), s.size(), cs);
     }
-    return true;
+
+/*!
+    \since 4.8
+    \overload endsWith()
+    Returns true if the string ends with the string reference \a s;
+    otherwise returns false.
+
+    If \a cs is Qt::CaseSensitive (default), the search is case
+    sensitive; otherwise the search is case insensitive.
+
+    \sa startsWith()
+*/
+bool QString::endsWith(const QStringRef &s, Qt::CaseSensitivity cs) const
+{
+    return qt_ends_with(isNull() ? 0 : unicode(), size(),
+                        s.isNull() ? 0 : s.unicode(), s.size(), cs);
 }
 
+
 /*!
     \overload endsWith()
 */
 bool QString::endsWith(const QLatin1String& s, Qt::CaseSensitivity cs) const
 {
-    if (d == &shared_null)
-        return (s.latin1() == 0);
-    if (d->size == 0)
-        return !s.latin1() || *s.latin1() == 0;
-    int slen = qstrlen(s.latin1());
-    int pos = d->size - slen;
-    const uchar *latin = (const uchar *)s.latin1();
-    if (pos < 0)
-        return false;
-    if (cs == Qt::CaseSensitive) {
-        for (int i = 0; i < slen; i++)
-            if (d->data[pos+i] != latin[i])
-                return false;
-    } else {
-        for (int i = 0; i < slen; i++)
-            if (foldCase(d->data[pos+i]) != foldCase((ushort)latin[i]))
-                return false;
-    }
-    return true;
+    return qt_ends_with(isNull() ? 0 : unicode(), size(), s, cs);
 }
 
 /*!
@@ -7613,6 +7638,7 @@ QDataStream &operator>>(QDataStream &in, QString &str)
     Use the startsWith(QString, Qt::CaseSensitive) overload instead.
 */
 
+
 /*!
     \fn bool QString::endsWith(const QString &s, bool cs) const
 
@@ -8318,4 +8344,607 @@ QStringRef QString::midRef(int position, int n) const
     return QStringRef(this, position, n);
 }
 
+/*!
+  \since 4.8
+
+  Returns the index position of the first occurrence of the string \a
+  str in this string reference, searching forward from index position
+  \a from. Returns -1 if \a str is not found.
+
+  If \a cs is Qt::CaseSensitive (default), the search is case
+  sensitive; otherwise the search is case insensitive.
+
+  If \a from is -1, the search starts at the last character; if it is
+  -2, at the next to last character and so on.
+
+  \sa QString::indexOf(), lastIndexOf(), contains(), count()
+*/
+int QStringRef::indexOf(const QString &str, int from, Qt::CaseSensitivity cs) const
+{
+    return qFindString(unicode(), length(), from, str.unicode(), str.length(), cs);
+}
+
+/*!
+    \since 4.8
+    \overload indexOf()
+
+    Returns the index position of the first occurrence of the
+    character \a ch in the string reference, searching forward from
+    index position \a from. Returns -1 if \a ch could not be found.
+
+    \sa QString::indexOf(), lastIndexOf(), contains(), count()
+*/
+int QStringRef::indexOf(QChar ch, int from, Qt::CaseSensitivity cs) const
+{
+    return findChar(unicode(), length(), ch, from, cs);
+}
+
+/*!
+  \since 4.8
+
+  Returns the index position of the first occurrence of the string \a
+  str in this string reference, searching forward from index position
+  \a from. Returns -1 if \a str is not found.
+
+  If \a cs is Qt::CaseSensitive (default), the search is case
+  sensitive; otherwise the search is case insensitive.
+
+  If \a from is -1, the search starts at the last character; if it is
+  -2, at the next to last character and so on.
+
+  \sa QString::indexOf(), lastIndexOf(), contains(), count()
+*/
+int QStringRef::indexOf(QLatin1String str, int from, Qt::CaseSensitivity cs) const
+{
+    return qt_find_latin1_string(unicode(), size(), str, from, cs);
+}
+
+/*!
+    \since 4.8
+
+    \overload indexOf()
+
+    Returns the index position of the first occurrence of the string
+    reference \a str in this string reference, searching forward from
+    index position \a from. Returns -1 if \a str is not found.
+
+    If \a cs is Qt::CaseSensitive (default), the search is case
+    sensitive; otherwise the search is case insensitive.
+
+    \sa QString::indexOf(), lastIndexOf(), contains(), count()
+*/
+int QStringRef::indexOf(const QStringRef &str, int from, Qt::CaseSensitivity cs) const
+{
+    return qFindString(unicode(), size(), from, str.unicode(), str.size(), cs);
+}
+
+/*!
+  \since 4.8
+
+  Returns the index position of the last occurrence of the string \a
+  str in this string reference, searching backward from index position
+  \a from. If \a from is -1 (default), the search starts at the last
+  character; if \a from is -2, at the next to last character and so
+  on. Returns -1 if \a str is not found.
+
+  If \a cs is Qt::CaseSensitive (default), the search is case
+  sensitive; otherwise the search is case insensitive.
+
+  \sa QString::lastIndexOf(), indexOf(), contains(), count()
+*/
+int QStringRef::lastIndexOf(const QString &str, int from, Qt::CaseSensitivity cs) const
+{
+    const int sl = str.size();
+    if (sl == 1)
+        return lastIndexOf(str.at(0), from, cs);
+
+    const int l = size();;
+    if (from < 0)
+        from += l;
+    int delta = l - sl;
+    if (from == l && sl == 0)
+        return from;
+    if (from < 0 || from >= l || delta < 0)
+        return -1;
+    if (from > delta)
+        from = delta;
+
+    return lastIndexOfHelper(reinterpret_cast<const ushort*>(unicode()), from,
+                             reinterpret_cast<const ushort*>(str.unicode()), str.size(), cs);
+}
+
+/*!
+  \since 4.8
+  \overload lastIndexOf()
+
+  Returns the index position of the last occurrence of the character
+  \a ch, searching backward from position \a from.
+
+  \sa QString::lastIndexOf(), indexOf(), contains(), count()
+*/
+int QStringRef::lastIndexOf(QChar ch, int from, Qt::CaseSensitivity cs) const
+{
+    return qt_last_index_of(unicode(), size(), ch, from, cs);
+}
+
+/*!
+  \since 4.8
+  \overload lastIndexOf()
+
+  Returns the index position of the last occurrence of the string \a
+  str in this string reference, searching backward from index position
+  \a from. If \a from is -1 (default), the search starts at the last
+  character; if \a from is -2, at the next to last character and so
+  on. Returns -1 if \a str is not found.
+
+  If \a cs is Qt::CaseSensitive (default), the search is case
+  sensitive; otherwise the search is case insensitive.
+
+  \sa QString::lastIndexOf(), indexOf(), contains(), count()
+*/
+int QStringRef::lastIndexOf(QLatin1String str, int from, Qt::CaseSensitivity cs) const
+{
+    const int sl = qstrlen(str.latin1());
+    if (sl == 1)
+        return lastIndexOf(QLatin1Char(str.latin1()[0]), from, cs);
+
+    const int l = size();
+    if (from < 0)
+        from += l;
+    int delta = l - sl;
+    if (from == l && sl == 0)
+        return from;
+    if (from < 0 || from >= l || delta < 0)
+        return -1;
+    if (from > delta)
+        from = delta;
+
+    QVarLengthArray<ushort> s(sl);
+    for (int i = 0; i < sl; ++i)
+        s[i] = str.latin1()[i];
+
+    return lastIndexOfHelper(reinterpret_cast<const ushort*>(unicode()), from, s.data(), sl, cs);
+}
+
+/*!
+  \since 4.8
+  \overload lastIndexOf()
+
+  Returns the index position of the last occurrence of the string
+  reference \a str in this string reference, searching backward from
+  index position \a from. If \a from is -1 (default), the search
+  starts at the last character; if \a from is -2, at the next to last
+  character and so on. Returns -1 if \a str is not found.
+
+  If \a cs is Qt::CaseSensitive (default), the search is case
+  sensitive; otherwise the search is case insensitive.
+
+  \sa QString::lastIndexOf(), indexOf(), contains(), count()
+*/
+int QStringRef::lastIndexOf(const QStringRef &str, int from, Qt::CaseSensitivity cs) const
+{
+    const int sl = str.size();
+    if (sl == 1)
+        return lastIndexOf(str.at(0), from, cs);
+
+    const int l = size();
+    if (from < 0)
+        from += l;
+    int delta = l - sl;
+    if (from == l && sl == 0)
+        return from;
+    if (from < 0 || from >= l || delta < 0)
+        return -1;
+    if (from > delta)
+        from = delta;
+
+    return lastIndexOfHelper(reinterpret_cast<const ushort*>(unicode()), from,
+                             reinterpret_cast<const ushort*>(str.unicode()),
+                             str.size(), cs);
+}
+
+/*!
+    \since 4.8
+    Returns the number of (potentially overlapping) occurrences of
+    the string \a str in this string reference.
+
+    If \a cs is Qt::CaseSensitive (default), the search is
+    case sensitive; otherwise the search is case insensitive.
+
+    \sa QString::count(), contains(), indexOf()
+*/
+int QStringRef::count(const QString &str, Qt::CaseSensitivity cs) const
+{
+    return qt_string_count(unicode(), size(), str.unicode(), str.size(), cs);
+}
+
+/*!
+    \since 4.8
+    \overload count()
+
+    Returns the number of occurrences of the character \a ch in the
+    string reference.
+
+    If \a cs is Qt::CaseSensitive (default), the search is
+    case sensitive; otherwise the search is case insensitive.
+
+    \sa QString::count(), contains(), indexOf()
+*/
+int QStringRef::count(QChar ch, Qt::CaseSensitivity cs) const
+{
+    return qt_string_count(unicode(), size(), ch, cs);
+}
+
+/*!
+    \since 4.8
+    \overload count()
+
+    Returns the number of (potentially overlapping) occurrences of the
+    string reference \a str in this string reference.
+
+    If \a cs is Qt::CaseSensitive (default), the search is
+    case sensitive; otherwise the search is case insensitive.
+
+    \sa QString::count(), contains(), indexOf()
+*/
+int QStringRef::count(const QStringRef &str, Qt::CaseSensitivity cs) const
+{
+    return qt_string_count(unicode(), size(), str.unicode(), str.size(), cs);
+}
+
+/*!
+    \since 4.8
+
+    Returns true if the string reference starts with \a str; otherwise
+    returns false.
+
+    If \a cs is Qt::CaseSensitive (default), the search is
+    case sensitive; otherwise the search is case insensitive.
+
+    \sa QString::startsWith(), endsWith()
+*/
+bool QStringRef::startsWith(const QString &str, Qt::CaseSensitivity cs) const
+{
+    return qt_starts_with(isNull() ? 0 : unicode(), size(),
+                          str.isNull() ? 0 : str.unicode(), str.size(), cs);
+}
+
+/*!
+    \since 4.8
+    \overload startsWith()
+    \sa QString::startsWith(), endsWith()
+*/
+bool QStringRef::startsWith(QLatin1String str, Qt::CaseSensitivity cs) const
+{
+    return qt_starts_with(isNull() ? 0 : unicode(), size(), str, cs);
+}
+
+/*!
+    \since 4.8
+    \overload startsWith()
+    \sa QString::startsWith(), endsWith()
+*/
+bool QStringRef::startsWith(const QStringRef &str, Qt::CaseSensitivity cs) const
+{
+    return qt_starts_with(isNull() ? 0 : unicode(), size(),
+                          str.isNull() ? 0 : str.unicode(), str.size(), cs);
+}
+
+/*!
+    \since 4.8
+    \overload startsWith()
+
+    Returns true if the string reference starts with \a ch; otherwise
+    returns false.
+
+    If \a cs is Qt::CaseSensitive (default), the search is case
+    sensitive; otherwise the search is case insensitive.
+
+    \sa QString::startsWith(), endsWith()
+*/
+bool QStringRef::startsWith(QChar ch, Qt::CaseSensitivity cs) const
+{
+    if (!isEmpty()) {
+        const ushort *data = reinterpret_cast<const ushort*>(unicode());
+        return (cs == Qt::CaseSensitive
+                ? data[0] == ch
+                : foldCase(data[0]) == foldCase(ch.unicode()));
+    } else {
+        return false;
+    }
+}
+
+/*!
+    \since 4.8
+    Returns true if the string reference ends with \a str; otherwise
+    returns false.
+
+    If \a cs is Qt::CaseSensitive (default), the search is case
+    sensitive; otherwise the search is case insensitive.
+
+    \sa QString::endsWith(), startsWith()
+*/
+bool QStringRef::endsWith(const QString &str, Qt::CaseSensitivity cs) const
+{
+    return qt_ends_with(isNull() ? 0 : unicode(), size(),
+                        str.isNull() ? 0 : str.unicode(), str.size(), cs);
+}
+
+/*!
+    \since 4.8
+    \overload endsWith()
+
+    Returns true if the string reference ends with \a ch; otherwise
+    returns false.
+
+    If \a cs is Qt::CaseSensitive (default), the search is case
+    sensitive; otherwise the search is case insensitive.
+
+    \sa QString::endsWith(), endsWith()
+*/
+bool QStringRef::endsWith(QChar ch, Qt::CaseSensitivity cs) const
+{
+    if (!isEmpty()) {
+        const ushort *data = reinterpret_cast<const ushort*>(unicode());
+        const int size = length();
+        return (cs == Qt::CaseSensitive
+                ? data[size - 1] == ch
+                : foldCase(data[size - 1]) == foldCase(ch.unicode()));
+    } else {
+        return false;
+    }
+}
+
+/*!
+    \since 4.8
+    \overload endsWith()
+    \sa QString::endsWith(), endsWith()
+*/
+bool QStringRef::endsWith(QLatin1String str, Qt::CaseSensitivity cs) const
+{
+    return qt_ends_with(isNull() ? 0 : unicode(), size(), str, cs);
+}
+
+/*!
+    \since 4.8
+    \overload endsWith()
+    \sa QString::endsWith(), endsWith()
+*/
+bool QStringRef::endsWith(const QStringRef &str, Qt::CaseSensitivity cs) const
+{
+    return qt_ends_with(isNull() ? 0 : unicode(), size(),
+                        str.isNull() ? 0 : str.unicode(), str.size(), cs);
+}
+
+
+/*! \fn bool QStringRef::contains(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
+
+    \since 4.8
+    Returns true if this string reference contains an occurrence of
+    the string \a str; otherwise returns false.
+
+    If \a cs is Qt::CaseSensitive (default), the search is
+    case sensitive; otherwise the search is case insensitive.
+
+    \sa indexOf(), count()
+*/
+
+/*! \fn bool QStringRef::contains(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
+
+    \overload contains()
+    \since 4.8
+
+    Returns true if this string contains an occurrence of the
+    character \a ch; otherwise returns false.
+
+    If \a cs is Qt::CaseSensitive (default), the search is
+    case sensitive; otherwise the search is case insensitive.
+
+*/
+
+/*! \fn bool QStringRef::contains(const QStringRef &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
+    \overload contains()
+    \since 4.8
+
+    Returns true if this string reference contains an occurrence of
+    the string reference \a str; otherwise returns false.
+
+    If \a cs is Qt::CaseSensitive (default), the search is
+    case sensitive; otherwise the search is case insensitive.
+
+    \sa indexOf(), count()
+*/
+
+/*! \fn bool QStringRef::contains(QLatin1String str, Qt::CaseSensitivity cs) const
+    \since 4,8
+    \overload contains()
+
+    Returns true if this string reference contains an occurrence of
+    the string \a str; otherwise returns false.
+
+    If \a cs is Qt::CaseSensitive (default), the search is
+    case sensitive; otherwise the search is case insensitive.
+
+    \sa indexOf(), count()
+*/
+
+static inline int qt_last_index_of(const QChar *haystack, int haystackLen, const QChar &needle,
+                                   int from, Qt::CaseSensitivity cs)
+{
+    ushort c = needle.unicode();
+    if (from < 0)
+        from += haystackLen;
+    if (from < 0 || from >= haystackLen)
+        return -1;
+    if (from >= 0) {
+        const ushort *b = reinterpret_cast<const ushort*>(haystack);
+        const ushort *n = b + from;
+        if (cs == Qt::CaseSensitive) {
+            for (; n >= b; --n)
+                if (*n == c)
+                    return n - b;
+        } else {
+            c = foldCase(c);
+            for (; n >= b; --n)
+                if (foldCase(*n) == c)
+                    return n - b;
+        }
+    }
+    return -1;
+
+
+}
+
+static inline int qt_string_count(const QChar *haystack, int haystackLen,
+                                  const QChar *needle, int needleLen,
+                                  Qt::CaseSensitivity cs)
+{
+    int num = 0;
+    int i = -1;
+    if (haystackLen > 500 && needleLen > 5) {
+        QStringMatcher matcher(needle, needleLen, cs);
+        while ((i = matcher.indexIn(haystack, haystackLen, i + 1)) != -1)
+            ++num;
+    } else {
+        while ((i = qFindString(haystack, haystackLen, i + 1, needle, needleLen, cs)) != -1)
+            ++num;
+    }
+    return num;
+}
+
+static inline int qt_string_count(const QChar *unicode, int size, const QChar &ch,
+                                  Qt::CaseSensitivity cs)
+{
+    ushort c = ch.unicode();
+    int num = 0;
+    const ushort *b = reinterpret_cast<const ushort*>(unicode);
+    const ushort *i = b + size;
+    if (cs == Qt::CaseSensitive) {
+        while (i != b)
+            if (*--i == c)
+                ++num;
+    } else {
+        c = foldCase(c);
+        while (i != b)
+            if (foldCase(*(--i)) == c)
+                ++num;
+    }
+    return num;
+}
+
+static inline int qt_find_latin1_string(const QChar *haystack, int size,
+                                        const QLatin1String &needle,
+                                        int from, Qt::CaseSensitivity cs)
+{
+    const char *latin1 = needle.latin1();
+    int len = qstrlen(latin1);
+    QVarLengthArray<ushort> s(len);
+    for (int i = 0; i < len; ++i)
+        s[i] = latin1[i];
+
+    return qFindString(haystack, size, from,
+                       reinterpret_cast<const QChar*>(s.constData()), len, cs);
+}
+
+static inline bool qt_starts_with(const QChar *haystack, int haystackLen,
+                                  const QChar *needle, int needleLen, Qt::CaseSensitivity cs)
+{
+    if (!haystack)
+        return !needle;
+    if (haystackLen == 0)
+        return needleLen == 0;
+    if (needleLen > haystackLen)
+        return false;
+
+    const ushort *h = reinterpret_cast<const ushort*>(haystack);
+    const ushort *n = reinterpret_cast<const ushort*>(needle);
+
+    if (cs == Qt::CaseSensitive) {
+        return qMemEquals(h, n, needleLen);
+    } else {
+        uint last = 0;
+        uint olast = 0;
+        for (int i = 0; i < needleLen; ++i)
+            if (foldCase(h[i], last) != foldCase(n[i], olast))
+                return false;
+    }
+    return true;
+}
+
+static inline bool qt_starts_with(const QChar *haystack, int haystackLen,
+                                  const QLatin1String &needle, Qt::CaseSensitivity cs)
+{
+    if (!haystack)
+        return !needle.latin1();
+    if (haystackLen == 0)
+        return !needle.latin1() || *needle.latin1() == 0;
+    const int slen = qstrlen(needle.latin1());
+    if (slen > haystackLen)
+        return false;
+    const ushort *data = reinterpret_cast<const ushort*>(haystack);
+    const uchar *latin = reinterpret_cast<const uchar*>(needle.latin1());
+    if (cs == Qt::CaseSensitive) {
+        for (int i = 0; i < slen; ++i)
+            if (data[i] != latin[i])
+                return false;
+    } else {
+        for (int i = 0; i < slen; ++i)
+            if (foldCase(data[i]) != foldCase((ushort)latin[i]))
+                return false;
+    }
+    return true;
+}
+
+static inline bool qt_ends_with(const QChar *haystack, int haystackLen,
+                                const QChar *needle, int needleLen, Qt::CaseSensitivity cs)
+{
+    if (!haystack)
+        return !needle;
+    if (haystackLen == 0)
+        return needleLen == 0;
+    const int pos = haystackLen - needleLen;
+    if (pos < 0)
+        return false;
+
+    const ushort *h = reinterpret_cast<const ushort*>(haystack);
+    const ushort *n = reinterpret_cast<const ushort*>(needle);
+
+    if (cs == Qt::CaseSensitive) {
+        return qMemEquals(h + pos, n, needleLen);
+    } else {
+        uint last = 0;
+        uint olast = 0;
+        for (int i = 0; i < needleLen; i++)
+            if (foldCase(h[pos+i], last) != foldCase(n[i], olast))
+                return false;
+    }
+    return true;
+}
+
+
+static inline bool qt_ends_with(const QChar *haystack, int haystackLen,
+                                const QLatin1String &needle, Qt::CaseSensitivity cs)
+{
+    if (!haystack)
+        return !needle.latin1();
+    if (haystackLen == 0)
+        return !needle.latin1() || *needle.latin1() == 0;
+    const int slen = qstrlen(needle.latin1());
+    int pos = haystackLen - slen;
+    if (pos < 0)
+        return false;
+    const uchar *latin = reinterpret_cast<const uchar*>(needle.latin1());
+    const ushort *data = reinterpret_cast<const ushort*>(haystack);
+    if (cs == Qt::CaseSensitive) {
+        for (int i = 0; i < slen; i++)
+            if (data[pos+i] != latin[i])
+                return false;
+    } else {
+        for (int i = 0; i < slen; i++)
+            if (foldCase(data[pos+i]) != foldCase((ushort)latin[i]))
+                return false;
+    }
+    return true;
+}
+
 QT_END_NAMESPACE
diff --git a/src/corelib/tools/qstring.h b/src/corelib/tools/qstring.h
index a1c4e77..ed87acf 100644
--- a/src/corelib/tools/qstring.h
+++ b/src/corelib/tools/qstring.h
@@ -198,14 +198,18 @@ public:
     int indexOf(QChar c, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
     int indexOf(const QString &s, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
     int indexOf(const QLatin1String &s, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int indexOf(const QStringRef &s, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
     int lastIndexOf(QChar c, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
     int lastIndexOf(const QString &s, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
     int lastIndexOf(const QLatin1String &s, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int lastIndexOf(const QStringRef &s, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 
     inline QBool contains(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
     inline QBool contains(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    inline QBool contains(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
     int count(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
     int count(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int count(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 
 #ifndef QT_NO_REGEXP
     int indexOf(const QRegExp &, int from = 0) const;
@@ -241,9 +245,11 @@ public:
     QStringRef midRef(int position, int n = -1) const Q_REQUIRED_RESULT;
 
     bool startsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    bool startsWith(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
     bool startsWith(const QLatin1String &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
     bool startsWith(const QChar &c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
     bool endsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    bool endsWith(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
     bool endsWith(const QLatin1String &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
     bool endsWith(const QChar &c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
 
@@ -901,6 +907,8 @@ inline QString::const_iterator QString::constEnd() const
 { return reinterpret_cast<const QChar*>(d->data + d->size); }
 inline QBool QString::contains(const QString &s, Qt::CaseSensitivity cs) const
 { return QBool(indexOf(s, 0, cs) != -1); }
+inline QBool QString::contains(const QStringRef &s, Qt::CaseSensitivity cs) const
+{ return QBool(indexOf(s, 0, cs) != -1); }
 inline QBool QString::contains(QChar c, Qt::CaseSensitivity cs) const
 { return QBool(indexOf(c, 0, cs) != -1); }
 
@@ -1122,6 +1130,34 @@ public:
         m_size = other.m_size; return *this;
     }
 
+    int indexOf(const QString &str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int indexOf(QChar ch, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int indexOf(QLatin1String str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int indexOf(const QStringRef &str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int lastIndexOf(const QString &str, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int lastIndexOf(QChar ch, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int lastIndexOf(QLatin1String str, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int lastIndexOf(const QStringRef &str, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+
+    inline QBool contains(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    inline QBool contains(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    inline QBool contains(QLatin1String str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    inline QBool contains(const QStringRef &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+
+    int count(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int count(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int count(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+
+    bool startsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    bool startsWith(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    bool startsWith(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    bool startsWith(const QStringRef &c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+
+    bool endsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    bool endsWith(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    bool endsWith(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    bool endsWith(const QStringRef &c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+
     inline QStringRef &operator=(const QString *string);
 
     inline const QChar *unicode() const {
@@ -1240,6 +1276,16 @@ inline int QStringRef::localeAwareCompare(const QStringRef &s1, const QString &s
 inline int QStringRef::localeAwareCompare(const QStringRef &s1, const QStringRef &s2)
 { return QString::localeAwareCompare_helper(s1.constData(), s1.length(), s2.constData(), s2.length()); }
 
+inline QBool QStringRef::contains(const QString &s, Qt::CaseSensitivity cs) const
+{ return QBool(indexOf(s, 0, cs) != -1); }
+inline QBool QStringRef::contains(QLatin1String s, Qt::CaseSensitivity cs) const
+{ return QBool(indexOf(s, 0, cs) != -1); }
+inline QBool QStringRef::contains(QChar c, Qt::CaseSensitivity cs) const
+{ return QBool(indexOf(c, 0, cs) != -1); }
+inline QBool QStringRef::contains(const QStringRef &s, Qt::CaseSensitivity cs) const
+{ return QBool(indexOf(s, 0, cs) != -1); }
+
+
 
 QT_END_NAMESPACE
 
diff --git a/src/gui/itemviews/qabstractitemview_p.h b/src/gui/itemviews/qabstractitemview_p.h
index fce74f3..b9408a5 100644
--- a/src/gui/itemviews/qabstractitemview_p.h
+++ b/src/gui/itemviews/qabstractitemview_p.h
@@ -136,7 +136,7 @@ public:
     void stopAutoScroll() { autoScrollTimer.stop(); autoScrollCount = 0;}
 
 
-    bool dropOn(QDropEvent *event, int *row, int *col, QModelIndex *index);
+    virtual bool dropOn(QDropEvent *event, int *row, int *col, QModelIndex *index);
     bool droppingOnItself(QDropEvent *event, const QModelIndex &index);
 
     QWidget *editor(const QModelIndex &index, const QStyleOptionViewItem &options);
diff --git a/src/gui/itemviews/qlistview.cpp b/src/gui/itemviews/qlistview.cpp
index 1869093..846d911 100644
--- a/src/gui/itemviews/qlistview.cpp
+++ b/src/gui/itemviews/qlistview.cpp
@@ -1833,6 +1833,14 @@ QAbstractItemView::DropIndicatorPosition QListViewPrivate::position(const QPoint
     else
         return QAbstractItemViewPrivate::position(pos, rect, idx);
 }
+
+bool QListViewPrivate::dropOn(QDropEvent *event, int *dropRow, int *dropCol, QModelIndex *dropIndex)
+{
+    if (viewMode == QListView::ListMode && flow == QListView::LeftToRight)
+        return static_cast<QListModeViewBase *>(commonListView)->dropOn(event, dropRow, dropCol, dropIndex);
+    else
+        return QAbstractItemViewPrivate::dropOn(event, dropRow, dropCol, dropIndex);
+}
 #endif
 
 /*
@@ -1960,7 +1968,13 @@ void QListModeViewBase::dragMoveEvent(QDragMoveEvent *event)
     // ignore by default
     event->ignore();
 
-    QModelIndex index = qq->indexAt(event->pos());
+    // can't use indexAt, doesn't account for spacing.
+    QPoint p = event->pos();
+    QRect rect(p.x() + horizontalOffset(), p.y() + verticalOffset(), 1, 1);
+    rect.adjust(-dd->spacing(), -dd->spacing(), dd->spacing(), dd->spacing());
+    const QVector<QModelIndex> intersectVector = dd->intersectingSet(rect);
+    QModelIndex index = intersectVector.count() > 0
+                        ? intersectVector.last() : QModelIndex();
     dd->hover = index;
     if (!dd->droppingOnItself(event, index)
         && dd->canDecode(event)) {
@@ -1968,10 +1982,11 @@ void QListModeViewBase::dragMoveEvent(QDragMoveEvent *event)
         if (index.isValid() && dd->showDropIndicator) {
             QRect rect = qq->visualRect(index);
             dd->dropIndicatorPosition = position(event->pos(), rect, index);
+            // if spacing, should try to draw between items, not just next to item.
             switch (dd->dropIndicatorPosition) {
             case QAbstractItemView::AboveItem:
                 if (dd->isIndexDropEnabled(index.parent())) {
-                    dd->dropIndicatorRect = QRect(rect.left(), rect.top(), 0, rect.height());
+                    dd->dropIndicatorRect = QRect(rect.left()-dd->spacing(), rect.top(), 0, rect.height());
                     event->accept();
                 } else {
                     dd->dropIndicatorRect = QRect();
@@ -1979,7 +1994,7 @@ void QListModeViewBase::dragMoveEvent(QDragMoveEvent *event)
                 break;
             case QAbstractItemView::BelowItem:
                 if (dd->isIndexDropEnabled(index.parent())) {
-                    dd->dropIndicatorRect = QRect(rect.right(), rect.top(), 0, rect.height());
+                    dd->dropIndicatorRect = QRect(rect.right()+dd->spacing(), rect.top(), 0, rect.height());
                     event->accept();
                 } else {
                     dd->dropIndicatorRect = QRect();
@@ -2014,6 +2029,68 @@ void QListModeViewBase::dragMoveEvent(QDragMoveEvent *event)
         qq->startAutoScroll();
 }
 
+/*!
+    If the event hasn't already been accepted, determines the index to drop on.
+
+    if (row == -1 && col == -1)
+        // append to this drop index
+    else
+        // place at row, col in drop index
+
+    If it returns true a drop can be done, and dropRow, dropCol and dropIndex reflects the position of the drop.
+    \internal
+  */
+bool QListModeViewBase::dropOn(QDropEvent *event, int *dropRow, int *dropCol, QModelIndex *dropIndex)
+{
+    if (event->isAccepted())
+        return false;
+
+    QModelIndex index;
+    if (dd->viewport->rect().contains(event->pos())) {
+        // can't use indexAt, doesn't account for spacing.
+        QPoint p = event->pos();
+        QRect rect(p.x() + horizontalOffset(), p.y() + verticalOffset(), 1, 1);
+        rect.adjust(-dd->spacing(), -dd->spacing(), dd->spacing(), dd->spacing());
+        const QVector<QModelIndex> intersectVector = dd->intersectingSet(rect);
+        index = intersectVector.count() > 0
+            ? intersectVector.last() : QModelIndex();
+        if (!index.isValid())
+            index = dd->root;
+    }
+
+    // If we are allowed to do the drop
+    if (dd->model->supportedDropActions() & event->dropAction()) {
+        int row = -1;
+        int col = -1;
+        if (index != dd->root) {
+            dd->dropIndicatorPosition = position(event->pos(), qq->visualRect(index), index);
+            switch (dd->dropIndicatorPosition) {
+            case QAbstractItemView::AboveItem:
+                row = index.row();
+                col = index.column();
+                index = index.parent();
+                break;
+            case QAbstractItemView::BelowItem:
+                row = index.row() + 1;
+                col = index.column();
+                index = index.parent();
+                break;
+            case QAbstractItemView::OnItem:
+            case QAbstractItemView::OnViewport:
+                break;
+            }
+        } else {
+            dd->dropIndicatorPosition = QAbstractItemView::OnViewport;
+        }
+        *dropIndex = index;
+        *dropRow = row;
+        *dropCol = col;
+        if (!dd->droppingOnItself(event, index))
+            return true;
+    }
+    return false;
+}
+
 #endif //QT_NO_DRAGANDDROP
 
 void QListModeViewBase::updateVerticalScrollBar(const QSize &step)
@@ -2107,7 +2184,7 @@ int QListModeViewBase::verticalOffset() const
                 int value = verticalScrollBar()->value();
                 if (value >= segmentPositions.count())
                     return 0;
-                return segmentPositions.at(value);
+                return segmentPositions.at(value) - spacing();
             }
         } else if (flow() == QListView::TopToBottom && !flowPositions.isEmpty()) {
             int value = verticalScrollBar()->value();
@@ -2155,14 +2232,14 @@ void QListModeViewBase::scrollContentsBy(int dx, int dy, bool scrollElasticBand)
         if (horizontal && flow() == QListView::TopToBottom && dx != 0) {
             int currentValue = qBound(0, horizontalValue, max);
             int previousValue = qBound(0, currentValue + dx, max);
-            int currentCoordinate = segmentPositions.at(currentValue);
-            int previousCoordinate = segmentPositions.at(previousValue);
+            int currentCoordinate = segmentPositions.at(currentValue) - spacing();
+            int previousCoordinate = segmentPositions.at(previousValue) - spacing();
             dx = previousCoordinate - currentCoordinate;
         } else if (vertical && flow() == QListView::LeftToRight && dy != 0) {
             int currentValue = qBound(0, verticalValue, max);
             int previousValue = qBound(0, currentValue + dy, max);
-            int currentCoordinate = segmentPositions.at(currentValue);
-            int previousCoordinate = segmentPositions.at(previousValue);
+            int currentCoordinate = segmentPositions.at(currentValue) - spacing();
+            int previousCoordinate = segmentPositions.at(previousValue) - spacing();
             dy = previousCoordinate - currentCoordinate;
         }
     } else {
@@ -2330,6 +2407,8 @@ void QListModeViewBase::doStaticLayout(const QListViewLayoutInfo &info)
                 segmentExtents.append(flowPosition);
                 flowPosition = info.spacing + segStartPosition;
                 segPosition += deltaSegPosition;
+                if (info.wrap)
+                    segPosition += info.spacing;
                 segmentPositions.append(segPosition);
                 segmentStartRows.append(row);
                 deltaSegPosition = 0;
diff --git a/src/gui/itemviews/qlistview_p.h b/src/gui/itemviews/qlistview_p.h
index bf7657b..9ae1f50 100644
--- a/src/gui/itemviews/qlistview_p.h
+++ b/src/gui/itemviews/qlistview_p.h
@@ -237,6 +237,7 @@ public:
     // WARNING: Plenty of duplicated code from QAbstractItemView{,Private}.
     QAbstractItemView::DropIndicatorPosition position(const QPoint &pos, const QRect &rect, const QModelIndex &idx) const;
     void dragMoveEvent(QDragMoveEvent *e);
+    bool dropOn(QDropEvent *event, int *row, int *col, QModelIndex *index);
 #endif
 
 private:
@@ -364,6 +365,7 @@ public:
 
 #ifndef QT_NO_DRAGANDDROP
     virtual QAbstractItemView::DropIndicatorPosition position(const QPoint &pos, const QRect &rect, const QModelIndex &idx) const;
+    bool dropOn(QDropEvent *event, int *row, int *col, QModelIndex *index);
 #endif
 
     inline void setGridSize(const QSize &size) { grid = size; }