diff --git a/autotests/trackmetadatamodeltest.cpp b/autotests/trackmetadatamodeltest.cpp
--- a/autotests/trackmetadatamodeltest.cpp
+++ b/autotests/trackmetadatamodeltest.cpp
@@ -67,7 +67,7 @@
         QCOMPARE(dataChangedSpy.count(), 0);
         QCOMPARE(beginRemovedRowsSpy.count(), 0);
         QCOMPARE(endRemovedRowsSpy.count(), 0);
-        QCOMPARE(myModel.rowCount(), 1);
+        QCOMPARE(myModel.rowCount(), 2);
     }
 
     void modifyTrackInDatabase()
@@ -107,16 +107,16 @@
 
         auto trackId = musicDb.trackIdFromFileName(QUrl::fromLocalFile(QStringLiteral("/$1")));
 
-        myModel.initializeByTrackId(trackId);
+        myModel.initializeById(ElisaUtils::Track, trackId);
 
         QCOMPARE(beginResetSpy.count(), 1);
         QCOMPARE(endResetSpy.count(), 1);
         QCOMPARE(beginInsertRowsSpy.count(), 0);
         QCOMPARE(endInsertRowsSpy.count(), 0);
         QCOMPARE(dataChangedSpy.count(), 0);
         QCOMPARE(beginRemovedRowsSpy.count(), 0);
         QCOMPARE(endRemovedRowsSpy.count(), 0);
-        QCOMPARE(myModel.rowCount(), 11);
+        QCOMPARE(myModel.rowCount(), 12);
 
         musicDb.trackHasStartedPlaying(QUrl::fromLocalFile(QStringLiteral("/$2")), QDateTime::currentDateTime());
 
@@ -127,7 +127,7 @@
         QCOMPARE(dataChangedSpy.count(), 0);
         QCOMPARE(beginRemovedRowsSpy.count(), 0);
         QCOMPARE(endRemovedRowsSpy.count(), 0);
-        QCOMPARE(myModel.rowCount(), 11);
+        QCOMPARE(myModel.rowCount(), 12);
 
         musicDb.trackHasStartedPlaying(QUrl::fromLocalFile(QStringLiteral("/$1")), QDateTime::currentDateTime());
 
@@ -138,7 +138,7 @@
         QCOMPARE(dataChangedSpy.count(), 0);
         QCOMPARE(beginRemovedRowsSpy.count(), 0);
         QCOMPARE(endRemovedRowsSpy.count(), 0);
-        QCOMPARE(myModel.rowCount(), 12);
+        QCOMPARE(myModel.rowCount(), 13);
     }
 };
 
diff --git a/src/databaseinterface.cpp b/src/databaseinterface.cpp
--- a/src/databaseinterface.cpp
+++ b/src/databaseinterface.cpp
@@ -6385,7 +6385,7 @@
     }
     result[TrackDataType::key_type::PlayCounter] = trackRecord.value(28);
     result[TrackDataType::key_type::PlayFrequency] = trackRecord.value(29);
-    result[DataType::key_type::ElementTypeRole] = ElisaUtils::Track;
+    result[TrackDataType::key_type::ElementTypeRole] = ElisaUtils::Track;
 
     return result;
 }
@@ -6406,7 +6406,7 @@
         result[TrackDataType::key_type::GenreRole] = trackRecord.value(4);
     }
     result[TrackDataType::key_type::CommentRole] = trackRecord.value(5);
-    result[DataType::key_type::ElementTypeRole] = ElisaUtils::Radio;
+    result[TrackDataType::key_type::ElementTypeRole] = ElisaUtils::Radio;
 
     return result;
 }
@@ -6820,18 +6820,14 @@
         qCDebug(orgKdeElisaDatabase) << "DatabaseInterface::updateTrackInDatabase" << query.lastQuery();
         qCDebug(orgKdeElisaDatabase) << "DatabaseInterface::updateTrackInDatabase" << query.boundValues();
         qCDebug(orgKdeElisaDatabase) << "DatabaseInterface::updateTrackInDatabase" << query.lastError();
-    }else{
-        TrackDataType radio(oneTrack);
-        radio[TrackDataType::key_type::ArtistRole] = radio[TrackDataType::key_type::TitleRole];
-        if (radio[TrackDataType::key_type::DatabaseIdRole] == -1) {
-            radio[TrackDataType::key_type::DatabaseIdRole] = internalRadioIdFromHttpAddress(oneTrack.resourceURI().toString());
-            radio[TrackDataType::key_type::AlbumRole] = QStringLiteral("Radios");
-            radio[TrackDataType::key_type::ArtistRole] = radio[TrackDataType::key_type::TitleRole];
-            radio[DataType::key_type::ElementTypeRole] = ElisaUtils::Radio;
-            // Genre and rating missing for now, see buildRadioDataFromDatabaseRecord. Should be added if used for radios.
+    } else {
+        if (oneTrack[TrackDataType::key_type::DatabaseIdRole] == -1) {
+            auto radio = internalOneRadioPartialData(internalRadioIdFromHttpAddress(oneTrack.resourceURI().toString()));
 
             Q_EMIT radioAdded(radio);
         } else {
+            auto radio = internalOneRadioPartialData(oneTrack.databaseId());
+
             Q_EMIT radioModified(radio);
         }
     }
diff --git a/src/elisautils.h b/src/elisautils.h
--- a/src/elisautils.h
+++ b/src/elisautils.h
@@ -54,8 +54,8 @@
     Composer,
     Track,
     FileName,
-    Unknown,
     Radio,
+    Unknown,
 };
 
 Q_ENUM_NS(PlayListEntryType)
