Make sure that all visible items have an icon

We try to determine "final" icons, i.e., icons with known mime type,
for 200 ms. If this does not succeed, we at least load "fast" icons,
i.e., load the icons without determining the mime type.

REVIEW: 111009

diff --git a/src/kitemviews/kfileitemmodelrolesupdater.cpp b/src/kitemviews/kfileitemmodelrolesupdater.cpp
index 1867390759c23471714083a68da84adc62263ebe..28024fd6802316f097521e2fe8fe2b902000aa63 100644 (file)
--- a/src/kitemviews/kfileitemmodelrolesupdater.cpp
+++ b/src/kitemviews/kfileitemmodelrolesupdater.cpp
@@ -88,7 +88,6 @@ KFileItemModelRolesUpdater::KFileItemModelRolesUpdater(KFileItemModel* model, QO
     m_resolvableRoles(),
     m_enabledPlugins(),
     m_pendingSortRoleItems(),
     m_resolvableRoles(),
     m_enabledPlugins(),
     m_pendingSortRoleItems(),

-    m_pendingSortRoleIndexes(),

     m_pendingIndexes(),
     m_pendingPreviewItems(),
     m_previewJob(),
     m_pendingIndexes(),
     m_pendingPreviewItems(),
     m_previewJob(),


@@ -261,8 +260,9 @@ void KFileItemModelRolesUpdater::setPaused(bool paused)
             resolveNextSortRole();
         } else {
             m_state = Idle;
             resolveNextSortRole();
         } else {
             m_state = Idle;

-            startUpdating();

         }
         }

+
+        startUpdating();

     }
 }
 
     }
 }
 


@@ -345,16 +345,13 @@ void KFileItemModelRolesUpdater::slotItemsInserted(const KItemRangeList& itemRan
 
         applySortProgressToModel();
 
 
         applySortProgressToModel();
 

-        // If there are still items whose sort role is unknown, return
-        // and handle them asynchronously.
-        if (!m_pendingSortRoleItems.isEmpty()) {
-            if (m_state != ResolvingSortRole) {
-                // Trigger the asynchronous determination of the sort role.
-                killPreviewJob();
-                m_state = ResolvingSortRole;
-                resolveNextSortRole();
-            }
-            return;
+        // If there are still items whose sort role is unknown, check if the
+        // asynchronous determination of the sort role is already in progress,
+        // and start it if that is not the case.
+        if (!m_pendingSortRoleItems.isEmpty() && m_state != ResolvingSortRole) {
+            killPreviewJob();
+            m_state = ResolvingSortRole;
+            resolveNextSortRole();

         }
     }
 
         }
     }
 


@@ -419,7 +416,6 @@ void KFileItemModelRolesUpdater::slotItemsRemoved(const KItemRangeList& itemRang
 
         m_finishedItems.clear();
         m_pendingSortRoleItems.clear();
 
         m_finishedItems.clear();
         m_pendingSortRoleItems.clear();

-        m_pendingSortRoleIndexes.clear();

         m_pendingIndexes.clear();
         m_pendingPreviewItems.clear();
         m_recentlyChangedItems.clear();
         m_pendingIndexes.clear();
         m_pendingPreviewItems.clear();
         m_recentlyChangedItems.clear();


@@ -449,9 +445,6 @@ void KFileItemModelRolesUpdater::slotItemsMoved(const KItemRange& itemRange, QLi
     Q_UNUSED(itemRange);
     Q_UNUSED(movedToIndexes);
 
     Q_UNUSED(itemRange);
     Q_UNUSED(movedToIndexes);
 

-    // The indexes of the items with missing sort role are not valid any more.
-    m_pendingSortRoleIndexes.clear();
-

     // The visible items might have changed.
     startUpdating();
 }
     // The visible items might have changed.
     startUpdating();
 }


@@ -492,7 +485,6 @@ void KFileItemModelRolesUpdater::slotSortRoleChanged(const QByteArray& current,
 
     if (m_resolvableRoles.contains(current)) {
         m_pendingSortRoleItems.clear();
 
     if (m_resolvableRoles.contains(current)) {
         m_pendingSortRoleItems.clear();

-        m_pendingSortRoleIndexes.clear();

         m_finishedItems.clear();
 
         const int count = m_model->count();
         m_finishedItems.clear();
 
         const int count = m_model->count();


@@ -519,7 +511,6 @@ void KFileItemModelRolesUpdater::slotSortRoleChanged(const QByteArray& current,
     } else {
         m_state = Idle;
         m_pendingSortRoleItems.clear();
     } else {
         m_state = Idle;
         m_pendingSortRoleItems.clear();

-        m_pendingSortRoleIndexes.clear();

         applySortProgressToModel();
     }
 }
         applySortProgressToModel();
     }
 }


@@ -636,55 +627,20 @@ void KFileItemModelRolesUpdater::resolveNextSortRole()
         return;
     }
 
         return;
     }
 

