#include "kfileitemlistview.h"
-#include "kfileitemmodelrolesupdater.h"
#include "kfileitemlistwidget.h"
#include "kfileitemmodel.h"
-#include <KLocale>
-#include <KStringHandler>
+#include "kfileitemmodelrolesupdater.h"
#include "private/kpixmapmodifier.h"
-#include <KDebug>
-#include <KIcon>
-#include <KTextEdit>
+#include <KIconLoader>
+#include <QGraphicsScene>
+#include <QGraphicsView>
#include <QPainter>
-#include <QTextLine>
#include <QTimer>
// #define KFILEITEMLISTVIEW_DEBUG
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) :
KStandardItemListView(parent),
- m_modelRolesUpdater(0),
- m_updateVisibleIndexRangeTimer(0),
- m_updateIconSizeTimer(0)
+ m_modelRolesUpdater(nullptr),
+ m_updateVisibleIndexRangeTimer(nullptr),
+ m_updateIconSizeTimer(nullptr)
{
setAcceptDrops(true);
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);
- setVisibleRoles(QList<QByteArray>() << "text");
+ setVisibleRoles({"text"});
}
KFileItemListView::~KFileItemListView()
return m_modelRolesUpdater ? m_modelRolesUpdater->enabledPlugins() : QStringList();
}
-QPixmap KFileItemListView::createDragPixmap(const QSet<int>& indexes) const
+void KFileItemListView::setLocalFileSizePreviewLimit(const qlonglong size)
+{
+ if (m_modelRolesUpdater) {
+ m_modelRolesUpdater->setLocalFileSizePreviewLimit(size);
+ }
+}
+
+qlonglong KFileItemListView::localFileSizePreviewLimit() const
+{
+ return m_modelRolesUpdater ? m_modelRolesUpdater->localFileSizePreviewLimit() : 0;
+}
+
+QPixmap KFileItemListView::createDragPixmap(const KItemSet& indexes) const
{
if (!model()) {
return QPixmap();
const int itemCount = indexes.count();
Q_ASSERT(itemCount > 0);
+ if (itemCount == 1) {
+ return KItemListView::createDragPixmap(indexes);
+ }
// 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.
yCount = xCount;
}
+ const qreal dpr = scene()->views()[0]->devicePixelRatio();
// Draw the selected items into the grid cells.
- QPixmap dragPixmap(xCount * size + xCount, yCount * size + yCount);
+ 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;
- QSetIterator<int> it(indexes);
- while (it.hasNext()) {
- const int index = it.next();
+ for (int index : indexes) {
QPixmap pixmap = model()->data(index).value("iconPixmap").value<QPixmap>();
if (pixmap.isNull()) {
- KIcon icon(model()->data(index).value("iconName").toString());
+ QIcon icon = QIcon::fromTheme(model()->data(index).value("iconName").toString());
pixmap = icon.pixmap(size, size);
} else {
- KPixmapModifier::scale(pixmap, QSize(size, size));
+ KPixmapModifier::scale(pixmap, QSize(size, size) * dpr);
}
painter.drawPixmap(x, y, pixmap);
return new KItemListWidgetCreator<KFileItemListWidget>();
}
+void KFileItemListView::initializeItemListWidget(KItemListWidget* item)
+{
+ KStandardItemListView::initializeItemListWidget(item);
+
+ // 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);
+ Q_UNUSED(shown)
}
void KFileItemListView::onItemLayoutChanged(ItemLayout current, ItemLayout previous)
{
- if (previous == DetailsLayout || current == DetailsLayout) {
- // The details-layout requires some invisible roles that
- // must be added to the model if the new layout is "details".
- // If the old layout was "details" the roles will get removed.
- applyRolesToModel();
- }
KStandardItemListView::onItemLayoutChanged(current, previous);
triggerVisibleIndexRangeUpdate();
}
KStandardItemListView::onModelChanged(current, previous);
delete m_modelRolesUpdater;
- m_modelRolesUpdater = 0;
+ m_modelRolesUpdater = nullptr;
if (current) {
m_modelRolesUpdater = new KFileItemModelRolesUpdater(static_cast<KFileItemModel*>(current), this);
void KFileItemListView::onItemSizeChanged(const QSizeF& current, const QSizeF& previous)
{
- Q_UNUSED(current);
- Q_UNUSED(previous);
+ Q_UNUSED(current)
+ Q_UNUSED(previous)
triggerVisibleIndexRangeUpdate();
}
void KFileItemListView::slotItemsRemoved(const KItemRangeList& itemRanges)
{
KStandardItemListView::slotItemsRemoved(itemRanges);
- updateTimersInterval();
}
void KFileItemListView::slotSortRoleChanged(const QByteArray& current, const QByteArray& previous)
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();
- m_modelRolesUpdater->setIconSize(availableIconSize());
- }
-
m_modelRolesUpdater->setPaused(isTransactionActive());
- updateTimersInterval();
}
void KFileItemListView::triggerIconSizeUpdate()
}
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()
m_modelRolesUpdater->setIconSize(availableIconSize());
- 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);
- }
+ // 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();
-}
-
-void KFileItemListView::updateTimersInterval()
-{
- if (!model()) {
- return;
- }
-
- // 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.
-
- const int interval = (model()->count() <= 0) ? ShortInterval : LongInterval;
- m_updateVisibleIndexRangeTimer->setInterval(interval);
- m_updateIconSizeTimer->setInterval(interval);
}
void KFileItemListView::applyRolesToModel()
roles.insert("iconName");
roles.insert("text");
roles.insert("isDir");
+ roles.insert("isLink");
+ roles.insert("isHidden");
if (supportsItemExpanding()) {
roles.insert("isExpanded");
roles.insert("isExpandable");
return QSize(iconSize, iconSize);
}
-#include "kfileitemlistview.moc"
projects / dolphin.git / blobdiff