Fix for crash which was introduced by commit

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

diff --git a/src/panels/places/placesitemmodel.cpp b/src/panels/places/placesitemmodel.cpp
index 2a3dfa441826c83e83c9f065d229c0accc49c891..cfe6d2e462dfdeb2d0ea97a4744d718df2737f3b 100644 (file)
--- a/src/panels/places/placesitemmodel.cpp
+++ b/src/panels/places/placesitemmodel.cpp
@@ -28,17 +28,20 @@
 #include <KBookmark>
 #include <KBookmarkGroup>
 #include <KBookmarkManager>
 #include <KBookmark>
 #include <KBookmarkGroup>
 #include <KBookmarkManager>

-#include <KComponentData>

 #include <KDebug>
 #include <KDebug>

-#include <KIcon>
-#include <KLocale>
-#include <KStandardDirs>
+#include <QIcon>
+#include <kprotocolinfo.h>
+#include <KLocalizedString>
+#include <KComponentData>
+#include <QStandardPaths>

 #include <KUser>
 #include <KUser>

+#include <KGlobal>

 #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 <Solid/Device>
 #include <Solid/DeviceNotifier>
 
 #include <Solid/Device>
 #include <Solid/DeviceNotifier>


@@ -50,30 +53,25 @@
 #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>
+#ifdef HAVE_BALOO
+    #include <Baloo/Query>
+    #include <Baloo/IndexerConfig>

 #endif
 
 namespace {
     // As long as KFilePlacesView from kdelibs is available in parallel, the
 #endif
 
 namespace {
     // As long as KFilePlacesView from kdelibs is available in parallel, the

-    // system-bookmarks for "Recently Accessed" and "Search For" should be
+    // system-bookmarks for "Recently Saved" and "Search For" should be

     // shown only inside the Places Panel. This is necessary as the stored
     // shown only inside the Places Panel. This is necessary as the stored

-    // URLs needs to get translated to a Nepomuk-search-URL on-the-fly to
-    // be independent from changes in the Nepomuk-search-URL-syntax.
+    // URLs needs to get translated to a Baloo-search-URL on-the-fly to
+    // be independent from changes in the Baloo-search-URL-syntax.

     // Hence a prefix to the application-name of the stored bookmarks is
     // added, which is only read by PlacesItemModel.
     // Hence a prefix to the application-name of the stored bookmarks is
     // added, which is only read by PlacesItemModel.

-    const char* AppNamePrefix = "-places-panel";
+    const char AppNamePrefix[] = "-places-panel";

 }
 
 PlacesItemModel::PlacesItemModel(QObject* parent) :
     KStandardItemModel(parent),
 }
 
 PlacesItemModel::PlacesItemModel(QObject* parent) :
     KStandardItemModel(parent),

-    m_nepomukRunning(false),
+    m_fileIndexingEnabled(false),

     m_hiddenItemsShown(false),
     m_availableDevices(),
     m_predicate(),
     m_hiddenItemsShown(false),
     m_availableDevices(),
     m_predicate(),


@@ -83,34 +81,36 @@ PlacesItemModel::PlacesItemModel(QObject* parent) :
     m_bookmarkedItems(),
     m_hiddenItemToRemove(-1),
     m_saveBookmarksTimer(0),
     m_bookmarkedItems(),
     m_hiddenItemToRemove(-1),
     m_saveBookmarksTimer(0),

