Added Play/Queue buttons in the releases view

approot/releases.xml

@@ -5,6 +5,7 @@
 <message id="Lms.Explore.Releases.template">
 	<div class="page-header">
 		<h2>${tr:Lms.Explore.releases}</h2>
+		${play-btn}${add-btn}
 	</div>
 	<div class="form-group">
 		<div class="input-group">

src/ui/explore/ArtistView.cpp

@@ -102,19 +102,19 @@ Artist::refresh()
 	{
 		Wt::WText* playBtn = t->bindNew<Wt::WText>("play-btn", Wt::WString::tr("Lms.Explore.template.play-btn"), Wt::TextFormat::XHTML);
 
-		playBtn->clicked().connect(std::bind([=]
+		playBtn->clicked().connect([=]
 		{
-			artistPlay.emit(*artistId);
+			artistsPlay.emit({*artistId});
-		}));
+		});
 	}
 
 	{
 		Wt::WText* addBtn = t->bindNew<Wt::WText>("add-btn", Wt::WString::tr("Lms.Explore.template.add-btn"), Wt::TextFormat::XHTML);
 
-		addBtn->clicked().connect(std::bind([=]
+		addBtn->clicked().connect([=]
 		{
-			artistAdd.emit(*artistId);
+			artistsAdd.emit({*artistId});
-		}));
+		});
 	}
 
 	Wt::WContainerWidget* releasesContainer = t->bindNew<Wt::WContainerWidget>("releases");
@@ -179,13 +179,13 @@ Artist::refresh()
 		Wt::WText* playBtn = entry->bindNew<Wt::WText>("play-btn", Wt::WString::tr("Lms.Explore.template.play-btn"), Wt::TextFormat::XHTML);
 		playBtn->clicked().connect(std::bind([=]
 		{
-			releasePlay.emit(releaseId);
+			releasesPlay.emit({releaseId});
 		}));
 
 		Wt::WText* addBtn = entry->bindNew<Wt::WText>("add-btn", Wt::WString::tr("Lms.Explore.template.add-btn"), Wt::TextFormat::XHTML);
 		addBtn->clicked().connect(std::bind([=]
 		{
-			releaseAdd.emit(releaseId);
+			releasesAdd.emit({releaseId});
 		}));
 	}
 }

src/ui/explore/ArtistView.hpp

@@ -33,11 +33,11 @@ class Artist : public Wt::WContainerWidget
 	public:
 		Artist(Filters* filters);
 
-		Wt::Signal<Database::IdType> artistAdd;
+		Wt::Signal<const std::vector<Database::IdType>&> artistsAdd;
-		Wt::Signal<Database::IdType> artistPlay;
+		Wt::Signal<const std::vector<Database::IdType>&> artistsPlay;
 
-		Wt::Signal<Database::IdType> releaseAdd;
+		Wt::Signal<const std::vector<Database::IdType>&> releasesAdd;
-		Wt::Signal<Database::IdType> releasePlay;
+		Wt::Signal<const std::vector<Database::IdType>&> releasesPlay;
 
 	private:
 		void refresh();

src/ui/explore/ArtistsView.hpp

@@ -36,8 +36,8 @@ class Artists : public Wt::WTemplate
 	public:
 		Artists(Filters* filters);
 
-		Wt::Signal<Database::IdType> artistAdd;
+		Wt::Signal<const std::vector<Database::IdType>&> artistsAdd;
-		Wt::Signal<Database::IdType> artistPlay;
+		Wt::Signal<const std::vector<Database::IdType>&> artistsPlay;
 
 	private:
 		void refresh();

src/ui/explore/Explore.cpp

@@ -121,32 +121,30 @@ Explore::Explore()
 	Wt::WStackedWidget* contentsStack = bindNew<Wt::WStackedWidget>("contents");
 
 	auto artists = std::make_unique<Artists>(_filters);
