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