-    m_updateBookmarksTimer(0)
+    m_updateBookmarksTimer(0),
+    m_storageSetupInProgress()

 {
 {

-#ifdef HAVE_NEPOMUK
-    m_nepomukRunning = (Nepomuk::ResourceManager::instance()->initialized());
+#ifdef HAVE_BALOO
+    Baloo::IndexerConfig config;
+    m_fileIndexingEnabled = config.fileIndexingEnabled();

 #endif
 #endif

-    const QString file = KStandardDirs::locateLocal("data", "kfileplaces/bookmarks.xml");
+    const QString file = QStandardPaths::locate(QStandardPaths::GenericDataLocation, "kfileplaces/bookmarks.xml");

     m_bookmarkManager = KBookmarkManager::managerForFile(file, "kfilePlaces");
 
     createSystemBookmarks();
     initializeAvailableDevices();
     loadBookmarks();
 
     m_bookmarkManager = KBookmarkManager::managerForFile(file, "kfilePlaces");
 
     createSystemBookmarks();
     initializeAvailableDevices();
     loadBookmarks();
 

-    const int syncBookmarksTimeout = 1000;
+    const int syncBookmarksTimeout = 100;

 
     m_saveBookmarksTimer = new QTimer(this);
     m_saveBookmarksTimer->setInterval(syncBookmarksTimeout);
     m_saveBookmarksTimer->setSingleShot(true);
 
     m_saveBookmarksTimer = new QTimer(this);
     m_saveBookmarksTimer->setInterval(syncBookmarksTimeout);
     m_saveBookmarksTimer->setSingleShot(true);

-    connect(m_saveBookmarksTimer, SIGNAL(timeout()), this, SLOT(saveBookmarks()));
+    connect(m_saveBookmarksTimer, &QTimer::timeout, this, &PlacesItemModel::saveBookmarks);

 
     m_updateBookmarksTimer = new QTimer(this);
     m_updateBookmarksTimer->setInterval(syncBookmarksTimeout);
     m_updateBookmarksTimer->setSingleShot(true);
 
     m_updateBookmarksTimer = new QTimer(this);
     m_updateBookmarksTimer->setInterval(syncBookmarksTimeout);
     m_updateBookmarksTimer->setSingleShot(true);

-    connect(m_updateBookmarksTimer, SIGNAL(timeout()), this, SLOT(updateBookmarks()));
+    connect(m_updateBookmarksTimer, &QTimer::timeout, this, &PlacesItemModel::updateBookmarks);

 
 

-    connect(m_bookmarkManager, SIGNAL(changed(QString,QString)),
-            m_updateBookmarksTimer, SLOT(start()));
-    connect(m_bookmarkManager, SIGNAL(bookmarksChanged(QString)),
-            m_updateBookmarksTimer, SLOT(start()));
+    connect(m_bookmarkManager, &KBookmarkManager::changed,
+            m_updateBookmarksTimer, static_cast<void(QTimer::*)()>(&QTimer::start));
+    connect(m_bookmarkManager, &KBookmarkManager::bookmarksChanged,
+            m_updateBookmarksTimer, static_cast<void(QTimer::*)()>(&QTimer::start));

 }
 
 PlacesItemModel::~PlacesItemModel()
 }
 
 PlacesItemModel::~PlacesItemModel()


@@ -121,7 +121,7 @@ PlacesItemModel::~PlacesItemModel()
 }
 
 PlacesItem* PlacesItemModel::createPlacesItem(const QString& text,
 }
 
 PlacesItem* PlacesItemModel::createPlacesItem(const QString& text,

-                                              const KUrl& url,
+                                              const QUrl& url,

                                               const QString& iconName)
 {
     const KBookmark bookmark = PlacesItem::createBookmark(m_bookmarkManager, text, url, iconName);
                                               const QString& iconName)
 {
     const KBookmark bookmark = PlacesItem::createBookmark(m_bookmarkManager, text, url, iconName);


@@ -207,15 +207,19 @@ 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;
 
     for (int i = 0; i < count(); ++i) {
 {
     int foundIndex = -1;
     int maxLength = 0;
 
     for (int i = 0; i < count(); ++i) {

-        const KUrl itemUrl = placesItem(i)->url();
-        if (itemUrl.isParentOf(url)) {
-            const int length = itemUrl.prettyUrl().length();
+        const QUrl itemUrl = placesItem(i)->url();
+        if (url == itemUrl) {
+            // We can't find a closer one, so stop here.
+            foundIndex = i;
+            break;
+        } else if (itemUrl.isParentOf(url)) {
+            const int length = itemUrl.path().length();

             if (length > maxLength) {
                 foundIndex = i;
                 maxLength = length;
             if (length > maxLength) {
                 foundIndex = i;
                 maxLength = length;


@@ -226,11 +230,37 @@ int PlacesItemModel::closestItem(const KUrl& url) const
     return foundIndex;
 }
 
     return foundIndex;
 }
 

+void PlacesItemModel::appendItemToGroup(PlacesItem* item)
+{
+    if (!item) {
+        return;
+    }
+
+    int i = 0;
+    while (i < count() && placesItem(i)->group() != item->group()) {
+        ++i;
+    }
+
+    bool inserted = false;
+    while (!inserted && i < count()) {
+        if (placesItem(i)->group() != item->group()) {
+            insertItem(i, item);
+            inserted = true;
+        }
+        ++i;
+    }
+
+    if (!inserted) {
+        appendItem(item);
+    }
+}
+
+

 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("media-eject"), i18nc("@item", "Eject '%1'", item->text()), 0);

     }
 
     return 0;
     }
 
     return 0;


@@ -279,7 +309,7 @@ QAction* PlacesItemModel::teardownAction(int index) const
         return new QAction(text, 0);
     }
 
         return new QAction(text, 0);
     }
 

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

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


@@ -288,8 +318,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();


@@ -305,22 +335,51 @@ void PlacesItemModel::requestTeardown(int index)
     if (item) {
         Solid::StorageAccess* access = item->device().as<Solid::StorageAccess>();
         if (access) {
     if (item) {
         Solid::StorageAccess* access = item->device().as<Solid::StorageAccess>();
         if (access) {

-            connect(access, SIGNAL(teardownDone(Solid::ErrorType,QVariant,QString)),
-                    this, SLOT(slotStorageTeardownDone(Solid::ErrorType,QVariant)));
+            connect(access, &Solid::StorageAccess::teardownDone,
+                    this, &PlacesItemModel::slotStorageTeardownDone);

             access->teardown();
         }
     }
 }
 
             access->teardown();
         }
     }
 }
 