diff --git a/src/mediaplaylist.cpp b/src/mediaplaylist.cpp
--- a/src/mediaplaylist.cpp
+++ b/src/mediaplaylist.cpp
@@ -114,6 +114,7 @@
     roles[static_cast<int>(ColumnsRoles::TrackDataRole)] = "trackData";
     roles[static_cast<int>(ColumnsRoles::AlbumIdRole)] = "albumId";
     roles[static_cast<int>(ColumnsRoles::AlbumSectionRole)] = "albumSection";
+    roles[static_cast<int>(ColumnsRoles::ElementTypeRole)] = "entryType";
 
     return roles;
 }
diff --git a/src/modeldataloader.h b/src/modeldataloader.h
--- a/src/modeldataloader.h
+++ b/src/modeldataloader.h
@@ -122,36 +122,14 @@
 
     void loadFrequentlyPlayedData(ElisaUtils::PlayListEntryType dataType);
 
-    void updateRadioData(const ModelDataLoader::TrackDataType &trackDataType);
-
-    void deleteRadioData(qulonglong radioId);
-
-private:
+private Q_SLOTS:
 
     void databaseTracksAdded(const ListTrackDataType &newData);
 
-    void databaseTrackModified(const TrackDataType &modifiedTrack);
-
-    void databaseTrackRemoved(qulonglong removedTrackId);
-
-    void databaseGenresAdded(const ListGenreDataType &newData);
-
     void databaseArtistsAdded(const ListArtistDataType &newData);
 
-    void databaseArtistRemoved(qulonglong removedDatabaseId);
-
     void databaseAlbumsAdded(const ListAlbumDataType &newData);
 
-    void databaseAlbumRemoved(qulonglong removedDatabaseId);
-
-    void databaseAlbumModified(const AlbumDataType &modifiedAlbum);
-
-    void databaseRadioAdded(const TrackDataType radio);
-
-    void databaseRadioModified(const TrackDataType radio);
-
-    void databaseRadioRemoved(qulonglong radioId);
-
 private:
 
     std::unique_ptr<ModelDataLoaderPrivate> d;
diff --git a/src/modeldataloader.cpp b/src/modeldataloader.cpp
--- a/src/modeldataloader.cpp
+++ b/src/modeldataloader.cpp
@@ -58,33 +58,33 @@
     d->mDatabase = database;
 
     connect(database, &DatabaseInterface::genresAdded,
-            this, &ModelDataLoader::databaseGenresAdded);
+            this, &ModelDataLoader::genresAdded);
     connect(database, &DatabaseInterface::albumsAdded,
             this, &ModelDataLoader::databaseAlbumsAdded);
     connect(database, &DatabaseInterface::albumModified,
-            this, &ModelDataLoader::databaseAlbumModified);
+            this, &ModelDataLoader::albumModified);
     connect(database, &DatabaseInterface::albumRemoved,
-            this, &ModelDataLoader::databaseAlbumRemoved);
+            this, &ModelDataLoader::albumRemoved);
     connect(database, &DatabaseInterface::tracksAdded,
             this, &ModelDataLoader::databaseTracksAdded);
     connect(database, &DatabaseInterface::trackModified,
-            this, &ModelDataLoader::databaseTrackModified);
+            this, &ModelDataLoader::trackModified);
     connect(database, &DatabaseInterface::trackRemoved,
-            this, &ModelDataLoader::databaseTrackRemoved);
+            this, &ModelDataLoader::trackRemoved);
     connect(database, &DatabaseInterface::artistsAdded,
             this, &ModelDataLoader::databaseArtistsAdded);
     connect(database, &DatabaseInterface::artistRemoved,
-            this, &ModelDataLoader::databaseArtistRemoved);
+            this, &ModelDataLoader::artistRemoved);
     connect(this, &ModelDataLoader::saveRadioModified,
             database, &DatabaseInterface::insertRadio);
     connect(this, &ModelDataLoader::removeRadio,
             database, &DatabaseInterface::removeRadio);
     connect(database, &DatabaseInterface::radioAdded,
-            this, &ModelDataLoader::databaseRadioAdded);
+            this, &ModelDataLoader::radioAdded);
     connect(database, &DatabaseInterface::radioModified,
-            this, &ModelDataLoader::databaseRadioModified);
+            this, &ModelDataLoader::radioModified);
     connect(database, &DatabaseInterface::radioRemoved,
-            this, &ModelDataLoader::databaseRadioRemoved);
+            this, &ModelDataLoader::radioRemoved);
 }
 
 void ModelDataLoader::loadData(ElisaUtils::PlayListEntryType dataType)
@@ -365,21 +365,6 @@
     }
 }
 
