Build TerminalPanel also on Windows

[dolphin.git] / src / panels / places / placesitemmodel.cpp

diff --git a/src/panels/places/placesitemmodel.cpp b/src/panels/places/placesitemmodel.cpp
index 2a3dfa441826c83e83c9f065d229c0accc49c891..077c9044c24930e3c2b37224a2569dc089065175 100644 (file)
--- a/src/panels/places/placesitemmodel.cpp
+++ b/src/panels/places/placesitemmodel.cpp
@@ -22,23 +22,25 @@
  ***************************************************************************/
 
 #include "placesitemmodel.h"
  ***************************************************************************/
 
 #include "placesitemmodel.h"

+#include "placesitemsignalhandler.h"

 
 #include "dolphin_generalsettings.h"
 
 #include <KBookmark>
 
 #include "dolphin_generalsettings.h"
 
 #include <KBookmark>

-#include <KBookmarkGroup>

 #include <KBookmarkManager>
 #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 "placesitem.h"
 #include <QAction>
 #include <QDate>
 #include <QMimeData>
 #include <QTimer>

+#include <KUrlMimeData>
+#include <KFilePlacesModel>

 
 #include <Solid/Device>
 #include <Solid/DeviceNotifier>
 
 #include <Solid/Device>
 #include <Solid/DeviceNotifier>


@@ -50,82 +52,51 @@
 #include <views/dolphinview.h>
 #include <views/viewproperties.h>
 
 #include <views/dolphinview.h>
 #include <views/viewproperties.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
-

 namespace {
 namespace {

-    // As long as KFilePlacesView from kdelibs is available in parallel, the
-    // system-bookmarks for "Recently Accessed" and "Search For" should be
-    // shown only inside the Places Panel. This is necessary as the stored
-    // URLs needs to get translated to a Nepomuk-search-URL on-the-fly to
-    // be independent from changes in the Nepomuk-search-URL-syntax.
-    // Hence a prefix to the application-name of the stored bookmarks is
+    // A suffix to the application-name of the stored bookmarks is

     // added, which is only read by PlacesItemModel.
     // added, which is only read by PlacesItemModel.

-    const char* AppNamePrefix = "-places-panel";
+    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),
 }
 
 PlacesItemModel::PlacesItemModel(QObject* parent) :
     KStandardItemModel(parent),

-    m_nepomukRunning(false),

     m_hiddenItemsShown(false),
     m_hiddenItemsShown(false),

-    m_availableDevices(),
-    m_predicate(),
-    m_bookmarkManager(0),
-    m_systemBookmarks(),
-    m_systemBookmarksIndexes(),
-    m_bookmarkedItems(),
-    m_hiddenItemToRemove(-1),
-    m_saveBookmarksTimer(0),
-    m_updateBookmarksTimer(0)
-{
-#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();
     loadBookmarks();

+    initializeDefaultViewProperties();

 
 

-    const int syncBookmarksTimeout = 1000;
-
-    m_saveBookmarksTimer = new QTimer(this);
-    m_saveBookmarksTimer->setInterval(syncBookmarksTimeout);
-    m_saveBookmarksTimer->setSingleShot(true);
-    connect(m_saveBookmarksTimer, SIGNAL(timeout()), this, SLOT(saveBookmarks()));
-
-    m_updateBookmarksTimer = new QTimer(this);
-    m_updateBookmarksTimer->setInterval(syncBookmarksTimeout);
-    m_updateBookmarksTimer->setSingleShot(true);
-    connect(m_updateBookmarksTimer, SIGNAL(timeout()), this, SLOT(updateBookmarks()));
-
-    connect(m_bookmarkManager, SIGNAL(changed(QString,QString)),
-            m_updateBookmarksTimer, SLOT(start()));
-    connect(m_bookmarkManager, SIGNAL(bookmarksChanged(QString)),
-            m_updateBookmarksTimer, SLOT(start()));
+    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()
 {
 }
 
 PlacesItemModel::~PlacesItemModel()
 {

-    saveBookmarks();
-    qDeleteAll(m_bookmarkedItems);
-    m_bookmarkedItems.clear();

 }
 
 }
 

-PlacesItem* PlacesItemModel::createPlacesItem(const QString& text,
-                                              const KUrl& url,
-                                              const QString& iconName)
+void PlacesItemModel::createPlacesItem(const QString& text,
+                                       const QUrl& url,
+                                       const QString& iconName,
+                                       int after)

 {
 {

-    const KBookmark bookmark = PlacesItem::createBookmark(m_bookmarkManager, text, url, iconName);
-    return new PlacesItem(bookmark);
+    m_sourceModel->addPlace(text, url, iconName, {}, mapToSource(after));

 }
 
 PlacesItem* PlacesItemModel::placesItem(int index) const
 }
 
 PlacesItem* PlacesItemModel::placesItem(int index) const