-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);
 
     foreach (int index, indexes) {
     QByteArray itemData;
 
     QDataStream stream(&itemData, QIODevice::WriteOnly);
 
     foreach (int index, indexes) {

-        const KUrl itemUrl = placesItem(index)->url();
+        const QUrl itemUrl = placesItem(index)->url();

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


@@ -329,22 +388,75 @@ 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);

     }
     }

-
-    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")) {
+    return index >= 0 && index < count();
+}
+
+void PlacesItemModel::dropMimeDataBefore(int index, const QMimeData* mimeData)
+{
+    if (mimeData->hasFormat(internalMimeType())) {
+        // The item has been moved inside the view
+        QByteArray itemData = mimeData->data(internalMimeType());
+        QDataStream stream(&itemData, QIODevice::ReadOnly);
+        int oldIndex;
+        stream >> oldIndex;
+        if (oldIndex == index || oldIndex == index - 1) {
+            // No moving has been done
+            return;
+        }
+
+        PlacesItem* oldItem = placesItem(oldIndex);
+        if (!oldItem) {
+            return;
+        }
+
+        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")) {
+        // One or more items must be added to the model
+        const QList<QUrl> urls = KUrlMimeData::urlsFromMimeData(mimeData);
+        for (int i = urls.count() - 1; i >= 0; --i) {
+            const QUrl& url = urls[i];
+
+            QString text = url.fileName();
+            if (text.isEmpty()) {
+                text = url.host();
+            }
+
+            if ((url.isLocalFile() && !QFileInfo(url.toLocalFile()).isDir())
+                    || url.scheme() == "trash") {
+                // Only directories outside the trash are allowed
+                continue;
+            }
+
+            PlacesItem* newItem = createPlacesItem(text, url);
+            const int dropIndex = groupedDropIndex(index, newItem);
+            insertItem(dropIndex, newItem);
+        }
+    }
+}
+
+QUrl PlacesItemModel::convertedUrl(const QUrl& url)
+{
+    QUrl newUrl = url;
+    if (url.scheme() == QLatin1String("timeline")) {

         newUrl = createTimelineUrl(url);
         newUrl = createTimelineUrl(url);

-    } else if (url.protocol() == QLatin1String("search")) {
+    } else if (url.scheme() == QLatin1String("search")) {

         newUrl = createSearchUrl(url);
     }
 
         newUrl = createSearchUrl(url);
     }
 


@@ -447,11 +559,14 @@ void PlacesItemModel::onItemChanged(int index, const QSet<QByteArray>& changedRo
 void PlacesItemModel::slotDeviceAdded(const QString& udi)
 {
     const Solid::Device device(udi);
 void PlacesItemModel::slotDeviceAdded(const QString& udi)
 {
     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));
+
+    if (!m_predicate.matches(device)) {
+        return;

     }
     }

+
+    m_availableDevices << udi;
+    const KBookmark bookmark = PlacesItem::createDeviceBookmark(m_bookmarkManager, udi);
+    appendItem(new PlacesItem(bookmark));

 }
 
 void PlacesItemModel::slotDeviceRemoved(const QString& udi)
 }
 
 void PlacesItemModel::slotDeviceRemoved(const QString& udi)


@@ -467,14 +582,14 @@ void PlacesItemModel::slotDeviceRemoved(const QString& udi)
             delete item;
             return;
         }
             delete item;
             return;
         }

-     }
+    }

 
 

-     for (int i = 0; i < count(); ++i) {
-         if (placesItem(i)->udi() == udi) {
-             removeItem(i);
-             return;
-         }
-     }
+    for (int i = 0; i < count(); ++i) {
+        if (placesItem(i)->udi() == udi) {
+            removeItem(i);
+            return;
+        }
+    }

 }
 
 void PlacesItemModel::slotStorageTeardownDone(Solid::ErrorType error, const QVariant& errorData)
 }
 
 void PlacesItemModel::slotStorageTeardownDone(Solid::ErrorType error, const QVariant& errorData)


@@ -484,6 +599,33 @@ void PlacesItemModel::slotStorageTeardownDone(Solid::ErrorType error, const QVar
     }
 }
 
     }
 }
 