-void ModelDataLoader::databaseTrackModified(const TrackDataType &modifiedTrack)
-{
-    Q_EMIT trackModified(modifiedTrack);
-}
-
-void ModelDataLoader::databaseTrackRemoved(qulonglong removedTrackId)
-{
-    Q_EMIT trackRemoved(removedTrackId);
-}
-
-void ModelDataLoader::databaseGenresAdded(const ListGenreDataType &newData)
-{
-    Q_EMIT genresAdded(newData);
-}
-
 void ModelDataLoader::databaseArtistsAdded(const ListArtistDataType &newData)
 {
     switch(d->mFilterType) {
@@ -407,11 +392,6 @@
     }
 }
 
-void ModelDataLoader::databaseArtistRemoved(qulonglong removedDatabaseId)
-{
-    Q_EMIT artistRemoved(removedDatabaseId);
-}
-
 void ModelDataLoader::databaseAlbumsAdded(const ListAlbumDataType &newData)
 {
     switch(d->mFilterType) {
@@ -452,39 +432,4 @@
     }
 }
 
-void ModelDataLoader::databaseAlbumRemoved(qulonglong removedDatabaseId)
-{
-    Q_EMIT albumRemoved(removedDatabaseId);
-}
-
-void ModelDataLoader::databaseAlbumModified(const AlbumDataType &modifiedAlbum)
-{
-    Q_EMIT albumModified(modifiedAlbum);
-}
-
-void ModelDataLoader::updateRadioData(const TrackDataType &trackDataType)
-{
-    Q_EMIT saveRadioModified(trackDataType);
-}
-
-void ModelDataLoader::deleteRadioData(qulonglong radioId)
-{
-    Q_EMIT removeRadio(radioId);
-}
-
-void ModelDataLoader::databaseRadioAdded(TrackDataType radio)
-{
-    Q_EMIT radioAdded(radio);
-}
-
-void ModelDataLoader::databaseRadioModified(TrackDataType radio)
-{
-    Q_EMIT radioModified(radio);
-}
-
-void ModelDataLoader::databaseRadioRemoved(qulonglong radioId)
-{
-    Q_EMIT radioRemoved(radioId);
-}
-
 #include "moc_modeldataloader.cpp"
diff --git a/src/models/trackmetadatamodel.h b/src/models/trackmetadatamodel.h
--- a/src/models/trackmetadatamodel.h
+++ b/src/models/trackmetadatamodel.h
@@ -44,6 +44,10 @@
                READ fileUrl
                NOTIFY fileUrlChanged)
 
+    Q_PROPERTY(qulonglong databaseId
+               READ databaseId
+               NOTIFY databaseIdChanged)
+
     Q_PROPERTY(MusicListenersManager* manager
                READ manager
                WRITE setManager
@@ -53,11 +57,6 @@
                READ lyrics
                NOTIFY lyricsChanged)
 
-    Q_PROPERTY(bool isRadio
-               READ isRadio
-               WRITE setIsRadio
-               NOTIFY isRadioChanged)
-
 public:
 
     enum ColumnRoles
@@ -100,7 +99,7 @@
 
     QString lyrics() const;
 
-    bool isRadio();
+    qulonglong databaseId() const;
 
 Q_SIGNALS:
 
@@ -120,45 +119,32 @@
 
     void deleteRadioData(qulonglong radioId);
 
-    void disableApplyButton();
-
-    void hideDeleteButton();
-
-    void showDeleteButton();
-
-    void closeWindow();
-
-    void isRadioChanged();
+    void databaseIdChanged();
 
 public Q_SLOTS:
 
     void trackData(const TrackMetadataModel::TrackDataType &trackData);
 
-    void initializeByTrackId(qulonglong databaseId);
+    void initializeById(ElisaUtils::PlayListEntryType type, qulonglong databaseId);
 
     void initializeByTrackFileName(const QString &fileName);
 
     void initializeForNewRadio();
 
     void setManager(MusicListenersManager *newManager);
 
-    void setIsRadio(bool isRadio);
-
     void setDatabase(DatabaseInterface *trackDatabase);
 
     void saveData();
 
     void deleteRadio();
 
-    void radioAdded(const TrackMetadataModel::TrackDataType &radiosData);
-
-    void radioModified();
-
-    void radioRemoved();
+    void radioData(const TrackMetadataModel::TrackDataType &radiosData);
 
 protected:
 
-    void fillDataFromTrackData(const TrackMetadataModel::TrackDataType &trackData);
+    void fillDataFromTrackData(const TrackMetadataModel::TrackDataType &trackData,
+                               const QList<DatabaseInterface::ColumnsRoles> &fieldsForTrack);
 
     void fillDataForNewRadio();
 
@@ -181,26 +167,22 @@
 
     void fetchLyrics();
 
-    QVariant dataGeneral(const QModelIndex &index, int role) const;
-
-    QVariant dataRadio(const QModelIndex &index, int role) const;
-
     TrackDataType mFullData;
 
     TrackDataType mTrackData;
 
     QUrl mCoverImage;
 
     QString mFileUrl;
 
+    qulonglong mDatabaseId = 0;
+
     QList<TrackDataType::key_type> mTrackKeys;
 
     ModelDataLoader mDataLoader;
 
     MusicListenersManager *mManager = nullptr;
 