@@ -135,20 +106,7 @@ PlacesItem* PlacesItemModel::placesItem(int index) const
 
 int PlacesItemModel::hiddenCount() 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)
 }
 
 void PlacesItemModel::setHiddenItemsShown(bool show)


@@ -160,44 +118,24 @@ void PlacesItemModel::setHiddenItemsShown(bool show)
     m_hiddenItemsShown = show;
 
     if (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 {
     } 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
             }
         }
     }
 
 #ifdef PLACESITEMMODEL_DEBUG

-        kDebug() << "Changed visibility of hidden items";
+        qCDebug(DolphinDebug) << "Changed visibility of hidden items";

         showModelState();
 #endif
 }
         showModelState();
 #endif
 }


@@ -207,47 +145,101 @@ bool PlacesItemModel::hiddenItemsShown() const
     return m_hiddenItemsShown;
 }
 
     return m_hiddenItemsShown;
 }
 

-int PlacesItemModel::closestItem(const KUrl& url) const
+int PlacesItemModel::closestItem(const QUrl& url) const

 {
 {

-    int foundIndex = -1;
-    int maxLength = 0;
+    return mapFromSource(m_sourceModel->closestItem(url));
+}

 
 

-    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;
-            }
+// look for the correct position for the item based on source model
+void PlacesItemModel::insertSortedItem(PlacesItem* item)
+{
+    if (!item) {
+        return;
+    }
+
+    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);
+}
+
+void PlacesItemModel::onItemInserted(int index)
+{
+    KStandardItemModel::onItemInserted(index);
+#ifdef PLACESITEMMODEL_DEBUG
+    qCDebug(DolphinDebug) << "Inserted item" << index;
+    showModelState();
+#endif
+}
+
+void PlacesItemModel::onItemRemoved(int index, KStandardItem* removedItem)
+{
+    m_indexMap.removeAt(index);
+
+    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));
+
+    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>()) {
 }
 
 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
 {
     const PlacesItem* item = placesItem(index);
     if (!item) {
 }
 
 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) {
     }
 
     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>();
     }
 
     Solid::StorageDrive* drive = device.as<Solid::StorageDrive>();


@@ -264,22 +256,21 @@ QAction* PlacesItemModel::teardownAction(int index) const
 
     QString iconName;
     QString text;
 
     QString iconName;
     QString text;

-    const QString label = item->text();

     if (device.is<Solid::OpticalDisc>()) {
     if (device.is<Solid::OpticalDisc>()) {

-        text = i18nc("@item", "Release '%1'", label);
+        text = i18nc("@item", "Release");

     } else if (removable || hotPluggable) {
     } else if (removable || hotPluggable) {

-        text = i18nc("@item", "Safely Remove '%1'", label);
-        iconName = "media-eject";
+        text = i18nc("@item", "Safely Remove");
+        iconName = QStringLiteral("media-eject");

     } else {
     } else {

-        text = i18nc("@item", "Unmount '%1'", label);
-        iconName = "media-eject";
+        text = i18nc("@item", "Unmount");
+        iconName = QStringLiteral("media-eject");

     }
 
     if (iconName.isEmpty()) {
     }
 
     if (iconName.isEmpty()) {

-        return new QAction(text, 0);
+        return new QAction(text, nullptr);

     }
 
     }
 

-    return new QAction(KIcon(iconName), text, 0);
+    return new QAction(QIcon::fromTheme(iconName), text, nullptr);

 }
 
 void PlacesItemModel::requestEject(int index)
 }
 
 void PlacesItemModel::requestEject(int index)


@@ -288,8 +279,8 @@ void PlacesItemModel::requestEject(int index)
     if (item) {
         Solid::OpticalDrive* drive = item->device().parent().as<Solid::OpticalDrive>();
         if (drive) {
     if (item) {
         Solid::OpticalDrive* drive = item->device().parent().as<Solid::OpticalDrive>();
         if (drive) {

-            connect(drive, SIGNAL(ejectDone(Solid::ErrorType,QVariant,QString)),
-                    this, SLOT(slotStorageTeardownDone(Solid::ErrorType,QVariant)));
+            connect(drive, &Solid::OpticalDrive::ejectDone,
+                    this, &PlacesItemModel::slotStorageTearDownDone);

             drive->eject();
         } else {
             const QString label = item->text();
             drive->eject();
         } else {
             const QString label = item->text();


@@ -299,28 +290,61 @@ void PlacesItemModel::requestEject(int index)
     }
 }
 
     }
 }
 