+void PlacesItemModel::slotStorageSetupDone(Solid::ErrorType error,
+                                           const QVariant& errorData,
+                                           const QString& udi)
+{
+    Q_UNUSED(udi);
+
+    const int index = m_storageSetupInProgress.take(sender());
+    const PlacesItem*  item = placesItem(index);
+    if (!item) {
+        return;
+    }
+
+    if (error != Solid::NoError) {
+        if (errorData.isValid()) {
+            emit errorMessage(i18nc("@info", "An error occurred while accessing '%1', the system responded: %2",
+                                    item->text(),
+                                    errorData.toString()));
+        } else {
+            emit errorMessage(i18nc("@info", "An error occurred while accessing '%1'",
+                                    item->text()));
+        }
+        emit storageSetupDone(index, false);
+    } else {
+        emit storageSetupDone(index, true);
+    }
+}
+

 void PlacesItemModel::hideItem()
 {
     hideItem(m_hiddenItemToRemove);
 void PlacesItemModel::hideItem()
 {
     hideItem(m_hiddenItemToRemove);


@@ -497,7 +639,7 @@ void PlacesItemModel::updateBookmarks()
     KBookmarkGroup root = m_bookmarkManager->root();
     KBookmark newBookmark = root.first();
     while (!newBookmark.isNull()) {
     KBookmarkGroup root = m_bookmarkManager->root();
     KBookmark newBookmark = root.first();
     while (!newBookmark.isNull()) {

-        if (acceptBookmark(newBookmark)) {
+        if (acceptBookmark(newBookmark, m_availableDevices)) {

             bool found = false;
             int modelIndex = 0;
             for (int i = 0; i < m_bookmarkedItems.count(); ++i) {
             bool found = false;
             int modelIndex = 0;
             for (int i = 0; i < m_bookmarkedItems.count(); ++i) {


@@ -515,17 +657,29 @@ void PlacesItemModel::updateBookmarks()
                     found = true;
                     if (newBookmark.metaDataItem("UDI").isEmpty()) {
                         item->setBookmark(newBookmark);
                     found = true;
                     if (newBookmark.metaDataItem("UDI").isEmpty()) {
                         item->setBookmark(newBookmark);

+                        item->setText(i18nc("KFile System Bookmarks", newBookmark.text().toUtf8().constData()));

                     }
                     break;
                 }
             }
 
             if (!found) {
                     }
                     break;
                 }
             }
 
             if (!found) {

-                PlacesItem* item = new PlacesItem(newBookmark);
-                if (item->isHidden() && !m_hiddenItemsShown) {
-                    m_bookmarkedItems.append(item);
-                } else {
-                    appendItem(item);
+                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);
+                    }

                 }
             }
         }
                 }
             }
         }


@@ -580,7 +734,7 @@ void PlacesItemModel::loadBookmarks()
     KBookmark bookmark = root.first();
     QSet<QString> devices = m_availableDevices;
 
     KBookmark bookmark = root.first();
     QSet<QString> devices = m_availableDevices;
 

-    QSet<KUrl> missingSystemBookmarks;
+    QSet<QUrl> missingSystemBookmarks;

     foreach (const SystemBookmarkData& data, m_systemBookmarks) {
         missingSystemBookmarks.insert(data.url);
     }
     foreach (const SystemBookmarkData& data, m_systemBookmarks) {
         missingSystemBookmarks.insert(data.url);
     }


@@ -590,34 +744,36 @@ void PlacesItemModel::loadBookmarks()
     // items should always be collected in one group so the items are collected first
     // in separate lists before inserting them.
     QList<PlacesItem*> placesItems;
     // items should always be collected in one group so the items are collected first
     // in separate lists before inserting them.
     QList<PlacesItem*> placesItems;