-    bool mIsRadio = false;
-
     FileScanner mFileScanner;
 
     QMimeDatabase mMimeDatabase;
diff --git a/src/models/trackmetadatamodel.cpp b/src/models/trackmetadatamodel.cpp
--- a/src/models/trackmetadatamodel.cpp
+++ b/src/models/trackmetadatamodel.cpp
@@ -23,7 +23,6 @@
 
 #include <QtConcurrent>
 
-
 TrackMetadataModel::TrackMetadataModel(QObject *parent)
     : QAbstractListModel(parent)
 {
@@ -47,7 +46,7 @@
     return mTrackData.count();
 }
 
-QVariant TrackMetadataModel::dataGeneral(const QModelIndex &index, int role) const
+QVariant TrackMetadataModel::data(const QModelIndex &index, int role) const
 {
     auto result = QVariant{};
 
@@ -272,135 +271,6 @@
     return result;
 }
 
-QVariant TrackMetadataModel::dataRadio(const QModelIndex &index, int role) const
-{
-    auto result = QVariant{};
-
-    const auto currentKey = mTrackKeys[index.row()];
-
-    switch (role)
-    {
-    case Qt::DisplayRole:
-        result = mTrackData[currentKey];
-        break;
-    case ItemNameRole:
-        switch (currentKey)
-        {
-        case DatabaseInterface::TitleRole:
-            result = i18nc("Track title for track metadata view", "Title");
-            break;
-        case DatabaseInterface::CommentRole:
-            result = i18nc("Comment label for track metadata view", "Comment");
-            break;
-        case DatabaseInterface::ResourceRole:
-            result = i18nc("Radio HTTP address for radio metadata view", "Stream Http Address");
-            break;
-        case DatabaseInterface::ChannelsRole:
-        case DatabaseInterface::BitRateRole:
-        case DatabaseInterface::SampleRateRole:
-        case DatabaseInterface::LastPlayDate:
-        case DatabaseInterface::PlayCounter:
-        case DatabaseInterface::LyricsRole:
-        case DatabaseInterface::YearRole:
-        case DatabaseInterface::ComposerRole:
-        case DatabaseInterface::ArtistRole:
-        case DatabaseInterface::AlbumRole:
-        case DatabaseInterface::AlbumArtistRole:
-        case DatabaseInterface::TrackNumberRole:
-        case DatabaseInterface::DiscNumberRole:
-        case DatabaseInterface::RatingRole:
-        case DatabaseInterface::GenreRole:
-        case DatabaseInterface::LyricistRole:
-        case DatabaseInterface::DurationRole:
-        case DatabaseInterface::SecondaryTextRole:
-        case DatabaseInterface::ImageUrlRole:
-        case DatabaseInterface::ShadowForImageRole:
-        case DatabaseInterface::ChildModelRole:
-        case DatabaseInterface::StringDurationRole:
-        case DatabaseInterface::MilliSecondsDurationRole:
-        case DatabaseInterface::AllArtistsRole:
-        case DatabaseInterface::HighestTrackRating:
-        case DatabaseInterface::IdRole:
-        case DatabaseInterface::DatabaseIdRole:
-        case DatabaseInterface::IsSingleDiscAlbumRole:
-        case DatabaseInterface::ContainerDataRole:
-        case DatabaseInterface::IsPartialDataRole:
-        case DatabaseInterface::AlbumIdRole:
-        case DatabaseInterface::HasEmbeddedCover:
-        case DatabaseInterface::FileModificationTime:
-        case DatabaseInterface::FirstPlayDate:
-        case DatabaseInterface::PlayFrequency:
-        case DatabaseInterface::ElementTypeRole:
-        case DatabaseInterface::IsValidAlbumArtistRole:
-            break;
-        }
-        break;
-    case ItemTypeRole:
-        switch (currentKey)
-        {
-        case DatabaseInterface::TitleRole:
-            result = TextEntry;
-            break;
-        case DatabaseInterface::ResourceRole:
-            result = TextEntry;
-            break;
-        case DatabaseInterface::CommentRole:
-            result = TextEntry;
-            break;
-        case DatabaseInterface::ArtistRole:
-        case DatabaseInterface::AlbumRole:
-        case DatabaseInterface::AlbumArtistRole:
-        case DatabaseInterface::TrackNumberRole:
-        case DatabaseInterface::DiscNumberRole:
-        case DatabaseInterface::RatingRole:
-        case DatabaseInterface::GenreRole:
-        case DatabaseInterface::LyricistRole:
-        case DatabaseInterface::ComposerRole:
-        case DatabaseInterface::YearRole:
-        case DatabaseInterface::LastPlayDate:
-        case DatabaseInterface::PlayCounter:
-        case DatabaseInterface::LyricsRole:
-        case DatabaseInterface::DurationRole:
-        case DatabaseInterface::SampleRateRole:
-        case DatabaseInterface::BitRateRole:
-        case DatabaseInterface::ChannelsRole:
-        case DatabaseInterface::SecondaryTextRole:
-        case DatabaseInterface::ImageUrlRole:
-        case DatabaseInterface::ShadowForImageRole:
-        case DatabaseInterface::ChildModelRole:
-        case DatabaseInterface::StringDurationRole:
-        case DatabaseInterface::MilliSecondsDurationRole:
-        case DatabaseInterface::AllArtistsRole:
-        case DatabaseInterface::HighestTrackRating:
-        case DatabaseInterface::IdRole:
-        case DatabaseInterface::DatabaseIdRole:
-        case DatabaseInterface::IsSingleDiscAlbumRole:
-        case DatabaseInterface::ContainerDataRole:
-        case DatabaseInterface::IsPartialDataRole:
-        case DatabaseInterface::AlbumIdRole:
-        case DatabaseInterface::HasEmbeddedCover:
-        case DatabaseInterface::FileModificationTime:
-        case DatabaseInterface::FirstPlayDate:
-        case DatabaseInterface::PlayFrequency:
-        case DatabaseInterface::ElementTypeRole:
-        case DatabaseInterface::IsValidAlbumArtistRole:
-            break;
-        }
-        break;
-    }
-
-    return result;
-}
-
-QVariant TrackMetadataModel::data(const QModelIndex &index, int role) const
-{
-    if (this->mIsRadio) {
-        return dataRadio(index, role);
-    } else {
-        return dataGeneral(index, role);
-    }
-}
-
 bool TrackMetadataModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
     if (data(index, role) != value) {
@@ -446,32 +316,38 @@
     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;
     }
 
