Improve the performance when creating previews for thousands of items by the followin...

 - The previews for currently visible items are created before
   the previews for invisible items.
 - If the user changes the visible area by using the scrollbars,
   all pending previews get paused. As soon as the user stays
   on the same position for a short delay, the previews are
   resumed. Also in this case the previews for the visible items
   are generated first.

svn path=/trunk/KDE/kdebase/apps/; revision=815480

diff --git a/src/iconmanager.cpp b/src/iconmanager.cpp
index a8ccc9ed1d090ac9b018162117a96dbce2e95955..d2169cb9e42b197fb61de432a007213451153161 100644 (file)
--- a/src/iconmanager.cpp
+++ b/src/iconmanager.cpp
@@ -32,18 +32,23 @@
 #include <QClipboard>
 #include <QColor>
 #include <QPainter>
 #include <QClipboard>
 #include <QColor>
 #include <QPainter>

+#include <QScrollBar>

 #include <QIcon>
 
 IconManager::IconManager(QAbstractItemView* parent, DolphinSortFilterProxyModel* model) :
     QObject(parent),
     m_showPreview(false),
 #include <QIcon>
 
 IconManager::IconManager(QAbstractItemView* parent, DolphinSortFilterProxyModel* model) :
     QObject(parent),
     m_showPreview(false),

+    m_clearItemQueues(true),

     m_view(parent),
     m_previewTimer(0),
     m_view(parent),
     m_previewTimer(0),

+    m_scrollAreaTimer(0),

     m_previewJobs(),
     m_dolphinModel(0),
     m_proxyModel(model),
     m_cutItemsCache(),
     m_previewJobs(),
     m_dolphinModel(0),
     m_proxyModel(model),
     m_cutItemsCache(),

-    m_previews()
+    m_previews(),
+    m_pendingItems(),
+    m_dispatchedItems()

 {
     Q_ASSERT(m_view->iconSize().isValid());  // each view must provide its current icon size
 
 {
     Q_ASSERT(m_view->iconSize().isValid());  // each view must provide its current icon size
 


@@ -56,12 +61,29 @@ IconManager::IconManager(QAbstractItemView* parent, DolphinSortFilterProxyModel*
             this, SLOT(updateCutItems()));
 
     m_previewTimer = new QTimer(this);
             this, SLOT(updateCutItems()));
 
     m_previewTimer = new QTimer(this);

+    m_previewTimer->setSingleShot(true);

     connect(m_previewTimer, SIGNAL(timeout()), this, SLOT(dispatchPreviewQueue()));
     connect(m_previewTimer, SIGNAL(timeout()), this, SLOT(dispatchPreviewQueue()));

+
+    // Whenever the scrollbar values have been changed, the pending previews should
+    // be reordered in a way that the previews for the visible items are generated
+    // first. The reordering is done with a small delay, so that during moving the
+    // scrollbars the CPU load is kept low.
+    m_scrollAreaTimer = new QTimer(this);
+    m_scrollAreaTimer->setSingleShot(true);
+    m_scrollAreaTimer->setInterval(200);
+    connect(m_scrollAreaTimer, SIGNAL(timeout()),
+            this, SLOT(resumePreviews()));
+    connect(m_view->horizontalScrollBar(), SIGNAL(valueChanged(int)),
+            this, SLOT(pausePreviews()));
+    connect(m_view->verticalScrollBar(), SIGNAL(valueChanged(int)),
+            this, SLOT(pausePreviews()));

 }
 
 IconManager::~IconManager()
 {
 }
 
 IconManager::~IconManager()
 {

-    killJobs();
+    killPreviewJobs();
+    m_pendingItems.clear();
+    m_dispatchedItems.clear();

 }
 
 
 }
 
 


@@ -83,8 +105,10 @@ void IconManager::updatePreviews()
         return;
     }
 
         return;
     }
 

-    killJobs();
+    killPreviewJobs();

     m_cutItemsCache.clear();
     m_cutItemsCache.clear();