-    QList<PlacesItem*> recentlyAccessedItems;
+    QList<PlacesItem*> recentlySavedItems;

     QList<PlacesItem*> searchForItems;
     QList<PlacesItem*> devicesItems;
 
     while (!bookmark.isNull()) {
     QList<PlacesItem*> searchForItems;
     QList<PlacesItem*> devicesItems;
 
     while (!bookmark.isNull()) {

-        const bool deviceAvailable = devices.remove(bookmark.metaDataItem("UDI"));
-        if (acceptBookmark(bookmark)) {
+        if (acceptBookmark(bookmark, devices)) {

             PlacesItem* item = new PlacesItem(bookmark);
             PlacesItem* item = new PlacesItem(bookmark);

-            if (deviceAvailable) {
+            if (item->groupType() == PlacesItem::DevicesType) {
+                devices.remove(item->udi());

                 devicesItems.append(item);
             } else {
                 devicesItems.append(item);
             } else {

-                const KUrl url = bookmark.url();
+                const QUrl url = bookmark.url();

                 if (missingSystemBookmarks.contains(url)) {
                     missingSystemBookmarks.remove(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);
+                    // 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);
                 }
 
                 switch (item->groupType()) {
                     item->setSystemItem(true);
                 }
 
                 switch (item->groupType()) {

-                case PlacesItem::PlacesType:           placesItems.append(item); break;
-                case PlacesItem::RecentlyAccessedType: recentlyAccessedItems.append(item); break;
-                case PlacesItem::SearchForType:        searchForItems.append(item); break;
+                case PlacesItem::PlacesType:        placesItems.append(item); break;
+                case PlacesItem::RecentlySavedType: recentlySavedItems.append(item); break;
+                case PlacesItem::SearchForType:     searchForItems.append(item); break;

                 case PlacesItem::DevicesType:
                 case PlacesItem::DevicesType:

-                default:                               Q_ASSERT(false); break;
+                default:                            Q_ASSERT(false); break;

                 }
             }
         }
                 }
             }
         }


@@ -632,11 +788,11 @@ void PlacesItemModel::loadBookmarks()
             if (missingSystemBookmarks.contains(data.url)) {
                 PlacesItem* item = createSystemPlacesItem(data);
                 switch (item->groupType()) {
             if (missingSystemBookmarks.contains(data.url)) {
                 PlacesItem* item = createSystemPlacesItem(data);
                 switch (item->groupType()) {

-                case PlacesItem::PlacesType:           placesItems.append(item); break;
-                case PlacesItem::RecentlyAccessedType: recentlyAccessedItems.append(item); break;
-                case PlacesItem::SearchForType:        searchForItems.append(item); break;
+                case PlacesItem::PlacesType:        placesItems.append(item); break;
+                case PlacesItem::RecentlySavedType: recentlySavedItems.append(item); break;
+                case PlacesItem::SearchForType:     searchForItems.append(item); break;

                 case PlacesItem::DevicesType:
                 case PlacesItem::DevicesType:

-                default:                               Q_ASSERT(false); break;
+                default:                            Q_ASSERT(false); break;

                 }
             }
         }
                 }
             }
         }


@@ -650,7 +806,7 @@ void PlacesItemModel::loadBookmarks()
 
     QList<PlacesItem*> items;
     items.append(placesItems);
 
     QList<PlacesItem*> items;
     items.append(placesItems);

-    items.append(recentlyAccessedItems);
+    items.append(recentlySavedItems);

     items.append(searchForItems);
     items.append(devicesItems);
 
     items.append(searchForItems);
     items.append(devicesItems);
 


@@ -668,18 +824,19 @@ void PlacesItemModel::loadBookmarks()
 #endif
 }
 
 #endif
 }
 

-bool PlacesItemModel::acceptBookmark(const KBookmark& bookmark) const
+bool PlacesItemModel::acceptBookmark(const KBookmark& bookmark,
+                                     const QSet<QString>& availableDevices) const

 {
     const QString udi = bookmark.metaDataItem("UDI");
 {
     const QString udi = bookmark.metaDataItem("UDI");

-    const KUrl url = bookmark.url();
+    const QUrl url = bookmark.url();

     const QString appName = bookmark.metaDataItem("OnlyInApp");
     const QString appName = bookmark.metaDataItem("OnlyInApp");

-    const bool deviceAvailable = m_availableDevices.contains(udi);
+    const bool deviceAvailable = availableDevices.contains(udi);

 
     const bool allowedHere = (appName.isEmpty()
                               || appName == KGlobal::mainComponent().componentName()
                               || appName == KGlobal::mainComponent().componentName() + AppNamePrefix)
 
     const bool allowedHere = (appName.isEmpty()
                               || appName == KGlobal::mainComponent().componentName()
                               || appName == KGlobal::mainComponent().componentName() + AppNamePrefix)

-                             && (m_nepomukRunning || (url.protocol() != QLatin1String("timeline") &&
-                                                      url.protocol() != QLatin1String("search")));
+                             && (m_fileIndexingEnabled || (url.scheme() != QLatin1String("timeline") &&
+                                                           url.scheme() != QLatin1String("search")));

 
     return (udi.isEmpty() && allowedHere) || deviceAvailable;
 }
 
     return (udi.isEmpty() && allowedHere) || deviceAvailable;
 }


@@ -691,10 +848,10 @@ PlacesItem* PlacesItemModel::createSystemPlacesItem(const SystemBookmarkData& da
                                                     data.url,
                                                     data.icon);
 
                                                     data.url,
                                                     data.icon);
 

