qt: allow MLModels to load a given item from the medialibrary by id

modules/gui/qt/medialibrary/mlalbummodel.cpp

@@ -166,3 +166,13 @@ MLAlbumModel::Loader::load(vlc_medialibrary_t* ml, size_t index, size_t count) c
         res.emplace_back( std::make_unique<MLAlbum>( &album ) );
     return res;
 }
+
+std::unique_ptr<MLItem>
+MLAlbumModel::Loader::loadItemById(vlc_medialibrary_t* ml, MLItemId itemId) const
+{
+    assert(itemId.type == VLC_ML_PARENT_ALBUM);
+    ml_unique_ptr<vlc_ml_album_t> album(vlc_ml_get_album(ml, itemId.id));
+    if (!album)
+        return nullptr;
+    return std::make_unique<MLAlbum>(album.get());
+}

modules/gui/qt/medialibrary/mlalbummodel.hpp

@@ -72,6 +72,7 @@ private:
         Loader(const MLAlbumModel &model) : BaseLoader(model) {}
         size_t count(vlc_medialibrary_t* ml) const override;
         std::vector<std::unique_ptr<MLItem>> load(vlc_medialibrary_t* ml, size_t index, size_t count) const override;
+        std::unique_ptr<MLItem> loadItemById(vlc_medialibrary_t* ml, MLItemId itemId) const override;
     };
 };
 

modules/gui/qt/medialibrary/mlalbumtrackmodel.cpp

@@ -177,3 +177,14 @@ MLAlbumTrackModel::Loader::load(vlc_medialibrary_t* ml, size_t index, size_t cou
         res.emplace_back( std::make_unique<MLAlbumTrack>( ml, &media ) );
     return res;
 }
+
+std::unique_ptr<MLItem>
+MLAlbumTrackModel::Loader::loadItemById(vlc_medialibrary_t* ml, MLItemId itemId) const
+{
+    assert(itemId.type == VLC_ML_PARENT_UNKNOWN);
+    ml_unique_ptr<vlc_ml_media_t> media(vlc_ml_get_media(ml, itemId.id));
+    if (!media)
+        return nullptr;
+    return std::make_unique<MLAlbumTrack>(ml, media.get());
+}
+

modules/gui/qt/medialibrary/mlalbumtrackmodel.hpp

@@ -71,6 +71,7 @@ private:
         Loader(const MLAlbumTrackModel &model) : BaseLoader(model) {}
         size_t count(vlc_medialibrary_t* ml) const override;
         std::vector<std::unique_ptr<MLItem>> load(vlc_medialibrary_t* ml, size_t index, size_t count) const override;
+        std::unique_ptr<MLItem> loadItemById(vlc_medialibrary_t* ml, MLItemId itemId) const override;
     };
 };
 #endif // MLTRACKMODEL_HPP

modules/gui/qt/medialibrary/mlartistmodel.cpp

@@ -136,3 +136,14 @@ MLArtistModel::Loader::load(vlc_medialibrary_t* ml, size_t index, size_t count)
         res.emplace_back( std::make_unique<MLArtist>( &artist ) );
     return res;
 }
+
+std::unique_ptr<MLItem>
+MLArtistModel::Loader::loadItemById(vlc_medialibrary_t* ml, MLItemId itemId) const
+{
+    assert(itemId.type == VLC_ML_PARENT_ARTIST);
+    ml_unique_ptr<vlc_ml_artist_t> artist(vlc_ml_get_artist(ml, itemId.id));
+    if (!artist)
+        return nullptr;
+    return std::make_unique<MLArtist>(artist.get());
+}
+

modules/gui/qt/medialibrary/mlartistmodel.hpp

@@ -64,6 +64,7 @@ private:
         Loader(const MLArtistModel &model) : BaseLoader(model) {}
         size_t count(vlc_medialibrary_t* ml) const override;
         std::vector<std::unique_ptr<MLItem>> load(vlc_medialibrary_t* ml, size_t index, size_t count) const override;