-	artists->artistAdd.connect(this, &Explore::handleArtistAdd);
+	artists->artistsAdd.connect(this, &Explore::handleArtistsAdd);
-	artists->artistPlay.connect(this, &Explore::handleArtistPlay);
+	artists->artistsPlay.connect(this, &Explore::handleArtistsPlay);
 	contentsStack->addWidget(std::move(artists));
 
 	auto artist = std::make_unique<Artist>(_filters);
-	artist->artistAdd.connect(this, &Explore::handleArtistAdd);
+	artist->artistsAdd.connect(this, &Explore::handleArtistsAdd);
-	artist->artistPlay.connect(this, &Explore::handleArtistPlay);
+	artist->artistsPlay.connect(this, &Explore::handleArtistsPlay);
-	artist->releaseAdd.connect(this, &Explore::handleReleaseAdd);
+	artist->releasesAdd.connect(this, &Explore::handleReleasesAdd);
-	artist->releasePlay.connect(this, &Explore::handleReleasePlay);
+	artist->releasesPlay.connect(this, &Explore::handleReleasesPlay);
 	contentsStack->addWidget(std::move(artist));
 
 	auto releases = std::make_unique<Releases>(_filters);
-	releases->releaseAdd.connect(this, &Explore::handleReleaseAdd);
+	releases->releasesAdd.connect(this, &Explore::handleReleasesAdd);
-	releases->releasePlay.connect(this, &Explore::handleReleasePlay);
+	releases->releasesPlay.connect(this, &Explore::handleReleasesPlay);
 	contentsStack->addWidget(std::move(releases));
 
 	auto release = std::make_unique<Release>(_filters);
-	release->releaseAdd.connect(this, &Explore::handleReleaseAdd);
+	release->releasesAdd.connect(this, &Explore::handleReleasesAdd);
-	release->releasePlay.connect(this, &Explore::handleReleasePlay);
+	release->releasesPlay.connect(this, &Explore::handleReleasesPlay);
-	release->trackAdd.connect(this, &Explore::handleTrackAdd);
+	release->tracksAdd.connect(this, &Explore::handleTracksAdd);
-	release->trackPlay.connect(this, &Explore::handleTrackPlay);
+	release->tracksPlay.connect(this, &Explore::handleTracksPlay);
 	contentsStack->addWidget(std::move(release));
 
 	auto tracks = std::make_unique<Tracks>(_filters);
-	tracks->trackAdd.connect(this, &Explore::handleTrackAdd);
-	tracks->trackPlay.connect(this, &Explore::handleTrackPlay);
 	tracks->tracksAdd.connect(this, &Explore::handleTracksAdd);
 	tracks->tracksPlay.connect(this, &Explore::handleTracksPlay);
 	contentsStack->addWidget(std::move(tracks));
@@ -181,102 +179,85 @@ Explore::Explore()
 
 static
 std::vector<Database::IdType>
-getArtistTracks(Database::Session& session, Database::IdType artistId, const std::set<Database::IdType>& clusters)
+getArtistsTracks(Database::Session& session, const std::vector<Database::IdType>& artistsId, const std::set<Database::IdType>& clusters)
 {
+	std::vector<Database::IdType> res;
+
 	auto transaction {LmsApp->getDbSession().createSharedTransaction()};
 
-	Database::Artist::pointer artist {Database::Artist::getById(session, artistId)};
+	for (Database::IdType artistId : artistsId)
-	if (!artist)
+	{
-		return {};
+		Database::Artist::pointer artist {Database::Artist::getById(session, artistId)};
+		if (!artist)
+			continue;
 
-	// TODO handle clusters here
+		// TODO handle clusters here
-	const std::vector<Database::Track::pointer> tracks {artist->getTracks()};
+		const std::vector<Database::Track::pointer> tracks {artist->getTracks()};
 
-	std::vector<Database::IdType> res;
+		res.reserve(res.size() + tracks.size());
-	res.reserve(tracks.size());
+		std::transform(std::cbegin(tracks), std::cend(tracks), std::back_inserter(res), [](const Database::Track::pointer& track) { return track.id(); });
+	}
 
-	std::transform(std::cbegin(tracks), std::cend(tracks), std::back_inserter(res), [](const Database::Track::pointer& track) { return track.id(); });
 	return res;
 }
 
 static
 std::vector<Database::IdType>