-    const QString protocol = data.url.protocol();
+    const QString protocol = data.url.scheme();

     if (protocol == QLatin1String("timeline") || protocol == QLatin1String("search")) {
         // As long as the KFilePlacesView from kdelibs is available, the system-bookmarks
     if (protocol == QLatin1String("timeline") || protocol == QLatin1String("search")) {
         // As long as the KFilePlacesView from kdelibs is available, the system-bookmarks

-        // for "Recently Accessed" and "Search For" should be a setting available only
+        // for "Recently Saved" and "Search For" should be a setting available only

         // in the Places Panel (see description of AppNamePrefix for more details).
         const QString appName = KGlobal::mainComponent().componentName() + AppNamePrefix;
         bookmark.setMetaDataItem("OnlyInApp", appName);
         // in the Places Panel (see description of AppNamePrefix for more details).
         const QString appName = KGlobal::mainComponent().componentName() + AppNamePrefix;
         bookmark.setMetaDataItem("OnlyInApp", appName);


@@ -703,11 +860,11 @@ PlacesItem* PlacesItemModel::createSystemPlacesItem(const SystemBookmarkData& da
     PlacesItem* item = new PlacesItem(bookmark);
     item->setSystemItem(true);
 
     PlacesItem* item = new PlacesItem(bookmark);
     item->setSystemItem(true);
 

-    // Create default view-properties for all "Search For" and "Recently Accessed" bookmarks
+    // Create default view-properties for all "Search For" and "Recently Saved" bookmarks

     // in case if the user has not already created custom view-properties for a corresponding
     // query yet.
     const bool createDefaultViewProperties = (item->groupType() == PlacesItem::SearchForType ||
     // in case if the user has not already created custom view-properties for a corresponding
     // query yet.
     const bool createDefaultViewProperties = (item->groupType() == PlacesItem::SearchForType ||

-                                              item->groupType() == PlacesItem::RecentlyAccessedType) &&
+                                              item->groupType() == PlacesItem::RecentlySavedType) &&

                                               !GeneralSettings::self()->globalViewProps();
     if (createDefaultViewProperties) {
         ViewProperties props(convertedUrl(data.url));
                                               !GeneralSettings::self()->globalViewProps();
     if (createDefaultViewProperties) {
         ViewProperties props(convertedUrl(data.url));


@@ -716,22 +873,22 @@ PlacesItem* PlacesItemModel::createSystemPlacesItem(const SystemBookmarkData& da
             if (path == QLatin1String("/documents")) {
                 props.setViewMode(DolphinView::DetailsView);
                 props.setPreviewsShown(false);
             if (path == QLatin1String("/documents")) {
                 props.setViewMode(DolphinView::DetailsView);
                 props.setPreviewsShown(false);

-                props.setVisibleRoles(QList<QByteArray>() << "text" << "path");
+                props.setVisibleRoles({"text", "path"});

             } else if (path == QLatin1String("/images")) {
                 props.setViewMode(DolphinView::IconsView);
                 props.setPreviewsShown(true);
             } else if (path == QLatin1String("/images")) {
                 props.setViewMode(DolphinView::IconsView);
                 props.setPreviewsShown(true);

-                props.setVisibleRoles(QList<QByteArray>() << "text" << "imageSize");
+                props.setVisibleRoles({"text", "imageSize"});

             } else if (path == QLatin1String("/audio")) {
                 props.setViewMode(DolphinView::DetailsView);
                 props.setPreviewsShown(false);
             } else if (path == QLatin1String("/audio")) {
                 props.setViewMode(DolphinView::DetailsView);
                 props.setPreviewsShown(false);

-                props.setVisibleRoles(QList<QByteArray>() << "text" << "artist" << "album");
+                props.setVisibleRoles({"text", "artist", "album"});

             } else if (path == QLatin1String("/videos")) {
                 props.setViewMode(DolphinView::IconsView);
                 props.setPreviewsShown(true);
             } else if (path == QLatin1String("/videos")) {
                 props.setViewMode(DolphinView::IconsView);
                 props.setPreviewsShown(true);

-                props.setVisibleRoles(QList<QByteArray>() << "text");
-            } else if (data.url.protocol() == "timeline") {
+                props.setVisibleRoles({"text"});
+            } else if (data.url.scheme() == "timeline") {

                 props.setViewMode(DolphinView::DetailsView);
                 props.setViewMode(DolphinView::DetailsView);

-                props.setVisibleRoles(QList<QByteArray>() << "text" << "date");
+                props.setVisibleRoles({"text", "date"});

             }
         }
     }
             }
         }
     }


@@ -744,47 +901,48 @@ void PlacesItemModel::createSystemBookmarks()
     Q_ASSERT(m_systemBookmarks.isEmpty());
     Q_ASSERT(m_systemBookmarksIndexes.isEmpty());
 
     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
-
-    m_systemBookmarks.append(SystemBookmarkData(KUrl(KUser().homeDir()),
+    // 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",
                                                 "user-home",

-                                                i18nc("@item", "Home")));
-    m_systemBookmarks.append(SystemBookmarkData(KUrl("remote:/"),
+                                                I18N_NOOP2("KFile System Bookmarks", "Home")));
+    m_systemBookmarks.append(SystemBookmarkData(QUrl("remote:/"),

                                                 "network-workgroup",
                                                 "network-workgroup",

-                                                i18nc("@item", "Network")));
-    m_systemBookmarks.append(SystemBookmarkData(KUrl("/"),
+                                                I18N_NOOP2("KFile System Bookmarks", "Network")));
+    m_systemBookmarks.append(SystemBookmarkData(QUrl::fromLocalFile("/"),

                                                 "folder-red",
                                                 "folder-red",

-                                                i18nc("@item", "Root")));
-    m_systemBookmarks.append(SystemBookmarkData(KUrl("trash:/"),
+                                                I18N_NOOP2("KFile System Bookmarks", "Root")));
+    m_systemBookmarks.append(SystemBookmarkData(QUrl("trash:/"),

                                                 "user-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"),
+                                                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-txt",
                                                     "folder-txt",

-                                                    i18nc("@item Commonly Accessed", "Documents")));
-        m_systemBookmarks.append(SystemBookmarkData(KUrl("search:/images"),
+                                                    I18N_NOOP2("KFile System Bookmarks", "Documents")));
+        m_systemBookmarks.append(SystemBookmarkData(QUrl("search:/images"),

                                                     "folder-image",
                                                     "folder-image",

-                                                    i18nc("@item Commonly Accessed", "Images")));
-        m_systemBookmarks.append(SystemBookmarkData(KUrl("search:/audio"),
+                                                    I18N_NOOP2("KFile System Bookmarks", "Images")));
+        m_systemBookmarks.append(SystemBookmarkData(QUrl("search:/audio"),

                                                     "folder-sound",
                                                     "folder-sound",

-                                                    i18nc("@item Commonly Accessed", "Audio Files")));
-        m_systemBookmarks.append(SystemBookmarkData(KUrl("search:/videos"),
+                                                    I18N_NOOP2("KFile System Bookmarks", "Audio Files")));
+        m_systemBookmarks.append(SystemBookmarkData(QUrl("search:/videos"),

                                                     "folder-video",
                                                     "folder-video",

-                                                    i18nc("@item Commonly Accessed", "Videos")));
+                                                    I18N_NOOP2("KFile System Bookmarks", "Videos")));

     }
 
     for (int i = 0; i < m_systemBookmarks.count(); ++i) {
     }
 
     for (int i = 0; i < m_systemBookmarks.count(); ++i) {


@@ -792,24 +950,36 @@ void PlacesItemModel::createSystemBookmarks()
     }
 }
 
     }
 }
 

