diff --git a/autotests/trackmetadatamodeltest.cpp b/autotests/trackmetadatamodeltest.cpp
--- a/autotests/trackmetadatamodeltest.cpp
+++ b/autotests/trackmetadatamodeltest.cpp
@@ -107,7 +107,7 @@
 
         auto trackId = musicDb.trackIdFromFileName(QUrl::fromLocalFile(QStringLiteral("/$1")));
 
-        myModel.initializeByTrackId(trackId);
+        myModel.initializeById(ElisaUtils::Track, trackId);
 
         QCOMPARE(beginResetSpy.count(), 1);
         QCOMPARE(endResetSpy.count(), 1);
diff --git a/src/databaseinterface.cpp b/src/databaseinterface.cpp
--- a/src/databaseinterface.cpp
+++ b/src/databaseinterface.cpp
@@ -6383,7 +6383,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;
 }
@@ -6404,7 +6404,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;
 }
@@ -6825,7 +6825,7 @@
             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;
+            radio[TrackDataType::key_type::ElementTypeRole] = ElisaUtils::Radio;
             // Genre and rating missing for now, see buildRadioDataFromDatabaseRecord. Should be added if used for radios.
 
             Q_EMIT radioAdded(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
@@ -113,6 +113,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/models/trackmetadatamodel.h b/src/models/trackmetadatamodel.h
--- a/src/models/trackmetadatamodel.h
+++ b/src/models/trackmetadatamodel.h
@@ -53,10 +53,6 @@
                READ lyrics
                NOTIFY lyricsChanged)
 
-    Q_PROPERTY(bool isRadio
-               READ isRadio
-               WRITE setIsRadio)
-
 public:
 
     enum ColumnRoles
@@ -99,8 +95,6 @@
 
     QString lyrics() const;
 
-    bool isRadio();
-
 Q_SIGNALS:
 
     void needDataByDatabaseId(ElisaUtils::PlayListEntryType dataType, qulonglong databaseId);
@@ -119,43 +113,30 @@
 
     void deleteRadioData(qulonglong radioId);
 
-    void disableApplyButton();
-
-    void hideDeleteButton();
-
-    void showDeleteButton();
-
-    void closeWindow();
-
 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(TrackMetadataModel::TrackDataType radiosData);
-
-    void radioModified();
-
-    void radioRemoved();
+    void radioData(TrackMetadataModel::TrackDataType radiosData);
 
 protected:
 
-    void fillDataFromTrackData(const TrackMetadataModel::TrackDataType &trackData);
+    void fillDataFromTrackData(const TrackMetadataModel::TrackDataType &trackData,
+                               const QList<DatabaseInterface::ColumnsRoles> &fieldsForTrack);
 
     void fillDataForNewRadio();
 
@@ -178,10 +159,6 @@
 
     void fetchLyrics();
 
-    QVariant dataGeneral(const QModelIndex &index, int role) const;
-
-    QVariant dataRadio(const QModelIndex &index, int role) const;
-
     TrackDataType mFullData;
 
     TrackDataType mTrackData;
@@ -196,8 +173,6 @@
 
     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,16 +23,6 @@
 
 #include <QtConcurrent>
 
-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});
-
-
 TrackMetadataModel::TrackMetadataModel(QObject *parent)
     : QAbstractListModel(parent)
 {
@@ -56,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{};
 
@@ -281,133 +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:
-            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:
-            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) {
@@ -459,17 +322,24 @@
         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});
+
+    fillDataFromTrackData(trackData, fieldsForTrack);
 }
 
-void TrackMetadataModel::fillDataFromTrackData(const TrackMetadataModel::TrackDataType &trackData)
+void TrackMetadataModel::fillDataFromTrackData(const TrackMetadataModel::TrackDataType &trackData,
+                                               const QList<DatabaseInterface::ColumnsRoles> &fieldsForTrack)
 {
     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) {
@@ -538,6 +408,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;
@@ -557,26 +439,16 @@
             &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::updateRadioData);
+    connect(this, &TrackMetadataModel::deleteRadioData,
+            &mDataLoader, &ModelDataLoader::deleteRadioData);
+    connect(&mDataLoader, &ModelDataLoader::trackModified,
+            this, &TrackMetadataModel::trackData);
+    connect(&mDataLoader, &ModelDataLoader::allTrackData,
+            this, &TrackMetadataModel::trackData);
+    connect(&mDataLoader, &ModelDataLoader::allRadioData,
+            this, &TrackMetadataModel::radioData);
 }
 
 void TrackMetadataModel::fetchLyrics()
