Now diplaying albums in grid mode

src/libs/database/impl/Artist.cpp

@@ -362,7 +362,7 @@ Artist::getReleases(const std::set<IdType>& clusterIds) const
 	if (!clusterIds.empty())
 		oss << " GROUP BY t.id HAVING COUNT(DISTINCT c.id) = " << clusterIds.size();
 
-	oss << " ORDER BY t.year,r.name";
+	oss << " ORDER BY t.year DESC, r.name COLLATE NOCASE";
 
 	Wt::Dbo::Query<Release::pointer> query = session()->query<Release::pointer>( oss.str() );
 

src/lms/CMakeLists.txt

@@ -24,6 +24,7 @@ add_executable(lms
 	ui/explore/ReleasesView.cpp
 	ui/explore/ReleaseView.cpp
 	ui/explore/SearchView.cpp
+	ui/explore/TrackListHelpers.cpp
 	ui/explore/TracksView.cpp
 	ui/resource/AudioFileResource.cpp
 	ui/resource/AudioTranscodeResource.cpp

src/lms/ui/LmsApplication.cpp

@@ -251,6 +251,7 @@ LmsApplication::createArtistAnchor(Database::Artist::pointer artist, bool addTex
 	{
 		res->setTextFormat(Wt::TextFormat::Plain);
 		res->setText(Wt::WString::fromUTF8(artist->getName()));
+		res->setToolTip(Wt::WString::fromUTF8(artist->getName()), Wt::TextFormat::Plain);
 	}
 
 	return res;
@@ -269,8 +270,10 @@ LmsApplication::createReleaseAnchor(Database::Release::pointer release, bool add
 
 	if (addText)
 	{
+		res->setWordWrap(false);
 		res->setTextFormat(Wt::TextFormat::Plain);
 		res->setText(Wt::WString::fromUTF8(release->getName()));
+		res->setToolTip(Wt::WString::fromUTF8(release->getName()), Wt::TextFormat::Plain);
 	}
 
 	return res;
@@ -462,7 +465,7 @@ LmsApplication::createHome()
 	mainStack->setAttributeValue("style", "overflow-x:visible;overflow-y:visible;");
 
 	Explore* explore = mainStack->addNew<Explore>(filters);
-	PlayQueue* playqueue = mainStack->addNew<PlayQueue>();
+	_playQueue = mainStack->addNew<PlayQueue>();
 	auto* search {mainStack->addNew<SearchView>(filters)};
 	mainStack->addNew<SettingsView>();
 
@@ -485,31 +488,31 @@ LmsApplication::createHome()
 		mainStack->addNew<UserView>();
 	}
 
-	explore->tracksAction.connect([playqueue] (PlayQueueAction action, const std::vector<Database::IdType>& trackIds)
+	explore->tracksAction.connect([this] (PlayQueueAction action, const std::vector<Database::IdType>& trackIds)
 	{
-		playqueue->processTracks(action, trackIds);
+		_playQueue->processTracks(action, trackIds);
 	});
 
 	// Events from MediaPlayer
-	_mediaPlayer->playNext.connect([=]
+	_mediaPlayer->playNext.connect([this]
 	{
-		playqueue->playNext();
+		_playQueue->playNext();
 	});
-	_mediaPlayer->playPrevious.connect([=]
+	_mediaPlayer->playPrevious.connect([this]
 	{
-		playqueue->playPrevious();
+		_playQueue->playPrevious();
 	});
-	_mediaPlayer->playbackEnded.connect([=]
+	_mediaPlayer->playbackEnded.connect([this]
 	{
-		playqueue->playNext();
+		_playQueue->playNext();
 	});
 
-	playqueue->trackSelected.connect([=] (Database::IdType trackId, bool play, float replayGain)
+	_playQueue->trackSelected.connect([this] (Database::IdType trackId, bool play, float replayGain)
 	{
 		_mediaPlayer->loadTrack(trackId, play, replayGain);
 	});
 
-	playqueue->trackUnselected.connect([=] ()
+	_playQueue->trackUnselected.connect([this] ()
 	{
 		_mediaPlayer->stop();
 	});

src/lms/ui/LmsApplication.hpp

@@ -45,6 +45,7 @@ class Auth;
 class ImageResource;
 class LmsApplicationException;
 class MediaPlayer;
+class PlayQueue;
 
 // Events that can be listen from anywhere in the application
 struct Events
@@ -100,7 +101,8 @@ class LmsApplication : public Wt::WApplication
 		static std::unique_ptr<Wt::WAnchor> createReleaseAnchor(Wt::Dbo::ptr<Database::Release> release, bool addText = true);
 		static std::unique_ptr<Wt::WText> createCluster(Wt::Dbo::ptr<Database::Cluster> cluster, bool canDelete = false);
 
-		MediaPlayer* getMediaPlayer() const { return _mediaPlayer; }
+		MediaPlayer&	getMediaPlayer() const { return *_mediaPlayer; }
+		PlayQueue&		getPlayQueue() const { return *_playQueue; }
 
 		// Signal emitted just before the session ends (user may already be logged out)
 		Wt::Signal<>&	preQuit() { return _preQuit; }
@@ -124,13 +126,14 @@ class LmsApplication : public Wt::WApplication
 		Wt::Signal<>				_preQuit;
 		Database::Session			_dbSession;
 		LmsApplicationGroupContainer&   	_appGroups;
-		Events					_events;
+		Events						_events;
 		std::optional<Database::IdType>	_userId;
 		std::optional<bool>			_userAuthStrong;
 		std::shared_ptr<AudioTranscodeResource>	_audioTranscodeResource;
 		std::shared_ptr<AudioFileResource>	_audioFileResource;
 		std::shared_ptr<ImageResource>		_imageResource;
 		MediaPlayer*				_mediaPlayer {};
+		PlayQueue*					_playQueue {};
 };
 
 

src/lms/ui/PlayQueue.cpp

@@ -136,7 +136,7 @@ PlayQueue::PlayQueue()
 
 		if (!LmsApp->getUser()->isDemo())
 		{
-			LmsApp->getMediaPlayer()->settingsLoaded.connect([=]
+			LmsApp->getMediaPlayer().settingsLoaded.connect([=]
 			{
 				if (_mediaPlayerSettingsLoaded)
 					return;
@@ -451,7 +451,7 @@ PlayQueue::enqueueRadioTrack()
 std::optional<float>
 PlayQueue::getReplayGain(std::size_t pos, const Database::Track::pointer& track) const
 {
-	const auto& settings {LmsApp->getMediaPlayer()->getSettings()};
+	const auto& settings {LmsApp->getMediaPlayer().getSettings()};
 	if (!settings)
 		return std::nullopt;
 

src/lms/ui/SettingsView.cpp

@@ -156,7 +156,7 @@ class SettingsModel : public Wt::WFormModel
 				settings.replayGain.preAmpGain = Wt::asNumber(value(ReplayGainPreAmpGainField));
 				settings.replayGain.preAmpGainIfNoInfo = Wt::asNumber(value(ReplayGainPreAmpGainIfNoInfoField));
 
-				LmsApp->getMediaPlayer()->setSettings(settings);
+				LmsApp->getMediaPlayer().setSettings(settings);
 			}
 
 			{
@@ -191,7 +191,7 @@ class SettingsModel : public Wt::WFormModel
 			setValue(DarkModeField, user->getUITheme() == User::UITheme::Dark);
 
 			{
-				const auto settings {*LmsApp->getMediaPlayer()->getSettings()};
+				const auto settings {*LmsApp->getMediaPlayer().getSettings()};
 
 				auto transcodeModeRow {_transcodeModeModel->getRowFromValue(settings.transcode.mode)};
 				if (transcodeModeRow)
@@ -350,7 +350,7 @@ SettingsView::SettingsView()
 		refreshView();
 	});
 
-	LmsApp->getMediaPlayer()->settingsLoaded.connect([=]()
+	LmsApp->getMediaPlayer().settingsLoaded.connect([=]()
 	{
 		refreshView();
 	});
@@ -367,7 +367,7 @@ SettingsView::refreshView()
 	clear();
 
 	// Hack to wait for the audio player know the settings applied
-	if (!LmsApp->getMediaPlayer()->getSettings())
+	if (!LmsApp->getMediaPlayer().getSettings())
 		return;
 
 	auto t {addNew<Wt::WTemplateFormView>(Wt::WString::tr("Lms.Settings.template"))};
@@ -426,7 +426,7 @@ SettingsView::refreshView()
 			t->updateModel(model.get());
 			t->updateView(model.get());
 		});
-		if (LmsApp->getMediaPlayer()->getSettings()->transcode.mode == MediaPlayer::Settings::Transcode::Mode::Never)
+		if (LmsApp->getMediaPlayer().getSettings()->transcode.mode == MediaPlayer::Settings::Transcode::Mode::Never)
 		{
 			model->setReadOnly(SettingsModel::TranscodeFormatField, true);
 			model->setReadOnly(SettingsModel::TranscodeBitrateField, true);
@@ -456,7 +456,7 @@ SettingsView::refreshView()
 			t->updateModel(model.get());
 			t->updateView(model.get());
 		});
-		if (LmsApp->getMediaPlayer()->getSettings()->replayGain.mode == MediaPlayer::Settings::ReplayGain::Mode::None)
+		if (LmsApp->getMediaPlayer().getSettings()->replayGain.mode == MediaPlayer::Settings::ReplayGain::Mode::None)
 		{
 			model->setReadOnly(SettingsModel::SettingsModel::ReplayGainPreAmpGainField, true);
 			model->setReadOnly(SettingsModel::SettingsModel::ReplayGainPreAmpGainIfNoInfoField, true);

src/lms/ui/explore/ArtistView.cpp

@@ -32,11 +32,11 @@
 #include "utils/String.hpp"
 
 #include "resource/ImageResource.hpp"
-
 #include "ArtistListHelpers.hpp"
+#include "Filters.hpp"
 #include "LmsApplication.hpp"
 #include "LmsApplicationException.hpp"
-#include "Filters.hpp"
+#include "ReleaseListHelpers.hpp"
 
 using namespace Database;
 
@@ -128,61 +128,10 @@ Artist::refreshView()
 	auto releases = artist->getReleases(_filters->getClusterIds());
 	for (const auto& release : releases)
 	{
-		releasesContainer->addWidget(createRelease(artist, release));
+		releasesContainer->addWidget(ReleaseListHelpers::createEntryForArtist(release, artist));
 	}
 }
 
-std::unique_ptr<Wt::WTemplate>
-Artist::createRelease(const Database::Artist::pointer& artist, const Release::pointer& release)
-{
-	auto entry = std::make_unique<Wt::WTemplate>(Wt::WString::tr("Lms.Explore.Artist.template.entry"));
-	entry->addFunction("tr", Wt::WTemplate::Functions::tr);
-
-	{
-		Wt::WAnchor* anchor = entry->bindWidget("cover", LmsApplication::createReleaseAnchor(release, false));
-
-		auto cover = std::make_unique<Wt::WImage>();
-		cover->setImageLink(LmsApp->getImageResource()->getReleaseUrl(release.id(), ImageResource::Size::Small));
-		cover->setStyleClass("Lms-cover");
-		anchor->setImage(std::move(cover));
-	}
-
-	entry->bindWidget("name", LmsApplication::createReleaseAnchor(release));
-
-	auto artists {release->getReleaseArtists()};
-	if (artists.empty())
-		artists = release->getArtists();
-
-	bool isSameArtist {(std::find(std::cbegin(artists), std::cend(artists), artist) != artists.end())};
-
-	if (artists.size() > 1)
-	{
-		entry->setCondition("if-has-artist", true);
-		entry->bindNew<Wt::WText>("artist", Wt::WString::tr("Lms.Explore.various-artists"));
-	}
-	else if (artists.size() == 1 && !isSameArtist)
-	{
-		entry->setCondition("if-has-artist", true);
-		entry->bindWidget("artist", LmsApplication::createArtistAnchor(artists.front()));
-	}
-
-	std::optional<int> year {release->getReleaseYear()};
-	if (year)
-	{
-		entry->setCondition("if-has-year", true);
-		entry->bindInt("year", *year);
-
-		std::optional<int> originalYear {release->getReleaseYear(true)};
-		if (originalYear && *originalYear != *year)
-		{
-			entry->setCondition("if-has-orig-year", true);
-			entry->bindInt("orig-year", *originalYear);
-		}
-	}
-
-	return entry;
-}
-
 void
 Artist::refreshSimilarArtists(const std::vector<Database::IdType>& similarArtistsId)
 {

src/lms/ui/explore/ArtistsView.cpp

@@ -140,7 +140,7 @@ Artists::getArtists(std::optional<Range> range, bool& moreResults)
 	if (modeLimit)
 	{
 		if (range)
-			range->limit = std::min(*modeLimit - range->offset, range->offset + range->limit);
+			range->limit = std::min(*modeLimit - range->offset, range->limit);
 		else
 			range = Range {0, *modeLimit};
 	}

src/lms/ui/explore/ReleaseListHelpers.cpp

@@ -23,6 +23,7 @@
 #include <Wt/WImage.h>
 #include <Wt/WText.h>
 
+#include "database/Artist.hpp"
 #include "database/Release.hpp"
 #include "resource/ImageResource.hpp"
 
@@ -35,7 +36,7 @@ namespace UserInterface::ReleaseListHelpers
 
 	static
 	std::unique_ptr<Wt::WTemplate>
-	createEntryInternal(const Database::Release::pointer& release, const std::string& templateKey)
+	createEntryInternal(const Release::pointer& release, const std::string& templateKey, const Artist::pointer& artist, const bool showYear)
 	{
 		auto entry {std::make_unique<Wt::WTemplate>(Wt::WString::tr(templateKey))};
 
@@ -43,7 +44,7 @@ namespace UserInterface::ReleaseListHelpers
 
 		Wt::WAnchor* anchor = entry->bindWidget("cover", LmsApplication::createReleaseAnchor(release, false));
 		auto cover = std::make_unique<Wt::WImage>();
-		cover->setImageLink(LmsApp->getImageResource()->getReleaseUrl(release.id(), ImageResource::Size::Small));
+		cover->setImageLink(LmsApp->getImageResource()->getReleaseUrl(release.id(), ImageResource::Size::Large));
 		cover->setStyleClass("Lms-cover");
 		anchor->setImage(std::move(cover));
 
@@ -51,30 +52,56 @@ namespace UserInterface::ReleaseListHelpers
 		if (artists.empty())
 			artists = release->getArtists();
 
+		bool isSameArtist {(std::find(std::cbegin(artists), std::cend(artists), artist) != artists.end())};
+
 		if (artists.size() > 1)
 		{
 			entry->setCondition("if-has-artist", true);
 			entry->bindNew<Wt::WText>("artist-name", Wt::WString::tr("Lms.Explore.various-artists"));
 		}
-		else if (artists.size() == 1)
+		else if (artists.size() == 1 && !isSameArtist)
 		{
 			entry->setCondition("if-has-artist", true);
 			entry->bindWidget("artist-name", LmsApplication::createArtistAnchor(artists.front()));
 		}
 
+		if (showYear)
+		{
+			if (std::optional<int> year {release->getReleaseYear()})
+			{
+				entry->setCondition("if-has-year", true);
+
+				std::string strYear {std::to_string(*year)};
+
+				std::optional<int> originalYear {release->getReleaseYear(true)};
+				if (originalYear && *originalYear != *year)
+				{
+					strYear += " (" + std::to_string(*originalYear) + ")";
+				}
+
+				entry->bindString("year", strYear);
+			}
+		}
+
 		return entry;
 	}
 
 	std::unique_ptr<Wt::WTemplate>
-	createEntry(const Release::pointer& release)
+	createEntry(const Release::pointer& release, const Artist::pointer& artist, bool showYear)
 	{
-		return createEntryInternal(release, "Lms.Explore.Releases.template.entry");
+		return createEntryInternal(release, "Lms.Explore.Releases.template.entry-grid", artist, showYear);
 	}
 
 	std::unique_ptr<Wt::WTemplate>
-	createEntrySmall(const Release::pointer& release)
+	createEntry(const Release::pointer& release)
 	{
-		return createEntryInternal(release, "Lms.Explore.Releases.template.entry-small");
+		return createEntry(release, Artist::pointer {}, false /*year*/);
+	}
+
+	std::unique_ptr<Wt::WTemplate>
+	createEntryForArtist(const Wt::Dbo::ptr<Database::Release>& release, const Wt::Dbo::ptr<Database::Artist>& artist)
+	{
+		return createEntry(release, artist, true);
 	}
 
 } // namespace UserInterface

src/lms/ui/explore/ReleaseListHelpers.hpp

@@ -25,13 +25,13 @@
 
 namespace Database
 {
+	class Artist;
 	class Release;
 }
 
 namespace UserInterface::ReleaseListHelpers
 {
-
-	std::unique_ptr<Wt::WTemplate> createEntrySmall(const Wt::Dbo::ptr<Database::Release>& release);
 	std::unique_ptr<Wt::WTemplate> createEntry(const Wt::Dbo::ptr<Database::Release>& release);
+	std::unique_ptr<Wt::WTemplate> createEntryForArtist(const Wt::Dbo::ptr<Database::Release>& release, const Wt::Dbo::ptr<Database::Artist>& artist);
 } // namespace UserInterface
 

src/lms/ui/explore/ReleaseView.cpp

@@ -76,7 +76,7 @@ Release::refreshView()
 	if (!releaseId)
 		return;
 
-	const std::vector<Database::IdType> similarReleasesIds {ServiceProvider<Recommendation::IEngine>::get()->getSimilarReleases(LmsApp->getDbSession(), *releaseId, 5)};
+	const std::vector<Database::IdType> similarReleasesIds {ServiceProvider<Recommendation::IEngine>::get()->getSimilarReleases(LmsApp->getDbSession(), *releaseId, 6)};
 
     auto transaction {LmsApp->getDbSession().createSharedTransaction()};
 
@@ -244,12 +244,12 @@ Release::refreshView()
 
 		entry->bindString("duration", trackDurationToString(track->getDuration()), Wt::TextFormat::Plain);
 
-		LmsApp->getMediaPlayer()->trackLoaded.connect(entry, [=] (Database::IdType loadedTrackId)
+		LmsApp->getMediaPlayer().trackLoaded.connect(entry, [=] (Database::IdType loadedTrackId)
 		{
 			entry->bindString("is-playing", loadedTrackId == trackId ? "Lms-entry-playing" : "");
 		});
 
-		if (auto trackIdLoaded {LmsApp->getMediaPlayer()->getTrackLoaded()})
+		if (auto trackIdLoaded {LmsApp->getMediaPlayer().getTrackLoaded()})
 		{
 			if (*trackIdLoaded == trackId)
 				entry->bindString("is-playing", "Lms-entry-playing");
@@ -313,7 +313,7 @@ Release::refreshSimilarReleases(const std::vector<Database::IdType>& similarRele
 		if (!similarRelease)
 			continue;
 
-		similarReleasesContainer->addWidget(ReleaseListHelpers::createEntrySmall(similarRelease));
+		similarReleasesContainer->addWidget(ReleaseListHelpers::createEntry(similarRelease));
 	}
 }
 

src/lms/ui/explore/ReleasesView.cpp

@@ -111,8 +111,9 @@ Releases::addSome()
 	bool moreResults {};
 
 	auto transaction {LmsApp->getDbSession().createSharedTransaction()};
+	const auto releases {getReleases(Range {static_cast<std::size_t>(_container->count()), batchSize}, moreResults)};
 
-	for (const Release::pointer& release : getReleases(Range {static_cast<std::size_t>(_container->count()), batchSize}, moreResults))
+	for (const Release::pointer& release : releases)
 	{
 		_container->addWidget(ReleaseListHelpers::createEntry(release));
 	}
@@ -154,7 +155,7 @@ Releases::getReleases(std::optional<Range> range, bool& moreResults)
 	if (modeLimit)
 	{
 		if (range)
-			range->limit = std::min(*modeLimit - range->offset, range->offset + range->limit);
+			range->limit = std::min(*modeLimit - range->offset, range->limit);
 		else
 			range = Range {0, *modeLimit};
 	}

src/lms/ui/explore/ReleasesView.hpp

@@ -63,7 +63,7 @@ class Releases : public Wt::WTemplate
 		std::vector<Database::IdType> getAllReleases();
 
 		static constexpr Mode defaultMode {Mode::Random};
-		static constexpr std::size_t batchSize {20};
+		static constexpr std::size_t batchSize {18};
 		static inline std::unordered_map<Mode, std::optional<std::size_t>> maxItemsPerMode
 		{
 			{Mode::Random, batchSize * 6},

src/lms/ui/explore/SearchView.cpp

@@ -29,63 +29,15 @@
 #include "resource/ImageResource.hpp"
 #include "ArtistListHelpers.hpp"
 #include "Filters.hpp"
-#include "ReleaseListHelpers.hpp"
 #include "LmsApplication.hpp"
+#include "ReleaseListHelpers.hpp"
+#include "TrackListHelpers.hpp"
 
-static constexpr std::size_t maxEntries {5};
+static constexpr std::size_t maxEntries {6};
 
 namespace UserInterface
 {
 
-	static
-	std::unique_ptr<Wt::WTemplate>
-	createTrack(const Database::Track::pointer& track)
-	{
-		auto entry {std::make_unique<Wt::WTemplate>(Wt::WString::tr("Lms.Explore.Search.template.track-entry"))};
-
-		entry->bindString("name", Wt::WString::fromUTF8(track->getName()), Wt::TextFormat::Plain);
-
-		auto artists {track->getArtists()};
-		auto release {track->getRelease()};
-		const auto trackId {track.id()};
-
-		if (!artists.empty() || release)
-			entry->setCondition("if-has-artists-or-release", true);
-
-		if (!artists.empty())
-		{
-			entry->setCondition("if-has-artists", true);
-
-			Wt::WContainerWidget* artistContainer {entry->bindNew<Wt::WContainerWidget>("artists")};
-			for (const auto& artist : artists)
-			{
-				Wt::WTemplate* a {artistContainer->addNew<Wt::WTemplate>(Wt::WString::tr("Lms.Explore.Tracks.template.entry-artist"))};
-				a->bindWidget("artist", LmsApplication::createArtistAnchor(artist));
-			}
-		}
-
-		if (track->getRelease())
-		{
-			entry->setCondition("if-has-release", true);
-			entry->bindWidget("release", LmsApplication::createReleaseAnchor(track->getRelease()));
-			{
-				Wt::WAnchor* anchor = entry->bindWidget("cover", LmsApplication::createReleaseAnchor(release, false));
-				auto cover = std::make_unique<Wt::WImage>();
-				cover->setImageLink(LmsApp->getImageResource()->getReleaseUrl(release.id(), ImageResource::Size::Small));
-				cover->setStyleClass("Lms-cover");
-				anchor->setImage(std::move(cover));
-			}
-		}
-		else
-		{
-			auto cover = entry->bindNew<Wt::WImage>("cover");
-			cover->setImageLink(LmsApp->getImageResource()->getTrackUrl(trackId, ImageResource::Size::Small));
-			cover->setStyleClass("Lms-cover");
-		}
-
-		return entry;
-	}
-
 	SearchView::SearchView(Filters* filters)
 	: Wt::WTemplate {Wt::WString::tr("Lms.Explore.Search.template")}
 	, _filters {filters}
@@ -175,7 +127,7 @@ namespace UserInterface
 			auto* container {bindNew<Wt::WContainerWidget>("tracks")};
 
 			for (const Database::Track::pointer& track : tracks)
-				container->addWidget(createTrack(track));
+				container->addWidget(TrackListHelpers::createEntry(track));
 		}
 	}
 

src/lms/ui/explore/TrackListHelpers.cpp

@@ -0,0 +1,117 @@
+/*
+ * Copyright (C) 2020 Emeric Poupon
+ *
+ * This file is part of LMS.
+ *
+ * LMS is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LMS is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "TrackListHelpers.hpp"
+
+#include <Wt/WAnchor.h>
+#include <Wt/WContainerWidget.h>
+#include <Wt/WImage.h>
+#include <Wt/WText.h>
+
+#include "database/Artist.hpp"
+#include "database/Release.hpp"
+#include "database/Track.hpp"
+#include "resource/ImageResource.hpp"
+#include "LmsApplication.hpp"
+#include "MediaPlayer.hpp"
+#include "PlayQueue.hpp"
+#include "TrackStringUtils.hpp"
+
+using namespace Database;
+
+namespace UserInterface::TrackListHelpers
+{
+	std::unique_ptr<Wt::WTemplate>
+	createEntry(const Wt::Dbo::ptr<Database::Track>& track)
+	{
+		auto entry {std::make_unique<Wt::WTemplate>(Wt::WString::tr("Lms.Explore.Tracks.template.entry"))};
+		auto* entryPtr {entry.get()};
+
+		entry->bindString("name", Wt::WString::fromUTF8(track->getName()), Wt::TextFormat::Plain);
+
+		const auto artists {track->getArtists()};
+		const Release::pointer release {track->getRelease()};
+		const IdType trackId {track.id()};
+
+		if (!artists.empty() || release)
+			entry->setCondition("if-has-artists-or-release", true);
+
+		if (!artists.empty())
+		{
+			entry->setCondition("if-has-artists", true);
+
+			Wt::WContainerWidget* artistContainer {entry->bindNew<Wt::WContainerWidget>("artists")};
+			for (const Artist::pointer& artist : artists)
+			{
+				Wt::WTemplate* a {artistContainer->addNew<Wt::WTemplate>(Wt::WString::tr("Lms.Explore.Tracks.template.entry-artist"))};
+				a->bindWidget("artist", LmsApplication::createArtistAnchor(artist));
+			}
+		}
+
+		if (track->getRelease())
+		{
+			entry->setCondition("if-has-release", true);
+			entry->bindWidget("release", LmsApplication::createReleaseAnchor(track->getRelease()));
+			{
+				Wt::WAnchor* anchor = entry->bindWidget("cover", LmsApplication::createReleaseAnchor(release, false));
+				auto cover = std::make_unique<Wt::WImage>();
+				cover->setImageLink(LmsApp->getImageResource()->getReleaseUrl(release.id(), ImageResource::Size::Large));
+				cover->setStyleClass("Lms-cover");
+				anchor->setImage(std::move(cover));
+			}
+		}
+		else
+		{
+			auto cover = entry->bindNew<Wt::WImage>("cover");
+			cover->setImageLink(LmsApp->getImageResource()->getTrackUrl(trackId, ImageResource::Size::Large));
+			cover->setStyleClass("Lms-cover");
+		}
+
+		entry->bindString("duration", trackDurationToString(track->getDuration()), Wt::TextFormat::Plain);
+
+		Wt::WText* playBtn = entry->bindNew<Wt::WText>("play-btn", Wt::WString::tr("Lms.Explore.template.play-btn"), Wt::TextFormat::XHTML);
+		playBtn->clicked().connect([=]
+		{
+			LmsApp->getPlayQueue().processTracks(PlayQueueAction::Play, {trackId});
+		});
+
+		Wt::WText* addBtn = entry->bindNew<Wt::WText>("add-btn", Wt::WString::tr("Lms.Explore.template.add-btn"), Wt::TextFormat::XHTML);
+		addBtn->clicked().connect([=]
+		{
+			LmsApp->getPlayQueue().processTracks(PlayQueueAction::AddLast, {trackId});
+		});
+
+		LmsApp->getMediaPlayer().trackLoaded.connect(entryPtr, [=] (Database::IdType loadedTrackId)
+		{
+			entryPtr->bindString("is-playing", loadedTrackId == trackId ? "Lms-entry-playing" : "");
+		});
+
+		if (auto trackIdLoaded {LmsApp->getMediaPlayer().getTrackLoaded()})
+		{
+			if (*trackIdLoaded == trackId)
+				entry->bindString("is-playing", "Lms-entry-playing");
+		}
+		else
+			entry->bindString("is-playing", "");
+
+		return entry;
+	}
+
+} // namespace UserInterface
+

src/lms/ui/explore/TrackListHelpers.hpp

@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2020 Emeric Poupon
+ *
+ * This file is part of LMS.
+ *
+ * LMS is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LMS is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <memory>
+
+#include <Wt/WTemplate.h>
+
+namespace Database
+{
+	class Track;
+}
+
+namespace UserInterface::TrackListHelpers
+{
+	std::unique_ptr<Wt::WTemplate> createEntry(const Wt::Dbo::ptr<Database::Track>& track);
+} // namespace UserInterface
+

src/lms/ui/explore/TracksView.cpp

@@ -37,6 +37,7 @@
 #include "Filters.hpp"
 #include "LmsApplication.hpp"
 #include "MediaPlayer.hpp"
+#include "TrackListHelpers.hpp"
 #include "TrackStringUtils.hpp"
 
 using namespace Database;
@@ -145,7 +146,7 @@ Tracks::getTracks(std::optional<Range> range, bool& moreResults)
 	if (modeLimit)
 	{
 		if (range)
-			range->limit = std::min(*modeLimit - range->offset, range->offset + range->limit);
+			range->limit = std::min(*modeLimit - range->offset, range->limit);
 		else
 			range = Range {0, *modeLimit};
 	}
@@ -194,82 +195,6 @@ Tracks::getAllTracks()
 	return res;
 }
 
-std::unique_ptr<Wt::WTemplate>
-Tracks::createEntry(const Track::pointer& track)
-{
-	auto entry {std::make_unique<Wt::WTemplate>(Wt::WString::tr("Lms.Explore.Tracks.template.entry"))};
-	auto* entryPtr {entry.get()};
-
-	entry->bindString("name", Wt::WString::fromUTF8(track->getName()), Wt::TextFormat::Plain);
-
-	auto artists {track->getArtists()};
-	auto release {track->getRelease()};
-	const auto trackId {track.id()};
-
-	if (!artists.empty() || release)
-		entry->setCondition("if-has-artists-or-release", true);
-
-	if (!artists.empty())
-	{
-		entry->setCondition("if-has-artists", true);
-
-		Wt::WContainerWidget* artistContainer {entry->bindNew<Wt::WContainerWidget>("artists")};
-		for (const auto& artist : artists)
-		{
-			Wt::WTemplate* a {artistContainer->addNew<Wt::WTemplate>(Wt::WString::tr("Lms.Explore.Tracks.template.entry-artist"))};
-			a->bindWidget("artist", LmsApplication::createArtistAnchor(artist));
-		}
-	}
-
-	if (track->getRelease())
-	{
-		entry->setCondition("if-has-release", true);
-		entry->bindWidget("release", LmsApplication::createReleaseAnchor(track->getRelease()));
-		{
-			Wt::WAnchor* anchor = entry->bindWidget("cover", LmsApplication::createReleaseAnchor(release, false));
-			auto cover = std::make_unique<Wt::WImage>();
-			cover->setImageLink(LmsApp->getImageResource()->getReleaseUrl(release.id(), ImageResource::Size::Small));
-			cover->setStyleClass("Lms-cover");
-			anchor->setImage(std::move(cover));
-		}
-	}
-	else
-	{
-		auto cover = entry->bindNew<Wt::WImage>("cover");
-		cover->setImageLink(LmsApp->getImageResource()->getTrackUrl(trackId, ImageResource::Size::Small));
-		cover->setStyleClass("Lms-cover");
-	}
-
-	entry->bindString("duration", trackDurationToString(track->getDuration()), Wt::TextFormat::Plain);
-
-	Wt::WText* playBtn = entry->bindNew<Wt::WText>("play-btn", Wt::WString::tr("Lms.Explore.template.play-btn"), Wt::TextFormat::XHTML);
-	playBtn->clicked().connect([=]
-	{
-		tracksAction.emit(PlayQueueAction::Play, {trackId});
-	});
-
-	Wt::WText* addBtn = entry->bindNew<Wt::WText>("add-btn", Wt::WString::tr("Lms.Explore.template.add-btn"), Wt::TextFormat::XHTML);
-	addBtn->clicked().connect([=]
-	{
-		tracksAction.emit(PlayQueueAction::AddLast, {trackId});
-	});
-
-	LmsApp->getMediaPlayer()->trackLoaded.connect(entryPtr, [=] (Database::IdType loadedTrackId)
-	{
-		entryPtr->bindString("is-playing", loadedTrackId == trackId ? "Lms-entry-playing" : "");
-	});
-
-	if (auto trackIdLoaded {LmsApp->getMediaPlayer()->getTrackLoaded()})
-	{
-		if (*trackIdLoaded == trackId)
-			entry->bindString("is-playing", "Lms-entry-playing");
-	}
-	else
-		entry->bindString("is-playing", "");
-
-	return entry;
-}
-
 void
 Tracks::addSome()
 {
@@ -278,7 +203,7 @@ Tracks::addSome()
 	bool moreResults;
 	for (const Track::pointer& track : getTracks(Range {static_cast<std::size_t>(_tracksContainer->count()), batchSize}, moreResults))
 	{
-		_tracksContainer->addWidget(createEntry(track));
+		_tracksContainer->addWidget(TrackListHelpers::createEntry(track));
 	}
 
 	_showMore->setHidden(!moreResults);

src/lms/ui/explore/TracksView.hpp

@@ -59,7 +59,6 @@ class Tracks : public Wt::WTemplate
 		void refreshView(Mode mode);
 		void addSome();
 
-		std::unique_ptr<Wt::WTemplate> createEntry(const Wt::Dbo::ptr<Database::Track>& track);
 		std::vector<Wt::Dbo::ptr<Database::Track>> getRandomTracks(std::optional<Database::Range> range, bool& moreResults);
 		std::vector<Wt::Dbo::ptr<Database::Track>> getTracks(std::optional<Database::Range> range, bool& moreResults);
 		std::vector<Database::IdType> getAllTracks();