From: Peter Penz Date: Sun, 1 Jun 2008 22:15:13 +0000 (+0000) Subject: Improve the performance when creating previews for thousands of items by the followin... X-Git-Url: https://cloud.milkyroute.net/gitweb/dolphin.git/commitdiff_plain/32298bba66fe57a6a42a1b92ae9aec002a637483 Improve the performance when creating previews for thousands of items by the following strategy: - 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 a8ccc9ed1..d2169cb9e 100644 --- a/src/iconmanager.cpp +++ b/src/iconmanager.cpp @@ -32,18 +32,23 @@ #include #include #include +#include #include IconManager::IconManager(QAbstractItemView* parent, DolphinSortFilterProxyModel* model) : QObject(parent), m_showPreview(false), + m_clearItemQueues(true), m_view(parent), m_previewTimer(0), + m_scrollAreaTimer(0), 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 @@ -56,12 +61,29 @@ IconManager::IconManager(QAbstractItemView* parent, DolphinSortFilterProxyModel* this, SLOT(updateCutItems())); m_previewTimer = new QTimer(this); + m_previewTimer->setSingleShot(true); 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() { - killJobs(); + killPreviewJobs(); + m_pendingItems.clear(); + m_dispatchedItems.clear(); } @@ -83,8 +105,10 @@ void IconManager::updatePreviews() return; } - killJobs(); + killPreviewJobs(); m_cutItemsCache.clear(); + m_pendingItems.clear(); + m_dispatchedItems.clear(); KFileItemList itemList; const int rowCount = m_dolphinModel->rowCount(); @@ -106,31 +130,24 @@ void IconManager::generatePreviews(const KFileItemList& items) 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. + const QRect visibleArea = m_view->viewport()->rect(); 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); + m_pendingItems.insert(0, item.url()); } 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) @@ -139,12 +156,19 @@ void IconManager::addToPreviewQueue(const KFileItem& item, const QPixmap& pixmap 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); + + if ((m_previewJobs.count() == 0) && m_clearItemQueues) { + m_pendingItems.clear(); + m_dispatchedItems.clear(); + } } 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::iterator begin = m_pendingItems.begin(); + QList::iterator end = m_pendingItems.end(); + for (QList::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()); @@ -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); diff --git a/src/iconmanager.h b/src/iconmanager.h index f72811c27..e9d7c9b78 100644 --- 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. + * + * 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 { @@ -73,11 +82,25 @@ private slots: void updateCutItems(); /** - * Dispatches the preview queue m_previews block by block within + * Dispatches the preview queue block by block within * 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 @@ -107,13 +130,17 @@ private: */ 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. */ - void killJobs(); + void killPreviewJobs(); 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; @@ -122,14 +149,33 @@ private: 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; + QTimer* m_scrollAreaTimer; QList m_previewJobs; DolphinModel* m_dolphinModel; DolphinSortFilterProxyModel* m_proxyModel; QList m_cutItemsCache; QList 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 m_pendingItems; + + /** + * Containts the URLs of all items, where a preview has already been + * generated by the preview jobs. + */ + QList m_dispatchedItems; }; inline bool IconManager::showPreview() const