1 files changed, 45 insertions, 30 deletions

diff --git a/src/widgets/widgets/qmdiarea.cpp b/src/widgets/widgets/qmdiarea.cpp
index 600d9b536f..d0488d5955 100644
--- a/src/widgets/widgets/qmdiarea.cpp
+++ b/src/widgets/widgets/qmdiarea.cpp
@@ -169,7 +169,7 @@
 #include <QResizeEvent>
 #include <QScrollBar>
 #include <QtAlgorithms>
-#include <QMutableListIterator>
+#include <QMutableVectorIterator>
 #include <QPainter>
 #include <QFontMetrics>
 #include <QStyleOption>
@@ -413,7 +413,7 @@ void IconTiler::rearrange(QList<QWidget *> &widgets, const QRect &domain) const
     \internal
     Calculates the accumulated overlap (intersection area) between 'source' and 'rects'.
 */
-int MinOverlapPlacer::accumulatedOverlap(const QRect &source, const QList<QRect> &rects)
+int MinOverlapPlacer::accumulatedOverlap(const QRect &source, const QVector<QRect> &rects)
 {
     int accOverlap = 0;
     foreach (const QRect &rect, rects) {
@@ -429,7 +429,7 @@ int MinOverlapPlacer::accumulatedOverlap(const QRect &source, const QList<QRect>
     Finds among 'source' the rectangle with the minimum accumulated overlap with the
     rectangles in 'rects'.
 */
-QRect MinOverlapPlacer::findMinOverlapRect(const QList<QRect> &source, const QList<QRect> &rects)
+QRect MinOverlapPlacer::findMinOverlapRect(const QVector<QRect> &source, const QVector<QRect> &rects)
 {
     int minAccOverlap = -1;
     QRect minAccOverlapRect;
@@ -447,28 +447,37 @@ QRect MinOverlapPlacer::findMinOverlapRect(const QList<QRect> &source, const QLi
     \internal
     Gets candidates for the final placement.
 */
-void MinOverlapPlacer::getCandidatePlacements(const QSize &size, const QList<QRect> &rects,
-                                              const QRect &domain,QList<QRect> &candidates)
+QVector<QRect> MinOverlapPlacer::getCandidatePlacements(const QSize &size, const QVector<QRect> &rects,
+                                                        const QRect &domain)
 {
-    QSet<int> xset;
-    QSet<int> yset;
-    xset << domain.left() << domain.right() - size.width() + 1;
-    yset << domain.top();
+    QVector<QRect> result;
+
+    QVector<int> xlist;
+    xlist.reserve(2 + rects.size());
+    xlist << domain.left() << domain.right() - size.width() + 1;
+
+    QVector<int> ylist;
+    ylist.reserve(2 + rects.size());
+    ylist << domain.top();
     if (domain.bottom() - size.height() + 1 >= 0)
-        yset << domain.bottom() - size.height() + 1;
+        ylist << domain.bottom() - size.height() + 1;
+
     foreach (const QRect &rect, rects) {
-        xset << rect.right() + 1;
-        yset << rect.bottom() + 1;
+        xlist << rect.right() + 1;
+        ylist << rect.bottom() + 1;
     }
 
-    QList<int> xlist = xset.values();
     std::sort(xlist.begin(), xlist.end());
-    QList<int> ylist = yset.values();
+    xlist.erase(std::unique(xlist.begin(), xlist.end()), xlist.end());
+
     std::sort(ylist.begin(), ylist.end());
+    ylist.erase(std::unique(ylist.begin(), ylist.end()), ylist.end());
 
+    result.reserve(ylist.size() * xlist.size());
     foreach (int y, ylist)
         foreach (int x, xlist)
-            candidates << QRect(QPoint(x, y), size);
+            result << QRect(QPoint(x, y), size);
+    return result;
 }
 
 /*!
@@ -476,10 +485,12 @@ void MinOverlapPlacer::getCandidatePlacements(const QSize &size, const QList<QRe
     Finds all rectangles in 'source' not completely inside 'domain'. The result is stored
     in 'result' and also removed from 'source'.
 */
-void MinOverlapPlacer::findNonInsiders(const QRect &domain, QList<QRect> &source,
-                                       QList<QRect> &result)
+QVector<QRect> MinOverlapPlacer::findNonInsiders(const QRect &domain, QVector<QRect> &source)
 {
-    QMutableListIterator<QRect> it(source);
+    QVector<QRect> result;
+    result.reserve(source.size());
+
+    QMutableVectorIterator<QRect> it(source);
     while (it.hasNext()) {
         const QRect srcRect = it.next();
         if (!domain.contains(srcRect)) {
@@ -487,6 +498,8 @@ void MinOverlapPlacer::findNonInsiders(const QRect &domain, QList<QRect> &source
             it.remove();
         }
     }
+
+    return result;
 }
 
 /*!
@@ -494,9 +507,11 @@ void MinOverlapPlacer::findNonInsiders(const QRect &domain, QList<QRect> &source
     Finds all rectangles in 'source' that overlaps 'domain' by the maximum overlap area
     between 'domain' and any rectangle in 'source'. The result is stored in 'result'.
 */
-void MinOverlapPlacer::findMaxOverlappers(const QRect &domain, const QList<QRect> &source,
-                                          QList<QRect> &result)
+QVector<QRect> MinOverlapPlacer::findMaxOverlappers(const QRect &domain, const QVector<QRect> &source)
 {
+    QVector<QRect> result;
+    result.reserve(source.size());
+
     int maxOverlap = -1;
     foreach (const QRect &srcRect, source) {
         QRect intersection = domain.intersected(srcRect);
@@ -509,6 +524,8 @@ void MinOverlapPlacer::findMaxOverlappers(const QRect &domain, const QList<QRect
             result << srcRect;
         }
     }
+
+    return result;
 }
 
 /*!
@@ -517,17 +534,15 @@ void MinOverlapPlacer::findMaxOverlappers(const QRect &domain, const QList<QRect
     placement that overlaps the rectangles in 'rects' as little as possible while at the
     same time being as much as possible inside 'domain'.
 */
-QPoint MinOverlapPlacer::findBestPlacement(const QRect &domain, const QList<QRect> &rects,
-                                           QList<QRect> &source)
+QPoint MinOverlapPlacer::findBestPlacement(const QRect &domain, const QVector<QRect> &rects,
+                                           QVector<QRect> &source)
 {
-    QList<QRect> nonInsiders;
-    findNonInsiders(domain, source, nonInsiders);
+    const QVector<QRect> nonInsiders = findNonInsiders(domain, source);
 
     if (!source.empty())
         return findMinOverlapRect(source, rects).topLeft();
 
-    QList<QRect> maxOverlappers;
-    findMaxOverlappers(domain, nonInsiders, maxOverlappers);
+    QVector<QRect> maxOverlappers = findMaxOverlappers(domain, nonInsiders);
     return findMinOverlapRect(maxOverlappers, rects).topLeft();
 }
 
@@ -538,7 +553,7 @@ QPoint MinOverlapPlacer::findBestPlacement(const QRect &domain, const QList<QRec
     overlaps 'rects' as little as possible and 'domain' as much as possible.
     Returns the position of the resulting rectangle.
 */
-QPoint MinOverlapPlacer::place(const QSize &size, const QList<QRect> &rects,
+QPoint MinOverlapPlacer::place(const QSize &size, const QVector<QRect> &rects,
                                const QRect &domain) const
 {
     if (size.isEmpty() || !domain.isValid())
@@ -548,8 +563,7 @@ QPoint MinOverlapPlacer::place(const QSize &size, const QList<QRect> &rects,
             return QPoint();
     }
 
-    QList<QRect> candidates;
-    getCandidatePlacements(size, rects, domain, candidates);
+    QVector<QRect> candidates = getCandidatePlacements(size, rects, domain);
     return findBestPlacement(domain, rects, candidates);
 }
 
@@ -882,7 +896,8 @@ void QMdiAreaPrivate::place(Placer *placer, QMdiSubWindow *child)
         return;
     }
 
-    QList<QRect> rects;
+    QVector<QRect> rects;
+    rects.reserve(childWindows.size());
     QRect parentRect = q->rect();
     foreach (QMdiSubWindow *window, childWindows) {
         if (!sanityCheck(window, "QMdiArea::place") || window == child || !window->isVisibleTo(q)