-    fillDataFromTrackData(trackData);
+    const QList<DatabaseInterface::ColumnsRoles> fieldsForTrack({DatabaseInterface::TitleRole, DatabaseInterface::ArtistRole,
+                                                                 DatabaseInterface::AlbumRole, DatabaseInterface::AlbumArtistRole,
+                                                                 DatabaseInterface::TrackNumberRole, DatabaseInterface::DiscNumberRole,
+                                                                 DatabaseInterface::RatingRole, DatabaseInterface::GenreRole,
+                                                                 DatabaseInterface::LyricistRole, DatabaseInterface::ComposerRole,
+                                                                 DatabaseInterface::CommentRole, DatabaseInterface::YearRole,
+                                                                 DatabaseInterface::LastPlayDate, DatabaseInterface::PlayCounter,
+                                                                 DatabaseInterface::DatabaseIdRole});
+
+    fillDataFromTrackData(trackData, fieldsForTrack);
 }
 
-void TrackMetadataModel::fillDataFromTrackData(const TrackMetadataModel::TrackDataType &trackData)
+void TrackMetadataModel::fillDataFromTrackData(const TrackMetadataModel::TrackDataType &trackData,
+                                               const QList<DatabaseInterface::ColumnsRoles> &fieldsForTrack)
 {
-    const QList<DatabaseInterface::ColumnsRoles> mFieldsForClassicTrack({DatabaseInterface::TitleRole, DatabaseInterface::ArtistRole, DatabaseInterface::AlbumRole,
-                                                                      DatabaseInterface::AlbumArtistRole, DatabaseInterface::TrackNumberRole, DatabaseInterface::DiscNumberRole,
-                                                                      DatabaseInterface::RatingRole, DatabaseInterface::GenreRole, DatabaseInterface::LyricistRole,
-                                                                      DatabaseInterface::ComposerRole, DatabaseInterface::CommentRole, DatabaseInterface::YearRole,
-                                                                      DatabaseInterface::LastPlayDate, DatabaseInterface::PlayCounter});
-
-    const QList mFieldsForRadioTrack({DatabaseInterface::TitleRole,DatabaseInterface::ResourceRole, DatabaseInterface::CommentRole, DatabaseInterface::DatabaseIdRole,
-                                            DatabaseInterface::ArtistRole, DatabaseInterface::AlbumRole});
-
     beginResetModel();
     mFullData = trackData;
     mTrackData.clear();
     mTrackKeys.clear();
 
-    for (DatabaseInterface::ColumnsRoles role : (isRadio() ? mFieldsForRadioTrack : mFieldsForClassicTrack)){
+    for (DatabaseInterface::ColumnsRoles role : fieldsForTrack) {
         if (trackData.constFind(role) != trackData.constEnd()) {
             if (role == DatabaseInterface::RatingRole) {
                 if (trackData[role].toInt() == 0) {
@@ -488,6 +364,9 @@
 
     fetchLyrics();
 
+    mDatabaseId = trackData[DatabaseInterface::DatabaseIdRole].toULongLong();
+    Q_EMIT databaseIdChanged();
+
     mCoverImage = trackData[DatabaseInterface::ImageUrlRole].toUrl();
     Q_EMIT coverUrlChanged();
 
@@ -540,6 +419,18 @@
     }
 }
 
+void TrackMetadataModel::initializeById(ElisaUtils::PlayListEntryType type, qulonglong databaseId)
+{
+    mFullData.clear();
+    mTrackData.clear();
+    mCoverImage.clear();
+    mFileUrl.clear();
+
+    Q_EMIT lyricsChanged();
+
+    Q_EMIT needDataByDatabaseId(type, databaseId);
+}
+
 void TrackMetadataModel::initialize(MusicListenersManager *newManager, DatabaseInterface *trackDatabase)
 {
     mManager = newManager;
@@ -559,26 +450,20 @@
             &mDataLoader, &ModelDataLoader::loadDataByDatabaseId);
     connect(this, &TrackMetadataModel::needDataByFileName,
             &mDataLoader, &ModelDataLoader::loadDataByFileName);
-
-    if (isRadio()) {
-        connect(this, &TrackMetadataModel::saveRadioData,
-                &mDataLoader, &ModelDataLoader::updateRadioData);
-        connect(this, &TrackMetadataModel::deleteRadioData,
-                &mDataLoader, &ModelDataLoader::deleteRadioData);
-        connect(&mDataLoader, &ModelDataLoader::radioAdded,
-                this, &TrackMetadataModel::radioAdded);
-        connect(&mDataLoader, &ModelDataLoader::radioModified,
-                this, &TrackMetadataModel::radioModified);
-        connect(&mDataLoader, &ModelDataLoader::radioRemoved,
-                this, &TrackMetadataModel::radioRemoved);
-        connect(&mDataLoader, &ModelDataLoader::allRadioData,
-                this, &TrackMetadataModel::trackData);
-    } else {
-        connect(&mDataLoader, &ModelDataLoader::trackModified,
-                this, &TrackMetadataModel::trackData);
-        connect(&mDataLoader, &ModelDataLoader::allTrackData,
-                this, &TrackMetadataModel::trackData);
-    }
+    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);
 }
 
 void TrackMetadataModel::fetchLyrics()
@@ -594,18 +479,6 @@
     mLyricsValueWatcher.setFuture(lyricicsValue);
 }
 
-void TrackMetadataModel::initializeByTrackId(qulonglong databaseId)
-{
-    mFullData.clear();
-    mTrackData.clear();
-    mCoverImage.clear();
-    mFileUrl.clear();
-
-    Q_EMIT lyricsChanged();
-
-    Q_EMIT needDataByDatabaseId((isRadio() ? ElisaUtils::Radio : ElisaUtils::Track), databaseId);
-}
-
 void TrackMetadataModel::initializeForNewRadio()
 {
     mFullData.clear();
@@ -626,11 +499,10 @@
          DatabaseInterface::CommentRole,
          DatabaseInterface::DatabaseIdRole
 
-    }) {
+}) {
         mTrackKeys.push_back(role);
         if (role == DatabaseInterface::DatabaseIdRole) {
             mTrackData[role] = -1;
-            Q_EMIT hideDeleteButton();
         } else {
             mTrackData[role] = QString();
         }
@@ -657,21 +529,11 @@
     initialize(newManager, nullptr);
 }
 
