X-Git-Url: https://cloud.milkyroute.net/gitweb/dolphin.git/blobdiff_plain/84010807786c352aaeb2320caf27e5f9048d8dec..e57f6215659ee36877c7c36c9e3fcba0ba5d03a0:/src/kitemviews/kfileitemlistview.cpp diff --git a/src/kitemviews/kfileitemlistview.cpp b/src/kitemviews/kfileitemlistview.cpp index d9742945a..d763fe287 100644 --- a/src/kitemviews/kfileitemlistview.cpp +++ b/src/kitemviews/kfileitemlistview.cpp @@ -1,344 +1,385 @@ -/*************************************************************************** - * Copyright (C) 2011 by Peter Penz * - * * - * This program is free software; you can redistribute it and/or modify * - * it under the terms of the GNU General Public License as published by * - * the Free Software Foundation; either version 2 of the License, or * - * (at your option) any later version. * - * * - * This program is distributed in the hope that it will be useful, * - * but WITHOUT ANY WARRANTY; without even the implied warranty of * - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * - * GNU General Public License for more details. * - * * - * You should have received a copy of the GNU General Public License * - * along with this program; if not, write to the * - * Free Software Foundation, Inc., * - * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * - ***************************************************************************/ +/* + * SPDX-FileCopyrightText: 2011 Peter Penz + * + * SPDX-License-Identifier: GPL-2.0-or-later + */ #include "kfileitemlistview.h" -#include "kitemlistgroupheader.h" -#include "kfileitemmodelrolesupdater.h" #include "kfileitemlistwidget.h" #include "kfileitemmodel.h" -#include -#include +#include "kfileitemmodelrolesupdater.h" +#include "private/kitemviewsutils.h" +#include "private/kpixmapmodifier.h" -#include -#include +#include -#include +#include +#include +#include +#include +#include #include -#define KFILEITEMLISTVIEW_DEBUG +// #define KFILEITEMLISTVIEW_DEBUG -namespace { - const int ShortInterval = 50; - const int LongInterval = 300; +namespace +{ +// If the visible index range changes, KFileItemModelRolesUpdater is not +// informed immediately, but with a short delay. This ensures that scrolling +// always feels smooth and is not interrupted by icon loading (which can be +// quite expensive if a disk access is required to determine the final icon). +const int ShortInterval = 50; + +// If the icon size changes, a longer delay is used. This prevents that +// the expensive re-generation of all previews is triggered repeatedly when +// changing the zoom level. +const int LongInterval = 300; } -KFileItemListView::KFileItemListView(QGraphicsWidget* parent) : - KItemListView(parent), - m_itemLayout(IconsLayout), - m_modelRolesUpdater(0), - m_updateVisibleIndexRangeTimer(0), - m_updateIconSizeTimer(0), - m_minimumRolesWidths() +KFileItemListView::KFileItemListView(QGraphicsWidget *parent) + : KStandardItemListView(parent) + , m_modelRolesUpdater(nullptr) + , m_updateVisibleIndexRangeTimer(nullptr) + , m_updateIconSizeTimer(nullptr) { setAcceptDrops(true); setScrollOrientation(Qt::Vertical); - setWidgetCreator(new KItemListWidgetCreator()); - setGroupHeaderCreator(new KItemListGroupHeaderCreator()); m_updateVisibleIndexRangeTimer = new QTimer(this); m_updateVisibleIndexRangeTimer->setSingleShot(true); m_updateVisibleIndexRangeTimer->setInterval(ShortInterval); - connect(m_updateVisibleIndexRangeTimer, SIGNAL(timeout()), this, SLOT(updateVisibleIndexRange())); + connect(m_updateVisibleIndexRangeTimer, &QTimer::timeout, this, &KFileItemListView::updateVisibleIndexRange); m_updateIconSizeTimer = new QTimer(this); m_updateIconSizeTimer->setSingleShot(true); - m_updateIconSizeTimer->setInterval(ShortInterval); - connect(m_updateIconSizeTimer, SIGNAL(timeout()), this, SLOT(updateIconSize())); + m_updateIconSizeTimer->setInterval(LongInterval); + connect(m_updateIconSizeTimer, &QTimer::timeout, this, &KFileItemListView::updateIconSize); - updateMinimumRolesWidths(); + setVisibleRoles({"text"}); } KFileItemListView::~KFileItemListView() { - delete widgetCreator(); - delete groupHeaderCreator(); - - delete m_modelRolesUpdater; - m_modelRolesUpdater = 0; } void KFileItemListView::setPreviewsShown(bool show) { - if (m_modelRolesUpdater) { - m_modelRolesUpdater->setPreviewShown(show); + if (!m_modelRolesUpdater) { + return; + } + + if (m_modelRolesUpdater->previewsShown() != show) { + beginTransaction(); + m_modelRolesUpdater->setPreviewsShown(show); + onPreviewsShownChanged(show); + endTransaction(); } } bool KFileItemListView::previewsShown() const { - return m_modelRolesUpdater->isPreviewShown(); + return m_modelRolesUpdater ? m_modelRolesUpdater->previewsShown() : false; } -void KFileItemListView::setItemLayout(Layout layout) +void KFileItemListView::setEnlargeSmallPreviews(bool enlarge) { - if (m_itemLayout != layout) { - m_itemLayout = layout; - updateLayoutOfVisibleItems(); + if (m_modelRolesUpdater) { + m_modelRolesUpdater->setEnlargeSmallPreviews(enlarge); } } -KFileItemListView::Layout KFileItemListView::itemLayout() const +bool KFileItemListView::enlargeSmallPreviews() const { - return m_itemLayout; + return m_modelRolesUpdater ? m_modelRolesUpdater->enlargeSmallPreviews() : false; } -QSizeF KFileItemListView::itemSizeHint(int index) const +void KFileItemListView::setEnabledPlugins(const QStringList &list) { - const QHash values = model()->data(index); - const KItemListStyleOption& option = styleOption(); - const int additionalRolesCount = qMax(visibleRoles().count() - 1, 0); - - switch (m_itemLayout) { - case IconsLayout: { - const QString text = KStringHandler::preProcessWrap(values["name"].toString()); - - const qreal maxWidth = itemSize().width() - 2 * option.margin; - int textLinesCount = 0; - QTextLine line; - - // Calculate the number of lines required for wrapping the name - QTextOption textOption(Qt::AlignHCenter); - textOption.setWrapMode(QTextOption::WrapAtWordBoundaryOrAnywhere); - - QTextLayout layout(text, option.font); - layout.setTextOption(textOption); - layout.beginLayout(); - while ((line = layout.createLine()).isValid()) { - line.setLineWidth(maxWidth); - line.naturalTextWidth(); - ++textLinesCount; - } - layout.endLayout(); + if (m_modelRolesUpdater) { + m_modelRolesUpdater->setEnabledPlugins(list); + } +} - // Add one line for each additional information - textLinesCount += additionalRolesCount; +QStringList KFileItemListView::enabledPlugins() const +{ + return m_modelRolesUpdater ? m_modelRolesUpdater->enabledPlugins() : QStringList(); +} - const qreal height = textLinesCount * option.fontMetrics.height() + - option.iconSize + - option.margin * 4; - return QSizeF(itemSize().width(), height); +void KFileItemListView::setLocalFileSizePreviewLimit(const qlonglong size) +{ + if (m_modelRolesUpdater) { + m_modelRolesUpdater->setLocalFileSizePreviewLimit(size); } +} - case CompactLayout: { - // For each row exactly one role is shown. Calculate the maximum required width that is necessary - // to show all roles without horizontal clipping. - qreal maximumRequiredWidth = 0.0; - QHashIterator it(visibleRoles()); - while (it.hasNext()) { - it.next(); - const QByteArray& role = it.key(); - const QString text = values[role].toString(); - const qreal requiredWidth = option.fontMetrics.width(text); - maximumRequiredWidth = qMax(maximumRequiredWidth, requiredWidth); - } +qlonglong KFileItemListView::localFileSizePreviewLimit() const +{ + return m_modelRolesUpdater ? m_modelRolesUpdater->localFileSizePreviewLimit() : 0; +} - const qreal width = option.margin * 4 + option.iconSize + maximumRequiredWidth; - const qreal height = option.margin * 2 + qMax(option.iconSize, (1 + additionalRolesCount) * option.fontMetrics.height()); - return QSizeF(width, height); +QPixmap KFileItemListView::createDragPixmap(const KItemSet &indexes) const +{ + if (!model()) { + return QPixmap(); } - case DetailsLayout: { - // The width will be determined dynamically by KFileItemListView::visibleRoleSizes() - const qreal height = option.margin * 2 + qMax(option.iconSize, option.fontMetrics.height()); - return QSizeF(-1, height); + const int itemCount = indexes.count(); + Q_ASSERT(itemCount > 0); + if (itemCount == 1) { + return KItemListView::createDragPixmap(indexes); } - default: - Q_ASSERT(false); - break; + // If more than one item is dragged, align the items inside a + // rectangular grid. The maximum grid size is limited to 5 x 5 items. + int xCount; + int size; + if (itemCount > 16) { + xCount = 5; + size = KIconLoader::SizeSmall; + } else if (itemCount > 9) { + xCount = 4; + size = KIconLoader::SizeSmallMedium; + } else { + xCount = 3; + size = KIconLoader::SizeMedium; } - return QSize(); -} - -QHash KFileItemListView::visibleRoleSizes() const -{ - QElapsedTimer timer; - timer.start(); + if (itemCount < xCount) { + xCount = itemCount; + } - QHash sizes; + int yCount = itemCount / xCount; + if (itemCount % xCount != 0) { + ++yCount; + } + if (yCount > xCount) { + yCount = xCount; + } - const int itemCount = model()->count(); - for (int i = 0; i < itemCount; ++i) { - QHashIterator it(visibleRoles()); - while (it.hasNext()) { - it.next(); - const QByteArray& visibleRole = it.key(); + const qreal dpr = KItemViewsUtils::devicePixelRatio(this); + // Draw the selected items into the grid cells. + QPixmap dragPixmap(QSize(xCount * size + xCount, yCount * size + yCount) * dpr); + dragPixmap.setDevicePixelRatio(dpr); + dragPixmap.fill(Qt::transparent); + + QPainter painter(&dragPixmap); + int x = 0; + int y = 0; + + for (int index : indexes) { + QPixmap pixmap = model()->data(index).value("iconPixmap").value(); + if (pixmap.isNull()) { + QIcon icon = QIcon::fromTheme(model()->data(index).value("iconName").toString()); + if (icon.isNull()) { + icon = QIcon::fromTheme(QStringLiteral("unknown")); + } + if (!icon.isNull()) { + pixmap = icon.pixmap(size, size); + } else { + pixmap = QPixmap(size, size); + pixmap.fill(Qt::transparent); + } + } else { + KPixmapModifier::scale(pixmap, QSize(size, size) * dpr); + } - QSizeF maxSize = sizes.value(visibleRole, QSizeF(0, 0)); + painter.drawPixmap(x, y, pixmap); - const QSizeF itemSize = visibleRoleSizeHint(i, visibleRole); - maxSize = maxSize.expandedTo(itemSize); - sizes.insert(visibleRole, maxSize); + x += size + 1; + if (x >= dragPixmap.width()) { + x = 0; + y += size + 1; } - if (i > 100 && timer.elapsed() > 200) { - // When having several thousands of items calculating the sizes can get - // very expensive. We accept a possibly too small role-size in favour - // of having no blocking user interface. - #ifdef KFILEITEMLISTVIEW_DEBUG - kDebug() << "Timer exceeded, stopped after" << i << "items"; - #endif + if (y >= dragPixmap.height()) { break; } } -#ifdef KFILEITEMLISTVIEW_DEBUG - kDebug() << "[TIME] Calculated dynamic item size for " << itemCount << "items:" << timer.elapsed(); -#endif - return sizes; + return dragPixmap; } -QPixmap KFileItemListView::createDragPixmap(const QSet& indexes) const +void KFileItemListView::setHoverSequenceState(const QUrl &itemUrl, int seqIdx) { - QPixmap pixmap; + if (m_modelRolesUpdater) { + m_modelRolesUpdater->setHoverSequenceState(itemUrl, seqIdx); + } +} - if (model()) { - QSetIterator it(indexes); - while (it.hasNext()) { - const int index = it.next(); - // TODO: Only one item is considered currently - pixmap = model()->data(index).value("iconPixmap").value(); - if (pixmap.isNull()) { - KIcon icon(model()->data(index).value("iconName").toString()); - pixmap = icon.pixmap(itemSize().toSize()); - } +KItemListWidgetCreatorBase *KFileItemListView::defaultWidgetCreator() const +{ + return new KItemListWidgetCreator(); +} + +void KFileItemListView::initializeItemListWidget(KItemListWidget *item) +{ + KStandardItemListView::initializeItemListWidget(item); + + // Make sure that the item has an icon. + QHash data = item->data(); + if (!data.contains("iconName") && data["iconPixmap"].value().isNull()) { + Q_ASSERT(qobject_cast(model())); + KFileItemModel *fileItemModel = static_cast(model()); + + const KFileItem fileItem = fileItemModel->fileItem(item->index()); + QString iconName = fileItem.iconName(); + if (!QIcon::hasThemeIcon(iconName)) { + QMimeDatabase mimeDb; + iconName = mimeDb.mimeTypeForName(fileItem.mimetype()).genericIconName(); } + data.insert("iconName", iconName); + item->setData(data, {"iconName"}); } - - return pixmap; } -void KFileItemListView::initializeItemListWidget(KItemListWidget* item) +void KFileItemListView::onPreviewsShownChanged(bool shown) { - KFileItemListWidget* fileItemListWidget = static_cast(item); + Q_UNUSED(shown) +} - switch (m_itemLayout) { - case IconsLayout: fileItemListWidget->setLayout(KFileItemListWidget::IconsLayout); break; - case CompactLayout: fileItemListWidget->setLayout(KFileItemListWidget::CompactLayout); break; - case DetailsLayout: fileItemListWidget->setLayout(KFileItemListWidget::DetailsLayout); break; - default: Q_ASSERT(false); break; - } +void KFileItemListView::onItemLayoutChanged(ItemLayout current, ItemLayout previous) +{ + KStandardItemListView::onItemLayoutChanged(current, previous); + triggerVisibleIndexRangeUpdate(); } -void KFileItemListView::onModelChanged(KItemModelBase* current, KItemModelBase* previous) +void KFileItemListView::onModelChanged(KItemModelBase *current, KItemModelBase *previous) { - Q_UNUSED(previous); - Q_ASSERT(qobject_cast(current)); + Q_ASSERT(qobject_cast(current)); + KStandardItemListView::onModelChanged(current, previous); - if (m_modelRolesUpdater) { - delete m_modelRolesUpdater; - } + delete m_modelRolesUpdater; + m_modelRolesUpdater = nullptr; - m_modelRolesUpdater = new KFileItemModelRolesUpdater(static_cast(current), this); - const int size = styleOption().iconSize; - m_modelRolesUpdater->setIconSize(QSize(size, size)); + if (current) { + m_modelRolesUpdater = new KFileItemModelRolesUpdater(static_cast(current), this); + m_modelRolesUpdater->setIconSize(availableIconSize()); + m_modelRolesUpdater->setDevicePixelRatio(KItemViewsUtils::devicePixelRatio(this)); + + applyRolesToModel(); + } } void KFileItemListView::onScrollOrientationChanged(Qt::Orientation current, Qt::Orientation previous) { - Q_UNUSED(current); - Q_UNUSED(previous); - updateLayoutOfVisibleItems(); + KStandardItemListView::onScrollOrientationChanged(current, previous); + triggerVisibleIndexRangeUpdate(); } -void KFileItemListView::onItemSizeChanged(const QSizeF& current, const QSizeF& previous) +void KFileItemListView::onItemSizeChanged(const QSizeF ¤t, const QSizeF &previous) { - Q_UNUSED(current); - Q_UNUSED(previous); + Q_UNUSED(current) + Q_UNUSED(previous) triggerVisibleIndexRangeUpdate(); } -void KFileItemListView::onOffsetChanged(qreal current, qreal previous) +void KFileItemListView::onScrollOffsetChanged(qreal current, qreal previous) { - Q_UNUSED(current); - Q_UNUSED(previous); + KStandardItemListView::onScrollOffsetChanged(current, previous); triggerVisibleIndexRangeUpdate(); } -void KFileItemListView::onVisibleRolesChanged(const QHash& current, const QHash& previous) +void KFileItemListView::onVisibleRolesChanged(const QList ¤t, const QList &previous) { - Q_UNUSED(previous); - - Q_ASSERT(qobject_cast(model())); - KFileItemModel* fileItemModel = static_cast(model()); - - // KFileItemModel does not distinct between "visible" and "invisible" roles. - // Add all roles that are mandatory for having a working KFileItemListView: - QSet keys = current.keys().toSet(); - QSet roles = keys; - roles.insert("iconPixmap"); - roles.insert("iconName"); - roles.insert("name"); // TODO: just don't allow to disable it - roles.insert("isDir"); - if (m_itemLayout == DetailsLayout) { - roles.insert("isExpanded"); - roles.insert("expansionLevel"); - } - - fileItemModel->setRoles(roles); - - m_modelRolesUpdater->setRoles(keys); + KStandardItemListView::onVisibleRolesChanged(current, previous); + applyRolesToModel(); } -void KFileItemListView::onStyleOptionChanged(const KItemListStyleOption& current, const KItemListStyleOption& previous) +void KFileItemListView::onStyleOptionChanged(const KItemListStyleOption ¤t, const KItemListStyleOption &previous) { - Q_UNUSED(current); - Q_UNUSED(previous); + KStandardItemListView::onStyleOptionChanged(current, previous); triggerIconSizeUpdate(); } +void KFileItemListView::onSupportsItemExpandingChanged(bool supportsExpanding) +{ + applyRolesToModel(); + KStandardItemListView::onSupportsItemExpandingChanged(supportsExpanding); + triggerVisibleIndexRangeUpdate(); +} + void KFileItemListView::onTransactionBegin() { - m_modelRolesUpdater->setPaused(true); + if (m_modelRolesUpdater) { + m_modelRolesUpdater->setPaused(true); + } } void KFileItemListView::onTransactionEnd() { + if (!m_modelRolesUpdater) { + return; + } + // Only unpause the model-roles-updater if no timer is active. If one // timer is still active the model-roles-updater will be unpaused later as // soon as the timer has been exceeded. - const bool timerActive = m_updateVisibleIndexRangeTimer->isActive() || - m_updateIconSizeTimer->isActive(); + const bool timerActive = m_updateVisibleIndexRangeTimer->isActive() || m_updateIconSizeTimer->isActive(); if (!timerActive) { m_modelRolesUpdater->setPaused(false); } } -void KFileItemListView::resizeEvent(QGraphicsSceneResizeEvent* event) +void KFileItemListView::resizeEvent(QGraphicsSceneResizeEvent *event) { - KItemListView::resizeEvent(event); + KStandardItemListView::resizeEvent(event); triggerVisibleIndexRangeUpdate(); } -void KFileItemListView::slotItemsRemoved(const KItemRangeList& itemRanges) +void KFileItemListView::focusInEvent(QFocusEvent *event) +{ + Q_UNUSED(event) + updateSelectedWidgets(); +} + +void KFileItemListView::focusOutEvent(QFocusEvent *event) +{ + Q_UNUSED(event) + updateSelectedWidgets(); +} + +void KFileItemListView::updateSelectedWidgets() { - KItemListView::slotItemsRemoved(itemRanges); - updateTimersInterval(); + const auto visibleWidgets = visibleItemListWidgets(); + for (KItemListWidget *widget : visibleWidgets) { + if (widget->isSelected()) { + auto w = qobject_cast(widget); + if (w) { + w->forceUpdate(); + } + } + } +} + +void KFileItemListView::slotItemsRemoved(const KItemRangeList &itemRanges) +{ + KStandardItemListView::slotItemsRemoved(itemRanges); +} + +void KFileItemListView::slotSortRoleChanged(const QByteArray ¤t, const QByteArray &previous) +{ + const QByteArray sortRole = model()->sortRole(); + if (!visibleRoles().contains(sortRole)) { + applyRolesToModel(); + } + + KStandardItemListView::slotSortRoleChanged(current, previous); } void KFileItemListView::triggerVisibleIndexRangeUpdate() { + if (!model()) { + return; + } m_modelRolesUpdater->setPaused(true); - m_updateVisibleIndexRangeTimer->start(); + + // If the icon size has been changed recently, wait until + // m_updateIconSizeTimer expires. + if (!m_updateIconSizeTimer->isActive()) { + m_updateVisibleIndexRangeTimer->start(); + } } void KFileItemListView::updateVisibleIndexRange() @@ -349,25 +390,23 @@ void KFileItemListView::updateVisibleIndexRange() const int index = firstVisibleIndex(); const int count = lastVisibleIndex() - index + 1; + m_modelRolesUpdater->setMaximumVisibleItems(maximumVisibleItems()); m_modelRolesUpdater->setVisibleIndexRange(index, count); - - if (m_updateIconSizeTimer->isActive()) { - // If the icon-size update is pending do an immediate update - // of the icon-size before unpausing m_modelRolesUpdater. This prevents - // an unnecessary expensive recreation of all previews afterwards. - m_updateIconSizeTimer->stop(); - const KItemListStyleOption& option = styleOption(); - m_modelRolesUpdater->setIconSize(QSize(option.iconSize, option.iconSize)); - } - m_modelRolesUpdater->setPaused(isTransactionActive()); - updateTimersInterval(); } void KFileItemListView::triggerIconSizeUpdate() { + if (!model()) { + return; + } m_modelRolesUpdater->setPaused(true); m_updateIconSizeTimer->start(); + + // The visible index range will be updated when m_updateIconSizeTimer expires. + // Stop m_updateVisibleIndexRangeTimer to prevent an expensive re-generation + // of all previews (note that the user might change the icon size again soon). + m_updateVisibleIndexRangeTimer->stop(); } void KFileItemListView::updateIconSize() @@ -376,71 +415,60 @@ void KFileItemListView::updateIconSize() return; } - const KItemListStyleOption& option = styleOption(); - m_modelRolesUpdater->setIconSize(QSize(option.iconSize, option.iconSize)); - - if (m_updateVisibleIndexRangeTimer->isActive()) { - // If the visibility-index-range update is pending do an immediate update - // of the range before unpausing m_modelRolesUpdater. This prevents - // an unnecessary expensive recreation of all previews afterwards. - m_updateVisibleIndexRangeTimer->stop(); - const int index = firstVisibleIndex(); - const int count = lastVisibleIndex() - index + 1; - m_modelRolesUpdater->setVisibleIndexRange(index, count); - } + m_modelRolesUpdater->setIconSize(availableIconSize()); + m_modelRolesUpdater->setDevicePixelRatio(KItemViewsUtils::devicePixelRatio(this)); + + // Update the visible index range (which has most likely changed after the + // icon size change) before unpausing m_modelRolesUpdater. + const int index = firstVisibleIndex(); + const int count = lastVisibleIndex() - index + 1; + m_modelRolesUpdater->setVisibleIndexRange(index, count); m_modelRolesUpdater->setPaused(isTransactionActive()); - updateTimersInterval(); } -QSizeF KFileItemListView::visibleRoleSizeHint(int index, const QByteArray& role) const +void KFileItemListView::applyRolesToModel() { - const KItemListStyleOption& option = styleOption(); - - qreal width = m_minimumRolesWidths.value(role, 0); - const qreal height = option.margin * 2 + option.fontMetrics.height(); - - const QVariant value = model()->data(index).value(role); - const QString text = value.toString(); - if (!text.isEmpty()) { - width = qMax(width, qreal(option.margin * 2 + option.fontMetrics.width(text))); + if (!model()) { + return; } - return QSizeF(width, height); -} + Q_ASSERT(qobject_cast(model())); + KFileItemModel *fileItemModel = static_cast(model()); -void KFileItemListView::updateLayoutOfVisibleItems() -{ - foreach (KItemListWidget* widget, visibleItemListWidgets()) { - initializeItemListWidget(widget); - } - triggerVisibleIndexRangeUpdate(); -} - -void KFileItemListView::updateTimersInterval() -{ - if (!model()) { - return; + // KFileItemModel does not distinct between "visible" and "invisible" roles. + // Add all roles that are mandatory for having a working KFileItemListView: + const auto visibleRoles = this->visibleRoles(); + auto roles = QSet(visibleRoles.constBegin(), visibleRoles.constEnd()); + roles.insert("iconPixmap"); + roles.insert("iconName"); + roles.insert("text"); + roles.insert("isDir"); + roles.insert("isLink"); + roles.insert("isHidden"); + if (supportsItemExpanding()) { + roles.insert("isExpanded"); + roles.insert("isExpandable"); + roles.insert("expandedParentsCount"); } - // The ShortInterval is used for cases like switching the directory: If the - // model is empty and filled later the creation of the previews should be done - // as soon as possible. The LongInterval is used when the model already contains - // items and assures that operations like zooming don't result in too many temporary - // recreations of the previews. + // Assure that the role that is used for sorting will be determined + roles.insert(fileItemModel->sortRole()); - const int interval = (model()->count() <= 0) ? ShortInterval : LongInterval; - m_updateVisibleIndexRangeTimer->setInterval(interval); - m_updateIconSizeTimer->setInterval(interval); + fileItemModel->setRoles(roles); + m_modelRolesUpdater->setRoles(roles); } -void KFileItemListView::updateMinimumRolesWidths() +QSize KFileItemListView::availableIconSize() const { - m_minimumRolesWidths.clear(); + const KItemListStyleOption &option = styleOption(); + const int iconSize = option.iconSize; + if (itemLayout() == IconsLayout) { + const int maxIconWidth = itemSize().width() - 2 * option.padding; + return QSize(maxIconWidth, iconSize); + } - const KItemListStyleOption& option = styleOption(); - const QString sizeText = QLatin1String("888888") + i18nc("@item:intable", "items"); - m_minimumRolesWidths.insert("size", option.fontMetrics.width(sizeText)); + return QSize(iconSize, iconSize); } -#include "kfileitemlistview.moc" +#include "moc_kfileitemlistview.cpp"