+    m_pendingItems.clear();
+    m_dispatchedItems.clear();

 
     KFileItemList itemList;
     const int rowCount = m_dolphinModel->rowCount();
 
     KFileItemList itemList;
     const int rowCount = m_dolphinModel->rowCount();


@@ -106,31 +130,24 @@ void IconManager::generatePreviews(const KFileItemList& items)
         return;
     }
 
         return;
     }
 

-    const QRect visibleArea = m_view->viewport()->rect();
-

     // Order the items in a way that the preview for the visible items
     // is generated first, as this improves the feeled performance a lot.
     // Order the items in a way that the preview for the visible items
     // is generated first, as this improves the feeled performance a lot.

+    const QRect visibleArea = m_view->viewport()->rect();

     KFileItemList orderedItems;
     KFileItemList orderedItems;

-    foreach (const KFileItem &item, items) {
+    foreach (const KFileItem& item, items) {

         const QModelIndex dirIndex = m_dolphinModel->indexForItem(item);
         const QModelIndex proxyIndex = m_proxyModel->mapFromSource(dirIndex);
         const QRect itemRect = m_view->visualRect(proxyIndex);
         if (itemRect.intersects(visibleArea)) {
             orderedItems.insert(0, item);
         const QModelIndex dirIndex = m_dolphinModel->indexForItem(item);
         const QModelIndex proxyIndex = m_proxyModel->mapFromSource(dirIndex);
         const QRect itemRect = m_view->visualRect(proxyIndex);
         if (itemRect.intersects(visibleArea)) {
             orderedItems.insert(0, item);

+            m_pendingItems.insert(0, item.url());

         } else {
             orderedItems.append(item);
         } else {
             orderedItems.append(item);

+            m_pendingItems.append(item.url());

         }
     }
 
         }
     }
 

-    const QSize size = m_view->iconSize();
-    KIO::PreviewJob* job = KIO::filePreview(orderedItems, 128, 128);
-    connect(job, SIGNAL(gotPreview(const KFileItem&, const QPixmap&)),
-            this, SLOT(addToPreviewQueue(const KFileItem&, const QPixmap&)));
-    connect(job, SIGNAL(finished(KJob*)),
-            this, SLOT(slotPreviewJobFinished(KJob*)));
-
-    m_previewJobs.append(job);
-    m_previewTimer->start(200);
+    startPreviewJob(orderedItems);

 }
 
 void IconManager::addToPreviewQueue(const KFileItem& item, const QPixmap& pixmap)
 }
 
 void IconManager::addToPreviewQueue(const KFileItem& item, const QPixmap& pixmap)


@@ -139,12 +156,19 @@ void IconManager::addToPreviewQueue(const KFileItem& item, const QPixmap& pixmap
     preview.url = item.url();
     preview.pixmap = pixmap;
     m_previews.append(preview);
     preview.url = item.url();
     preview.pixmap = pixmap;
     m_previews.append(preview);

+
+    m_dispatchedItems.append(item.url());

 }
 
 void IconManager::slotPreviewJobFinished(KJob* job)
 {
     const int index = m_previewJobs.indexOf(job);
     m_previewJobs.removeAt(index);
 }
 
 void IconManager::slotPreviewJobFinished(KJob* job)
 {
     const int index = m_previewJobs.indexOf(job);
     m_previewJobs.removeAt(index);

+
+    if ((m_previewJobs.count() == 0) && m_clearItemQueues) {
+        m_pendingItems.clear();
+        m_dispatchedItems.clear();
+    }

 }
 
 void IconManager::updateCutItems()
 }
 
 void IconManager::updateCutItems()


@@ -197,6 +221,63 @@ void IconManager::dispatchPreviewQueue()
     }
 }
 
     }
 }
 