+        std::unique_ptr<MLItem> loadItemById(vlc_medialibrary_t* ml, MLItemId itemId) const override;
     };
 };
 

modules/gui/qt/medialibrary/mlbasemodel.hpp

@@ -132,6 +132,8 @@ protected:
 
         MLQueryParams getParams(size_t index = 0, size_t count = 0) const;
 
+        virtual std::unique_ptr<MLItem> loadItemById(vlc_medialibrary_t* ml, MLItemId itemId) const = 0;
+
     protected:
         MLItemId m_parent;
         QString m_searchPattern;

modules/gui/qt/medialibrary/mlgenremodel.cpp

@@ -205,3 +205,13 @@ MLGenreModel::Loader::load(vlc_medialibrary_t* ml, size_t index, size_t count) c
     return res;
 
 }
+
+std::unique_ptr<MLItem>
+MLGenreModel::Loader::loadItemById(vlc_medialibrary_t* ml, MLItemId itemId) const
+{
+    assert(itemId.type == VLC_ML_PARENT_GENRE);
+    ml_unique_ptr<vlc_ml_genre_t> genre(vlc_ml_get_genre(ml, itemId.id));
+    if (!genre)
+        return nullptr;
+    return std::make_unique<MLGenre>(genre.get());
+}

modules/gui/qt/medialibrary/mlgenremodel.hpp

@@ -67,6 +67,7 @@ private:
         Loader(const MLGenreModel &model) : BaseLoader(model) {}
         size_t count(vlc_medialibrary_t* ml) const override;
         std::vector<std::unique_ptr<MLItem>> load(vlc_medialibrary_t* ml, size_t index, size_t count) const override;
+        std::unique_ptr<MLItem> loadItemById(vlc_medialibrary_t* ml, MLItemId itemId) const override;
     };
 
 private: // Variables

modules/gui/qt/medialibrary/mlplaylistlistmodel.cpp

@@ -456,3 +456,13 @@ MLPlaylistListModel::Loader::load(vlc_medialibrary_t* ml, size_t index, size_t c
 
     return result;
 }
+
+std::unique_ptr<MLItem>
+MLPlaylistListModel::Loader::loadItemById(vlc_medialibrary_t* ml, MLItemId itemId) const
+{
+    assert(itemId.type == VLC_ML_PARENT_PLAYLIST);
+    ml_unique_ptr<vlc_ml_playlist_t> playlist(vlc_ml_get_playlist(ml, itemId.id));
+    if (!playlist)
+        return nullptr;
+    return std::make_unique<MLPlaylist>(playlist.get());
+}

modules/gui/qt/medialibrary/mlplaylistlistmodel.hpp

@@ -112,6 +112,8 @@ private:
         size_t count(vlc_medialibrary_t* ml) const override;
 
         std::vector<std::unique_ptr<MLItem>> load(vlc_medialibrary_t* ml, size_t index, size_t count) const override;
+
+        std::unique_ptr<MLItem> loadItemById(vlc_medialibrary_t* ml, MLItemId itemId) const override;
     };
 };
 

modules/gui/qt/medialibrary/mlplaylistmodel.cpp

@@ -537,3 +537,13 @@ MLPlaylistModel::Loader::load(vlc_medialibrary_t* ml, size_t index, size_t count
 
     return result;
 }
+
+std::unique_ptr<MLItem>
+MLPlaylistModel::Loader::loadItemById(vlc_medialibrary_t* ml, MLItemId itemId) const
+{
+    assert(itemId.type == VLC_ML_PARENT_UNKNOWN);
+    ml_unique_ptr<vlc_ml_media_t> media(vlc_ml_get_media(ml, itemId.id));
+    if (!media)
+        return nullptr;
+    return std::make_unique<MLPlaylistMedia>(media.get());
+}

modules/gui/qt/medialibrary/mlplaylistmodel.hpp

@@ -108,6 +108,8 @@ private:
         size_t count(vlc_medialibrary_t* ml) const override;
 
         std::vector<std::unique_ptr<MLItem>> load(vlc_medialibrary_t* ml, size_t index, size_t count) const override;