-void PlacesItemModel::requestTeardown(int index)
+void PlacesItemModel::requestTearDown(int index)

 {
     const PlacesItem* item = placesItem(index);
     if (item) {
 {
     const PlacesItem* item = placesItem(index);
     if (item) {

-        Solid::StorageAccess* access = item->device().as<Solid::StorageAccess>();
-        if (access) {
-            connect(access, SIGNAL(teardownDone(Solid::ErrorType,QVariant,QString)),
-                    this, SLOT(slotStorageTeardownDone(Solid::ErrorType,QVariant)));
-            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);
+            emit storageTearDownRequested(tmp->filePath());

         }
     }
 }
 
         }
     }
 }
 

-QMimeData* PlacesItemModel::createMimeData(const QSet<int>& indexes) const
+bool PlacesItemModel::storageSetupNeeded(int index) const

 {
 {

-    KUrl::List urls;
+    const PlacesItem* item = placesItem(index);
+    return item ? item->storageSetupNeeded() : false;
+}
+
+void PlacesItemModel::requestStorageSetup(int index)
+{
+    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();
+    }
+}
+
+QMimeData* PlacesItemModel::createMimeData(const KItemSet& indexes) const
+{
+    QList<QUrl> urls;

     QByteArray itemData;
 
     QDataStream stream(&itemData, QIODevice::WriteOnly);
 
     QByteArray itemData;
 
     QDataStream stream(&itemData, QIODevice::WriteOnly);
 

-    foreach (int index, indexes) {
-        const KUrl itemUrl = placesItem(index)->url();
+    for (int index : indexes) {
+        const QUrl itemUrl = placesItem(index)->url();

         if (itemUrl.isValid()) {
             urls << itemUrl;
         }
         if (itemUrl.isValid()) {
             urls << itemUrl;
         }


@@ -329,506 +353,333 @@ QMimeData* PlacesItemModel::createMimeData(const QSet<int>& indexes) const
 
     QMimeData* mimeData = new QMimeData();
     if (!urls.isEmpty()) {
 
     QMimeData* mimeData = new QMimeData();
     if (!urls.isEmpty()) {

-        urls.populateMimeData(mimeData);
+        mimeData->setUrls(urls);
+    } else {
+        // #378954: prevent itemDropEvent() drops if there isn't a source url.
+        mimeData->setData(blacklistItemDropEventMimeType(), QByteArrayLiteral("true"));

     }
     }

-
-    const QString internalMimeType = "application/x-dolphinplacesmodel-" +
-                                     QString::number((qptrdiff)this);
-    mimeData->setData(internalMimeType, itemData);
+    mimeData->setData(internalMimeType(), itemData);

 
     return mimeData;
 }
 
 
     return mimeData;
 }
 

-KUrl PlacesItemModel::convertedUrl(const KUrl& url)
+bool PlacesItemModel::supportsDropping(int index) const

 {
 {

-    KUrl newUrl = url;
-    if (url.protocol() == QLatin1String("timeline")) {
-        newUrl = createTimelineUrl(url);
-    } else if (url.protocol() == QLatin1String("search")) {
-        newUrl = createSearchUrl(url);
-    }
-
-    return newUrl;
+    return index >= 0 && index < count();

 }
 
 }
 

-void PlacesItemModel::onItemInserted(int index)
+void PlacesItemModel::dropMimeDataBefore(int index, const QMimeData* mimeData)

 {
 {

-    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();
-        }
+    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_bookmarkManager->root().moveBookmark(insertedBookmark, previousBookmark);
-    }
+        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];

 
 

-    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 {
+            QString text = url.fileName();
+            if (text.isEmpty()) {
+                text = url.host();
+            }

 
 

-        int modelIndex = -1;
-        int bookmarkIndex = 0;
-        while (bookmarkIndex < m_bookmarkedItems.count()) {
-            if (!m_bookmarkedItems[bookmarkIndex]) {
-                ++modelIndex;
-                if (modelIndex + 1 == index) {
-                    break;
-                }
+            if ((url.isLocalFile() && !QFileInfo(url.toLocalFile()).isDir())
+                    || url.scheme() == QLatin1String("trash")) {
+                // Only directories outside the trash are allowed
+                continue;

             }
             }

-            ++bookmarkIndex;
+
+            createPlacesItem(text, url, KIO::iconNameForUrl(url), qMax(0, index - 1));

         }
         }

-        m_bookmarkedItems.insert(bookmarkIndex, 0);

     }
     }

-
-    triggerBookmarksSaving();
-
-#ifdef PLACESITEMMODEL_DEBUG
-    kDebug() << "Inserted item" << index;
-    showModelState();
-#endif
+    // will save bookmark alteration and fix sort if that is broken by the drag/drop operation
+    refresh();

 }
 
 }
 

