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