-    if (m_pendingSortRoleItems.count() != m_pendingSortRoleIndexes.count()) {
-        // The indexes with missing sort role have to be updated.
-        m_pendingSortRoleIndexes.clear();
-        foreach (const KFileItem& item, m_pendingSortRoleItems) {
-            const int index = m_model->index(item);
-            if (index < 0) {
-                m_pendingSortRoleItems.remove(item);
-            } else {
-                m_pendingSortRoleIndexes.append(index);
-            }
-        }
-
-        std::sort(m_pendingSortRoleIndexes.begin(), m_pendingSortRoleIndexes.end());
-    }
-
-    // Try to update an item in the visible range.
-    QList<int>::iterator it = std::lower_bound(m_pendingSortRoleIndexes.begin(),
-                                                m_pendingSortRoleIndexes.end(),
-                                                m_firstVisibleIndex);
-
-    // It seems that there is no such item. Start with the first item in the list.
-    if (it == m_pendingSortRoleIndexes.end()) {
-        it = m_pendingSortRoleIndexes.begin();
-    }
-
-    while (it != m_pendingSortRoleIndexes.end()) {
-        // TODO: Note that removing an index from the list m_pendingSortRoleIndexes
-        // at a random position is O(N). We might need a better solution
-        // to make sure that this does not harm the performance if
-        // many items have to be sorted.
-        const int index = *it;
-        const KFileItem item = m_model->fileItem(index);
+    QSet<KFileItem>::iterator it = m_pendingSortRoleItems.begin();
+    while (it != m_pendingSortRoleItems.end()) {
+        const KFileItem item = *it;
+        const int index = m_model->index(item);

 
         // Continue if the sort role has already been determined for the
         // item, and the item has not been changed recently.
         if (!m_changedItems.contains(item) && m_model->data(index).contains(m_model->sortRole())) {
 
         // Continue if the sort role has already been determined for the
         // item, and the item has not been changed recently.
         if (!m_changedItems.contains(item) && m_model->data(index).contains(m_model->sortRole())) {

-            m_pendingSortRoleItems.remove(item);
-            m_pendingSortRoleIndexes.erase(it);
-
-            // Check if we are at the end of the list (note that the list's end has changed).
-            if (it != m_pendingSortRoleIndexes.end()) {
-                ++it;
-            }
+            it = m_pendingSortRoleItems.erase(it);

             continue;
         }
 
         applySortRole(index);
             continue;
         }
 
         applySortRole(index);

-        m_pendingSortRoleItems.remove(item);
-        m_pendingSortRoleIndexes.erase(it);
+        m_pendingSortRoleItems.erase(it);

         break;
     }
 
         break;
     }
 


@@ -836,9 +792,7 @@ void KFileItemModelRolesUpdater::slotDirWatchDirty(const QString& path)
 
 void KFileItemModelRolesUpdater::startUpdating()
 {
 
 void KFileItemModelRolesUpdater::startUpdating()
 {

-    // Updating the items in and near the visible area makes sense only
-    // if sorting is finished.
-    if (m_state == ResolvingSortRole || m_state == Paused) {
+    if (m_state == Paused) {

         return;
     }
 
         return;
     }
 


@@ -848,16 +802,6 @@ void KFileItemModelRolesUpdater::startUpdating()
         return;
     }
 
         return;
     }
 

-    int lastVisibleIndex = m_lastVisibleIndex;
-    if (lastVisibleIndex <= 0) {
-        // Guess a reasonable value for the last visible index if the view
-        // has not told us about the real value yet.
-        lastVisibleIndex = qMin(m_firstVisibleIndex + m_maximumVisibleItems, m_model->count() - 1);
-        if (lastVisibleIndex <= 0) {
-            lastVisibleIndex = qMin(200, m_model->count() - 1);
-        }
-    }
-

     // Terminate all updates that are currently active.
     killPreviewJob();
     m_pendingIndexes.clear();
     // Terminate all updates that are currently active.
     killPreviewJob();
     m_pendingIndexes.clear();


@@ -866,12 +810,13 @@ void KFileItemModelRolesUpdater::startUpdating()
     timer.start();
 
     // Determine the icons for the visible items synchronously.
     timer.start();
 
     // Determine the icons for the visible items synchronously.

-    int index;
-    for (index = m_firstVisibleIndex; index <= lastVisibleIndex && timer.elapsed() < MaxBlockTimeout; ++index) {
-        const KFileItem item = m_model->fileItem(index);
-        applyResolvedRoles(item, ResolveFast);
+    updateVisibleIcons();
+
+    // A detailed update of the items in and near the visible area
+    // only makes sense if sorting is finished.
+    if (m_state == ResolvingSortRole) {
+        return;

     }
     }

-    const int firstIndexWithoutIcon = index;

 
     // Start the preview job or the asynchronous resolving of all roles.
     QList<int> indexes = indexesToResolve();
 
     // Start the preview job or the asynchronous resolving of all roles.
     QList<int> indexes = indexesToResolve();


