Joren/qobuz-qt
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: resync with qbqt baseline and restore genre browser
Some checks failed
Build for Windows / build-windows (push) Has been cancelled
Details

Browse Source
This commit is contained in:
joren
2026-03-30 22:36:39 +02:00
parent 200ef39d04
commit 3346b424b3
26 changed files with 8533 additions and 446 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
src/CMakeLists.txt
View File

@@ -26,6 +26,8 @@ target_sources(qobuz-qt PRIVATE
view/artistlistview.hpp
view/artistview.hpp
view/artistview.cpp
view/genrebrowser.hpp
view/genrebrowser.cpp
view/sidepanel/view.hpp
view/sidepanel/view.cpp
@@ -56,3 +58,10 @@ target_sources(qobuz-qt PRIVATE
util/icon.hpp
util/settings.hpp
)
if (USE_DBUS)
target_sources(qobuz-qt PRIVATE
backend/mpris.hpp
backend/mpris.cpp
)
endif ()

29
src/backend/mpris.cpp Normal file
View File

@@ -0,0 +1,29 @@
#include "mpris.hpp"
#include <QDBusConnection>
#include <QCoreApplication>
#include <QProcess>
MprisRootAdaptor::MprisRootAdaptor(QObject *parent)
: QDBusAbstractAdaptor(parent)
{
}
MprisPlayerAdaptor::MprisPlayerAdaptor(QObject *parent)
: QDBusAbstractAdaptor(parent)
{
}
Mpris::Mpris(QObject *parent)
: QObject(parent)
{
m_root = new MprisRootAdaptor(this);
m_player = new MprisPlayerAdaptor(this);
QDBusConnection dbus = QDBusConnection::sessionBus();
QString serviceName = QString("org.mpris.MediaPlayer2.qobuz_qt.instance%1").arg(QCoreApplication::applicationPid());
dbus.registerService(serviceName);
dbus.registerObject("/org/mpris/MediaPlayer2", this,
QDBusConnection::ExportAdaptors);
}

165
src/backend/mpris.hpp Normal file
View File

@@ -0,0 +1,165 @@
#pragma once
#include <QObject>
#include <QString>
#include <QStringList>
#include <QVariantMap>
#include <QDBusAbstractAdaptor>
#include <QDBusObjectPath>
class MprisRootAdaptor : public QDBusAbstractAdaptor
{
Q_OBJECT
Q_CLASSINFO("D-Bus Interface", "org.mpris.MediaPlayer2")
Q_PROPERTY(bool CanQuit READ canQuit)
Q_PROPERTY(bool Fullscreen READ fullscreen WRITE setFullscreen)
Q_PROPERTY(bool CanSetFullscreen READ canSetFullscreen)
Q_PROPERTY(bool CanRaise READ canRaise)
Q_PROPERTY(bool HasTrackList READ hasTrackList)
Q_PROPERTY(QString Identity READ identity)
Q_PROPERTY(QString DesktopEntry READ desktopEntry)
Q_PROPERTY(QStringList SupportedUriSchemes READ supportedUriSchemes)
Q_PROPERTY(QStringList SupportedMimeTypes READ supportedMimeTypes)
public:
explicit MprisRootAdaptor(QObject *parent);
bool canQuit() const { return true; }
bool fullscreen() const { return false; }
void setFullscreen(bool) {}
bool canSetFullscreen() const { return false; }
bool canRaise() const { return true; }
bool hasTrackList() const { return false; }
QString identity() const { return "Qobuz"; }
QString desktopEntry() const { return "qobuz-qt"; }
QStringList supportedUriSchemes() const { return {}; }
QStringList supportedMimeTypes() const { return {}; }
public slots:
void Quit() { emit quitRequested(); }
void Raise() { emit raiseRequested(); }
signals:
void quitRequested();
void raiseRequested();
};
class MprisPlayerAdaptor : public QDBusAbstractAdaptor
{
Q_OBJECT
Q_CLASSINFO("D-Bus Interface", "org.mpris.MediaPlayer2.Player")
Q_PROPERTY(QString PlaybackStatus READ playbackStatus NOTIFY playbackStatusChanged)
Q_PROPERTY(QString LoopStatus READ loopStatus WRITE setLoopStatus)
Q_PROPERTY(double Rate READ rate WRITE setRate)
Q_PROPERTY(bool Shuffle READ shuffle WRITE setShuffle)
Q_PROPERTY(QVariantMap Metadata READ metadata NOTIFY metadataChanged)
Q_PROPERTY(double Volume READ volume WRITE setVolume NOTIFY volumeChanged)
Q_PROPERTY(qlonglong Position READ position)
Q_PROPERTY(double MinimumRate READ minimumRate)
Q_PROPERTY(double MaximumRate READ maximumRate)
Q_PROPERTY(bool CanGoNext READ canGoNext)
Q_PROPERTY(bool CanGoPrevious READ canGoPrevious)
Q_PROPERTY(bool CanPlay READ canPlay)
Q_PROPERTY(bool CanPause READ canPause)
Q_PROPERTY(bool CanSeek READ canSeek)
Q_PROPERTY(bool CanControl READ canControl)
public:
explicit MprisPlayerAdaptor(QObject *parent);
QString playbackStatus() const { return m_playbackStatus; }
void setPlaybackStatus(const QString &s) {
if (m_playbackStatus != s) {
m_playbackStatus = s;
emit playbackStatusChanged();
}
}
QString loopStatus() const { return "None"; }
void setLoopStatus(const QString &) {}
double rate() const { return 1.0; }
void setRate(double) {}
bool shuffle() const { return false; }
void setShuffle(bool) {}
QVariantMap metadata() const { return m_metadata; }
void setMetadata(const QVariantMap &m) {
m_metadata = m;
emit metadataChanged();
}
double volume() const { return m_volume; }
void setVolume(double v) {
emit volumeChangeRequested(v);
}
void updateVolume(double v) {
if (m_volume != v) {
m_volume = v;
emit volumeChanged();
}
}
qlonglong position() const { return m_positionMicro; }
void updatePosition(qlonglong posSecs) { m_positionMicro = posSecs * 1000000LL; }
double minimumRate() const { return 1.0; }
double maximumRate() const { return 1.0; }
bool canGoNext() const { return true; }
bool canGoPrevious() const { return true; }
bool canPlay() const { return true; }
bool canPause() const { return true; }
bool canSeek() const { return true; }
bool canControl() const { return true; }
public slots:
void Next() { emit nextRequested(); }
void Previous() { emit previousRequested(); }
void Pause() { emit pauseRequested(); }
void PlayPause() { emit playPauseRequested(); }
void Stop() { emit stopRequested(); }
void Play() { emit playRequested(); }
void Seek(qlonglong offset) { emit seekRequested(offset); }
void SetPosition(const QDBusObjectPath &trackId, qlonglong position) { Q_UNUSED(trackId); emit seekToRequested(position); }
void OpenUri(const QString &uri) { Q_UNUSED(uri); }
signals:
void playbackStatusChanged();
void metadataChanged();
void volumeChanged();
// Commands to MainWindow
void playRequested();
void pauseRequested();
void playPauseRequested();
void stopRequested();
void nextRequested();
void previousRequested();
void seekRequested(qlonglong offsetMicroseconds);
void seekToRequested(qlonglong positionMicroseconds);
void volumeChangeRequested(double volume);
private:
QString m_playbackStatus = "Stopped";
QVariantMap m_metadata;
double m_volume = 1.0;
qlonglong m_positionMicro = 0;
};
class Mpris : public QObject
{
Q_OBJECT
public:
explicit Mpris(QObject *parent = nullptr);
MprisRootAdaptor *root() const { return m_root; }
MprisPlayerAdaptor *player() const { return m_player; }
private:
MprisRootAdaptor *m_root;
MprisPlayerAdaptor *m_player;
};

26
src/backend/qobuzbackend.cpp
View File

@@ -51,11 +51,6 @@ void QobuzBackend::search(const QString &query, quint32 offset, quint32 limit)
qobuz_backend_search(m_backend, query.toUtf8().constData(), offset, limit);
}
void QobuzBackend::mostPopularSearch(const QString &query, quint32 limit)
{
qobuz_backend_most_popular_search(m_backend, query.toUtf8().constData(), limit);
}
void QobuzBackend::getAlbum(const QString &albumId)
{
qobuz_backend_get_album(m_backend, albumId.toUtf8().constData());
@@ -84,6 +79,16 @@ void QobuzBackend::getPlaylist(qint64 playlistId, quint32 offset, quint32 limit)
qobuz_backend_get_playlist(m_backend, playlistId, offset, limit);
}
void QobuzBackend::getGenres()
{
qobuz_backend_get_genres(m_backend);
}
void QobuzBackend::getFeaturedAlbums(qint64 genreId, const QString &kind, quint32 limit, quint32 offset)
{
qobuz_backend_get_featured_albums(m_backend, genreId, kind.toUtf8().constData(), limit, offset);
}
// ---- favorites ----
void QobuzBackend::getFavTracks(quint32 offset, quint32 limit)
@@ -222,7 +227,7 @@ void QobuzBackend::onPositionTick()
if (qobuz_backend_take_track_finished(m_backend))
emit trackFinished();
if (qobuz_backend_take_track_transitioned(m_backend))
emit trackTransitioned();
}
@@ -246,9 +251,6 @@ void QobuzBackend::onEvent(int eventType, const QString &json)
case EV_SEARCH_OK:
emit searchResult(obj);
break;
case 26: // EV_MOST_POPULAR_OK
emit mostPopularResult(obj);
break;
case EV_SEARCH_ERR:
emit error(obj["error"].toString());
break;
@@ -272,6 +274,12 @@ void QobuzBackend::onEvent(int eventType, const QString &json)
case 25: // EV_DEEP_SHUFFLE_OK
emit deepShuffleTracksLoaded(obj["tracks"].toArray());
break;
case 27: // EV_GENRES_OK
emit genresLoaded(obj);
break;
case 28: // EV_FEATURED_ALBUMS_OK
emit featuredAlbumsLoaded(obj);
break;
case EV_ARTIST_ERR:
emit error(obj["error"].toString());
break;

