#include "dolphin_generalsettings.h"
#include <KBookmark>
-#include <KBookmarkGroup>
#include <KBookmarkManager>
-#include <KComponentData>
-#include <KDebug>
-#include <KIcon>
-#include <kprotocolinfo.h>
-#include <KLocale>
-#include <KStandardDirs>
+#include "dolphindebug.h"
+#include <QIcon>
+#include <KProtocolInfo>
+#include <KLocalizedString>
+#include <QStandardPaths>
#include <KUser>
+#include <KAboutData>
#include "placesitem.h"
#include <QAction>
#include <QDate>
#include <QMimeData>
#include <QTimer>
+#include <KUrlMimeData>
#include <Solid/Device>
#include <Solid/DeviceNotifier>
#include <views/dolphinview.h>
#include <views/viewproperties.h>
-#ifdef HAVE_NEPOMUK
- #include <Nepomuk2/ResourceManager>
- #include <Nepomuk2/Query/ComparisonTerm>
- #include <Nepomuk2/Query/LiteralTerm>
- #include <Nepomuk2/Query/FileQuery>
- #include <Nepomuk2/Query/ResourceTypeTerm>
- #include <Nepomuk2/Vocabulary/NFO>
- #include <Nepomuk2/Vocabulary/NIE>
+#ifdef HAVE_BALOO
+ #include <Baloo/Query>
+ #include <Baloo/IndexerConfig>
#endif
namespace {
// As long as KFilePlacesView from kdelibs is available in parallel, the
- // system-bookmarks for "Recently Accessed" and "Search For" should be
+ // system-bookmarks for "Recently Saved" and "Search For" should be
// shown only inside the Places Panel. This is necessary as the stored
- // URLs needs to get translated to a Nepomuk-search-URL on-the-fly to
- // be independent from changes in the Nepomuk-search-URL-syntax.
+ // URLs needs to get translated to a Baloo-search-URL on-the-fly to
+ // be independent from changes in the Baloo-search-URL-syntax.
// Hence a prefix to the application-name of the stored bookmarks is
// added, which is only read by PlacesItemModel.
- const char* AppNamePrefix = "-places-panel";
+ const char AppNamePrefix[] = "-places-panel";
}
PlacesItemModel::PlacesItemModel(QObject* parent) :
m_systemBookmarksIndexes(),
m_bookmarkedItems(),
m_hiddenItemToRemove(-1),
- m_saveBookmarksTimer(0),
m_updateBookmarksTimer(0),
m_storageSetupInProgress()
{
-#ifdef HAVE_NEPOMUK
- Nepomuk2::ResourceManager* rm = Nepomuk2::ResourceManager::instance();
- connect(rm, SIGNAL(nepomukSystemStarted()), this, SLOT(slotNepomukStarted()));
- connect(rm, SIGNAL(nepomukSystemStopped()), this, SLOT(slotNepomukStopped()));
-
- if (rm->initialized()) {
- KConfig config("nepomukserverrc");
- m_fileIndexingEnabled = config.group("Service-nepomukfileindexer").readEntry("autostart", true);
- }
-
+#ifdef HAVE_BALOO
+ Baloo::IndexerConfig config;
+ m_fileIndexingEnabled = config.fileIndexingEnabled();
#endif
- const QString file = KStandardDirs::locateLocal("data", "kfileplaces/bookmarks.xml");
- m_bookmarkManager = KBookmarkManager::managerForFile(file, "kfilePlaces");
+ const QString file = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + "/user-places.xbel";
+ m_bookmarkManager = KBookmarkManager::managerForExternalFile(file);
createSystemBookmarks();
initializeAvailableDevices();
const int syncBookmarksTimeout = 100;
- m_saveBookmarksTimer = new QTimer(this);
- m_saveBookmarksTimer->setInterval(syncBookmarksTimeout);
- m_saveBookmarksTimer->setSingleShot(true);
- connect(m_saveBookmarksTimer, SIGNAL(timeout()), this, SLOT(saveBookmarks()));
-
m_updateBookmarksTimer = new QTimer(this);
m_updateBookmarksTimer->setInterval(syncBookmarksTimeout);
m_updateBookmarksTimer->setSingleShot(true);
- connect(m_updateBookmarksTimer, SIGNAL(timeout()), this, SLOT(updateBookmarks()));
+ connect(m_updateBookmarksTimer, &QTimer::timeout, this, &PlacesItemModel::updateBookmarks);
- connect(m_bookmarkManager, SIGNAL(changed(QString,QString)),
- m_updateBookmarksTimer, SLOT(start()));
- connect(m_bookmarkManager, SIGNAL(bookmarksChanged(QString)),
- m_updateBookmarksTimer, SLOT(start()));
+ connect(m_bookmarkManager, &KBookmarkManager::changed,
+ m_updateBookmarksTimer, static_cast<void(QTimer::*)()>(&QTimer::start));
}
PlacesItemModel::~PlacesItemModel()
{
- saveBookmarks();
qDeleteAll(m_bookmarkedItems);
m_bookmarkedItems.clear();
}
PlacesItem* PlacesItemModel::createPlacesItem(const QString& text,
- const KUrl& url,
+ const QUrl& url,
const QString& iconName)
{
const KBookmark bookmark = PlacesItem::createBookmark(m_bookmarkManager, text, url, iconName);
}
#ifdef PLACESITEMMODEL_DEBUG
- kDebug() << "Changed visibility of hidden items";
+ qCDebug(DolphinDebug) << "Changed visibility of hidden items";
showModelState();
#endif
}
return m_hiddenItemsShown;
}
-int PlacesItemModel::closestItem(const KUrl& url) const
+int PlacesItemModel::closestItem(const QUrl& url) const
{
int foundIndex = -1;
int maxLength = 0;
for (int i = 0; i < count(); ++i) {
- const KUrl itemUrl = placesItem(i)->url();
- if (itemUrl.isParentOf(url)) {
- const int length = itemUrl.prettyUrl().length();
+ const QUrl itemUrl = placesItem(i)->url();
+ if (url == itemUrl) {
+ // We can't find a closer one, so stop here.
+ foundIndex = i;
+ break;
+ } else if (itemUrl.isParentOf(url)) {
+ const int length = itemUrl.path().length();
if (length > maxLength) {
foundIndex = i;
maxLength = length;
{
const PlacesItem* item = placesItem(index);
if (item && item->device().is<Solid::OpticalDisc>()) {
- return new QAction(KIcon("media-eject"), i18nc("@item", "Eject '%1'", item->text()), 0);
+ return new QAction(QIcon::fromTheme(QStringLiteral("media-eject")), i18nc("@item", "Eject '%1'", item->text()), 0);
}
return 0;
text = i18nc("@item", "Release '%1'", label);
} else if (removable || hotPluggable) {
text = i18nc("@item", "Safely Remove '%1'", label);
- iconName = "media-eject";
+ iconName = QStringLiteral("media-eject");
} else {
text = i18nc("@item", "Unmount '%1'", label);
- iconName = "media-eject";
+ iconName = QStringLiteral("media-eject");
}
if (iconName.isEmpty()) {
return new QAction(text, 0);
}
- return new QAction(KIcon(iconName), text, 0);
+ return new QAction(QIcon::fromTheme(iconName), text, 0);
}
void PlacesItemModel::requestEject(int index)
if (item) {
Solid::OpticalDrive* drive = item->device().parent().as<Solid::OpticalDrive>();
if (drive) {
- connect(drive, SIGNAL(ejectDone(Solid::ErrorType,QVariant,QString)),
- this, SLOT(slotStorageTeardownDone(Solid::ErrorType,QVariant)));
+ connect(drive, &Solid::OpticalDrive::ejectDone,
+ this, &PlacesItemModel::slotStorageTeardownDone);
drive->eject();
} else {
const QString label = item->text();
if (item) {
Solid::StorageAccess* access = item->device().as<Solid::StorageAccess>();
if (access) {
- connect(access, SIGNAL(teardownDone(Solid::ErrorType,QVariant,QString)),
- this, SLOT(slotStorageTeardownDone(Solid::ErrorType,QVariant)));
+ connect(access, &Solid::StorageAccess::teardownDone,
+ this, &PlacesItemModel::slotStorageTeardownDone);
access->teardown();
}
}
m_storageSetupInProgress[access] = index;
- connect(access, SIGNAL(setupDone(Solid::ErrorType,QVariant,QString)),
- this, SLOT(slotStorageSetupDone(Solid::ErrorType,QVariant,QString)));
+ connect(access, &Solid::StorageAccess::setupDone,
+ this, &PlacesItemModel::slotStorageSetupDone);
access->setup();
}
QMimeData* PlacesItemModel::createMimeData(const KItemSet& indexes) const
{
- KUrl::List urls;
+ QList<QUrl> urls;
QByteArray itemData;
QDataStream stream(&itemData, QIODevice::WriteOnly);
- foreach (int index, indexes) {
- const KUrl itemUrl = placesItem(index)->url();
+ for (int index : indexes) {
+ const QUrl itemUrl = placesItem(index)->url();
if (itemUrl.isValid()) {
urls << itemUrl;
}
QMimeData* mimeData = new QMimeData();
if (!urls.isEmpty()) {
- urls.populateMimeData(mimeData);
+ mimeData->setUrls(urls);
}
mimeData->setData(internalMimeType(), itemData);
const int dropIndex = groupedDropIndex(index, newItem);
insertItem(dropIndex, newItem);
- } else if (mimeData->hasFormat("text/uri-list")) {
+ } else if (mimeData->hasFormat(QStringLiteral("text/uri-list"))) {
// One or more items must be added to the model
- const KUrl::List urls = KUrl::List::fromMimeData(mimeData);
+ const QList<QUrl> urls = KUrlMimeData::urlsFromMimeData(mimeData);
for (int i = urls.count() - 1; i >= 0; --i) {
- const KUrl& url = urls[i];
+ const QUrl& url = urls[i];
QString text = url.fileName();
if (text.isEmpty()) {
text = url.host();
}
- if (url.isLocalFile() && !QFileInfo(url.toLocalFile()).isDir()) {
- // Only directories are allowed
+ if ((url.isLocalFile() && !QFileInfo(url.toLocalFile()).isDir())
+ || url.scheme() == QLatin1String("trash")) {
+ // Only directories outside the trash are allowed
continue;
}
}
}
-KUrl PlacesItemModel::convertedUrl(const KUrl& url)
+QUrl PlacesItemModel::convertedUrl(const QUrl& url)
{
- KUrl newUrl = url;
- if (url.protocol() == QLatin1String("timeline")) {
+ QUrl newUrl = url;
+ if (url.scheme() == QLatin1String("timeline")) {
newUrl = createTimelineUrl(url);
- } else if (url.protocol() == QLatin1String("search")) {
+ } else if (url.scheme() == QLatin1String("search")) {
newUrl = createSearchUrl(url);
}
m_bookmarkedItems.insert(bookmarkIndex, 0);
}
- triggerBookmarksSaving();
-
#ifdef PLACESITEMMODEL_DEBUG
- kDebug() << "Inserted item" << index;
+ qCDebug(DolphinDebug) << "Inserted item" << index;
showModelState();
#endif
}
Q_ASSERT(!m_bookmarkedItems[boomarkIndex]);
m_bookmarkedItems.removeAt(boomarkIndex);
- triggerBookmarksSaving();
-
#ifdef PLACESITEMMODEL_DEBUG
- kDebug() << "Removed item" << index;
+ qCDebug(DolphinDebug) << "Removed item" << index;
showModelState();
#endif
}
if (changedRoles.contains("isHidden")) {
if (!m_hiddenItemsShown && changedItem->isHidden()) {
m_hiddenItemToRemove = index;
- QTimer::singleShot(0, this, SLOT(hideItem()));
+ QTimer::singleShot(0, this, static_cast<void (PlacesItemModel::*)()>(&PlacesItemModel::hideItem));
}
}
-
- triggerBookmarksSaving();
}
void PlacesItemModel::slotDeviceAdded(const QString& udi)
return;
}
- if (error) {
+ if (error != Solid::NoError) {
if (errorData.isValid()) {
emit errorMessage(i18nc("@info", "An error occurred while accessing '%1', the system responded: %2",
item->text(),
// a hidden item. The content of the bookmark might
// have been changed, so an update is done.
found = true;
- if (newBookmark.metaDataItem("UDI").isEmpty()) {
+ if (newBookmark.metaDataItem(QStringLiteral("UDI")).isEmpty()) {
item->setBookmark(newBookmark);
+ item->setText(i18nc("KFile System Bookmarks", newBookmark.text().toUtf8().constData()));
}
break;
}
}
if (!found) {
- const QString udi = newBookmark.metaDataItem("UDI");
+ const QString udi = newBookmark.metaDataItem(QStringLiteral("UDI"));
/*
* See Bug 304878
KBookmark bookmark = root.first();
QSet<QString> devices = m_availableDevices;
- QSet<KUrl> missingSystemBookmarks;
+ QSet<QUrl> missingSystemBookmarks;
foreach (const SystemBookmarkData& data, m_systemBookmarks) {
missingSystemBookmarks.insert(data.url);
}
// items should always be collected in one group so the items are collected first
// in separate lists before inserting them.
QList<PlacesItem*> placesItems;
- QList<PlacesItem*> recentlyAccessedItems;
+ QList<PlacesItem*> recentlySavedItems;
QList<PlacesItem*> searchForItems;
QList<PlacesItem*> devicesItems;
devices.remove(item->udi());
devicesItems.append(item);
} else {
- const KUrl url = bookmark.url();
+ const QUrl url = bookmark.url();
if (missingSystemBookmarks.contains(url)) {
missingSystemBookmarks.remove(url);
// text, the retranslation will fail and the users custom text is still used.
// It is important to use "KFile System Bookmarks" as context (see
// createSystemBookmarks()).
- item->setText(i18nc("KFile System Bookmarks", bookmark.text().toUtf8().data()));
+ item->setText(i18nc("KFile System Bookmarks", bookmark.text().toUtf8().constData()));
item->setSystemItem(true);
}
switch (item->groupType()) {
- case PlacesItem::PlacesType: placesItems.append(item); break;
- case PlacesItem::RecentlyAccessedType: recentlyAccessedItems.append(item); break;
- case PlacesItem::SearchForType: searchForItems.append(item); break;
+ case PlacesItem::PlacesType: placesItems.append(item); break;
+ case PlacesItem::RecentlySavedType: recentlySavedItems.append(item); break;
+ case PlacesItem::SearchForType: searchForItems.append(item); break;
case PlacesItem::DevicesType:
- default: Q_ASSERT(false); break;
+ default: Q_ASSERT(false); break;
}
}
}
if (missingSystemBookmarks.contains(data.url)) {
PlacesItem* item = createSystemPlacesItem(data);
switch (item->groupType()) {
- case PlacesItem::PlacesType: placesItems.append(item); break;
- case PlacesItem::RecentlyAccessedType: recentlyAccessedItems.append(item); break;
- case PlacesItem::SearchForType: searchForItems.append(item); break;
+ case PlacesItem::PlacesType: placesItems.append(item); break;
+ case PlacesItem::RecentlySavedType: recentlySavedItems.append(item); break;
+ case PlacesItem::SearchForType: searchForItems.append(item); break;
case PlacesItem::DevicesType:
- default: Q_ASSERT(false); break;
+ default: Q_ASSERT(false); break;
}
}
}
}
// Create items for devices that have not been stored as bookmark yet
+ devicesItems.reserve(devicesItems.count() + devices.count());
foreach (const QString& udi, devices) {
const KBookmark bookmark = PlacesItem::createDeviceBookmark(m_bookmarkManager, udi);
devicesItems.append(new PlacesItem(bookmark));
QList<PlacesItem*> items;
items.append(placesItems);
- items.append(recentlyAccessedItems);
+ items.append(recentlySavedItems);
items.append(searchForItems);
items.append(devicesItems);
}
#ifdef PLACESITEMMODEL_DEBUG
- kDebug() << "Loaded bookmarks";
+ qCDebug(DolphinDebug) << "Loaded bookmarks";
showModelState();
#endif
}
bool PlacesItemModel::acceptBookmark(const KBookmark& bookmark,
const QSet<QString>& availableDevices) const
{
- const QString udi = bookmark.metaDataItem("UDI");
- const KUrl url = bookmark.url();
- const QString appName = bookmark.metaDataItem("OnlyInApp");
+ const QString udi = bookmark.metaDataItem(QStringLiteral("UDI"));
+ const QUrl url = bookmark.url();
+ const QString appName = bookmark.metaDataItem(QStringLiteral("OnlyInApp"));
const bool deviceAvailable = availableDevices.contains(udi);
const bool allowedHere = (appName.isEmpty()
- || appName == KGlobal::mainComponent().componentName()
- || appName == KGlobal::mainComponent().componentName() + AppNamePrefix)
- && (m_fileIndexingEnabled || (url.protocol() != QLatin1String("timeline") &&
- url.protocol() != QLatin1String("search")));
+ || appName == KAboutData::applicationData().componentName()
+ || appName == KAboutData::applicationData().componentName() + AppNamePrefix)
+ && (m_fileIndexingEnabled || (url.scheme() != QLatin1String("timeline") &&
+ url.scheme() != QLatin1String("search")));
return (udi.isEmpty() && allowedHere) || deviceAvailable;
}
data.url,
data.icon);
- const QString protocol = data.url.protocol();
+ const QString protocol = data.url.scheme();
if (protocol == QLatin1String("timeline") || protocol == QLatin1String("search")) {
// As long as the KFilePlacesView from kdelibs is available, the system-bookmarks
- // for "Recently Accessed" and "Search For" should be a setting available only
+ // for "Recently Saved" and "Search For" should be a setting available only
// in the Places Panel (see description of AppNamePrefix for more details).
- const QString appName = KGlobal::mainComponent().componentName() + AppNamePrefix;
- bookmark.setMetaDataItem("OnlyInApp", appName);
+ const QString appName = KAboutData::applicationData().componentName() + AppNamePrefix;
+ bookmark.setMetaDataItem(QStringLiteral("OnlyInApp"), appName);
}
PlacesItem* item = new PlacesItem(bookmark);
item->setSystemItem(true);
- // Create default view-properties for all "Search For" and "Recently Accessed" bookmarks
+ // Create default view-properties for all "Search For" and "Recently Saved" bookmarks
// in case if the user has not already created custom view-properties for a corresponding
// query yet.
const bool createDefaultViewProperties = (item->groupType() == PlacesItem::SearchForType ||
- item->groupType() == PlacesItem::RecentlyAccessedType) &&
+ item->groupType() == PlacesItem::RecentlySavedType) &&
!GeneralSettings::self()->globalViewProps();
if (createDefaultViewProperties) {
ViewProperties props(convertedUrl(data.url));
if (path == QLatin1String("/documents")) {
props.setViewMode(DolphinView::DetailsView);
props.setPreviewsShown(false);
- props.setVisibleRoles(QList<QByteArray>() << "text" << "path");
+ props.setVisibleRoles({"text", "path"});
} else if (path == QLatin1String("/images")) {
props.setViewMode(DolphinView::IconsView);
props.setPreviewsShown(true);
- props.setVisibleRoles(QList<QByteArray>() << "text" << "imageSize");
+ props.setVisibleRoles({"text", "imageSize"});
} else if (path == QLatin1String("/audio")) {
props.setViewMode(DolphinView::DetailsView);
props.setPreviewsShown(false);
- props.setVisibleRoles(QList<QByteArray>() << "text" << "artist" << "album");
+ props.setVisibleRoles({"text", "artist", "album"});
} else if (path == QLatin1String("/videos")) {
props.setViewMode(DolphinView::IconsView);
props.setPreviewsShown(true);
- props.setVisibleRoles(QList<QByteArray>() << "text");
- } else if (data.url.protocol() == "timeline") {
+ props.setVisibleRoles({"text"});
+ } else if (data.url.scheme() == QLatin1String("timeline")) {
props.setViewMode(DolphinView::DetailsView);
- props.setVisibleRoles(QList<QByteArray>() << "text" << "date");
+ props.setVisibleRoles({"text", "modificationtime"});
}
}
}
// i18nc call is done after reading the bookmark. The reason why the i18nc call is not
// done here is because otherwise switching the language would not result in retranslating the
// bookmarks.
- m_systemBookmarks.append(SystemBookmarkData(KUrl(KUser().homeDir()),
- "user-home",
+ m_systemBookmarks.append(SystemBookmarkData(QUrl::fromLocalFile(KUser().homeDir()),
+ QStringLiteral("user-home"),
I18N_NOOP2("KFile System Bookmarks", "Home")));
- m_systemBookmarks.append(SystemBookmarkData(KUrl("remote:/"),
- "network-workgroup",
+ m_systemBookmarks.append(SystemBookmarkData(QUrl(QStringLiteral("remote:/")),
+ QStringLiteral("network-workgroup"),
I18N_NOOP2("KFile System Bookmarks", "Network")));
- m_systemBookmarks.append(SystemBookmarkData(KUrl("/"),
- "folder-red",
+ m_systemBookmarks.append(SystemBookmarkData(QUrl::fromLocalFile(QStringLiteral("/")),
+ QStringLiteral("folder-red"),
I18N_NOOP2("KFile System Bookmarks", "Root")));
- m_systemBookmarks.append(SystemBookmarkData(KUrl("trash:/"),
- "user-trash",
+ m_systemBookmarks.append(SystemBookmarkData(QUrl(QStringLiteral("trash:/")),
+ QStringLiteral("user-trash"),
I18N_NOOP2("KFile System Bookmarks", "Trash")));
if (m_fileIndexingEnabled) {
- m_systemBookmarks.append(SystemBookmarkData(KUrl("timeline:/today"),
- "go-jump-today",
+ m_systemBookmarks.append(SystemBookmarkData(QUrl(QStringLiteral("timeline:/today")),
+ QStringLiteral("go-jump-today"),
I18N_NOOP2("KFile System Bookmarks", "Today")));
- m_systemBookmarks.append(SystemBookmarkData(KUrl("timeline:/yesterday"),
- "view-calendar-day",
+ m_systemBookmarks.append(SystemBookmarkData(QUrl(QStringLiteral("timeline:/yesterday")),
+ QStringLiteral("view-calendar-day"),
I18N_NOOP2("KFile System Bookmarks", "Yesterday")));
- m_systemBookmarks.append(SystemBookmarkData(KUrl("timeline:/thismonth"),
- "view-calendar-month",
+ m_systemBookmarks.append(SystemBookmarkData(QUrl(QStringLiteral("timeline:/thismonth")),
+ QStringLiteral("view-calendar-month"),
I18N_NOOP2("KFile System Bookmarks", "This Month")));
- m_systemBookmarks.append(SystemBookmarkData(KUrl("timeline:/lastmonth"),
- "view-calendar-month",
+ m_systemBookmarks.append(SystemBookmarkData(QUrl(QStringLiteral("timeline:/lastmonth")),
+ QStringLiteral("view-calendar-month"),
I18N_NOOP2("KFile System Bookmarks", "Last Month")));
- m_systemBookmarks.append(SystemBookmarkData(KUrl("search:/documents"),
- "folder-txt",
+ m_systemBookmarks.append(SystemBookmarkData(QUrl(QStringLiteral("search:/documents")),
+ QStringLiteral("folder-text"),
I18N_NOOP2("KFile System Bookmarks", "Documents")));
- m_systemBookmarks.append(SystemBookmarkData(KUrl("search:/images"),
- "folder-image",
+ m_systemBookmarks.append(SystemBookmarkData(QUrl(QStringLiteral("search:/images")),
+ QStringLiteral("folder-images"),
I18N_NOOP2("KFile System Bookmarks", "Images")));
- m_systemBookmarks.append(SystemBookmarkData(KUrl("search:/audio"),
- "folder-sound",
+ m_systemBookmarks.append(SystemBookmarkData(QUrl(QStringLiteral("search:/audio")),
+ QStringLiteral("folder-sound"),
I18N_NOOP2("KFile System Bookmarks", "Audio Files")));
- m_systemBookmarks.append(SystemBookmarkData(KUrl("search:/videos"),
- "folder-video",
+ m_systemBookmarks.append(SystemBookmarkData(QUrl(QStringLiteral("search:/videos")),
+ QStringLiteral("folder-videos"),
I18N_NOOP2("KFile System Bookmarks", "Videos")));
}
KStandardItemModel::clear();
}
-void PlacesItemModel::slotNepomukStarted()
-{
- KConfig config("nepomukserverrc");
- m_fileIndexingEnabled = config.group("Service-nepomukfileindexer").readEntry("autostart", true);
- if (m_fileIndexingEnabled) {
- m_systemBookmarks.clear();
- m_systemBookmarksIndexes.clear();
- createSystemBookmarks();
-
- clear();
- loadBookmarks();
- }
-}
-
-void PlacesItemModel::slotNepomukStopped()
-{
- if (m_fileIndexingEnabled) {
- m_fileIndexingEnabled = false;
-
- m_systemBookmarks.clear();
- m_systemBookmarksIndexes.clear();
- createSystemBookmarks();
-
- clear();
- loadBookmarks();
- }
-}
-
-
void PlacesItemModel::initializeAvailableDevices()
{
- QString predicate("[[[[ StorageVolume.ignored == false AND [ StorageVolume.usage == 'FileSystem' OR StorageVolume.usage == 'Encrypted' ]]"
+ QString predicate(QStringLiteral("[[[[ StorageVolume.ignored == false AND [ StorageVolume.usage == 'FileSystem' OR StorageVolume.usage == 'Encrypted' ]]"
" OR "
"[ IS StorageAccess AND StorageDrive.driveType == 'Floppy' ]]"
" OR "
"OpticalDisc.availableContent & 'Audio' ]"
" OR "
- "StorageAccess.ignored == false ]");
+ "StorageAccess.ignored == false ]"));
- if (KProtocolInfo::isKnownProtocol("mtp")) {
+ if (KProtocolInfo::isKnownProtocol(QStringLiteral("mtp"))) {
predicate.prepend("[");
predicate.append(" OR PortableMediaPlayer.supportedProtocols == 'mtp']");
}
Q_ASSERT(m_predicate.isValid());
Solid::DeviceNotifier* notifier = Solid::DeviceNotifier::instance();
- connect(notifier, SIGNAL(deviceAdded(QString)), this, SLOT(slotDeviceAdded(QString)));
- connect(notifier, SIGNAL(deviceRemoved(QString)), this, SLOT(slotDeviceRemoved(QString)));
+ connect(notifier, &Solid::DeviceNotifier::deviceAdded, this, &PlacesItemModel::slotDeviceAdded);
+ connect(notifier, &Solid::DeviceNotifier::deviceRemoved, this, &PlacesItemModel::slotDeviceRemoved);
const QList<Solid::Device>& deviceList = Solid::Device::listFromQuery(m_predicate);
foreach (const Solid::Device& device, deviceList) {
// bookmark should still be remembered, so readd it again:
m_bookmarkManager->root().addBookmark(hiddenBookmark);
m_bookmarkManager->root().moveBookmark(hiddenBookmark, previousBookmark);
- triggerBookmarksSaving();
}
m_bookmarkedItems.insert(newIndex, hiddenItem);
}
}
-void PlacesItemModel::triggerBookmarksSaving()
-{
- if (m_saveBookmarksTimer) {
- m_saveBookmarksTimer->start();
- }
-}
-
QString PlacesItemModel::internalMimeType() const
{
return "application/x-dolphinplacesmodel-" +
bool PlacesItemModel::equalBookmarkIdentifiers(const KBookmark& b1, const KBookmark& b2)
{
- const QString udi1 = b1.metaDataItem("UDI");
- const QString udi2 = b2.metaDataItem("UDI");
+ const QString udi1 = b1.metaDataItem(QStringLiteral("UDI"));
+ const QString udi2 = b2.metaDataItem(QStringLiteral("UDI"));
if (!udi1.isEmpty() && !udi2.isEmpty()) {
return udi1 == udi2;
} else {
- return b1.metaDataItem("ID") == b2.metaDataItem("ID");
+ return b1.metaDataItem(QStringLiteral("ID")) == b2.metaDataItem(QStringLiteral("ID"));
}
}
-KUrl PlacesItemModel::createTimelineUrl(const KUrl& url)
+QUrl PlacesItemModel::createTimelineUrl(const QUrl& url)
{
- // TODO: Clarify with the Nepomuk-team whether it makes sense
+ // TODO: Clarify with the Baloo-team whether it makes sense
// provide default-timeline-URLs like 'yesterday', 'this month'
// and 'last month'.
- KUrl timelineUrl;
+ QUrl timelineUrl;
- const QString path = url.pathOrUrl();
+ const QString path = url.toDisplayString(QUrl::PreferLocalFile);
if (path.endsWith(QLatin1String("yesterday"))) {
const QDate date = QDate::currentDate().addDays(-1);
const int year = date.year();
const int month = date.month();
const int day = date.day();
- timelineUrl = "timeline:/" + timelineDateString(year, month) +
- '/' + timelineDateString(year, month, day);
+ timelineUrl = QUrl("timeline:/" + timelineDateString(year, month) +
+ '/' + timelineDateString(year, month, day));
} else if (path.endsWith(QLatin1String("thismonth"))) {
const QDate date = QDate::currentDate();
- timelineUrl = "timeline:/" + timelineDateString(date.year(), date.month());
+ timelineUrl = QUrl("timeline:/" + timelineDateString(date.year(), date.month()));
} else if (path.endsWith(QLatin1String("lastmonth"))) {
const QDate date = QDate::currentDate().addMonths(-1);
- timelineUrl = "timeline:/" + timelineDateString(date.year(), date.month());
+ timelineUrl = QUrl("timeline:/" + timelineDateString(date.year(), date.month()));
} else {
Q_ASSERT(path.endsWith(QLatin1String("today")));
- timelineUrl= url;
+ timelineUrl = url;
}
return timelineUrl;
return date;
}
-KUrl PlacesItemModel::createSearchUrl(const KUrl& url)
+QUrl PlacesItemModel::createSearchUrl(const QUrl& url)
{
- KUrl searchUrl;
+ QUrl searchUrl;
-#ifdef HAVE_NEPOMUK
- const QString path = url.pathOrUrl();
+#ifdef HAVE_BALOO
+ const QString path = url.toDisplayString(QUrl::PreferLocalFile);
if (path.endsWith(QLatin1String("documents"))) {
- searchUrl = searchUrlForTerm(Nepomuk2::Query::ResourceTypeTerm(Nepomuk2::Vocabulary::NFO::Document()));
+ searchUrl = searchUrlForType(QStringLiteral("Document"));
} else if (path.endsWith(QLatin1String("images"))) {
- searchUrl = searchUrlForTerm(Nepomuk2::Query::ResourceTypeTerm(Nepomuk2::Vocabulary::NFO::Image()));
+ searchUrl = searchUrlForType(QStringLiteral("Image"));
} else if (path.endsWith(QLatin1String("audio"))) {
- searchUrl = searchUrlForTerm(Nepomuk2::Query::ComparisonTerm(Nepomuk2::Vocabulary::NIE::mimeType(),
- Nepomuk2::Query::LiteralTerm("audio")));
+ searchUrl = searchUrlForType(QStringLiteral("Audio"));
} else if (path.endsWith(QLatin1String("videos"))) {
- searchUrl = searchUrlForTerm(Nepomuk2::Query::ComparisonTerm(Nepomuk2::Vocabulary::NIE::mimeType(),
- Nepomuk2::Query::LiteralTerm("video")));
+ searchUrl = searchUrlForType(QStringLiteral("Video"));
} else {
Q_ASSERT(false);
}
return searchUrl;
}
-#ifdef HAVE_NEPOMUK
-KUrl PlacesItemModel::searchUrlForTerm(const Nepomuk2::Query::Term& term)
+#ifdef HAVE_BALOO
+QUrl PlacesItemModel::searchUrlForType(const QString& type)
{
- const Nepomuk2::Query::FileQuery query(term);
+ Baloo::Query query;
+ query.addType(type);
+
return query.toSearchUrl();
}
#endif
#ifdef PLACESITEMMODEL_DEBUG
void PlacesItemModel::showModelState()
{
- kDebug() << "=================================";
- kDebug() << "Model:";
- kDebug() << "hidden-index model-index text";
+ qCDebug(DolphinDebug) << "=================================";
+ qCDebug(DolphinDebug) << "Model:";
+ qCDebug(DolphinDebug) << "hidden-index model-index text";
int modelIndex = 0;
for (int i = 0; i < m_bookmarkedItems.count(); ++i) {
if (m_bookmarkedItems[i]) {
- kDebug() << i << "(Hidden) " << " " << m_bookmarkedItems[i]->dataValue("text").toString();
+ qCDebug(DolphinDebug) << i << "(Hidden) " << " " << m_bookmarkedItems[i]->dataValue("text").toString();
} else {
if (item(modelIndex)) {
- kDebug() << i << " " << modelIndex << " " << item(modelIndex)->dataValue("text").toString();
+ qCDebug(DolphinDebug) << i << " " << modelIndex << " " << item(modelIndex)->dataValue("text").toString();
} else {
- kDebug() << i << " " << modelIndex << " " << "(not available yet)";
+ qCDebug(DolphinDebug) << i << " " << modelIndex << " " << "(not available yet)";
}
++modelIndex;
}
}
- kDebug();
- kDebug() << "Bookmarks:";
+ qCDebug(DolphinDebug);
+ qCDebug(DolphinDebug) << "Bookmarks:";
int bookmarkIndex = 0;
KBookmarkGroup root = m_bookmarkManager->root();
const QString udi = bookmark.metaDataItem("UDI");
const QString text = udi.isEmpty() ? bookmark.text() : udi;
if (bookmark.metaDataItem("IsHidden") == QLatin1String("true")) {
- kDebug() << bookmarkIndex << "(Hidden)" << text;
+ qCDebug(DolphinDebug) << bookmarkIndex << "(Hidden)" << text;
} else {
- kDebug() << bookmarkIndex << " " << text;
+ qCDebug(DolphinDebug) << bookmarkIndex << " " << text;
}
bookmark = root.next(bookmark);
}
#endif
-#include "placesitemmodel.moc"
projects / dolphin.git / blobdiff