@@ -592,18 +464,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();
@@ -624,11 +484,10 @@
          DatabaseInterface::CommentRole,
          DatabaseInterface::DatabaseIdRole
 
-    }) {
+}) {
         mTrackKeys.push_back(role);
         if (role == DatabaseInterface::DatabaseIdRole) {
             mTrackData[role] = -1;
-            Q_EMIT hideDeleteButton();
         } else {
             mTrackData[role] = QStringLiteral("");
         }
@@ -655,19 +514,11 @@
     initialize(newManager, nullptr);
 }
 
-void TrackMetadataModel::setIsRadio(bool isRadio){
-    this->mIsRadio = isRadio;
-}
-
 void TrackMetadataModel::setDatabase(DatabaseInterface *trackDatabase)
 {
     initialize(nullptr, trackDatabase);
 }
 
-bool TrackMetadataModel::isRadio(){
-    return this->mIsRadio;
-}
-
 void TrackMetadataModel::saveData()
 {
     Q_EMIT saveRadioData(mTrackData);
@@ -680,18 +531,15 @@
     }
 }
 
-void TrackMetadataModel::radioAdded(TrackDataType radiosData){
-    mTrackData[DatabaseInterface::DatabaseIdRole] = radiosData[DatabaseInterface::DatabaseIdRole];
-    Q_EMIT showDeleteButton();
-    radioModified();
-}
+void TrackMetadataModel::radioData(TrackDataType radiosData){
+    if (!mFullData.isEmpty() && radiosData.databaseId() != mFullData.databaseId()) {
+        return;
+    }
 
-void TrackMetadataModel::radioModified(){
-    Q_EMIT disableApplyButton();
-}
+    const QList<DatabaseInterface::ColumnsRoles> fieldsForTrack({DatabaseInterface::TitleRole, DatabaseInterface::ResourceRole,
+                                                                 DatabaseInterface::CommentRole,});
 
-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,27 @@
     property alias radioCase: listView.showCreateRadioButton
 
     function openMetaDataView(databaseId){
-        metadataLoader.setSource("MediaTrackMetadataView.qml", {"databaseId": databaseId, "isRadio": viewHeader.radioCase});
+        if (viewHeader.radioCase) {
+            metadataLoader.setSource("MediaTrackMetadataView.qml",
+                                     {
+                                         "databaseId": databaseId,
+                                         "modelType": modelType,
+                                         "showImage": false,
+                                         "showTrackFileName": false,
+                                         "showDeleteButton": true,
+                                         "showApplyButton": true,
+                                     });
+        } else {
+            metadataLoader.setSource("MediaTrackMetadataView.qml",
+                                     {
+                                         "databaseId": databaseId,
+                                         "modelType": modelType,
+                                         "showImage": true,
+                                         "showTrackFileName": true,
+                                         "showDeleteButton": false,
+                                         "showApplyButton": 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,12 @@
 
         sourceComponent:  MediaTrackMetadataView {
             fileName: gridEntry.fileUrl ? gridEntry.fileUrl : ''
+            showImage: true
+            modelType: modelType
+            showTrackFileName: true
+            showDeleteButton: false
+            showApplyButton: 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
@@ -28,21 +28,20 @@
     id: trackMetadata
 
     property int databaseId: 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: (databaseId === -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: (modelType == ElisaUtils.Radio) ? 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, databaseId)
+                        trackMetadata.close()
+                    }
                 }
             }
 
@@ -200,21 +205,6 @@
                     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
         }
     }
 
@@ -225,28 +215,19 @@
             if (databaseId === -1) {
                 realModel.initializeForNewRadio()
             } else if (databaseId !== 0) {
-                realModel.initializeByTrackId(databaseId)
+                realModel.initializeById(modelType, databaseId)
             } 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) {
                 realModel.initializeForNewRadio()
             } else if (databaseId !== 0) {
-                realModel.initializeByTrackId(databaseId)
+                realModel.initializeById(modelType, databaseId)
             } 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
@@ -111,7 +112,13 @@
         sourceComponent:  MediaTrackMetadataView {
             databaseId: 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
+
+            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 : ''