-void PlacesItemModel::onItemRemoved(int index, KStandardItem* removedItem)
+void PlacesItemModel::addItemFromSourceModel(const QModelIndex &index)

 {
 {

-    PlacesItem* placesItem = dynamic_cast<PlacesItem*>(removedItem);
-    if (placesItem) {
-        const KBookmark bookmark = placesItem->bookmark();
-        m_bookmarkManager->root().deleteBookmark(bookmark);
+    if (!m_hiddenItemsShown && m_sourceModel->isHidden(index)) {
+        return;

     }
 
     }
 

-    const int boomarkIndex = bookmarkIndex(index);
-    Q_ASSERT(!m_bookmarkedItems[boomarkIndex]);
-    m_bookmarkedItems.removeAt(boomarkIndex);
-
-    triggerBookmarksSaving();
+    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);

 
 

-#ifdef PLACESITEMMODEL_DEBUG
-    kDebug() << "Removed item" << index;
-    showModelState();
-#endif
+    if (m_sourceModel->isDevice(index)) {
+        connect(item->signalHandler(), &PlacesItemSignalHandler::tearDownExternallyRequested,
+                this, &PlacesItemModel::storageTearDownExternallyRequested);
+    }

 }
 
 }
 

-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();
+    QString id = bookmarkId(m_sourceModel->bookmarkForIndex(sourceIndex));

 
 

-        const PlacesItem* previousItem = placesItem(index - 1);
-        KBookmark previousBookmark;
-        if (previousItem) {
-            previousBookmark = previousItem->bookmark();
-        }
-
-        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;

         }
     }
         }
     }

-
-    triggerBookmarksSaving();

 }
 
 }
 

-void PlacesItemModel::slotDeviceAdded(const QString& udi)
+QString PlacesItemModel::bookmarkId(const KBookmark &bookmark) const

 {
 {

-    const Solid::Device device(udi);
-    if (m_predicate.matches(device)) {
-        m_availableDevices << udi;
-        const KBookmark bookmark = PlacesItem::createDeviceBookmark(m_bookmarkManager, udi);
-        appendItem(new PlacesItem(bookmark));
+    QString id = bookmark.metaDataItem(QStringLiteral("UDI"));
+    if (id.isEmpty()) {
+        id = bookmark.metaDataItem(QStringLiteral("ID"));

     }
     }

+    return id;

 }
 
 }
 

-void PlacesItemModel::slotDeviceRemoved(const QString& udi)
+void PlacesItemModel::initializeDefaultViewProperties() const

 {
 {

-    if (!m_availableDevices.contains(udi)) {
-        return;
-    }
+    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;
+        }

 
 

-    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;
+        // 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();
+            }

         }
         }

-     }
+    }
+}

 
 

-     for (int i = 0; i < count(); ++i) {
-         if (placesItem(i)->udi() == udi) {
-             removeItem(i);
-             return;
-         }
-     }
+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)
+void PlacesItemModel::slotStorageTearDownDone(Solid::ErrorType error, const QVariant& errorData)

 {
     if (error && errorData.isValid()) {
         emit errorMessage(errorData.toString());
     }
 {
     if (error && errorData.isValid()) {
         emit errorMessage(errorData.toString());
     }

+    m_deviceToTearDown->disconnect();
+    m_deviceToTearDown = nullptr;

 }
 
 }
 

-void PlacesItemModel::hideItem()
-{
-    hideItem(m_hiddenItemToRemove);
-    m_hiddenItemToRemove = -1;
-}
-
-void PlacesItemModel::updateBookmarks()
+void PlacesItemModel::slotStorageSetupDone(Solid::ErrorType error,
+                                           const QVariant& errorData,
+                                           const QString& udi)

 {
 {

-    // 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)) {
-            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;
-                }
+    Q_UNUSED(udi);

 
 

-                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);
-                    }
-                    break;
-                }
-            }
-
-            if (!found) {
-                PlacesItem* item = new PlacesItem(newBookmark);
-                if (item->isHidden() && !m_hiddenItemsShown) {
-                    m_bookmarkedItems.append(item);
-                } else {
-                    appendItem(item);
-                }
-            }
-        }
-
-        newBookmark = root.next(newBookmark);
+    const int index = m_storageSetupInProgress.take(sender());
+    const PlacesItem*  item = placesItem(index);
+    if (!item) {
+        return;

     }
 
     }
 

-    // 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 (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);
+    }
+}

 
 

-        if (hasBeenRemoved) {
-            if (m_bookmarkedItems[i]) {
-                delete m_bookmarkedItems[i];
-                m_bookmarkedItems.removeAt(i);
-            } else {
-                removeItem(modelIndex);
-                --modelIndex;
-            }
-        }
+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);
+    }
+}

 
 