+
+        std::unique_ptr<MLItem> loadItemById(vlc_medialibrary_t* ml, MLItemId itemId) const override;
     };
 };
 

modules/gui/qt/medialibrary/mlrecentsmodel.cpp

@@ -146,3 +146,13 @@ MLRecentsModel::Loader::load(vlc_medialibrary_t* ml, size_t index, size_t count)
         res.emplace_back( std::make_unique<MLRecentMedia>( &media ) );
     return res;
 }
+
+std::unique_ptr<MLItem>
+MLRecentsModel::Loader::loadItemById(vlc_medialibrary_t* ml, MLItemId itemId) const
+{
+    assert(itemId.type == VLC_ML_PARENT_UNKNOWN);
+    ml_unique_ptr<vlc_ml_media_t> media(vlc_ml_get_media(ml, itemId.id));
+    if (!media)
+        return nullptr;
+    return std::make_unique<MLRecentMedia>(media.get());
+}

modules/gui/qt/medialibrary/mlrecentsmodel.hpp

@@ -89,7 +89,7 @@ private:
 
         size_t count(vlc_medialibrary_t* ml) const override;
         std::vector<std::unique_ptr<MLItem>> load(vlc_medialibrary_t* ml, size_t index, size_t count) const override;
-
+        std::unique_ptr<MLItem> loadItemById(vlc_medialibrary_t* ml, MLItemId itemId) const override;
     private:
         int m_numberOfItemsToShow;
     };

modules/gui/qt/medialibrary/mlrecentsvideomodel.cpp

@@ -118,3 +118,13 @@ MLRecentsVideoModel::Loader::load(vlc_medialibrary_t* ml, size_t index, size_t c
 
     return res;
 }
+
+std::unique_ptr<MLItem>
+MLRecentsVideoModel::Loader::loadItemById(vlc_medialibrary_t* ml, MLItemId itemId) const
+{
+    assert(itemId.type == VLC_ML_PARENT_UNKNOWN);
+    ml_unique_ptr<vlc_ml_media_t> media(vlc_ml_get_media(ml, itemId.id));
+    if (!media)
+        return nullptr;
+    return std::make_unique<MLVideo>(media.get());
+}

modules/gui/qt/medialibrary/mlrecentsvideomodel.hpp

@@ -58,6 +58,8 @@ private:
         size_t count(vlc_medialibrary_t* ml) const override;
 
         std::vector<std::unique_ptr<MLItem>> load(vlc_medialibrary_t* ml, size_t index, size_t count) const override;
+
+        std::unique_ptr<MLItem> loadItemById(vlc_medialibrary_t* ml, MLItemId itemId) const override;
     private:
         int m_numberOfItemsToShow;
     };

modules/gui/qt/medialibrary/mlurlmodel.cpp

@@ -161,3 +161,13 @@ MLUrlModel::Loader::load(vlc_medialibrary_t* ml, size_t index, size_t count) con
         res.emplace_back( std::make_unique<MLUrl>( &media ) );
     return res;
 }
+
+std::unique_ptr<MLItem>
+MLUrlModel::Loader::loadItemById(vlc_medialibrary_t* ml, MLItemId itemId) const
+{
+    assert(itemId.type == VLC_ML_PARENT_UNKNOWN);
+    ml_unique_ptr<vlc_ml_media_t> media(vlc_ml_get_media(ml, itemId.id));
+    if (!media)
+        return nullptr;
+    return std::make_unique<MLUrl>(media.get());
+}

modules/gui/qt/medialibrary/mlurlmodel.hpp

@@ -77,6 +77,7 @@ private:
         Loader(const MLUrlModel &model) : BaseLoader(model) {}
         size_t count(vlc_medialibrary_t* ml) const override;
         std::vector<std::unique_ptr<MLItem>> load(vlc_medialibrary_t* ml, size_t index, size_t count) const override;
+        std::unique_ptr<MLItem> loadItemById(vlc_medialibrary_t* ml, MLItemId itemId) const override;
     };
 };
 