-void TrackMetadataModel::setIsRadio(bool isRadio){
-    this->mIsRadio = isRadio;
-
-    Q_EMIT isRadioChanged();
-}
-
 void TrackMetadataModel::setDatabase(DatabaseInterface *trackDatabase)
 {
     initialize(nullptr, trackDatabase);
 }
 
-bool TrackMetadataModel::isRadio(){
-    return this->mIsRadio;
-}
-
 void TrackMetadataModel::saveData()
 {
     Q_EMIT saveRadioData(mTrackData);
@@ -684,18 +546,17 @@
     }
 }
 
-void TrackMetadataModel::radioAdded(const TrackDataType &radiosData){
-    mTrackData[DatabaseInterface::DatabaseIdRole] = radiosData[DatabaseInterface::DatabaseIdRole];
-    Q_EMIT showDeleteButton();
-    radioModified();
-}
+void TrackMetadataModel::radioData(const TrackDataType &radiosData)
+{
+    if (!mFullData.isEmpty() && mFullData[DatabaseInterface::DatabaseIdRole].toInt() != -1 &&
+            mFullData.databaseId() != radiosData.databaseId()) {
+        return;
+    }
 
-void TrackMetadataModel::radioModified(){
-    Q_EMIT disableApplyButton();
-}
+    const QList<DatabaseInterface::ColumnsRoles> fieldsForTrack({DatabaseInterface::TitleRole, DatabaseInterface::ResourceRole,
+                                                                 DatabaseInterface::CommentRole, DatabaseInterface::DatabaseIdRole});
 
-void TrackMetadataModel::radioRemoved(){
-    Q_EMIT closeWindow();
+    fillDataFromTrackData(radiosData, fieldsForTrack);
 }
 
 #include "moc_trackmetadatamodel.cpp"
diff --git a/src/musiclistenersmanager.h b/src/musiclistenersmanager.h
--- a/src/musiclistenersmanager.h
+++ b/src/musiclistenersmanager.h
@@ -140,6 +140,8 @@
 
     void playBackError(const QUrl &sourceInError, QMediaPlayer::Error playerError);
 
+    void deleteElementById(ElisaUtils::PlayListEntryType entryType, qulonglong databaseId);
+
     void connectModel(ModelDataLoader *dataLoader);
 
     void resetMusicData();
diff --git a/src/musiclistenersmanager.cpp b/src/musiclistenersmanager.cpp
--- a/src/musiclistenersmanager.cpp
+++ b/src/musiclistenersmanager.cpp
@@ -277,6 +277,26 @@
     }
 }
 