-        if (itemIsPartOfModel) {
-            ++modelIndex;
+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::saveBookmarks()
+void PlacesItemModel::onSourceModelRowsAboutToBeMoved(const QModelIndex &parent, int start, int end, const QModelIndex &destination, int row)

 {
 {

-    m_bookmarkManager->emitChanged(m_bookmarkManager->root());
+    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::loadBookmarks()
+void PlacesItemModel::onSourceModelRowsMoved(const QModelIndex &parent, int start, int end, const QModelIndex &destination, int row)

 {
 {

-    KBookmarkGroup root = m_bookmarkManager->root();
-    KBookmark bookmark = root.first();
-    QSet<QString> devices = m_availableDevices;
+    Q_UNUSED(destination);
+    Q_UNUSED(parent);
+
+    const int blockSize = (end - start) + 1;

 
 

-    QSet<KUrl> 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);
+
+        addItemFromSourceModel(targetIndex);

     }
     }

+}

 
 

-    // 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*> recentlyAccessedItems;
-    QList<PlacesItem*> searchForItems;
-    QList<PlacesItem*> devicesItems;
+void PlacesItemModel::onSourceModelDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight, const QVector<int> &roles)
+{
+    Q_UNUSED(roles);

 
 

-    while (!bookmark.isNull()) {
-        const bool deviceAvailable = devices.remove(bookmark.metaDataItem("UDI"));
-        if (acceptBookmark(bookmark)) {
-            PlacesItem* item = new PlacesItem(bookmark);
-            if (deviceAvailable) {
-                devicesItems.append(item);
-            } else {
-                const KUrl url = bookmark.url();
-                if (missingSystemBookmarks.contains(url)) {
-                    missingSystemBookmarks.remove(url);
-
-                    // 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);
-                    item->setSystemItem(true);
-                }
+    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);

 
 

-                switch (item->groupType()) {
-                case PlacesItem::PlacesType:           placesItems.append(item); break;
-                case PlacesItem::RecentlyAccessedType: recentlyAccessedItems.append(item); break;
-                case PlacesItem::SearchForType:        searchForItems.append(item); break;
-                case PlacesItem::DevicesType:
-                default:                               Q_ASSERT(false); break;
-                }
-            }
+        if (placeItem && (!m_hiddenItemsShown && m_sourceModel->isHidden(sourceIndex))) {
+            //hide item if it became invisible
+            removeItem(index(placeItem));
+            return;

         }
 
         }
 

-        bookmark = root.next(bookmark);
-    }
+        if (!placeItem && (m_hiddenItemsShown || !m_sourceModel->isHidden(sourceIndex))) {
+            //show item if it became visible
+            addItemFromSourceModel(sourceIndex);
+            return;
+        }

 
 

-    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::RecentlyAccessedType: recentlyAccessedItems.append(item); break;
-                case PlacesItem::SearchForType:        searchForItems.append(item); break;
-                case PlacesItem::DevicesType:
-                default:                               Q_ASSERT(false); break;
-                }
-            }
+        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);

         }
     }
         }
     }

+}

 
 

-    // 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));
+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);
+        }

     }
     }

+}

 
 

-    QList<PlacesItem*> items;
-    items.append(placesItems);
-    items.append(recentlyAccessedItems);
-    items.append(searchForItems);
-    items.append(devicesItems);
+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"));

 
 

-    foreach (PlacesItem* item, items) {
-        if (!m_hiddenItemsShown && item->isHidden()) {
-            m_bookmarkedItems.append(item);
+        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 {
         } else {

-            appendItem(item);
+            row++;
+        }
+    } while (row < m_sourceModel->rowCount());
+}
+
+void PlacesItemModel::loadBookmarks()
+{
+    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
         }
     }
 
 #ifdef PLACESITEMMODEL_DEBUG

-    kDebug() << "Loaded bookmarks";
+    qCDebug(DolphinDebug) << "Loaded bookmarks";

     showModelState();
 #endif
 }
 
     showModelState();
 #endif
 }
 

