src/kitemviews/kfileitemlistview.cpp

   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 #include "kfileitemlistview.h"
  21
  22 #include "kfileitemlistwidget.h"
  23 #include "kfileitemmodel.h"
  24 #include "kfileitemmodelrolesupdater.h"
  25 #include "private/kpixmapmodifier.h"
  26
  27 #include <KIconLoader>
  28
  29 #include <QGraphicsScene>
  30 #include <QGraphicsView>
  31 #include <QPainter>
  32 #include <QTimer>
  33
  34 // #define KFILEITEMLISTVIEW_DEBUG
  35
  36 namespace {
  37     // If the visible index range changes, KFileItemModelRolesUpdater is not
  38     // informed immediately, but with a short delay. This ensures that scrolling
  39     // always feels smooth and is not interrupted by icon loading (which can be
  40     // quite expensive if a disk access is required to determine the final icon).
  41     const int ShortInterval = 50;
  42
  43     // If the icon size changes, a longer delay is used. This prevents that
  44     // the expensive re-generation of all previews is triggered repeatedly when
  45     // changing the zoom level.
  46     const int LongInterval = 300;
  47 }
  48
  49 KFileItemListView::KFileItemListView(QGraphicsWidget* parent) :
  50     KStandardItemListView(parent),
  51     m_modelRolesUpdater(nullptr),
  52     m_updateVisibleIndexRangeTimer(nullptr),
  53     m_updateIconSizeTimer(nullptr)
  54 {
  55     setAcceptDrops(true);
  56
  57     setScrollOrientation(Qt::Vertical);
  58
  59     m_updateVisibleIndexRangeTimer = new QTimer(this);
  60     m_updateVisibleIndexRangeTimer->setSingleShot(true);
  61     m_updateVisibleIndexRangeTimer->setInterval(ShortInterval);
  62     connect(m_updateVisibleIndexRangeTimer, &QTimer::timeout, this, &KFileItemListView::updateVisibleIndexRange);
  63
  64     m_updateIconSizeTimer = new QTimer(this);
  65     m_updateIconSizeTimer->setSingleShot(true);
  66     m_updateIconSizeTimer->setInterval(LongInterval);
  67     connect(m_updateIconSizeTimer, &QTimer::timeout, this, &KFileItemListView::updateIconSize);
  68
  69     setVisibleRoles({"text"});
  70 }
  71
  72 KFileItemListView::~KFileItemListView()
  73 {
  74 }
  75
  76 void KFileItemListView::setPreviewsShown(bool show)
  77 {
  78     if (!m_modelRolesUpdater) {
  79         return;
  80     }
  81
  82     if (m_modelRolesUpdater->previewsShown() != show) {
  83         beginTransaction();
  84         m_modelRolesUpdater->setPreviewsShown(show);
  85         onPreviewsShownChanged(show);
  86         endTransaction();
  87     }
  88 }
  89
  90 bool KFileItemListView::previewsShown() const
  91 {
  92     return m_modelRolesUpdater ? m_modelRolesUpdater->previewsShown() : false;
  93 }
  94
  95 void KFileItemListView::setEnlargeSmallPreviews(bool enlarge)
  96 {
  97     if (m_modelRolesUpdater) {
  98         m_modelRolesUpdater->setEnlargeSmallPreviews(enlarge);
  99     }
 100 }
 101
 102 bool KFileItemListView::enlargeSmallPreviews() const
 103 {
 104     return m_modelRolesUpdater ? m_modelRolesUpdater->enlargeSmallPreviews() : false;
 105 }
 106
 107 void KFileItemListView::setEnabledPlugins(const QStringList& list)
 108 {
 109     if (m_modelRolesUpdater) {
 110         m_modelRolesUpdater->setEnabledPlugins(list);
 111     }
 112 }
 113
 114 QStringList KFileItemListView::enabledPlugins() const
 115 {
 116     return m_modelRolesUpdater ? m_modelRolesUpdater->enabledPlugins() : QStringList();
 117 }
 118
 119 void KFileItemListView::setLocalFileSizePreviewLimit(const qlonglong size)
 120 {
 121     if (m_modelRolesUpdater) {
 122         m_modelRolesUpdater->setLocalFileSizePreviewLimit(size);
 123     }
 124 }
 125
 126 qlonglong KFileItemListView::localFileSizePreviewLimit() const
 127 {
 128     return m_modelRolesUpdater ? m_modelRolesUpdater->localFileSizePreviewLimit() : 0;
 129 }
 130
 131 QPixmap KFileItemListView::createDragPixmap(const KItemSet& indexes) const
 132 {
 133     if (!model()) {
 134         return QPixmap();
 135     }
 136
 137     const int itemCount = indexes.count();
 138     Q_ASSERT(itemCount > 0);
 139     if (itemCount == 1) {
 140         return KItemListView::createDragPixmap(indexes);
 141     }
 142
 143     // If more than one item is dragged, align the items inside a
 144     // rectangular grid. The maximum grid size is limited to 5 x 5 items.
 145     int xCount;
 146     int size;
 147     if (itemCount > 16) {
 148         xCount = 5;
 149         size = KIconLoader::SizeSmall;
 150     } else if (itemCount > 9) {
 151         xCount = 4;
 152         size = KIconLoader::SizeSmallMedium;
 153     } else {
 154         xCount = 3;
 155         size = KIconLoader::SizeMedium;
 156     }
 157
 158     if (itemCount < xCount) {
 159         xCount = itemCount;
 160     }
 161
 162     int yCount = itemCount / xCount;
 163     if (itemCount % xCount != 0) {
 164         ++yCount;
 165     }
 166     if (yCount > xCount) {
 167         yCount = xCount;
 168     }
 169
 170     const qreal dpr = scene()->views()[0]->devicePixelRatio();
 171     // Draw the selected items into the grid cells.
 172     QPixmap dragPixmap(QSize(xCount * size + xCount, yCount * size + yCount) * dpr);
 173     dragPixmap.setDevicePixelRatio(dpr);
 174     dragPixmap.fill(Qt::transparent);
 175
 176     QPainter painter(&dragPixmap);
 177     int x = 0;
 178     int y = 0;
 179
 180     for (int index : indexes) {
 181         QPixmap pixmap = model()->data(index).value("iconPixmap").value<QPixmap>();
 182         if (pixmap.isNull()) {
 183             QIcon icon = QIcon::fromTheme(model()->data(index).value("iconName").toString());
 184             pixmap = icon.pixmap(size, size);
 185         } else {
 186             KPixmapModifier::scale(pixmap, QSize(size, size) * dpr);
 187         }
 188
 189         painter.drawPixmap(x, y, pixmap);
 190
 191         x += size + 1;
 192         if (x >= dragPixmap.width()) {
 193             x = 0;
 194             y += size + 1;
 195         }
 196
 197         if (y >= dragPixmap.height()) {
 198             break;
 199         }
 200     }
 201
 202     return dragPixmap;
 203 }
 204
 205 KItemListWidgetCreatorBase* KFileItemListView::defaultWidgetCreator() const
 206 {
 207     return new KItemListWidgetCreator<KFileItemListWidget>();
 208 }
 209
 210 void KFileItemListView::initializeItemListWidget(KItemListWidget* item)
 211 {
 212     KStandardItemListView::initializeItemListWidget(item);
 213
 214     // Make sure that the item has an icon.
 215     QHash<QByteArray, QVariant> data = item->data();
 216     if (!data.contains("iconName") && data["iconPixmap"].value<QPixmap>().isNull()) {
 217         Q_ASSERT(qobject_cast<KFileItemModel*>(model()));
 218         KFileItemModel* fileItemModel = static_cast<KFileItemModel*>(model());
 219
 220         const KFileItem fileItem = fileItemModel->fileItem(item->index());
 221         data.insert("iconName", fileItem.iconName());
 222         item->setData(data, {"iconName"});
 223     }
 224 }
 225
 226 void KFileItemListView::onPreviewsShownChanged(bool shown)
 227 {
 228     Q_UNUSED(shown)
 229 }
 230
 231 void KFileItemListView::onItemLayoutChanged(ItemLayout current, ItemLayout previous)
 232 {
 233     KStandardItemListView::onItemLayoutChanged(current, previous);
 234     triggerVisibleIndexRangeUpdate();
 235 }
 236
 237 void KFileItemListView::onModelChanged(KItemModelBase* current, KItemModelBase* previous)
 238 {
 239     Q_ASSERT(qobject_cast<KFileItemModel*>(current));
 240     KStandardItemListView::onModelChanged(current, previous);
 241
 242     delete m_modelRolesUpdater;
 243     m_modelRolesUpdater = nullptr;
 244
 245     if (current) {
 246         m_modelRolesUpdater = new KFileItemModelRolesUpdater(static_cast<KFileItemModel*>(current), this);
 247         m_modelRolesUpdater->setIconSize(availableIconSize());
 248
 249         applyRolesToModel();
 250     }
 251 }
 252
 253 void KFileItemListView::onScrollOrientationChanged(Qt::Orientation current, Qt::Orientation previous)
 254 {
 255     KStandardItemListView::onScrollOrientationChanged(current, previous);
 256     triggerVisibleIndexRangeUpdate();
 257 }
 258
 259 void KFileItemListView::onItemSizeChanged(const QSizeF& current, const QSizeF& previous)
 260 {
 261     Q_UNUSED(current)
 262     Q_UNUSED(previous)
 263     triggerVisibleIndexRangeUpdate();
 264 }
 265
 266 void KFileItemListView::onScrollOffsetChanged(qreal current, qreal previous)
 267 {
 268     KStandardItemListView::onScrollOffsetChanged(current, previous);
 269     triggerVisibleIndexRangeUpdate();
 270 }
 271
 272 void KFileItemListView::onVisibleRolesChanged(const QList<QByteArray>& current, const QList<QByteArray>& previous)
 273 {
 274     KStandardItemListView::onVisibleRolesChanged(current, previous);
 275     applyRolesToModel();
 276 }
 277
 278 void KFileItemListView::onStyleOptionChanged(const KItemListStyleOption& current, const KItemListStyleOption& previous)
 279 {
 280     KStandardItemListView::onStyleOptionChanged(current, previous);
 281     triggerIconSizeUpdate();
 282 }
 283
 284 void KFileItemListView::onSupportsItemExpandingChanged(bool supportsExpanding)
 285 {
 286     applyRolesToModel();
 287     KStandardItemListView::onSupportsItemExpandingChanged(supportsExpanding);
 288     triggerVisibleIndexRangeUpdate();
 289 }
 290
 291 void KFileItemListView::onTransactionBegin()
 292 {
 293     if (m_modelRolesUpdater) {
 294         m_modelRolesUpdater->setPaused(true);
 295     }
 296 }
 297
 298 void KFileItemListView::onTransactionEnd()
 299 {
 300     if (!m_modelRolesUpdater) {
 301         return;
 302     }
 303
 304     // Only unpause the model-roles-updater if no timer is active. If one
 305     // timer is still active the model-roles-updater will be unpaused later as
 306     // soon as the timer has been exceeded.
 307     const bool timerActive = m_updateVisibleIndexRangeTimer->isActive() ||
 308                              m_updateIconSizeTimer->isActive();
 309     if (!timerActive) {
 310         m_modelRolesUpdater->setPaused(false);
 311     }
 312 }
 313
 314 void KFileItemListView::resizeEvent(QGraphicsSceneResizeEvent* event)
 315 {
 316     KStandardItemListView::resizeEvent(event);
 317     triggerVisibleIndexRangeUpdate();
 318 }
 319
 320 void KFileItemListView::slotItemsRemoved(const KItemRangeList& itemRanges)
 321 {
 322     KStandardItemListView::slotItemsRemoved(itemRanges);
 323 }
 324
 325 void KFileItemListView::slotSortRoleChanged(const QByteArray& current, const QByteArray& previous)
 326 {
 327     const QByteArray sortRole = model()->sortRole();
 328     if (!visibleRoles().contains(sortRole)) {
 329         applyRolesToModel();
 330     }
 331
 332     KStandardItemListView::slotSortRoleChanged(current, previous);
 333 }
 334
 335 void KFileItemListView::triggerVisibleIndexRangeUpdate()
 336 {
 337     if (!model()) {
 338         return;
 339     }
 340     m_modelRolesUpdater->setPaused(true);
 341
 342     // If the icon size has been changed recently, wait until
 343     // m_updateIconSizeTimer expires.
 344     if (!m_updateIconSizeTimer->isActive()) {
 345         m_updateVisibleIndexRangeTimer->start();
 346     }
 347 }
 348
 349 void KFileItemListView::updateVisibleIndexRange()
 350 {
 351     if (!m_modelRolesUpdater) {
 352         return;
 353     }
 354
 355     const int index = firstVisibleIndex();
 356     const int count = lastVisibleIndex() - index + 1;
 357     m_modelRolesUpdater->setMaximumVisibleItems(maximumVisibleItems());
 358     m_modelRolesUpdater->setVisibleIndexRange(index, count);
 359     m_modelRolesUpdater->setPaused(isTransactionActive());
 360 }
 361
 362 void KFileItemListView::triggerIconSizeUpdate()
 363 {
 364     if (!model()) {
 365         return;
 366     }
 367     m_modelRolesUpdater->setPaused(true);
 368     m_updateIconSizeTimer->start();
 369
 370     // The visible index range will be updated when m_updateIconSizeTimer expires.
 371     // Stop m_updateVisibleIndexRangeTimer to prevent an expensive re-generation
 372     // of all previews (note that the user might change the icon size again soon).
 373     m_updateVisibleIndexRangeTimer->stop();
 374 }
 375
 376 void KFileItemListView::updateIconSize()
 377 {
 378     if (!m_modelRolesUpdater) {
 379         return;
 380     }
 381
 382     m_modelRolesUpdater->setIconSize(availableIconSize());
 383
 384     // Update the visible index range (which has most likely changed after the
 385     // icon size change) before unpausing m_modelRolesUpdater.
 386     const int index = firstVisibleIndex();
 387     const int count = lastVisibleIndex() - index + 1;
 388     m_modelRolesUpdater->setVisibleIndexRange(index, count);
 389
 390     m_modelRolesUpdater->setPaused(isTransactionActive());
 391 }
 392
 393 void KFileItemListView::applyRolesToModel()
 394 {
 395     if (!model()) {
 396         return;
 397     }
 398
 399     Q_ASSERT(qobject_cast<KFileItemModel*>(model()));
 400     KFileItemModel* fileItemModel = static_cast<KFileItemModel*>(model());
 401
 402     // KFileItemModel does not distinct between "visible" and "invisible" roles.
 403     // Add all roles that are mandatory for having a working KFileItemListView:
 404     QSet<QByteArray> roles = visibleRoles().toSet();
 405     roles.insert("iconPixmap");
 406     roles.insert("iconName");
 407     roles.insert("text");
 408     roles.insert("isDir");
 409     roles.insert("isLink");
 410     roles.insert("isHidden");
 411     if (supportsItemExpanding()) {
 412         roles.insert("isExpanded");
 413         roles.insert("isExpandable");
 414         roles.insert("expandedParentsCount");
 415     }
 416
 417     // Assure that the role that is used for sorting will be determined
 418     roles.insert(fileItemModel->sortRole());
 419
 420     fileItemModel->setRoles(roles);
 421     m_modelRolesUpdater->setRoles(roles);
 422 }
 423
 424 QSize KFileItemListView::availableIconSize() const
 425 {
 426     const KItemListStyleOption& option = styleOption();
 427     const int iconSize = option.iconSize;
 428     if (itemLayout() == IconsLayout) {
 429         const int maxIconWidth = itemSize().width() - 2 * option.padding;
 430         return QSize(maxIconWidth, iconSize);
 431     }
 432
 433     return QSize(iconSize, iconSize);
 434 }
 435