+void MusicListenersManager::deleteElementById(ElisaUtils::PlayListEntryType entryType, qulonglong databaseId)
+{
+    switch(entryType)
+    {
+    case ElisaUtils::Radio:
+        QMetaObject::invokeMethod(&d->mDatabaseInterface, "removeRadio", Qt::QueuedConnection,
+                                  Q_ARG(qulonglong, databaseId));
+        break;
+    case ElisaUtils::Album:
+    case ElisaUtils::Artist:
+    case ElisaUtils::Genre:
+    case ElisaUtils::Lyricist:
+    case ElisaUtils::Composer:
+    case ElisaUtils::Track:
+    case ElisaUtils::FileName:
+    case ElisaUtils::Unknown:
+        break;
+    }
+}
+
 void MusicListenersManager::connectModel(ModelDataLoader *dataLoader)
 {
     dataLoader->moveToThread(&d->mDatabaseThread);
diff --git a/src/qml/DataListView.qml b/src/qml/DataListView.qml
--- a/src/qml/DataListView.qml
+++ b/src/qml/DataListView.qml
@@ -39,7 +39,29 @@
     property alias radioCase: listView.showCreateRadioButton
 
     function openMetaDataView(databaseId){
-        metadataLoader.setSource("MediaTrackMetadataView.qml", {"databaseId": databaseId, "isRadio": viewHeader.radioCase});
+        if (viewHeader.radioCase) {
+            metadataLoader.setSource("MediaTrackMetadataView.qml",
+                                     {
+                                         "initialDatabaseId": databaseId,
+                                         "modelType": modelType,
+                                         "showImage": false,
+                                         "showTrackFileName": false,
+                                         "showDeleteButton": databaseId !== -1,
+                                         "showApplyButton": true,
+                                         "editableMetadata": true,
+                                     });
+        } else {
+            metadataLoader.setSource("MediaTrackMetadataView.qml",
+                                     {
+                                         "initialDatabaseId": databaseId,
+                                         "modelType": modelType,
+                                         "showImage": true,
+                                         "showTrackFileName": true,
+                                         "showDeleteButton": false,
+                                         "showApplyButton": false,
+                                         "editableMetadata": false,
+                                     });
+        }
         metadataLoader.active = true
     }
 
diff --git a/src/qml/GridBrowserDelegate.qml b/src/qml/GridBrowserDelegate.qml
--- a/src/qml/GridBrowserDelegate.qml
+++ b/src/qml/GridBrowserDelegate.qml
@@ -52,6 +52,13 @@
 
         sourceComponent:  MediaTrackMetadataView {
             fileName: gridEntry.fileUrl ? gridEntry.fileUrl : ''
+            showImage: true
+            modelType: modelType
+            showTrackFileName: true
+            showDeleteButton: false
+            showApplyButton: false
+            editableMetadata: false
+
             onRejected: metadataLoader.active = false;
         }
     }
diff --git a/src/qml/MediaTrackMetadataView.qml b/src/qml/MediaTrackMetadataView.qml
--- a/src/qml/MediaTrackMetadataView.qml
+++ b/src/qml/MediaTrackMetadataView.qml
@@ -27,22 +27,21 @@
 Window {
     id: trackMetadata
 
-    property int databaseId: 0
+    property int initialDatabaseId: 0
+    property var modelType
     property string fileName
-    property alias isRadio: realModel.isRadio
+    property bool editableMetadata
+    property alias showImage: metadataImage.visible
+    property alias showTrackFileName: fileNameRow.visible
+    property alias showDeleteButton: deleteButtonBox.visible
+    property alias showApplyButton: applyButton.visible
 
     signal rejected()
 
     LayoutMirroring.enabled: Qt.application.layoutDirection == Qt.RightToLeft
     LayoutMirroring.childrenInherit: true
 
-    title: {
-        if (trackMetadata.isRadio && databaseId === -1) {
-            return i18nc("Window title for track metadata", "Create a Radio")
-        }
-
-        return i18nc("Window title for track metadata", "View Details")
-    }
+    title: (initialDatabaseId === -1) ? i18nc("Window title for track metadata", "Create a Radio") : i18nc("Window title for track metadata", "View Details")
 
     TrackMetadataModel {
         id: realModel
@@ -73,6 +72,8 @@
             spacing: 0
 
             Image {
+                id: metadataImage
+
                 source: realModel.coverUrl
 
                 sourceSize.width: elisaTheme.coverImageSize
@@ -87,8 +88,6 @@
                 Layout.minimumWidth: elisaTheme.coverImageSize
                 Layout.maximumHeight: elisaTheme.coverImageSize
                 Layout.maximumWidth: elisaTheme.coverImageSize
-
-                visible: !trackMetadata.isRadio
             }
 
             ListView {
@@ -130,11 +129,13 @@
                     }
                 }
 
-                delegate: trackMetadata.isRadio ? editableMetaDataDelegate: metaDataDelegate
+                delegate: editableMetadata ? editableMetaDataDelegate: metaDataDelegate
             }
         }
 
         RowLayout {
+            id: fileNameRow
+
             Layout.alignment: Qt.AlignLeft | Qt.AlignBottom
             Layout.topMargin: elisaTheme.layoutVerticalMargin
             Layout.bottomMargin: elisaTheme.layoutVerticalMargin
@@ -160,22 +161,26 @@
 
                 elide: Text.ElideRight
             }
-
-            visible: !trackMetadata.isRadio
         }
 