-bool PlacesItemModel::acceptBookmark(const KBookmark& bookmark) const
-{
-    const QString udi = bookmark.metaDataItem("UDI");
-    const KUrl url = bookmark.url();
-    const QString appName = bookmark.metaDataItem("OnlyInApp");
-    const bool deviceAvailable = m_availableDevices.contains(udi);
-
-    const bool allowedHere = (appName.isEmpty()
-                              || appName == KGlobal::mainComponent().componentName()
-                              || appName == KGlobal::mainComponent().componentName() + AppNamePrefix)
-                             && (m_nepomukRunning || (url.protocol() != QLatin1String("timeline") &&
-                                                      url.protocol() != QLatin1String("search")));
-
-    return (udi.isEmpty() && allowedHere) || deviceAvailable;
-}
-
-PlacesItem* PlacesItemModel::createSystemPlacesItem(const SystemBookmarkData& data)
-{
-    KBookmark bookmark = PlacesItem::createBookmark(m_bookmarkManager,
-                                                    data.text,
-                                                    data.url,
-                                                    data.icon);
-
-    const QString protocol = data.url.protocol();
-    if (protocol == QLatin1String("timeline") || protocol == QLatin1String("search")) {
-        // As long as the KFilePlacesView from kdelibs is available, the system-bookmarks
-        // for "Recently Accessed" and "Search For" should be a setting available only
-        // in the Places Panel (see description of AppNamePrefix for more details).
-        const QString appName = KGlobal::mainComponent().componentName() + AppNamePrefix;
-        bookmark.setMetaDataItem("OnlyInApp", appName);
-    }
-
-    PlacesItem* item = new PlacesItem(bookmark);
-    item->setSystemItem(true);
-
-    // Create default view-properties for all "Search For" and "Recently Accessed" bookmarks
-    // in case if the user has not already created custom view-properties for a corresponding
-    // query yet.
-    const bool createDefaultViewProperties = (item->groupType() == PlacesItem::SearchForType ||
-                                              item->groupType() == PlacesItem::RecentlyAccessedType) &&
-                                              !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(QList<QByteArray>() << "text" << "path");
-            } else if (path == QLatin1String("/images")) {
-                props.setViewMode(DolphinView::IconsView);
-                props.setPreviewsShown(true);
-                props.setVisibleRoles(QList<QByteArray>() << "text" << "imageSize");
-            } else if (path == QLatin1String("/audio")) {
-                props.setViewMode(DolphinView::DetailsView);
-                props.setPreviewsShown(false);
-                props.setVisibleRoles(QList<QByteArray>() << "text" << "artist" << "album");
-            } else if (path == QLatin1String("/videos")) {
-                props.setViewMode(DolphinView::IconsView);
-                props.setPreviewsShown(true);
-                props.setVisibleRoles(QList<QByteArray>() << "text");
-            } else if (data.url.protocol() == "timeline") {
-                props.setViewMode(DolphinView::DetailsView);
-                props.setVisibleRoles(QList<QByteArray>() << "text" << "date");
-            }
-        }
-    }
-
-    return item;
+void PlacesItemModel::clear() {
+    KStandardItemModel::clear();

 }
 
 }
 

-void PlacesItemModel::createSystemBookmarks()
+void PlacesItemModel::proceedWithTearDown()

 {
 {

-    Q_ASSERT(m_systemBookmarks.isEmpty());
-    Q_ASSERT(m_systemBookmarksIndexes.isEmpty());
-
-    const QString timeLineIcon = "package_utility_time"; // TODO: Ask the Oxygen team to create
-                                                         // a custom icon for the timeline-protocol
+    Q_ASSERT(m_deviceToTearDown);

 
 

-    m_systemBookmarks.append(SystemBookmarkData(KUrl(KUser().homeDir()),
-                                                "user-home",
-                                                i18nc("@item", "Home")));
-    m_systemBookmarks.append(SystemBookmarkData(KUrl("remote:/"),
-                                                "network-workgroup",
-                                                i18nc("@item", "Network")));
-    m_systemBookmarks.append(SystemBookmarkData(KUrl("/"),
-                                                "folder-red",
-                                                i18nc("@item", "Root")));
-    m_systemBookmarks.append(SystemBookmarkData(KUrl("trash:/"),
-                                                "user-trash",
-                                                i18nc("@item", "Trash")));
-
-    if (m_nepomukRunning) {
-        m_systemBookmarks.append(SystemBookmarkData(KUrl("timeline:/today"),
-                                                    timeLineIcon,
-                                                    i18nc("@item Recently Accessed", "Today")));
-        m_systemBookmarks.append(SystemBookmarkData(KUrl("timeline:/yesterday"),
-                                                    timeLineIcon,
-                                                    i18nc("@item Recently Accessed", "Yesterday")));
-        m_systemBookmarks.append(SystemBookmarkData(KUrl("timeline:/thismonth"),
-                                                    timeLineIcon,
-                                                    i18nc("@item Recently Accessed", "This Month")));
-        m_systemBookmarks.append(SystemBookmarkData(KUrl("timeline:/lastmonth"),
-                                                    timeLineIcon,
-                                                    i18nc("@item Recently Accessed", "Last Month")));
-        m_systemBookmarks.append(SystemBookmarkData(KUrl("search:/documents"),
-                                                    "folder-txt",
-                                                    i18nc("@item Commonly Accessed", "Documents")));
-        m_systemBookmarks.append(SystemBookmarkData(KUrl("search:/images"),
-                                                    "folder-image",
-                                                    i18nc("@item Commonly Accessed", "Images")));
-        m_systemBookmarks.append(SystemBookmarkData(KUrl("search:/audio"),
-                                                    "folder-sound",
-                                                    i18nc("@item Commonly Accessed", "Audio Files")));
-        m_systemBookmarks.append(SystemBookmarkData(KUrl("search:/videos"),
-                                                    "folder-video",
-                                                    i18nc("@item Commonly Accessed", "Videos")));
-    }
-
-    for (int i = 0; i < m_systemBookmarks.count(); ++i) {
-        m_systemBookmarksIndexes.insert(m_systemBookmarks[i].url, i);
-    }
+    connect(m_deviceToTearDown, &Solid::StorageAccess::teardownDone,
+            this, &PlacesItemModel::slotStorageTearDownDone);
+    m_deviceToTearDown->teardown();

 }
 
 }
 

