-/***************************************************************************
- * Copyright (C) 2012 by Peter Penz <peter.penz19@gmail.com> *
- * *
- * Based on KFilePlacesModel from kdelibs: *
- * Copyright (C) 2007 Kevin Ottens <ervin@kde.org> *
- * Copyright (C) 2007 David Faure <faure@kde.org> *
- * *
- * This program is free software; you can redistribute it and/or modify *
- * it under the terms of the GNU General Public License as published by *
- * the Free Software Foundation; either version 2 of the License, or *
- * (at your option) any later version. *
- * *
- * This program is distributed in the hope that it will be useful, *
- * but WITHOUT ANY WARRANTY; without even the implied warranty of *
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
- * GNU General Public License for more details. *
- * *
- * You should have received a copy of the GNU General Public License *
- * along with this program; if not, write to the *
- * Free Software Foundation, Inc., *
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA *
- ***************************************************************************/
+/*
+ * SPDX-FileCopyrightText: 2012 Peter Penz <peter.penz19@gmail.com>
+ *
+ * Based on KFilePlacesModel from kdelibs:
+ * SPDX-FileCopyrightText: 2007 Kevin Ottens <ervin@kde.org>
+ * SPDX-FileCopyrightText: 2007 David Faure <faure@kde.org>
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
#include "placesitemmodel.h"
#include "dolphin_generalsettings.h"
-
-#include <KBookmark>
-#include <KBookmarkManager>
#include "dolphindebug.h"
-#include <QIcon>
-#include <KProtocolInfo>
-#include <KLocalizedString>
-#include <QStandardPaths>
-#include <KUser>
-#include <KAboutData>
+#include "dolphinplacesmodelsingleton.h"
#include "placesitem.h"
-#include <QAction>
-#include <QDate>
-#include <QMimeData>
-#include <QTimer>
-#include <KUrlMimeData>
+#include "placesitemsignalhandler.h"
+#include "views/dolphinview.h"
+#include "views/viewproperties.h"
-#include <Solid/Device>
+#include <KAboutData>
+#include <KLocalizedString>
+#include <KUrlMimeData>
#include <Solid/DeviceNotifier>
-#include <Solid/OpticalDisc>
#include <Solid/OpticalDrive>
-#include <Solid/StorageAccess>
-#include <Solid/StorageDrive>
-
-#include <views/dolphinview.h>
-#include <views/viewproperties.h>
-
-#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 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 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";
-}
+#include <KCoreAddons/KProcessList>
+#include <KCoreAddons/KListOpenFilesJob>
+
+#include <QAction>
+#include <QIcon>
+#include <QMimeData>
+#include <QTimer>
PlacesItemModel::PlacesItemModel(QObject* parent) :
KStandardItemModel(parent),
- m_fileIndexingEnabled(false),
m_hiddenItemsShown(false),
- m_availableDevices(),
- m_predicate(),
- m_bookmarkManager(0),
- m_systemBookmarks(),
- m_systemBookmarksIndexes(),
- m_bookmarkedItems(),
- m_hiddenItemToRemove(-1),
- m_updateBookmarksTimer(0),
- m_storageSetupInProgress()
+ m_deviceToTearDown(nullptr),
+ m_storageSetupInProgress(),
+ m_sourceModel(DolphinPlacesModelSingleton::instance().placesModel())
{
-#ifdef HAVE_BALOO
- Baloo::IndexerConfig config;
- m_fileIndexingEnabled = config.fileIndexingEnabled();
-#endif
- const QString file = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + "/user-places.xbel";
- m_bookmarkManager = KBookmarkManager::managerForExternalFile(file);
-
- createSystemBookmarks();
- initializeAvailableDevices();
+ cleanupBookmarks();
loadBookmarks();
+ initializeDefaultViewProperties();
- const int syncBookmarksTimeout = 100;
-
- m_updateBookmarksTimer = new QTimer(this);
- m_updateBookmarksTimer->setInterval(syncBookmarksTimeout);
- m_updateBookmarksTimer->setSingleShot(true);
- connect(m_updateBookmarksTimer, &QTimer::timeout, this, &PlacesItemModel::updateBookmarks);
-
- connect(m_bookmarkManager, &KBookmarkManager::changed,
- m_updateBookmarksTimer, static_cast<void(QTimer::*)()>(&QTimer::start));
+ 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_bookmarkedItems);
- m_bookmarkedItems.clear();
}
-PlacesItem* PlacesItemModel::createPlacesItem(const QString& text,
- const QUrl& url,
- const QString& iconName)
+void PlacesItemModel::createPlacesItem(const QString &text, const QUrl &url, const QString &iconName, const QString &appName)
+{
+ createPlacesItem(text, url, iconName, appName, -1);
+}
+
+void PlacesItemModel::createPlacesItem(const QString &text, const QUrl &url, const QString &iconName, const QString &appName, int after)
{
- const KBookmark bookmark = PlacesItem::createBookmark(m_bookmarkManager, text, url, iconName);
- return new PlacesItem(bookmark);
+ m_sourceModel->addPlace(text, url, iconName, appName, mapToSource(after));
}
PlacesItem* PlacesItemModel::placesItem(int index) const
int PlacesItemModel::hiddenCount() const
{
- int modelIndex = 0;
- int hiddenItemCount = 0;
- foreach (const PlacesItem* item, m_bookmarkedItems) {
- if (item) {
- ++hiddenItemCount;
- } else {
- if (placesItem(modelIndex)->isHidden()) {
- ++hiddenItemCount;
- }
- ++modelIndex;
- }
- }
-
- return hiddenItemCount;
+ return m_sourceModel->hiddenCount();
}
void PlacesItemModel::setHiddenItemsShown(bool show)
m_hiddenItemsShown = show;
if (show) {
- // Move all items that are part of m_bookmarkedItems to the model.
- QList<PlacesItem*> itemsToInsert;
- QList<int> insertPos;
- int modelIndex = 0;
- for (int i = 0; i < m_bookmarkedItems.count(); ++i) {
- if (m_bookmarkedItems[i]) {
- itemsToInsert.append(m_bookmarkedItems[i]);
- m_bookmarkedItems[i] = 0;
- insertPos.append(modelIndex);
+ 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;
- }
-
- // Inserting the items will automatically insert an item
- // to m_bookmarkedItems in PlacesItemModel::onItemsInserted().
- // The items are temporary saved in itemsToInsert, so
- // m_bookmarkedItems can be shrinked now.
- m_bookmarkedItems.erase(m_bookmarkedItems.begin(),
- m_bookmarkedItems.begin() + itemsToInsert.count());
-
- for (int i = 0; i < itemsToInsert.count(); ++i) {
- insertItem(insertPos[i], itemsToInsert[i]);
+ addItemFromSourceModel(index);
}
-
- Q_ASSERT(m_bookmarkedItems.count() == count());
} else {
- // Move all items of the model, where the "isHidden" property is true, to
- // m_bookmarkedItems.
- Q_ASSERT(m_bookmarkedItems.count() == count());
- for (int i = count() - 1; i >= 0; --i) {
- if (placesItem(i)->isHidden()) {
- hideItem(i);
+ 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
- qCDebug(DolphinDebug) << "Changed visibility of hidden items";
- showModelState();
-#endif
}
bool PlacesItemModel::hiddenItemsShown() const
int PlacesItemModel::closestItem(const QUrl& url) const
{
- int foundIndex = -1;
- int maxLength = 0;
-
- for (int i = 0; i < count(); ++i) {
- 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;
- }
- }
- }
-
- return foundIndex;
+ return mapFromSource(m_sourceModel->closestItem(url));
}
-void PlacesItemModel::appendItemToGroup(PlacesItem* item)
+// look for the correct position for the item based on source model
+void PlacesItemModel::insertSortedItem(PlacesItem* item)
{
if (!item) {
return;
}
- int i = 0;
- while (i < count() && placesItem(i)->group() != item->group()) {
- ++i;
- }
+ 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);
- bool inserted = false;
- while (!inserted && i < count()) {
- if (placesItem(i)->group() != item->group()) {
- insertItem(i, item);
- inserted = true;
+ if (bookmarkId(sourceBookmark) == iBookmarkId) {
+ break;
}
- ++i;
- }
- if (!inserted) {
- appendItem(item);
+ if (m_hiddenItemsShown || !m_sourceModel->isHidden(sourceIndex)) {
+ pos++;
+ }
}
+
+ m_indexMap.insert(pos, sourceIndex);
+ insertItem(pos, item);
}
+void PlacesItemModel::onItemInserted(int index)
+{
+ KStandardItemModel::onItemInserted(index);
+}
+
+void PlacesItemModel::onItemRemoved(int index, KStandardItem* removedItem)
+{
+ m_indexMap.removeAt(index);
+
+ KStandardItemModel::onItemRemoved(index, removedItem);
+}
+
+void PlacesItemModel::onItemChanged(int index, const QSet<QByteArray>& changedRoles)
+{
+ const QModelIndex sourceIndex = mapToSource(index);
+ const PlacesItem *changedItem = placesItem(mapFromSource(sourceIndex));
+
+ 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(QIcon::fromTheme("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
{
const PlacesItem* item = placesItem(index);
if (!item) {
- return 0;
+ return nullptr;
}
Solid::Device device = item->device();
const bool providesTearDown = device.is<Solid::StorageAccess>() &&
device.as<Solid::StorageAccess>()->isAccessible();
if (!providesTearDown) {
- return 0;
+ return nullptr;
}
Solid::StorageDrive* drive = device.as<Solid::StorageDrive>();
QString iconName;
QString text;
- const QString label = item->text();
if (device.is<Solid::OpticalDisc>()) {
- text = i18nc("@item", "Release '%1'", label);
+ text = i18nc("@item", "Release");
} else if (removable || hotPluggable) {
- text = i18nc("@item", "Safely Remove '%1'", label);
- iconName = "media-eject";
+ text = i18nc("@item", "Safely Remove");
+ iconName = QStringLiteral("media-eject");
} else {
- text = i18nc("@item", "Unmount '%1'", label);
- iconName = "media-eject";
+ text = i18nc("@item", "Unmount");
+ iconName = QStringLiteral("media-eject");
}
if (iconName.isEmpty()) {
- return new QAction(text, 0);
+ return new QAction(text, nullptr);
}
- return new QAction(QIcon::fromTheme(iconName), text, 0);
+ return new QAction(QIcon::fromTheme(iconName), text, nullptr);
}
void PlacesItemModel::requestEject(int index)
Solid::OpticalDrive* drive = item->device().parent().as<Solid::OpticalDrive>();
if (drive) {
connect(drive, &Solid::OpticalDrive::ejectDone,
- this, &PlacesItemModel::slotStorageTeardownDone);
+ 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);
+ Q_EMIT errorMessage(message);
}
}
}
-void PlacesItemModel::requestTeardown(int index)
+void PlacesItemModel::requestTearDown(int index)
{
const PlacesItem* item = placesItem(index);
if (item) {
- Solid::StorageAccess* access = item->device().as<Solid::StorageAccess>();
- if (access) {
- connect(access, &Solid::StorageAccess::teardownDone,
- this, &PlacesItemModel::slotStorageTeardownDone);
- access->teardown();
+ 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);
+ Q_EMIT storageTearDownRequested(tmp->filePath());
}
}
}
QDataStream stream(&itemData, QIODevice::WriteOnly);
- foreach (int index, indexes) {
+ for (int index : indexes) {
const QUrl itemUrl = placesItem(index)->url();
if (itemUrl.isValid()) {
urls << itemUrl;
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);
QDataStream stream(&itemData, QIODevice::ReadOnly);
int oldIndex;
stream >> oldIndex;
- if (oldIndex == index || oldIndex == index - 1) {
- // No moving has been done
- return;
- }
- PlacesItem* oldItem = placesItem(oldIndex);
- if (!oldItem) {
- return;
- }
+ QModelIndex sourceIndex = mapToSource(index);
+ QModelIndex oldSourceIndex = mapToSource(oldIndex);
- PlacesItem* newItem = new PlacesItem(oldItem->bookmark());
- removeItem(oldIndex);
-
- if (oldIndex < index) {
- --index;
- }
-
- const int dropIndex = groupedDropIndex(index, newItem);
- insertItem(dropIndex, newItem);
- } else if (mimeData->hasFormat("text/uri-list")) {
+ 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<QUrl> urls = KUrlMimeData::urlsFromMimeData(mimeData);
for (int i = urls.count() - 1; i >= 0; --i) {
}
if ((url.isLocalFile() && !QFileInfo(url.toLocalFile()).isDir())
- || url.scheme() == "trash") {
+ || url.scheme() == QLatin1String("trash")) {
// Only directories outside the trash are allowed
continue;
}
- PlacesItem* newItem = createPlacesItem(text, url);
- const int dropIndex = groupedDropIndex(index, newItem);
- insertItem(dropIndex, newItem);
+ 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();
}
-QUrl PlacesItemModel::convertedUrl(const QUrl& url)
+void PlacesItemModel::addItemFromSourceModel(const QModelIndex &index)
{
- QUrl newUrl = url;
- if (url.scheme() == QLatin1String("timeline")) {
- newUrl = createTimelineUrl(url);
- } else if (url.scheme() == QLatin1String("search")) {
- newUrl = createSearchUrl(url);
- }
-
- return newUrl;
-}
-
-void PlacesItemModel::onItemInserted(int index)
-{
- const PlacesItem* insertedItem = placesItem(index);
- if (insertedItem) {
- // Take care to apply the PlacesItemModel-order of the inserted item
- // also to the bookmark-manager.
- const KBookmark insertedBookmark = insertedItem->bookmark();
-
- const PlacesItem* previousItem = placesItem(index - 1);
- KBookmark previousBookmark;
- if (previousItem) {
- previousBookmark = previousItem->bookmark();
- }
-
- m_bookmarkManager->root().moveBookmark(insertedBookmark, previousBookmark);
- }
-
- if (index == count() - 1) {
- // The item has been appended as last item to the list. In this
- // case assure that it is also appended after the hidden items and
- // not before (like done otherwise).
- m_bookmarkedItems.append(0);
- } else {
-
- int modelIndex = -1;
- int bookmarkIndex = 0;
- while (bookmarkIndex < m_bookmarkedItems.count()) {
- if (!m_bookmarkedItems[bookmarkIndex]) {
- ++modelIndex;
- if (modelIndex + 1 == index) {
- break;
- }
- }
- ++bookmarkIndex;
- }
- m_bookmarkedItems.insert(bookmarkIndex, 0);
+ if (!m_hiddenItemsShown && m_sourceModel->isHidden(index)) {
+ return;
}
-#ifdef PLACESITEMMODEL_DEBUG
- qCDebug(DolphinDebug) << "Inserted item" << index;
- showModelState();
-#endif
-}
+ const KBookmark bookmark = m_sourceModel->bookmarkForIndex(index);
+ Q_ASSERT(!bookmark.isNull());
+ PlacesItem *item = new PlacesItem(bookmark);
+ updateItem(item, index);
+ insertSortedItem(item);
-void PlacesItemModel::onItemRemoved(int index, KStandardItem* removedItem)
-{
- PlacesItem* placesItem = dynamic_cast<PlacesItem*>(removedItem);
- if (placesItem) {
- const KBookmark bookmark = placesItem->bookmark();
- m_bookmarkManager->root().deleteBookmark(bookmark);
+ if (m_sourceModel->isDevice(index)) {
+ connect(item->signalHandler(), &PlacesItemSignalHandler::tearDownExternallyRequested,
+ this, &PlacesItemModel::storageTearDownExternallyRequested);
}
-
- const int boomarkIndex = bookmarkIndex(index);
- Q_ASSERT(!m_bookmarkedItems[boomarkIndex]);
- m_bookmarkedItems.removeAt(boomarkIndex);
-
-#ifdef PLACESITEMMODEL_DEBUG
- qCDebug(DolphinDebug) << "Removed item" << index;
- showModelState();
-#endif
}
-void PlacesItemModel::onItemChanged(int index, const QSet<QByteArray>& changedRoles)
+void PlacesItemModel::removeItemByIndex(const QModelIndex &sourceIndex)
{
- const PlacesItem* changedItem = placesItem(index);
- if (changedItem) {
- // Take care to apply the PlacesItemModel-order of the changed item
- // also to the bookmark-manager.
- const KBookmark insertedBookmark = changedItem->bookmark();
-
- const PlacesItem* previousItem = placesItem(index - 1);
- KBookmark previousBookmark;
- if (previousItem) {
- previousBookmark = previousItem->bookmark();
- }
+ QString id = bookmarkId(m_sourceModel->bookmarkForIndex(sourceIndex));
- m_bookmarkManager->root().moveBookmark(insertedBookmark, previousBookmark);
- }
-
- if (changedRoles.contains("isHidden")) {
- if (!m_hiddenItemsShown && changedItem->isHidden()) {
- m_hiddenItemToRemove = index;
- QTimer::singleShot(0, this, SLOT(hideItem()));
+ for (int i = 0, iMax = count(); i < iMax; ++i) {
+ if (bookmarkId(placesItem(i)->bookmark()) == id) {
+ removeItem(i);
+ return;
}
}
}
-void PlacesItemModel::slotDeviceAdded(const QString& udi)
-{
- const Solid::Device device(udi);
-
- if (!m_predicate.matches(device)) {
- return;
+QString PlacesItemModel::bookmarkId(const KBookmark &bookmark) const
+{
+ QString id = bookmark.metaDataItem(QStringLiteral("UDI"));
+ if (id.isEmpty()) {
+ id = bookmark.metaDataItem(QStringLiteral("ID"));
+ }
+ return id;
+}
+
+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;
+ }
+
+ // 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();
+ }
+ }
}
-
- m_availableDevices << udi;
- const KBookmark bookmark = PlacesItem::createDeviceBookmark(m_bookmarkManager, udi);
- appendItem(new PlacesItem(bookmark));
}
-void PlacesItemModel::slotDeviceRemoved(const QString& udi)
+void PlacesItemModel::updateItem(PlacesItem *item, const QModelIndex &index)
{
- if (!m_availableDevices.contains(udi)) {
- return;
- }
-
- for (int i = 0; i < m_bookmarkedItems.count(); ++i) {
- PlacesItem* item = m_bookmarkedItems[i];
- if (item && item->udi() == udi) {
- m_bookmarkedItems.removeAt(i);
- delete item;
- return;
- }
- }
-
- for (int i = 0; i < count(); ++i) {
- if (placesItem(i)->udi() == udi) {
- removeItem(i);
- return;
- }
- }
+ 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)
+void PlacesItemModel::slotStorageTearDownDone(Solid::ErrorType error, const QVariant& errorData)
{
if (error && errorData.isValid()) {
- emit errorMessage(errorData.toString());
+ 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 <application>\"%2\"</application>.",
+ "One or more files on this device are opened in following applications: <application>%2</application>.",
+ 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
+ Q_EMIT storageTearDownSuccessful();
}
+ disconnect(m_deviceToTearDown, &Solid::StorageAccess::teardownDone,
+ this, &PlacesItemModel::slotStorageTearDownDone);
+ m_deviceToTearDown = nullptr;
}
void PlacesItemModel::slotStorageSetupDone(Solid::ErrorType error,
const QVariant& errorData,
const QString& udi)
{
- Q_UNUSED(udi);
+ Q_UNUSED(udi)
const int index = m_storageSetupInProgress.take(sender());
const PlacesItem* item = placesItem(index);
if (error != Solid::NoError) {
if (errorData.isValid()) {
- emit errorMessage(i18nc("@info", "An error occurred while accessing '%1', the system responded: %2",
+ Q_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'",
+ Q_EMIT errorMessage(i18nc("@info", "An error occurred while accessing '%1'",
item->text()));
}
- emit storageSetupDone(index, false);
+ Q_EMIT storageSetupDone(index, false);
} else {
- emit storageSetupDone(index, true);
+ Q_EMIT storageSetupDone(index, true);
}
}
-void PlacesItemModel::hideItem()
+void PlacesItemModel::onSourceModelRowsInserted(const QModelIndex &parent, int first, int last)
{
- hideItem(m_hiddenItemToRemove);
- m_hiddenItemToRemove = -1;
+ for (int i = first; i <= last; i++) {
+ const QModelIndex index = m_sourceModel->index(i, 0, parent);
+ addItemFromSourceModel(index);
+ }
}
-void PlacesItemModel::updateBookmarks()
+void PlacesItemModel::onSourceModelRowsAboutToBeRemoved(const QModelIndex &parent, int first, int last)
{
- // Verify whether new bookmarks have been added or existing
- // bookmarks have been changed.
- KBookmarkGroup root = m_bookmarkManager->root();
- KBookmark newBookmark = root.first();
- while (!newBookmark.isNull()) {
- if (acceptBookmark(newBookmark, m_availableDevices)) {
- bool found = false;
- int modelIndex = 0;
- for (int i = 0; i < m_bookmarkedItems.count(); ++i) {
- PlacesItem* item = m_bookmarkedItems[i];
- if (!item) {
- item = placesItem(modelIndex);
- ++modelIndex;
- }
-
- const KBookmark oldBookmark = item->bookmark();
- if (equalBookmarkIdentifiers(newBookmark, oldBookmark)) {
- // The bookmark has been found in the model or as
- // a hidden item. The content of the bookmark might
- // have been changed, so an update is done.
- found = true;
- if (newBookmark.metaDataItem("UDI").isEmpty()) {
- item->setBookmark(newBookmark);
- item->setText(i18nc("KFile System Bookmarks", newBookmark.text().toUtf8().constData()));
- }
- break;
- }
- }
-
- if (!found) {
- const QString udi = newBookmark.metaDataItem("UDI");
-
- /*
- * See Bug 304878
- * Only add a new places item, if the item text is not empty
- * and if the device is available. Fixes the strange behaviour -
- * add a places item without text in the Places section - when you
- * remove a device (e.g. a usb stick) without unmounting.
- */
- if (udi.isEmpty() || Solid::Device(udi).isValid()) {
- PlacesItem* item = new PlacesItem(newBookmark);
- if (item->isHidden() && !m_hiddenItemsShown) {
- m_bookmarkedItems.append(item);
- } else {
- appendItemToGroup(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);
}
-
- newBookmark = root.next(newBookmark);
}
+}
- // Remove items that are not part of the bookmark-manager anymore
- int modelIndex = 0;
- for (int i = m_bookmarkedItems.count() - 1; i >= 0; --i) {
- PlacesItem* item = m_bookmarkedItems[i];
- const bool itemIsPartOfModel = (item == 0);
- if (itemIsPartOfModel) {
- item = placesItem(modelIndex);
- }
-
- bool hasBeenRemoved = true;
- const KBookmark oldBookmark = item->bookmark();
- KBookmark newBookmark = root.first();
- while (!newBookmark.isNull()) {
- if (equalBookmarkIdentifiers(newBookmark, oldBookmark)) {
- hasBeenRemoved = false;
- break;
- }
- newBookmark = root.next(newBookmark);
- }
-
- if (hasBeenRemoved) {
- if (m_bookmarkedItems[i]) {
- delete m_bookmarkedItems[i];
- m_bookmarkedItems.removeAt(i);
- } else {
- removeItem(modelIndex);
- --modelIndex;
- }
- }
+void PlacesItemModel::onSourceModelRowsAboutToBeMoved(const QModelIndex &parent, int start, int end, const QModelIndex &destination, int row)
+{
+ Q_UNUSED(destination)
+ Q_UNUSED(row)
- if (itemIsPartOfModel) {
- ++modelIndex;
- }
+ for(int r = start; r <= end; r++) {
+ const QModelIndex sourceIndex = m_sourceModel->index(r, 0, parent);
+ // remove moved item
+ removeItem(mapFromSource(sourceIndex));
}
}
-void PlacesItemModel::saveBookmarks()
+void PlacesItemModel::onSourceModelRowsMoved(const QModelIndex &parent, int start, int end, const QModelIndex &destination, int row)
{
- m_bookmarkManager->emitChanged(m_bookmarkManager->root());
-}
+ Q_UNUSED(destination)
+ Q_UNUSED(parent)
-void PlacesItemModel::loadBookmarks()
-{
- KBookmarkGroup root = m_bookmarkManager->root();
- KBookmark bookmark = root.first();
- QSet<QString> devices = m_availableDevices;
+ const int blockSize = (end - start) + 1;
- QSet<QUrl> missingSystemBookmarks;
- foreach (const SystemBookmarkData& data, m_systemBookmarks) {
- missingSystemBookmarks.insert(data.url);
- }
+ 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);
- // The bookmarks might have a mixed order of places, devices and search-groups due
- // to the compatibility with the KFilePlacesPanel. In Dolphin's places panel the
- // 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*> recentlySavedItems;
- QList<PlacesItem*> searchForItems;
- QList<PlacesItem*> devicesItems;
-
- while (!bookmark.isNull()) {
- if (acceptBookmark(bookmark, devices)) {
- PlacesItem* item = new PlacesItem(bookmark);
- if (item->groupType() == PlacesItem::DevicesType) {
- devices.remove(item->udi());
- devicesItems.append(item);
- } else {
- const QUrl url = bookmark.url();
- if (missingSystemBookmarks.contains(url)) {
- missingSystemBookmarks.remove(url);
-
- // Try to retranslate the text of system bookmarks to have translated
- // items when changing the language. In case if the user has applied a custom
- // 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().constData()));
- item->setSystemItem(true);
- }
+ addItemFromSourceModel(targetIndex);
+ }
+}
- switch (item->groupType()) {
- 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;
- }
- }
- }
+void PlacesItemModel::onSourceModelDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight, const QVector<int> &roles)
+{
+ Q_UNUSED(roles)
- bookmark = root.next(bookmark);
- }
+ 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 (!missingSystemBookmarks.isEmpty()) {
- // The current bookmarks don't contain all system-bookmarks. Add the missing
- // bookmarks.
- foreach (const SystemBookmarkData& data, m_systemBookmarks) {
- if (missingSystemBookmarks.contains(data.url)) {
- PlacesItem* item = createSystemPlacesItem(data);
- switch (item->groupType()) {
- 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;
- }
- }
+ if (placeItem && (!m_hiddenItemsShown && m_sourceModel->isHidden(sourceIndex))) {
+ //hide item if it became invisible
+ removeItem(index(placeItem));
+ return;
}
- }
-
- // Create items for devices that have not been stored as bookmark yet
- 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(recentlySavedItems);
- items.append(searchForItems);
- items.append(devicesItems);
+ if (!placeItem && (m_hiddenItemsShown || !m_sourceModel->isHidden(sourceIndex))) {
+ //show item if it became visible
+ addItemFromSourceModel(sourceIndex);
+ return;
+ }
- foreach (PlacesItem* item, items) {
- if (!m_hiddenItemsShown && item->isHidden()) {
- m_bookmarkedItems.append(item);
- } else {
- appendItem(item);
+ if (placeItem && !m_sourceModel->isDevice(sourceIndex)) {
+ // must update the bookmark object
+ placeItem->setBookmark(bookmark);
}
}
-
-#ifdef PLACESITEMMODEL_DEBUG
- qCDebug(DolphinDebug) << "Loaded bookmarks";
- showModelState();
-#endif
}
-bool PlacesItemModel::acceptBookmark(const KBookmark& bookmark,
- const QSet<QString>& availableDevices) const
+void PlacesItemModel::onSourceModelGroupHiddenChanged(KFilePlacesModel::GroupType group, bool hidden)
{
- const QString udi = bookmark.metaDataItem("UDI");
- const QUrl url = bookmark.url();
- const QString appName = bookmark.metaDataItem("OnlyInApp");
- const bool deviceAvailable = availableDevices.contains(udi);
-
- const bool allowedHere = (appName.isEmpty()
- || appName == KAboutData::applicationData().componentName()
- || appName == KAboutData::applicationData().componentName() + AppNamePrefix)
- && (m_fileIndexingEnabled || (url.scheme() != QLatin1String("timeline") &&
- url.scheme() != QLatin1String("search")));
-
- return (udi.isEmpty() && allowedHere) || deviceAvailable;
+ const auto groupIndexes = m_sourceModel->groupIndexes(group);
+ for (const QModelIndex &sourceIndex : groupIndexes) {
+ PlacesItem *item = placesItem(mapFromSource(sourceIndex));
+ if (item) {
+ item->setGroupHidden(hidden);
+ }
+ }
}
-PlacesItem* PlacesItemModel::createSystemPlacesItem(const SystemBookmarkData& data)
+void PlacesItemModel::cleanupBookmarks()
{
- KBookmark bookmark = PlacesItem::createBookmark(m_bookmarkManager,
- data.text,
- data.url,
- data.icon);
-
- 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 Saved" and "Search For" should be a setting available only
- // in the Places Panel (see description of AppNamePrefix for more details).
- const QString appName = KAboutData::applicationData().componentName() + AppNamePrefix;
- bookmark.setMetaDataItem("OnlyInApp", appName);
- }
+ // 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
- PlacesItem* item = new PlacesItem(bookmark);
- item->setSystemItem(true);
-
- // 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::RecentlySavedType) &&
- !GeneralSettings::self()->globalViewProps();
- if (createDefaultViewProperties) {
- ViewProperties props(convertedUrl(data.url));
- if (!props.exist()) {
- const QString path = data.url.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 (data.url.scheme() == "timeline") {
- props.setViewMode(DolphinView::DetailsView);
- props.setVisibleRoles({"text", "date"});
- }
- }
- }
+ static const QVector<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"))
+ };
- return item;
+ 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());
}
-void PlacesItemModel::createSystemBookmarks()
+void PlacesItemModel::loadBookmarks()
{
- Q_ASSERT(m_systemBookmarks.isEmpty());
- Q_ASSERT(m_systemBookmarksIndexes.isEmpty());
-
- // Note: The context of the I18N_NOOP2 must be "KFile System Bookmarks". The real
- // 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(QUrl::fromLocalFile(KUser().homeDir()),
- "user-home",
- I18N_NOOP2("KFile System Bookmarks", "Home")));
- m_systemBookmarks.append(SystemBookmarkData(QUrl("remote:/"),
- "network-workgroup",
- I18N_NOOP2("KFile System Bookmarks", "Network")));
- m_systemBookmarks.append(SystemBookmarkData(QUrl::fromLocalFile("/"),
- "folder-red",
- I18N_NOOP2("KFile System Bookmarks", "Root")));
- m_systemBookmarks.append(SystemBookmarkData(QUrl("trash:/"),
- "user-trash",
- I18N_NOOP2("KFile System Bookmarks", "Trash")));
-
- if (m_fileIndexingEnabled) {
- m_systemBookmarks.append(SystemBookmarkData(QUrl("timeline:/today"),
- "go-jump-today",
- I18N_NOOP2("KFile System Bookmarks", "Today")));
- m_systemBookmarks.append(SystemBookmarkData(QUrl("timeline:/yesterday"),
- "view-calendar-day",
- I18N_NOOP2("KFile System Bookmarks", "Yesterday")));
- m_systemBookmarks.append(SystemBookmarkData(QUrl("timeline:/thismonth"),
- "view-calendar-month",
- I18N_NOOP2("KFile System Bookmarks", "This Month")));
- m_systemBookmarks.append(SystemBookmarkData(QUrl("timeline:/lastmonth"),
- "view-calendar-month",
- I18N_NOOP2("KFile System Bookmarks", "Last Month")));
- m_systemBookmarks.append(SystemBookmarkData(QUrl("search:/documents"),
- "folder-text",
- I18N_NOOP2("KFile System Bookmarks", "Documents")));
- m_systemBookmarks.append(SystemBookmarkData(QUrl("search:/images"),
- "folder-images",
- I18N_NOOP2("KFile System Bookmarks", "Images")));
- m_systemBookmarks.append(SystemBookmarkData(QUrl("search:/audio"),
- "folder-sound",
- I18N_NOOP2("KFile System Bookmarks", "Audio Files")));
- m_systemBookmarks.append(SystemBookmarkData(QUrl("search:/videos"),
- "folder-videos",
- I18N_NOOP2("KFile System Bookmarks", "Videos")));
- }
-
- for (int i = 0; i < m_systemBookmarks.count(); ++i) {
- m_systemBookmarksIndexes.insert(m_systemBookmarks[i].url, i);
+ 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);
+ }
}
}
void PlacesItemModel::clear() {
- m_bookmarkedItems.clear();
KStandardItemModel::clear();
}
-void PlacesItemModel::initializeAvailableDevices()
+void PlacesItemModel::proceedWithTearDown()
{
- QString predicate("[[[[ 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 ]");
-
-
- if (KProtocolInfo::isKnownProtocol("mtp")) {
- predicate.prepend("[");
- predicate.append(" OR PortableMediaPlayer.supportedProtocols == 'mtp']");
- }
-
- m_predicate = Solid::Predicate::fromString(predicate);
- Q_ASSERT(m_predicate.isValid());
+ Q_ASSERT(m_deviceToTearDown);
- Solid::DeviceNotifier* notifier = Solid::DeviceNotifier::instance();
- 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) {
- m_availableDevices << device.udi();
- }
+ connect(m_deviceToTearDown, &Solid::StorageAccess::teardownDone,
+ this, &PlacesItemModel::slotStorageTearDownDone);
+ m_deviceToTearDown->teardown();
}
-int PlacesItemModel::bookmarkIndex(int index) const
+void PlacesItemModel::deleteItem(int index)
{
- int bookmarkIndex = 0;
- int modelIndex = 0;
- while (bookmarkIndex < m_bookmarkedItems.count()) {
- if (!m_bookmarkedItems[bookmarkIndex]) {
- if (modelIndex == index) {
- break;
- }
- ++modelIndex;
- }
- ++bookmarkIndex;
- }
+ QModelIndex sourceIndex = mapToSource(index);
+ Q_ASSERT(sourceIndex.isValid());
+ m_sourceModel->removePlace(sourceIndex);
+}
- return bookmarkIndex >= m_bookmarkedItems.count() ? -1 : bookmarkIndex;
+void PlacesItemModel::refresh()
+{
+ m_sourceModel->refresh();
}
void PlacesItemModel::hideItem(int index)
}
shownItem->setHidden(true);
- if (m_hiddenItemsShown) {
- // Removing items from the model is not allowed if all hidden
- // items should be shown.
- return;
- }
-
- const int newIndex = bookmarkIndex(index);
- if (newIndex >= 0) {
- const KBookmark hiddenBookmark = shownItem->bookmark();
- PlacesItem* hiddenItem = new PlacesItem(hiddenBookmark);
-
- const PlacesItem* previousItem = placesItem(index - 1);
- KBookmark previousBookmark;
- if (previousItem) {
- previousBookmark = previousItem->bookmark();
- }
-
- const bool updateBookmark = (m_bookmarkManager->root().indexOf(hiddenBookmark) >= 0);
- removeItem(index);
-
- if (updateBookmark) {
- // removeItem() also removed the bookmark from m_bookmarkManager in
- // PlacesItemModel::onItemRemoved(). However for hidden items the
- // bookmark should still be remembered, so readd it again:
- m_bookmarkManager->root().addBookmark(hiddenBookmark);
- m_bookmarkManager->root().moveBookmark(hiddenBookmark, previousBookmark);
- }
-
- m_bookmarkedItems.insert(newIndex, hiddenItem);
- }
}
QString PlacesItemModel::internalMimeType() const
Q_ASSERT(item);
int dropIndex = index;
- const PlacesItem::GroupType type = item->groupType();
+ const QString group = item->group();
const int itemCount = count();
if (index < 0) {
// Search nearest previous item with the same group
int previousIndex = -1;
for (int i = dropIndex - 1; i >= 0; --i) {
- if (placesItem(i)->groupType() == type) {
+ 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)->groupType() == type) {
+ if (placesItem(i)->group() == group) {
nextIndex = i;
break;
}
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"));
}
}
-QUrl PlacesItemModel::createTimelineUrl(const QUrl& url)
+int PlacesItemModel::mapFromSource(const QModelIndex &index) const
{
- // TODO: Clarify with the Baloo-team whether it makes sense
- // provide default-timeline-URLs like 'yesterday', 'this month'
- // and 'last month'.
- QUrl timelineUrl;
-
- 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);
- } else if (path.endsWith(QLatin1String("thismonth"))) {
- const QDate date = QDate::currentDate();
- timelineUrl = "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());
- } else {
- Q_ASSERT(path.endsWith(QLatin1String("today")));
- timelineUrl= url;
+ if (!index.isValid()) {
+ return -1;
}
- return timelineUrl;
+ return m_indexMap.indexOf(index);
}
-QString PlacesItemModel::timelineDateString(int year, int month, int day)
+bool PlacesItemModel::isDir(int index) const
{
- QString date = QString::number(year) + '-';
- if (month < 10) {
- date += '0';
- }
- date += QString::number(month);
-
- if (day >= 1) {
- date += '-';
- if (day < 10) {
- date += '0';
- }
- date += QString::number(day);
- }
-
- return date;
+ Q_UNUSED(index)
+ return true;
}
-QUrl PlacesItemModel::createSearchUrl(const QUrl& url)
+KFilePlacesModel::GroupType PlacesItemModel::groupType(int row) const
{
- QUrl searchUrl;
-
-#ifdef HAVE_BALOO
- const QString path = url.toDisplayString(QUrl::PreferLocalFile);
- if (path.endsWith(QLatin1String("documents"))) {
- searchUrl = searchUrlForType("Document");
- } else if (path.endsWith(QLatin1String("images"))) {
- searchUrl = searchUrlForType("Image");
- } else if (path.endsWith(QLatin1String("audio"))) {
- searchUrl = searchUrlForType("Audio");
- } else if (path.endsWith(QLatin1String("videos"))) {
- searchUrl = searchUrlForType("Video");
- } else {
- Q_ASSERT(false);
- }
-#else
- Q_UNUSED(url);
-#endif
-
- return searchUrl;
+ return m_sourceModel->groupType(mapToSource(row));
}
-#ifdef HAVE_BALOO
-QUrl PlacesItemModel::searchUrlForType(const QString& type)
+bool PlacesItemModel::isGroupHidden(KFilePlacesModel::GroupType type) const
{
- Baloo::Query query;
- query.addType("File");
- query.addType(type);
+ return m_sourceModel->isGroupHidden(type);
+}
- return query.toSearchUrl();
+void PlacesItemModel::setGroupHidden(KFilePlacesModel::GroupType type, bool hidden)
+{
+ return m_sourceModel->setGroupHidden(type, hidden);
}
-#endif
-#ifdef PLACESITEMMODEL_DEBUG
-void PlacesItemModel::showModelState()
+QModelIndex PlacesItemModel::mapToSource(int row) const
{
- 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 {
- if (item(modelIndex)) {
- qCDebug(DolphinDebug) << i << " " << modelIndex << " " << item(modelIndex)->dataValue("text").toString();
- } else {
- qCDebug(DolphinDebug) << i << " " << modelIndex << " " << "(not available yet)";
- }
- ++modelIndex;
- }
- }
+ return m_indexMap.value(row);
+}
- 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;
+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;
}
-
- bookmark = root.next(bookmark);
- ++bookmarkIndex;
}
+ return nullptr;
}
-#endif
projects / dolphin.git / blobdiff