-        RowLayout{
+        RowLayout {
             spacing: elisaTheme.layoutVerticalMargin
 
             DialogButtonBox {
+                id: deleteButtonBox
+
                 Layout.minimumHeight: implicitHeight
                 alignment: Qt.AlignLeft
 
                 Button {
                     id: deleteButton
                     text: qsTr("Delete")
                     DialogButtonBox.buttonRole: DialogButtonBox.DestructiveRole
-                    onClicked: realModel.deleteRadio()
+                    onClicked:
+                    {
+                        elisa.musicManager.deleteElementById(modelType, realModel.databaseId)
+                        trackMetadata.close()
+                    }
                 }
             }
 
@@ -191,62 +196,45 @@
 
                     text: qsTr("Apply")
                     DialogButtonBox.buttonRole: DialogButtonBox.ApplyRole
-                    onClicked: realModel.saveData()
+                    onClicked:
+                    {
+                        realModel.saveData()
+                        enabled = false
+                        if (!deleteButtonBox.visible && editableMetadata) {
+                            deleteButtonBox.visible = true
+                        }
+                    }
                     enabled: false
                 }
                 Button {
                     text: qsTr("Close")
                     DialogButtonBox.buttonRole: DialogButtonBox.DestructiveRole
                     onClicked: trackMetadata.close()
                 }
             }
-
-            visible: trackMetadata.isRadio
-        }
-
-        DialogButtonBox {
-            id: buttonsTrack
-
-            Layout.fillWidth: true
-            Layout.minimumHeight: implicitHeight
-
-            standardButtons: DialogButtonBox.Close
-            alignment: Qt.AlignRight
-            onRejected: trackMetadata.close()
-
-            visible: !trackMetadata.isRadio
         }
     }
 
     Connections {
         target: elisa
 
         onMusicManagerChanged: {
-            if (databaseId === -1) {
+            if (initialDatabaseId === -1) {
                 realModel.initializeForNewRadio()
-            } else if (databaseId !== 0) {
-                realModel.initializeByTrackId(databaseId)
+            } else if (initialDatabaseId !== 0) {
+                realModel.initializeById(modelType, initialDatabaseId)
             } else {
                 realModel.initializeByTrackFileName(fileName)
             }
         }
     }
 
-    Connections{
-        target: realModel
-
-        onDisableApplyButton: applyButton.enabled = false
-        onShowDeleteButton: deleteButton.visible = true
-        onHideDeleteButton: deleteButton.visible = false
-        onCloseWindow: trackMetadata.close()
-    }
-
     Component.onCompleted: {
         if (elisa.musicManager) {
-            if (databaseId === -1) {
+            if (initialDatabaseId === -1) {
                 realModel.initializeForNewRadio()
-            } else if (databaseId !== 0) {
-                realModel.initializeByTrackId(databaseId)
+            } else if (initialDatabaseId !== 0) {
+                realModel.initializeById(modelType, initialDatabaseId)
             } else {
                 realModel.initializeByTrackFileName(fileName)
             }
diff --git a/src/qml/PlayListBasicView.qml b/src/qml/PlayListBasicView.qml
--- a/src/qml/PlayListBasicView.qml
+++ b/src/qml/PlayListBasicView.qml
@@ -119,6 +119,7 @@
                 containsMouse: item.containsMouse
 
                 databaseId: model.databaseId ? model.databaseId : 0
+                entryType: model.entryType ? model.entryType : ElisaUtils.Unknown
                 title: model.title ? model.title : ''
                 artist: model.artist ? model.artist : ''
                 album: model.album ? model.album : ''
diff --git a/src/qml/PlayListEntry.qml b/src/qml/PlayListEntry.qml
--- a/src/qml/PlayListEntry.qml
+++ b/src/qml/PlayListEntry.qml
@@ -33,6 +33,7 @@
     property bool isAlternateColor
     property bool containsMouse
     property int databaseId: 0
+    property var entryType
     property string title
     property string artist
     property string album
@@ -109,9 +110,16 @@
         onLoaded: item.show()
 
         sourceComponent:  MediaTrackMetadataView {
-            databaseId: playListEntry.databaseId
+            initialDatabaseId: playListEntry.databaseId
             fileName: playListEntry.fileName
-            onRejected: metadataLoader.active = false;
+            showImage: entryType == ElisaUtils.Track
+            modelType: entryType
+            showTrackFileName: entryType == ElisaUtils.Track
+            showDeleteButton: entryType != ElisaUtils.Track
+            showApplyButton: entryType != ElisaUtils.Track
+            editableMetadata: entryType != ElisaUtils.Track
+
+            onRejected: metadataLoader.active = false
         }
     }
 
diff --git a/src/qml/SimplePlayListView.qml b/src/qml/SimplePlayListView.qml
--- a/src/qml/SimplePlayListView.qml
+++ b/src/qml/SimplePlayListView.qml
@@ -108,6 +108,7 @@
                 simpleMode: true
 
                 databaseId: model.databaseId ? model.databaseId : 0
+                entryType: model.entryType ? model.entryType : ElisaUtils.Unknown
                 title: model.title ? model.title : ''
                 artist: model.artist ? model.artist : ''
                 album: model.album ? model.album : ''