-void PlacesItemModel::initializeAvailableDevices()
+void PlacesItemModel::deleteItem(int index)

 {
 {

-    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();
-    }
+    QModelIndex sourceIndex = mapToSource(index);
+    Q_ASSERT(sourceIndex.isValid());
+    m_sourceModel->removePlace(sourceIndex);

 }
 
 }
 

-int PlacesItemModel::bookmarkIndex(int index) const
+void PlacesItemModel::refresh()

 {
 {

-    int bookmarkIndex = 0;
-    int modelIndex = 0;
-    while (bookmarkIndex < m_bookmarkedItems.count()) {
-        if (!m_bookmarkedItems[bookmarkIndex]) {
-            if (modelIndex == index) {
-                break;
-            }
-            ++modelIndex;
-        }
-        ++bookmarkIndex;
-    }
-
-    return bookmarkIndex >= m_bookmarkedItems.count() ? -1 : bookmarkIndex;
+    m_sourceModel->refresh();

 }
 
 void PlacesItemModel::hideItem(int index)
 }
 
 void PlacesItemModel::hideItem(int index)


@@ -839,161 +690,139 @@ void PlacesItemModel::hideItem(int index)
     }
 
     shownItem->setHidden(true);
     }
 
     shownItem->setHidden(true);

-    if (m_hiddenItemsShown) {
-        // Removing items from the model is not allowed if all hidden
-        // items should be shown.
-        return;
-    }
+}
+
+QString PlacesItemModel::internalMimeType() const
+{
+    return "application/x-dolphinplacesmodel-" +
+            QString::number((qptrdiff)this);
+}

 
 

-    const int newIndex = bookmarkIndex(index);
-    if (newIndex >= 0) {
-        const KBookmark hiddenBookmark = shownItem->bookmark();
-        PlacesItem* hiddenItem = new PlacesItem(hiddenBookmark);
+int PlacesItemModel::groupedDropIndex(int index, const PlacesItem* item) const
+{
+    Q_ASSERT(item);

 
 

-        const PlacesItem* previousItem = placesItem(index - 1);
-        KBookmark previousBookmark;
-        if (previousItem) {
-            previousBookmark = previousItem->bookmark();
-        }
+    int dropIndex = index;
+    const QString group = item->group();

 
 

-        const bool updateBookmark = (m_bookmarkManager->root().indexOf(hiddenBookmark) >= 0);
-        removeItem(index);
+    const int itemCount = count();
+    if (index < 0) {
+        dropIndex = itemCount;
+    }

 
 

-        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);
-            triggerBookmarksSaving();
+    // 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;

         }
         }

+    }

 
 

-        m_bookmarkedItems.insert(newIndex, hiddenItem);
+    // 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;
+        }

     }
     }

-}

 
 

-void PlacesItemModel::triggerBookmarksSaving()
-{
-    if (m_saveBookmarksTimer) {
-        m_saveBookmarksTimer->start();
+    // 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;

 }
 
 bool PlacesItemModel::equalBookmarkIdentifiers(const KBookmark& b1, const KBookmark& b2)
 {
 }
 
 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 {
     if (!udi1.isEmpty() && !udi2.isEmpty()) {
         return udi1 == udi2;
     } else {

-        return b1.metaDataItem("ID") == b2.metaDataItem("ID");
-    }
-}
-
-KUrl PlacesItemModel::createTimelineUrl(const KUrl& url)
-{
-    // TODO: Clarify with the Nepomuk-team whether it makes sense
-    // provide default-timeline-URLs like 'yesterday', 'this month'
-    // and 'last month'.
-    KUrl timelineUrl;
-
-    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;
+        return b1.metaDataItem(QStringLiteral("ID")) == b2.metaDataItem(QStringLiteral("ID"));

     }
     }

-
-    return timelineUrl;

 }
 
 }
 

