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 "kfileitemlistgroupheader.h"
  23 #include "kfileitemmodelrolesupdater.h"
  24 #include "kfileitemlistwidget.h"
  25 #include "kfileitemmodel.h"
  26 #include <KLocale>
  27 #include <KStringHandler>
  28 #include "private/kpixmapmodifier.h"
  29
  30 #include <KDebug>
  31 #include <KIcon>
  32 #include <KTextEdit>
  33
  34 #include <QPainter>
  35 #include <QTextLine>
  36 #include <QTimer>
  37
  38 // #define KFILEITEMLISTVIEW_DEBUG
  39
  40 namespace {
  41     const int ShortInterval = 50;
  42     const int LongInterval = 300;
  43 }
  44
  45 KFileItemListView::KFileItemListView(QGraphicsWidget* parent) :
  46     KStandardItemListView(parent),
  47     m_modelRolesUpdater(0),
  48     m_updateVisibleIndexRangeTimer(0),
  49     m_updateIconSizeTimer(0)
  50 {
  51     setAcceptDrops(true);
  52
  53     setScrollOrientation(Qt::Vertical);
  54
  55     m_updateVisibleIndexRangeTimer = new QTimer(this);
  56     m_updateVisibleIndexRangeTimer->setSingleShot(true);
  57     m_updateVisibleIndexRangeTimer->setInterval(ShortInterval);
  58     connect(m_updateVisibleIndexRangeTimer, SIGNAL(timeout()), this, SLOT(updateVisibleIndexRange()));
  59
  60     m_updateIconSizeTimer = new QTimer(this);
  61     m_updateIconSizeTimer->setSingleShot(true);
  62     m_updateIconSizeTimer->setInterval(ShortInterval);
  63     connect(m_updateIconSizeTimer, SIGNAL(timeout()), this, SLOT(updateIconSize()));
  64
  65     setVisibleRoles(QList<QByteArray>() << "text");
  66 }
  67
  68 KFileItemListView::~KFileItemListView()
  69 {
  70     delete m_modelRolesUpdater;
  71     m_modelRolesUpdater = 0;
  72 }
  73
  74 void KFileItemListView::setPreviewsShown(bool show)
  75 {
  76     if (!m_modelRolesUpdater) {
  77         return;
  78     }
  79
  80     if (m_modelRolesUpdater->previewsShown() != show) {
  81         beginTransaction();
  82         m_modelRolesUpdater->setPreviewsShown(show);
  83         onPreviewsShownChanged(show);
  84         endTransaction();
  85     }
  86 }
  87
  88 bool KFileItemListView::previewsShown() const
  89 {
  90     return m_modelRolesUpdater ? m_modelRolesUpdater->previewsShown() : false;
  91 }
  92
  93 void KFileItemListView::setEnlargeSmallPreviews(bool enlarge)
  94 {
  95     if (m_modelRolesUpdater) {
  96         m_modelRolesUpdater->setEnlargeSmallPreviews(enlarge);
  97     }
  98 }
  99
 100 bool KFileItemListView::enlargeSmallPreviews() const
 101 {
 102     return m_modelRolesUpdater ? m_modelRolesUpdater->enlargeSmallPreviews() : false;
 103 }
 104
 105 void KFileItemListView::setEnabledPlugins(const QStringList& list)
 106 {
 107     if (m_modelRolesUpdater) {
 108         m_modelRolesUpdater->setEnabledPlugins(list);
 109     }
 110 }
 111
 112 QStringList KFileItemListView::enabledPlugins() const
 113 {
 114     return m_modelRolesUpdater ? m_modelRolesUpdater->enabledPlugins() : QStringList();
 115 }
 116
 117 QPixmap KFileItemListView::createDragPixmap(const QSet<int>& indexes) const
 118 {
 119     if (!model()) {
 120         return QPixmap();
 121     }
 122
 123     const int itemCount = indexes.count();
 124     Q_ASSERT(itemCount > 0);
 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 KItemListGroupHeaderCreatorBase* KFileItemListView::defaultGroupHeaderCreator() const
 194 {
 195     return new KItemListGroupHeaderCreator<KFileItemListGroupHeader>();
 196 }
 197
 198 void KFileItemListView::onPreviewsShownChanged(bool shown)
 199 {
 200     Q_UNUSED(shown);
 201 }
 202
 203 void KFileItemListView::onItemLayoutChanged(ItemLayout current, ItemLayout previous)
 204 {
 205     if (previous == DetailsLayout || current == DetailsLayout) {
 206         // The details-layout requires some invisible roles that
 207         // must be added to the model if the new layout is "details".
 208         // If the old layout was "details" the roles will get removed.
 209         applyRolesToModel();
 210     }
 211     KStandardItemListView::onItemLayoutChanged(current, previous);
 212     triggerVisibleIndexRangeUpdate();
 213 }
 214
 215 void KFileItemListView::onModelChanged(KItemModelBase* current, KItemModelBase* previous)
 216 {
 217     Q_ASSERT(qobject_cast<KFileItemModel*>(current));
 218     KStandardItemListView::onModelChanged(current, previous);
 219
 220     delete m_modelRolesUpdater;
 221     m_modelRolesUpdater = 0;
 222
 223     if (current) {
 224         m_modelRolesUpdater = new KFileItemModelRolesUpdater(static_cast<KFileItemModel*>(current), this);
 225         m_modelRolesUpdater->setIconSize(availableIconSize());
 226
 227         applyRolesToModel();
 228     }
 229 }
 230
 231 void KFileItemListView::onScrollOrientationChanged(Qt::Orientation current, Qt::Orientation previous)
 232 {
 233     KStandardItemListView::onScrollOrientationChanged(current, previous);
 234     triggerVisibleIndexRangeUpdate();
 235 }
 236
 237 void KFileItemListView::onItemSizeChanged(const QSizeF& current, const QSizeF& previous)
 238 {
 239     Q_UNUSED(current);
 240     Q_UNUSED(previous);
 241     triggerVisibleIndexRangeUpdate();
 242 }
 243
 244 void KFileItemListView::onScrollOffsetChanged(qreal current, qreal previous)
 245 {
 246     KStandardItemListView::onScrollOffsetChanged(current, previous);
 247     triggerVisibleIndexRangeUpdate();
 248 }
 249
 250 void KFileItemListView::onVisibleRolesChanged(const QList<QByteArray>& current, const QList<QByteArray>& previous)
 251 {
 252     KStandardItemListView::onVisibleRolesChanged(current, previous);
 253     applyRolesToModel();
 254 }
 255
 256 void KFileItemListView::onStyleOptionChanged(const KItemListStyleOption& current, const KItemListStyleOption& previous)
 257 {
 258     KStandardItemListView::onStyleOptionChanged(current, previous);
 259     triggerIconSizeUpdate();
 260 }
 261
 262 void KFileItemListView::onSupportsItemExpandingChanged(bool supportsExpanding)
 263 {
 264     applyRolesToModel();
 265     KStandardItemListView::onSupportsItemExpandingChanged(supportsExpanding);
 266     triggerVisibleIndexRangeUpdate();
 267 }
 268
 269 void KFileItemListView::onTransactionBegin()
 270 {
 271     if (m_modelRolesUpdater) {
 272         m_modelRolesUpdater->setPaused(true);
 273     }
 274 }
 275
 276 void KFileItemListView::onTransactionEnd()
 277 {
 278     if (!m_modelRolesUpdater) {
 279         return;
 280     }
 281
 282     // Only unpause the model-roles-updater if no timer is active. If one
 283     // timer is still active the model-roles-updater will be unpaused later as
 284     // soon as the timer has been exceeded.
 285     const bool timerActive = m_updateVisibleIndexRangeTimer->isActive() ||
 286                              m_updateIconSizeTimer->isActive();
 287     if (!timerActive) {
 288         m_modelRolesUpdater->setPaused(false);
 289     }
 290 }
 291
 292 void KFileItemListView::resizeEvent(QGraphicsSceneResizeEvent* event)
 293 {
 294     KStandardItemListView::resizeEvent(event);
 295     triggerVisibleIndexRangeUpdate();
 296 }
 297
 298 void KFileItemListView::slotItemsRemoved(const KItemRangeList& itemRanges)
 299 {
 300     KStandardItemListView::slotItemsRemoved(itemRanges);
 301     updateTimersInterval();
 302 }
 303
 304 void KFileItemListView::slotSortRoleChanged(const QByteArray& current, const QByteArray& previous)
 305 {
 306     const QByteArray sortRole = model()->sortRole();
 307     if (!visibleRoles().contains(sortRole)) {
 308         applyRolesToModel();
 309     }
 310
 311     KStandardItemListView::slotSortRoleChanged(current, previous);
 312 }
 313
 314 void KFileItemListView::triggerVisibleIndexRangeUpdate()
 315 {
 316     if (!model()) {
 317         return;
 318     }
 319     m_modelRolesUpdater->setPaused(true);
 320     m_updateVisibleIndexRangeTimer->start();
 321 }
 322
 323 void KFileItemListView::updateVisibleIndexRange()
 324 {
 325     if (!m_modelRolesUpdater) {
 326         return;
 327     }
 328
 329     const int index = firstVisibleIndex();
 330     const int count = lastVisibleIndex() - index + 1;
 331     m_modelRolesUpdater->setVisibleIndexRange(index, count);
 332
 333     if (m_updateIconSizeTimer->isActive()) {
 334         // If the icon-size update is pending do an immediate update
 335         // of the icon-size before unpausing m_modelRolesUpdater. This prevents
 336         // an unnecessary expensive recreation of all previews afterwards.
 337         m_updateIconSizeTimer->stop();
 338         m_modelRolesUpdater->setIconSize(availableIconSize());
 339     }
 340
 341     m_modelRolesUpdater->setPaused(isTransactionActive());
 342     updateTimersInterval();
 343 }
 344
 345 void KFileItemListView::triggerIconSizeUpdate()
 346 {
 347     if (!model()) {
 348         return;
 349     }
 350     m_modelRolesUpdater->setPaused(true);
 351     m_updateIconSizeTimer->start();
 352 }
 353
 354 void KFileItemListView::updateIconSize()
 355 {
 356     if (!m_modelRolesUpdater) {
 357         return;
 358     }
 359
 360     m_modelRolesUpdater->setIconSize(availableIconSize());
 361
 362     if (m_updateVisibleIndexRangeTimer->isActive()) {
 363         // If the visibility-index-range update is pending do an immediate update
 364         // of the range before unpausing m_modelRolesUpdater. This prevents
 365         // an unnecessary expensive recreation of all previews afterwards.
 366         m_updateVisibleIndexRangeTimer->stop();
 367         const int index = firstVisibleIndex();
 368         const int count = lastVisibleIndex() - index + 1;
 369         m_modelRolesUpdater->setVisibleIndexRange(index, count);
 370     }
 371
 372     m_modelRolesUpdater->setPaused(isTransactionActive());
 373     updateTimersInterval();
 374 }
 375
 376 void KFileItemListView::updateTimersInterval()
 377 {
 378     if (!model()) {
 379         return;
 380     }
 381
 382     // The ShortInterval is used for cases like switching the directory: If the
 383     // model is empty and filled later the creation of the previews should be done
 384     // as soon as possible. The LongInterval is used when the model already contains
 385     // items and assures that operations like zooming don't result in too many temporary
 386     // recreations of the previews.
 387
 388     const int interval = (model()->count() <= 0) ? ShortInterval : LongInterval;
 389     m_updateVisibleIndexRangeTimer->setInterval(interval);
 390     m_updateIconSizeTimer->setInterval(interval);
 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     if (supportsItemExpanding()) {
 410         roles.insert("isExpanded");
 411         roles.insert("isExpandable");
 412         roles.insert("expandedParentsCount");
 413     }
 414
 415     // Assure that the role that is used for sorting will be determined
 416     roles.insert(fileItemModel->sortRole());
 417
 418     fileItemModel->setRoles(roles);
 419     m_modelRolesUpdater->setRoles(roles);
 420 }
 421
 422 QSize KFileItemListView::availableIconSize() const
 423 {
 424     const KItemListStyleOption& option = styleOption();
 425     const int iconSize = option.iconSize;
 426     if (itemLayout() == IconsLayout) {
 427         const int maxIconWidth = itemSize().width() - 2 * option.padding;
 428         return QSize(maxIconWidth, iconSize);
 429     }
 430
 431     return QSize(iconSize, iconSize);
 432 }
 433
 434 #include "kfileitemlistview.moc"