modules/gui/qt/medialibrary/mlvideofoldersmodel.cpp

@@ -184,3 +184,13 @@ MLVideoFoldersModel::Loader::load(vlc_medialibrary_t * ml,
 
     return result;
 }
+
+std::unique_ptr<MLItem>
+MLVideoFoldersModel::Loader::loadItemById(vlc_medialibrary_t* ml, MLItemId itemId) const
+{
+    assert(itemId.type == VLC_ML_PARENT_FOLDER);
+    ml_unique_ptr<vlc_ml_folder_t> folder(vlc_ml_get_folder(ml, itemId.id));
+    if (!folder)
+        return nullptr;
+    return std::make_unique<MLFolder>(folder.get());
+}

modules/gui/qt/medialibrary/mlvideofoldersmodel.hpp

@@ -72,6 +72,8 @@ private:
 
         std::vector<std::unique_ptr<MLItem>> load(vlc_medialibrary_t * ml,
                                                   size_t index, size_t count) const override;
+
+        std::unique_ptr<MLItem> loadItemById(vlc_medialibrary_t* ml, MLItemId itemId) const override;
     };
 };
 

modules/gui/qt/medialibrary/mlvideogroupsmodel.cpp

@@ -234,3 +234,29 @@ MLVideoGroupsModel::Loader::load(vlc_medialibrary_t* ml,
 
     return result;
 }
+
+
+std::unique_ptr<MLItem>
+MLVideoGroupsModel::Loader::loadItemById(vlc_medialibrary_t* ml, MLItemId itemId) const
+{
+    if (itemId.type == VLC_ML_PARENT_UNKNOWN)
+    {
+        ml_unique_ptr<vlc_ml_media_t> media(vlc_ml_get_media(ml, itemId.id));
+        if (!media)
+            return nullptr;
+        return std::make_unique<MLVideo>(media.get());
+    }
+    else if (itemId.type == VLC_ML_PARENT_GROUP)
+    {
+        ml_unique_ptr<vlc_ml_group_t> group(vlc_ml_get_group(ml, itemId.id));
+        if (!group)
+            return nullptr;
+        return std::make_unique<MLGroup>(group.get());
+    }
+    else
+    {
+        vlc_assert_unreachable();
+        return nullptr;
+    }
+
+}

modules/gui/qt/medialibrary/mlvideogroupsmodel.hpp

@@ -67,6 +67,8 @@ private:
         size_t count(vlc_medialibrary_t* ml) const override;
 
         std::vector<std::unique_ptr<MLItem>> load(vlc_medialibrary_t* ml, size_t index, size_t count) const override;
+
+        std::unique_ptr<MLItem> loadItemById(vlc_medialibrary_t* ml, MLItemId itemId) const override;
     };
 };
 

modules/gui/qt/medialibrary/mlvideomodel.cpp

@@ -217,3 +217,14 @@ MLVideoModel::Loader::load(vlc_medialibrary_t* ml, size_t index, size_t count) c
 
     return result;
 }
+
+std::unique_ptr<MLItem>
+MLVideoModel::Loader::loadItemById(vlc_medialibrary_t* ml, MLItemId itemId) const
+{
+    assert(itemId.type == VLC_ML_PARENT_UNKNOWN);
+    ml_unique_ptr<vlc_ml_media_t> media(vlc_ml_get_media(ml, itemId.id));
+    if (!media)
+        return nullptr;
+    return std::make_unique<MLVideo>(media.get());
+}
+

modules/gui/qt/medialibrary/mlvideomodel.hpp

@@ -86,6 +86,7 @@ private:
         Loader(const MLVideoModel &model) : BaseLoader(model) {}
         size_t count(vlc_medialibrary_t* ml) const override;
         std::vector<std::unique_ptr<MLItem>> load(vlc_medialibrary_t* ml, size_t index, size_t count) const override;
+        std::unique_ptr<MLItem> loadItemById(vlc_medialibrary_t* ml, MLItemId itemId) const override;
     };
 };