-QString PlacesItemModel::timelineDateString(int year, int month, int day)
+int PlacesItemModel::mapFromSource(const QModelIndex &index) const

 {
 {

-    QString date = QString::number(year) + '-';
-    if (month < 10) {
-        date += '0';
+    if (!index.isValid()) {
+        return -1;

     }
     }

-    date += QString::number(month);

 
 

-    if (day >= 1) {
-        date += '-';
-        if (day < 10) {
-            date += '0';
-        }
-        date += QString::number(day);
-    }
+    return m_indexMap.indexOf(index);
+}

 
 

-    return date;
+bool PlacesItemModel::isDir(int index) const
+{
+    Q_UNUSED(index);
+    return true;

 }
 
 }
 

-KUrl PlacesItemModel::createSearchUrl(const KUrl& url)
+KFilePlacesModel::GroupType PlacesItemModel::groupType(int row) const

 {
 {

-    KUrl searchUrl;
+    return m_sourceModel->groupType(mapToSource(row));
+}

 
 

-#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
+bool PlacesItemModel::isGroupHidden(KFilePlacesModel::GroupType type) const
+{
+    return m_sourceModel->isGroupHidden(type);
+}

 
 

-    return searchUrl;
+void PlacesItemModel::setGroupHidden(KFilePlacesModel::GroupType type, bool hidden)
+{
+    return m_sourceModel->setGroupHidden(type, hidden);

 }
 
 }
 

-#ifdef HAVE_NEPOMUK
-KUrl PlacesItemModel::searchUrlForTerm(const Nepomuk::Query::Term& term)
+QModelIndex PlacesItemModel::mapToSource(int row) const

 {
 {

-    const Nepomuk::Query::Query query(term);
-    return query.toSearchUrl();
+    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()
 {
 
 #ifdef PLACESITEMMODEL_DEBUG
 void PlacesItemModel::showModelState()
 {

-    kDebug() << "=================================";
-    kDebug() << "Model:";
-    kDebug() << "hidden-index model-index   text";
+    qCDebug(DolphinDebug) << "=================================";
+    qCDebug(DolphinDebug) << "Model:";
+    qCDebug(DolphinDebug) << "hidden-index model-index   text";

     int modelIndex = 0;
     for (int i = 0; i < m_bookmarkedItems.count(); ++i) {
         if (m_bookmarkedItems[i]) {
     int modelIndex = 0;
     for (int i = 0; i < m_bookmarkedItems.count(); ++i) {
         if (m_bookmarkedItems[i]) {

-            kDebug() <<  i << "(Hidden)    " << "             " << m_bookmarkedItems[i]->dataValue("text").toString();
+            qCDebug(DolphinDebug) <<  i << "(Hidden)    " << "             " << m_bookmarkedItems[i]->dataValue("text").toString();

         } else {
             if (item(modelIndex)) {
         } else {
             if (item(modelIndex)) {

-                kDebug() <<  i << "          " << modelIndex << "           " << item(modelIndex)->dataValue("text").toString();
+                qCDebug(DolphinDebug) <<  i << "          " << modelIndex << "           " << item(modelIndex)->dataValue("text").toString();

             } else {
             } else {

-                kDebug() <<  i << "          " << modelIndex << "           " << "(not available yet)";
+                qCDebug(DolphinDebug) <<  i << "          " << modelIndex << "           " << "(not available yet)";

             }
             ++modelIndex;
         }
     }
 
             }
             ++modelIndex;
         }
     }
 

-    kDebug();
-    kDebug() << "Bookmarks:";
+    qCDebug(DolphinDebug);
+    qCDebug(DolphinDebug) << "Bookmarks:";

 
     int bookmarkIndex = 0;
     KBookmarkGroup root = m_bookmarkManager->root();
 
     int bookmarkIndex = 0;
     KBookmarkGroup root = m_bookmarkManager->root();


@@ -1002,9 +831,9 @@ void PlacesItemModel::showModelState()
         const QString udi = bookmark.metaDataItem("UDI");
         const QString text = udi.isEmpty() ? bookmark.text() : udi;
         if (bookmark.metaDataItem("IsHidden") == QLatin1String("true")) {
         const QString udi = bookmark.metaDataItem("UDI");
         const QString text = udi.isEmpty() ? bookmark.text() : udi;
         if (bookmark.metaDataItem("IsHidden") == QLatin1String("true")) {

-            kDebug() << bookmarkIndex << "(Hidden)" << text;
+            qCDebug(DolphinDebug) << bookmarkIndex << "(Hidden)" << text;

         } else {
         } else {

-            kDebug() << bookmarkIndex << "        " << text;
+            qCDebug(DolphinDebug) << bookmarkIndex << "        " << text;

         }
 
         bookmark = root.next(bookmark);
         }
 
         bookmark = root.next(bookmark);


@@ -1013,4 +842,3 @@ void PlacesItemModel::showModelState()
 }
 #endif
 
 }
 #endif
 

-#include "placesitemmodel.moc"