X-Git-Url: https://cloud.milkyroute.net/gitweb/dolphin.git/blobdiff_plain/321f747ddf9cf71ed3c8fa4de287d131cd22c2d8..edced8460b:/src/panels/places/placesitemmodel.cpp diff --git a/src/panels/places/placesitemmodel.cpp b/src/panels/places/placesitemmodel.cpp index 48f54b276..8ac6b46a8 100644 --- a/src/panels/places/placesitemmodel.cpp +++ b/src/panels/places/placesitemmodel.cpp @@ -1,126 +1,77 @@ -/*************************************************************************** - * Copyright (C) 2012 by Peter Penz * - * * - * Based on KFilePlacesModel from kdelibs: * - * Copyright (C) 2007 Kevin Ottens * - * Copyright (C) 2007 David Faure * - * * - * 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 * - ***************************************************************************/ +/* + * SPDX-FileCopyrightText: 2012 Peter Penz + * + * Based on KFilePlacesModel from kdelibs: + * SPDX-FileCopyrightText: 2007 Kevin Ottens + * SPDX-FileCopyrightText: 2007 David Faure + * + * SPDX-License-Identifier: GPL-2.0-or-later + */ #include "placesitemmodel.h" -#ifdef HAVE_NEPOMUK - #include - #include - #include - #include - #include - #include - #include -#endif - -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include "dolphin_generalsettings.h" +#include "dolphindebug.h" +#include "dolphinplacesmodelsingleton.h" #include "placesitem.h" -#include -#include +#include "placesitemsignalhandler.h" +#include "views/dolphinview.h" +#include "views/viewproperties.h" -#include +#include +#include +#include #include +#include +#include +#include + +#include +#include +#include +#include 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(DolphinPlacesModelSingleton::instance().placesModel()) +{ + cleanupBookmarks(); loadBookmarks(); + initializeDefaultViewProperties(); + + connect(m_sourceModel, &KFilePlacesModel::rowsInserted, this, &PlacesItemModel::onSourceModelRowsInserted); + connect(m_sourceModel, &KFilePlacesModel::rowsAboutToBeRemoved, this, &PlacesItemModel::onSourceModelRowsAboutToBeRemoved); + connect(m_sourceModel, &KFilePlacesModel::dataChanged, this, &PlacesItemModel::onSourceModelDataChanged); + connect(m_sourceModel, &KFilePlacesModel::rowsAboutToBeMoved, this, &PlacesItemModel::onSourceModelRowsAboutToBeMoved); + connect(m_sourceModel, &KFilePlacesModel::rowsMoved, this, &PlacesItemModel::onSourceModelRowsMoved); + connect(m_sourceModel, &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, const QString &appName) { - return dynamic_cast(item(index)); + createPlacesItem(text, url, iconName, appName, -1); } -int PlacesItemModel::hiddenCount() const +void PlacesItemModel::createPlacesItem(const QString &text, const QUrl &url, const QString &iconName, const QString &appName, int after) { - int modelIndex = 0; - int itemCount = 0; - foreach (const PlacesItem* hiddenItem, m_hiddenItems) { - if (hiddenItem) { - ++itemCount; - } else { - if (placesItem(modelIndex)->isHidden()) { - ++itemCount; - } - ++modelIndex; - } - } - - return itemCount; + m_sourceModel->addPlace(text, url, iconName, appName, mapToSource(after)); } -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(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) @@ -132,35 +83,21 @@ 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"; - showModelState(); -#endif } bool PlacesItemModel::hiddenItemsShown() const @@ -168,451 +105,680 @@ bool PlacesItemModel::hiddenItemsShown() const 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); +} - 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); +} + +void PlacesItemModel::onItemChanged(int index, const QSet& 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()) { - 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() && + device.as()->isAccessible(); + if (!providesTearDown) { + return nullptr; + } + + Solid::StorageDrive* drive = device.as(); + if (!drive) { + drive = device.parent().as(); + } + + 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()) { + 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(); + 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); + Q_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(); + 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); + Q_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() + && !m_storageSetupInProgress.contains(device.as()) + && !device.as()->isAccessible(); + if (setup) { + Solid::StorageAccess* access = device.as(); + + 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 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 +{ + return index >= 0 && index < count(); +} + +void PlacesItemModel::dropMimeDataBefore(int index, const QMimeData* mimeData) { - KBookmarkGroup root = m_bookmarkManager->root(); - KBookmark bookmark = root.first(); - QSet devices = m_availableDevices; + 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; + + QModelIndex sourceIndex = mapToSource(index); + QModelIndex oldSourceIndex = mapToSource(oldIndex); + + m_sourceModel->movePlace(oldSourceIndex.row(), sourceIndex.row()); + } else if (mimeData->hasFormat(QStringLiteral("text/uri-list"))) { + // One or more items must be added to the model + const QList 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 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 placesItems; - QList 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 = new PlacesItem(bookmark); + updateItem(item, index); + insertSortedItem(item); - const bool allowedHere = (appName.isEmpty() || appName == KGlobal::mainComponent().componentName()) - && (m_nepomukRunning || url.protocol() != QLatin1String("timeline")); + if (m_sourceModel->isDevice(index)) { + connect(item->signalHandler(), &PlacesItemSignalHandler::tearDownExternallyRequested, + this, &PlacesItemModel::storageTearDownExternallyRequested); + } +} - if ((udi.isEmpty() && allowedHere) || deviceAvailable) { - PlacesItem* item = new PlacesItem(bookmark); - if (deviceAvailable) { - devicesItems.append(item); - } else { - placesItems.append(item); +void PlacesItemModel::removeItemByIndex(const QModelIndex &sourceIndex) +{ + QString id = bookmarkId(m_sourceModel->bookmarkForIndex(sourceIndex)); - if (missingSystemBookmarks.contains(url)) { - missingSystemBookmarks.remove(url); + for (int i = 0, iMax = count(); i < iMax; ++i) { + if (bookmarkId(placesItem(i)->bookmark()) == id) { + removeItem(i); + return; + } + } +} + +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", "height", "width"}); + } 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); } +} - addItems(placesItems); +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()); +} - 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); - } +void PlacesItemModel::slotStorageTearDownDone(Solid::ErrorType error, const QVariant& errorData) +{ + if (error && errorData.isValid()) { + if (error == Solid::ErrorType::DeviceBusy) { + KListOpenFilesJob* listOpenFilesJob = new KListOpenFilesJob(m_deviceToTearDown->filePath()); + connect(listOpenFilesJob, &KIO::Job::result, this, [this, listOpenFilesJob](KJob*) { + const KProcessList::KProcessInfoList blockingProcesses = listOpenFilesJob->processInfoList(); + QString errorString; + if (blockingProcesses.isEmpty()) { + errorString = i18n("One or more files on this device are open within an application."); + } else { + QStringList blockingApps; + for (const auto& process : blockingProcesses) { + blockingApps << process.name(); + } + blockingApps.removeDuplicates(); + errorString = xi18np("One or more files on this device are opened in application \"%2\".", + "One or more files on this device are opened in following applications: %2.", + blockingApps.count(), blockingApps.join(i18nc("separator in list of apps blocking device unmount", ", "))); + } + Q_EMIT errorMessage(errorString); + }); + listOpenFilesJob->start(); + } else { + Q_EMIT errorMessage(errorData.toString()); } + } else { + // No error; it must have been unmounted successfully + emit storageTearDownSuccessful(); } + disconnect(m_deviceToTearDown, &Solid::StorageAccess::teardownDone, + this, &PlacesItemModel::slotStorageTearDownDone); + m_deviceToTearDown = nullptr; +} - // Create items for devices that have not stored as bookmark yet - foreach (const QString& udi, devices) { - PlacesItem* item = new PlacesItem(udi); - devicesItems.append(item); +void PlacesItemModel::slotStorageSetupDone(Solid::ErrorType error, + const QVariant& errorData, + const QString& udi) +{ + Q_UNUSED(udi) + + const int index = m_storageSetupInProgress.take(sender()); + const PlacesItem* item = placesItem(index); + if (!item) { + return; } - addItems(devicesItems); + if (error != Solid::NoError) { + if (errorData.isValid()) { + Q_EMIT errorMessage(i18nc("@info", "An error occurred while accessing '%1', the system responded: %2", + item->text(), + errorData.toString())); + } else { + Q_EMIT errorMessage(i18nc("@info", "An error occurred while accessing '%1'", + item->text())); + } + Q_EMIT storageSetupDone(index, false); + } else { + Q_EMIT storageSetupDone(index, true); + } +} -#ifdef PLACESITEMMODEL_DEBUG - kDebug() << "Loaded bookmarks"; - showModelState(); -#endif +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::addItems(const QList& items) +void PlacesItemModel::onSourceModelRowsAboutToBeRemoved(const QModelIndex &parent, int first, int last) { - foreach (PlacesItem* item, items) { - if (item->isHidden()) { - m_hiddenItems.append(item); - } else { - appendItem(item); + 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::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& 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; - } - ++hiddenIndex; +void PlacesItemModel::onSourceModelRowsAboutToBeMoved(const QModelIndex &parent, int start, int end, const QModelIndex &destination, int row) +{ + Q_UNUSED(destination) + Q_UNUSED(row) + + for(int r = start; r <= end; r++) { + const QModelIndex sourceIndex = m_sourceModel->index(r, 0, parent); + // remove moved item + removeItem(mapFromSource(sourceIndex)); } +} + +void PlacesItemModel::onSourceModelRowsMoved(const QModelIndex &parent, int start, int end, const QModelIndex &destination, int row) +{ + Q_UNUSED(destination) + Q_UNUSED(parent) - return hiddenIndex >= m_hiddenItems.count() ? -1 : hiddenIndex; + 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); + } } -QString PlacesItemModel::placesGroupName() +void PlacesItemModel::onSourceModelDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight, const QVector &roles) { - return i18nc("@item", "Places"); + 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)) { + // must update the bookmark object + placeItem->setBookmark(bookmark); + } + } } -QString PlacesItemModel::recentlyAccessedGroupName() +void PlacesItemModel::onSourceModelGroupHiddenChanged(KFilePlacesModel::GroupType group, bool hidden) { - return i18nc("@item", "Recently Accessed"); + const auto groupIndexes = m_sourceModel->groupIndexes(group); + for (const QModelIndex &sourceIndex : groupIndexes) { + PlacesItem *item = placesItem(mapFromSource(sourceIndex)); + if (item) { + item->setGroupHidden(hidden); + } + } } -QString PlacesItemModel::searchForGroupName() +void PlacesItemModel::cleanupBookmarks() { - return i18nc("@item", "Search For"); + // 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 + + static const QVector 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")) + }; + + 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() + DolphinPlacesModelSingleton::applicationNameSuffix()) && balooURLs.contains(url)) { + qCDebug(DolphinDebug) << "Removing old baloo url:" << url; + m_sourceModel->removePlace(sourceIndex); + } else { + row++; + } + } while (row < m_sourceModel->rowCount()); } -KUrl PlacesItemModel::translatedSystemBookmarkUrl(const KUrl& url) +void PlacesItemModel::loadBookmarks() { - KUrl translatedUrl = url; - if (url.protocol() == QLatin1String("timeline")) { - translatedUrl = createTimelineUrl(url); - } else if (url.protocol() == QLatin1String("search")) { - translatedUrl = createSearchUrl(url); + 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); + } } +} - return translatedUrl; +void PlacesItemModel::clear() { + KStandardItemModel::clear(); } -KUrl PlacesItemModel::createTimelineUrl(const KUrl& url) +void PlacesItemModel::proceedWithTearDown() { - // TODO: Clarify with the Nepomuk-team whether it makes sense - // provide default-timeline-URLs like 'yesterday', 'this month' - // and 'last month'. - KUrl timelineUrl; + Q_ASSERT(m_deviceToTearDown); - 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; + 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); +} + +void PlacesItemModel::refresh() +{ + m_sourceModel->refresh(); +} + +void PlacesItemModel::hideItem(int index) +{ + PlacesItem* shownItem = placesItem(index); + if (!shownItem) { + return; } - return timelineUrl; + shownItem->setHidden(true); } -QString PlacesItemModel::timelineDateString(int year, int month, int day) +QString PlacesItemModel::internalMimeType() const { - QString date = QString::number(year) + '-'; - if (month < 10) { - date += '0'; + return "application/x-dolphinplacesmodel-" + + QString::number((qptrdiff)this); +} + +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; } - date += QString::number(month); - if (day >= 1) { - date += '-'; - if (day < 10) { - date += '0'; + // 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; } - date += QString::number(day); } - return date; + // 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; + } + } + + // 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; } -KUrl PlacesItemModel::createSearchUrl(const KUrl& url) +bool PlacesItemModel::equalBookmarkIdentifiers(const KBookmark& b1, const KBookmark& b2) { - KUrl searchUrl; - -#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"))); + const QString udi1 = b1.metaDataItem(QStringLiteral("UDI")); + const QString udi2 = b2.metaDataItem(QStringLiteral("UDI")); + if (!udi1.isEmpty() && !udi2.isEmpty()) { + return udi1 == udi2; } else { - Q_ASSERT(false); + return b1.metaDataItem(QStringLiteral("ID")) == b2.metaDataItem(QStringLiteral("ID")); + } +} + +int PlacesItemModel::mapFromSource(const QModelIndex &index) const +{ + if (!index.isValid()) { + return -1; } -#else - Q_UNUSED(url); -#endif - return searchUrl; + return m_indexMap.indexOf(index); } -#ifdef HAVE_NEPOMUK -KUrl PlacesItemModel::searchUrlForTerm(const Nepomuk::Query::Term& term) +bool PlacesItemModel::isDir(int index) const { - const Nepomuk::Query::Query query(term); - return query.toSearchUrl(); + Q_UNUSED(index) + return true; } -#endif -#ifdef PLACESITEMMODEL_DEBUG -void PlacesItemModel::showModelState() +KFilePlacesModel::GroupType PlacesItemModel::groupType(int row) const { - 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(); - } else { - kDebug() << i << " " << j << " " << item(j)->dataValue("text").toString(); - ++j; + return m_sourceModel->groupType(mapToSource(row)); +} + +bool PlacesItemModel::isGroupHidden(KFilePlacesModel::GroupType type) const +{ + return m_sourceModel->isGroupHidden(type); +} + +void PlacesItemModel::setGroupHidden(KFilePlacesModel::GroupType type, bool hidden) +{ + 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 -#include "placesitemmodel.moc"