-getReleaseTracks(Database::Session& session, Database::IdType releaseId, std::set<Database::IdType> clusters)
+getReleasesTracks(Database::Session& session, const std::vector<Database::IdType>& releasesId, const std::set<Database::IdType>& clusters)
 {
+	std::vector<Database::IdType> res;
+
 	auto transaction {LmsApp->getDbSession().createSharedTransaction()};
 
-	Database::Release::pointer release {Database::Release::getById(session, releaseId)};
+	for (Database::IdType releaseId : releasesId)
-	if (!release)
+	{
-		return {};
+		Database::Release::pointer release {Database::Release::getById(session, releaseId)};
+		if (!release)
+			continue;
 
-	const std::vector<Database::Track::pointer> tracks {release->getTracks(clusters)};
+		const std::vector<Database::Track::pointer> tracks {release->getTracks(clusters)};
 
-	std::vector<Database::IdType> res;
+		res.reserve(res.size() + tracks.size());
-	res.reserve(tracks.size());
+		std::transform(std::cbegin(tracks), std::cend(tracks), std::back_inserter(res), [](const Database::Track::pointer& track) { return track.id(); });
+	}
 
-	std::transform(std::cbegin(tracks), std::cend(tracks), std::back_inserter(res), [](const Database::Track::pointer& track) { return track.id(); });
 	return res;
 }
 
-static
+void
-std::vector<Database::IdType>
+Explore::handleArtistsAdd(const std::vector<Database::IdType>& artistsId)
-getTrack(Database::Session& session, Database::IdType trackId)
 {
-	auto transaction {LmsApp->getDbSession().createSharedTransaction()};
+	tracksAdd.emit(getArtistsTracks(LmsApp->getDbSession(), artistsId, _filters->getClusterIds()));
-
-	Database::Track::pointer track {Database::Track::getById(session, trackId)};
-	if (!track)
-		return {};
-
-	return {track.id()};
 }
 
 void
-Explore::handleArtistAdd(Database::IdType id)
+Explore::handleArtistsPlay(const std::vector<Database::IdType>& artistsId)
 {
-	tracksAdd.emit(getArtistTracks(LmsApp->getDbSession(), id, _filters->getClusterIds()));
+	tracksPlay.emit(getArtistsTracks(LmsApp->getDbSession(), artistsId, _filters->getClusterIds()));
 }
 
 void
-Explore::handleArtistPlay(Database::IdType id)
+Explore::handleReleasesAdd(const std::vector<Database::IdType>& releasesId)
 {
-	tracksPlay.emit(getArtistTracks(LmsApp->getDbSession(), id, _filters->getClusterIds()));
+	tracksAdd.emit(getReleasesTracks(LmsApp->getDbSession(), releasesId, _filters->getClusterIds()));
 }
 
 void
-Explore::handleReleaseAdd(Database::IdType id)
+Explore::handleReleasesPlay(const std::vector<Database::IdType>& releasesId)
 {
-	tracksAdd.emit(getReleaseTracks(LmsApp->getDbSession(), id, _filters->getClusterIds()));
+	tracksPlay.emit(getReleasesTracks(LmsApp->getDbSession(), releasesId, _filters->getClusterIds()));
 }
 
 void
-Explore::handleReleasePlay(Database::IdType id)
+Explore::handleTracksAdd(const std::vector<Database::IdType>& tracksId)
 {
-	tracksPlay.emit(getReleaseTracks(LmsApp->getDbSession(), id, _filters->getClusterIds()));
+	tracksAdd.emit(tracksId);
 }
 
 void
