src/kitemviews/kfileitemmodelrolesupdater.h

   1 /***************************************************************************
   2  *   Copyright (C) 2011 by Peter Penz <peter.penz19@gmail.com>             *
   3  *                                                                         *
   4  *   This program is free software; you can redistribute it and/or modify  *
   5  *   it under the terms of the GNU General Public License as published by  *
   6  *   the Free Software Foundation; either version 2 of the License, or     *
   7  *   (at your option) any later version.                                   *
   8  *                                                                         *
   9  *   This program is distributed in the hope that it will be useful,       *
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  12  *   GNU General Public License for more details.                          *
  13  *                                                                         *
  14  *   You should have received a copy of the GNU General Public License     *
  15  *   along with this program; if not, write to the                         *
  16  *   Free Software Foundation, Inc.,                                       *
  17  *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA            *
  18  ***************************************************************************/
  19
  20 #ifndef KFILEITEMMODELROLESUPDATER_H
  21 #define KFILEITEMMODELROLESUPDATER_H
  22
  23 #include "dolphin_export.h"
  24 #include "kitemviews/kitemmodelbase.h"
  25
  26 #include <KFileItem>
  27 #include <config-baloo.h>
  28
  29 #include <QObject>
  30 #include <QSet>
  31 #include <QSize>
  32 #include <QStringList>
  33
  34 class KDirectoryContentsCounter;
  35 class KFileItemModel;
  36 class QPixmap;
  37 class QTimer;
  38 class KOverlayIconPlugin;
  39
  40 namespace KIO {
  41     class PreviewJob;
  42 }
  43
  44 #ifdef HAVE_BALOO
  45     namespace Baloo
  46     {
  47         class FileMonitor;
  48     }
  49     #include <Baloo/IndexerConfig>
  50 #endif
  51
  52 /**
  53  * @brief Resolves expensive roles asynchronously and applies them to the KFileItemModel.
  54  *
  55  * KFileItemModel only resolves roles that are inexpensive like e.g. the file name or
  56  * the permissions. Creating previews or determining the MIME-type can be quite expensive
  57  * and KFileItemModelRolesUpdater takes care to update such roles asynchronously.
  58  *
  59  * To prevent a huge CPU and I/O load, these roles are not updated for all
  60  * items, but only for the visible items, some items around the visible area,
  61  * and the items on the first and last pages of the view. This is a compromise
  62  * that aims to minimize the risk that the user sees items with unknown icons
  63  * in the view when scrolling or pressing Home or End.
  64  *
  65  * Determining the roles is done in several phases:
  66  *
  67  * 1.   If the sort role is "slow", it is determined for all items. If this
  68  *      cannot be finished synchronously in 200 ms, the remaining items are
  69  *      handled asynchronously by \a resolveNextSortRole().
  70  *
  71  * 2.   The function startUpdating(), which is called if either the sort role
  72  *      has been successfully determined for all items, or items are inserted
  73  *      in the view, or the visible items might have changed because items
  74  *      were removed or moved, tries to determine the icons for all visible
  75  *      items synchronously for 200 ms. Then:
  76  *
  77  *      (a) If previews are disabled, icons and all other roles are determined
  78  *          asynchronously for the interesting items. This is done by the
  79  *          function \a resolveNextPendingRoles().
  80  *
  81  *      (b) If previews are enabled, a \a KIO::PreviewJob is started that loads
  82  *          the previews for the interesting items. At the same time, the icons
  83  *          for these items are determined asynchronously as fast as possible
  84  *          by \a resolveNextPendingRoles(). This minimizes the risk that the
  85  *          user sees "unknown" icons when scrolling before the previews have
  86  *          arrived.
  87  *
  88  * 3.   Finally, the entire process is repeated for any items that might have
  89  *      changed in the mean time.
  90  */
  91 class DOLPHIN_EXPORT KFileItemModelRolesUpdater : public QObject
  92 {
  93     Q_OBJECT
  94
  95 public:
  96     explicit KFileItemModelRolesUpdater(KFileItemModel* model, QObject* parent = nullptr);
  97     ~KFileItemModelRolesUpdater() override;
  98
  99     void setIconSize(const QSize& size);
 100     QSize iconSize() const;
 101
 102     /**
 103      * Sets the range of items that are visible currently. The roles
 104      * of visible items are resolved first.
 105      */
 106     void setVisibleIndexRange(int index, int count);
 107
 108     void setMaximumVisibleItems(int count);
 109
 110     /**
 111      * If \a show is set to true, the "iconPixmap" role will be filled with a preview
 112      * of the file. If \a show is false the MIME type icon will be used for the "iconPixmap"
 113      * role.
 114      */
 115     void setPreviewsShown(bool show);
 116     bool previewsShown() const;
 117
 118     /**
 119      * If enabled a small preview gets upscaled to the icon size in case where
 120      * the icon size is larger than the preview. Per default enlarging is
 121      * enabled.
 122      */
 123     void setEnlargeSmallPreviews(bool enlarge);
 124     bool enlargeSmallPreviews() const;
 125
 126     /**
 127      * If \a paused is set to true the asynchronous resolving of roles will be paused.
 128      * State changes during pauses like changing the icon size or the preview-shown
 129      * will be remembered and handled after unpausing.
 130      */
 131     void setPaused(bool paused);
 132     bool isPaused() const;
 133
 134     /**
 135      * Sets the roles that should be resolved asynchronously.
 136      */
 137     void setRoles(const QSet<QByteArray>& roles);
 138     QSet<QByteArray> roles() const;
 139
 140     /**
 141      * Sets the list of enabled thumbnail plugins that are used for previews.
 142      * Per default all plugins enabled in the KConfigGroup "PreviewSettings"
 143      * are used.
 144      *
 145      * For a list of available plugins, call KServiceTypeTrader::self()->query("ThumbCreator").
 146      *
 147      * @see enabledPlugins
 148      */
 149     void setEnabledPlugins(const QStringList& list);
 150
 151     /**
 152      * Returns the list of enabled thumbnail plugins.
 153      * @see setEnabledPlugins
 154      */
 155     QStringList enabledPlugins() const;
 156
 157     /**
 158      * Sets the maximum file size of local files for which
 159      * previews will be generated (if enabled). A value of 0
 160      * indicates no file size limit.
 161      * Per default the value from KConfigGroup "PreviewSettings"
 162      * MaximumSize is used, 0 otherwise.
 163      * @param size
 164      */
 165     void setLocalFileSizePreviewLimit(qlonglong size);
 166     qlonglong localFileSizePreviewLimit() const;
 167
 168 private slots:
 169     void slotItemsInserted(const KItemRangeList& itemRanges);
 170     void slotItemsRemoved(const KItemRangeList& itemRanges);
 171     void slotItemsMoved(const KItemRange& itemRange, const QList<int> &movedToIndexes);
 172     void slotItemsChanged(const KItemRangeList& itemRanges,
 173                           const QSet<QByteArray>& roles);
 174     void slotSortRoleChanged(const QByteArray& current,
 175                              const QByteArray& previous);
 176
 177     /**
 178      * Is invoked after a preview has been received successfully.
 179      * @see startPreviewJob()
 180      */
 181     void slotGotPreview(const KFileItem& item, const QPixmap& pixmap);
 182
 183     /**
 184      * Is invoked after generating a preview has failed.
 185      * @see startPreviewJob()
 186      */
 187     void slotPreviewFailed(const KFileItem& item);
 188
 189     /**
 190      * Is invoked when the preview job has been finished. Starts a new preview
 191      * job if there are any interesting items without previews left, or updates
 192      * the changed items otherwise.     *
 193      * @see startPreviewJob()
 194      */
 195     void slotPreviewJobFinished();
 196
 197     /**
 198      * Is invoked when one of the KOverlayIconPlugin emit the signal that an overlay has changed
 199      */
 200     void slotOverlaysChanged(const QUrl& url, const QStringList&);
 201
 202     /**
 203      * Resolves the sort role of the next item in m_pendingSortRole, applies it
 204      * to the model, and invokes itself if there are any pending items left. If
 205      * that is not the case, \a startUpdating() is called.
 206      */
 207     void resolveNextSortRole();
 208
 209     /**
 210      * Resolves the icon name and (if previews are disabled) all other roles
 211      * for the next interesting item. If there are no pending items left, any
 212      * changed items are updated.
 213      */
 214     void resolveNextPendingRoles();
 215
 216     /**
 217      * Resolves items that have not been resolved yet after the change has been
 218      * notified by slotItemsChanged(). Is invoked if the m_changedItemsTimer
 219      * expires.
 220      */
 221     void resolveRecentlyChangedItems();
 222
 223     void applyChangedBalooRoles(const QString& file);
 224     void applyChangedBalooRolesForItem(const KFileItem& file);
 225
 226     void slotDirectoryContentsCountReceived(const QString& path, int count, long size);
 227
 228 private:
 229     /**
 230      * Starts the updating of all roles. The visible items are handled first.
 231      */
 232     void startUpdating();
 233
 234     /**
 235      * Loads the icons for the visible items. After 200 ms, the function
 236      * stops determining mime types and only loads preliminary icons.
 237      * This is a compromise that prevents that
 238      * (a) the GUI is blocked for more than 200 ms, and
 239      * (b) "unknown" icons could be shown in the view.
 240      */
 241     void updateVisibleIcons();
 242
 243     /**
 244      * Creates previews for the items starting from the first item in
 245      * m_pendingPreviewItems.
 246      * @see slotGotPreview()
 247      * @see slotPreviewFailed()
 248      * @see slotPreviewJobFinished()
 249      */
 250     void startPreviewJob();
 251
 252     /**
 253      * Ensures that icons, previews, and other roles are determined for any
 254      * items that have been changed.
 255      */
 256     void updateChangedItems();
 257
 258     /**
 259      * Resolves the sort role of the item and applies it to the model.
 260      */
 261     void applySortRole(int index);
 262
 263     void applySortProgressToModel();
 264
 265     enum ResolveHint {
 266         ResolveFast,
 267         ResolveAll
 268     };
 269     bool applyResolvedRoles(int index, ResolveHint hint);
 270     QHash<QByteArray, QVariant> rolesData(const KFileItem& item);
 271
 272     /**
 273      * @return The number of items of the path \a path.
 274      */
 275     int subItemsCount(const QString& path) const;
 276
 277     /**
 278      * Must be invoked if a property has been changed that affects
 279      * the look of the preview. Takes care to update all previews.
 280      */
 281     void updateAllPreviews();
 282
 283     void killPreviewJob();
 284
 285     QList<int> indexesToResolve() const;
 286
 287 private:
 288     enum State {
 289         Idle,
 290         Paused,
 291         ResolvingSortRole,
 292         ResolvingAllRoles,
 293         PreviewJobRunning
 294     };
 295
 296     State m_state;
 297
 298     // Property changes during pausing must be remembered to be able
 299     // to react when unpausing again:
 300     bool m_previewChangedDuringPausing;
 301     bool m_iconSizeChangedDuringPausing;
 302     bool m_rolesChangedDuringPausing;
 303
 304     // Property for setPreviewsShown()/previewsShown().
 305     bool m_previewShown;
 306
 307     // Property for setEnlargeSmallPreviews()/enlargeSmallPreviews()
 308     bool m_enlargeSmallPreviews;
 309
 310     // True if the role "iconPixmap" should be cleared when resolving the next
 311     // role with resolveRole(). Is necessary if the preview gets disabled
 312     // during the roles-updater has been paused by setPaused().
 313     bool m_clearPreviews;
 314
 315     // Remembers which items have been handled already, to prevent that
 316     // previews and other expensive roles are determined again.
 317     QSet<KFileItem> m_finishedItems;
 318
 319     KFileItemModel* m_model;
 320     QSize m_iconSize;
 321     int m_firstVisibleIndex;
 322     int m_lastVisibleIndex;
 323     int m_maximumVisibleItems;
 324     QSet<QByteArray> m_roles;
 325     QSet<QByteArray> m_resolvableRoles;
 326     QStringList m_enabledPlugins;
 327     qulonglong m_localFileSizePreviewLimit;
 328
 329     // Items for which the sort role still has to be determined.
 330     QSet<KFileItem> m_pendingSortRoleItems;
 331
 332     // Indexes of items which still have to be handled by
 333     // resolveNextPendingRoles().
 334     QList<int> m_pendingIndexes;
 335
 336     // Items which have been left over from the last call of startPreviewJob().
 337     // A new preview job will be started from them once the first one finishes.
 338     KFileItemList m_pendingPreviewItems;
 339
 340     KIO::PreviewJob* m_previewJob;
 341
 342     // When downloading or copying large files, the slot slotItemsChanged()
 343     // will be called periodically within a quite short delay. To prevent
 344     // a high CPU-load by generating e.g. previews for each notification, the update
 345     // will be postponed until no file change has been done within a longer period
 346     // of time.
 347     QTimer* m_recentlyChangedItemsTimer;
 348     QSet<KFileItem> m_recentlyChangedItems;
 349
 350     // Items which have not been changed repeatedly recently.
 351     QSet<KFileItem> m_changedItems;
 352
 353     KDirectoryContentsCounter* m_directoryContentsCounter;
 354
 355     QList<KOverlayIconPlugin*> m_overlayIconsPlugin;
 356
 357 #ifdef HAVE_BALOO
 358     Baloo::FileMonitor* m_balooFileMonitor;
 359     Baloo::IndexerConfig m_balooConfig;
 360 #endif
 361 };
 362
 363 #endif
 364
 365