#include "kfileitemlistview.h"
-#include "kitemlistgroupheader.h"
#include "kfileitemmodelrolesupdater.h"
#include "kfileitemlistwidget.h"
#include "kfileitemmodel.h"
-#include <KLocale>
-#include <KStringHandler>
+#include "private/kpixmapmodifier.h"
-#include <KDebug>
-#include <KIcon>
+#include <QIcon>
+#include <KIconLoader>
-#include <QTextLine>
+#include <QPainter>
#include <QTimer>
+#include <QGraphicsScene>
+#include <QGraphicsView>
-#define KFILEITEMLISTVIEW_DEBUG
+// #define KFILEITEMLISTVIEW_DEBUG
namespace {
+ // If the visible index range changes, KFileItemModelRolesUpdater is not
+ // informed immediatetly, 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
+ // chaning the zoom level.
const int LongInterval = 300;
}
KFileItemListView::KFileItemListView(QGraphicsWidget* parent) :
- KItemListView(parent),
- m_itemLayout(IconsLayout),
+ KStandardItemListView(parent),
m_modelRolesUpdater(0),
m_updateVisibleIndexRangeTimer(0),
- m_updateIconSizeTimer(0),
- m_minimumRolesWidths()
+ m_updateIconSizeTimer(0)
{
setAcceptDrops(true);
setScrollOrientation(Qt::Vertical);
- setWidgetCreator(new KItemListWidgetCreator<KFileItemListWidget>());
- setGroupHeaderCreator(new KItemListGroupHeaderCreator<KItemListGroupHeader>());
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<QByteArray, QVariant> 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);
+QPixmap KFileItemListView::createDragPixmap(const KItemSet& indexes) const
+{
+ if (!model()) {
+ return QPixmap();
}
- 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;
-
- foreach (const QByteArray& role, visibleRoles()) {
- const QString text = values[role].toString();
- const qreal requiredWidth = option.fontMetrics.width(text);
- maximumRequiredWidth = qMax(maximumRequiredWidth, requiredWidth);
- }
+ const int itemCount = indexes.count();
+ Q_ASSERT(itemCount > 0);
+ if (itemCount == 1) {
+ return KItemListView::createDragPixmap(indexes);
+ }
- 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);
+ // 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;
}
- 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);
+ if (itemCount < xCount) {
+ xCount = itemCount;
}
- default:
- Q_ASSERT(false);
- break;
+ int yCount = itemCount / xCount;
+ if (itemCount % xCount != 0) {
+ ++yCount;
+ }
+ if (yCount > xCount) {
+ yCount = xCount;
}
- return QSize();
-}
+ const qreal dpr = scene()->views()[0]->devicePixelRatio();
+ // 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;
+
+ foreach (int index, indexes) {
+ QPixmap pixmap = model()->data(index).value("iconPixmap").value<QPixmap>();
+ if (pixmap.isNull()) {
+ QIcon icon = QIcon::fromTheme(model()->data(index).value("iconName").toString());
+ pixmap = icon.pixmap(size, size);
+ } else {
+ KPixmapModifier::scale(pixmap, QSize(size, size) * dpr);
+ }
-QHash<QByteArray, QSizeF> KFileItemListView::visibleRoleSizes() const
-{
- QElapsedTimer timer;
- timer.start();
-
- QHash<QByteArray, QSizeF> sizes;
-
- const int itemCount = model()->count();
- for (int i = 0; i < itemCount; ++i) {
- foreach (const QByteArray& visibleRole, visibleRoles()) {
- QSizeF maxSize = sizes.value(visibleRole, QSizeF(0, 0));
- const QSizeF itemSize = visibleRoleSizeHint(i, visibleRole);
- maxSize = maxSize.expandedTo(itemSize);
- sizes.insert(visibleRole, maxSize);
+ painter.drawPixmap(x, y, pixmap);
+
+ 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<int>& indexes) const
+KItemListWidgetCreatorBase* KFileItemListView::defaultWidgetCreator() const
{
- QPixmap pixmap;
-
- if (model()) {
- QSetIterator<int> it(indexes);
- while (it.hasNext()) {
- const int index = it.next();
- // TODO: Only one item is considered currently
- pixmap = model()->data(index).value("iconPixmap").value<QPixmap>();
- if (pixmap.isNull()) {
- KIcon icon(model()->data(index).value("iconName").toString());
- pixmap = icon.pixmap(itemSize().toSize());
- }
- }
- }
-
- return pixmap;
+ return new KItemListWidgetCreator<KFileItemListWidget>();
}
void KFileItemListView::initializeItemListWidget(KItemListWidget* item)
{
- KFileItemListWidget* fileItemListWidget = static_cast<KFileItemListWidget*>(item);
+ KStandardItemListView::initializeItemListWidget(item);
- 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;
+ // Make sure that the item has an icon.
+ QHash<QByteArray, QVariant> data = item->data();
+ if (!data.contains("iconName") && data["iconPixmap"].value<QPixmap>().isNull()) {
+ Q_ASSERT(qobject_cast<KFileItemModel*>(model()));
+ KFileItemModel* fileItemModel = static_cast<KFileItemModel*>(model());
+
+ const KFileItem fileItem = fileItemModel->fileItem(item->index());
+ data.insert("iconName", fileItem.iconName());
+ item->setData(data, {"iconName"});
}
}
+void KFileItemListView::onPreviewsShownChanged(bool shown)
+{
+ Q_UNUSED(shown);
+}
+
+void KFileItemListView::onItemLayoutChanged(ItemLayout current, ItemLayout previous)
+{
+ KStandardItemListView::onItemLayoutChanged(current, previous);
+ triggerVisibleIndexRangeUpdate();
+}
+
void KFileItemListView::onModelChanged(KItemModelBase* current, KItemModelBase* previous)
{
- Q_UNUSED(previous);
Q_ASSERT(qobject_cast<KFileItemModel*>(current));
+ KStandardItemListView::onModelChanged(current, previous);
- if (m_modelRolesUpdater) {
- delete m_modelRolesUpdater;
- }
+ delete m_modelRolesUpdater;
+ m_modelRolesUpdater = 0;
+
+ if (current) {
+ m_modelRolesUpdater = new KFileItemModelRolesUpdater(static_cast<KFileItemModel*>(current), this);
+ m_modelRolesUpdater->setIconSize(availableIconSize());
- m_modelRolesUpdater = new KFileItemModelRolesUpdater(static_cast<KFileItemModel*>(current), this);
- const int size = styleOption().iconSize;
- m_modelRolesUpdater->setIconSize(QSize(size, size));
+ 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)
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 QList<QByteArray>& current, const QList<QByteArray>& previous)
{
- Q_UNUSED(previous);
-
- Q_ASSERT(qobject_cast<KFileItemModel*>(model()));
- KFileItemModel* fileItemModel = static_cast<KFileItemModel*>(model());
-
- // KFileItemModel does not distinct between "visible" and "invisible" roles.
- // Add all roles that are mandatory for having a working KFileItemListView:
- QSet<QByteArray> keys = current.toSet();
- QSet<QByteArray> 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)
{
- 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.
void KFileItemListView::resizeEvent(QGraphicsSceneResizeEvent* event)
{
- KItemListView::resizeEvent(event);
+ KStandardItemListView::resizeEvent(event);
triggerVisibleIndexRangeUpdate();
}
void KFileItemListView::slotItemsRemoved(const KItemRangeList& itemRanges)
{
- KItemListView::slotItemsRemoved(itemRanges);
- updateTimersInterval();
+ KStandardItemListView::slotItemsRemoved(itemRanges);
+}
+
+void KFileItemListView::slotSortRoleChanged(const QByteArray& current, 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()
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()
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());
+
+ // 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);
-}
-
-void KFileItemListView::updateLayoutOfVisibleItems()
-{
- foreach (KItemListWidget* widget, visibleItemListWidgets()) {
- initializeItemListWidget(widget);
- }
- triggerVisibleIndexRangeUpdate();
-}
+ Q_ASSERT(qobject_cast<KFileItemModel*>(model()));
+ KFileItemModel* fileItemModel = static_cast<KFileItemModel*>(model());
-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:
+ QSet<QByteArray> roles = visibleRoles().toSet();
+ roles.insert("iconPixmap");
+ roles.insert("iconName");
+ roles.insert("text");
+ roles.insert("isDir");
+ roles.insert("isLink");
+ 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 QString sizeText = QLatin1String("888888") + i18nc("@item:intable", "items");
- m_minimumRolesWidths.insert("size", option.fontMetrics.width(sizeText));
+ const int iconSize = option.iconSize;
+ if (itemLayout() == IconsLayout) {
+ const int maxIconWidth = itemSize().width() - 2 * option.padding;
+ return QSize(maxIconWidth, iconSize);
+ }
+
+ return QSize(iconSize, iconSize);
}
-#include "kfileitemlistview.moc"
projects / dolphin.git / blobdiff