-Explore::handleTrackAdd(Database::IdType id)
+Explore::handleTracksPlay(const std::vector<Database::IdType>& tracksId)
 {
-	tracksAdd.emit(getTrack(LmsApp->getDbSession(), id));
+	tracksPlay.emit(tracksId);
-}
-
-void
-Explore::handleTrackPlay(Database::IdType id)
-{
-	tracksPlay.emit(getTrack(LmsApp->getDbSession(), id));
-}
-
-void
-Explore::handleTracksAdd(const std::vector<Database::IdType>& trackIds)
-{
-	tracksAdd.emit(trackIds);
-}
-
-void
-Explore::handleTracksPlay(const std::vector<Database::IdType>& trackIds)
-{
-	tracksPlay.emit(trackIds);
 }
 
 } // namespace UserInterface

src/ui/explore/Explore.hpp

@@ -37,14 +37,12 @@ class Explore : public Wt::WTemplate
 
 	private:
 
-		void handleArtistAdd(Database::IdType artistId);
+		void handleArtistsAdd(const std::vector<Database::IdType>& artistsId);
-		void handleArtistPlay(Database::IdType artistId);
+		void handleArtistsPlay(const std::vector<Database::IdType>& artistsId);
-		void handleReleaseAdd(Database::IdType releaseId);
+		void handleReleasesAdd(const std::vector<Database::IdType>& releasesId);
-		void handleReleasePlay(Database::IdType releaseId);
+		void handleReleasesPlay(const std::vector<Database::IdType>& releasesId);
-		void handleTrackAdd(Database::IdType trackId);
+		void handleTracksAdd(const std::vector<Database::IdType>& tracksId);
-		void handleTrackPlay(Database::IdType trackId);
+		void handleTracksPlay(const std::vector<Database::IdType>& tracksId);
-		void handleTracksAdd(const std::vector<Database::IdType>& trackIds);
-		void handleTracksPlay(const std::vector<Database::IdType>& trackIds);
 
 		Filters* _filters;
 };

src/ui/explore/ReleaseView.cpp

@@ -139,7 +139,7 @@ Release::refresh()
 		Wt::WText* playBtn {t->bindNew<Wt::WText>("play-btn", Wt::WString::tr("Lms.Explore.template.play-btn"), Wt::TextFormat::XHTML)};
 		playBtn->clicked().connect([=]
 		{
-			releasePlay.emit(*releaseId);
+			releasesPlay.emit({*releaseId});
 		});
 	}
 
@@ -147,7 +147,7 @@ Release::refresh()
 		Wt::WText* addBtn {t->bindNew<Wt::WText>("add-btn", Wt::WString::tr("Lms.Explore.template.add-btn"), Wt::TextFormat::XHTML)};
 		addBtn->clicked().connect([=]
 		{
-			releaseAdd.emit(*releaseId);
+			releasesAdd.emit({*releaseId});
 		});
 	}
 