+void IconManager::pausePreviews()
+{
+    foreach (KJob* job, m_previewJobs) {
+        Q_ASSERT(job != 0);
+        job->suspend();
+    }
+    m_scrollAreaTimer->start();
+}
+
+void IconManager::resumePreviews()
+{
+    // Before creating new preview jobs the m_pendingItems queue must be
+    // cleaned up by removing the already dispatched items. Implementation
+    // note: The order of the m_dispatchedItems queue and the m_pendingItems
+    // queue is usually equal. So even when having a lot of elements the
+    // nested loop is no performance bottle neck, as the inner loop is only
+    // entered once in most cases.
+    foreach (const KUrl& url, m_dispatchedItems) {
+        QList<KUrl>::iterator begin = m_pendingItems.begin();
+        QList<KUrl>::iterator end   = m_pendingItems.end();
+        for (QList<KUrl>::iterator it = begin; it != end; ++it) {
+            if ((*it) == url) {
+                m_pendingItems.erase(it);
+                break;
+            }
+        }
+    }
+    m_dispatchedItems.clear();
+
+    // Create a new preview job for the remaining items.
+    // Order the items in a way that the preview for the visible items
+    // is generated first, as this improves the feeled performance a lot.
+    const QRect visibleArea = m_view->viewport()->rect();
+    KFileItemList orderedItems;
+    foreach (const KUrl& url, m_pendingItems) {
+        const QModelIndex dirIndex = m_dolphinModel->indexForUrl(url);
+        const KFileItem item = m_dolphinModel->itemForIndex(dirIndex);
+        const QModelIndex proxyIndex = m_proxyModel->mapFromSource(dirIndex);
+        const QRect itemRect = m_view->visualRect(proxyIndex);
+        if (itemRect.intersects(visibleArea)) {
+            orderedItems.insert(0, item);
+        } else {
+            orderedItems.append(item);
+        }
+    }
+
+    // Kill all suspended preview jobs. Usually when a preview job
+    // has been finished, slotPreviewJobFinished() clears all item queues.
+    // This is not wanted in this case, as a new job is created afterwards
+    // for m_pendingItems.
+    m_clearItemQueues = false;
+    killPreviewJobs();
+    m_clearItemQueues = true;
+
+    startPreviewJob(orderedItems);
+}
+

 void IconManager::replaceIcon(const KUrl& url, const QPixmap& pixmap)
 {
     Q_ASSERT(url.isValid());
 void IconManager::replaceIcon(const KUrl& url, const QPixmap& pixmap)
 {
     Q_ASSERT(url.isValid());


@@ -374,7 +455,24 @@ void IconManager::limitToSize(QPixmap& icon, const QSize& maxSize)
     }
 }
 
     }
 }
 