+void PlacesItemModel::clear() {
+    m_bookmarkedItems.clear();
+    KStandardItemModel::clear();
+}
+

 void PlacesItemModel::initializeAvailableDevices()
 {
 void PlacesItemModel::initializeAvailableDevices()
 {

-    m_predicate = Solid::Predicate::fromString(
-        "[[[[ StorageVolume.ignored == false AND [ StorageVolume.usage == 'FileSystem' OR StorageVolume.usage == 'Encrypted' ]]"
+    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 ]");
         " 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());
 
     Solid::DeviceNotifier* notifier = Solid::DeviceNotifier::instance();
     Q_ASSERT(m_predicate.isValid());
 
     Solid::DeviceNotifier* notifier = Solid::DeviceNotifier::instance();

-    connect(notifier, SIGNAL(deviceAdded(QString)),   this, SLOT(slotDeviceAdded(QString)));
-    connect(notifier, SIGNAL(deviceRemoved(QString)), this, SLOT(slotDeviceRemoved(QString)));
+    connect(notifier, &Solid::DeviceNotifier::deviceAdded,   this, &PlacesItemModel::slotDeviceAdded);
+    connect(notifier, &Solid::DeviceNotifier::deviceRemoved, this, &PlacesItemModel::slotDeviceRemoved);

 
     const QList<Solid::Device>& deviceList = Solid::Device::listFromQuery(m_predicate);
 
     const QList<Solid::Device>& deviceList = Solid::Device::listFromQuery(m_predicate);

-    foreach(const Solid::Device& device, deviceList) {
+    foreach (const Solid::Device& device, deviceList) {

         m_availableDevices << device.udi();
     }
 }
         m_availableDevices << device.udi();
     }
 }


@@ -879,6 +1049,56 @@ void PlacesItemModel::triggerBookmarksSaving()
     }
 }
 
     }
 }
 

