***************************************************************************/
#include "placesitemmodel.h"
+#include "placesitemsignalhandler.h"
-#ifdef HAVE_NEPOMUK
- #include <Nepomuk/ResourceManager>
- #include <Nepomuk/Query/ComparisonTerm>
- #include <Nepomuk/Query/LiteralTerm>
- #include <Nepomuk/Query/Query>
- #include <Nepomuk/Query/ResourceTypeTerm>
- #include <Nepomuk/Vocabulary/NFO>
- #include <Nepomuk/Vocabulary/NIE>
-#endif
+#include "dolphin_generalsettings.h"
#include <KBookmark>
-#include <KBookmarkGroup>
#include <KBookmarkManager>
-#include <KComponentData>
-#include <KDebug>
-#include <KIcon>
-#include <KLocale>
-#include <KStandardDirs>
-#include <KUser>
+#include "dolphindebug.h"
+#include <QIcon>
+#include <KProtocolInfo>
+#include <KLocalizedString>
+#include <QStandardPaths>
+#include <KAboutData>
#include "placesitem.h"
#include <QAction>
#include <QDate>
+#include <QMimeData>
+#include <QTimer>
+#include <KUrlMimeData>
+#include <KFilePlacesModel>
#include <Solid/Device>
#include <Solid/DeviceNotifier>
+#include <Solid/OpticalDisc>
+#include <Solid/OpticalDrive>
+#include <Solid/StorageAccess>
+#include <Solid/StorageDrive>
+
+#include <views/dolphinview.h>
+#include <views/viewproperties.h>
+
+namespace {
+ // A suffix to the application-name of the stored bookmarks is
+ // added, which is only read by PlacesItemModel.
+ const QString AppNameSuffix = QStringLiteral("-places-panel");
+ static QList<QUrl> balooURLs = {
+ QUrl(QStringLiteral("timeline:/today")),
+ QUrl(QStringLiteral("timeline:/yesterday")),
+ QUrl(QStringLiteral("timeline:/thismonth")),
+ QUrl(QStringLiteral("timeline:/lastmonth")),
+ QUrl(QStringLiteral("search:/documents")),
+ QUrl(QStringLiteral("search:/images")),
+ QUrl(QStringLiteral("search:/audio")),
+ QUrl(QStringLiteral("search:/videos"))
+ };
+}
PlacesItemModel::PlacesItemModel(QObject* parent) :
KStandardItemModel(parent),
- m_nepomukRunning(false),
m_hiddenItemsShown(false),
- m_availableDevices(),
- m_predicate(),
- m_bookmarkManager(0),
- m_systemBookmarks(),
- m_systemBookmarksIndexes(),
- m_hiddenItems()
-{
-#ifdef HAVE_NEPOMUK
- m_nepomukRunning = (Nepomuk::ResourceManager::instance()->initialized());
-#endif
- const QString file = KStandardDirs::locateLocal("data", "kfileplaces/bookmarks.xml");
- m_bookmarkManager = KBookmarkManager::managerForFile(file, "kfilePlaces");
-
- createSystemBookmarks();
- initializeAvailableDevices();
+ m_deviceToTearDown(nullptr),
+ m_storageSetupInProgress(),
+ m_sourceModel(new KFilePlacesModel(KAboutData::applicationData().componentName() + AppNameSuffix, this))
+{
+ cleanupBookmarks();
loadBookmarks();
+ initializeDefaultViewProperties();
+
+ connect(m_sourceModel.data(), &KFilePlacesModel::rowsInserted, this, &PlacesItemModel::onSourceModelRowsInserted);
+ connect(m_sourceModel.data(), &KFilePlacesModel::rowsAboutToBeRemoved, this, &PlacesItemModel::onSourceModelRowsAboutToBeRemoved);
+ connect(m_sourceModel.data(), &KFilePlacesModel::dataChanged, this, &PlacesItemModel::onSourceModelDataChanged);
+ connect(m_sourceModel.data(), &KFilePlacesModel::rowsAboutToBeMoved, this, &PlacesItemModel::onSourceModelRowsAboutToBeMoved);
+ connect(m_sourceModel.data(), &KFilePlacesModel::rowsMoved, this, &PlacesItemModel::onSourceModelRowsMoved);
+ connect(m_sourceModel.data(), &KFilePlacesModel::groupHiddenChanged, this, &PlacesItemModel::onSourceModelGroupHiddenChanged);
}
PlacesItemModel::~PlacesItemModel()
{
- qDeleteAll(m_hiddenItems);
- m_hiddenItems.clear();
}
-PlacesItem* PlacesItemModel::placesItem(int index) const
+void PlacesItemModel::createPlacesItem(const QString& text,
+ const QUrl& url,
+ const QString& iconName,
+ int after)
{
- return dynamic_cast<PlacesItem*>(item(index));
+ m_sourceModel->addPlace(text, url, iconName, {}, mapToSource(after));
}
-int PlacesItemModel::hiddenCount() const
-{
- int modelIndex = 0;
- int itemCount = 0;
- foreach (const PlacesItem* hiddenItem, m_hiddenItems) {
- if (hiddenItem) {
- ++itemCount;
- } else {
- if (placesItem(modelIndex)->isHidden()) {
- ++itemCount;
- }
- ++modelIndex;
- }
- }
-
- return itemCount;
-}
-
-void PlacesItemModel::setItemHidden(int index, bool hide)
+PlacesItem* PlacesItemModel::placesItem(int index) const
{
- if (index >= 0 && index < count()) {
- PlacesItem* shownItem = placesItem(index);
- shownItem->setHidden(true);
- if (!m_hiddenItemsShown && hide) {
- const int newIndex = hiddenIndex(index);
- PlacesItem* hiddenItem = new PlacesItem(*shownItem);
- removeItem(index);
- m_hiddenItems.insert(newIndex, hiddenItem);
- }
-#ifdef PLACESITEMMODEL_DEBUG
- kDebug() << "Changed hide-state from" << index << "to" << hide;
- showModelState();
-#endif
- }
+ return dynamic_cast<PlacesItem*>(item(index));
}
-bool PlacesItemModel::isItemHidden(int index) const
+int PlacesItemModel::hiddenCount() const
{
- return (index >= 0 && index < count()) ? m_hiddenItems[index] != 0 : false;
+ return m_sourceModel->hiddenCount();
}
void PlacesItemModel::setHiddenItemsShown(bool show)
m_hiddenItemsShown = show;
if (show) {
- // Move all items that are part of m_hiddenItems to the model.
- int modelIndex = 0;
- for (int hiddenIndex = 0; hiddenIndex < m_hiddenItems.count(); ++hiddenIndex) {
- if (m_hiddenItems[hiddenIndex]) {
- PlacesItem* visibleItem = new PlacesItem(*m_hiddenItems[hiddenIndex]);
- delete m_hiddenItems[hiddenIndex];
- m_hiddenItems.removeAt(hiddenIndex);
- insertItem(modelIndex, visibleItem);
- Q_ASSERT(!m_hiddenItems[hiddenIndex]);
+ for (int r = 0, rMax = m_sourceModel->rowCount(); r < rMax; r++) {
+ const QModelIndex index = m_sourceModel->index(r, 0);
+ if (!m_sourceModel->isHidden(index)) {
+ continue;
}
- ++modelIndex;
+ addItemFromSourceModel(index);
}
} else {
- // Move all items of the model, where the "isHidden" property is true, to
- // m_hiddenItems.
- Q_ASSERT(m_hiddenItems.count() == count());
- for (int i = count() - 1; i >= 0; --i) {
- PlacesItem* visibleItem = placesItem(i);
- if (visibleItem->isHidden()) {
- PlacesItem* hiddenItem = new PlacesItem(*visibleItem);
- removeItem(i);
- m_hiddenItems.insert(i, hiddenItem);
+ for (int r = 0, rMax = m_sourceModel->rowCount(); r < rMax; r++) {
+ const QModelIndex index = m_sourceModel->index(r, 0);
+ if (m_sourceModel->isHidden(index)) {
+ removeItemByIndex(index);
}
}
}
+
#ifdef PLACESITEMMODEL_DEBUG
- kDebug() << "Changed visibility of hidden items";
+ qCDebug(DolphinDebug) << "Changed visibility of hidden items";
showModelState();
#endif
}
return m_hiddenItemsShown;
}
-bool PlacesItemModel::isSystemItem(int index) const
+int PlacesItemModel::closestItem(const QUrl& url) const
{
- if (index >= 0 && index < count()) {
- const KUrl url = placesItem(index)->url();
- return m_systemBookmarksIndexes.contains(url);
- }
- return false;
+ return mapFromSource(m_sourceModel->closestItem(url));
}
-int PlacesItemModel::closestItem(const KUrl& url) const
+// look for the correct position for the item based on source model
+void PlacesItemModel::insertSortedItem(PlacesItem* item)
{
- int foundIndex = -1;
- int maxLength = 0;
+ if (!item) {
+ return;
+ }
- for (int i = 0; i < count(); ++i) {
- const KUrl itemUrl = placesItem(i)->url();
- if (itemUrl.isParentOf(url)) {
- const int length = itemUrl.prettyUrl().length();
- if (length > maxLength) {
- foundIndex = i;
- maxLength = length;
- }
+ const KBookmark iBookmark = item->bookmark();
+ const QString iBookmarkId = bookmarkId(iBookmark);
+ QModelIndex sourceIndex;
+ int pos = 0;
+
+ for(int r = 0, rMax = m_sourceModel->rowCount(); r < rMax; r++) {
+ sourceIndex = m_sourceModel->index(r, 0);
+ const KBookmark sourceBookmark = m_sourceModel->bookmarkForIndex(sourceIndex);
+
+ if (bookmarkId(sourceBookmark) == iBookmarkId) {
+ break;
+ }
+
+ if (m_hiddenItemsShown || !m_sourceModel->isHidden(sourceIndex)) {
+ pos++;
}
}
- return foundIndex;
+ m_indexMap.insert(pos, sourceIndex);
+ insertItem(pos, item);
}
-QString PlacesItemModel::groupName(const KUrl &url) const
+void PlacesItemModel::onItemInserted(int index)
{
- const QString protocol = url.protocol();
+ KStandardItemModel::onItemInserted(index);
+#ifdef PLACESITEMMODEL_DEBUG
+ qCDebug(DolphinDebug) << "Inserted item" << index;
+ showModelState();
+#endif
+}
- if (protocol.contains(QLatin1String("search"))) {
- return searchForGroupName();
- }
+void PlacesItemModel::onItemRemoved(int index, KStandardItem* removedItem)
+{
+ m_indexMap.removeAt(index);
- if (protocol == QLatin1String("timeline")) {
- return recentlyAccessedGroupName();
- }
+ KStandardItemModel::onItemRemoved(index, removedItem);
+#ifdef PLACESITEMMODEL_DEBUG
+ qCDebug(DolphinDebug) << "Removed item" << index;
+ showModelState();
+#endif
+}
+
+void PlacesItemModel::onItemChanged(int index, const QSet<QByteArray>& changedRoles)
+{
+ const QModelIndex sourceIndex = mapToSource(index);
+ const PlacesItem *changedItem = placesItem(mapFromSource(sourceIndex));
- return placesGroupName();
+ if (!changedItem || !sourceIndex.isValid()) {
+ qWarning() << "invalid item changed signal";
+ return;
+ }
+ if (changedRoles.contains("isHidden")) {
+ if (m_sourceModel->isHidden(sourceIndex) != changedItem->isHidden()) {
+ m_sourceModel->setPlaceHidden(sourceIndex, changedItem->isHidden());
+ } else {
+ m_sourceModel->refresh();
+ }
+ }
+ KStandardItemModel::onItemChanged(index, changedRoles);
}
QAction* PlacesItemModel::ejectAction(int index) const
{
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"), nullptr);
}
- return 0;
+ return nullptr;
}
-QAction* PlacesItemModel::tearDownAction(int index) const
+QAction* PlacesItemModel::teardownAction(int index) const
{
- // TODO: This is a dummy-implementation to have at least all
- // translation-strings as part of the code before the freeze
+ const PlacesItem* item = placesItem(index);
+ if (!item) {
+ return nullptr;
+ }
+
+ Solid::Device device = item->device();
+ const bool providesTearDown = device.is<Solid::StorageAccess>() &&
+ device.as<Solid::StorageAccess>()->isAccessible();
+ if (!providesTearDown) {
+ return nullptr;
+ }
+
+ Solid::StorageDrive* drive = device.as<Solid::StorageDrive>();
+ if (!drive) {
+ drive = device.parent().as<Solid::StorageDrive>();
+ }
+
+ bool hotPluggable = false;
+ bool removable = false;
+ if (drive) {
+ hotPluggable = drive->isHotpluggable();
+ removable = drive->isRemovable();
+ }
+
QString iconName;
QString text;
- QString label;
- switch (index) {
- case 0:
- text = i18nc("@item", "Release '%1'", label);
- break;
- case 1:
- text = i18nc("@item", "Safely Remove '%1'", label);
- iconName = "media-eject";
- break;
- case 2:
- text = i18nc("@item", "Unmount '%1'", label);
- iconName = "media-eject";
- break;
- default:
- break;
- }
-
- //return new QAction(KIcon(iconName), text, 0);
- return 0;
+ if (device.is<Solid::OpticalDisc>()) {
+ text = i18nc("@item", "Release");
+ } else if (removable || hotPluggable) {
+ text = i18nc("@item", "Safely Remove");
+ iconName = QStringLiteral("media-eject");
+ } else {
+ text = i18nc("@item", "Unmount");
+ iconName = QStringLiteral("media-eject");
+ }
+
+ if (iconName.isEmpty()) {
+ return new QAction(text, nullptr);
+ }
+
+ return new QAction(QIcon::fromTheme(iconName), text, nullptr);
}
-void PlacesItemModel::onItemInserted(int index)
+void PlacesItemModel::requestEject(int index)
{
- int modelIndex = 0;
- int hiddenIndex = 0;
- while (hiddenIndex < m_hiddenItems.count()) {
- if (!m_hiddenItems[hiddenIndex]) {
- ++modelIndex;
- if (modelIndex + 1 == index) {
- ++hiddenIndex;
- break;
- }
+ const PlacesItem* item = placesItem(index);
+ if (item) {
+ Solid::OpticalDrive* drive = item->device().parent().as<Solid::OpticalDrive>();
+ if (drive) {
+ connect(drive, &Solid::OpticalDrive::ejectDone,
+ this, &PlacesItemModel::slotStorageTearDownDone);
+ drive->eject();
+ } else {
+ const QString label = item->text();
+ const QString message = i18nc("@info", "The device '%1' is not a disk and cannot be ejected.", label);
+ emit errorMessage(message);
}
- ++hiddenIndex;
}
- m_hiddenItems.insert(hiddenIndex, 0);
+}
-#ifdef PLACESITEMMODEL_DEBUG
- kDebug() << "Inserted item" << index;
- showModelState();
-#endif
+void PlacesItemModel::requestTearDown(int index)
+{
+ const PlacesItem* item = placesItem(index);
+ if (item) {
+ Solid::StorageAccess *tmp = item->device().as<Solid::StorageAccess>();
+ if (tmp) {
+ m_deviceToTearDown = tmp;
+ // disconnect the Solid::StorageAccess::teardownRequested
+ // to prevent emitting PlacesItemModel::storageTearDownExternallyRequested
+ // after we have emitted PlacesItemModel::storageTearDownRequested
+ disconnect(tmp, &Solid::StorageAccess::teardownRequested,
+ item->signalHandler(), &PlacesItemSignalHandler::onTearDownRequested);
+ emit storageTearDownRequested(tmp->filePath());
+ }
+ }
}
-void PlacesItemModel::onItemRemoved(int index)
+bool PlacesItemModel::storageSetupNeeded(int index) const
{
- const int removeIndex = hiddenIndex(index);
- Q_ASSERT(!m_hiddenItems[removeIndex]);
- m_hiddenItems.removeAt(removeIndex);
-#ifdef PLACESITEMMODEL_DEBUG
- kDebug() << "Removed item" << index;
- showModelState();
-#endif
+ const PlacesItem* item = placesItem(index);
+ return item ? item->storageSetupNeeded() : false;
}
-void PlacesItemModel::slotDeviceAdded(const QString& udi)
+void PlacesItemModel::requestStorageSetup(int index)
{
- Q_UNUSED(udi);
+ const PlacesItem* item = placesItem(index);
+ if (!item) {
+ return;
+ }
+
+ Solid::Device device = item->device();
+ const bool setup = device.is<Solid::StorageAccess>()
+ && !m_storageSetupInProgress.contains(device.as<Solid::StorageAccess>())
+ && !device.as<Solid::StorageAccess>()->isAccessible();
+ if (setup) {
+ Solid::StorageAccess* access = device.as<Solid::StorageAccess>();
+
+ m_storageSetupInProgress[access] = index;
+
+ connect(access, &Solid::StorageAccess::setupDone,
+ this, &PlacesItemModel::slotStorageSetupDone);
+
+ access->setup();
+ }
}
-void PlacesItemModel::slotDeviceRemoved(const QString& udi)
+QMimeData* PlacesItemModel::createMimeData(const KItemSet& indexes) const
{
- Q_UNUSED(udi);
+ QList<QUrl> urls;
+ QByteArray itemData;
+
+ QDataStream stream(&itemData, QIODevice::WriteOnly);
+
+ for (int index : indexes) {
+ const QUrl itemUrl = placesItem(index)->url();
+ if (itemUrl.isValid()) {
+ urls << itemUrl;
+ }
+ stream << index;
+ }
+
+ QMimeData* mimeData = new QMimeData();
+ if (!urls.isEmpty()) {
+ mimeData->setUrls(urls);
+ } else {
+ // #378954: prevent itemDropEvent() drops if there isn't a source url.
+ mimeData->setData(blacklistItemDropEventMimeType(), QByteArrayLiteral("true"));
+ }
+ mimeData->setData(internalMimeType(), itemData);
+
+ return mimeData;
}
-void PlacesItemModel::loadBookmarks()
+bool PlacesItemModel::supportsDropping(int index) const
{
- KBookmarkGroup root = m_bookmarkManager->root();
- KBookmark bookmark = root.first();
- QSet<QString> devices = m_availableDevices;
+ return index >= 0 && index < count();
+}
+
+void PlacesItemModel::dropMimeDataBefore(int index, const QMimeData* mimeData)
+{
+ if (mimeData->hasFormat(internalMimeType())) {
+ // The item has been moved inside the view
+ QByteArray itemData = mimeData->data(internalMimeType());
+ QDataStream stream(&itemData, QIODevice::ReadOnly);
+ int oldIndex;
+ stream >> oldIndex;
+
+ m_sourceModel->movePlace(oldIndex, index);
+ } else if (mimeData->hasFormat(QStringLiteral("text/uri-list"))) {
+ // One or more items must be added to the model
+ const QList<QUrl> urls = KUrlMimeData::urlsFromMimeData(mimeData);
+ for (int i = urls.count() - 1; i >= 0; --i) {
+ const QUrl& url = urls[i];
+
+ QString text = url.fileName();
+ if (text.isEmpty()) {
+ text = url.host();
+ }
- QSet<KUrl> missingSystemBookmarks;
- foreach (const SystemBookmarkData& data, m_systemBookmarks) {
- missingSystemBookmarks.insert(data.url);
+ if ((url.isLocalFile() && !QFileInfo(url.toLocalFile()).isDir())
+ || url.scheme() == QLatin1String("trash")) {
+ // Only directories outside the trash are allowed
+ continue;
+ }
+
+ createPlacesItem(text, url, KIO::iconNameForUrl(url), qMax(0, index - 1));
+ }
}
+ // will save bookmark alteration and fix sort if that is broken by the drag/drop operation
+ refresh();
+}
- // The bookmarks might have a mixed order of "places" and "devices". In
- // Dolphin's places panel the devices should always be appended as last
- // group.
- QList<PlacesItem*> placesItems;
- QList<PlacesItem*> devicesItems;
+void PlacesItemModel::addItemFromSourceModel(const QModelIndex &index)
+{
+ if (!m_hiddenItemsShown && m_sourceModel->isHidden(index)) {
+ return;
+ }
- while (!bookmark.isNull()) {
- const QString udi = bookmark.metaDataItem("UDI");
- const KUrl url = bookmark.url();
- const QString appName = bookmark.metaDataItem("OnlyInApp");
- const bool deviceAvailable = devices.remove(udi);
+ const KBookmark bookmark = m_sourceModel->bookmarkForIndex(index);
+ Q_ASSERT(!bookmark.isNull());
+ PlacesItem *item = itemFromBookmark(bookmark);
+ if (!item) {
+ item = new PlacesItem(bookmark);
+ }
+ updateItem(item, index);
+ insertSortedItem(item);
+
+ if (m_sourceModel->isDevice(index)) {
+ connect(item->signalHandler(), &PlacesItemSignalHandler::tearDownExternallyRequested,
+ this, &PlacesItemModel::storageTearDownExternallyRequested);
+ }
+}
- const bool allowedHere = (appName.isEmpty() || appName == KGlobal::mainComponent().componentName())
- && (m_nepomukRunning || url.protocol() != QLatin1String("timeline"));
+void PlacesItemModel::removeItemByIndex(const QModelIndex &sourceIndex)
+{
+ QString id = bookmarkId(m_sourceModel->bookmarkForIndex(sourceIndex));
- if ((udi.isEmpty() && allowedHere) || deviceAvailable) {
- PlacesItem* item = new PlacesItem(bookmark);
- if (deviceAvailable) {
- devicesItems.append(item);
- } else {
- placesItems.append(item);
+ for (int i = 0, iMax = count(); i < iMax; ++i) {
+ if (bookmarkId(placesItem(i)->bookmark()) == id) {
+ removeItem(i);
+ return;
+ }
+ }
+}
- if (missingSystemBookmarks.contains(url)) {
- missingSystemBookmarks.remove(url);
+QString PlacesItemModel::bookmarkId(const KBookmark &bookmark) const
+{
+ QString id = bookmark.metaDataItem(QStringLiteral("UDI"));
+ if (id.isEmpty()) {
+ id = bookmark.metaDataItem(QStringLiteral("ID"));
+ }
+ return id;
+}
- // Apply the translated text to the system bookmarks, otherwise an outdated
- // translation might be shown.
- const int index = m_systemBookmarksIndexes.value(url);
- item->setText(m_systemBookmarks[index].text);
+void PlacesItemModel::initializeDefaultViewProperties() const
+{
+ for(int i = 0, iMax = m_sourceModel->rowCount(); i < iMax; i++) {
+ const QModelIndex index = m_sourceModel->index(i, 0);
+ const PlacesItem *item = placesItem(mapFromSource(index));
+ if (!item) {
+ continue;
+ }
- // The system bookmarks don't contain "real" queries stored as URLs, so
- // they must be translated first.
- item->setUrl(translatedSystemBookmarkUrl(url));
+ // Create default view-properties for all "Search For" and "Recently Saved" bookmarks
+ // in case the user has not already created custom view-properties for a corresponding
+ // query yet.
+ const bool createDefaultViewProperties = item->isSearchOrTimelineUrl() && !GeneralSettings::self()->globalViewProps();
+ if (createDefaultViewProperties) {
+ const QUrl itemUrl = item->url();
+ ViewProperties props(KFilePlacesModel::convertedUrl(itemUrl));
+ if (!props.exist()) {
+ const QString path = itemUrl.path();
+ if (path == QLatin1String("/documents")) {
+ props.setViewMode(DolphinView::DetailsView);
+ props.setPreviewsShown(false);
+ props.setVisibleRoles({"text", "path"});
+ } else if (path == QLatin1String("/images")) {
+ props.setViewMode(DolphinView::IconsView);
+ props.setPreviewsShown(true);
+ props.setVisibleRoles({"text", "imageSize"});
+ } else if (path == QLatin1String("/audio")) {
+ props.setViewMode(DolphinView::DetailsView);
+ props.setPreviewsShown(false);
+ props.setVisibleRoles({"text", "artist", "album"});
+ } else if (path == QLatin1String("/videos")) {
+ props.setViewMode(DolphinView::IconsView);
+ props.setPreviewsShown(true);
+ props.setVisibleRoles({"text"});
+ } else if (itemUrl.scheme() == QLatin1String("timeline")) {
+ props.setViewMode(DolphinView::DetailsView);
+ props.setVisibleRoles({"text", "modificationtime"});
}
+ props.save();
}
}
+ }
+}
- bookmark = root.next(bookmark);
+void PlacesItemModel::updateItem(PlacesItem *item, const QModelIndex &index)
+{
+ item->setGroup(index.data(KFilePlacesModel::GroupRole).toString());
+ item->setIcon(index.data(KFilePlacesModel::IconNameRole).toString());
+ item->setGroupHidden(index.data(KFilePlacesModel::GroupHiddenRole).toBool());
+}
+
+void PlacesItemModel::slotStorageTearDownDone(Solid::ErrorType error, const QVariant& errorData)
+{
+ if (error && errorData.isValid()) {
+ emit errorMessage(errorData.toString());
}
+ m_deviceToTearDown->disconnect();
+ m_deviceToTearDown = nullptr;
+}
- addItems(placesItems);
+void PlacesItemModel::slotStorageSetupDone(Solid::ErrorType error,
+ const QVariant& errorData,
+ const QString& udi)
+{
+ Q_UNUSED(udi);
- if (!missingSystemBookmarks.isEmpty()) {
- foreach (const SystemBookmarkData& data, m_systemBookmarks) {
- if (missingSystemBookmarks.contains(data.url)) {
- PlacesItem* item = new PlacesItem();
- item->setIcon(data.icon);
- item->setText(data.text);
- item->setUrl(translatedSystemBookmarkUrl(data.url));
- item->setGroup(data.group);
- appendItem(item);
- }
+ const int index = m_storageSetupInProgress.take(sender());
+ const PlacesItem* item = placesItem(index);
+ if (!item) {
+ return;
+ }
+
+ if (error != Solid::NoError) {
+ if (errorData.isValid()) {
+ emit errorMessage(i18nc("@info", "An error occurred while accessing '%1', the system responded: %2",
+ item->text(),
+ errorData.toString()));
+ } else {
+ emit errorMessage(i18nc("@info", "An error occurred while accessing '%1'",
+ item->text()));
+ }
+ emit storageSetupDone(index, false);
+ } else {
+ emit storageSetupDone(index, true);
+ }
+}
+
+void PlacesItemModel::onSourceModelRowsInserted(const QModelIndex &parent, int first, int last)
+{
+ for (int i = first; i <= last; i++) {
+ const QModelIndex index = m_sourceModel->index(i, 0, parent);
+ addItemFromSourceModel(index);
+ }
+}
+
+void PlacesItemModel::onSourceModelRowsAboutToBeRemoved(const QModelIndex &parent, int first, int last)
+{
+ for(int r = first; r <= last; r++) {
+ const QModelIndex index = m_sourceModel->index(r, 0, parent);
+ int oldIndex = mapFromSource(index);
+ if (oldIndex != -1) {
+ removeItem(oldIndex);
}
}
+}
+
+void PlacesItemModel::onSourceModelRowsAboutToBeMoved(const QModelIndex &parent, int start, int end, const QModelIndex &destination, int row)
+{
+ Q_UNUSED(destination);
+ Q_UNUSED(row);
- // Create items for devices that have not stored as bookmark yet
- foreach (const QString& udi, devices) {
- PlacesItem* item = new PlacesItem(udi);
- devicesItems.append(item);
+ for(int r = start; r <= end; r++) {
+ const QModelIndex sourceIndex = m_sourceModel->index(r, 0, parent);
+ // remove moved item
+ removeItem(mapFromSource(sourceIndex));
}
+}
- addItems(devicesItems);
+void PlacesItemModel::onSourceModelRowsMoved(const QModelIndex &parent, int start, int end, const QModelIndex &destination, int row)
+{
+ Q_UNUSED(destination);
+ Q_UNUSED(parent);
-#ifdef PLACESITEMMODEL_DEBUG
- kDebug() << "Loaded bookmarks";
- showModelState();
-#endif
+ const int blockSize = (end - start) + 1;
+
+ for (int r = start; r <= end; r++) {
+ // insert the moved item in the new position
+ const int targetRow = row + (start - r) - (r < row ? blockSize : 0);
+ const QModelIndex targetIndex = m_sourceModel->index(targetRow, 0, destination);
+
+ addItemFromSourceModel(targetIndex);
+ }
}
-void PlacesItemModel::addItems(const QList<PlacesItem*>& items)
+void PlacesItemModel::onSourceModelDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight, const QVector<int> &roles)
{
- foreach (PlacesItem* item, items) {
- if (item->isHidden()) {
- m_hiddenItems.append(item);
- } else {
- appendItem(item);
+ Q_UNUSED(roles);
+
+ for (int r = topLeft.row(); r <= bottomRight.row(); r++) {
+ const QModelIndex sourceIndex = m_sourceModel->index(r, 0);
+ const KBookmark bookmark = m_sourceModel->bookmarkForIndex(sourceIndex);
+ PlacesItem *placeItem = itemFromBookmark(bookmark);
+
+ if (placeItem && (!m_hiddenItemsShown && m_sourceModel->isHidden(sourceIndex))) {
+ //hide item if it became invisible
+ removeItem(index(placeItem));
+ return;
+ }
+
+ if (!placeItem && (m_hiddenItemsShown || !m_sourceModel->isHidden(sourceIndex))) {
+ //show item if it became visible
+ addItemFromSourceModel(sourceIndex);
+ return;
+ }
+
+ if (placeItem && !m_sourceModel->isDevice(sourceIndex)) {
+ placeItem->setText(bookmark.text());
+ placeItem->setIcon(sourceIndex.data(KFilePlacesModel::IconNameRole).toString());
+ placeItem->setUrl(m_sourceModel->url(sourceIndex));
+ placeItem->bookmark().setMetaDataItem(QStringLiteral("OnlyInApp"),
+ bookmark.metaDataItem(QStringLiteral("OnlyInApp")));
+ // must update the bookmark object
+ placeItem->setBookmark(bookmark);
}
}
}
-void PlacesItemModel::createSystemBookmarks()
-{
- Q_ASSERT(m_systemBookmarks.isEmpty());
- Q_ASSERT(m_systemBookmarksIndexes.isEmpty());
-
- const QString placesGroup = placesGroupName();
- const QString recentlyAccessedGroup = recentlyAccessedGroupName();
- const QString searchForGroup = searchForGroupName();
- const QString timeLineIcon = "package_utility_time"; // TODO: Ask the Oxygen team to create
- // a custom icon for the timeline-protocol
-
- m_systemBookmarks.append(SystemBookmarkData(KUrl(KUser().homeDir()),
- "user-home",
- i18nc("@item", "Home"),
- placesGroup));
- m_systemBookmarks.append(SystemBookmarkData(KUrl("remote:/"),
- "network-workgroup",
- i18nc("@item", "Network"),
- placesGroup));
- m_systemBookmarks.append(SystemBookmarkData(KUrl("/"),
- "folder-red",
- i18nc("@item", "Root"),
- placesGroup));
- m_systemBookmarks.append(SystemBookmarkData(KUrl("trash:/"),
- "user-trash",
- i18nc("@item", "Trash"),
- placesGroup));
-
- if (m_nepomukRunning) {
- m_systemBookmarks.append(SystemBookmarkData(KUrl("timeline:/today"),
- timeLineIcon,
- i18nc("@item Recently Accessed", "Today"),
- recentlyAccessedGroup));
- m_systemBookmarks.append(SystemBookmarkData(KUrl("timeline:/yesterday"),
- timeLineIcon,
- i18nc("@item Recently Accessed", "Yesterday"),
- recentlyAccessedGroup));
- m_systemBookmarks.append(SystemBookmarkData(KUrl("timeline:/thismonth"),
- timeLineIcon,
- i18nc("@item Recently Accessed", "This Month"),
- recentlyAccessedGroup));
- m_systemBookmarks.append(SystemBookmarkData(KUrl("timeline:/lastmonth"),
- timeLineIcon,
- i18nc("@item Recently Accessed", "Last Month"),
- recentlyAccessedGroup));
- m_systemBookmarks.append(SystemBookmarkData(KUrl("search:/documents"),
- "folder-txt",
- i18nc("@item Commonly Accessed", "Documents"),
- searchForGroup));
- m_systemBookmarks.append(SystemBookmarkData(KUrl("search:/images"),
- "folder-image",
- i18nc("@item Commonly Accessed", "Images"),
- searchForGroup));
- m_systemBookmarks.append(SystemBookmarkData(KUrl("search:/audio"),
- "folder-sound",
- i18nc("@item Commonly Accessed", "Audio"),
- searchForGroup));
- m_systemBookmarks.append(SystemBookmarkData(KUrl("search:/videos"),
- "folder-video",
- i18nc("@item Commonly Accessed", "Videos"),
- searchForGroup));
- }
-
- for (int i = 0; i < m_systemBookmarks.count(); ++i) {
- const KUrl url = translatedSystemBookmarkUrl(m_systemBookmarks[i].url);
- m_systemBookmarksIndexes.insert(url, i);
- }
-}
-
-void PlacesItemModel::initializeAvailableDevices()
-{
- m_predicate = Solid::Predicate::fromString(
- "[[[[ 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 ]");
- 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)));
-
- const QList<Solid::Device>& deviceList = Solid::Device::listFromQuery(m_predicate);
- foreach(const Solid::Device& device, deviceList) {
- m_availableDevices << device.udi();
- }
-}
-
-int PlacesItemModel::hiddenIndex(int index) const
-{
- int hiddenIndex = 0;
- int visibleItemIndex = 0;
- while (hiddenIndex < m_hiddenItems.count()) {
- if (!m_hiddenItems[hiddenIndex]) {
- if (visibleItemIndex == index) {
- break;
- }
- ++visibleItemIndex;
+void PlacesItemModel::onSourceModelGroupHiddenChanged(KFilePlacesModel::GroupType group, bool hidden)
+{
+ for(const QModelIndex &sourceIndex : m_sourceModel->groupIndexes(group)) {
+ PlacesItem *item = placesItem(mapFromSource(sourceIndex));
+ if (item) {
+ item->setGroupHidden(hidden);
}
- ++hiddenIndex;
}
+}
- return hiddenIndex >= m_hiddenItems.count() ? -1 : hiddenIndex;
+void PlacesItemModel::cleanupBookmarks()
+{
+ // KIO model now provides support for baloo urls, and because of that we
+ // need to remove old URLs that were visible only in Dolphin to avoid duplication
+ int row = 0;
+ do {
+ const QModelIndex sourceIndex = m_sourceModel->index(row, 0);
+ const KBookmark bookmark = m_sourceModel->bookmarkForIndex(sourceIndex);
+ const QUrl url = bookmark.url();
+ const QString appName = bookmark.metaDataItem(QStringLiteral("OnlyInApp"));
+
+ if ((appName == KAboutData::applicationData().componentName() ||
+ appName == KAboutData::applicationData().componentName() + AppNameSuffix) && balooURLs.contains(url)) {
+ qCDebug(DolphinDebug) << "Removing old baloo url:" << url;
+ m_sourceModel->removePlace(sourceIndex);
+ } else {
+ row++;
+ }
+ } while (row < m_sourceModel->rowCount());
}
-QString PlacesItemModel::placesGroupName()
+void PlacesItemModel::loadBookmarks()
{
- return i18nc("@item", "Places");
+ for(int r = 0, rMax = m_sourceModel->rowCount(); r < rMax; r++) {
+ const QModelIndex sourceIndex = m_sourceModel->index(r, 0);
+ if (m_hiddenItemsShown || !m_sourceModel->isHidden(sourceIndex)) {
+ addItemFromSourceModel(sourceIndex);
+ }
+ }
+
+#ifdef PLACESITEMMODEL_DEBUG
+ qCDebug(DolphinDebug) << "Loaded bookmarks";
+ showModelState();
+#endif
+}
+
+void PlacesItemModel::clear() {
+ KStandardItemModel::clear();
}
-QString PlacesItemModel::recentlyAccessedGroupName()
+void PlacesItemModel::proceedWithTearDown()
{
- return i18nc("@item", "Recently Accessed");
+ Q_ASSERT(m_deviceToTearDown);
+
+ connect(m_deviceToTearDown, &Solid::StorageAccess::teardownDone,
+ this, &PlacesItemModel::slotStorageTearDownDone);
+ m_deviceToTearDown->teardown();
+}
+
+void PlacesItemModel::deleteItem(int index)
+{
+ QModelIndex sourceIndex = mapToSource(index);
+ Q_ASSERT(sourceIndex.isValid());
+ m_sourceModel->removePlace(sourceIndex);
}
-QString PlacesItemModel::searchForGroupName()
+void PlacesItemModel::refresh()
{
- return i18nc("@item", "Search For");
+ m_sourceModel->refresh();
}
-KUrl PlacesItemModel::translatedSystemBookmarkUrl(const KUrl& url)
+void PlacesItemModel::hideItem(int index)
{
- KUrl translatedUrl = url;
- if (url.protocol() == QLatin1String("timeline")) {
- translatedUrl = createTimelineUrl(url);
- } else if (url.protocol() == QLatin1String("search")) {
- translatedUrl = createSearchUrl(url);
+ PlacesItem* shownItem = placesItem(index);
+ if (!shownItem) {
+ return;
}
- return translatedUrl;
+ shownItem->setHidden(true);
}
-KUrl PlacesItemModel::createTimelineUrl(const KUrl& url)
+QString PlacesItemModel::internalMimeType() const
{
- // TODO: Clarify with the Nepomuk-team whether it makes sense
- // provide default-timeline-URLs like 'yesterday', 'this month'
- // and 'last month'.
- KUrl timelineUrl;
+ return "application/x-dolphinplacesmodel-" +
+ QString::number((qptrdiff)this);
+}
- const QString path = url.pathOrUrl();
- if (path.endsWith("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);
- } else if (path.endsWith("thismonth")) {
- const QDate date = QDate::currentDate();
- timelineUrl = "timeline:/" + timelineDateString(date.year(), date.month());
- } else if (path.endsWith("lastmonth")) {
- const QDate date = QDate::currentDate().addMonths(-1);
- timelineUrl = "timeline:/" + timelineDateString(date.year(), date.month());
- } else {
- Q_ASSERT(path.endsWith("today"));
- timelineUrl= url;
+int PlacesItemModel::groupedDropIndex(int index, const PlacesItem* item) const
+{
+ Q_ASSERT(item);
+
+ int dropIndex = index;
+ const QString group = item->group();
+
+ const int itemCount = count();
+ if (index < 0) {
+ dropIndex = itemCount;
+ }
+
+ // Search nearest previous item with the same group
+ int previousIndex = -1;
+ for (int i = dropIndex - 1; i >= 0; --i) {
+ if (placesItem(i)->group() == group) {
+ previousIndex = i;
+ break;
+ }
+ }
+
+ // Search nearest next item with the same group
+ int nextIndex = -1;
+ for (int i = dropIndex; i < count(); ++i) {
+ if (placesItem(i)->group() == group) {
+ nextIndex = i;
+ break;
+ }
}
- return timelineUrl;
+ // Adjust the drop-index to be inserted to the
+ // nearest item with the same group.
+ if (previousIndex >= 0 && nextIndex >= 0) {
+ dropIndex = (dropIndex - previousIndex < nextIndex - dropIndex) ?
+ previousIndex + 1 : nextIndex;
+ } else if (previousIndex >= 0) {
+ dropIndex = previousIndex + 1;
+ } else if (nextIndex >= 0) {
+ dropIndex = nextIndex;
+ }
+
+ return dropIndex;
}
-QString PlacesItemModel::timelineDateString(int year, int month, int day)
+bool PlacesItemModel::equalBookmarkIdentifiers(const KBookmark& b1, const KBookmark& b2)
{
- QString date = QString::number(year) + '-';
- if (month < 10) {
- date += '0';
+ 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(QStringLiteral("ID")) == b2.metaDataItem(QStringLiteral("ID"));
}
- date += QString::number(month);
+}
- if (day >= 1) {
- date += '-';
- if (day < 10) {
- date += '0';
- }
- date += QString::number(day);
+int PlacesItemModel::mapFromSource(const QModelIndex &index) const
+{
+ if (!index.isValid()) {
+ return -1;
}
- return date;
+ return m_indexMap.indexOf(index);
}
-KUrl PlacesItemModel::createSearchUrl(const KUrl& url)
+bool PlacesItemModel::isDir(int index) const
{
- KUrl searchUrl;
+ Q_UNUSED(index);
+ return true;
+}
-#ifdef HAVE_NEPOMUK
- const QString path = url.pathOrUrl();
- if (path.endsWith("documents")) {
- searchUrl = searchUrlForTerm(Nepomuk::Query::ResourceTypeTerm(Nepomuk::Vocabulary::NFO::Document()));
- } else if (path.endsWith("images")) {
- searchUrl = searchUrlForTerm(Nepomuk::Query::ResourceTypeTerm(Nepomuk::Vocabulary::NFO::Image()));
- } else if (path.endsWith("audio")) {
- searchUrl = searchUrlForTerm(Nepomuk::Query::ComparisonTerm(Nepomuk::Vocabulary::NIE::mimeType(),
- Nepomuk::Query::LiteralTerm("audio")));
- } else if (path.endsWith("videos")) {
- searchUrl = searchUrlForTerm(Nepomuk::Query::ComparisonTerm(Nepomuk::Vocabulary::NIE::mimeType(),
- Nepomuk::Query::LiteralTerm("video")));
- } else {
- Q_ASSERT(false);
- }
-#else
- Q_UNUSED(url);
-#endif
+KFilePlacesModel::GroupType PlacesItemModel::groupType(int row) const
+{
+ return m_sourceModel->groupType(mapToSource(row));
+}
- return searchUrl;
+bool PlacesItemModel::isGroupHidden(KFilePlacesModel::GroupType type) const
+{
+ return m_sourceModel->isGroupHidden(type);
}
-#ifdef HAVE_NEPOMUK
-KUrl PlacesItemModel::searchUrlForTerm(const Nepomuk::Query::Term& term)
+void PlacesItemModel::setGroupHidden(KFilePlacesModel::GroupType type, bool hidden)
{
- const Nepomuk::Query::Query query(term);
- return query.toSearchUrl();
+ return m_sourceModel->setGroupHidden(type, hidden);
+}
+
+QModelIndex PlacesItemModel::mapToSource(int row) const
+{
+ return m_indexMap.value(row);
+}
+
+PlacesItem *PlacesItemModel::itemFromBookmark(const KBookmark &bookmark) const
+{
+ const QString id = bookmarkId(bookmark);
+ for (int i = 0, iMax = count(); i < iMax; i++) {
+ PlacesItem *item = placesItem(i);
+ const KBookmark itemBookmark = item->bookmark();
+ if (bookmarkId(itemBookmark) == id) {
+ return item;
+ }
+ }
+ return nullptr;
}
-#endif
#ifdef PLACESITEMMODEL_DEBUG
void PlacesItemModel::showModelState()
{
- kDebug() << "hidden-index model-index text";
- int j = 0;
- for (int i = 0; i < m_hiddenItems.count(); ++i) {
- if (m_hiddenItems[i]) {
- kDebug() << i << "(Hidden) " << " " << m_hiddenItems[i]->dataValue("text").toString();
+ 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]) {
+ qCDebug(DolphinDebug) << i << "(Hidden) " << " " << m_bookmarkedItems[i]->dataValue("text").toString();
} else {
- kDebug() << i << " " << j << " " << item(j)->dataValue("text").toString();
- ++j;
+ if (item(modelIndex)) {
+ qCDebug(DolphinDebug) << i << " " << modelIndex << " " << item(modelIndex)->dataValue("text").toString();
+ } else {
+ qCDebug(DolphinDebug) << i << " " << modelIndex << " " << "(not available yet)";
+ }
+ ++modelIndex;
}
}
+
+ qCDebug(DolphinDebug);
+ qCDebug(DolphinDebug) << "Bookmarks:";
+
+ int bookmarkIndex = 0;
+ KBookmarkGroup root = m_bookmarkManager->root();
+ KBookmark bookmark = root.first();
+ while (!bookmark.isNull()) {
+ const QString udi = bookmark.metaDataItem("UDI");
+ const QString text = udi.isEmpty() ? bookmark.text() : udi;
+ if (bookmark.metaDataItem("IsHidden") == QLatin1String("true")) {
+ qCDebug(DolphinDebug) << bookmarkIndex << "(Hidden)" << text;
+ } else {
+ qCDebug(DolphinDebug) << bookmarkIndex << " " << text;
+ }
+
+ bookmark = root.next(bookmark);
+ ++bookmarkIndex;
+ }
}
#endif
-#include "placesitemmodel.moc"
projects / dolphin.git / blobdiff