diff --git a/src/models/trackmetadatamodel.cpp b/src/models/trackmetadatamodel.cpp
index 569cef1f..5301ab9d 100644
--- a/src/models/trackmetadatamodel.cpp
+++ b/src/models/trackmetadatamodel.cpp
@@ -1,563 +1,565 @@
 /*
  * Copyright 2018 Matthieu Gallien <matthieu_gallien@yahoo.fr>
  *
  * This program is free software: you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 3 of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
 #include "trackmetadatamodel.h"
 
 #include "musiclistenersmanager.h"
 
 #include <KI18n/KLocalizedString>
 
 #include <QtConcurrentRun>
 
 TrackMetadataModel::TrackMetadataModel(QObject *parent)
     : QAbstractListModel(parent)
 {
     connect(&mLyricsValueWatcher, &QFutureWatcher<QString>::finished,
             this, &TrackMetadataModel::lyricsValueIsReady);
 }
 
 TrackMetadataModel::~TrackMetadataModel()
 {
     if (mLyricsValueWatcher.isRunning() && !mLyricsValueWatcher.isFinished()) {
         mLyricsValueWatcher.waitForFinished();
     }
 }
 
 int TrackMetadataModel::rowCount(const QModelIndex &parent) const
 {
     if (parent.isValid()) {
         return 0;
     }
 
     return mTrackData.count();
 }
 
 QVariant TrackMetadataModel::data(const QModelIndex &index, int role) const
 {
     auto result = QVariant{};
 
     const auto currentKey = mTrackKeys[index.row()];
 
     switch (role)
     {
     case Qt::DisplayRole:
         switch (currentKey)
         {
         case DataTypes::TrackNumberRole:
         {
             auto trackNumber = mTrackData.trackNumber();
             if (trackNumber > 0) {
                 result = trackNumber;
             }
             break;
         }
         case DataTypes::DiscNumberRole:
         {
             auto discNumber = mTrackData.discNumber();
             if (discNumber > 0) {
                 result = discNumber;
             }
             break;
         }
         case DataTypes::ChannelsRole:
         {
             auto channels = mTrackData.channels();
             if (channels > 0) {
                 result = channels;
             }
             break;
         }
         case DataTypes::BitRateRole:
         {
             auto bitRate = mTrackData.bitRate();
             if (bitRate > 0) {
                 result = bitRate;
             }
             break;
         }
         case DataTypes::SampleRateRole:
         {
             auto sampleRate = mTrackData.sampleRate();
             if (sampleRate > 0) {
                 result = sampleRate;
             }
             break;
         }
         default:
             result = mTrackData[currentKey];
             break;
         }
         break;
     case ItemNameRole:
         switch (currentKey)
         {
         case DataTypes::TitleRole:
             result = i18nc("Track title for track metadata view", "Title");
             break;
         case DataTypes::DurationRole:
             result = i18nc("Duration label for track metadata view", "Duration");
             break;
         case DataTypes::ArtistRole:
             result = i18nc("Track artist for track metadata view", "Artist");
             break;
         case DataTypes::AlbumRole:
             result = i18nc("Album name for track metadata view", "Album");
             break;
         case DataTypes::AlbumArtistRole:
             result = i18nc("Album artist for track metadata view", "Album Artist");
             break;
         case DataTypes::TrackNumberRole:
             result = i18nc("Track number for track metadata view", "Track Number");
             break;
         case DataTypes::DiscNumberRole:
             result = i18nc("Disc number for track metadata view", "Disc Number");
             break;
         case DataTypes::RatingRole:
             result = i18nc("Rating label for information panel", "Rating");
             break;
         case DataTypes::GenreRole:
             result = i18nc("Genre label for track metadata view", "Genre");
             break;
         case DataTypes::LyricistRole:
             result = i18nc("Lyricist label for track metadata view", "Lyricist");
             break;
         case DataTypes::ComposerRole:
             result = i18nc("Composer name for track metadata view", "Composer");
             break;
         case DataTypes::CommentRole:
             result = i18nc("Comment label for track metadata view", "Comment");
             break;
         case DataTypes::YearRole:
             result = i18nc("Year label for track metadata view", "Year");
             break;
         case DataTypes::ChannelsRole:
             result = i18nc("Channels label for track metadata view", "Channels");
             break;
         case DataTypes::BitRateRole:
             result = i18nc("Bit rate label for track metadata view", "Bit Rate");
             break;
         case DataTypes::SampleRateRole:
             result = i18nc("Sample Rate label for track metadata view", "Sample Rate");
             break;
         case DataTypes::LastPlayDate:
             result = i18nc("Last play date label for track metadata view", "Last played");
             break;
         case DataTypes::PlayCounter:
             result = i18nc("Play counter label for track metadata view", "Play count");
             break;
         case DataTypes::LyricsRole:
             result = i18nc("Lyrics label for track metadata view", "Lyrics");
             break;
         case DataTypes::ResourceRole:
             result = i18nc("Radio HTTP address for radio metadata view", "Stream Http Address");
             break;
         case DataTypes::SecondaryTextRole:
         case DataTypes::ImageUrlRole:
         case DataTypes::ShadowForImageRole:
         case DataTypes::ChildModelRole:
         case DataTypes::StringDurationRole:
         case DataTypes::IsValidAlbumArtistRole:
         case DataTypes::AllArtistsRole:
         case DataTypes::HighestTrackRating:
         case DataTypes::IdRole:
         case DataTypes::ParentIdRole:
         case DataTypes::DatabaseIdRole:
         case DataTypes::IsSingleDiscAlbumRole:
         case DataTypes::ContainerDataRole:
         case DataTypes::IsPartialDataRole:
         case DataTypes::AlbumIdRole:
         case DataTypes::HasEmbeddedCover:
         case DataTypes::FileModificationTime:
         case DataTypes::FirstPlayDate:
         case DataTypes::PlayFrequency:
         case DataTypes::ElementTypeRole:
             break;
         }
         break;
     case ItemTypeRole:
         switch (currentKey)
         {
         case DataTypes::TitleRole:
             result = TextEntry;
             break;
         case DataTypes::ResourceRole:
             result = TextEntry;
             break;
         case DataTypes::ArtistRole:
             result = TextEntry;
             break;
         case DataTypes::AlbumRole:
             result = TextEntry;
             break;
         case DataTypes::AlbumArtistRole:
             result = TextEntry;
             break;
         case DataTypes::TrackNumberRole:
             result = IntegerEntry;
             break;
         case DataTypes::DiscNumberRole:
             result = IntegerEntry;
             break;
         case DataTypes::RatingRole:
             result = RatingEntry;
             break;
         case DataTypes::GenreRole:
             result = TextEntry;
             break;
         case DataTypes::LyricistRole:
             result = TextEntry;
             break;
         case DataTypes::ComposerRole:
             result = TextEntry;
             break;
         case DataTypes::CommentRole:
             result = TextEntry;
             break;
         case DataTypes::YearRole:
             result = IntegerEntry;
             break;
         case DataTypes::LastPlayDate:
             result = DateEntry;
             break;
         case DataTypes::PlayCounter:
             result = IntegerEntry;
             break;
         case DataTypes::LyricsRole:
             result = LongTextEntry;
             break;
         case DataTypes::DurationRole:
         case DataTypes::SampleRateRole:
         case DataTypes::BitRateRole:
         case DataTypes::ChannelsRole:
         case DataTypes::SecondaryTextRole:
         case DataTypes::ImageUrlRole:
         case DataTypes::ShadowForImageRole:
         case DataTypes::ChildModelRole:
         case DataTypes::StringDurationRole:
         case DataTypes::IsValidAlbumArtistRole:
         case DataTypes::AllArtistsRole:
         case DataTypes::HighestTrackRating:
         case DataTypes::IdRole:
         case DataTypes::ParentIdRole:
         case DataTypes::DatabaseIdRole:
         case DataTypes::IsSingleDiscAlbumRole:
         case DataTypes::ContainerDataRole:
         case DataTypes::IsPartialDataRole:
         case DataTypes::AlbumIdRole:
         case DataTypes::HasEmbeddedCover:
         case DataTypes::FileModificationTime:
         case DataTypes::FirstPlayDate:
         case DataTypes::PlayFrequency:
         case DataTypes::ElementTypeRole:
             break;
         }
         break;
     }
 
     return result;
 }
 
 bool TrackMetadataModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
     if (data(index, role) != value) {
         mTrackData[mTrackKeys[index.row()]] = value;
 
         emit dataChanged(index, index, QVector<int>() << role);
         return true;
     }
     return false;
 }
 
 QHash<int, QByteArray> TrackMetadataModel::roleNames() const
 {
     auto names = QAbstractListModel::roleNames();
 
     names[ItemNameRole] = "name";
     names[ItemTypeRole] = "type";
 
     return names;
 }
 
 QString TrackMetadataModel::fileUrl() const
 {
     return mFileUrl;
 }
 
 QUrl TrackMetadataModel::coverUrl() const
 {
     if (mCoverImage.isEmpty()) {
         return QUrl(QStringLiteral("image://icon/media-optical-audio"));
     } else {
         return mCoverImage;
     }
 }
 
 MusicListenersManager *TrackMetadataModel::manager() const
 {
     return mManager;
 }
 
 QString TrackMetadataModel::lyrics() const
 {
     return mFullData[TrackDataType::key_type::LyricsRole].toString();
 }
 
 qulonglong TrackMetadataModel::databaseId() const
 {
     return mDatabaseId;
 }
 
 void TrackMetadataModel::trackData(const TrackMetadataModel::TrackDataType &trackData)
 {
     if (!mFullData.isEmpty() && trackData.databaseId() != mFullData.databaseId()) {
         return;
     }
 
     const QList<DataTypes::ColumnsRoles> fieldsForTrack({DataTypes::TitleRole, DataTypes::ArtistRole,
                                                                  DataTypes::AlbumRole, DataTypes::AlbumArtistRole,
                                                                  DataTypes::TrackNumberRole, DataTypes::DiscNumberRole,
                                                                  DataTypes::RatingRole, DataTypes::GenreRole,
                                                                  DataTypes::LyricistRole, DataTypes::ComposerRole,
                                                                  DataTypes::CommentRole, DataTypes::YearRole,
                                                                  DataTypes::LastPlayDate, DataTypes::PlayCounter});
 
     fillDataFromTrackData(trackData, fieldsForTrack);
 }
 
 void TrackMetadataModel::fillDataFromTrackData(const TrackMetadataModel::TrackDataType &trackData,
                                                const QList<DataTypes::ColumnsRoles> &fieldsForTrack)
 {
     beginResetModel();
     mFullData = trackData;
     mTrackData.clear();
     mTrackKeys.clear();
 
     for (DataTypes::ColumnsRoles role : fieldsForTrack) {
         if (trackData.constFind(role) != trackData.constEnd()) {
             if (role == DataTypes::RatingRole) {
                 if (trackData[role].toInt() == 0) {
                     continue;
                 }
             }
 
             mTrackKeys.push_back(role);
             mTrackData[role] = trackData[role];
         }
     }
     filterDataFromTrackData();
     endResetModel();
 
     fetchLyrics();
 
     mDatabaseId = trackData[DataTypes::DatabaseIdRole].toULongLong();
     Q_EMIT databaseIdChanged();
 
     mCoverImage = trackData[DataTypes::ImageUrlRole].toUrl();
     Q_EMIT coverUrlChanged();
 
     auto rawFileUrl = trackData[DataTypes::ResourceRole].toUrl();
 
     if (rawFileUrl.isLocalFile()) {
         mFileUrl = rawFileUrl.toLocalFile();
     } else {
         mFileUrl = rawFileUrl.toString();
     }
     Q_EMIT fileUrlChanged();
 }
 
 void TrackMetadataModel::filterDataFromTrackData()
 {
 }
 
 void TrackMetadataModel::removeMetaData(DataTypes::ColumnsRoles metaData)
 {
     auto itMetaData = std::find(mTrackKeys.begin(), mTrackKeys.end(), metaData);
     if (itMetaData == mTrackKeys.end()) {
         return;
     }
 
     mTrackKeys.erase(itMetaData);
     mTrackData.remove(metaData);
 }
 
 TrackMetadataModel::TrackDataType::mapped_type TrackMetadataModel::dataFromType(TrackDataType::key_type metaData) const
 {
     return mFullData[metaData];
 }
 
 void TrackMetadataModel::fillLyricsDataFromTrack()
 {
     beginInsertRows({}, mTrackData.size(), mTrackData.size());
     mTrackKeys.push_back(DataTypes::LyricsRole);
     mTrackData[DataTypes::LyricsRole] = mLyricsValueWatcher.result();
     endInsertRows();
 }
 
 void TrackMetadataModel::lyricsValueIsReady()
 {
     if (!mLyricsValueWatcher.result().isEmpty()) {
         fillLyricsDataFromTrack();
 
         mFullData[DataTypes::LyricsRole] = mLyricsValueWatcher.result();
 
         Q_EMIT lyricsChanged();
     }
 }
 
 void TrackMetadataModel::initializeByIdAndUrl(ElisaUtils::PlayListEntryType type, qulonglong databaseId, const QUrl &url)
 {
     mFullData.clear();
     mTrackData.clear();
     mCoverImage.clear();
     mFileUrl.clear();
 
     Q_EMIT lyricsChanged();
 
     Q_EMIT needDataByDatabaseIdAndUrl(type, databaseId, url);
 }
 
 void TrackMetadataModel::initialize(MusicListenersManager *newManager, DatabaseInterface *trackDatabase)
 {
     mManager = newManager;
     Q_EMIT managerChanged();
 
     if (mManager) {
         mDataLoader.setDatabase(mManager->viewDatabase());
+        connect(this, &TrackMetadataModel::needDataByUrl,
+                mManager->tracksListener(), &TracksListener::trackByFileNameInList);
+        connect(mManager->tracksListener(), &TracksListener::trackHasChanged,
+                this, &TrackMetadataModel::trackData);
     } else if (trackDatabase) {
         mDataLoader.setDatabase(trackDatabase);
     }
 
     if (mManager) {
         mManager->connectModel(&mDataLoader);
     }
 
     connect(this, &TrackMetadataModel::needDataByDatabaseIdAndUrl,
             &mDataLoader, &ModelDataLoader::loadDataByDatabaseIdAndUrl);
     connect(this, &TrackMetadataModel::needDataByUrl,
             &mDataLoader, &ModelDataLoader::loadDataByUrl);
     connect(this, &TrackMetadataModel::saveRadioData,
             &mDataLoader, &ModelDataLoader::saveRadioModified);
     connect(this, &TrackMetadataModel::deleteRadioData,
             &mDataLoader, &ModelDataLoader::removeRadio);
     connect(&mDataLoader, &ModelDataLoader::trackModified,
             this, &TrackMetadataModel::trackData);
     connect(&mDataLoader, &ModelDataLoader::allTrackData,
             this, &TrackMetadataModel::trackData);
     connect(&mDataLoader, &ModelDataLoader::allRadioData,
             this, &TrackMetadataModel::radioData);
     connect(&mDataLoader, &ModelDataLoader::radioAdded,
             this, &TrackMetadataModel::radioData);
     connect(&mDataLoader, &ModelDataLoader::radioModified,
             this, &TrackMetadataModel::radioData);
-    connect(this, &TrackMetadataModel::needDataByUrl,
-            &mDataLoader, &ModelDataLoader::loadDataByUrl);
 }
 
 void TrackMetadataModel::fetchLyrics()
 {
     auto lyricicsValue = QtConcurrent::run(QThreadPool::globalInstance(), [=]() {
         auto trackData = mFileScanner.scanOneFile(mFullData[DataTypes::ResourceRole].toUrl());
         if (!trackData.lyrics().isEmpty()) {
             return trackData.lyrics();
         }
         return QString{};
     });
 
     mLyricsValueWatcher.setFuture(lyricicsValue);
 }
 
 void TrackMetadataModel::initializeForNewRadio()
 {
     mFullData.clear();
     mTrackData.clear();
 
     fillDataForNewRadio();
 }
 
 void TrackMetadataModel::fillDataForNewRadio()
 {
     beginResetModel();
     mTrackData.clear();
     mTrackKeys.clear();
 
     for (auto role : {
          DataTypes::TitleRole,
          DataTypes::ResourceRole,
          DataTypes::CommentRole,
          DataTypes::DatabaseIdRole
 
 }) {
         mTrackKeys.push_back(role);
         if (role == DataTypes::DatabaseIdRole) {
             mTrackData[role] = -1;
         } else {
             mTrackData[role] = QString();
         }
 
     }
     filterDataFromTrackData();
     endResetModel();
 }
 
 void TrackMetadataModel::initializeByUrl(ElisaUtils::PlayListEntryType type, const QUrl &url)
 {
     mFullData.clear();
     mTrackData.clear();
     mCoverImage.clear();
     mFileUrl.clear();
 
     Q_EMIT lyricsChanged();
 
     Q_EMIT needDataByUrl(type, url);
 }
 
 void TrackMetadataModel::setManager(MusicListenersManager *newManager)
 {
     initialize(newManager, nullptr);
 }
 
 void TrackMetadataModel::setDatabase(DatabaseInterface *trackDatabase)
 {
     initialize(nullptr, trackDatabase);
 }
 
 void TrackMetadataModel::saveData()
 {
     Q_EMIT saveRadioData(mTrackData);
 }
 
 void TrackMetadataModel::deleteRadio()
 {
     if (mTrackData[DataTypes::DatabaseIdRole]>=0) {
         Q_EMIT deleteRadioData(mTrackData[DataTypes::DatabaseIdRole].toULongLong());
     }
 }
 
 void TrackMetadataModel::radioData(const TrackDataType &radiosData)
 {
     if (!mFullData.isEmpty() && mFullData[DataTypes::DatabaseIdRole].toInt() != -1 &&
             mFullData.databaseId() != radiosData.databaseId()) {
         return;
     }
 
     const QList<DataTypes::ColumnsRoles> fieldsForTrack({DataTypes::TitleRole, DataTypes::ResourceRole,
                                                                  DataTypes::CommentRole, DataTypes::DatabaseIdRole});
 
     fillDataFromTrackData(radiosData, fieldsForTrack);
 }
 
 #include "moc_trackmetadatamodel.cpp"
diff --git a/src/trackslistener.cpp b/src/trackslistener.cpp
index 50bbee2f..49e561ae 100644
--- a/src/trackslistener.cpp
+++ b/src/trackslistener.cpp
@@ -1,302 +1,304 @@
 /*
  * Copyright 2017 Matthieu Gallien <matthieu_gallien@yahoo.fr>
  *
  * This program is free software: you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 3 of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
 #include "trackslistener.h"
 
 #include "playListLogging.h"
 #include "databaseinterface.h"
 #include "datatypes.h"
 #include "filescanner.h"
 
 #include <QSet>
 #include <QList>
 #include <QDebug>
 
 #include <array>
 #include <algorithm>
 
 class TracksListenerPrivate
 {
 public:
 
     QSet<qulonglong> mTracksByIdSet;
 
     QSet<qulonglong> mRadiosByIdSet;
 
     QList<std::tuple<QString, QString, QString, int, int>> mTracksByNameSet;
 
     QList<QUrl> mTracksByFileNameSet;
 
     DatabaseInterface *mDatabase = nullptr;
 
     FileScanner mFileScanner;
 
 };
 
 TracksListener::TracksListener(DatabaseInterface *database, QObject *parent) : QObject(parent), d(std::make_unique<TracksListenerPrivate>())
 {
     d->mDatabase = database;
 }
 
 TracksListener::~TracksListener()
 = default;
 
 void TracksListener::tracksAdded(const ListTrackDataType &allTracks)
 {
     for (const auto &oneTrack : allTracks) {
         if (d->mTracksByIdSet.contains(oneTrack.databaseId())) {
             Q_EMIT trackHasChanged(oneTrack);
         }
 
         if (d->mTracksByNameSet.isEmpty()) {
             return;
         }
 
         for (auto itTrack = d->mTracksByNameSet.begin(); itTrack != d->mTracksByNameSet.end(); ) {
             if (!std::get<0>(*itTrack).isEmpty() && std::get<0>(*itTrack) != oneTrack.title()) {
                 ++itTrack;
                 continue;
             }
 
             if (!std::get<1>(*itTrack).isEmpty() && std::get<1>(*itTrack) != oneTrack.artist()) {
                 ++itTrack;
                 continue;
             }
 
             if (!std::get<2>(*itTrack).isEmpty() && std::get<2>(*itTrack) != oneTrack.album()) {
                 ++itTrack;
                 continue;
             }
 
             if (std::get<3>(*itTrack) != oneTrack.trackNumber()) {
                 ++itTrack;
                 continue;
             }
 
             if (std::get<4>(*itTrack) != oneTrack.discNumber()) {
                 ++itTrack;
                 continue;
             }
 
             Q_EMIT trackHasChanged(TrackDataType(oneTrack));
 
             d->mTracksByIdSet.insert(oneTrack.databaseId());
             itTrack = d->mTracksByNameSet.erase(itTrack);
         }
     }
 }
 
 void TracksListener::trackRemoved(qulonglong id)
 {
     if (d->mTracksByIdSet.contains(id)) {
         Q_EMIT trackHasBeenRemoved(id);
     }
 }
 
 void TracksListener::trackModified(const TrackDataType &modifiedTrack)
 {
     if (d->mTracksByIdSet.contains(modifiedTrack.databaseId())) {
         Q_EMIT trackHasChanged(modifiedTrack);
     }
 }
 
 void TracksListener::trackByNameInList(const QVariant &title, const QVariant &artist, const QVariant &album,
                                        const QVariant &trackNumber, const QVariant &discNumber)
 {
     const auto realTitle = title.toString();
     const auto realArtist = artist.toString();
     const auto albumIsValid = !album.isNull() && album.isValid() && !album.toString().isEmpty();
     auto realAlbum = std::optional<QString>{};
     if (albumIsValid) {
         realAlbum = album.toString();
     }
     auto trackNumberIsValid = bool{};
     const auto trackNumberValue = trackNumber.toInt(&trackNumberIsValid);
     auto realTrackNumber = std::optional<int>{};
     if (trackNumberIsValid) {
         realTrackNumber = trackNumberValue;
     }
     auto discNumberIsValid = bool{};
     const auto discNumberValue = discNumber.toInt(&discNumberIsValid);
     auto realDiscNumber = std::optional<int>{};
     if (discNumberIsValid) {
         realDiscNumber = discNumberValue;
     }
 
     auto newTrackId = d->mDatabase->trackIdFromTitleAlbumTrackDiscNumber(realTitle, realArtist, realAlbum,
                                                                          realTrackNumber, realDiscNumber);
     if (newTrackId == 0) {
         auto newTrack = std::tuple<QString, QString, QString, int, int>(realTitle, realArtist, album.toString(), trackNumber.toInt(), discNumber.toInt());
         d->mTracksByNameSet.push_back(newTrack);
 
         return;
     }
 
     d->mTracksByIdSet.insert(newTrackId);
 
     auto newTrack = d->mDatabase->trackDataFromDatabaseId(newTrackId);
 
     if (!newTrack.isEmpty()) {
         Q_EMIT trackHasChanged(newTrack);
     }
 }
 
-void TracksListener::trackByFileNameInList(const QUrl &fileName)
+void TracksListener::trackByFileNameInList(ElisaUtils::PlayListEntryType type, const QUrl &fileName)
 {
+    Q_UNUSED(type)
+
     if (fileName.isLocalFile() || fileName.scheme().isEmpty()) {
         auto newTrackId = d->mDatabase->trackIdFromFileName(fileName);
         if (newTrackId == 0) {
             auto newTrack = d->mFileScanner.scanOneFile(fileName);
 
             if (newTrack.isValid()) {
                 d->mTracksByFileNameSet.push_back(fileName);
 
                 Q_EMIT trackHasChanged(newTrack);
                 return;
             }
 
             d->mTracksByFileNameSet.push_back(fileName);
 
             return;
         }
     } else {
         auto newRadioId = d->mDatabase->radioIdFromFileName(fileName);
         if (newRadioId) {
             auto newRadio = d->mDatabase->radioDataFromDatabaseId(newRadioId);
 
             if (!newRadio.isEmpty()) {
                 Q_EMIT trackHasChanged({newRadio});
             }
         }
     }
 }
 
 void TracksListener::newAlbumInList(qulonglong newDatabaseId, const QString &entryTitle)
 {
     qCDebug(orgKdeElisaPlayList()) << "TracksListener::newAlbumInList" << newDatabaseId << entryTitle << d->mDatabase->albumData(newDatabaseId);
     Q_EMIT tracksListAdded(newDatabaseId, entryTitle, ElisaUtils::Album, d->mDatabase->albumData(newDatabaseId));
 }
 
 void TracksListener::newEntryInList(qulonglong newDatabaseId,
                                     const QString &entryTitle,
                                     ElisaUtils::PlayListEntryType databaseIdType)
 {
     qCDebug(orgKdeElisaPlayList()) << "TracksListener::newEntryInList" << newDatabaseId << entryTitle << databaseIdType;
     switch (databaseIdType)
     {
     case ElisaUtils::Track:
     {
         d->mTracksByIdSet.insert(newDatabaseId);
 
         auto newTrack = d->mDatabase->trackDataFromDatabaseId(newDatabaseId);
         if (!newTrack.isEmpty()) {
             Q_EMIT trackHasChanged(newTrack);
         }
         break;
     }
     case ElisaUtils::Radio:
     {
         d->mRadiosByIdSet.insert(newDatabaseId);
 
         auto newRadio = d->mDatabase->radioDataFromDatabaseId(newDatabaseId);
         if (!newRadio.isEmpty()) {
             Q_EMIT trackHasChanged(newRadio);
         }
         break;
     }
     case ElisaUtils::Artist:
         newArtistInList(newDatabaseId, entryTitle);
         break;
     case ElisaUtils::FileName:
         newUrlInList(QUrl::fromLocalFile(entryTitle), ElisaUtils::FileName);
         break;
     case ElisaUtils::Album:
         newAlbumInList(newDatabaseId, entryTitle);
         break;
     case ElisaUtils::Lyricist:
     case ElisaUtils::Composer:
     case ElisaUtils::Genre:
     case ElisaUtils::Unknown:
         break;
     }
 }
 
 void TracksListener::newUrlInList(const QUrl &entryUrl, ElisaUtils::PlayListEntryType databaseIdType)
 {
     switch (databaseIdType)
     {
     case ElisaUtils::Track:
     case ElisaUtils::FileName:
     {
         auto newDatabaseId = d->mDatabase->trackIdFromFileName(entryUrl);
 
         if (!newDatabaseId)
         {
-            trackByFileNameInList(entryUrl);
+            trackByFileNameInList(databaseIdType, entryUrl);
             return;
         }
 
         d->mTracksByIdSet.insert(newDatabaseId);
 
         auto newTrack = d->mDatabase->trackDataFromDatabaseIdAndUrl(newDatabaseId, entryUrl);
         if (!newTrack.isEmpty()) {
             Q_EMIT trackHasChanged(newTrack);
         }
         break;
     }
     case ElisaUtils::Radio:
     {
         auto newDatabaseId = d->mDatabase->radioIdFromFileName(entryUrl);
 
         if (!newDatabaseId)
         {
             return;
         }
 
         d->mRadiosByIdSet.insert(newDatabaseId);
 
         auto newRadio = d->mDatabase->radioDataFromDatabaseId(newDatabaseId);
         if (!newRadio.isEmpty()) {
             Q_EMIT trackHasChanged(newRadio);
         }
         break;
     }
     case ElisaUtils::Artist:
     case ElisaUtils::Album:
     case ElisaUtils::Lyricist:
     case ElisaUtils::Composer:
     case ElisaUtils::Genre:
     case ElisaUtils::Unknown:
         break;
     }
 }
 
 void TracksListener::newArtistInList(qulonglong newDatabaseId, const QString &artist)
 {
     auto newTracks = d->mDatabase->tracksDataFromAuthor(artist);
     if (newTracks.isEmpty()) {
         return;
     }
 
     for (const auto &oneTrack : newTracks) {
         d->mTracksByIdSet.insert(oneTrack.databaseId());
     }
 
     Q_EMIT tracksListAdded(newDatabaseId, artist, ElisaUtils::Artist, newTracks);
 }
 
 #include "moc_trackslistener.cpp"
diff --git a/src/trackslistener.h b/src/trackslistener.h
index 3eeb6e33..7b178899 100644
--- a/src/trackslistener.h
+++ b/src/trackslistener.h
@@ -1,88 +1,88 @@
 /*
  * Copyright 2017 Matthieu Gallien <matthieu_gallien@yahoo.fr>
  *
  * This program is free software: you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 3 of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
 #ifndef TRACKSLISTENER_H
 #define TRACKSLISTENER_H
 
 #include "elisaLib_export.h"
 
 #include "databaseinterface.h"
 #include "datatypes.h"
 #include "elisautils.h"
 
 #include <QObject>
 
 #include <memory>
 
 class TracksListenerPrivate;
 
 class ELISALIB_EXPORT TracksListener : public QObject
 {
     Q_OBJECT
 
 public:
 
     using ListTrackDataType = DataTypes::ListTrackDataType;
 
     using TrackDataType = DataTypes::TrackDataType;
 
     explicit TracksListener(DatabaseInterface *database, QObject *parent = nullptr);
 
     ~TracksListener() override;
 
 Q_SIGNALS:
 
     void trackHasChanged(const TracksListener::TrackDataType &audioTrack);
 
     void trackHasBeenRemoved(qulonglong id);
 
     void tracksListAdded(qulonglong newDatabaseId,
                          const QString &entryTitle,
                          ElisaUtils::PlayListEntryType databaseIdType,
                          const TracksListener::ListTrackDataType &tracks);
 
 public Q_SLOTS:
 
     void tracksAdded(const TracksListener::ListTrackDataType &allTracks);
 
     void trackRemoved(qulonglong id);
 
     void trackModified(const TracksListener::TrackDataType &modifiedTrack);
 
     void trackByNameInList(const QVariant &title, const QVariant &artist, const QVariant &album, const QVariant &trackNumber, const QVariant &discNumber);
 
     void newEntryInList(qulonglong newDatabaseId,
                         const QString &entryTitle,
                         ElisaUtils::PlayListEntryType databaseIdType);
 
-    void trackByFileNameInList(const QUrl &fileName);
+    void trackByFileNameInList(ElisaUtils::PlayListEntryType type, const QUrl &fileName);
 
     void newUrlInList(const QUrl &entryUrl,
                       ElisaUtils::PlayListEntryType databaseIdType);
 
 private:
 
     void newArtistInList(qulonglong newDatabaseId, const QString &artist);
 
     void newAlbumInList(qulonglong newDatabaseId,
                         const QString &entryTitle);
 
     std::unique_ptr<TracksListenerPrivate> d;
 
 };
 
 #endif // TRACKSLISTENER_H