11
src/backend/qobuzbackend.hpp
View File

@@ -28,12 +28,13 @@ public:
// --- catalog ---
void search(const QString &query, quint32 offset = 0, quint32 limit = 20);
void mostPopularSearch(const QString &query, quint32 limit = 30);
void getAlbum(const QString &albumId);
void getArtist(qint64 artistId);
void getArtistReleases(qint64 artistId, const QString &releaseType, quint32 limit = 50, quint32 offset = 0);
void getAlbumsTracks(const QStringList &albumIds);
void getPlaylist(qint64 playlistId, quint32 offset = 0, quint32 limit = 500);
void getGenres();
void getFeaturedAlbums(qint64 genreId, const QString &kind, quint32 limit = 50, quint32 offset = 0);
// --- favorites ---
void getFavTracks(quint32 offset = 0, quint32 limit = 500);
@@ -82,11 +83,12 @@ signals:
// catalog
void searchResult(const QJsonObject &result);
void mostPopularResult(const QJsonObject &result);
void albumLoaded(const QJsonObject &album);
void artistLoaded(const QJsonObject &artist);
void artistReleasesLoaded(const QString &releaseType, const QJsonArray &items, bool hasMore, int offset);
void deepShuffleTracksLoaded(const QJsonArray &tracks);
void genresLoaded(const QJsonObject &result);
void featuredAlbumsLoaded(const QJsonObject &result);
void playlistLoaded(const QJsonObject &playlist);
void playlistCreated(const QJsonObject &playlist);
void playlistDeleted(const QJsonObject &result);
@@ -112,6 +114,11 @@ private slots:
Q_INVOKABLE void onEvent(int eventType, const QString &json);
void onPositionTick();
public:
void manuallyEmitTrackChanged(const QJsonObject &track) {
emit trackChanged(track);
}
private:
QobuzBackendOpaque *m_backend = nullptr;
QTimer *m_positionTimer = nullptr;