@@ -196,13 +196,13 @@ Release::refresh()
 		Wt::WText* playBtn {entry->bindNew<Wt::WText>("play-btn", Wt::WString::tr("Lms.Explore.template.play-btn"), Wt::TextFormat::XHTML)};
 		playBtn->clicked().connect(std::bind([=]
 		{
-			trackPlay.emit(trackId);
+			tracksPlay.emit({trackId});
 		}));
 
 		Wt::WText* addBtn {entry->bindNew<Wt::WText>("add-btn", Wt::WString::tr("Lms.Explore.template.add-btn"), Wt::TextFormat::XHTML)};
 		addBtn->clicked().connect(std::bind([=]
 		{
-			trackAdd.emit(trackId);
+			tracksAdd.emit({trackId});
 		}));
 
 		LmsApp->getEvents().trackLoaded.connect(entry, [=] (Database::IdType loadedTrackId, bool /*play*/)

src/ui/explore/ReleaseView.hpp

@@ -32,11 +32,11 @@ class Release : public Wt::WContainerWidget
 	public:
 		Release(Filters* filters);
 
-		Wt::Signal<Database::IdType> releaseAdd;
+		Wt::Signal<const std::vector<Database::IdType>&> releasesAdd;
-		Wt::Signal<Database::IdType> releasePlay;
+		Wt::Signal<const std::vector<Database::IdType>&> releasesPlay;
 
-		Wt::Signal<Database::IdType> trackAdd;
+		Wt::Signal<const std::vector<Database::IdType>&> tracksAdd;
-		Wt::Signal<Database::IdType> trackPlay;
+		Wt::Signal<const std::vector<Database::IdType>&> tracksPlay;
 
 	private:
 		void refresh();

src/ui/explore/ReleasesView.cpp

@@ -48,10 +48,21 @@ _filters(filters)
 	_search->setPlaceholderText(Wt::WString::tr("Lms.Explore.search-placeholder"));
 	_search->textInput().connect(this, &Releases::refresh);
 
+	Wt::WText* playBtn {bindNew<Wt::WText>("play-btn", Wt::WString::tr("Lms.Explore.template.play-btn"), Wt::TextFormat::XHTML)};
+	playBtn->clicked().connect([this]
+	{
+		releasesPlay.emit(getReleases());
+	});
+	Wt::WText* addBtn {bindNew<Wt::WText>("add-btn", Wt::WString::tr("Lms.Explore.template.add-btn"), Wt::TextFormat::XHTML)};
+	addBtn->clicked().connect([this]
+	{
+		releasesAdd.emit(getReleases());
+	});
+
 	_container = bindNew<Wt::WContainerWidget>("releases");
 
 	_showMore = bindNew<Wt::WPushButton>("show-more", Wt::WString::tr("Lms.Explore.show-more"));
-	_showMore->clicked().connect([=]
+	_showMore->clicked().connect([this]
 	{
 		addSome();
 	});
@@ -71,17 +82,14 @@ Releases::refresh()
 void
 Releases::addSome()
 {
-	const auto searchKeywords {splitString(_search->text().toUTF8(), " ")};
+	bool moreResults {};
-	const auto clusterIds {_filters->getClusterIds()};
 
-	auto transaction {LmsApp->getDbSession().createSharedTransaction()};
+	const auto releasesId {getReleases(_container->count(), 20, moreResults)};
-
+	for (const Database::IdType releaseId : releasesId )
-	bool moreResults;
-	const auto releases {Release::getByFilter(LmsApp->getDbSession(), clusterIds, searchKeywords, _container->count(), 20, moreResults)};
-
-	for (const Database::Release::pointer& release : releases)
 	{
-		const Database::IdType releaseId {release.id()};
+		auto transaction {LmsApp->getDbSession().createSharedTransaction()};
+
+		const Database::Release::pointer release {Database::Release::getById(LmsApp->getDbSession(), releaseId)};
 
 		Wt::WTemplate* entry = _container->addNew<Wt::WTemplate>(Wt::WString::tr("Lms.Explore.Releases.template.entry"));
 		entry->addFunction("tr", Wt::WTemplate::Functions::tr);
@@ -113,18 +121,41 @@ Releases::addSome()
 		Wt::WText* playBtn = entry->bindNew<Wt::WText>("play-btn", Wt::WString::tr("Lms.Explore.template.play-btn"), Wt::TextFormat::XHTML);
 		playBtn->clicked().connect([=]
 		{
-			releasePlay.emit(releaseId);
+			releasesPlay.emit({releaseId});
 		});
 
 		Wt::WText* addBtn = entry->bindNew<Wt::WText>("add-btn", Wt::WString::tr("Lms.Explore.template.add-btn"), Wt::TextFormat::XHTML);
 		addBtn->clicked().connect([=]
 		{
-			releaseAdd.emit(releaseId);
+			releasesAdd.emit({releaseId});
 		});
 	}
 
 	_showMore->setHidden(!moreResults);
 }
 
+std::vector<Database::IdType>
+Releases::getReleases(boost::optional<std::size_t> offset, boost::optional<std::size_t> limit, bool& moreResults) const
+{
+	const auto searchKeywords {splitString(_search->text().toUTF8(), " ")};
+
+	auto transaction {LmsApp->getDbSession().createSharedTransaction()};
+
+	const auto releases {Release::getByFilter(LmsApp->getDbSession(), _filters->getClusterIds(), searchKeywords, offset, limit, moreResults)};
+
+	std::vector<Database::IdType> res;
+	for (const Database::Release::pointer& release : releases)
+		res.push_back(release.id());
+
+	return res;
+}
+
+std::vector<Database::IdType>
+Releases::getReleases() const
+{
+	bool moreResults;
+	return getReleases({}, {}, moreResults);
+}
+
 } // namespace UserInterface
 

src/ui/explore/ReleasesView.hpp

@@ -19,6 +19,8 @@
 
 #pragma once
 
+#include <boost/optional.hpp>
+
 #include <Wt/WContainerWidget.h>
 #include <Wt/WLineEdit.h>
 #include <Wt/WPushButton.h>
@@ -35,13 +37,16 @@ class Releases : public Wt::WTemplate
 	public:
 		Releases(Filters* filters);
 
-		Wt::Signal<Database::IdType> releaseAdd;
+		Wt::Signal<const std::vector<Database::IdType>&> releasesAdd;
-		Wt::Signal<Database::IdType> releasePlay;
+		Wt::Signal<const std::vector<Database::IdType>&> releasesPlay;
 
 	private:
 		void refresh();
 		void addSome();
 
+		std::vector<Database::IdType> getReleases(boost::optional<std::size_t> offset, boost::optional<std::size_t> limit, bool& moreResults) const;
+		std::vector<Database::IdType> getReleases() const;
+
 		Filters* _filters;
 		Wt::WPushButton* _showMore;
 		Wt::WLineEdit* _search;

src/ui/explore/TracksView.cpp

@@ -50,10 +50,10 @@ _filters(filters)
 	_search->textInput().connect(this, &Tracks::refresh);
 
 	Wt::WText* playBtn = bindNew<Wt::WText>("play-btn", Wt::WString::tr("Lms.Explore.template.play-btn"), Wt::TextFormat::XHTML);
-	playBtn->clicked().connect(std::bind([=]
+	playBtn->clicked().connect([=]
 	{
 		tracksPlay.emit(getTracks());
-	}));
+	});
 
 	Wt::WText* addBtn = bindNew<Wt::WText>("add-btn", Wt::WString::tr("Lms.Explore.template.add-btn"), Wt::TextFormat::XHTML);
 	addBtn->clicked().connect(std::bind([=]
@@ -148,13 +148,13 @@ Tracks::addSome()
 		Wt::WText* playBtn = entry->bindNew<Wt::WText>("play-btn", Wt::WString::tr("Lms.Explore.template.play-btn"), Wt::TextFormat::XHTML);
 		playBtn->clicked().connect(std::bind([=]
 		{
-			trackPlay.emit(trackId);
+			tracksPlay.emit({trackId});
 		}));
 
 		Wt::WText* addBtn = entry->bindNew<Wt::WText>("add-btn", Wt::WString::tr("Lms.Explore.template.add-btn"), Wt::TextFormat::XHTML);
 		addBtn->clicked().connect(std::bind([=]
 		{
-			trackAdd.emit(trackId);
+			tracksAdd.emit({trackId});
 		}));
 	}
 

src/ui/explore/TracksView.hpp

@@ -36,11 +36,8 @@ class Tracks : public Wt::WTemplate
 	public:
 		Tracks(Filters* filters);
 
-		Wt::Signal<Database::IdType> trackAdd;
+		Wt::Signal<const std::vector<Database::IdType>&> tracksAdd;
-		Wt::Signal<Database::IdType> trackPlay;
+		Wt::Signal<const std::vector<Database::IdType>&> tracksPlay;
-
-		Wt::Signal<std::vector<Database::IdType>> tracksAdd;
-		Wt::Signal<std::vector<Database::IdType>> tracksPlay;
 
 	private:
 		void refresh();