@@ -896,6 +841,51 @@ void KFileItemModelRolesUpdater::startUpdating()
     }
 }
 
     }
 }
 

+void KFileItemModelRolesUpdater::updateVisibleIcons()
+{
+    int lastVisibleIndex = m_lastVisibleIndex;
+    if (lastVisibleIndex <= 0) {
+        // Guess a reasonable value for the last visible index if the view
+        // has not told us about the real value yet.
+        lastVisibleIndex = qMin(m_firstVisibleIndex + m_maximumVisibleItems, m_model->count() - 1);
+        if (lastVisibleIndex <= 0) {
+            lastVisibleIndex = qMin(200, m_model->count() - 1);
+        }
+    }
+
+    QElapsedTimer timer;
+    timer.start();
+
+    // Try to determine the final icons for all visible items.
+    int index;
+    for (index = m_firstVisibleIndex; index <= lastVisibleIndex && timer.elapsed() < MaxBlockTimeout; ++index) {
+        const KFileItem item = m_model->fileItem(index);
+        applyResolvedRoles(item, ResolveFast);
+    }
+
+    if (index > lastVisibleIndex) {
+        return;
+    }
+
+    // If this didn't work before MaxBlockTimeout was reached, at least
+    // prevent that the user sees 'unknown' icons.
+    disconnect(m_model, SIGNAL(itemsChanged(KItemRangeList,QSet<QByteArray>)),
+               this,    SLOT(slotItemsChanged(KItemRangeList,QSet<QByteArray>)));
+
+    while (index <= lastVisibleIndex) {
+        if (!m_model->data(index).contains("iconName")) {
+            const KFileItem item = m_model->fileItem(index);
+            QHash<QByteArray, QVariant> data;
+            data.insert("iconName", item.iconName());
+            m_model->setData(index, data);
+        }
+        ++index;
+    }
+
+    connect(m_model, SIGNAL(itemsChanged(KItemRangeList,QSet<QByteArray>)),
+            this,    SLOT(slotItemsChanged(KItemRangeList,QSet<QByteArray>)));
+}
+

 void KFileItemModelRolesUpdater::startPreviewJob()
 {
     m_state = PreviewJobRunning;
 void KFileItemModelRolesUpdater::startPreviewJob()
 {
     m_state = PreviewJobRunning;


@@ -1032,11 +1022,6 @@ void KFileItemModelRolesUpdater::applySortRole(int index)
     QHash<QByteArray, QVariant> data;
     const KFileItem item = m_model->fileItem(index);
 
     QHash<QByteArray, QVariant> data;
     const KFileItem item = m_model->fileItem(index);
 

-    if (index >= m_firstVisibleIndex && index <= m_lastVisibleIndex) {
-        // Determine the icon.
-        applyResolvedRoles(item, ResolveFast);
-    }
-

     if (m_model->sortRole() == "type") {
         if (!item.isMimeTypeKnown()) {
             item.determineMimeType();
     if (m_model->sortRole() == "type") {
         if (!item.isMimeTypeKnown()) {
             item.determineMimeType();

diff --git a/src/kitemviews/kfileitemmodelrolesupdater.h b/src/kitemviews/kfileitemmodelrolesupdater.h
index 2a5a4041c25cd0a909c8aec41f05fa4a2bde2558..605c36f81af3943d5a7ffb22c739c5c03063e910 100644 (file)
--- a/src/kitemviews/kfileitemmodelrolesupdater.h
+++ b/src/kitemviews/kfileitemmodelrolesupdater.h
@@ -223,6 +223,15 @@ private:
      */
     void startUpdating();
 
      */
     void startUpdating();
 

+    /**
+     * Loads the icons for the visible items. After 200 ms, the function
+     * stops determining mime types and only loads preliminary icons.
+     * This is a compromise that prevents that
+     * (a) the GUI is blocked for more than 200 ms, and
+     * (b) "unknown" icons could be shown in the view.
+     */
+    void updateVisibleIcons();
+

     /**
      * Creates previews for the items starting from the first item in
      * m_pendingPreviewItems.
     /**
      * Creates previews for the items starting from the first item in
      * m_pendingPreviewItems.


@@ -311,11 +320,6 @@ private:
     // Items for which the sort role still has to be determined.
     QSet<KFileItem> m_pendingSortRoleItems;
 
     // Items for which the sort role still has to be determined.
     QSet<KFileItem> m_pendingSortRoleItems;
 

-    // While the sort role is being resolved, we also keep the indexes
-    // in a sorted list. The reason is that this enables us to determine
-    // both the sort role and the icon for the visible items first.
-    QList<int> m_pendingSortRoleIndexes;
-

     // Indexes of items which still have to be handled by
     // resolveNextPendingRoles().
     QList<int> m_pendingIndexes;
     // Indexes of items which still have to be handled by
     // resolveNextPendingRoles().
     QList<int> m_pendingIndexes;