#include "kfileitemmodelrolesupdater.h"
#include "kfileitemmodel.h"
-#include "kpixmapmodifier_p.h"
#include <KConfig>
#include <KConfigGroup>
#include <KDebug>
#include <KFileItem>
#include <KGlobal>
+#include <KIO/JobUiDelegate>
#include <KIO/PreviewJob>
+
+#include "private/kpixmapmodifier.h"
+
+#include <QApplication>
#include <QPainter>
#include <QPixmap>
#include <QElapsedTimer>
#include <QTimer>
#ifdef HAVE_NEPOMUK
- #include "knepomukrolesprovider_p.h"
- #include "knepomukresourcewatcher_p.h"
+ #include "private/knepomukrolesprovider.h"
+ #include "private/nepomuk/resourcewatcher.h"
#endif
// Required includes for subItemsCount():
m_iconSizeChangedDuringPausing(false),
m_rolesChangedDuringPausing(false),
m_previewShown(false),
+ m_enlargeSmallPreviews(true),
m_clearPreviews(false),
+ m_sortingProgress(-1),
m_model(model),
m_iconSize(),
m_firstVisibleIndex(0),
this, SLOT(slotItemsRemoved(KItemRangeList)));
connect(m_model, SIGNAL(itemsChanged(KItemRangeList,QSet<QByteArray>)),
this, SLOT(slotItemsChanged(KItemRangeList,QSet<QByteArray>)));
+ connect(m_model, SIGNAL(sortRoleChanged(QByteArray,QByteArray)),
+ this, SLOT(slotSortRoleChanged(QByteArray,QByteArray)));
// Use a timer to prevent that each call of slotItemsChanged() results in a synchronous
// resolving of the roles. Postpone the resolving until no update has been done for 1 second.
m_changedItemsTimer->setInterval(1000);
m_changedItemsTimer->setSingleShot(true);
connect(m_changedItemsTimer, SIGNAL(timeout()), this, SLOT(resolveChangedItems()));
+
+ m_resolvableRoles.insert("size");
+ m_resolvableRoles.insert("type");
+ m_resolvableRoles.insert("isExpandable");
+#ifdef HAVE_NEPOMUK
+ m_resolvableRoles += KNepomukRolesProvider::instance().roles();
+#endif
}
KFileItemModelRolesUpdater::~KFileItemModelRolesUpdater()
}
}
-void KFileItemModelRolesUpdater::setPreviewShown(bool show)
+void KFileItemModelRolesUpdater::setPreviewsShown(bool show)
{
if (show == m_previewShown) {
return;
m_clearPreviews = true;
}
- if (m_paused) {
- m_previewChangedDuringPausing = true;
- } else {
- sortAndResolveAllRoles();
- }
+ updateAllPreviews();
}
-bool KFileItemModelRolesUpdater::isPreviewShown() const
+bool KFileItemModelRolesUpdater::previewsShown() const
{
return m_previewShown;
}
-void KFileItemModelRolesUpdater::setEnabledPlugins(const QStringList& list)
+void KFileItemModelRolesUpdater::setEnlargeSmallPreviews(bool enlarge)
{
- if (m_enabledPlugins == list) {
- return;
+ if (enlarge != m_enlargeSmallPreviews) {
+ m_enlargeSmallPreviews = enlarge;
+ if (m_previewShown) {
+ updateAllPreviews();
+ }
}
+}
- m_enabledPlugins = list;
- if (m_previewShown) {
- if (m_paused) {
- m_previewChangedDuringPausing = true;
- } else {
- sortAndResolveAllRoles();
+bool KFileItemModelRolesUpdater::enlargeSmallPreviews() const
+{
+ return m_enlargeSmallPreviews;
+}
+
+void KFileItemModelRolesUpdater::setEnabledPlugins(const QStringList& list)
+{
+ if (m_enabledPlugins == list) {
+ m_enabledPlugins = list;
+ if (m_previewShown) {
+ updateAllPreviews();
}
}
}
QSetIterator<QByteArray> it(roles);
while (it.hasNext()) {
const QByteArray& role = it.next();
- if (rolesProvider.isNepomukRole(role)) {
+ if (rolesProvider.roles().contains(role)) {
hasNepomukRole = true;
break;
}
this, SLOT(applyChangedNepomukRoles(Nepomuk::Resource)));
connect(m_nepomukResourceWatcher, SIGNAL(resourceCreated(Nepomuk::Resource,QList<QUrl>)),
this, SLOT(applyChangedNepomukRoles(Nepomuk::Resource)));
- connect(m_nepomukResourceWatcher, SIGNAL(resourceRemoved(QUrl,QList<QUrl>)),
- this, SLOT(applyChangedNepomukRoles(Nepomuk::Resource)));
} else if (!hasNepomukRole && m_nepomukResourceWatcher) {
delete m_nepomukResourceWatcher;
m_nepomukResourceWatcher = 0;
}
#endif
+ updateSortProgress();
+
if (m_paused) {
m_rolesChangedDuringPausing = true;
} else {
// Don't let the ResourceWatcher watch for removed items
if (m_model->count() == 0) {
m_nepomukResourceWatcher->setResources(QList<Nepomuk::Resource>());
+ m_nepomukResourceWatcher->stop();
m_nepomukUriItems.clear();
} else {
QList<Nepomuk::Resource> newResources;
}
}
m_nepomukResourceWatcher->setResources(newResources);
+ if (newResources.isEmpty()) {
+ Q_ASSERT(m_nepomukUriItems.isEmpty());
+ m_nepomukResourceWatcher->stop();
+ }
}
}
#endif
m_changedItemsTimer->start();
}
+void KFileItemModelRolesUpdater::slotSortRoleChanged(const QByteArray& current,
+ const QByteArray& previous)
+{
+ Q_UNUSED(current);
+ Q_UNUSED(previous);
+ updateSortProgress();
+}
+
void KFileItemModelRolesUpdater::slotGotPreview(const KFileItem& item, const QPixmap& pixmap)
{
m_pendingVisibleItems.remove(item);
const int slashIndex = mimeType.indexOf(QLatin1Char('/'));
const QString mimeTypeGroup = mimeType.left(slashIndex);
if (mimeTypeGroup == QLatin1String("image")) {
- KPixmapModifier::applyFrame(scaledPixmap, m_iconSize);
+ if (m_enlargeSmallPreviews) {
+ KPixmapModifier::applyFrame(scaledPixmap, m_iconSize);
+ } else {
+ // Assure that small previews don't get enlarged. Instead they
+ // should be shown centered within the frame.
+ const QSize contentSize = KPixmapModifier::sizeInsideFrame(m_iconSize);
+ const bool enlargingRequired = scaledPixmap.width() < contentSize.width() &&
+ scaledPixmap.height() < contentSize.height();
+ if (enlargingRequired) {
+ QSize frameSize = scaledPixmap.size();
+ frameSize.scale(m_iconSize, Qt::KeepAspectRatio);
+
+ QPixmap largeFrame(frameSize);
+ largeFrame.fill(Qt::transparent);
+
+ KPixmapModifier::applyFrame(largeFrame, frameSize);
+
+ QPainter painter(&largeFrame);
+ painter.drawPixmap((largeFrame.width() - scaledPixmap.width()) / 2,
+ (largeFrame.height() - scaledPixmap.height()) / 2,
+ scaledPixmap);
+ scaledPixmap = largeFrame;
+ } else {
+ // The image must be shrinked as it is too large to fit into
+ // the available icon size
+ KPixmapModifier::applyFrame(scaledPixmap, m_iconSize);
+ }
+ }
} else {
KPixmapModifier::scale(scaledPixmap, m_iconSize);
}
m_model->setData(index, data);
connect(m_model, SIGNAL(itemsChanged(KItemRangeList,QSet<QByteArray>)),
this, SLOT(slotItemsChanged(KItemRangeList,QSet<QByteArray>)));
+
+ applySortProgressToModel();
}
void KFileItemModelRolesUpdater::slotPreviewFailed(const KFileItem& item)
m_clearPreviews = true;
applyResolvedRoles(item, ResolveAll);
m_clearPreviews = clearPreviews;
+
+ applySortProgressToModel();
}
void KFileItemModelRolesUpdater::slotPreviewJobFinished(KJob* job)
m_clearPreviews = false;
}
+ applySortProgressToModel();
+
#ifdef KFILEITEMMODELROLESUPDATER_DEBUG
static int callCount = 0;
++callCount;
// worst case) might block the application for several seconds. To prevent such
// a blocking the MIME-type of the items will determined until the MaxBlockTimeout
// has been reached and only those items will get passed. As soon as the MIME-type
- // has been resolved once KIO::filePreview() can already access the resolved
+ // has been resolved once KIO::PreviewJob() can already access the resolved
// MIME-type in a fast way.
QElapsedTimer timer;
timer.start();
break;
}
}
- KJob* job = KIO::filePreview(itemSubSet, cacheSize, &m_enabledPlugins);
+ KIO::PreviewJob* job = new KIO::PreviewJob(itemSubSet, cacheSize, &m_enabledPlugins);
+ job->setIgnoreMaximumSize(items.first().isLocalFile());
+ if (job->ui()) {
+ job->ui()->setWindow(qApp->activeWindow());
+ }
connect(job, SIGNAL(gotPreview(KFileItem,QPixmap)),
this, SLOT(slotGotPreview(KFileItem,QPixmap)));
{
int resolvedCount = 0;
- const bool hasSlowRoles = m_previewShown
- || m_roles.contains("size")
- || m_roles.contains("type")
- || m_roles.contains("isExpandable");
+ bool hasSlowRoles = m_previewShown;
+ if (!hasSlowRoles) {
+ QSetIterator<QByteArray> it(m_roles);
+ while (it.hasNext()) {
+ if (m_resolvableRoles.contains(it.next())) {
+ hasSlowRoles = true;
+ break;
+ }
+ }
+ }
+
const ResolveHint resolveHint = hasSlowRoles ? ResolveFast : ResolveAll;
// Resolving the MIME type can be expensive. Assure that not more than MaxBlockTimeout ms are
QSetIterator<KFileItem> visibleIt(m_pendingVisibleItems);
while (visibleIt.hasNext()) {
const KFileItem item = visibleIt.next();
- applyResolvedRoles(item, resolveHint);
if (!hasSlowRoles) {
Q_ASSERT(!m_pendingInvisibleItems.contains(item));
- // All roles have been resolved already by applyResolvedRoles()
+ // All roles will be resolved by applyResolvedRoles()
m_pendingVisibleItems.remove(item);
}
+ applyResolvedRoles(item, resolveHint);
++resolvedCount;
if (timer.elapsed() > MaxBlockTimeout) {
}
kDebug() << "[TIME] Resolved pending roles:" << timer.elapsed();
#endif
+
+ applySortProgressToModel();
}
void KFileItemModelRolesUpdater::resetPendingRoles()
resolvePendingRoles();
}
+void KFileItemModelRolesUpdater::applySortProgressToModel()
+{
+ if (m_sortingProgress < 0) {
+ return;
+ }
+
+ // Inform the model about the progress of the resolved items,
+ // so that it can give an indication when the sorting has been finished.
+ const int resolvedCount = m_model->count()
+ - m_pendingVisibleItems.count()
+ - m_pendingInvisibleItems.count();
+ if (resolvedCount > 0) {
+ m_model->emitSortProgress(resolvedCount);
+ if (resolvedCount == m_model->count()) {
+ m_sortingProgress = -1;
+ }
+ }
+}
+
+void KFileItemModelRolesUpdater::updateSortProgress()
+{
+ const QByteArray sortRole = m_model->sortRole();
+
+ // Optimization if the sorting is done by type: In case if all MIME-types
+ // are known, the types have been resolved already by KFileItemModel and
+ // no sort-progress feedback is required.
+ const bool showProgress = (sortRole == "type")
+ ? hasUnknownMimeTypes()
+ : m_resolvableRoles.contains(sortRole);
+
+ if (m_sortingProgress >= 0) {
+ // Mark the current sorting as finished
+ m_model->emitSortProgress(m_model->count());
+ }
+ m_sortingProgress = showProgress ? 0 : -1;
+}
+
+bool KFileItemModelRolesUpdater::hasUnknownMimeTypes() const
+{
+ const int count = m_model->count();
+ for (int i = 0; i < count; ++i) {
+ const KFileItem item = m_model->fileItem(i);
+ if (!item.isMimeTypeKnown()) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
bool KFileItemModelRolesUpdater::applyResolvedRoles(const KFileItem& item, ResolveHint hint)
{
if (item.isNull()) {
#ifdef HAVE_NEPOMUK
if (m_nepomukResourceWatcher) {
const KNepomukRolesProvider& rolesProvider = KNepomukRolesProvider::instance();
- Nepomuk::Resource resource(item.url());
+ Nepomuk::Resource resource(item.nepomukUri());
QHashIterator<QByteArray, QVariant> it(rolesProvider.roleValues(resource, m_roles));
while (it.hasNext()) {
it.next();
uri = resource.resourceUri();
}
if (!uri.isEmpty() && !m_nepomukUriItems.contains(uri)) {
- // TODO: Calling stop()/start() is a workaround until
- // ResourceWatcher has been fixed.
- m_nepomukResourceWatcher->stop();
m_nepomukResourceWatcher->addResource(resource);
- m_nepomukResourceWatcher->start();
+
+ if (m_nepomukUriItems.isEmpty()) {
+ m_nepomukResourceWatcher->start();
+ }
m_nepomukUriItems.insert(uri, item.url());
}
int KFileItemModelRolesUpdater::subItemsCount(const QString& path) const
{
const bool countHiddenFiles = m_model->showHiddenFiles();
- const bool showFoldersOnly = m_model->showFoldersOnly();
+ const bool showFoldersOnly = m_model->showDirectoriesOnly();
#ifdef Q_WS_WIN
QDir dir(path);
#endif
}
+void KFileItemModelRolesUpdater::updateAllPreviews()
+{
+ if (m_paused) {
+ m_previewChangedDuringPausing = true;
+ } else {
+ sortAndResolveAllRoles();
+ }
+}
+
#include "kfileitemmodelrolesupdater.moc"
projects / dolphin.git / blobdiff