9
src/list/library.cpp
View File

@@ -20,6 +20,7 @@ enum NodeType {
NodeFavAlbums,
NodeFavArtists,
NodePlaylist,
NodeBrowseGenres,
};
Library::Library(QobuzBackend *backend, QWidget *parent)
@@ -71,6 +72,13 @@ void Library::buildStaticNodes()
// Playlists
m_playlistsNode = new QTreeWidgetItem(this, QStringList{tr("Playlists")});
m_playlistsNode->setExpanded(true);
// Browse
m_browseNode = new QTreeWidgetItem(this, QStringList{tr("Browse")});
m_browseNode->setExpanded(true);
auto *genresItem = new QTreeWidgetItem(m_browseNode, QStringList{tr("Genres")});
genresItem->setData(0, TypeRole, NodeBrowseGenres);
}
void Library::refresh()
@@ -167,6 +175,7 @@ void Library::onItemClicked(QTreeWidgetItem *item, int)
case NodeFavTracks: emit favTracksRequested(); break;
case NodeFavAlbums: emit favAlbumsRequested(); break;
case NodeFavArtists: emit favArtistsRequested(); break;
case NodeBrowseGenres: emit browseGenresRequested(); break;
case NodePlaylist: {
const qint64 id = item->data(0, IdRole).toLongLong();
const QString name = item->data(0, NameRole).toString();

2
src/list/library.hpp
View File

@@ -26,6 +26,7 @@ namespace List
void favTracksRequested();
void favAlbumsRequested();
void favArtistsRequested();
void browseGenresRequested();
void playlistRequested(qint64 playlistId, const QString &name);
/// Emitted after playlists are loaded so others can cache the list.
void userPlaylistsChanged(const QVector<QPair<qint64, QString>> &playlists);
@@ -43,6 +44,7 @@ namespace List
QTreeWidgetItem *m_myLibNode = nullptr;
QTreeWidgetItem *m_playlistsNode = nullptr;
QTreeWidgetItem *m_browseNode = nullptr;
qint64 m_openPlaylistId = 0;
void buildStaticNodes();

122
src/mainwindow.cpp
View File

@@ -4,6 +4,10 @@
#include "util/settings.hpp"
#include "util/icon.hpp"
#ifdef USE_DBUS
#include "backend/mpris.hpp"
#endif
#include <QApplication>
#include <QMenuBar>
#include <QMenu>
@@ -61,17 +65,37 @@ MainWindow::MainWindow(QobuzBackend *backend, QWidget *parent)
statusBar()->showMessage(tr("Ready"));
// ---- Scrobbler ----
m_scrobbler = new LastFmScrobbler(this);
connect(m_backend, &QobuzBackend::trackChanged,
m_scrobbler, &LastFmScrobbler::onTrackStarted);
connect(m_backend, &QobuzBackend::positionChanged,
m_scrobbler, &LastFmScrobbler::onPositionChanged);
connect(m_backend, &QobuzBackend::trackFinished,
m_scrobbler, &LastFmScrobbler::onTrackFinished);
m_scrobbler = new LastFmScrobbler(this);
connect(m_backend, &QobuzBackend::trackChanged,
m_scrobbler, &LastFmScrobbler::onTrackStarted);
connect(m_backend, &QobuzBackend::positionChanged,
m_scrobbler, &LastFmScrobbler::onPositionChanged);
connect(m_backend, &QobuzBackend::trackFinished,
m_scrobbler, &LastFmScrobbler::onTrackFinished);
// Scrobble the finished track during a gapless transition
connect(m_backend, &QobuzBackend::trackTransitioned,
m_scrobbler, &LastFmScrobbler::onTrackFinished);
// 1. Scrobble the finished track during a gapless transition
connect(m_backend, &QobuzBackend::trackTransitioned,
m_scrobbler, &LastFmScrobbler::onTrackFinished);
// ---- Gapless Signal ----
connect(m_backend, &QobuzBackend::positionChanged, this, [this](quint64 pos, quint64 dur) {
if (!AppSettings::instance().gaplessEnabled() || dur == 0) return;
// Trigger prefetch if we pass the 50% mark OR are within 60 seconds of the end
if ((pos > dur / 2) || (dur > 60 && (dur - pos) <= 60)) {
if (!m_nextTrackPrefetched && m_queue->canGoNext()) {
m_nextTrackPrefetched = true; // Lock it so it only fires once
const auto upcoming = m_queue->upcomingTracks(1);
if (!upcoming.isEmpty()) {
const qint64 nextId = static_cast<qint64>(upcoming.first()["id"].toDouble());
if (nextId > 0) {
m_backend->prefetchTrack(nextId, AppSettings::instance().preferredFormat());
}
}
}
}
});
// ---- Backend signals ----
connect(m_backend, &QobuzBackend::loginSuccess, this, &MainWindow::onLoginSuccess);
@@ -122,6 +146,52 @@ MainWindow::MainWindow(QobuzBackend *backend, QWidget *parent)
m_backend->getFavTracks();
statusBar()->showMessage(tr("Loading favorite tracks…"));
});
#ifdef USE_DBUS
m_mpris = new Mpris(this);
connect(m_mpris->player(), &MprisPlayerAdaptor::playRequested, m_backend, [this] {
if (m_backend->state() == 2) m_backend->resume();
});
connect(m_mpris->player(), &MprisPlayerAdaptor::pauseRequested, m_backend, &QobuzBackend::pause);
connect(m_mpris->player(), &MprisPlayerAdaptor::playPauseRequested, m_backend, [this] {
if (m_backend->state() == 1)
m_backend->pause();
else
m_backend->resume();
});
connect(m_mpris->player(), &MprisPlayerAdaptor::stopRequested, m_backend, &QobuzBackend::stop);
connect(m_mpris->player(), &MprisPlayerAdaptor::nextRequested, this, [this] {
if (!m_queue->canGoNext()) return;
const qint64 id = static_cast<qint64>(m_queue->advance()["id"].toDouble());
if (id > 0) m_backend->playTrack(id);
});
connect(m_mpris->player(), &MprisPlayerAdaptor::previousRequested, this, [this] {
if (!m_queue->canGoPrev()) return;
const qint64 id = static_cast<qint64>(m_queue->stepBack()["id"].toDouble());
if (id > 0) m_backend->playTrack(id);
});
connect(m_mpris->player(), &MprisPlayerAdaptor::seekRequested, m_backend, [this](qlonglong offsetMicroseconds) {
qint64 newPos = m_backend->position() + (offsetMicroseconds / 1000000LL);
if (newPos < 0) newPos = 0;
m_backend->seek(newPos);
});
connect(m_mpris->player(), &MprisPlayerAdaptor::seekToRequested, m_backend, [this](qlonglong positionMicroseconds) {
m_backend->seek(positionMicroseconds / 1000000LL);
});
connect(m_mpris->player(), &MprisPlayerAdaptor::volumeChangeRequested, m_backend, [this](double vol) {
m_backend->setVolume(vol * 100);
});
connect(m_backend, &QobuzBackend::stateChanged, this, [this](const QString &state) {
if (state == "playing") m_mpris->player()->setPlaybackStatus("Playing");
else if (state == "paused") m_mpris->player()->setPlaybackStatus("Paused");
else m_mpris->player()->setPlaybackStatus("Stopped");
});
connect(m_backend, &QobuzBackend::positionChanged, this, [this](quint64 pos) {
m_mpris->player()->updatePosition(pos);
});
#endif
connect(m_library, &List::Library::favAlbumsRequested, this, [this] {
m_backend->getFavAlbums();
statusBar()->showMessage(tr("Loading favorite albums…"));
@@ -136,6 +206,10 @@ MainWindow::MainWindow(QobuzBackend *backend, QWidget *parent)
m_backend->getPlaylist(id);
statusBar()->showMessage(tr("Loading playlist: %1…").arg(name));
});
connect(m_library, &List::Library::browseGenresRequested, this, [this] {
m_content->showGenreBrowser();
statusBar()->showMessage(tr("Browse Genres"));
});
// ---- Track list → playback / playlist management ----
connect(m_content->tracksList(), &List::Tracks::playTrackRequested,
@@ -289,6 +363,7 @@ void MainWindow::onLoginError(const QString &error)
void MainWindow::onTrackChanged(const QJsonObject &track)
{
m_nextTrackPrefetched = false;
// Update playing row highlight in the track list
const qint64 id = static_cast<qint64>(track["id"].toDouble());
m_content->tracksList()->setPlayingTrackId(id);
@@ -301,15 +376,25 @@ void MainWindow::onTrackChanged(const QJsonObject &track)
statusBar()->showMessage(
artist.isEmpty() ? title : QStringLiteral("▶ %1 — %2").arg(artist, title));
// Prefetch next track URL when gapless is enabled
if (AppSettings::instance().gaplessEnabled() && m_queue->canGoNext()) {
const auto upcoming = m_queue->upcomingTracks(1);
if (!upcoming.isEmpty()) {
const qint64 nextId = static_cast<qint64>(upcoming.first()["id"].toDouble());
if (nextId > 0)
m_backend->prefetchTrack(nextId, AppSettings::instance().preferredFormat());
}
#ifdef USE_DBUS
QVariantMap metadata;
metadata["mpris:trackid"] = QVariant::fromValue(QDBusObjectPath(QString("/org/qobuz/track/%1").arg(id)));
metadata["mpris:length"] = QVariant::fromValue(qlonglong(track["duration"].toDouble() * 1000000LL));
metadata["xesam:title"] = title;
QJsonObject album = track["album"].toObject();
metadata["xesam:album"] = album["title"].toString();
if (!artist.isEmpty()) {
metadata["xesam:artist"] = QStringList{artist};
}
if (album.contains("image") && album["image"].toObject().contains("large")) {
metadata["mpris:artUrl"] = album["image"].toObject()["large"].toString();
}
m_mpris->player()->setMetadata(metadata);
#endif
}
void MainWindow::onFavTracksLoaded(const QJsonObject &result)
@@ -420,4 +505,3 @@ void MainWindow::onUserPlaylistsChanged(const QVector<QPair<qint64, QString>> &p
m_content->tracksList()->setUserPlaylists(playlists);
m_sidePanel->searchTab()->setUserPlaylists(playlists);
}

6
src/mainwindow.hpp
View File

@@ -19,6 +19,8 @@
#include <QPair>
#include <QString>
class Mpris;
class MainWindow : public QMainWindow
{
Q_OBJECT
@@ -62,7 +64,9 @@ private:
QueuePanel *m_queuePanel = nullptr;
SidePanel::View *m_sidePanel = nullptr;
QDockWidget *m_libraryDock = nullptr;
LastFmScrobbler *m_scrobbler = nullptr;
LastFmScrobbler *m_scrobbler = nullptr;
Mpris *m_mpris = nullptr;
bool m_nextTrackPrefetched = false;
void setupMenuBar();
void tryRestoreSession();

2
src/view/albumlistview.hpp
View File

@@ -80,6 +80,7 @@ public:
const QString year = date.isEmpty()
? a["dates"].toObject()["original"].toString().left(4)
: date.left(4);
const qint64 artistId = static_cast<qint64>(a["artist"].toObject()["id"].toDouble());
const int tracks = a["tracks_count"].toInt();
const bool hiRes = a["hires_streamable"].toBool()
@@ -97,6 +98,7 @@ public:
item->setText(3, year);
item->setText(4, tracks > 0 ? QString::number(tracks) : QString());
item->setData(1, Qt::UserRole, id);
item->setData(2, Qt::UserRole, artistId);
}
}

122
src/view/genrebrowser.cpp Normal file
View File

@@ -0,0 +1,122 @@
#include "genrebrowser.hpp"
#include <QAction>
#include <QHBoxLayout>
#include <QLabel>
#include <QMenu>
#include <QTreeWidgetItem>
#include <QVBoxLayout>
GenreBrowserView::GenreBrowserView(QobuzBackend *backend, QWidget *parent)
: QWidget(parent)
, m_backend(backend)
{
auto *layout = new QVBoxLayout(this);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
auto *topBar = new QWidget(this);
auto *topLayout = new QHBoxLayout(topBar);
topLayout->setContentsMargins(8, 6, 8, 6);
topLayout->addWidget(new QLabel(tr("Genre:"), this));
m_genreCombo = new QComboBox(this);
m_genreCombo->setMinimumWidth(160);
topLayout->addWidget(m_genreCombo);
topLayout->addSpacing(16);
topLayout->addWidget(new QLabel(tr("Type:"), this));
m_typeCombo = new QComboBox(this);
m_typeCombo->addItem(tr("New Releases"), QStringLiteral("new-releases"));
m_typeCombo->addItem(tr("Best Sellers"), QStringLiteral("best-sellers"));
m_typeCombo->addItem(tr("Most Streamed"), QStringLiteral("most-streamed"));
m_typeCombo->addItem(tr("Editor Picks"), QStringLiteral("editor-picks"));
m_typeCombo->addItem(tr("Press Awards"), QStringLiteral("press-awards"));
topLayout->addWidget(m_typeCombo);
topLayout->addStretch();
layout->addWidget(topBar);
m_albumList = new AlbumListView(this);
m_albumList->setContextMenuPolicy(Qt::CustomContextMenu);
layout->addWidget(m_albumList, 1);
connect(m_backend, &QobuzBackend::genresLoaded,
this, &GenreBrowserView::onGenresLoaded);
connect(m_backend, &QobuzBackend::featuredAlbumsLoaded,
this, &GenreBrowserView::onFeaturedAlbumsLoaded);
connect(m_genreCombo, QOverload<int>::of(&QComboBox::currentIndexChanged),
this, &GenreBrowserView::onSelectionChanged);
connect(m_typeCombo, QOverload<int>::of(&QComboBox::currentIndexChanged),
this, &GenreBrowserView::onSelectionChanged);
connect(m_albumList, &AlbumListView::albumSelected,
this, &GenreBrowserView::albumSelected);
connect(m_albumList, &QTreeWidget::customContextMenuRequested,
this, &GenreBrowserView::onAlbumContextMenu);
}
void GenreBrowserView::ensureGenresLoaded()
{
if (!m_genresLoaded)
m_backend->getGenres();
}
void GenreBrowserView::onGenresLoaded(const QJsonObject &result)
{
m_genresLoaded = true;
m_genreCombo->blockSignals(true);
m_genreCombo->clear();
const QJsonArray items = result["items"].toArray();
for (const auto &value : items) {
const QJsonObject genre = value.toObject();
m_genreCombo->addItem(
genre["name"].toString(),
static_cast<qint64>(genre["id"].toDouble()));
}
m_genreCombo->blockSignals(false);
onSelectionChanged();
}
void GenreBrowserView::onFeaturedAlbumsLoaded(const QJsonObject &result)
{
m_albumList->setAlbums(result["items"].toArray());
}
void GenreBrowserView::onSelectionChanged()
{
if (m_genreCombo->count() == 0)
return;
const qint64 genreId = m_genreCombo->currentData().toLongLong();
const QString type = m_typeCombo->currentData().toString();
m_backend->getFeaturedAlbums(genreId, type, 50, 0);
}
void GenreBrowserView::onAlbumContextMenu(const QPoint &pos)
{
QTreeWidgetItem *item = m_albumList->itemAt(pos);
if (!item)
return;
const QString albumId = item->data(1, Qt::UserRole).toString();
const qint64 artistId = item->data(2, Qt::UserRole).toLongLong();
QMenu menu(this);
auto *openAlbum = menu.addAction(tr("Open Album"));
connect(openAlbum, &QAction::triggered, this, [this, albumId] {
emit albumSelected(albumId);
});
if (artistId > 0) {
auto *openArtist = menu.addAction(tr("Open Artist"));
connect(openArtist, &QAction::triggered, this, [this, artistId] {
emit artistSelected(artistId);
});
}
menu.exec(m_albumList->viewport()->mapToGlobal(pos));
}

36
src/view/genrebrowser.hpp Normal file
View File

@@ -0,0 +1,36 @@
#pragma once
#include "../backend/qobuzbackend.hpp"
#include "albumlistview.hpp"
#include <QComboBox>
#include <QJsonArray>
#include <QJsonObject>
#include <QWidget>
class GenreBrowserView : public QWidget
{
Q_OBJECT
public:
explicit GenreBrowserView(QobuzBackend *backend, QWidget *parent = nullptr);
void ensureGenresLoaded();
signals:
void albumSelected(const QString &albumId);
void artistSelected(qint64 artistId);
private slots:
void onGenresLoaded(const QJsonObject &result);
void onFeaturedAlbumsLoaded(const QJsonObject &result);
void onSelectionChanged();
void onAlbumContextMenu(const QPoint &pos);
private:
QobuzBackend *m_backend = nullptr;
QComboBox *m_genreCombo = nullptr;
QComboBox *m_typeCombo = nullptr;
AlbumListView *m_albumList = nullptr;
bool m_genresLoaded = false;
};

10
src/view/maincontent.cpp
View File

@@ -45,12 +45,14 @@ MainContent::MainContent(QobuzBackend *backend, PlayQueue *queue, QWidget *paren
m_albumList = new AlbumListView(this);
m_artistList = new ArtistListView(this);
m_artistView = new ArtistView(backend, queue, this);
m_genreBrowser = new GenreBrowserView(backend, this);
m_stack->addWidget(m_welcome); // 0
m_stack->addWidget(tracksPage); // 1
m_stack->addWidget(m_albumList); // 2
m_stack->addWidget(m_artistList); // 3
m_stack->addWidget(m_artistView); // 4
m_stack->addWidget(m_genreBrowser); // 5
m_stack->setCurrentIndex(0);
@@ -58,6 +60,8 @@ MainContent::MainContent(QobuzBackend *backend, PlayQueue *queue, QWidget *paren
connect(m_artistList, &ArtistListView::artistSelected, this, &MainContent::artistRequested);
connect(m_artistView, &ArtistView::albumSelected, this, &MainContent::albumRequested);
connect(m_artistView, &ArtistView::playTrackRequested, this, &MainContent::playTrackRequested);
connect(m_genreBrowser, &GenreBrowserView::albumSelected, this, &MainContent::albumRequested);
connect(m_genreBrowser, &GenreBrowserView::artistSelected, this, &MainContent::artistRequested);
}
void MainContent::showWelcome() { m_stack->setCurrentIndex(0); }
@@ -122,3 +126,9 @@ void MainContent::onDeepShuffleTracks(const QJsonArray &tracks)
{
m_artistView->onDeepShuffleTracks(tracks);
}
void MainContent::showGenreBrowser()
{
m_genreBrowser->ensureGenresLoaded();
m_stack->setCurrentIndex(5);
}

3
src/view/maincontent.hpp
View File

@@ -6,6 +6,7 @@
#include "albumlistview.hpp"
#include "artistlistview.hpp"
#include "artistview.hpp"
#include "genrebrowser.hpp"
#include "trackcontextheader.hpp"
#include <QWidget>
@@ -34,6 +35,7 @@ public:
void updateArtistReleases(const QString &releaseType, const QJsonArray &items, bool hasMore, int offset);
void setFavArtistIds(const QSet<qint64> &ids);
void onDeepShuffleTracks(const QJsonArray &tracks);
void showGenreBrowser();
ArtistView *artistView() const { return m_artistView; }
@@ -51,4 +53,5 @@ private:
AlbumListView *m_albumList = nullptr;
ArtistListView *m_artistList = nullptr;
ArtistView *m_artistView = nullptr;
GenreBrowserView *m_genreBrowser = nullptr;
};

12
src/view/maintoolbar.cpp
View File

@@ -117,6 +117,7 @@ MainToolBar::MainToolBar(QobuzBackend *backend, PlayQueue *queue, QWidget *paren
connect(m_backend, &QobuzBackend::trackChanged, this, &MainToolBar::onTrackChanged);
connect(m_backend, &QobuzBackend::positionChanged, this, &MainToolBar::onPositionChanged);
connect(m_backend, &QobuzBackend::trackFinished, this, &MainToolBar::onTrackFinished);
connect(m_backend, &QobuzBackend::trackTransitioned, this, &MainToolBar::onTrackTransitioned);
// ---- Queue signals ----
connect(m_queue, &PlayQueue::queueChanged, this, &MainToolBar::onQueueChanged);
@@ -249,6 +250,17 @@ void MainToolBar::onTrackFinished()
}
}
void MainToolBar::onTrackTransitioned()
{
if (m_queue->canGoNext()) {
const QJsonObject track = m_queue->advance();
setCurrentTrack(track);
m_backend->manuallyEmitTrackChanged(track);
} else {
onTrackFinished();
}
}
void MainToolBar::onQueueChanged()
{
m_previous->setEnabled(m_queue->canGoPrev());

1
src/view/maintoolbar.hpp
View File

@@ -44,6 +44,7 @@ private slots:
void onTrackChanged(const QJsonObject &track);
void onPositionChanged(quint64 position, quint64 duration);
void onTrackFinished();
void onTrackTransitioned();
void onQueueChanged();
void onShuffleToggled(bool checked);

180
src/view/sidepanel/view.cpp
View File

@@ -39,16 +39,6 @@ SearchTab::SearchTab(QobuzBackend *backend, PlayQueue *queue, QWidget *parent)
// Result tabs
m_resultTabs = new QTabWidget(this);
// Top Results tab (default) — mixed artists/albums/tracks from most-popular endpoint
m_popularResults = new QTreeWidget(this);
m_popularResults->setHeaderLabels({tr(""), tr("Name"), tr("Detail")});
m_popularResults->setRootIsDecorated(false);
m_popularResults->header()->setSectionResizeMode(0, QHeaderView::ResizeToContents);
m_popularResults->header()->setSectionResizeMode(1, QHeaderView::Stretch);
m_popularResults->header()->setSectionResizeMode(2, QHeaderView::Stretch);
m_popularResults->header()->setStretchLastSection(false);
m_popularResults->setContextMenuPolicy(Qt::CustomContextMenu);
m_trackResults = new QTreeWidget(this);
m_trackResults->setHeaderLabels({tr("Title"), tr("Artist"), tr("Album")});
m_trackResults->setRootIsDecorated(false);
@@ -67,26 +57,21 @@ SearchTab::SearchTab(QobuzBackend *backend, PlayQueue *queue, QWidget *parent)
m_artistResults->setHeaderLabels({tr("Artist")});
m_artistResults->setRootIsDecorated(false);
m_resultTabs->addTab(m_popularResults, tr("Top Results"));
m_resultTabs->addTab(m_trackResults, tr("Tracks"));
m_resultTabs->addTab(m_albumResults, tr("Albums"));
m_resultTabs->addTab(m_artistResults, tr("Artists"));
m_resultTabs->addTab(m_trackResults, tr("Tracks"));
m_resultTabs->addTab(m_albumResults, tr("Albums"));
m_resultTabs->addTab(m_artistResults, tr("Artists"));
layout->addWidget(m_resultTabs);
connect(searchBtn, &QPushButton::clicked, this, &SearchTab::onSearchSubmit);
connect(m_searchBox, &QLineEdit::returnPressed, this, &SearchTab::onSearchSubmit);
connect(m_backend, &QobuzBackend::searchResult, this, &SearchTab::onSearchResult);
connect(m_backend, &QobuzBackend::mostPopularResult, this, &SearchTab::onMostPopularResult);
connect(m_backend, &QobuzBackend::searchResult, this, &SearchTab::onSearchResult);
connect(m_popularResults, &QTreeWidget::itemDoubleClicked, this, &SearchTab::onItemDoubleClicked);
connect(m_trackResults, &QTreeWidget::itemDoubleClicked, this, &SearchTab::onItemDoubleClicked);
connect(m_albumResults, &QTreeWidget::itemDoubleClicked, this, &SearchTab::onItemDoubleClicked);
connect(m_artistResults, &QTreeWidget::itemDoubleClicked, this, &SearchTab::onItemDoubleClicked);
connect(m_trackResults, &QTreeWidget::itemDoubleClicked, this, &SearchTab::onItemDoubleClicked);
connect(m_albumResults, &QTreeWidget::itemDoubleClicked, this, &SearchTab::onItemDoubleClicked);
connect(m_artistResults, &QTreeWidget::itemDoubleClicked, this, &SearchTab::onItemDoubleClicked);
// Context menus
connect(m_popularResults, &QTreeWidget::customContextMenuRequested,
this, &SearchTab::onPopularContextMenu);
connect(m_trackResults, &QTreeWidget::customContextMenuRequested,
this, &SearchTab::onTrackContextMenu);
connect(m_albumResults, &QTreeWidget::customContextMenuRequested,
@@ -101,10 +86,8 @@ void SearchTab::setUserPlaylists(const QVector<QPair<qint64, QString>> &playlist
void SearchTab::onSearchSubmit()
{
const QString q = m_searchBox->text().trimmed();
if (q.isEmpty()) return;
m_backend->mostPopularSearch(q, 30);
m_backend->search(q, 0, 20);
m_resultTabs->setCurrentIndex(0); // show Top Results tab
if (!q.isEmpty())
m_backend->search(q, 0, 20);
}
void SearchTab::onSearchResult(const QJsonObject &result)
@@ -162,62 +145,6 @@ void SearchTab::onSearchResult(const QJsonObject &result)
}
}
void SearchTab::onMostPopularResult(const QJsonObject &result)
{
m_popularResults->clear();
QFont badgeFont;
badgeFont.setBold(true);
badgeFont.setPointSizeF(badgeFont.pointSizeF() * 0.8);
const QJsonArray items = result["most_popular"].toObject()["items"].toArray();
for (const auto &v : items) {
const QJsonObject entry = v.toObject();
const QString type = entry["type"].toString();
const QJsonObject content = entry["content"].toObject();
QString badge, name, detail;
QColor badgeColor;
if (type == QStringLiteral("artists")) {
badge = QStringLiteral("A");
badgeColor = QColor(QStringLiteral("#6699CC"));
name = content["name"].toString();
detail = tr("%1 albums").arg(static_cast<int>(content["albums_count"].toDouble()));
} else if (type == QStringLiteral("albums")) {
const bool hiRes = content["hires_streamable"].toBool();
badge = hiRes ? QStringLiteral("H") : QStringLiteral("A");
badgeColor = hiRes ? QColor(QStringLiteral("#FFB232")) : QColor(QStringLiteral("#AAAAAA"));
name = content["title"].toString();
detail = content["artist"].toObject()["name"].toString();
} else if (type == QStringLiteral("tracks")) {
badge = QStringLiteral("T");
badgeColor = QColor(QStringLiteral("#66BB66"));
name = content["title"].toString();
detail = content["performer"].toObject()["name"].toString();
} else {
continue;
}
auto *item = new QTreeWidgetItem(m_popularResults, QStringList{badge, name, detail});
item->setForeground(0, badgeColor);
item->setFont(0, badgeFont);
item->setTextAlignment(0, Qt::AlignCenter);
item->setData(0, TypeRole, type == QStringLiteral("artists") ? QStringLiteral("artist")
: type == QStringLiteral("albums") ? QStringLiteral("album")
: QStringLiteral("track"));
item->setData(0, JsonRole, content);
if (type == QStringLiteral("artists")) {
item->setData(0, IdRole, static_cast<qint64>(content["id"].toDouble()));
} else if (type == QStringLiteral("albums")) {
item->setData(1, IdRole, content["id"].toString());
} else {
item->setData(0, IdRole, static_cast<qint64>(content["id"].toDouble()));
}
}
}
void SearchTab::onItemDoubleClicked(QTreeWidgetItem *item, int)
{
if (!item) return;
@@ -226,10 +153,7 @@ void SearchTab::onItemDoubleClicked(QTreeWidgetItem *item, int)
if (type == QStringLiteral("track")) {
emit trackPlayRequested(item->data(0, IdRole).toLongLong());
} else if (type == QStringLiteral("album")) {
// Album ID may be in col 0 or col 1 depending on which tree it came from
QString albumId = item->data(1, IdRole).toString();
if (albumId.isEmpty()) albumId = item->data(0, IdRole).toString();
emit albumSelected(albumId);
emit albumSelected(item->data(1, IdRole).toString());
} else if (type == QStringLiteral("artist")) {
emit artistSelected(item->data(0, IdRole).toLongLong());
}
@@ -344,90 +268,6 @@ void SearchTab::onAlbumContextMenu(const QPoint &pos)
menu.exec(m_albumResults->viewport()->mapToGlobal(pos));
}
void SearchTab::onPopularContextMenu(const QPoint &pos)
{
auto *item = m_popularResults->itemAt(pos);
if (!item) return;
const QString type = item->data(0, TypeRole).toString();
const QJsonObject json = item->data(0, JsonRole).toJsonObject();
QMenu menu(this);
if (type == QStringLiteral("track")) {
const qint64 trackId = item->data(0, IdRole).toLongLong();
if (trackId <= 0) return;
auto *playNow = menu.addAction(tr("Play now"));
auto *playNext = menu.addAction(tr("Play next"));
auto *addQueue = menu.addAction(tr("Add to queue"));
menu.addSeparator();
auto *addFav = menu.addAction(tr("Add to favorites"));
const QString albumId = json["album"].toObject()["id"].toString();
const qint64 artistId = static_cast<qint64>(json["performer"].toObject()["id"].toDouble());
const QString albumTitle = json["album"].toObject()["title"].toString();
const QString artistName = json["performer"].toObject()["name"].toString();
menu.addSeparator();
if (!albumId.isEmpty()) {
auto *openAlbum = menu.addAction(tr("Go to album: %1").arg(QString(albumTitle).replace(QLatin1Char('&'), QStringLiteral("&&"))));
connect(openAlbum, &QAction::triggered, this, [this, albumId] { emit albumSelected(albumId); });
}
if (artistId > 0) {
auto *openArtist = menu.addAction(tr("Go to artist: %1").arg(QString(artistName).replace(QLatin1Char('&'), QStringLiteral("&&"))));
connect(openArtist, &QAction::triggered, this, [this, artistId] { emit artistSelected(artistId); });
}
if (!m_userPlaylists.isEmpty()) {
menu.addSeparator();
auto *plMenu = menu.addMenu(tr("Add to playlist"));
for (const auto &pl : m_userPlaylists) {
auto *act = plMenu->addAction(pl.second);
connect(act, &QAction::triggered, this, [this, trackId, plId = pl.first] {
emit addToPlaylistRequested(trackId, plId);
});
}
}
menu.addSeparator();
auto *info = menu.addAction(tr("Track info..."));
connect(playNow, &QAction::triggered, this, [this, trackId] { emit trackPlayRequested(trackId); });
connect(playNext, &QAction::triggered, this, [this, json] { m_queue->playNext(json); });
connect(addQueue, &QAction::triggered, this, [this, json] { m_queue->addToQueue(json); });
connect(addFav, &QAction::triggered, this, [this, trackId] { m_backend->addFavTrack(trackId); });
connect(info, &QAction::triggered, this, [this, json] { showTrackInfo(json); });
} else if (type == QStringLiteral("album")) {
const QString albumId = item->data(1, IdRole).toString();
if (albumId.isEmpty()) return;
auto *openAlbum = menu.addAction(tr("Open album"));
auto *addFav = menu.addAction(tr("Add to favorites"));
const qint64 artistId = static_cast<qint64>(json["artist"].toObject()["id"].toDouble());
const QString artistName = json["artist"].toObject()["name"].toString();
if (artistId > 0) {
menu.addSeparator();
auto *openArtist = menu.addAction(tr("Go to artist: %1").arg(QString(artistName).replace(QLatin1Char('&'), QStringLiteral("&&"))));
connect(openArtist, &QAction::triggered, this, [this, artistId] { emit artistSelected(artistId); });
}
connect(openAlbum, &QAction::triggered, this, [this, albumId] { emit albumSelected(albumId); });
connect(addFav, &QAction::triggered, this, [this, albumId] { m_backend->addFavAlbum(albumId); });
} else if (type == QStringLiteral("artist")) {
const qint64 artistId = item->data(0, IdRole).toLongLong();
if (artistId <= 0) return;
auto *openArtist = menu.addAction(tr("Go to artist"));
connect(openArtist, &QAction::triggered, this, [this, artistId] { emit artistSelected(artistId); });
}
if (!menu.isEmpty())
menu.exec(m_popularResults->viewport()->mapToGlobal(pos));
}
void SearchTab::showTrackInfo(const QJsonObject &track)
{
TrackInfoDialog::show(track, this);

3
src/view/sidepanel/view.hpp
View File

@@ -30,7 +30,6 @@ namespace SidePanel
private slots:
void onSearchResult(const QJsonObject &result);
void onMostPopularResult(const QJsonObject &result);
void onSearchSubmit();
void onItemDoubleClicked(QTreeWidgetItem *item, int column);
@@ -39,7 +38,6 @@ namespace SidePanel
PlayQueue *m_queue = nullptr;
QLineEdit *m_searchBox = nullptr;
QTabWidget *m_resultTabs = nullptr;
QTreeWidget *m_popularResults = nullptr;
QTreeWidget *m_trackResults = nullptr;
QTreeWidget *m_albumResults = nullptr;
QTreeWidget *m_artistResults = nullptr;
@@ -47,7 +45,6 @@ namespace SidePanel
void onTrackContextMenu(const QPoint &pos);
void onAlbumContextMenu(const QPoint &pos);
void onPopularContextMenu(const QPoint &pos);
void showTrackInfo(const QJsonObject &track);
};