1167 lines
38 KiB
C++
1167 lines
38 KiB
C++
/*
|
|
Gwenview: an image viewer
|
|
Copyright 2007 Aurélien Gâteau <agateau@kde.org>
|
|
|
|
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.
|
|
|
|
*/
|
|
#include "thumbnailview.h"
|
|
|
|
// STL
|
|
#include <cmath>
|
|
|
|
// Qt
|
|
#include <QApplication>
|
|
#include <QDateTime>
|
|
#include <QDrag>
|
|
#include <QDragEnterEvent>
|
|
#include <QDropEvent>
|
|
#include <QMimeData>
|
|
#include <QPainter>
|
|
#include <QPointer>
|
|
#include <QQueue>
|
|
#include <QScrollBar>
|
|
#include <QScroller>
|
|
#include <QTimeLine>
|
|
#include <QTimer>
|
|
#include <QWindow>
|
|
|
|
// KF
|
|
#include <KDirLister>
|
|
#include <KDirModel>
|
|
#include <KIconLoader>
|
|
#include <KPixmapSequence>
|
|
#include <KPixmapSequenceLoader>
|
|
#include <KUrlMimeData>
|
|
|
|
// Local
|
|
#include "abstractdocumentinfoprovider.h"
|
|
#include "abstractthumbnailviewhelper.h"
|
|
#include "dragpixmapgenerator.h"
|
|
#include "gwenview_lib_debug.h"
|
|
#include "gwenviewconfig.h"
|
|
#include "mimetypeutils.h"
|
|
#include "urlutils.h"
|
|
#include <lib/gvdebug.h>
|
|
#include <lib/scrollerutils.h>
|
|
#include <lib/semanticinfo/sorteddirmodel.h>
|
|
#include <lib/thumbnailprovider/thumbnailprovider.h>
|
|
#include <lib/touch/touch.h>
|
|
|
|
namespace Gwenview
|
|
{
|
|
#undef ENABLE_LOG
|
|
#undef LOG
|
|
// #define ENABLE_LOG
|
|
#ifdef ENABLE_LOG
|
|
#define LOG(x) // qCDebug(GWENVIEW_LIB_LOG) << x
|
|
#else
|
|
#define LOG(x) ;
|
|
#endif
|
|
|
|
/** How many msec to wait before starting to smooth thumbnails */
|
|
const int SMOOTH_DELAY = 500;
|
|
|
|
const int WHEEL_ZOOM_MULTIPLIER = 4;
|
|
|
|
static KFileItem fileItemForIndex(const QModelIndex &index)
|
|
{
|
|
if (!index.isValid()) {
|
|
LOG("Invalid index");
|
|
return {};
|
|
}
|
|
QVariant data = index.data(KDirModel::FileItemRole);
|
|
return qvariant_cast<KFileItem>(data);
|
|
}
|
|
|
|
static QUrl urlForIndex(const QModelIndex &index)
|
|
{
|
|
KFileItem item = fileItemForIndex(index);
|
|
return item.isNull() ? QUrl() : item.url();
|
|
}
|
|
|
|
struct Thumbnail {
|
|
Thumbnail(const QPersistentModelIndex &index_, const QDateTime &mtime)
|
|
: mIndex(index_)
|
|
, mModificationTime(mtime)
|
|
, mFileSize(0)
|
|
, mRough(true)
|
|
, mWaitingForThumbnail(true)
|
|
{
|
|
}
|
|
|
|
Thumbnail()
|
|
: mFileSize(0)
|
|
, mRough(true)
|
|
, mWaitingForThumbnail(true)
|
|
{
|
|
}
|
|
|
|
/**
|
|
* Init the thumbnail based on a icon
|
|
*/
|
|
void initAsIcon(const QPixmap &pix)
|
|
{
|
|
mGroupPix = pix;
|
|
int largeGroupSize = ThumbnailGroup::pixelSize(ThumbnailGroup::Large);
|
|
mFullSize = QSize(largeGroupSize, largeGroupSize);
|
|
}
|
|
|
|
bool isGroupPixAdaptedForSize(int size) const
|
|
{
|
|
if (mWaitingForThumbnail) {
|
|
return false;
|
|
}
|
|
if (mGroupPix.isNull()) {
|
|
return false;
|
|
}
|
|
const int groupSize = qMax(mGroupPix.width(), mGroupPix.height());
|
|
if (groupSize >= size) {
|
|
return true;
|
|
}
|
|
|
|
// groupSize is less than size, but this may be because the full image
|
|
// is the same size as groupSize
|
|
return groupSize == qMax(mFullSize.width(), mFullSize.height());
|
|
}
|
|
|
|
void prepareForRefresh(const QDateTime &mtime)
|
|
{
|
|
mModificationTime = mtime;
|
|
mFileSize = 0;
|
|
mGroupPix = QPixmap();
|
|
mAdjustedPix = QPixmap();
|
|
mFullSize = QSize();
|
|
mRealFullSize = QSize();
|
|
mRough = true;
|
|
mWaitingForThumbnail = true;
|
|
}
|
|
|
|
QPersistentModelIndex mIndex;
|
|
QDateTime mModificationTime;
|
|
/// The pix loaded from .thumbnails/{large,normal}
|
|
QPixmap mGroupPix;
|
|
/// Scaled version of mGroupPix, adjusted to ThumbnailView::thumbnailSize
|
|
QPixmap mAdjustedPix;
|
|
/// Size of the full image
|
|
QSize mFullSize;
|
|
/// Real size of the full image, invalid unless the thumbnail
|
|
/// represents a raster image (not an icon)
|
|
QSize mRealFullSize;
|
|
/// File size of the full image
|
|
KIO::filesize_t mFileSize;
|
|
/// Whether mAdjustedPix represents has been scaled using fast or smooth
|
|
/// transformation
|
|
bool mRough;
|
|
/// Set to true if mGroupPix should be replaced with a real thumbnail
|
|
bool mWaitingForThumbnail;
|
|
};
|
|
|
|
using ThumbnailForUrl = QHash<QUrl, Thumbnail>;
|
|
using UrlQueue = QQueue<QUrl>;
|
|
using PersistentModelIndexSet = QSet<QPersistentModelIndex>;
|
|
|
|
class WindowScaleWatcher : public QObject
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
void setWindow(QWindow *window)
|
|
{
|
|
if (mWindow == window) {
|
|
return;
|
|
}
|
|
if (mWindow) {
|
|
mWindow->removeEventFilter(this);
|
|
}
|
|
mWindow = window;
|
|
if (mWindow) {
|
|
mWindow->installEventFilter(this);
|
|
updateDevicePixelRatio();
|
|
}
|
|
}
|
|
|
|
protected:
|
|
bool eventFilter(QObject *watched, QEvent *event) override
|
|
{
|
|
if (event->type() == QEvent::DevicePixelRatioChange) {
|
|
updateDevicePixelRatio();
|
|
}
|
|
return QObject::eventFilter(watched, event);
|
|
}
|
|
|
|
private:
|
|
void updateDevicePixelRatio()
|
|
{
|
|
if (mWindow->devicePixelRatio() != mLastDevicePixelRatio) {
|
|
Q_EMIT scaleChanged();
|
|
mLastDevicePixelRatio = mWindow->devicePixelRatio();
|
|
}
|
|
}
|
|
|
|
Q_SIGNALS:
|
|
void scaleChanged();
|
|
|
|
private:
|
|
QPointer<QWindow> mWindow;
|
|
// we don't know what dpr the widget was using
|
|
// before getting a window as it comes from the primary screen
|
|
// always trigger on the first set
|
|
qreal mLastDevicePixelRatio = -1;
|
|
};
|
|
|
|
struct ThumbnailViewPrivate {
|
|
ThumbnailView *q;
|
|
ThumbnailView::ThumbnailScaleMode mScaleMode;
|
|
QSize mThumbnailSize;
|
|
int mThumbnailLogicalWidth = 0;
|
|
qreal mThumbnailAspectRatio;
|
|
AbstractDocumentInfoProvider *mDocumentInfoProvider;
|
|
AbstractThumbnailViewHelper *mThumbnailViewHelper;
|
|
ThumbnailForUrl mThumbnailForUrl;
|
|
QTimer mScheduledThumbnailGenerationTimer;
|
|
WindowScaleWatcher mWindowScaleWatcher;
|
|
|
|
UrlQueue mSmoothThumbnailQueue;
|
|
QTimer mSmoothThumbnailTimer;
|
|
|
|
QPixmap mWaitingThumbnail;
|
|
QPointer<ThumbnailProvider> mThumbnailProvider;
|
|
|
|
PersistentModelIndexSet mBusyIndexSet;
|
|
KPixmapSequence mBusySequence;
|
|
QTimeLine *mBusyAnimationTimeLine;
|
|
|
|
bool mCreateThumbnailsForRemoteUrls;
|
|
|
|
QScroller *mScroller;
|
|
Touch *mTouch;
|
|
|
|
bool loading = false;
|
|
|
|
void setupBusyAnimation()
|
|
{
|
|
mBusySequence = KPixmapSequenceLoader::load(QStringLiteral("process-working"), 22);
|
|
mBusyAnimationTimeLine = new QTimeLine(100 * mBusySequence.frameCount(), q);
|
|
mBusyAnimationTimeLine->setEasingCurve(QEasingCurve::Linear);
|
|
mBusyAnimationTimeLine->setEndFrame(mBusySequence.frameCount() - 1);
|
|
mBusyAnimationTimeLine->setLoopCount(0);
|
|
QObject::connect(mBusyAnimationTimeLine, &QTimeLine::frameChanged, q, &ThumbnailView::updateBusyIndexes);
|
|
}
|
|
|
|
void scheduleThumbnailGeneration()
|
|
{
|
|
if (mThumbnailProvider) {
|
|
mThumbnailProvider->removePendingItems();
|
|
}
|
|
mSmoothThumbnailQueue.clear();
|
|
if (!mScheduledThumbnailGenerationTimer.isActive()) {
|
|
mScheduledThumbnailGenerationTimer.start();
|
|
}
|
|
}
|
|
|
|
void updateThumbnailForModifiedDocument(const QModelIndex &index)
|
|
{
|
|
Q_ASSERT(mDocumentInfoProvider);
|
|
KFileItem item = fileItemForIndex(index);
|
|
QUrl url = item.url();
|
|
ThumbnailGroup::Enum group = ThumbnailGroup::fromPixelSize(mThumbnailSize.width());
|
|
QPixmap pix;
|
|
QSize fullSize;
|
|
mDocumentInfoProvider->thumbnailForDocument(url, group, &pix, &fullSize);
|
|
mThumbnailForUrl[url] = Thumbnail(QPersistentModelIndex(index), QDateTime::currentDateTime());
|
|
q->setThumbnail(item, pix, fullSize, 0);
|
|
}
|
|
|
|
void appendItemsToThumbnailProvider(const KFileItemList &list)
|
|
{
|
|
if (mThumbnailProvider) {
|
|
ThumbnailGroup::Enum group = ThumbnailGroup::fromPixelSize(mThumbnailSize.width());
|
|
mThumbnailProvider->setThumbnailGroup(group);
|
|
mThumbnailProvider->appendItems(list);
|
|
}
|
|
}
|
|
|
|
void roughAdjustThumbnail(Thumbnail *thumbnail)
|
|
{
|
|
const QPixmap &mGroupPix = thumbnail->mGroupPix;
|
|
const int groupSize = qMax(mGroupPix.width(), mGroupPix.height());
|
|
const int fullSize = qMax(thumbnail->mFullSize.width(), thumbnail->mFullSize.height());
|
|
if (fullSize == groupSize && mGroupPix.height() <= mThumbnailSize.height() && mGroupPix.width() <= mThumbnailSize.width()) {
|
|
thumbnail->mAdjustedPix = mGroupPix;
|
|
thumbnail->mRough = false;
|
|
} else {
|
|
thumbnail->mAdjustedPix = scale(mGroupPix, Qt::FastTransformation);
|
|
thumbnail->mRough = true;
|
|
}
|
|
}
|
|
|
|
void initDragPixmap(QDrag *drag, const QModelIndexList &indexes)
|
|
{
|
|
const int thumbCount = qMin(indexes.count(), int(DragPixmapGenerator::MaxCount));
|
|
QList<QPixmap> lst;
|
|
for (int row = 0; row < thumbCount; ++row) {
|
|
const QUrl url = urlForIndex(indexes[row]);
|
|
lst << mThumbnailForUrl.value(url).mAdjustedPix;
|
|
}
|
|
DragPixmapGenerator::DragPixmap dragPixmap = DragPixmapGenerator::generate(lst, indexes.count());
|
|
drag->setPixmap(dragPixmap.pix);
|
|
drag->setHotSpot(dragPixmap.hotSpot);
|
|
}
|
|
|
|
QPixmap scale(const QPixmap &pix, Qt::TransformationMode transformationMode)
|
|
{
|
|
switch (mScaleMode) {
|
|
case ThumbnailView::ScaleToFit:
|
|
return pix.scaled(mThumbnailSize.width(), mThumbnailSize.height(), Qt::KeepAspectRatio, transformationMode);
|
|
case ThumbnailView::ScaleToSquare: {
|
|
int minSize = qMin(pix.width(), pix.height());
|
|
QPixmap pix2 = pix.copy((pix.width() - minSize) / 2, (pix.height() - minSize) / 2, minSize, minSize);
|
|
return pix2.scaled(mThumbnailSize.width(), mThumbnailSize.height(), Qt::KeepAspectRatio, transformationMode);
|
|
}
|
|
case ThumbnailView::ScaleToHeight:
|
|
return pix.scaledToHeight(mThumbnailSize.height(), transformationMode);
|
|
case ThumbnailView::ScaleToWidth:
|
|
return pix.scaledToWidth(mThumbnailSize.width(), transformationMode);
|
|
}
|
|
// Keep compiler happy
|
|
Q_ASSERT(0);
|
|
return {};
|
|
}
|
|
};
|
|
|
|
ThumbnailView::ThumbnailView(QWidget *parent)
|
|
: QListView(parent)
|
|
, d(new ThumbnailViewPrivate)
|
|
{
|
|
d->q = this;
|
|
d->mScaleMode = ScaleToFit;
|
|
d->mThumbnailViewHelper = nullptr;
|
|
d->mDocumentInfoProvider = nullptr;
|
|
d->mThumbnailProvider = nullptr;
|
|
// Init to some stupid value so that the first call to setThumbnailSize()
|
|
// is not ignored (do not use 0 in case someone try to divide by
|
|
// mThumbnailSize...)
|
|
d->mThumbnailSize = QSize(1, 1);
|
|
d->mThumbnailAspectRatio = 1;
|
|
d->mCreateThumbnailsForRemoteUrls = true;
|
|
|
|
setFrameShape(QFrame::NoFrame);
|
|
setViewMode(QListView::IconMode);
|
|
setResizeMode(QListView::Adjust);
|
|
setDragEnabled(true);
|
|
setAcceptDrops(true);
|
|
setDropIndicatorShown(true);
|
|
setUniformItemSizes(true);
|
|
setEditTriggers(QAbstractItemView::EditKeyPressed);
|
|
|
|
d->setupBusyAnimation();
|
|
|
|
setVerticalScrollMode(ScrollPerPixel);
|
|
setHorizontalScrollMode(ScrollPerPixel);
|
|
|
|
d->mScheduledThumbnailGenerationTimer.setSingleShot(true);
|
|
d->mScheduledThumbnailGenerationTimer.setInterval(500);
|
|
connect(&d->mScheduledThumbnailGenerationTimer, &QTimer::timeout, this, &ThumbnailView::generateThumbnailsForItems);
|
|
|
|
d->mSmoothThumbnailTimer.setSingleShot(true);
|
|
connect(&d->mSmoothThumbnailTimer, &QTimer::timeout, this, &ThumbnailView::smoothNextThumbnail);
|
|
|
|
setContextMenuPolicy(Qt::CustomContextMenu);
|
|
connect(this, &ThumbnailView::customContextMenuRequested, this, &ThumbnailView::showContextMenu);
|
|
|
|
connect(this, &ThumbnailView::activated, this, &ThumbnailView::emitIndexActivatedIfNoModifiers);
|
|
|
|
connect(&d->mWindowScaleWatcher, &WindowScaleWatcher::scaleChanged, this, [this]() {
|
|
setThumbnailWidth(d->mThumbnailLogicalWidth);
|
|
});
|
|
|
|
d->mScroller = ScrollerUtils::setQScroller(this->viewport());
|
|
d->mTouch = new Touch(viewport());
|
|
connect(d->mTouch, &Touch::twoFingerTapTriggered, this, &ThumbnailView::showContextMenu);
|
|
connect(d->mTouch, &Touch::pinchZoomTriggered, this, &ThumbnailView::zoomGesture);
|
|
connect(d->mTouch, &Touch::pinchGestureStarted, this, &ThumbnailView::setZoomParameter);
|
|
connect(d->mTouch, &Touch::tapTriggered, this, &ThumbnailView::tapGesture);
|
|
connect(d->mTouch, &Touch::tapHoldAndMovingTriggered, this, &ThumbnailView::startDragFromTouch);
|
|
|
|
const QFontMetrics metrics(viewport()->font());
|
|
const int singleStep = metrics.height() * QApplication::wheelScrollLines();
|
|
|
|
verticalScrollBar()->setSingleStep(singleStep);
|
|
horizontalScrollBar()->setSingleStep(singleStep);
|
|
}
|
|
|
|
ThumbnailView::~ThumbnailView()
|
|
{
|
|
delete d->mTouch;
|
|
delete d;
|
|
}
|
|
|
|
ThumbnailView::ThumbnailScaleMode ThumbnailView::thumbnailScaleMode() const
|
|
{
|
|
return d->mScaleMode;
|
|
}
|
|
|
|
void ThumbnailView::setThumbnailScaleMode(ThumbnailScaleMode mode)
|
|
{
|
|
d->mScaleMode = mode;
|
|
setUniformItemSizes(mode == ScaleToFit || mode == ScaleToSquare);
|
|
}
|
|
|
|
void ThumbnailView::setModel(QAbstractItemModel *newModel)
|
|
{
|
|
if (model()) {
|
|
disconnect(model(), nullptr, this, nullptr);
|
|
|
|
const auto sortedModel = qobject_cast<SortedDirModel *>(newModel);
|
|
if (sortedModel) {
|
|
sortedModel->dirLister()->disconnect(this);
|
|
}
|
|
}
|
|
QListView::setModel(newModel);
|
|
|
|
connect(model(), &QAbstractItemModel::rowsRemoved, this, [=](const QModelIndex &index, int first, int last) {
|
|
// Avoid the delegate doing a ton of work if we're not visible
|
|
if (isVisible()) {
|
|
Q_EMIT rowsRemovedSignal(index, first, last);
|
|
}
|
|
});
|
|
|
|
const auto sortedModel = qobject_cast<SortedDirModel *>(newModel);
|
|
if (sortedModel) {
|
|
connect(sortedModel->dirLister(), &KDirLister::started, this, [this]() {
|
|
d->loading = true;
|
|
});
|
|
|
|
connect(sortedModel->dirLister(), &KDirLister::listingDirCompleted, this, [this]() {
|
|
d->loading = false;
|
|
d->scheduleThumbnailGeneration();
|
|
});
|
|
}
|
|
}
|
|
|
|
void ThumbnailView::setThumbnailProvider(ThumbnailProvider *thumbnailProvider)
|
|
{
|
|
GV_RETURN_IF_FAIL(d->mThumbnailProvider != thumbnailProvider);
|
|
if (thumbnailProvider) {
|
|
connect(thumbnailProvider, &ThumbnailProvider::thumbnailLoaded, this, &ThumbnailView::setThumbnail);
|
|
connect(thumbnailProvider, &ThumbnailProvider::thumbnailLoadingFailed, this, &ThumbnailView::setBrokenThumbnail);
|
|
} else {
|
|
disconnect(d->mThumbnailProvider, nullptr, this, nullptr);
|
|
}
|
|
d->mThumbnailProvider = thumbnailProvider;
|
|
}
|
|
|
|
void ThumbnailView::updateThumbnailSize()
|
|
{
|
|
QSize value = d->mThumbnailSize;
|
|
// mWaitingThumbnail
|
|
const auto dpr = devicePixelRatioF();
|
|
int waitingThumbnailSize;
|
|
if (value.width() > 64 * dpr) {
|
|
waitingThumbnailSize = qRound(48 * dpr);
|
|
} else {
|
|
waitingThumbnailSize = qRound(32 * dpr);
|
|
}
|
|
QPixmap icon = QIcon::fromTheme(QStringLiteral("chronometer")).pixmap(waitingThumbnailSize);
|
|
QPixmap pix(value);
|
|
pix.fill(Qt::transparent);
|
|
QPainter painter(&pix);
|
|
painter.setOpacity(0.5);
|
|
style()->drawItemPixmap(&painter, QRect(QPoint(), pix.deviceIndependentSize().toSize()), Qt::AlignCenter, icon);
|
|
painter.end();
|
|
d->mWaitingThumbnail = pix;
|
|
d->mWaitingThumbnail.setDevicePixelRatio(dpr);
|
|
|
|
// Stop smoothing
|
|
d->mSmoothThumbnailTimer.stop();
|
|
d->mSmoothThumbnailQueue.clear();
|
|
|
|
// Clear adjustedPixes
|
|
ThumbnailForUrl::iterator it = d->mThumbnailForUrl.begin(), end = d->mThumbnailForUrl.end();
|
|
for (; it != end; ++it) {
|
|
it.value().mAdjustedPix = QPixmap();
|
|
}
|
|
|
|
Q_EMIT thumbnailSizeChanged(value / dpr);
|
|
Q_EMIT thumbnailWidthChanged(qRound(value.width() / dpr));
|
|
if (d->mScaleMode != ScaleToFit) {
|
|
scheduleDelayedItemsLayout();
|
|
}
|
|
d->scheduleThumbnailGeneration();
|
|
}
|
|
|
|
void ThumbnailView::setThumbnailWidth(int width)
|
|
{
|
|
d->mThumbnailLogicalWidth = width;
|
|
const auto dpr = devicePixelRatioF();
|
|
const qreal newWidthF = width * dpr;
|
|
const int newWidth = qRound(newWidthF);
|
|
if (d->mThumbnailSize.width() == newWidth) {
|
|
return;
|
|
}
|
|
int height = qRound(newWidthF / d->mThumbnailAspectRatio);
|
|
d->mThumbnailSize = QSize(newWidth, height);
|
|
updateThumbnailSize();
|
|
}
|
|
|
|
void ThumbnailView::setThumbnailAspectRatio(qreal ratio)
|
|
{
|
|
if (d->mThumbnailAspectRatio == ratio) {
|
|
return;
|
|
}
|
|
d->mThumbnailAspectRatio = ratio;
|
|
int width = d->mThumbnailSize.width();
|
|
int height = round((qreal)width / d->mThumbnailAspectRatio);
|
|
d->mThumbnailSize = QSize(width, height);
|
|
updateThumbnailSize();
|
|
}
|
|
|
|
qreal ThumbnailView::thumbnailAspectRatio() const
|
|
{
|
|
return d->mThumbnailAspectRatio;
|
|
}
|
|
|
|
QSize ThumbnailView::thumbnailSize() const
|
|
{
|
|
return d->mThumbnailSize / devicePixelRatioF();
|
|
}
|
|
|
|
void ThumbnailView::setThumbnailViewHelper(AbstractThumbnailViewHelper *helper)
|
|
{
|
|
d->mThumbnailViewHelper = helper;
|
|
}
|
|
|
|
AbstractThumbnailViewHelper *ThumbnailView::thumbnailViewHelper() const
|
|
{
|
|
return d->mThumbnailViewHelper;
|
|
}
|
|
|
|
void ThumbnailView::setDocumentInfoProvider(AbstractDocumentInfoProvider *provider)
|
|
{
|
|
d->mDocumentInfoProvider = provider;
|
|
if (provider) {
|
|
connect(provider, &AbstractDocumentInfoProvider::busyStateChanged, this, &ThumbnailView::updateThumbnailBusyState);
|
|
connect(provider, &AbstractDocumentInfoProvider::documentChanged, this, &ThumbnailView::updateThumbnail);
|
|
}
|
|
}
|
|
|
|
AbstractDocumentInfoProvider *ThumbnailView::documentInfoProvider() const
|
|
{
|
|
return d->mDocumentInfoProvider;
|
|
}
|
|
|
|
void ThumbnailView::rowsAboutToBeRemoved(const QModelIndex &parent, int start, int end)
|
|
{
|
|
QListView::rowsAboutToBeRemoved(parent, start, end);
|
|
|
|
// Remove references to removed items
|
|
KFileItemList itemList;
|
|
for (int pos = start; pos <= end; ++pos) {
|
|
QModelIndex index = model()->index(pos, 0, parent);
|
|
KFileItem item = fileItemForIndex(index);
|
|
if (item.isNull()) {
|
|
// qCDebug(GWENVIEW_LIB_LOG) << "Skipping invalid item!" << index.data().toString();
|
|
continue;
|
|
}
|
|
|
|
QUrl url = item.url();
|
|
d->mThumbnailForUrl.remove(url);
|
|
d->mSmoothThumbnailQueue.removeAll(url);
|
|
|
|
itemList.append(item);
|
|
}
|
|
|
|
if (d->mThumbnailProvider) {
|
|
d->mThumbnailProvider->removeItems(itemList);
|
|
}
|
|
|
|
// Removing rows might make new images visible, make sure their thumbnail
|
|
// is generated
|
|
if (!d->mScheduledThumbnailGenerationTimer.isActive()) {
|
|
d->mScheduledThumbnailGenerationTimer.start();
|
|
}
|
|
}
|
|
|
|
void ThumbnailView::rowsInserted(const QModelIndex &parent, int start, int end)
|
|
{
|
|
QListView::rowsInserted(parent, start, end);
|
|
|
|
if (!d->mScheduledThumbnailGenerationTimer.isActive()) {
|
|
d->mScheduledThumbnailGenerationTimer.start();
|
|
}
|
|
|
|
if (isVisible()) {
|
|
Q_EMIT rowsInsertedSignal(parent, start, end);
|
|
}
|
|
}
|
|
|
|
void ThumbnailView::dataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight, const QVector<int> &roles)
|
|
{
|
|
QListView::dataChanged(topLeft, bottomRight, roles);
|
|
bool thumbnailsNeedRefresh = false;
|
|
for (int row = topLeft.row(); row <= bottomRight.row(); ++row) {
|
|
QModelIndex index = model()->index(row, 0);
|
|
KFileItem item = fileItemForIndex(index);
|
|
if (item.isNull()) {
|
|
qCWarning(GWENVIEW_LIB_LOG) << "Invalid item for index" << index << ". This should not happen!";
|
|
GV_FATAL_FAILS;
|
|
continue;
|
|
}
|
|
|
|
ThumbnailForUrl::Iterator it = d->mThumbnailForUrl.find(item.url());
|
|
if (it != d->mThumbnailForUrl.end()) {
|
|
// All thumbnail views are connected to the model, so
|
|
// ThumbnailView::dataChanged() is called for all of them. As a
|
|
// result this method will also be called for views which are not
|
|
// currently visible, and do not yet have a thumbnail for the
|
|
// modified url.
|
|
QDateTime mtime = item.time(KFileItem::ModificationTime);
|
|
if (it->mModificationTime != mtime || it->mFileSize != item.size()) {
|
|
// dataChanged() is called when the file changes but also when
|
|
// the model fetched additional data such as semantic info. To
|
|
// avoid needless refreshes, we only trigger a refresh if the
|
|
// modification time changes.
|
|
thumbnailsNeedRefresh = true;
|
|
it->prepareForRefresh(mtime);
|
|
}
|
|
}
|
|
}
|
|
if (thumbnailsNeedRefresh && !d->mScheduledThumbnailGenerationTimer.isActive()) {
|
|
d->mScheduledThumbnailGenerationTimer.start();
|
|
}
|
|
}
|
|
|
|
void ThumbnailView::showContextMenu()
|
|
{
|
|
d->mThumbnailViewHelper->showContextMenu(this);
|
|
}
|
|
|
|
void ThumbnailView::emitIndexActivatedIfNoModifiers(const QModelIndex &index)
|
|
{
|
|
if (QApplication::keyboardModifiers() == Qt::NoModifier) {
|
|
Q_EMIT indexActivated(index);
|
|
}
|
|
}
|
|
|
|
void ThumbnailView::setThumbnail(const KFileItem &item, const QPixmap &pixmap, const QSize &size, qulonglong fileSize)
|
|
{
|
|
ThumbnailForUrl::iterator it = d->mThumbnailForUrl.find(item.url());
|
|
if (it == d->mThumbnailForUrl.end()) {
|
|
return;
|
|
}
|
|
Thumbnail &thumbnail = it.value();
|
|
thumbnail.mGroupPix = pixmap;
|
|
thumbnail.mAdjustedPix = QPixmap();
|
|
int largeGroupSize = ThumbnailGroup::pixelSize(ThumbnailGroup::XLarge);
|
|
thumbnail.mFullSize = size.isValid() ? size : QSize(largeGroupSize, largeGroupSize);
|
|
thumbnail.mRealFullSize = size;
|
|
thumbnail.mWaitingForThumbnail = false;
|
|
thumbnail.mFileSize = fileSize;
|
|
|
|
update(thumbnail.mIndex);
|
|
if (d->mScaleMode != ScaleToFit) {
|
|
scheduleDelayedItemsLayout();
|
|
}
|
|
}
|
|
|
|
void ThumbnailView::setBrokenThumbnail(const KFileItem &item)
|
|
{
|
|
ThumbnailForUrl::iterator it = d->mThumbnailForUrl.find(item.url());
|
|
if (it == d->mThumbnailForUrl.end()) {
|
|
return;
|
|
}
|
|
Thumbnail &thumbnail = it.value();
|
|
MimeTypeUtils::Kind kind = MimeTypeUtils::fileItemKind(item);
|
|
if (kind == MimeTypeUtils::KIND_VIDEO) {
|
|
// Special case for videos because our kde install may come without
|
|
// support for video thumbnails so we show the mimetype icon instead of
|
|
// a broken image icon
|
|
const QPixmap pix = QIcon::fromTheme(item.iconName()).pixmap(d->mThumbnailSize.height());
|
|
thumbnail.initAsIcon(pix);
|
|
} else if (kind == MimeTypeUtils::KIND_DIR) {
|
|
// Special case for folders because ThumbnailProvider does not return a
|
|
// thumbnail if there is no images
|
|
thumbnail.mWaitingForThumbnail = false;
|
|
return;
|
|
} else {
|
|
thumbnail.initAsIcon(QIcon::fromTheme(QStringLiteral("image-missing")).pixmap(48));
|
|
thumbnail.mFullSize = thumbnail.mGroupPix.size();
|
|
}
|
|
update(thumbnail.mIndex);
|
|
}
|
|
|
|
QPixmap ThumbnailView::thumbnailForIndex(const QModelIndex &index, QSize *fullSize)
|
|
{
|
|
KFileItem item = fileItemForIndex(index);
|
|
if (item.isNull()) {
|
|
LOG("Invalid item");
|
|
if (fullSize) {
|
|
*fullSize = QSize();
|
|
}
|
|
return {};
|
|
}
|
|
QUrl url = item.url();
|
|
|
|
// Find or create Thumbnail instance
|
|
ThumbnailForUrl::Iterator it = d->mThumbnailForUrl.find(url);
|
|
if (it == d->mThumbnailForUrl.end()) {
|
|
Thumbnail thumbnail = Thumbnail(QPersistentModelIndex(index), item.time(KFileItem::ModificationTime));
|
|
it = d->mThumbnailForUrl.insert(url, thumbnail);
|
|
}
|
|
Thumbnail &thumbnail = it.value();
|
|
|
|
// If dir or archive, generate a thumbnail from fileitem pixmap
|
|
MimeTypeUtils::Kind kind = MimeTypeUtils::fileItemKind(item);
|
|
if (kind == MimeTypeUtils::KIND_ARCHIVE || kind == MimeTypeUtils::KIND_DIR) {
|
|
int groupSize = ThumbnailGroup::pixelSize(ThumbnailGroup::fromPixelSize(d->mThumbnailSize.height()));
|
|
if (thumbnail.mGroupPix.isNull() || thumbnail.mGroupPix.height() < groupSize) {
|
|
const QPixmap pix = QIcon::fromTheme(item.iconName()).pixmap(d->mThumbnailSize.height());
|
|
|
|
thumbnail.initAsIcon(pix);
|
|
if (kind == MimeTypeUtils::KIND_ARCHIVE) {
|
|
// No thumbnails for archives
|
|
thumbnail.mWaitingForThumbnail = false;
|
|
} else if (!d->mCreateThumbnailsForRemoteUrls && !UrlUtils::urlIsFastLocalFile(url)) {
|
|
// If we don't want thumbnails for remote urls, use
|
|
// "folder-remote" icon for remote folders, so that they do
|
|
// not look like regular folders
|
|
thumbnail.mWaitingForThumbnail = false;
|
|
thumbnail.initAsIcon(QIcon::fromTheme(QStringLiteral("folder-remote")).pixmap(groupSize));
|
|
} else {
|
|
// set mWaitingForThumbnail to true (necessary in the case
|
|
// 'thumbnail' already existed before, but with a too small
|
|
// mGroupPix)
|
|
thumbnail.mWaitingForThumbnail = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (thumbnail.mGroupPix.isNull()) {
|
|
if (fullSize) {
|
|
*fullSize = QSize();
|
|
}
|
|
return d->mWaitingThumbnail;
|
|
}
|
|
|
|
// Adjust thumbnail
|
|
if (thumbnail.mAdjustedPix.isNull()) {
|
|
d->roughAdjustThumbnail(&thumbnail);
|
|
}
|
|
if (GwenviewConfig::lowResourceUsageMode() && thumbnail.mRough && !d->mSmoothThumbnailQueue.contains(url)) {
|
|
d->mSmoothThumbnailQueue.enqueue(url);
|
|
if (!d->mSmoothThumbnailTimer.isActive()) {
|
|
d->mSmoothThumbnailTimer.start(SMOOTH_DELAY);
|
|
}
|
|
}
|
|
if (fullSize) {
|
|
*fullSize = thumbnail.mRealFullSize;
|
|
}
|
|
thumbnail.mAdjustedPix.setDevicePixelRatio(devicePixelRatioF());
|
|
return thumbnail.mAdjustedPix;
|
|
}
|
|
|
|
bool ThumbnailView::isModified(const QModelIndex &index) const
|
|
{
|
|
if (!d->mDocumentInfoProvider) {
|
|
return false;
|
|
}
|
|
QUrl url = urlForIndex(index);
|
|
return d->mDocumentInfoProvider->isModified(url);
|
|
}
|
|
|
|
bool ThumbnailView::isBusy(const QModelIndex &index) const
|
|
{
|
|
if (!d->mDocumentInfoProvider) {
|
|
return false;
|
|
}
|
|
QUrl url = urlForIndex(index);
|
|
return d->mDocumentInfoProvider->isBusy(url);
|
|
}
|
|
|
|
void ThumbnailView::startDrag(Qt::DropActions)
|
|
{
|
|
const QModelIndexList indexes = selectionModel()->selectedIndexes();
|
|
if (indexes.isEmpty()) {
|
|
return;
|
|
}
|
|
|
|
KFileItemList selectedFiles;
|
|
for (const auto &index : indexes) {
|
|
selectedFiles << fileItemForIndex(index);
|
|
}
|
|
|
|
auto drag = new QDrag(this);
|
|
auto *mimeData = MimeTypeUtils::selectionMimeData(selectedFiles, MimeTypeUtils::DropTarget);
|
|
KUrlMimeData::exportUrlsToPortal(mimeData);
|
|
drag->setMimeData(mimeData);
|
|
d->initDragPixmap(drag, indexes);
|
|
drag->exec(Qt::MoveAction | Qt::CopyAction | Qt::LinkAction, Qt::CopyAction);
|
|
}
|
|
|
|
void ThumbnailView::setZoomParameter()
|
|
{
|
|
const qreal sensitivityModifier = 0.25;
|
|
d->mTouch->setZoomParameter(sensitivityModifier, thumbnailSize().width());
|
|
}
|
|
|
|
void ThumbnailView::zoomGesture(qreal newZoom, const QPoint &)
|
|
{
|
|
if (newZoom >= 0.0) {
|
|
int width = qBound(int(MinThumbnailSize), static_cast<int>(newZoom), int(MaxThumbnailSize));
|
|
setThumbnailWidth(width);
|
|
}
|
|
}
|
|
|
|
void ThumbnailView::tapGesture(const QPoint &pos)
|
|
{
|
|
const QRect rect = QRect(pos, QSize(1, 1));
|
|
setSelection(rect, QItemSelectionModel::ClearAndSelect);
|
|
Q_EMIT activated(indexAt(pos));
|
|
}
|
|
|
|
void ThumbnailView::startDragFromTouch(const QPoint &pos)
|
|
{
|
|
QModelIndex index = indexAt(pos);
|
|
if (index.isValid()) {
|
|
setCurrentIndex(index);
|
|
d->mScroller->stop();
|
|
startDrag(Qt::CopyAction);
|
|
}
|
|
}
|
|
|
|
void ThumbnailView::dragEnterEvent(QDragEnterEvent *event)
|
|
{
|
|
QAbstractItemView::dragEnterEvent(event);
|
|
if (event->mimeData()->hasUrls()) {
|
|
event->acceptProposedAction();
|
|
}
|
|
}
|
|
|
|
void ThumbnailView::dragMoveEvent(QDragMoveEvent *event)
|
|
{
|
|
// Necessary, otherwise we don't reach dropEvent()
|
|
QAbstractItemView::dragMoveEvent(event);
|
|
event->acceptProposedAction();
|
|
}
|
|
|
|
void ThumbnailView::dropEvent(QDropEvent *event)
|
|
{
|
|
const QList<QUrl> urlList = KUrlMimeData::urlsFromMimeData(event->mimeData());
|
|
if (urlList.isEmpty()) {
|
|
return;
|
|
}
|
|
|
|
QModelIndex destIndex = indexAt(event->pos());
|
|
if (destIndex.isValid()) {
|
|
KFileItem item = fileItemForIndex(destIndex);
|
|
if (item.isDir()) {
|
|
QUrl destUrl = item.url();
|
|
d->mThumbnailViewHelper->showMenuForUrlDroppedOnDir(this, urlList, destUrl);
|
|
return;
|
|
}
|
|
}
|
|
|
|
d->mThumbnailViewHelper->showMenuForUrlDroppedOnViewport(this, urlList);
|
|
|
|
event->acceptProposedAction();
|
|
}
|
|
|
|
void ThumbnailView::keyPressEvent(QKeyEvent *event)
|
|
{
|
|
if (event->key() == Qt::Key_Return) {
|
|
const QModelIndex index = selectionModel()->currentIndex();
|
|
if (index.isValid() && selectionModel()->selectedIndexes().count() == 1) {
|
|
Q_EMIT indexActivated(index);
|
|
}
|
|
} else if (event->key() == Qt::Key_Left && event->modifiers() == Qt::NoModifier) {
|
|
if (flow() == LeftToRight && QApplication::isRightToLeft()) {
|
|
setCurrentIndex(moveCursor(QAbstractItemView::MoveRight, Qt::NoModifier));
|
|
} else {
|
|
setCurrentIndex(moveCursor(QAbstractItemView::MoveLeft, Qt::NoModifier));
|
|
}
|
|
return;
|
|
} else if (event->key() == Qt::Key_Right && event->modifiers() == Qt::NoModifier) {
|
|
if (flow() == LeftToRight && QApplication::isRightToLeft()) {
|
|
setCurrentIndex(moveCursor(QAbstractItemView::MoveLeft, Qt::NoModifier));
|
|
} else {
|
|
setCurrentIndex(moveCursor(QAbstractItemView::MoveRight, Qt::NoModifier));
|
|
}
|
|
return;
|
|
}
|
|
|
|
QListView::keyPressEvent(event);
|
|
}
|
|
|
|
void ThumbnailView::resizeEvent(QResizeEvent *event)
|
|
{
|
|
QListView::resizeEvent(event);
|
|
d->scheduleThumbnailGeneration();
|
|
}
|
|
|
|
void ThumbnailView::showEvent(QShowEvent *event)
|
|
{
|
|
d->mWindowScaleWatcher.setWindow(window()->windowHandle());
|
|
|
|
QListView::showEvent(event);
|
|
d->scheduleThumbnailGeneration();
|
|
QTimer::singleShot(0, this, &ThumbnailView::scrollToSelectedIndex);
|
|
}
|
|
|
|
void ThumbnailView::wheelEvent(QWheelEvent *event)
|
|
{
|
|
// If we don't adjust the single step, the wheel scroll exactly one item up
|
|
// and down, giving the impression that the items do not move but only
|
|
// their label changes.
|
|
// For some reason it is necessary to set the step here: setting it in
|
|
// setThumbnailSize() does not work
|
|
// verticalScrollBar()->setSingleStep(d->mThumbnailSize / 5);
|
|
if (event->modifiers() == Qt::ControlModifier) {
|
|
int width = thumbnailSize().width() + (event->angleDelta().y() > 0 ? 1 : -1) * WHEEL_ZOOM_MULTIPLIER;
|
|
width = qMax(int(MinThumbnailSize), qMin(width, int(MaxThumbnailSize)));
|
|
setThumbnailWidth(width);
|
|
} else {
|
|
QListView::wheelEvent(event);
|
|
}
|
|
}
|
|
|
|
void ThumbnailView::mousePressEvent(QMouseEvent *event)
|
|
{
|
|
switch (event->button()) {
|
|
case Qt::ForwardButton:
|
|
case Qt::BackButton:
|
|
return;
|
|
default:
|
|
QListView::mousePressEvent(event);
|
|
}
|
|
}
|
|
|
|
void ThumbnailView::scrollToSelectedIndex()
|
|
{
|
|
QModelIndexList list = selectedIndexes();
|
|
if (list.count() >= 1) {
|
|
scrollTo(list.first(), PositionAtCenter);
|
|
}
|
|
}
|
|
|
|
void ThumbnailView::selectionChanged(const QItemSelection &selected, const QItemSelection &deselected)
|
|
{
|
|
QListView::selectionChanged(selected, deselected);
|
|
Q_EMIT selectionChangedSignal(selected, deselected);
|
|
}
|
|
|
|
void ThumbnailView::scrollContentsBy(int dx, int dy)
|
|
{
|
|
QListView::scrollContentsBy(dx, dy);
|
|
d->scheduleThumbnailGeneration();
|
|
}
|
|
|
|
void ThumbnailView::generateThumbnailsForItems()
|
|
{
|
|
if (!isVisible() || !model() || d->loading) {
|
|
return;
|
|
}
|
|
const QRect visibleRect = viewport()->rect();
|
|
const int visibleSurface = visibleRect.width() * visibleRect.height();
|
|
const QPoint origin = visibleRect.center();
|
|
// Keep thumbnails around that are at most two "screen heights" away.
|
|
const int discardDistance = visibleRect.bottomRight().manhattanLength() * 2;
|
|
|
|
// distance => item
|
|
QMultiMap<int, KFileItem> itemMap;
|
|
|
|
for (int row = 0; row < model()->rowCount(); ++row) {
|
|
QModelIndex index = model()->index(row, 0);
|
|
KFileItem item = fileItemForIndex(index);
|
|
QUrl url = item.url();
|
|
|
|
// Filter out remote items if necessary
|
|
if (!d->mCreateThumbnailsForRemoteUrls && !url.isLocalFile()) {
|
|
continue;
|
|
}
|
|
|
|
// Filter out archives
|
|
MimeTypeUtils::Kind kind = MimeTypeUtils::fileItemKind(item);
|
|
if (kind == MimeTypeUtils::KIND_ARCHIVE) {
|
|
continue;
|
|
}
|
|
|
|
// Immediately update modified items
|
|
if (d->mDocumentInfoProvider && d->mDocumentInfoProvider->isModified(url)) {
|
|
d->updateThumbnailForModifiedDocument(index);
|
|
continue;
|
|
}
|
|
|
|
ThumbnailForUrl::ConstIterator it = d->mThumbnailForUrl.constFind(url);
|
|
|
|
// Compute distance
|
|
int distance;
|
|
const QRect itemRect = visualRect(index);
|
|
if (itemRect.intersected(visibleRect).isValid()) {
|
|
// Item is visible, order thumbnails from left to right, top to bottom
|
|
// Distance is computed so that it is between 0 and visibleSurface
|
|
distance = itemRect.top() * visibleRect.width() + itemRect.left();
|
|
// Make sure directory thumbnails are generated after image thumbnails:
|
|
// Distance is between visibleSurface and 2 * visibleSurface
|
|
if (kind == MimeTypeUtils::KIND_DIR) {
|
|
distance = distance + visibleSurface;
|
|
}
|
|
} else {
|
|
// Calculate how far away the thumbnail is to determine if it could
|
|
// become visible soon.
|
|
qreal itemDistance = (itemRect.center() - origin).manhattanLength();
|
|
|
|
if (itemDistance < discardDistance) {
|
|
// Item is not visible but within an area that may potentially
|
|
// become visible soon, order thumbnails according to distance
|
|
// Start at 2 * visibleSurface to ensure invisible thumbnails are
|
|
// generated *after* visible thumbnails
|
|
distance = 2 * visibleSurface + itemDistance;
|
|
} else {
|
|
// Discard thumbnails that are too far away to prevent large
|
|
// directories from consuming massive amounts of RAM.
|
|
if (it != d->mThumbnailForUrl.constEnd()) {
|
|
// Thumbnail exists for this item, discard it.
|
|
const QUrl url = item.url();
|
|
d->mThumbnailForUrl.remove(url);
|
|
d->mSmoothThumbnailQueue.removeAll(url);
|
|
d->mThumbnailProvider->removeItems({item});
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// Filter out items which already have a thumbnail
|
|
if (it != d->mThumbnailForUrl.constEnd() && it.value().isGroupPixAdaptedForSize(d->mThumbnailSize.height())) {
|
|
continue;
|
|
}
|
|
|
|
// Add the item to our map
|
|
itemMap.insert(distance, item);
|
|
|
|
// Insert the thumbnail in mThumbnailForUrl, so that
|
|
// setThumbnail() can find the item to update
|
|
if (it == d->mThumbnailForUrl.constEnd()) {
|
|
Thumbnail thumbnail = Thumbnail(QPersistentModelIndex(index), item.time(KFileItem::ModificationTime));
|
|
d->mThumbnailForUrl.insert(url, thumbnail);
|
|
}
|
|
}
|
|
|
|
if (!itemMap.isEmpty()) {
|
|
d->appendItemsToThumbnailProvider(itemMap.values());
|
|
}
|
|
}
|
|
|
|
void ThumbnailView::updateThumbnail(const QUrl &url)
|
|
{
|
|
const ThumbnailForUrl::Iterator it = d->mThumbnailForUrl.find(url);
|
|
if (it == d->mThumbnailForUrl.end()) {
|
|
return;
|
|
}
|
|
|
|
if (d->mDocumentInfoProvider) {
|
|
d->updateThumbnailForModifiedDocument(it->mIndex);
|
|
} else {
|
|
const KFileItem item = fileItemForIndex(it->mIndex);
|
|
d->appendItemsToThumbnailProvider(KFileItemList({item}));
|
|
}
|
|
}
|
|
|
|
void ThumbnailView::updateThumbnailBusyState(const QUrl &url, bool busy)
|
|
{
|
|
const ThumbnailForUrl::Iterator it = d->mThumbnailForUrl.find(url);
|
|
if (it == d->mThumbnailForUrl.end()) {
|
|
return;
|
|
}
|
|
|
|
QPersistentModelIndex index(it->mIndex);
|
|
if (busy && !d->mBusyIndexSet.contains(index)) {
|
|
d->mBusyIndexSet << index;
|
|
update(index);
|
|
if (d->mBusyAnimationTimeLine->state() != QTimeLine::Running) {
|
|
d->mBusyAnimationTimeLine->start();
|
|
}
|
|
} else if (!busy && d->mBusyIndexSet.remove(index)) {
|
|
update(index);
|
|
if (d->mBusyIndexSet.isEmpty()) {
|
|
d->mBusyAnimationTimeLine->stop();
|
|
}
|
|
}
|
|
}
|
|
|
|
void ThumbnailView::updateBusyIndexes()
|
|
{
|
|
for (const QPersistentModelIndex &index : qAsConst(d->mBusyIndexSet)) {
|
|
update(index);
|
|
}
|
|
}
|
|
|
|
QPixmap ThumbnailView::busySequenceCurrentPixmap() const
|
|
{
|
|
return d->mBusySequence.frameAt(d->mBusyAnimationTimeLine->currentFrame());
|
|
}
|
|
|
|
void ThumbnailView::smoothNextThumbnail()
|
|
{
|
|
if (d->mSmoothThumbnailQueue.isEmpty()) {
|
|
return;
|
|
}
|
|
|
|
if (d->mThumbnailProvider && d->mThumbnailProvider->isRunning()) {
|
|
// give mThumbnailProvider priority over smoothing
|
|
d->mSmoothThumbnailTimer.start(SMOOTH_DELAY);
|
|
return;
|
|
}
|
|
|
|
QUrl url = d->mSmoothThumbnailQueue.dequeue();
|
|
ThumbnailForUrl::Iterator it = d->mThumbnailForUrl.find(url);
|
|
GV_RETURN_IF_FAIL2(it != d->mThumbnailForUrl.end(), url << "not in mThumbnailForUrl.");
|
|
|
|
Thumbnail &thumbnail = it.value();
|
|
thumbnail.mAdjustedPix = d->scale(thumbnail.mGroupPix, Qt::SmoothTransformation);
|
|
thumbnail.mRough = false;
|
|
|
|
GV_RETURN_IF_FAIL2(thumbnail.mIndex.isValid(), "index for" << url << "is invalid.");
|
|
update(thumbnail.mIndex);
|
|
|
|
if (!d->mSmoothThumbnailQueue.isEmpty()) {
|
|
d->mSmoothThumbnailTimer.start(0);
|
|
}
|
|
}
|
|
|
|
void ThumbnailView::reloadThumbnail(const QModelIndex &index)
|
|
{
|
|
QUrl url = urlForIndex(index);
|
|
if (!url.isValid()) {
|
|
qCWarning(GWENVIEW_LIB_LOG) << "Invalid url for index" << index;
|
|
return;
|
|
}
|
|
ThumbnailProvider::deleteImageThumbnail(url);
|
|
ThumbnailForUrl::Iterator it = d->mThumbnailForUrl.find(url);
|
|
if (it == d->mThumbnailForUrl.end()) {
|
|
return;
|
|
}
|
|
d->mThumbnailForUrl.erase(it);
|
|
generateThumbnailsForItems();
|
|
}
|
|
|
|
void ThumbnailView::setCreateThumbnailsForRemoteUrls(bool createRemoteThumbs)
|
|
{
|
|
d->mCreateThumbnailsForRemoteUrls = createRemoteThumbs;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
#include "thumbnailview.moc"
|