+QString PlacesItemModel::internalMimeType() const
+{
+    return "application/x-dolphinplacesmodel-" +
+            QString::number((qptrdiff)this);
+}
+
+int PlacesItemModel::groupedDropIndex(int index, const PlacesItem* item) const
+{
+    Q_ASSERT(item);
+
+    int dropIndex = index;
+    const PlacesItem::GroupType type = item->groupType();
+
+    const int itemCount = count();
+    if (index < 0) {
+        dropIndex = itemCount;
+    }
+
+    // Search nearest previous item with the same group
+    int previousIndex = -1;
+    for (int i = dropIndex - 1; i >= 0; --i) {
+        if (placesItem(i)->groupType() == type) {
+            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) {
+            nextIndex = i;
+            break;
+        }
+    }
+
+    // Adjust the drop-index to be inserted to the
+    // nearest item with the same group.
+    if (previousIndex >= 0 && nextIndex >= 0) {
+        dropIndex = (dropIndex - previousIndex < nextIndex - dropIndex) ?
+                    previousIndex + 1 : nextIndex;
+    } else if (previousIndex >= 0) {
+        dropIndex = previousIndex + 1;
+    } else if (nextIndex >= 0) {
+        dropIndex = nextIndex;
+    }
+
+    return dropIndex;
+}
+

 bool PlacesItemModel::equalBookmarkIdentifiers(const KBookmark& b1, const KBookmark& b2)
 {
     const QString udi1 = b1.metaDataItem("UDI");
 bool PlacesItemModel::equalBookmarkIdentifiers(const KBookmark& b1, const KBookmark& b2)
 {
     const QString udi1 = b1.metaDataItem("UDI");


@@ -890,29 +1110,29 @@ bool PlacesItemModel::equalBookmarkIdentifiers(const KBookmark& b1, const KBookm
     }
 }
 
     }
 }
 

-KUrl PlacesItemModel::createTimelineUrl(const KUrl& url)
+QUrl PlacesItemModel::createTimelineUrl(const QUrl& url)

 {
 {

-    // TODO: Clarify with the Nepomuk-team whether it makes sense
+    // TODO: Clarify with the Baloo-team whether it makes sense

     // provide default-timeline-URLs like 'yesterday', 'this month'
     // and 'last month'.
     // provide default-timeline-URLs like 'yesterday', 'this month'
     // and 'last month'.

-    KUrl timelineUrl;
+    QUrl timelineUrl;

 
 

-    const QString path = url.pathOrUrl();
-    if (path.endsWith("yesterday")) {
+    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);
         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")) {
+    } else if (path.endsWith(QLatin1String("thismonth"))) {

         const QDate date = QDate::currentDate();
         timelineUrl = "timeline:/" + timelineDateString(date.year(), date.month());
         const QDate date = QDate::currentDate();
         timelineUrl = "timeline:/" + timelineDateString(date.year(), date.month());

-    } else if (path.endsWith("lastmonth")) {
+    } else if (path.endsWith(QLatin1String("lastmonth"))) {

         const QDate date = QDate::currentDate().addMonths(-1);
         timelineUrl = "timeline:/" + timelineDateString(date.year(), date.month());
     } else {
         const QDate date = QDate::currentDate().addMonths(-1);
         timelineUrl = "timeline:/" + timelineDateString(date.year(), date.month());
     } else {

-        Q_ASSERT(path.endsWith("today"));
+        Q_ASSERT(path.endsWith(QLatin1String("today")));

         timelineUrl= url;
     }
 
         timelineUrl= url;
     }
 


@@ -938,22 +1158,20 @@ QString PlacesItemModel::timelineDateString(int year, int month, int day)
     return date;
 }
 
     return date;
 }
 

-KUrl PlacesItemModel::createSearchUrl(const KUrl& url)
+QUrl PlacesItemModel::createSearchUrl(const QUrl& url)

 {
 {

-    KUrl searchUrl;
-
-#ifdef HAVE_NEPOMUK
-    const QString path = url.pathOrUrl();
-    if (path.endsWith("documents")) {
-        searchUrl = searchUrlForTerm(Nepomuk::Query::ResourceTypeTerm(Nepomuk::Vocabulary::NFO::Document()));
-    } else if (path.endsWith("images")) {
-        searchUrl = searchUrlForTerm(Nepomuk::Query::ResourceTypeTerm(Nepomuk::Vocabulary::NFO::Image()));
-    } else if (path.endsWith("audio")) {
-        searchUrl = searchUrlForTerm(Nepomuk::Query::ComparisonTerm(Nepomuk::Vocabulary::NIE::mimeType(),
-                                                                    Nepomuk::Query::LiteralTerm("audio")));
-    } else if (path.endsWith("videos")) {
-        searchUrl = searchUrlForTerm(Nepomuk::Query::ComparisonTerm(Nepomuk::Vocabulary::NIE::mimeType(),
-                                                                    Nepomuk::Query::LiteralTerm("video")));
+    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_ASSERT(false);
     }


@@ -964,10 +1182,13 @@ KUrl PlacesItemModel::createSearchUrl(const KUrl& url)
     return searchUrl;
 }
 
     return searchUrl;
 }
 

-#ifdef HAVE_NEPOMUK
-KUrl PlacesItemModel::searchUrlForTerm(const Nepomuk::Query::Term& term)
+#ifdef HAVE_BALOO
+QUrl PlacesItemModel::searchUrlForType(const QString& type)

 {
 {

-    const Nepomuk::Query::Query query(term);
+    Baloo::Query query;
+    query.addType("File");
+    query.addType(type);
+

     return query.toSearchUrl();
 }
 #endif
     return query.toSearchUrl();
 }
 #endif


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

-#include "placesitemmodel.moc"