-void IconManager::killJobs()
+void IconManager::startPreviewJob(const KFileItemList& items)
+{
+    if (items.count() == 0) {
+        return;
+    }
+
+    const QSize size = m_view->iconSize();
+    KIO::PreviewJob* job = KIO::filePreview(items, 128, 128);
+    connect(job, SIGNAL(gotPreview(const KFileItem&, const QPixmap&)),
+            this, SLOT(addToPreviewQueue(const KFileItem&, const QPixmap&)));
+    connect(job, SIGNAL(finished(KJob*)),
+            this, SLOT(slotPreviewJobFinished(KJob*)));
+
+    m_previewJobs.append(job);
+    m_previewTimer->start(200);
+}
+
+void IconManager::killPreviewJobs()

 {
     foreach (KJob* job, m_previewJobs) {
         Q_ASSERT(job != 0);
 {
     foreach (KJob* job, m_previewJobs) {
         Q_ASSERT(job != 0);

diff --git a/src/iconmanager.h b/src/iconmanager.h
index f72811c2722fd257502f875cfec5d37bee255624..e9d7c9b780414f2c6660c465a8cf2fc74551bac5 100644 (file)
--- a/src/iconmanager.h
+++ b/src/iconmanager.h
@@ -38,6 +38,15 @@ class QAbstractItemView;
  * Per default a preview is generated for each item.
  * Additionally the clipboard is checked for cut items.
  * The icon state for cut items gets dimmed automatically.
  * Per default a preview is generated for each item.
  * Additionally the clipboard is checked for cut items.
  * The icon state for cut items gets dimmed automatically.

+ *
+ * The following strategy is used when creating previews:
+ * - The previews for currently visible items are created before
+ *   the previews for invisible items.
+ * - If the user changes the visible area by using the scrollbars,
+ *   all pending previews get paused. As soon as the user stays
+ *   on the same position for a short delay, the previews are
+ *   resumed. Also in this case the previews for the visible items
+ *   are generated first.

  */
 class IconManager : public QObject
 {
  */
 class IconManager : public QObject
 {


@@ -73,11 +82,25 @@ private slots:
     void updateCutItems();
 
     /**
     void updateCutItems();
 
     /**

-     * Dispatches the preview queue m_previews block by block within
+     * Dispatches the preview queue  block by block within

      * time slices.
      */
     void dispatchPreviewQueue();
 
      * time slices.
      */
     void dispatchPreviewQueue();
 

+    /**
+     * Pauses all preview jobs and invokes IconManager::resumePreviews()
+     * after a short delay. Is invoked as soon as the user has moved
+     * a scrollbar.
+     */
+    void pausePreviews();
+
+    /**
+     * Resumes the previews that have been paused after moving the
+     * scrollbar. The previews for the current visible area are
+     * generated first.
+     */
+    void resumePreviews();
+

 private:
     /**
      * Replaces the icon of the item with the \a url by the preview pixmap
 private:
     /**
      * Replaces the icon of the item with the \a url by the preview pixmap


@@ -107,13 +130,17 @@ private:
      */
     void limitToSize(QPixmap& icon, const QSize& maxSize);
 
      */
     void limitToSize(QPixmap& icon, const QSize& maxSize);
 

+    /**
+     * Starts a new preview job for the items \a to m_previewJobs
+     * and triggers the preview timer.
+     */
+    void startPreviewJob(const KFileItemList& items);
+

     /** Kills all ongoing preview jobs. */
     /** Kills all ongoing preview jobs. */

-    void killJobs();
+    void killPreviewJobs();

 
 private:
 
 private:

-    /**
-     * Remembers the pixmap for an item specified by an URL.
-     */
+    /** Remembers the pixmap for an item specified by an URL. */

     struct ItemInfo
     {
         KUrl url;
     struct ItemInfo
     {
         KUrl url;


@@ -122,14 +149,33 @@ private:
 
     bool m_showPreview;
 
 
     bool m_showPreview;
 

+    /**
+     * True, if m_pendingItems and m_dispatchedItems should be
+     * cleared when the preview jobs have been finished.
+     */
+    bool m_clearItemQueues;
+

     QAbstractItemView* m_view;
     QTimer* m_previewTimer;
     QAbstractItemView* m_view;
     QTimer* m_previewTimer;

+    QTimer* m_scrollAreaTimer;

     QList<KJob*> m_previewJobs;
     DolphinModel* m_dolphinModel;
     DolphinSortFilterProxyModel* m_proxyModel;
 
     QList<ItemInfo> m_cutItemsCache;
     QList<ItemInfo> m_previews;
     QList<KJob*> m_previewJobs;
     DolphinModel* m_dolphinModel;
     DolphinSortFilterProxyModel* m_proxyModel;
 
     QList<ItemInfo> m_cutItemsCache;
     QList<ItemInfo> m_previews;

+
+    /**
+     * Contains the URLs of all items where a preview must be generated, but
+     * where the preview job has not dispatched the items yet.
+     */
+    QList<KUrl> m_pendingItems;
+
+    /**
+     * Containts the URLs of all items, where a preview has already been
+     * generated by the preview jobs.
+     */
+    QList<KUrl> m_dispatchedItems;

 };
 
 inline bool IconManager::showPreview() const
 };
 
 inline bool IconManager::showPreview() const