Add artist biography

CMakeLists.txt

@@ -379,13 +379,6 @@ optional_component(STREAMTAGREADER ON "Stream tagreader"
 
 optional_component(DISCORD_RPC ON "Discord Rich Presence"
   DEPENDS "RapidJSON" RapidJSON_FOUND
-
-optional_component(DROPBOX ON "Streaming: Dropbox"
-  DEPENDS "Stream tagreader" HAVE_STREAMTAGREADER
-)
-
-optional_component(ONEDRIVE ON "Streaming: OneDrive"
-  DEPENDS "Stream tagreader" HAVE_STREAMTAGREADER
 )
 
 if(HAVE_SONGFINGERPRINTING OR HAVE_MUSICBRAINZ)
@@ -783,7 +776,6 @@ set(SOURCES
   src/streaming/streamingcollectionviewcontainer.cpp
   src/streaming/streamingsearchview.cpp
   src/streaming/streamsongmimedata.cpp
-  src/streaming/cloudstoragestreamingservice.cpp
 
   src/radios/radioservices.cpp
   src/radios/radiobackend.cpp
@@ -842,6 +834,12 @@ set(SOURCES
   src/device/devicestatefiltermodel.cpp
   src/device/deviceviewcontainer.cpp
   src/device/deviceview.cpp
+
+  src/artistbio/artistbioview.cpp
+  src/artistbio/artistbiofetcher.cpp
+  src/artistbio/artistbioprovider.cpp
+  src/artistbio/lastfmartistbio.cpp
+  src/artistbio/wikipediaartistbio.cpp
 )
 
 set(HEADERS
@@ -1080,7 +1078,6 @@ set(HEADERS
   src/streaming/streamingtabsview.h
   src/streaming/streamingcollectionview.h
   src/streaming/streamingcollectionviewcontainer.h
-  src/streaming/cloudstoragestreamingservice.h
 
   src/radios/radioservices.h
   src/radios/radiobackend.h
@@ -1131,6 +1128,12 @@ set(HEADERS
   src/device/devicestatefiltermodel.h
   src/device/deviceviewcontainer.h
   src/device/deviceview.h
+
+  src/artistbio/artistbiofetcher.h
+  src/artistbio/artistbioprovider.h
+  src/artistbio/artistbioview.h
+  src/artistbio/lastfmartistbio.h
+  src/artistbio/wikipediaartistbio.h
 )
 
 set(UI
@@ -1489,25 +1492,6 @@ optional_source(HAVE_QOBUZ
     src/settings/qobuzsettingspage.ui
 )
 
-optional_source(HAVE_DROPBOX
-  SOURCES
-    src/dropbox/dropboxservice.cpp
-    src/dropbox/dropboxurlhandler.cpp
-    src/dropbox/dropboxbaserequest.cpp
-    src/dropbox/dropboxsongsrequest.cpp
-    src/dropbox/dropboxstreamurlrequest.cpp
-    src/settings/dropboxsettingspage.cpp
-  HEADERS
-    src/dropbox/dropboxservice.h
-    src/dropbox/dropboxurlhandler.h
-    src/dropbox/dropboxbaserequest.h
-    src/dropbox/dropboxsongsrequest.h
-    src/dropbox/dropboxstreamurlrequest.h
-    src/settings/dropboxsettingspage.h
-  UI
-    src/settings/dropboxsettingspage.ui
-)
-
 qt_wrap_cpp(SOURCES ${HEADERS})
 qt_wrap_ui(SOURCES ${UI})
 qt_add_resources(SOURCES data/data.qrc data/icons.qrc)

data/data.qrc

@@ -15,6 +15,7 @@
         <file>schema/schema-21.sql</file>
         <file>schema/device-schema.sql</file>
         <file>style/strawberry.css</file>
+        <file>style/artistbio.css</file>
         <file>style/smartplaylistsearchterm.css</file>
         <file>html/oauthsuccess.html</file>
         <file>pictures/strawberry.png</file>

data/icons.qrc

@@ -98,7 +98,7 @@
         <file>icons/128x128/somafm.png</file>
         <file>icons/128x128/radioparadise.png</file>
         <file>icons/128x128/musicbrainz.png</file>
-        <file>icons/128x128/dropbox.png</file>
+        <file>icons/128x128/guitar.png</file>
         <file>icons/64x64/albums.png</file>
         <file>icons/64x64/alsa.png</file>
         <file>icons/64x64/application-exit.png</file>
@@ -198,7 +198,7 @@
         <file>icons/64x64/somafm.png</file>
         <file>icons/64x64/radioparadise.png</file>
         <file>icons/64x64/musicbrainz.png</file>
-        <file>icons/64x64/dropbox.png</file>
+        <file>icons/64x64/guitar.png</file>
         <file>icons/48x48/albums.png</file>
         <file>icons/48x48/alsa.png</file>
         <file>icons/48x48/application-exit.png</file>
@@ -302,7 +302,7 @@
         <file>icons/48x48/somafm.png</file>
         <file>icons/48x48/radioparadise.png</file>
         <file>icons/48x48/musicbrainz.png</file>
-        <file>icons/48x48/dropbox.png</file>
+        <file>icons/48x48/guitar.png</file>
         <file>icons/32x32/albums.png</file>
         <file>icons/32x32/alsa.png</file>
         <file>icons/32x32/application-exit.png</file>
@@ -406,7 +406,7 @@
         <file>icons/32x32/somafm.png</file>
         <file>icons/32x32/radioparadise.png</file>
         <file>icons/32x32/musicbrainz.png</file>
-        <file>icons/32x32/dropbox.png</file>
+        <file>icons/32x32/guitar.png</file>
         <file>icons/22x22/albums.png</file>
         <file>icons/22x22/alsa.png</file>
         <file>icons/22x22/application-exit.png</file>
@@ -510,6 +510,6 @@
         <file>icons/22x22/somafm.png</file>
         <file>icons/22x22/radioparadise.png</file>
         <file>icons/22x22/musicbrainz.png</file>
-        <file>icons/22x22/dropbox.png</file>
+        <file>icons/22x22/guitar.png</file>
     </qresource>
 </RCC>

data/schema/schema-22.sql

@@ -1,82 +0,0 @@
-CREATE TABLE IF NOT EXISTS dropbox_songs (
-
-  title TEXT,
-  album TEXT,
-  artist TEXT,
-  albumartist TEXT,
-  track INTEGER NOT NULL DEFAULT -1,
-  disc INTEGER NOT NULL DEFAULT -1,
-  year INTEGER NOT NULL DEFAULT -1,
-  originalyear INTEGER NOT NULL DEFAULT -1,
-  genre TEXT,
-  compilation INTEGER NOT NULL DEFAULT 0,
-  composer TEXT,
-  performer TEXT,
-  grouping TEXT,
-  comment TEXT,
-  lyrics TEXT,
-
-  artist_id TEXT,
-  album_id TEXT,
-  song_id TEXT,
-
-  beginning INTEGER NOT NULL DEFAULT 0,
-  length INTEGER NOT NULL DEFAULT 0,
-
-  bitrate INTEGER NOT NULL DEFAULT -1,
-  samplerate INTEGER NOT NULL DEFAULT -1,
-  bitdepth INTEGER NOT NULL DEFAULT -1,
-
-  source INTEGER NOT NULL DEFAULT 0,
-  directory_id INTEGER NOT NULL DEFAULT -1,
-  url TEXT NOT NULL,
-  filetype INTEGER NOT NULL DEFAULT 0,
-  filesize INTEGER NOT NULL DEFAULT -1,
-  mtime INTEGER NOT NULL DEFAULT -1,
-  ctime INTEGER NOT NULL DEFAULT -1,
-  unavailable INTEGER DEFAULT 0,
-
-  fingerprint TEXT,
-
-  playcount INTEGER NOT NULL DEFAULT 0,
-  skipcount INTEGER NOT NULL DEFAULT 0,
-  lastplayed INTEGER NOT NULL DEFAULT -1,
-  lastseen INTEGER NOT NULL DEFAULT -1,
-
-  compilation_detected INTEGER DEFAULT 0,
-  compilation_on INTEGER NOT NULL DEFAULT 0,
-  compilation_off INTEGER NOT NULL DEFAULT 0,
-  compilation_effective INTEGER NOT NULL DEFAULT 0,
-
-  art_embedded INTEGER DEFAULT 0,
-  art_automatic TEXT,
-  art_manual TEXT,
-  art_unset INTEGER DEFAULT 0,
-
-  effective_albumartist TEXT,
-  effective_originalyear INTEGER NOT NULL DEFAULT 0,
-
-  cue_path TEXT,
-
-  rating INTEGER DEFAULT -1,
-
-  acoustid_id TEXT,
-  acoustid_fingerprint TEXT,
-
-  musicbrainz_album_artist_id TEXT,
-  musicbrainz_artist_id TEXT,
-  musicbrainz_original_artist_id TEXT,
-  musicbrainz_album_id TEXT,
-  musicbrainz_original_album_id TEXT,
-  musicbrainz_recording_id TEXT,
-  musicbrainz_track_id TEXT,
-  musicbrainz_disc_id TEXT,
-  musicbrainz_release_group_id TEXT,
-  musicbrainz_work_id TEXT,
-
-  ebur128_integrated_loudness_lufs REAL,
-  ebur128_loudness_range_lu REAL
-
-);
-
-UPDATE schema_version SET version=22;

data/schema/schema.sql

@@ -1018,87 +1018,6 @@ CREATE TABLE IF NOT EXISTS qobuz_songs (
 
 );
 
-CREATE TABLE IF NOT EXISTS dropbox_songs (
-
-  title TEXT,
-  album TEXT,
-  artist TEXT,
-  albumartist TEXT,
-  track INTEGER NOT NULL DEFAULT -1,
-  disc INTEGER NOT NULL DEFAULT -1,
-  year INTEGER NOT NULL DEFAULT -1,
-  originalyear INTEGER NOT NULL DEFAULT -1,
-  genre TEXT,
-  compilation INTEGER NOT NULL DEFAULT 0,
-  composer TEXT,
-  performer TEXT,
-  grouping TEXT,
-  comment TEXT,
-  lyrics TEXT,
-
-  artist_id TEXT,
-  album_id TEXT,
-  song_id TEXT,
-
-  beginning INTEGER NOT NULL DEFAULT 0,
-  length INTEGER NOT NULL DEFAULT 0,
-
-  bitrate INTEGER NOT NULL DEFAULT -1,
-  samplerate INTEGER NOT NULL DEFAULT -1,
-  bitdepth INTEGER NOT NULL DEFAULT -1,
-
-  source INTEGER NOT NULL DEFAULT 0,
-  directory_id INTEGER NOT NULL DEFAULT -1,
-  url TEXT NOT NULL,
-  filetype INTEGER NOT NULL DEFAULT 0,
-  filesize INTEGER NOT NULL DEFAULT -1,
-  mtime INTEGER NOT NULL DEFAULT -1,
-  ctime INTEGER NOT NULL DEFAULT -1,
-  unavailable INTEGER DEFAULT 0,
-
-  fingerprint TEXT,
-
-  playcount INTEGER NOT NULL DEFAULT 0,
-  skipcount INTEGER NOT NULL DEFAULT 0,
-  lastplayed INTEGER NOT NULL DEFAULT -1,
-  lastseen INTEGER NOT NULL DEFAULT -1,
-
-  compilation_detected INTEGER DEFAULT 0,
-  compilation_on INTEGER NOT NULL DEFAULT 0,
-  compilation_off INTEGER NOT NULL DEFAULT 0,
-  compilation_effective INTEGER NOT NULL DEFAULT 0,
-
-  art_embedded INTEGER DEFAULT 0,
-  art_automatic TEXT,
-  art_manual TEXT,
-  art_unset INTEGER DEFAULT 0,
-
-  effective_albumartist TEXT,
-  effective_originalyear INTEGER NOT NULL DEFAULT 0,
-
-  cue_path TEXT,
-
-  rating INTEGER DEFAULT -1,
-
-  acoustid_id TEXT,
-  acoustid_fingerprint TEXT,
-
-  musicbrainz_album_artist_id TEXT,
-  musicbrainz_artist_id TEXT,
-  musicbrainz_original_artist_id TEXT,
-  musicbrainz_album_id TEXT,
-  musicbrainz_original_album_id TEXT,
-  musicbrainz_recording_id TEXT,
-  musicbrainz_track_id TEXT,
-  musicbrainz_disc_id TEXT,
-  musicbrainz_release_group_id TEXT,
-  musicbrainz_work_id TEXT,
-
-  ebur128_integrated_loudness_lufs REAL,
-  ebur128_loudness_range_lu REAL
-
-);
-
 CREATE TABLE IF NOT EXISTS playlists (
 
   name TEXT NOT NULL,

data/style/artistbio.css

@@ -0,0 +1,7 @@
+QScrollArea {
+  background: qpalette(base);
+}
+
+QTextEdit {
+  border: 0px;
+}

src/artistbio/artistbiofetcher.cpp

@@ -0,0 +1,126 @@
+/*
+ * Strawberry Music Player
+ * This file was part of Clementine.
+ * Copyright 2010, David Sansome <me@davidsansome.com>
+ *
+ * Strawberry 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.
+ *
+ * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <QObject>
+#include <QTimer>
+#include <QUrl>
+
+#include "artistbiofetcher.h"
+#include "artistbioprovider.h"
+#include "core/logging.h"
+
+ArtistBioFetcher::ArtistBioFetcher(QObject *parent)
+    : QObject(parent),
+      timeout_duration_(kDefaultTimeoutDuration),
+      next_id_(1) {}
+
+void ArtistBioFetcher::AddProvider(ArtistBioProvider *provider) {
+
+  providers_ << provider;
+  connect(provider, SIGNAL(ImageReady(int, QUrl)), SLOT(ImageReady(int, QUrl)), Qt::QueuedConnection);
+  connect(provider, SIGNAL(InfoReady(int, CollapsibleInfoPane::Data)), SLOT(InfoReady(int, CollapsibleInfoPane::Data)), Qt::QueuedConnection);
+  connect(provider, SIGNAL(Finished(int)), SLOT(ProviderFinished(int)), Qt::QueuedConnection);
+
+}
+
+ArtistBioFetcher::~ArtistBioFetcher() {
+
+  while (!providers_.isEmpty()) {
+    ArtistBioProvider *provider = providers_.takeFirst();
+    provider->deleteLater();
+  }
+
+}
+
+int ArtistBioFetcher::FetchInfo(const Song &metadata) {
+
+  const int id = next_id_++;
+  results_[id] = Result();
+  timeout_timers_[id] = new QTimer(this);
+  timeout_timers_[id]->setSingleShot(true);
+  timeout_timers_[id]->setInterval(timeout_duration_);
+  timeout_timers_[id]->start();
+
+  connect(timeout_timers_[id], &QTimer::timeout, [this, id]() { Timeout(id); });
+
+  for (ArtistBioProvider *provider : providers_) {
+    if (provider->is_enabled()) {
+      waiting_for_[id].append(provider);
+      provider->Start(id, metadata);
+    }
+  }
+  return id;
+
+}
+
+void ArtistBioFetcher::ImageReady(const int id, const QUrl &url) {
+
+  if (!results_.contains(id)) return;
+  results_[id].images_ << url;
+
+}
+
+void ArtistBioFetcher::InfoReady(const int id, const CollapsibleInfoPane::Data &data) {
+
+  if (!results_.contains(id)) return;
+  results_[id].info_ << data;
+
+  if (!waiting_for_.contains(id)) return;
+  Q_EMIT InfoResultReady(id, data);
+
+}
+
+void ArtistBioFetcher::ProviderFinished(const int id) {
+
+  if (!results_.contains(id)) return;
+  if (!waiting_for_.contains(id)) return;
+
+  ArtistBioProvider *provider = qobject_cast<ArtistBioProvider*>(sender());
+  if (!waiting_for_[id].contains(provider)) return;
+
+  waiting_for_[id].removeAll(provider);
+  if (waiting_for_[id].isEmpty()) {
+    Result result = results_.take(id);
+    Q_EMIT ResultReady(id, result);
+    waiting_for_.remove(id);
+    delete timeout_timers_.take(id);
+  }
+
+}
+
+void ArtistBioFetcher::Timeout(const int id) {
+
+  if (!results_.contains(id)) return;
+  if (!waiting_for_.contains(id)) return;
+
+  // Emit the results that we have already
+  Q_EMIT ResultReady(id, results_.take(id));
+
+  // Cancel any providers that we're still waiting for
+  for (ArtistBioProvider *provider : waiting_for_[id]) {
+    qLog(Info) << "Request timed out from info provider" << provider->name();
+    provider->Cancel(id);
+  }
+  waiting_for_.remove(id);
+
+  // Remove the timer
+  delete timeout_timers_.take(id);
+
+}

src/artistbio/artistbiofetcher.h

@@ -0,0 +1,75 @@
+/*
+ * Strawberry Music Player
+ * This file was part of Clementine.
+ * Copyright 2010, David Sansome <me@davidsansome.com>
+ *
+ * Strawberry 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.
+ *
+ * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef ARTISTBIOFETCHER_H
+#define ARTISTBIOFETCHER_H
+
+#include <QObject>
+#include <QList>
+#include <QMap>
+#include <QUrl>
+
+#include "widgets/collapsibleinfopane.h"
+#include "core/song.h"
+
+class QTimer;
+class ArtistBioProvider;
+
+class ArtistBioFetcher : public QObject {
+  Q_OBJECT
+
+ public:
+  explicit ArtistBioFetcher(QObject *parent = nullptr);
+  ~ArtistBioFetcher() override;
+
+  struct Result {
+    QList<QUrl> images_;
+    QList<CollapsibleInfoPane::Data> info_;
+  };
+
+  static const int kDefaultTimeoutDuration = 25000;
+
+  void AddProvider(ArtistBioProvider *provider);
+  int FetchInfo(const Song &metadata);
+
+  QList<ArtistBioProvider*> providers() const { return providers_; }
+
+ Q_SIGNALS:
+  void InfoResultReady(int, CollapsibleInfoPane::Data);
+  void ResultReady(int, ArtistBioFetcher::Result);
+
+ private Q_SLOTS:
+  void ImageReady(const int id, const QUrl &url);
+  void InfoReady(const int id, const CollapsibleInfoPane::Data &data);
+  void ProviderFinished(const int id);
+  void Timeout(const int id);
+
+ private:
+  QList<ArtistBioProvider*> providers_;
+
+  QMap<int, Result> results_;
+  QMap<int, QList<ArtistBioProvider*>> waiting_for_;
+  QMap<int, QTimer*> timeout_timers_;
+
+  int timeout_duration_;
+  int next_id_;
+};
+
+#endif  // ARTISTBIOFETCHER_H

src/artistbio/artistbioprovider.cpp

@@ -0,0 +1,25 @@
+/*
+ * Strawberry Music Player
+ * This file was part of Clementine.
+ * Copyright 2010, David Sansome <me@davidsansome.com>
+ *
+ * Strawberry 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.
+ *
+ * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "artistbioprovider.h"
+
+ArtistBioProvider::ArtistBioProvider() : enabled_(true) {}
+
+QString ArtistBioProvider::name() const { return QString::fromLatin1(metaObject()->className()); }

src/artistbio/artistbioprovider.h

@@ -0,0 +1,53 @@
+/*
+ * Strawberry Music Player
+ * This file was part of Clementine.
+ * Copyright 2010, David Sansome <me@davidsansome.com>
+ *
+ * Strawberry 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.
+ *
+ * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef ARTISTBIOPROVIDER_H
+#define ARTISTBIOPROVIDER_H
+
+#include <QObject>
+#include <QUrl>
+
+#include "widgets/collapsibleinfopane.h"
+#include "core/song.h"
+
+class ArtistBioProvider : public QObject {
+  Q_OBJECT
+
+ public:
+  explicit ArtistBioProvider();
+
+  virtual void Start(const int id, const Song &song) = 0;
+  virtual void Cancel(const int) {}
+
+  virtual QString name() const;
+
+  bool is_enabled() const { return enabled_; }
+  void set_enabled(bool enabled) { enabled_ = enabled; }
+
+ Q_SIGNALS:
+  void ImageReady(int, QUrl);
+  void InfoReady(int, CollapsibleInfoPane::Data);
+  void Finished(int);
+
+ private:
+  bool enabled_;
+};
+
+#endif  // ARTISTBIOPROVIDER_H

src/artistbio/artistbioview.cpp

@@ -0,0 +1,287 @@
+/*
+ * Strawberry Music Player
+ * This file was part of Clementine.
+ * Copyright 2010, David Sansome <me@davidsansome.com>
+ *
+ * Strawberry 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.
+ *
+ * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <QWidget>
+#include <QFile>
+#include <QScrollArea>
+#include <QSettings>
+#include <QSpacerItem>
+#include <QTimer>
+#include <QVBoxLayout>
+#include <QShowEvent>
+
+#include "core/song.h"
+#include "core/networkaccessmanager.h"
+#include "widgets/prettyimageview.h"
+#include "widgets/widgetfadehelper.h"
+#include "artistbiofetcher.h"
+#include "lastfmartistbio.h"
+#include "wikipediaartistbio.h"
+
+#include "artistbioview.h"
+
+const char *ArtistBioView::kSettingsGroup = "ArtistBio";
+
+ArtistBioView::ArtistBioView(QWidget *parent)
+    : QWidget(parent),
+      network_(new NetworkAccessManager(this)),
+      fetcher_(new ArtistBioFetcher(this)),
+      current_request_id_(-1),
+      container_(new QVBoxLayout),
+      section_container_(nullptr),
+      fader_(new WidgetFadeHelper(this, 1000)),
+      dirty_(false) {
+
+  // Add the top-level scroll area
+  QScrollArea *scrollarea = new QScrollArea(this);
+  setLayout(new QVBoxLayout);
+  layout()->setContentsMargins(0, 0, 0, 0);
+  layout()->addWidget(scrollarea);
+
+  // Add a container widget to the scroll area
+  QWidget *container_widget = new QWidget;
+  container_widget->setLayout(container_);
+  container_widget->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
+  container_widget->setBackgroundRole(QPalette::Base);
+  container_->setSizeConstraint(QLayout::SetMinAndMaxSize);
+  container_->setContentsMargins(0, 0, 0, 0);
+  container_->setSpacing(6);
+  scrollarea->setWidget(container_widget);
+  scrollarea->setWidgetResizable(true);
+
+  // Add a spacer to the bottom of the container
+  container_->addStretch();
+
+  // Set stylesheet
+  QFile stylesheet(QStringLiteral(":/style/artistbio.css"));
+  if (stylesheet.open(QIODevice::ReadOnly)) {
+    setStyleSheet(QString::fromLatin1(stylesheet.readAll()));
+    stylesheet.close();
+  }
+
+  fetcher_->AddProvider(new LastFMArtistBio);
+  fetcher_->AddProvider(new WikipediaArtistBio);
+
+  connect(fetcher_, SIGNAL(ResultReady(int, ArtistBioFetcher::Result)), SLOT(ResultReady(int, ArtistBioFetcher::Result)));
+  connect(fetcher_, SIGNAL(InfoResultReady(int, CollapsibleInfoPane::Data)), SLOT(InfoResultReady(int, CollapsibleInfoPane::Data)));
+
+}
+
+ArtistBioView::~ArtistBioView() {}
+
+void ArtistBioView::showEvent(QShowEvent *e) {
+
+  if (dirty_) {
+    MaybeUpdate(queued_metadata_);
+    dirty_ = false;
+  }
+
+  QWidget::showEvent(e);
+
+}
+
+void ArtistBioView::ReloadSettings() {
+
+  for (CollapsibleInfoPane *pane : sections_) {
+    QWidget *contents = pane->data().contents_;
+    if (!contents) continue;
+
+    QMetaObject::invokeMethod(contents, "ReloadSettings");
+  }
+
+}
+
+bool ArtistBioView::NeedsUpdate(const Song &old_metadata, const Song &new_metadata) const {
+
+  if (new_metadata.artist().isEmpty()) return false;
+
+  return old_metadata.artist() != new_metadata.artist();
+
+}
+
+void ArtistBioView::InfoResultReady(const int id, const CollapsibleInfoPane::Data &_data) {
+
+  if (id != current_request_id_) return;
+
+  AddSection(new CollapsibleInfoPane(_data, this));
+  CollapseSections();
+
+}
+
+void ArtistBioView::ResultReady(const int id, const ArtistBioFetcher::Result &result) {
+
+  if (id != current_request_id_) return;
+
+  if (!result.images_.isEmpty()) {
+    // Image view goes at the top
+    PrettyImageView *image_view = new PrettyImageView(network_, this);
+    AddWidget(image_view);
+
+    for (const QUrl& url : result.images_) {
+      image_view->AddImage(url);
+    }
+  }
+
+  CollapseSections();
+
+}
+
+void ArtistBioView::Clear() {
+
+  fader_->StartFade();
+
+  qDeleteAll(widgets_);
+  widgets_.clear();
+  if (section_container_) {
+    container_->removeWidget(section_container_);
+    delete section_container_;
+  }
+  sections_.clear();
+
+  // Container for collapsible sections goes below
+  section_container_ = new QWidget;
+  section_container_->setLayout(new QVBoxLayout);
+  section_container_->layout()->setContentsMargins(0, 0, 0, 0);
+  section_container_->layout()->setSpacing(1);
+  section_container_->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
+  container_->insertWidget(0, section_container_);
+
+}
+
+void ArtistBioView::AddSection(CollapsibleInfoPane *section) {
+
+  int i = 0;
+  for (; i < sections_.count(); ++i) {
+    if (section->data() < sections_[i]->data()) break;
+  }
+
+  ConnectWidget(section->data().contents_);
+
+  sections_.insert(i, section);
+  qobject_cast<QVBoxLayout*>(section_container_->layout())->insertWidget(i, section);
+  section->show();
+
+}
+
+void ArtistBioView::AddWidget(QWidget *widget) {
+
+  ConnectWidget(widget);
+
+  container_->insertWidget(container_->count() - 2, widget);
+  widgets_ << widget;
+
+}
+
+void ArtistBioView::SongChanged(const Song &metadata) {
+
+  if (isVisible()) {
+    MaybeUpdate(metadata);
+    dirty_ = false;
+  }
+  else {
+    queued_metadata_ = metadata;
+    dirty_ = true;
+  }
+
+}
+
+void ArtistBioView::SongFinished() { dirty_ = false; }
+
+void ArtistBioView::MaybeUpdate(const Song &metadata) {
+
+  if (old_metadata_.is_valid()) {
+    if (!NeedsUpdate(old_metadata_, metadata)) {
+      return;
+    }
+  }
+
+  Update(metadata);
+  old_metadata_ = metadata;
+
+}
+
+void ArtistBioView::Update(const Song &metadata) {
+
+  current_request_id_ = fetcher_->FetchInfo(metadata);
+
+  // Do this after the new pane has been shown otherwise it'll just grab a black rectangle.
+  Clear();
+  QTimer::singleShot(0, fader_, SLOT(StartBlur()));
+
+}
+
+void ArtistBioView::CollapseSections() {
+
+  QSettings s;
+  s.beginGroup(kSettingsGroup);
+
+  // Sections are already sorted by type and relevance, so the algorithm we use to determine which ones to show by default is:
+  //   * In the absence of any user preference, show the first (highest relevance section of each type and hide the rest)
+  //   * If one or more sections in a type have been explicitly hidden/shown by the user before then hide all sections in that type and show only the ones that are explicitly shown.
+
+  QMultiMap<CollapsibleInfoPane::Data::Type, CollapsibleInfoPane*> types_;
+  QSet<CollapsibleInfoPane::Data::Type> has_user_preference_;
+  for (CollapsibleInfoPane *pane : sections_) {
+    const CollapsibleInfoPane::Data::Type type = pane->data().type_;
+    types_.insert(type, pane);
+
+    QVariant preference = s.value(pane->data().id_);
+    if (preference.isValid()) {
+      has_user_preference_.insert(type);
+      if (preference.toBool()) {
+        pane->Expand();
+      }
+    }
+  }
+
+  for (CollapsibleInfoPane::Data::Type type : types_.keys()) {
+    if (!has_user_preference_.contains(type)) {
+      // Expand the first one
+      types_.values(type).last()->Expand();
+    }
+  }
+
+  for (CollapsibleInfoPane *pane : sections_) {
+    connect(pane, SIGNAL(Toggled(bool)), SLOT(SectionToggled(bool)));
+  }
+
+}
+
+void ArtistBioView::SectionToggled(const bool value) {
+
+  CollapsibleInfoPane *pane = qobject_cast<CollapsibleInfoPane*>(sender());
+  if (!pane || !sections_.contains(pane)) return;
+
+  QSettings s;
+  s.beginGroup(kSettingsGroup);
+  s.setValue(pane->data().id_, value);
+  s.endGroup();
+
+}
+
+void ArtistBioView::ConnectWidget(QWidget *widget) {
+
+  const QMetaObject *m = widget->metaObject();
+
+  if (m->indexOfSignal("ShowSettingsDialog()") != -1) {
+    connect(widget, SIGNAL(ShowSettingsDialog()), SIGNAL(ShowSettingsDialog()));
+  }
+
+}

src/artistbio/artistbioview.h

@@ -0,0 +1,104 @@
+/*
+ * Strawberry Music Player
+ * This file was part of Clementine.
+ * Copyright 2010, David Sansome <me@davidsansome.com>
+ *
+ * Strawberry 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.
+ *
+ * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef ARTISTBIOVIEW_H
+#define ARTISTBIOVIEW_H
+
+#include <QObject>
+#include <QWidget>
+#include <QList>
+
+#include "core/song.h"
+#include "widgets/collapsibleinfopane.h"
+#include "widgets/widgetfadehelper.h"
+#include "widgets/collapsibleinfopane.h"
+#include "playlist/playlistitem.h"
+#include "smartplaylists/playlistgenerator_fwd.h"
+#include "artistbiofetcher.h"
+
+class QNetworkAccessManager;
+class QTimeLine;
+class QVBoxLayout;
+class QScrollArea;
+class QShowEvent;
+
+class PrettyImageView;
+class CollapsibleInfoPane;
+class WidgetFadeHelper;
+
+class ArtistBioView : public QWidget {
+  Q_OBJECT
+
+ public:
+  explicit ArtistBioView(QWidget *parent = nullptr);
+  ~ArtistBioView() override;
+
+  static const char *kSettingsGroup;
+
+ public Q_SLOTS:
+  void SongChanged(const Song& metadata);
+  void SongFinished();
+  virtual void ReloadSettings();
+
+ Q_SIGNALS:
+  void ShowSettingsDialog();
+
+ protected:
+  void showEvent(QShowEvent *e) override;
+
+  void Update(const Song &metadata);
+  void AddWidget(QWidget *widget);
+  void AddSection(CollapsibleInfoPane *section);
+  void Clear();
+  void CollapseSections();
+
+  bool NeedsUpdate(const Song& old_metadata, const Song &new_metadata) const;
+
+ protected Q_SLOTS:
+  void ResultReady(const int id, const ArtistBioFetcher::Result &result);
+  void InfoResultReady(const int id, const CollapsibleInfoPane::Data &data);
+
+ protected:
+  QNetworkAccessManager *network_;
+  ArtistBioFetcher *fetcher_;
+  int current_request_id_;
+
+ private:
+  void MaybeUpdate(const Song &metadata);
+  void ConnectWidget(QWidget *widget);
+
+ private Q_SLOTS:
+  void SectionToggled(const bool value);
+
+ private:
+  QVBoxLayout *container_;
+  QList<QWidget*> widgets_;
+
+  QWidget *section_container_;
+  QList<CollapsibleInfoPane*> sections_;
+
+  WidgetFadeHelper *fader_;
+
+  Song queued_metadata_;
+  Song old_metadata_;
+  bool dirty_;
+};
+
+#endif  // ARTISTBIOVIEW_H

src/artistbio/lastfmartistbio.cpp

@@ -0,0 +1,209 @@
+/*
+ * Strawberry Music Player
+ * Copyright 2020, Jonas Kvinge <jonas@jkvinge.net>
+ *
+ * Strawberry 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.
+ *
+ * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "config.h"
+
+#include <algorithm>
+
+#include <QtGlobal>
+#include <QLocale>
+#include <QVariant>
+#include <QByteArray>
+#include <QString>
+#include <QUrl>
+#include <QUrlQuery>
+#include <QDateTime>
+#include <QNetworkRequest>
+#include <QNetworkReply>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QJsonArray>
+#include <QJsonValue>
+
+#include "core/networkaccessmanager.h"
+#include "core/song.h"
+#include "core/logging.h"
+#include "core/iconloader.h"
+
+#include "lastfmartistbio.h"
+#include "widgets/infotextview.h"
+#include "scrobbler/scrobblingapi20.h"
+#include "scrobbler/lastfmscrobbler.h"
+
+LastFMArtistBio::LastFMArtistBio() : ArtistBioProvider(), network_(new NetworkAccessManager(this)) {}
+
+LastFMArtistBio::~LastFMArtistBio() {
+
+  while (!replies_.isEmpty()) {
+    QNetworkReply *reply = replies_.takeFirst();
+    disconnect(reply, nullptr, this, nullptr);
+    reply->abort();
+    reply->deleteLater();
+  }
+
+}
+
+void LastFMArtistBio::Start(const int id, const Song &song) {
+
+  ParamList params = ParamList()
+    << Param(QStringLiteral("api_key"), QString::fromLatin1(ScrobblingAPI20::kApiKey))
+    << Param(QStringLiteral("lang"), QLocale().name().left(2).toLower())
+    << Param(QStringLiteral("format"), QStringLiteral("json"))
+    << Param(QStringLiteral("method"), QStringLiteral("artist.getinfo"))
+    << Param(QStringLiteral("artist"), song.artist());
+
+  std::sort(params.begin(), params.end());
+
+  QUrlQuery url_query;
+  for (const Param &param : params) {
+    url_query.addQueryItem(QString::fromLatin1(QUrl::toPercentEncoding(param.first)), QString::fromLatin1(QUrl::toPercentEncoding(param.second)));
+  }
+
+  QUrl url(QString::fromLatin1(LastFMScrobbler::kApiUrl));
+  url.setQuery(url_query);
+  QNetworkRequest req(url);
+#if QT_VERSION >= QT_VERSION_CHECK(5, 9, 0)
+  req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
+#else
+  req.setAttribute(QNetworkRequest::FollowRedirectsAttribute, true);
+#endif
+  req.setHeader(QNetworkRequest::ContentTypeHeader, QStringLiteral("application/x-www-form-urlencoded"));
+
+  QNetworkReply *reply = network_->get(req);
+  replies_ << reply;
+  connect(reply, &QNetworkReply::finished, [=] { RequestFinished(reply, id); });
+
+  qLog(Debug) << "Sending request" << url_query.toString(QUrl::FullyDecoded);
+
+}
+
+QByteArray LastFMArtistBio::GetReplyData(QNetworkReply *reply) {
+
+  QByteArray data;
+
+  if (reply->error() == QNetworkReply::NoError && reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt() == 200) {
+    data = reply->readAll();
+  }
+  else {
+    if (reply->error() != QNetworkReply::NoError && reply->error() < 200) {
+      // This is a network error, there is nothing more to do.
+      Error(QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
+    }
+    else {
+      QString error;
+      // See if there is Json data containing "error" and "message" - then use that instead.
+      data = reply->readAll();
+      QJsonParseError json_error;
+      QJsonDocument json_doc = QJsonDocument::fromJson(data, &json_error);
+      int error_code = -1;
+      if (json_error.error == QJsonParseError::NoError && !json_doc.isEmpty() && json_doc.isObject()) {
+        QJsonObject json_obj = json_doc.object();
+        if (json_obj.contains(QLatin1String("error")) && json_obj.contains(QLatin1String("message"))) {
+          error_code = json_obj[QLatin1String("error")].toInt();
+          QString error_message = json_obj[QLatin1String("message")].toString();
+          error = QStringLiteral("%1 (%2)").arg(error_message).arg(error_code);
+        }
+      }
+      if (error.isEmpty()) {
+        if (reply->error() != QNetworkReply::NoError) {
+          error = QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
+        }
+        else {
+          error = QStringLiteral("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt());
+        }
+      }
+      Error(error);
+    }
+    return QByteArray();
+  }
+
+  return data;
+
+}
+
+QJsonObject LastFMArtistBio::ExtractJsonObj(const QByteArray &data) {
+
+  if (data.isEmpty()) return QJsonObject();
+
+  QJsonParseError error;
+  QJsonDocument json_doc = QJsonDocument::fromJson(data, &error);
+
+  if (error.error != QJsonParseError::NoError) {
+    Error(QStringLiteral("Reply from server missing Json data."), data);
+    return QJsonObject();
+  }
+  if (json_doc.isEmpty()) {
+    Error(QStringLiteral("Received empty Json document."), json_doc);
+    return QJsonObject();
+  }
+  if (!json_doc.isObject()) {
+    Error(QStringLiteral("Json document is not an object."), json_doc);
+    return QJsonObject();
+  }
+  QJsonObject json_obj = json_doc.object();
+  if (json_obj.isEmpty()) {
+    Error(QStringLiteral("Received empty Json object."), json_doc);
+    return QJsonObject();
+  }
+
+  return json_obj;
+
+}
+
+void LastFMArtistBio::RequestFinished(QNetworkReply *reply, const int id) {
+
+  if (!replies_.contains(reply)) return;
+  replies_.removeAll(reply);
+  disconnect(reply, nullptr, this, nullptr);
+  reply->deleteLater();
+
+  QJsonObject json_obj = ExtractJsonObj(GetReplyData(reply));
+
+  QString title;
+  QString text;
+  if (!json_obj.isEmpty() && json_obj.contains(QLatin1String("artist")) && json_obj[QLatin1String("artist")].isObject()) {
+    json_obj = json_obj[QLatin1String("artist")].toObject();
+    if (json_obj.contains(QLatin1String("bio")) && json_obj[QLatin1String("bio")].isObject()) {
+      title = json_obj[QLatin1String("name")].toString();
+      QJsonObject obj_bio = json_obj[QLatin1String("bio")].toObject();
+      if (obj_bio.contains(QLatin1String("content"))) {
+        text = obj_bio[QLatin1String("content")].toString();
+      }
+    }
+  }
+
+  CollapsibleInfoPane::Data info_data;
+  info_data.id_ = title;
+  info_data.title_ = tr("Biography");
+  info_data.type_ = CollapsibleInfoPane::Data::Type_Biography;
+  info_data.icon_ = IconLoader::Load(QStringLiteral("scrobble"));
+  InfoTextView *editor = new InfoTextView;
+  editor->SetHtml(text);
+  info_data.contents_ = editor;
+  Q_EMIT InfoReady(id, info_data);
+  Q_EMIT Finished(id);
+
+}
+
+void LastFMArtistBio::Error(const QString &error, const QVariant &debug) {
+
+  qLog(Error) << error;
+  if (debug.isValid()) qLog(Debug) << debug;
+
+}

src/artistbio/lastfmartistbio.h

@@ -0,0 +1,66 @@
+/*
+ * Strawberry Music Player
+ * Copyright 2020, Jonas Kvinge <jonas@jkvinge.net>
+ *
+ * Strawberry 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.
+ *
+ * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef LASTFMARTISTBIO_H
+#define LASTFMARTISTBIO_H
+
+#include "config.h"
+
+#include <QtGlobal>
+#include <QObject>
+#include <QList>
+#include <QVariant>
+#include <QByteArray>
+#include <QString>
+
+#include "core/song.h"
+
+#include "artistbioprovider.h"
+
+class NetworkAccessManager;
+class QNetworkReply;
+
+class LastFMArtistBio : public ArtistBioProvider {
+  Q_OBJECT
+
+ public:
+  explicit LastFMArtistBio();
+  ~LastFMArtistBio();
+
+  void Start(const int id, const Song &song) override;
+
+ private:
+  using Param = QPair<QString, QString>;
+  using ParamList = QList<Param>;
+
+  QNetworkReply *CreateRequest(const ParamList &request_params);
+  QByteArray GetReplyData(QNetworkReply *reply);
+  QJsonObject ExtractJsonObj(const QByteArray &data);
+  void Error(const QString &error, const QVariant &debug = QVariant());
+
+ private Q_SLOTS:
+  void RequestFinished(QNetworkReply *reply, const int id);
+
+ private:
+  NetworkAccessManager *network_;
+  QList<QNetworkReply*> replies_;
+
+};
+
+#endif  // LASTFMARTISTBIO_H

src/artistbio/wikipediaartistbio.cpp

@@ -0,0 +1,319 @@
+/*
+ * Strawberry Music Player
+ * Copyright 2020, Jonas Kvinge <jonas@jkvinge.net>
+ *
+ * Strawberry 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.
+ *
+ * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <QObject>
+#include <QList>
+#include <QString>
+#include <QStringList>
+#include <QUrl>
+#include <QUrlQuery>
+#include <QJsonDocument>
+#include <QJsonArray>
+#include <QJsonObject>
+#include <QJsonValue>
+#include <QNetworkReply>
+
+#include "core/logging.h"
+#include "core/networkaccessmanager.h"
+#include "core/iconloader.h"
+#include "core/latch.h"
+
+#include "widgets/infotextview.h"
+#include "wikipediaartistbio.h"
+
+namespace {
+constexpr char kApiUrl[] = "https://en.wikipedia.org/w/api.php";
+constexpr int kMinimumImageSize = 400;
+}
+
+WikipediaArtistBio::WikipediaArtistBio() : ArtistBioProvider(), network_(new NetworkAccessManager(this)) {}
+
+WikipediaArtistBio::~WikipediaArtistBio() {
+
+  while (!replies_.isEmpty()) {
+    QNetworkReply *reply = replies_.takeFirst();
+    disconnect(reply, nullptr, this, nullptr);
+    if (reply->isRunning()) reply->abort();
+    reply->deleteLater();
+  }
+
+}
+
+QNetworkReply *WikipediaArtistBio::CreateRequest(QList<Param> &params) {
+
+  params << Param(QLatin1String("format"), QLatin1String("json"));
+  params << Param(QLatin1String("action"), QLatin1String("query"));
+
+  QUrlQuery url_query;
+  for (const Param &param : params) {
+    url_query.addQueryItem(QString::fromLatin1(QUrl::toPercentEncoding(param.first)), QString::fromLatin1(QUrl::toPercentEncoding(param.second)));
+  }
+
+  QUrl url(QString::fromLatin1(kApiUrl));
+  url.setQuery(url_query);
+  QNetworkRequest req(url);
+#if QT_VERSION >= QT_VERSION_CHECK(5, 9, 0)
+  req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
+#else
+  req.setAttribute(QNetworkRequest::FollowRedirectsAttribute, true);
+#endif
+  req.setHeader(QNetworkRequest::ContentTypeHeader, QStringLiteral("application/x-www-form-urlencoded"));
+
+  QNetworkReply *reply = network_->get(req);
+  connect(reply, &QNetworkReply::sslErrors, this, &WikipediaArtistBio::HandleSSLErrors);
+  replies_ << reply;
+
+  return reply;
+
+}
+
+QByteArray WikipediaArtistBio::GetReplyData(QNetworkReply *reply) {
+
+  QByteArray data;
+
+  if (reply->error() == QNetworkReply::NoError && reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt() == 200) {
+    data = reply->readAll();
+  }
+  else {
+    if (reply->error() == QNetworkReply::NoError) {
+      qLog(Error) << "Wikipedia artist biography error: Received HTTP code" << reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+    }
+    else {
+      qLog(Error) << "Wikipedia artist biography error:" << reply->error() << reply->errorString();
+    }
+  }
+
+  return data;
+
+}
+
+QJsonObject WikipediaArtistBio::ExtractJsonObj(const QByteArray &data) {
+
+  if (data.isEmpty()) return QJsonObject();
+
+  QJsonParseError json_error;
+  QJsonDocument json_doc = QJsonDocument::fromJson(data, &json_error);
+
+  if (json_error.error != QJsonParseError::NoError) {
+    qLog(Error) << "Wikipedia artist biography error: Failed to parse json data:" << json_error.errorString();
+    return QJsonObject();
+  }
+
+  if (json_doc.isEmpty()) {
+    qLog(Error) << "Wikipedia artist biography error: Received empty Json document.";
+    return QJsonObject();
+  }
+
+  if (!json_doc.isObject()) {
+    qLog(Error) << "Wikipedia artist biography error: Json document is not an object.";
+    return QJsonObject();
+  }
+
+  QJsonObject json_obj = json_doc.object();
+  if (json_obj.isEmpty()) {
+    qLog(Error) << "Wikipedia artist biography error: Received empty Json object.";
+    return QJsonObject();
+  }
+
+  return json_obj;
+
+}
+
+void WikipediaArtistBio::HandleSSLErrors(QList<QSslError>) {}
+
+void WikipediaArtistBio::Start(const int id, const Song &metadata) {
+
+  if (metadata.artist().isEmpty()) {
+    Q_EMIT Finished(id);
+    return;
+  }
+
+  CountdownLatch *latch = new CountdownLatch;
+  connect(latch, &CountdownLatch::Done, [this, id, latch](){
+    latch->deleteLater();
+    Q_EMIT Finished(id);
+  });
+
+  GetImageTitles(id, metadata.artist(), latch);
+  //GetArticle(id, metadata.artist(), latch);
+
+}
+
+void WikipediaArtistBio::GetArticle(const int id, const QString &artist, CountdownLatch *latch) {
+
+  latch->Wait();
+
+  ParamList params = ParamList() << Param(QStringLiteral("titles"), artist)
+                                 << Param(QStringLiteral("prop"), QStringLiteral("extracts"));
+
+  QNetworkReply *reply = CreateRequest(params);
+  connect(reply, &QNetworkReply::finished, [this, reply, id, latch]() { GetArticleReply(reply, id, latch); });
+
+}
+
+void WikipediaArtistBio::GetArticleReply(QNetworkReply *reply, const int id, CountdownLatch *latch) {
+
+  reply->deleteLater();
+  replies_.removeAll(reply);
+
+  QJsonObject json_obj = ExtractJsonObj(GetReplyData(reply));
+
+  QString title;
+  QString text;
+  if (!json_obj.isEmpty() && json_obj.contains(QLatin1String("query")) && json_obj[QLatin1String("query")].isObject()) {
+    json_obj = json_obj[QLatin1String("query")].toObject();
+    if (json_obj.contains(QLatin1String("pages")) && json_obj[QLatin1String("pages")].isObject()) {
+      QJsonObject value_pages = json_obj[QLatin1String("pages")].toObject();
+      for (const QJsonValue value_page : value_pages) {
+        if (!value_page.isObject()) continue;
+        QJsonObject obj_page = value_page.toObject();
+        if (!obj_page.contains(QLatin1String("title")) || !obj_page.contains(QLatin1String("extract"))) continue;
+        title = obj_page[QLatin1String("title")].toString();
+        text = obj_page[QLatin1String("extract")].toString();
+      }
+    }
+  }
+
+  CollapsibleInfoPane::Data info_data;
+  info_data.id_ = title;
+  info_data.title_ = tr("Biography");
+  info_data.type_ = CollapsibleInfoPane::Data::Type_Biography;
+  info_data.icon_ = IconLoader::Load(QStringLiteral("wikipedia"));
+  InfoTextView *editor = new InfoTextView;
+  editor->SetHtml(text);
+  info_data.contents_ = editor;
+  Q_EMIT InfoReady(id, info_data);
+
+  latch->CountDown();
+
+}
+
+void WikipediaArtistBio::GetImageTitles(const int id, const QString &artist, CountdownLatch *latch) {
+
+  latch->Wait();
+
+  ParamList params = ParamList() << Param(QStringLiteral("titles"), artist)
+                                 << Param(QStringLiteral("prop"), QStringLiteral("images"))
+                                 << Param(QStringLiteral("imlimit"), QString::number(25));
+
+  QNetworkReply *reply = CreateRequest(params);
+  connect(reply, &QNetworkReply::finished, [this, reply, id, latch]() { GetImageTitlesFinished(reply, id, latch); });
+
+}
+
+void WikipediaArtistBio::GetImageTitlesFinished(QNetworkReply *reply, const int id, CountdownLatch *latch) {
+
+  reply->deleteLater();
+  replies_.removeAll(reply);
+
+  QJsonObject json_obj = ExtractJsonObj(GetReplyData(reply));
+
+  QString title;
+  QStringList titles;
+  if (!json_obj.isEmpty() && json_obj.contains(QLatin1String("query")) && json_obj[QLatin1String("query")].isObject()) {
+    json_obj = json_obj[QLatin1String("query")].toObject();
+    if (json_obj.contains(QLatin1String("pages")) && json_obj[QLatin1String("pages")].isObject()) {
+      QJsonObject value_pages = json_obj[QLatin1String("pages")].toObject();
+      for (const QJsonValue value_page : value_pages) {
+        if (!value_page.isObject()) continue;
+        QJsonObject obj_page = value_page.toObject();
+        if (!obj_page.contains(QLatin1String("title")) || !obj_page.contains(QLatin1String("images")) || !obj_page[QLatin1String("images")].isArray()) continue;
+        title = obj_page[QLatin1String("title")].toString();
+        QJsonArray array_images = obj_page[QLatin1String("images")].toArray();
+        for (const QJsonValue value_image : array_images) {
+          if (!value_image.isObject()) continue;
+          QJsonObject obj_image = value_image.toObject();
+          if (!obj_image.contains(QLatin1String("title"))) continue;
+          QString filename = obj_image[QLatin1String("title")].toString();
+          if (filename.endsWith(QLatin1String(".jpg"), Qt::CaseInsensitive) || filename.endsWith(QLatin1String(".png"), Qt::CaseInsensitive)) {
+            titles << filename;
+          }
+        }
+      }
+    }
+  }
+
+  for (const QString &image_title : titles) {
+    GetImage(id, image_title, latch);
+  }
+
+  latch->CountDown();
+
+}
+
+void WikipediaArtistBio::GetImage(const int id, const QString &title, CountdownLatch *latch) {
+
+  latch->Wait();
+
+  ParamList params2 = ParamList() << Param(QStringLiteral("titles"), title)
+                                  << Param(QStringLiteral("prop"), QStringLiteral("imageinfo"))
+                                  << Param(QStringLiteral("iiprop"), QStringLiteral("url|size"));
+
+  QNetworkReply *reply = CreateRequest(params2);
+  connect(reply, &QNetworkReply::finished, [this, reply, id, latch]() { GetImageFinished(reply, id, latch); });
+
+}
+
+void WikipediaArtistBio::GetImageFinished(QNetworkReply *reply, const int id, CountdownLatch *latch) {
+
+  reply->deleteLater();
+  replies_.removeAll(reply);
+
+  QJsonObject json_obj = ExtractJsonObj(GetReplyData(reply));
+
+  if (!json_obj.isEmpty()) {
+    QList<QUrl> urls = ExtractImageUrls(json_obj);
+    for (const QUrl &url : urls) {
+      Q_EMIT ImageReady(id, url);
+    }
+  }
+
+  latch->CountDown();
+
+}
+
+QList<QUrl> WikipediaArtistBio::ExtractImageUrls(QJsonObject json_obj) {
+
+  QList<QUrl> urls;
+  if (json_obj.contains(QLatin1String("query")) && json_obj[QLatin1String("query")].isObject()) {
+    json_obj = json_obj[QLatin1String("query")].toObject();
+    if (json_obj.contains(QLatin1String("pages")) && json_obj[QLatin1String("pages")].isObject()) {
+      QJsonObject value_pages = json_obj[QLatin1String("pages")].toObject();
+      for (const QJsonValue value_page : value_pages) {
+        if (!value_page.isObject()) continue;
+        QJsonObject obj_page = value_page.toObject();
+        if (!obj_page.contains(QLatin1String("title")) || !obj_page.contains(QLatin1String("imageinfo")) || !obj_page[QLatin1String("imageinfo")].isArray()) continue;
+        QJsonArray array_images = obj_page[QLatin1String("imageinfo")].toArray();
+        for (const QJsonValue value_image : array_images) {
+          if (!value_image.isObject()) continue;
+          QJsonObject obj_image = value_image.toObject();
+          if (!obj_image.contains(QLatin1String("url")) || !obj_image.contains(QLatin1String("width")) || !obj_image.contains(QLatin1String("height"))) continue;
+          QUrl url(obj_image[QLatin1String("url")].toString());
+          const int width = obj_image[QLatin1String("width")].toInt();
+          const int height = obj_image[QLatin1String("height")].toInt();
+          if (!url.isValid() || width < kMinimumImageSize || height < kMinimumImageSize) continue;
+          urls << url;
+        }
+      }
+    }
+  }
+
+  return urls;
+
+}

src/artistbio/wikipediaartistbio.h

@@ -0,0 +1,69 @@
+/*
+ * Strawberry Music Player
+ * Copyright 2020, Jonas Kvinge <jonas@jkvinge.net>
+ *
+ * Strawberry 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.
+ *
+ * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef WIKIPEDIAARTISTBIO_H
+#define WIKIPEDIAARTISTBIO_H
+
+#include <QList>
+#include <QString>
+#include <QStringList>
+#include <QUrl>
+#include <QSslError>
+#include <QJsonObject>
+
+#include "artistbioprovider.h"
+
+class QNetworkReply;
+class CountdownLatch;
+class NetworkAccessManager;
+
+class WikipediaArtistBio : public ArtistBioProvider {
+  Q_OBJECT
+
+ public:
+  explicit WikipediaArtistBio();
+  ~WikipediaArtistBio();
+
+  void Start(const int id, const Song &song) override;
+
+ private:
+  typedef QPair<QString, QString> Param;
+  typedef QList<Param> ParamList;
+
+  QNetworkReply *CreateRequest(QList<Param> &params);
+  QByteArray GetReplyData(QNetworkReply *reply);
+  QJsonObject ExtractJsonObj(const QByteArray &data);
+  void GetArticle(const int id, const QString &artist, CountdownLatch* latch);
+  void GetImageTitles(const int id, const QString &artist, CountdownLatch* latch);
+  void GetImage(const int id, const QString &title, CountdownLatch *latch);
+  QList<QUrl> ExtractImageUrls(QJsonObject json_obj);
+
+ private Q_SLOTS:
+  void HandleSSLErrors(QList<QSslError> ssl_errors);
+  void GetArticleReply(QNetworkReply *reply, const int id, CountdownLatch *latch);
+  void GetImageTitlesFinished(QNetworkReply *reply, const int id, CountdownLatch *latch);
+  void GetImageFinished(QNetworkReply *reply, const int id, CountdownLatch *latch);
+
+ private:
+  NetworkAccessManager *network_;
+  QList<QNetworkReply*> replies_;
+
+};
+
+#endif  // WIKIPEDIAARTISTBIO_H

src/collection/collectionplaylistitem.cpp

@@ -41,11 +41,8 @@ bool CollectionPlaylistItem::InitFromQuery(const SqlRow &query) {
     case Song::Source::Collection:
       col = 0;
       break;
-    case Song::Source::Dropbox:
-      col = static_cast<int>(Song::kRowIdColumns.count());
-      break;
     default:
-      col = static_cast<int>(Song::kRowIdColumns.count() * 2);
+      col = static_cast<int>(Song::kRowIdColumns.count());
       break;
   }
 

src/config.h.in

@@ -33,8 +33,6 @@
 #cmakedefine HAVE_SPOTIFY
 #cmakedefine HAVE_QOBUZ
 #cmakedefine HAVE_DISCORD_RPC
-#cmakedefine HAVE_DROPBOX
-#cmakedefine HAVE_ONEDRIVE
 
 #cmakedefine HAVE_TAGLIB_DSFFILE
 #cmakedefine HAVE_TAGLIB_DSDIFFFILE

src/constants/dropboxconstants.h

@@ -1,30 +0,0 @@
-/*
-* Strawberry Music Player
-* Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
-*
-* Strawberry 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.
-*
-* Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
-*
-*/
-
-#ifndef DROPBOXCONSTANTS_H
-#define DROPBOXCONSTANTS_H
-
-namespace DropboxConstants {
-
-constexpr char kApiUrl[] = "https://api.dropboxapi.com";
-constexpr char kNotifyApiUrl[] = "https://notify.dropboxapi.com";
-
-}  // namespace
-
-#endif  // DROPBOXCONSTANTS_H

src/constants/dropboxsettings.h

@@ -1,46 +0,0 @@
-/*
-* Strawberry Music Player
-* Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
-*
-* Strawberry 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.
-*
-* Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
-*
-*/
-
-#ifndef DROPBOXSETTINGS_H
-#define DROPBOXSETTINGS_H
-
-namespace DropboxSettings {
-
-constexpr char kSettingsGroup[] = "Dropbox";
-
-constexpr char kEnabled[] = "enabled";
-constexpr char kSearchDelay[] = "searchdelay";
-constexpr char kArtistsSearchLimit[] = "artistssearchlimit";
-constexpr char kAlbumsSearchLimit[] = "albumssearchlimit";
-constexpr char kSongsSearchLimit[] = "songssearchlimit";
-constexpr char kFetchAlbums[] = "fetchalbums";
-constexpr char kDownloadAlbumCovers[] = "downloadalbumcovers";
-
-constexpr char kTokenType[] = "token_type";
-constexpr char kAccessToken[] = "access_token";
-constexpr char kRefreshToken[] = "refresh_token";
-constexpr char kExpiresIn[] = "expires_in";
-constexpr char kLoginTime[] = "login_time";
-
-constexpr char kApiUrl[] = "https://api.dropboxapi.com";
-constexpr char kNotifyApiUrl[] = "https://notify.dropboxapi.com";
-
-}  // namespace
-
-#endif  // DROPBOXSETTINGS_H

src/core/application.cpp

@@ -105,10 +105,6 @@
 #  include "covermanager/qobuzcoverprovider.h"
 #endif
 
-#ifdef HAVE_DROPBOX
-#  include "dropbox/dropboxservice.h"
-#endif
-
 #ifdef HAVE_MOODBAR
 #  include "moodbar/moodbarcontroller.h"
 #  include "moodbar/moodbarloader.h"
@@ -204,9 +200,6 @@ class ApplicationImpl {
 #endif
 #ifdef HAVE_QOBUZ
           streaming_services->AddService(make_shared<QobuzService>(app->task_manager(), app->database(), app->network(), app->url_handlers(), app->albumcover_loader()));
-#endif
-#ifdef HAVE_DROPBOX
-          streaming_services->AddService(make_shared<DropboxService>(app->task_manager(), app->database(), app->network(), app->url_handlers(), app->tagreader_client(), app->albumcover_loader()));
 #endif
           return streaming_services;
         }),

src/core/latch.cpp

@@ -0,0 +1,39 @@
+/* This file is part of Clementine.
+   Copyright 2016, John Maguire <john.maguire@gmail.com>
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+#include <QMutexLocker>
+
+#include "latch.h"
+
+CountdownLatch::CountdownLatch() : count_(0) {}
+
+void CountdownLatch::Wait() {
+
+  QMutexLocker l(&mutex_);
+  ++count_;
+
+}
+
+void CountdownLatch::CountDown() {
+
+  QMutexLocker l(&mutex_);
+  Q_ASSERT(count_ > 0);
+  --count_;
+  if (count_ == 0) {
+    emit Done();
+  }
+
+}

src/core/latch.h

@@ -0,0 +1,39 @@
+/* This file is part of Clementine.
+   Copyright 2016, John Maguire <john.maguire@gmail.com>
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+#ifndef LATCH_H
+#define LATCH_H
+
+#include <QObject>
+#include <QMutex>
+
+class CountdownLatch : public QObject {
+  Q_OBJECT
+
+ public:
+  explicit CountdownLatch();
+  void Wait();
+  void CountDown();
+
+ Q_SIGNALS:
+  void Done();
+
+ private:
+  QMutex mutex_;
+  int count_;
+};
+
+#endif  // LATCH_H

src/core/mainwindow.cpp

@@ -178,9 +178,6 @@
 #ifdef HAVE_QOBUZ
 #  include "constants/qobuzsettings.h"
 #endif
-#ifdef HAVE_DROPBOX
-#  include "constants/dropboxsettings.h"
-#endif
 
 #include "streaming/streamingservices.h"
 #include "streaming/streamingservice.h"
@@ -208,6 +205,7 @@
 #include "smartplaylists/smartplaylistsviewcontainer.h"
 
 #include "organize/organizeerrordialog.h"
+#include "artistbio/artistbioview.h"
 
 #ifdef Q_OS_WIN32
 #  include "core/windows7thumbbar.h"
@@ -235,6 +233,7 @@
 
 using std::make_unique;
 using std::make_shared;
+
 using namespace std::chrono_literals;
 using namespace Qt::Literals::StringLiterals;
 
@@ -358,11 +357,9 @@ MainWindow::MainWindow(Application *app,
 #endif
 #ifdef HAVE_QOBUZ
       qobuz_view_(new StreamingTabsView(app->streaming_services()->ServiceBySource(Song::Source::Qobuz), app->albumcover_loader(), QLatin1String(QobuzSettings::kSettingsGroup), this)),
-#endif
-#ifdef HAVE_DROPBOX
-      dropbox_view_(new StreamingSongsView(app->streaming_services()->ServiceBySource(Song::Source::Dropbox), QLatin1String(DropboxSettings::kSettingsGroup), this)),
 #endif
       radio_view_(new RadioViewContainer(this)),
+      artistbio_view_(new ArtistBioView(this)),
       lastfm_import_dialog_(new LastFMImportDialog(app_->lastfm_import(), this)),
       collection_show_all_(nullptr),
       collection_show_duplicates_(nullptr),
@@ -447,9 +444,7 @@ MainWindow::MainWindow(Application *app,
 #ifdef HAVE_QOBUZ
   ui_->tabs->AddTab(qobuz_view_, u"qobuz"_s, IconLoader::Load(u"qobuz"_s, true, 0, 32), tr("Qobuz"));
 #endif
-#ifdef HAVE_DROPBOX
-  ui_->tabs->AddTab(dropbox_view_, u"dropbox"_s, IconLoader::Load(u"dropbox"_s, true, 0, 32), tr("Dropbox"));
-#endif
+  ui_->tabs->AddTab(artistbio_view_, QStringLiteral("artistbio"), IconLoader::Load(QStringLiteral("guitar")), tr("Artist biography"));
 
   // Add the playing widget to the fancy tab widget
   ui_->tabs->AddBottomWidget(ui_->widget_playing);
@@ -791,12 +786,6 @@ MainWindow::MainWindow(Application *app,
   }
 #endif
 
-#ifdef HAVE_DROPBOX
-  QObject::connect(dropbox_view_, &StreamingSongsView::ShowErrorDialog, this, &MainWindow::ShowErrorDialog);
-  QObject::connect(dropbox_view_, &StreamingSongsView::OpenSettingsDialog, this, &MainWindow::OpenServiceSettingsDialog);
-  QObject::connect(dropbox_view_->view(), &StreamingCollectionView::AddToPlaylistSignal, this, &MainWindow::AddToPlaylist);
-#endif
-
   QObject::connect(radio_view_, &RadioViewContainer::Refresh, &*app_->radio_services(), &RadioServices::RefreshChannels);
   QObject::connect(radio_view_->view(), &RadioView::GetChannels, &*app_->radio_services(), &RadioServices::GetChannels);
   QObject::connect(radio_view_->view(), &RadioView::AddToPlaylistSignal, this, &MainWindow::AddToPlaylist);
@@ -992,6 +981,10 @@ MainWindow::MainWindow(Application *app,
   ui_->action_open_cd->setVisible(false);
 #endif
 
+  connect(&*app_->playlist_manager(), &PlaylistManager::CurrentSongChanged, artistbio_view_, &ArtistBioView::SongChanged);
+  connect(&*app_->player(), &Player::PlaylistFinished, artistbio_view_, &ArtistBioView::SongFinished);
+  connect(&*app_->player(), &Player::Stopped, artistbio_view_, &ArtistBioView::SongFinished);
+
   // Load settings
   qLog(Debug) << "Loading settings";
   Settings settings;
@@ -1247,6 +1240,16 @@ void MainWindow::ReloadSettings() {
   album_cover_choice_controller_->search_cover_auto_action()->setChecked(s.value(MainWindowSettings::kSearchForCoverAuto, true).toBool());
   s.endGroup();
 
+  s.beginGroup(BehaviourSettings::kSettingsGroup);
+  bool artistbio = s.value("artistbio", false).toBool();
+  s.endGroup();
+  if (artistbio) {
+    ui_->tabs->EnableTab(artistbio_view_);
+  }
+  else {
+    ui_->tabs->DisableTab(artistbio_view_);
+  }
+
 #ifdef HAVE_SUBSONIC
   s.beginGroup(SubsonicSettings::kSettingsGroup);
   bool enable_subsonic = s.value(SubsonicSettings::kEnabled, false).toBool();
@@ -1295,18 +1298,6 @@ void MainWindow::ReloadSettings() {
   }
 #endif
 
-#ifdef HAVE_DROPBOX
-  s.beginGroup(DropboxSettings::kSettingsGroup);
-  const bool enable_dropbox = s.value(DropboxSettings::kEnabled, false).toBool();
-  s.endGroup();
-  if (enable_dropbox) {
-    ui_->tabs->EnableTab(dropbox_view_);
-  }
-  else {
-    ui_->tabs->DisableTab(dropbox_view_);
-  }
-#endif
-
   ui_->tabs->ReloadSettings();
 
 }
@@ -1353,12 +1344,10 @@ void MainWindow::ReloadAllSettings() {
   qobuz_view_->ReloadSettings();
   qobuz_view_->search_view()->ReloadSettings();
 #endif
-#ifdef HAVE_DROPBOX
-  dropbox_view_->ReloadSettings();
-#endif
 #ifdef HAVE_DISCORD_RPC
   discord_rich_presence_->ReloadSettings();
 #endif
+
 }
 
 void MainWindow::RefreshStyleSheet() {
@@ -2746,9 +2735,6 @@ void MainWindow::OpenServiceSettingsDialog(const Song::Source source) {
     case Song::Source::Spotify:
       settings_dialog_->OpenAtPage(SettingsDialog::Page::Spotify);
       break;
-    case Song::Source::Dropbox:
-      settings_dialog_->OpenAtPage(SettingsDialog::Page::Dropbox);
-      break;
     default:
       break;
   }
@@ -3430,11 +3416,6 @@ void MainWindow::FocusSearchField() {
   else if (ui_->tabs->currentIndex() == ui_->tabs->IndexOfTab(qobuz_view_) && !qobuz_view_->SearchFieldHasFocus()) {
     qobuz_view_->FocusSearchField();
   }
-#endif
-#ifdef HAVE_DROPBOX
-  else if (ui_->tabs->currentIndex() == ui_->tabs->IndexOfTab(dropbox_view_) && !dropbox_view_->SearchFieldHasFocus()) {
-    dropbox_view_->FocusSearchField();
-  }
 #endif
   else if (!ui_->playlist->SearchFieldHasFocus()) {
     ui_->playlist->FocusSearchField();

src/core/mainwindow.h

@@ -97,6 +97,7 @@ class Windows7ThumbBar;
 class AddStreamDialog;
 class LastFMImportDialog;
 class RadioViewContainer;
+class ArtistBioView;
 
 #ifdef HAVE_DISCORD_RPC
 namespace discord {
@@ -355,12 +356,11 @@ class MainWindow : public QMainWindow, public PlatformInterface {
 #ifdef HAVE_QOBUZ
   StreamingTabsView *qobuz_view_;
 #endif
-#ifdef HAVE_DROPBOX
-  StreamingSongsView *dropbox_view_;
-#endif
 
   RadioViewContainer *radio_view_;
 
+  ArtistBioView *artistbio_view_;
+
   LastFMImportDialog *lastfm_import_dialog_;
 
   QAction *collection_show_all_;

src/core/metatypes.cpp

@@ -68,6 +68,7 @@
 #include "smartplaylists/playlistgenerator_fwd.h"
 
 #include "radios/radiochannel.h"
+#include "widgets/collapsibleinfopane.h"
 
 #ifdef HAVE_MTP
 #  include "device/mtpconnection.h"
@@ -147,6 +148,8 @@ void RegisterMetaTypes() {
   qRegisterMetaType<RadioChannel>("RadioChannel");
   qRegisterMetaType<RadioChannelList>("RadioChannelList");
 
+  qRegisterMetaType<CollapsibleInfoPane::Data>("CollapsibleInfoPane::Data");
+
 #ifdef HAVE_MTP
   qRegisterMetaType<MtpConnection*>("MtpConnection*");
 #endif

src/core/song.cpp

@@ -1163,8 +1163,6 @@ QString Song::TextForSource(const Source source) {
     case Source::Qobuz:         return u"qobuz"_s;
     case Source::SomaFM:        return u"somafm"_s;
     case Source::RadioParadise: return u"radioparadise"_s;
-    case Source::Dropbox:       return u"dropbox"_s;
-    case Source::OneDrive:      return u"onedrive"_s;
     case Source::Unknown:       return u"unknown"_s;
   }
   return u"unknown"_s;
@@ -1185,8 +1183,6 @@ QString Song::DescriptionForSource(const Source source) {
     case Source::Qobuz:         return u"Qobuz"_s;
     case Source::SomaFM:        return u"SomaFM"_s;
     case Source::RadioParadise: return u"Radio Paradise"_s;
-    case Source::Dropbox:       return u"Dropbox"_s;
-    case Source::OneDrive:      return u"OneDrive"_s;
     case Source::Unknown:       return u"Unknown"_s;
   }
   return u"unknown"_s;
@@ -1206,8 +1202,6 @@ Song::Source Song::SourceFromText(const QString &source) {
   if (source.compare("qobuz"_L1, Qt::CaseInsensitive) == 0) return Source::Qobuz;
   if (source.compare("somafm"_L1, Qt::CaseInsensitive) == 0) return Source::SomaFM;
   if (source.compare("radioparadise"_L1, Qt::CaseInsensitive) == 0) return Source::RadioParadise;
-  if (source.compare("dropbox"_L1, Qt::CaseInsensitive) == 0) return Source::Dropbox;
-  if (source.compare("onedrive"_L1, Qt::CaseInsensitive) == 0) return Source::OneDrive;
 
   return Source::Unknown;
 
@@ -1227,8 +1221,6 @@ QIcon Song::IconForSource(const Source source) {
     case Source::Qobuz:         return IconLoader::Load(u"qobuz"_s);
     case Source::SomaFM:        return IconLoader::Load(u"somafm"_s);
     case Source::RadioParadise: return IconLoader::Load(u"radioparadise"_s);
-    case Source::Dropbox:       return IconLoader::Load(u"dropbox"_s);
-    case Source::OneDrive:      return IconLoader::Load(u"onedrive"_s);
     case Source::Unknown:       return IconLoader::Load(u"edit-delete"_s);
   }
   return IconLoader::Load(u"edit-delete"_s);
@@ -1478,7 +1470,7 @@ Song::FileType Song::FiletypeByExtension(const QString &ext) {
 
 bool Song::IsLinkedCollectionSource(const Source source) {
 
-  return source == Source::Collection || source == Source::Dropbox;
+  return source == Source::Collection;
 
 }
 
@@ -1497,14 +1489,11 @@ QString Song::ImageCacheDir(const Source source) {
       return StandardPaths::WritableLocation(StandardPaths::StandardLocation::AppLocalDataLocation) + u"/qobuzalbumcovers"_s;
     case Source::Device:
       return StandardPaths::WritableLocation(StandardPaths::StandardLocation::AppLocalDataLocation) + u"/devicealbumcovers"_s;
-    case Source::Dropbox:
-      return StandardPaths::WritableLocation(StandardPaths::StandardLocation::AppLocalDataLocation) + u"/dropboxalbumcovers"_s;
     case Source::LocalFile:
     case Source::CDDA:
     case Source::Stream:
     case Source::SomaFM:
     case Source::RadioParadise:
-    case Source::OneDrive:
     case Source::Unknown:
       return StandardPaths::WritableLocation(StandardPaths::StandardLocation::AppLocalDataLocation) + u"/albumcovers"_s;
   }

src/core/song.h

@@ -76,9 +76,7 @@ class Song {
     Qobuz = 8,
     SomaFM = 9,
     RadioParadise = 10,
-    Spotify = 11,
-    Dropbox = 12,
-    OneDrive = 13,
+    Spotify = 11
   };
   static const int kSourceCount = 16;
 

src/covermanager/albumcoverchoicecontroller.cpp

@@ -589,8 +589,6 @@ void AlbumCoverChoiceController::SaveArtManualToSong(Song *song, const QUrl &art
     case Song::Source::Tidal:
     case Song::Source::Spotify:
     case Song::Source::Qobuz:
-    case Song::Source::Dropbox:
-    case Song::Source::OneDrive:
       StreamingServicePtr service = streaming_services_->ServiceBySource(song->source());
       if (!service) break;
       if (service->artists_collection_backend()) {

src/dropbox/dropboxbaserequest.cpp

@@ -1,132 +0,0 @@
-/*
- * Strawberry Music Player
- * Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
- *
- * Strawberry 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.
- *
- * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#include "config.h"
-
-#include <QByteArray>
-#include <QString>
-#include <QUrl>
-#include <QNetworkReply>
-#include <QJsonObject>
-
-#include "constants/dropboxconstants.h"
-#include "core/networkaccessmanager.h"
-#include "dropboxservice.h"
-#include "dropboxbaserequest.h"
-
-using namespace Qt::Literals::StringLiterals;
-using namespace DropboxConstants;
-
-DropboxBaseRequest::DropboxBaseRequest(const SharedPtr<NetworkAccessManager> network, DropboxService *service, QObject *parent)
-    : JsonBaseRequest(network, parent),
-      service_(service) {}
-
-QString DropboxBaseRequest::service_name() const {
-
-  return service_->name();
-
-}
-
-bool DropboxBaseRequest::authentication_required() const {
-
-  return true;
-
-}
-
-bool DropboxBaseRequest::authenticated() const {
-
-  return service_->authenticated();
-
-}
-
-bool DropboxBaseRequest::use_authorization_header() const {
-
-  return true;
-
-}
-
-QByteArray DropboxBaseRequest::authorization_header() const {
-
-  return service_->authorization_header();
-
-}
-
-QNetworkReply *DropboxBaseRequest::GetTemporaryLink(const QUrl &url) {
-
-  QJsonObject json_object;
-  json_object.insert("path"_L1, url.path());
-  return CreatePostRequest(QUrl(QLatin1String(kApiUrl) + "/2/files/get_temporary_link"_L1), json_object);
-
-}
-
-JsonBaseRequest::JsonObjectResult DropboxBaseRequest::ParseJsonObject(QNetworkReply *reply) {
-
-  if (reply->error() != QNetworkReply::NoError && reply->error() < 200) {
-    return ReplyDataResult(ErrorCode::NetworkError, QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
-  }
-
-  JsonObjectResult result(ErrorCode::Success);
-  result.network_error = reply->error();
-  if (reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).isValid()) {
-    result.http_status_code = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
-  }
-
-  const QByteArray data = reply->readAll();
-  if (!data.isEmpty()) {
-    QJsonParseError json_parse_error;
-    const QJsonDocument json_document = QJsonDocument::fromJson(data, &json_parse_error);
-    if (json_parse_error.error == QJsonParseError::NoError) {
-      const QJsonObject json_object = json_document.object();
-      if (json_object.contains("error"_L1) && json_object["error"_L1].isObject()) {
-        const QJsonObject object_error = json_object["error"_L1].toObject();
-        if (object_error.contains("status"_L1) && object_error.contains("message"_L1)) {
-          const int status = object_error["status"_L1].toInt();
-          const QString message = object_error["message"_L1].toString();
-          result.error_code = ErrorCode::APIError;
-          result.error_message = QStringLiteral("%1 (%2)").arg(message).arg(status);
-        }
-      }
-      else {
-        result.json_object = json_document.object();
-      }
-    }
-    else {
-      result.error_code = ErrorCode::ParseError;
-      result.error_message = json_parse_error.errorString();
-    }
-  }
-
-  if (result.error_code != ErrorCode::APIError) {
-    if (reply->error() != QNetworkReply::NoError) {
-      result.error_code = ErrorCode::NetworkError;
-      result.error_message = QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
-    }
-    else if (result.http_status_code != 200) {
-      result.error_code = ErrorCode::HttpError;
-      result.error_message = QStringLiteral("Received HTTP code %1").arg(result.http_status_code);
-    }
-  }
-
-  if (reply->error() == QNetworkReply::AuthenticationRequiredError) {
-    service_->ClearSession();
-  }
-
-  return result;
-
-}

src/dropbox/dropboxbaserequest.h

@@ -1,59 +0,0 @@
-/*
- * Strawberry Music Player
- * Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
- *
- * Strawberry 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.
- *
- * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifndef DROPBOXBASEREQUEST_H
-#define DROPBOXBASEREQUEST_H
-
-#include "config.h"
-
-#include <QByteArray>
-#include <QString>
-#include <QUrl>
-
-#include "includes/shared_ptr.h"
-#include "core/jsonbaserequest.h"
-
-class QNetworkReply;
-class NetworkAccessManager;
-class DropboxService;
-
-class DropboxBaseRequest : public JsonBaseRequest {
-  Q_OBJECT
-
- public:
-  explicit DropboxBaseRequest(const SharedPtr<NetworkAccessManager> network, DropboxService *service, QObject *parent = nullptr);
-
-  QString service_name() const override;
-  bool authentication_required() const override;
-  bool authenticated() const override;
-  bool use_authorization_header() const override;
-  QByteArray authorization_header() const override;
-
- protected:
-  QNetworkReply *GetTemporaryLink(const QUrl &url);
-  JsonObjectResult ParseJsonObject(QNetworkReply *reply);
-
- Q_SIGNALS:
-  void ShowErrorDialog(const QString &error);
-
- private:
-  DropboxService *service_;
-};
-
-#endif  // DROPBOXBASEREQUEST_H

src/dropbox/dropboxservice.cpp

@@ -1,190 +0,0 @@
-/*
- * Strawberry Music Player
- * Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
- *
- * Strawberry 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.
- *
- * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#include <QString>
-#include <QUrl>
-#include <QTimer>
-
-#include "constants/dropboxsettings.h"
-#include "core/logging.h"
-#include "core/settings.h"
-#include "core/database.h"
-#include "core/urlhandlers.h"
-#include "core/networkaccessmanager.h"
-#include "core/oauthenticator.h"
-#include "collection/collectionbackend.h"
-#include "collection/collectionmodel.h"
-#include "streaming/cloudstoragestreamingservice.h"
-#include "dropboxservice.h"
-#include "dropboxurlhandler.h"
-#include "dropboxsongsrequest.h"
-#include "dropboxstreamurlrequest.h"
-
-using namespace Qt::Literals::StringLiterals;
-using namespace DropboxSettings;
-
-const Song::Source DropboxService::kSource = Song::Source::Dropbox;
-
-namespace {
-constexpr char kClientIDB64[] = "Zmx0b2EyYzRwaGo2eHlw";
-constexpr char kClientSecretB64[] = "emo3em5jNnNpM3Ftd2s3";
-constexpr char kOAuthRedirectUrl[] = "http://localhost/";
-constexpr char kOAuthAuthorizeUrl[] = "https://www.dropbox.com/1/oauth2/authorize";
-constexpr char kOAuthAccessTokenUrl[] = "https://api.dropboxapi.com/1/oauth2/token";
-}  // namespace
-
-DropboxService::DropboxService(const SharedPtr<TaskManager> task_manager,
-                               const SharedPtr<Database> database,
-                               const SharedPtr<NetworkAccessManager> network,
-                               const SharedPtr<UrlHandlers> url_handlers,
-                               const SharedPtr<TagReaderClient> tagreader_client,
-                               const SharedPtr<AlbumCoverLoader> albumcover_loader,
-                               QObject *parent)
-    : CloudStorageStreamingService(task_manager, database, tagreader_client, albumcover_loader, Song::Source::Dropbox, u"Dropbox"_s, u"dropbox"_s, QLatin1String(kSettingsGroup), parent),
-      network_(network),
-      oauth_(new OAuthenticator(network, this)),
-      songs_request_(new DropboxSongsRequest(network, collection_backend_, this, this)),
-      enabled_(false),
-      next_stream_url_request_id_(0) {
-
-  url_handlers->Register(new DropboxUrlHandler(task_manager, this, this));
-
-  oauth_->set_settings_group(QLatin1String(kSettingsGroup));
-  oauth_->set_type(OAuthenticator::Type::Authorization_Code);
-  oauth_->set_authorize_url(QUrl(QLatin1String(kOAuthAuthorizeUrl)));
-  oauth_->set_redirect_url(QUrl(QLatin1String(kOAuthRedirectUrl)));
-  oauth_->set_access_token_url(QUrl(QLatin1String(kOAuthAccessTokenUrl)));
-  oauth_->set_client_id(QString::fromLatin1(QByteArray::fromBase64(kClientIDB64)));
-  oauth_->set_client_secret(QString::fromLatin1(QByteArray::fromBase64(kClientSecretB64)));
-  oauth_->set_use_local_redirect_server(true);
-  oauth_->set_random_port(true);
-
-  QObject::connect(oauth_, &OAuthenticator::AuthenticationFinished, this, &DropboxService::OAuthFinished);
-
-  DropboxService::ReloadSettings();
-  oauth_->LoadSession();
-
-}
-
-bool DropboxService::authenticated() const {
-
-  return oauth_->authenticated();
-
-}
-
-void DropboxService::Exit() {
-
-  wait_for_exit_ << &*collection_backend_;
-  QObject::connect(&*collection_backend_, &CollectionBackend::ExitFinished, this, &DropboxService::ExitReceived);
-  collection_backend_->ExitAsync();
-
-}
-
-void DropboxService::ExitReceived() {
-
-  QObject *obj = sender();
-  QObject::disconnect(obj, nullptr, this, nullptr);
-  qLog(Debug) << obj << "successfully exited.";
-  wait_for_exit_.removeAll(obj);
-  if (wait_for_exit_.isEmpty()) Q_EMIT ExitFinished();
-
-}
-
-void DropboxService::ReloadSettings() {
-
-  Settings s;
-  s.beginGroup(kSettingsGroup);
-  enabled_ = s.value(kEnabled, false).toBool();
-  s.endGroup();
-
-}
-
-void DropboxService::Authenticate() {
-
-  oauth_->Authenticate();
-
-}
-
-void DropboxService::ClearSession() {
-
-  oauth_->ClearSession();
-}
-
-void DropboxService::OAuthFinished(const bool success, const QString &error) {
-
-  if (success) {
-    Q_EMIT LoginFinished(true);
-    Q_EMIT LoginSuccess();
-  }
-  else {
-    Q_EMIT LoginFailure(error);
-    Q_EMIT LoginFinished(false);
-  }
-
-}
-
-QByteArray DropboxService::authorization_header() const {
-  return oauth_->authorization_header();
-}
-
-void DropboxService::Start() {
-  songs_request_->GetFolderList();
-}
-
-void DropboxService::Reset() {
-
-  collection_backend_->DeleteAll();
-
-  Settings s;
-  s.beginGroup(kSettingsGroup);
-  s.remove("cursor");
-  s.endGroup();
-
-  if (authenticated()) {
-    Start();
-  }
-
-}
-
-uint DropboxService::GetStreamURL(const QUrl &url, QString &error) {
-
-  if (!authenticated()) {
-    error = tr("Not authenticated with Dropbox.");
-    return 0;
-  }
-
-  uint id = 0;
-  while (id == 0) id = ++next_stream_url_request_id_;
-  DropboxStreamURLRequestPtr stream_url_request = DropboxStreamURLRequestPtr(new DropboxStreamURLRequest(network_, this, id, url));
-  stream_url_requests_.insert(id, stream_url_request);
-  QObject::connect(&*stream_url_request, &DropboxStreamURLRequest::StreamURLRequestFinished, this, &DropboxService::StreamURLRequestFinishedSlot);
-  stream_url_request->Process();
-
-  return id;
-
-}
-
-void DropboxService::StreamURLRequestFinishedSlot(const uint id, const QUrl &media_url, const bool success, const QUrl &stream_url, const QString &error) {
-
-  if (!stream_url_requests_.contains(id)) return;
-  DropboxStreamURLRequestPtr stream_url_request = stream_url_requests_.take(id);
-
-  Q_EMIT StreamURLRequestFinished(id, media_url, success, stream_url, error);
-
-}

src/dropbox/dropboxservice.h

@@ -1,93 +0,0 @@
-/*
- * Strawberry Music Player
- * Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
- *
- * Strawberry 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.
- *
- * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifndef DROPBOXSERVICE_H
-#define DROPBOXSERVICE_H
-
-#include <QList>
-#include <QString>
-#include <QUrl>
-#include <QSharedPointer>
-
-#include "core/song.h"
-#include "streaming/cloudstoragestreamingservice.h"
-
-class QNetworkReply;
-
-class TaskManager;
-class Database;
-class NetworkAccessManager;
-class UrlHandlers;
-class TagReaderClient;
-class AlbumCoverLoader;
-class OAuthenticator;
-class DropboxSongsRequest;
-class DropboxStreamURLRequest;
-
-class DropboxService : public CloudStorageStreamingService {
-  Q_OBJECT
-
- public:
-  explicit DropboxService(const SharedPtr<TaskManager> task_manager,
-                          const SharedPtr<Database> database,
-                          const SharedPtr<NetworkAccessManager> network,
-                          const SharedPtr<UrlHandlers> url_handlers,
-                          const SharedPtr<TagReaderClient> tagreader_client,
-                          const SharedPtr<AlbumCoverLoader> albumcover_loader,
-                          QObject *parent = nullptr);
-
-  static const Song::Source kSource;
-
-  bool oauth() const override { return true; }
-  bool authenticated() const override;
-  bool show_progress() const override { return false; }
-  bool enable_refresh_button() const override { return false; }
-
-  void Exit() override;
-  void ReloadSettings() override;
-
-  void Authenticate();
-  void ClearSession();
-
-  void Start();
-  void Reset();
-  uint GetStreamURL(const QUrl &url, QString &error);
-
-  QByteArray authorization_header() const;
-
- Q_SIGNALS:
-  void StreamURLRequestFinished(const uint id, const QUrl &media_url, const bool success, const QUrl &stream_url, const QString &error = QString());
-
- private Q_SLOTS:
-  void ExitReceived();
-  void OAuthFinished(const bool success, const QString &error = QString());
-  void StreamURLRequestFinishedSlot(const uint id, const QUrl &media_url, const bool success, const QUrl &stream_url, const QString &error = QString());
-
- private:
-  const SharedPtr<NetworkAccessManager> network_;
-  OAuthenticator *oauth_;
-  DropboxSongsRequest *songs_request_;
-  bool enabled_;
-  QList<QObject*> wait_for_exit_;
-  bool finished_;
-  uint next_stream_url_request_id_;
-  QMap<uint, QSharedPointer<DropboxStreamURLRequest>> stream_url_requests_;
-};
-
-#endif  // DROPBOXSERVICE_H

src/dropbox/dropboxsongsrequest.cpp

@@ -1,244 +0,0 @@
-/*
- * Strawberry Music Player
- * Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
- *
- * Strawberry 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.
- *
- * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#include "config.h"
-
-#include <QByteArray>
-#include <QString>
-#include <QUrl>
-#include <QDateTime>
-#include <QTimer>
-#include <QNetworkReply>
-#include <QJsonObject>
-#include <QJsonArray>
-#include <QJsonValue>
-
-#include "constants/dropboxsettings.h"
-#include "core/logging.h"
-#include "core/settings.h"
-#include "core/networkaccessmanager.h"
-#include "collection/collectionbackend.h"
-#include "dropboxservice.h"
-#include "dropboxbaserequest.h"
-#include "dropboxsongsrequest.h"
-
-using namespace Qt::Literals::StringLiterals;
-using namespace DropboxSettings;
-
-DropboxSongsRequest::DropboxSongsRequest(const SharedPtr<NetworkAccessManager> network, const SharedPtr<CollectionBackend> collection_backend, DropboxService *service, QObject *parent)
-    : DropboxBaseRequest(network, service, parent),
-      network_(network),
-      collection_backend_(collection_backend),
-      service_(service) {}
-
-void DropboxSongsRequest::GetFolderList() {
-
-  Settings s;
-  s.beginGroup(kSettingsGroup);
-  QString cursor = s.value("cursor").toString();
-  s.endGroup();
-
-  QUrl url(QLatin1String(kApiUrl) + "/2/files/list_folder"_L1);
-  QJsonObject json_object;
-
-  if (cursor.isEmpty()) {
-    json_object.insert("path"_L1, ""_L1);
-    json_object.insert("recursive"_L1, true);
-    json_object.insert("include_deleted"_L1, true);
-  }
-  else {
-    url.setUrl(QLatin1String(kApiUrl) + "/2/files/list_folder/continue"_L1);
-    json_object.insert("cursor"_L1, cursor);
-  }
-
-  QNetworkReply *reply = CreatePostRequest(url, json_object);
-  QObject::connect(reply, &QNetworkReply::finished, this, [this, reply] { GetFolderListFinished(reply); });
-
-}
-
-void DropboxSongsRequest::GetFolderListFinished(QNetworkReply *reply) {
-
-  reply->deleteLater();
-
-  const JsonObjectResult json_object_result = ParseJsonObject(reply);
-  if (json_object_result.success()) {
-    Error(json_object_result.error_message);
-    return;
-  }
-
-  const QJsonObject &json_object = json_object_result.json_object;
-  if (json_object.isEmpty()) {
-    return;
-  }
-
-  if (json_object.contains("reset"_L1) && json_object["reset"_L1].toBool()) {
-    qLog(Debug) << "Resetting Dropbox database";
-    collection_backend_->DeleteAll();
-  }
-
-  {
-    Settings s;
-    s.beginGroup(kSettingsGroup);
-    s.setValue("cursor", json_object["cursor"_L1].toString());
-    s.endGroup();
-  }
-
-  const QJsonArray entires = json_object["entries"_L1].toArray();
-  qLog(Debug) << "File list found:" << entires.size();
-
-  QList<QUrl> urls_deleted;
-  for (const QJsonValue &value_entry : entires) {
-    if (!value_entry.isObject()) {
-      continue;
-    }
-    const QJsonObject object_entry = value_entry.toObject();
-    const QString tag = object_entry[".tag"_L1].toString();
-    const QString path = object_entry["path_lower"_L1].toString();
-    const qint64 size = object_entry["size"_L1].toInt();
-    const QString server_modified = object_entry["server_modified"_L1].toString();
-
-    QUrl url;
-    url.setScheme(service_->url_scheme());
-    url.setPath(path);
-
-    if (tag == "deleted"_L1) {
-      qLog(Debug) << "Deleting song with URL" << url;
-      urls_deleted << url;
-      continue;
-    }
-
-    if (tag == "folder"_L1) {
-      continue;
-    }
-
-    if (DropboxService::IsSupportedFiletype(path)) {
-      GetStreamURL(url, path, size, QDateTime::fromString(server_modified, Qt::ISODate).toSecsSinceEpoch());
-    }
-
-  }
-
-  if (!urls_deleted.isEmpty()) {
-    collection_backend_->DeleteSongsByUrlsAsync(urls_deleted);
-  }
-
-  if (json_object.contains("has_more"_L1) && json_object["has_more"_L1].isBool() && json_object["has_more"_L1].toBool()) {
-    Settings s;
-    s.beginGroup(kSettingsGroup);
-    s.setValue("cursor", json_object["cursor"_L1].toVariant());
-    s.endGroup();
-    GetFolderList();
-  }
-  else {
-    // Long-poll wait for changes.
-    LongPollDelta();
-  }
-
-}
-
-void DropboxSongsRequest::LongPollDelta() {
-
-  if (!service_->authenticated()) {
-    return;
-  }
-
-  Settings s;
-  s.beginGroup(kSettingsGroup);
-  const QString cursor = s.value("cursor").toString();
-  s.endGroup();
-
-  QJsonObject json_object;
-  json_object.insert("cursor"_L1, cursor);
-  json_object.insert("timeout"_L1, 30);
-
-  QNetworkReply *reply = CreatePostRequest(QUrl(QLatin1String(kNotifyApiUrl) + "/2/files/list_folder/longpoll"_L1), json_object);
-  QObject::connect(reply, &QNetworkReply::finished, this, [this, reply] { LongPollDeltaFinished(reply); });
-
-}
-
-void DropboxSongsRequest::LongPollDeltaFinished(QNetworkReply *reply) {
-
-  reply->deleteLater();
-
-  const JsonObjectResult json_object_result = ParseJsonObject(reply);
-  if (json_object_result.success()) {
-    Error(json_object_result.error_message);
-    return;
-  }
-
-  const QJsonObject &json_object = json_object_result.json_object;
-  if (json_object["changes"_L1].toBool()) {
-    qLog(Debug) << "Dropbox: Received changes...";
-    GetFolderList();
-  }
-  else {
-    bool ok = false;
-    int backoff = json_object["backoff"_L1].toString().toInt(&ok);
-    if (!ok) {
-      backoff = 10;
-    }
-    QTimer::singleShot(backoff * 1000, this, &DropboxSongsRequest::LongPollDelta);
-  }
-
-}
-
-void DropboxSongsRequest::GetStreamURL(const QUrl &url, const QString &path, const qint64 size, const qint64 mtime) {
-
-  QNetworkReply *reply = GetTemporaryLink(url);
-  QObject::connect(reply, &QNetworkReply::finished, this, [this, reply, path, size, mtime]() {
-    GetStreamUrlFinished(reply, path, size, mtime);
-  });
-
-}
-
-void DropboxSongsRequest::GetStreamUrlFinished(QNetworkReply *reply, const QString &filename, const qint64 size, const qint64 mtime) {
-
-  reply->deleteLater();
-
-  const JsonObjectResult json_object_result = ParseJsonObject(reply);
-  if (!json_object_result.success()) {
-    Error(json_object_result.error_message);
-    return;
-  }
-
-  const QJsonObject &json_object = json_object_result.json_object;
-  if (json_object.isEmpty()) {
-    return;
-  }
-
-  if (!json_object.contains("link"_L1)) {
-    Error(u"Missing link"_s);
-    return;
-  }
-
-  const QUrl url = QUrl::fromEncoded(json_object["link"_L1].toVariant().toByteArray());
-
-  service_->MaybeAddFileToDatabase(url, filename, size, mtime);
-
-}
-
-void DropboxSongsRequest::Error(const QString &error_message, const QVariant &debug_output) {
-
-  qLog(Error) << service_name() << error_message;
-  if (debug_output.isValid()) {
-    qLog(Debug) << debug_output;
-  }
-
-  Q_EMIT ShowErrorDialog(error_message);
-
-}

src/dropbox/dropboxsongsrequest.h

@@ -1,67 +0,0 @@
-/*
- * Strawberry Music Player
- * Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
- *
- * Strawberry 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.
- *
- * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifndef DROPBOXSONGSREQUEST_H
-#define DROPBOXSONGSREQUEST_H
-
-#include "config.h"
-
-#include <QList>
-#include <QString>
-#include <QUrl>
-
-#include "dropboxbaserequest.h"
-
-class NetworkAccessManager;
-class CollectionBackend;
-class QNetworkReply;
-class DropboxService;
-
-class DropboxSongsRequest : public DropboxBaseRequest {
-  Q_OBJECT
-
- public:
-  explicit DropboxSongsRequest(const SharedPtr<NetworkAccessManager> network, const SharedPtr<CollectionBackend> collection_backend, DropboxService *service, QObject *parent = nullptr);
-
-  void ReloadSettings();
-
-  void GetFolderList();
-
- Q_SIGNALS:
-  void ShowErrorDialog(const QString &error);
-
- private:
-  void LongPollDelta();
-  void GetStreamURL(const QUrl &url, const QString &path, const qint64 size, const qint64 mtime);
-
- protected:
-  void Error(const QString &error_message, const QVariant &debug_output = QVariant()) override;
-
- private Q_SLOTS:
-  void GetFolderListFinished(QNetworkReply *reply);
-  void LongPollDeltaFinished(QNetworkReply *reply);
-  void GetStreamUrlFinished(QNetworkReply *reply, const QString &filename, const qint64 size, const qint64 mtime);
-
- private:
-  const SharedPtr<NetworkAccessManager> network_;
-  const SharedPtr<CollectionBackend> collection_backend_;
-  DropboxService *service_;
-};
-
-#endif  // DROPBOXSONGSREQUEST_H

src/dropbox/dropboxstreamurlrequest.cpp

@@ -1,129 +0,0 @@
-/*
- * Strawberry Music Player
- * Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
- *
- * Strawberry 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.
- *
- * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#include "config.h"
-
-#include <QByteArray>
-#include <QString>
-#include <QUrl>
-#include <QNetworkReply>
-#include <QJsonObject>
-
-#include "includes/shared_ptr.h"
-#include "core/logging.h"
-#include "core/networkaccessmanager.h"
-#include "dropboxservice.h"
-#include "dropboxbaserequest.h"
-#include "dropboxstreamurlrequest.h"
-
-using namespace Qt::Literals::StringLiterals;
-
-DropboxStreamURLRequest::DropboxStreamURLRequest(const SharedPtr<NetworkAccessManager> network, DropboxService *service, const uint id, const QUrl &media_url, QObject *parent)
-    : DropboxBaseRequest(network, service, parent),
-      network_(network),
-      service_(service),
-      id_(id),
-      media_url_(media_url),
-      reply_(nullptr) {}
-
-DropboxStreamURLRequest::~DropboxStreamURLRequest() {
-
-  if (reply_) {
-    QObject::disconnect(reply_, nullptr, this, nullptr);
-    if (reply_->isRunning()) reply_->abort();
-    reply_->deleteLater();
-    reply_ = nullptr;
-  }
-
-}
-
-void DropboxStreamURLRequest::Cancel() {
-
-  if (reply_ && reply_->isRunning()) {
-    reply_->abort();
-  }
-
-}
-
-void DropboxStreamURLRequest::Process() {
-
-  GetStreamURL();
-
-}
-
-void DropboxStreamURLRequest::GetStreamURL() {
-
-  if (reply_) {
-    QObject::disconnect(reply_, nullptr, this, nullptr);
-    if (reply_->isRunning()) reply_->abort();
-    reply_->deleteLater();
-  }
-
-  reply_ = GetTemporaryLink(media_url_);
-  QObject::connect(reply_, &QNetworkReply::finished, this, &DropboxStreamURLRequest::StreamURLReceived);
-
-}
-
-void DropboxStreamURLRequest::StreamURLReceived() {
-
-  const QScopeGuard finish = qScopeGuard([this]() { Finish(); });
-
-  if (!reply_) return;
-
-  Q_ASSERT(replies_.contains(reply_));
-  replies_.removeAll(reply_);
-
-  const JsonObjectResult json_object_result = ParseJsonObject(reply_).json_object;
-
-  QObject::disconnect(reply_, nullptr, this, nullptr);
-  reply_->deleteLater();
-  reply_ = nullptr;
-
-  if (!json_object_result.success()) {
-    Error(json_object_result.error_message);
-    return;
-  }
-
-  const QJsonObject &json_object = json_object_result.json_object;
-  if (json_object.isEmpty() || !json_object.contains("link"_L1)) {
-    Error(u"Could not parse stream URL"_s);
-    return;
-  }
-
-  stream_url_ = QUrl::fromEncoded(json_object["link"_L1].toVariant().toByteArray());
-  success_ = stream_url_.isValid();
-
-}
-
-void DropboxStreamURLRequest::Error(const QString &error_message, const QVariant &debug_output) {
-
-  qLog(Error) << service_name() << error_message;
-  if (debug_output.isValid()) {
-    qLog(Debug) << debug_output;
-  }
-
-  error_ = error_message;
-
-}
-
-void DropboxStreamURLRequest::Finish() {
-
-  Q_EMIT StreamURLRequestFinished(id_, media_url_, success_, stream_url_, error_);
-
-}

src/dropbox/dropboxstreamurlrequest.h

@@ -1,71 +0,0 @@
-/*
- * Strawberry Music Player
- * Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
- *
- * Strawberry 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.
- *
- * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifndef DROPBOXSTREAMURLREQUEST_H
-#define DROPBOXSTREAMURLREQUEST_H
-
-#include "config.h"
-
-#include <QVariant>
-#include <QString>
-#include <QUrl>
-#include <QSharedPointer>
-
-#include "includes/shared_ptr.h"
-#include "dropboxservice.h"
-#include "dropboxbaserequest.h"
-
-class QNetworkReply;
-class NetworkAccessManager;
-
-class DropboxStreamURLRequest : public DropboxBaseRequest {
-  Q_OBJECT
-
- public:
-  explicit DropboxStreamURLRequest(const SharedPtr<NetworkAccessManager> network, DropboxService *service, const uint id, const QUrl &media_url, QObject *parent = nullptr);
-  ~DropboxStreamURLRequest() override;
-
-  void Process();
-  void Cancel();
-
- Q_SIGNALS:
-  void StreamURLRequestFinished(const uint id, const QUrl &media_url, const bool success, const QUrl &stream_url, const QString &error = QString());
-
- private Q_SLOTS:
-  void StreamURLReceived();
-
- private:
-  void GetStreamURL();
-  void Error(const QString &error_message, const QVariant &debug_output = QVariant()) override;
-  void Finish();
-
- private:
-  const SharedPtr<NetworkAccessManager> network_;
-  DropboxService *service_;
-  uint id_;
-  QUrl media_url_;
-  QUrl stream_url_;
-  QNetworkReply *reply_;
-  bool success_;
-  QString error_;
-};
-
-using DropboxStreamURLRequestPtr = QSharedPointer<DropboxStreamURLRequest>;
-
-#endif  // DROPBOXSTREAMURLREQUEST_H

src/dropbox/dropboxurlhandler.cpp

@@ -1,76 +0,0 @@
-/*
- * Strawberry Music Player
- * Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
- *
- * Strawberry 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.
- *
- * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#include <QString>
-#include <QUrl>
-
-#include "includes/shared_ptr.h"
-#include "core/taskmanager.h"
-#include "dropboxurlhandler.h"
-#include "dropboxservice.h"
-
-DropboxUrlHandler::DropboxUrlHandler(const SharedPtr<TaskManager> task_manager, DropboxService *service, QObject *parent)
-    : UrlHandler(parent),
-      task_manager_(task_manager),
-      service_(service) {
-
-  QObject::connect(service, &DropboxService::StreamURLRequestFinished, this, &DropboxUrlHandler::StreamURLRequestFinished);
-
-}
-
-QString DropboxUrlHandler::scheme() const { return service_->url_scheme(); }
-
-UrlHandler::LoadResult DropboxUrlHandler::StartLoading(const QUrl &url) {
-
-  Request request;
-  request.task_id = task_manager_->StartTask(QStringLiteral("Loading %1 stream...").arg(url.scheme()));
-  QString error;
-  request.id = service_->GetStreamURL(url, error);
-  if (request.id == 0) {
-    CancelTask(request.task_id);
-    return LoadResult(url, LoadResult::Type::Error, error);
-  }
-
-  requests_.insert(request.id, request);
-
-  LoadResult load_result(url);
-  load_result.type_ = LoadResult::Type::WillLoadAsynchronously;
-
-  return load_result;
-
-}
-
-void DropboxUrlHandler::StreamURLRequestFinished(const uint id, const QUrl &media_url, const bool success, const QUrl &stream_url, const QString &error) {
-
-  if (!requests_.contains(id)) return;
-  const Request request = requests_.take(id);
-  CancelTask(request.task_id);
-
-  if (success) {
-    Q_EMIT AsyncLoadComplete(LoadResult(media_url, LoadResult::Type::TrackAvailable, stream_url));
-  }
-  else {
-    Q_EMIT AsyncLoadComplete(LoadResult(media_url, LoadResult::Type::Error, error));
-  }
-
-}
-
-void DropboxUrlHandler::CancelTask(const int task_id) {
-  task_manager_->SetTaskFinished(task_id);
-}

src/dropbox/dropboxurlhandler.h

@@ -1,56 +0,0 @@
-/*
- * Strawberry Music Player
- * Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
- *
- * Strawberry 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.
- *
- * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifndef DROPBOXURLHANDLER_H
-#define DROPBOXURLHANDLER_H
-
-#include "includes/shared_ptr.h"
-#include "core/urlhandler.h"
-
-class TaskManager;
-class DropboxService;
-
-class DropboxUrlHandler : public UrlHandler {
-  Q_OBJECT
-
- public:
-  explicit DropboxUrlHandler(const SharedPtr<TaskManager> task_manager, DropboxService *service, QObject *parent = nullptr);
-
-  QString scheme() const override;
-  LoadResult StartLoading(const QUrl &url) override;
-
- private:
-  void CancelTask(const int task_id);
-
- private Q_SLOTS:
-  void StreamURLRequestFinished(const uint id, const QUrl &media_url, const bool success, const QUrl &stream_url, const QString &error = QString());
-
- private:
-  class Request {
-   public:
-    explicit Request() : id(0), task_id(-1) {}
-    uint id;
-    int task_id;
-  };
-  const SharedPtr<TaskManager> task_manager_;
-  DropboxService *service_;
-  QMap<uint, Request> requests_;
-};
-
-#endif  // DROPBOXURLHANDLER_H

src/playlist/playlistbackend.cpp

@@ -56,7 +56,7 @@ using namespace Qt::Literals::StringLiterals;
 using std::make_shared;
 
 namespace {
-constexpr int kSongTableJoins = 3;
+constexpr int kSongTableJoins = 2;
 }
 
 PlaylistBackend::PlaylistBackend(const SharedPtr<Database> database,
@@ -186,12 +186,10 @@ PlaylistBackend::Playlist PlaylistBackend::GetPlaylist(const int id) {
 
 QString PlaylistBackend::PlaylistItemsQuery() {
 
-  return QStringLiteral("SELECT %1, %2, %3, p.type FROM playlist_items AS p "
+  return QStringLiteral("SELECT %1, %2, p.type FROM playlist_items AS p "
                         "LEFT JOIN songs ON p.type = songs.source AND p.collection_id = songs.ROWID "
-                        "LEFT JOIN dropbox_songs ON p.type = dropbox_songs.source AND p.collection_id = dropbox_songs.ROWID "
                         "WHERE p.playlist = :playlist"
                         ).arg(Song::JoinSpec(u"songs"_s),
-                              Song::JoinSpec(u"dropbox_songs"_s),
                               Song::JoinSpec(u"p"_s));
 
 }

src/playlist/playlistitem.cpp

@@ -47,8 +47,6 @@ PlaylistItemPtr PlaylistItem::NewFromSource(const Song::Source source) {
 
   switch (source) {
     case Song::Source::Collection:
-    case Song::Source::Dropbox:
-    case Song::Source::OneDrive:
       return make_shared<CollectionPlaylistItem>(source);
     case Song::Source::Subsonic:
     case Song::Source::Tidal:
@@ -74,8 +72,6 @@ PlaylistItemPtr PlaylistItem::NewFromSong(const Song &song) {
 
   switch (song.source()) {
     case Song::Source::Collection:
-    case Song::Source::Dropbox:
-    case Song::Source::OneDrive:
       return make_shared<CollectionPlaylistItem>(song);
     case Song::Source::Subsonic:
     case Song::Source::Tidal:

src/playlist/songplaylistitem.cpp

@@ -34,7 +34,7 @@ SongPlaylistItem::SongPlaylistItem(const Song::Source source) : PlaylistItem(sou
 SongPlaylistItem::SongPlaylistItem(const Song &song) : PlaylistItem(song.source()), song_(song) {}
 
 bool SongPlaylistItem::InitFromQuery(const SqlRow &query) {
-  song_.InitFromQuery(query, false, static_cast<int>(Song::kRowIdColumns.count() * 2));
+  song_.InitFromQuery(query, false, static_cast<int>(Song::kRowIdColumns.count()));
   return true;
 }
 

src/playlist/streamplaylistitem.cpp

@@ -47,7 +47,7 @@ void StreamPlaylistItem::InitMetadata() {
 
 bool StreamPlaylistItem::InitFromQuery(const SqlRow &query) {
 
-  song_.InitFromQuery(query, false, static_cast<int>(Song::kRowIdColumns.count() * 2));
+  song_.InitFromQuery(query, false, static_cast<int>(Song::kRowIdColumns.count()));
   InitMetadata();
   return true;
 

src/settings/behavioursettingspage.cpp

@@ -165,6 +165,7 @@ void BehaviourSettingsPage::Load() {
 
   ui_->checkbox_resumeplayback->setChecked(s.value(kResumePlayback, false).toBool());
   ui_->checkbox_playingwidget->setChecked(s.value(kPlayingWidget, true).toBool());
+  ui_->checkbox_artistbio->setChecked(s.value("artistbio", false).toBool());
 
 #ifndef Q_OS_MACOS
   const StartupBehaviour startup_behaviour = static_cast<StartupBehaviour>(s.value(kStartupBehaviour, static_cast<int>(StartupBehaviour::Remember)).toInt());
@@ -232,9 +233,12 @@ void BehaviourSettingsPage::Save() {
 #if defined(HAVE_DBUS) && !defined(Q_OS_MACOS)
   s.setValue(kTaskbarProgress, ui_->checkbox_taskbar_progress->isChecked());
 #endif
+
   s.setValue(kResumePlayback, ui_->checkbox_resumeplayback->isChecked());
   s.setValue(kPlayingWidget, ui_->checkbox_playingwidget->isChecked());
 
+  s.setValue("artistbio", ui_->checkbox_artistbio->isChecked());
+
   StartupBehaviour startup_behaviour = StartupBehaviour::Remember;
   if (ui_->radiobutton_remember->isChecked()) startup_behaviour = StartupBehaviour::Remember;
   if (ui_->radiobutton_show->isChecked()) startup_behaviour = StartupBehaviour::Show;

src/settings/behavioursettingspage.ui

@@ -65,6 +65,13 @@
      </property>
     </widget>
    </item>
+   <item>
+    <widget class="QCheckBox" name="checkbox_artistbio">
+     <property name="text">
+      <string>Artist biography</string>
+     </property>
+    </widget>
+   </item>
    <item>
     <widget class="QGroupBox" name="groupbox_startup">
      <property name="title">

src/settings/dropboxsettingspage.cpp

@@ -1,144 +0,0 @@
-/*
- * Strawberry Music Player
- * Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
- *
- * Strawberry 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.
- *
- * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#include <QObject>
-#include <QVariant>
-#include <QByteArray>
-#include <QString>
-#include <QSettings>
-#include <QCheckBox>
-#include <QComboBox>
-#include <QLineEdit>
-#include <QPushButton>
-#include <QSpinBox>
-#include <QMessageBox>
-#include <QEvent>
-
-#include "constants/dropboxsettings.h"
-#include "core/settings.h"
-#include "core/iconloader.h"
-#include "widgets/loginstatewidget.h"
-#include "dropbox/dropboxservice.h"
-#include "settingsdialog.h"
-#include "dropboxsettingspage.h"
-#include "ui_dropboxsettingspage.h"
-
-using namespace Qt::Literals::StringLiterals;
-using namespace DropboxSettings;
-
-DropboxSettingsPage::DropboxSettingsPage(SettingsDialog *dialog, const SharedPtr<DropboxService> service, QWidget *parent)
-    : SettingsPage(dialog, parent),
-      ui_(new Ui_DropboxSettingsPage),
-      service_(service) {
-
-  Q_ASSERT(service);
-
-  ui_->setupUi(this);
-
-  setWindowIcon(IconLoader::Load(u"dropbox"_s));
-
-  ui_->login_state->AddCredentialGroup(ui_->widget_authorization);
-
-  QObject::connect(ui_->button_login, &QPushButton::clicked, this, &DropboxSettingsPage::LoginClicked);
-  QObject::connect(ui_->button_reset, &QPushButton::clicked, this, &DropboxSettingsPage::ResetClicked);
-  QObject::connect(ui_->login_state, &LoginStateWidget::LogoutClicked, this, &DropboxSettingsPage::LogoutClicked);
-
-  QObject::connect(this, &DropboxSettingsPage::Authorize, &*service_, &DropboxService::Authenticate);
-  QObject::connect(&*service_, &StreamingService::LoginFailure, this, &DropboxSettingsPage::LoginFailure);
-  QObject::connect(&*service_, &StreamingService::LoginSuccess, this, &DropboxSettingsPage::LoginSuccess);
-
-  dialog->installEventFilter(this);
-
-}
-
-DropboxSettingsPage::~DropboxSettingsPage() {
-  delete ui_;
-}
-
-void DropboxSettingsPage::Load() {
-
-  Settings s;
-  s.beginGroup(kSettingsGroup);
-  ui_->enable->setChecked(s.value(kEnabled, false).toBool());
-  s.endGroup();
-
-  if (service_->authenticated()) ui_->login_state->SetLoggedIn(LoginStateWidget::State::LoggedIn);
-
-  Init(ui_->layout_dropboxsettingspage->parentWidget());
-
-  if (!Settings().childGroups().contains(QLatin1String(kSettingsGroup))) set_changed();
-
-}
-
-void DropboxSettingsPage::Save() {
-
-  Settings s;
-  s.beginGroup(kSettingsGroup);
-  s.setValue(kEnabled, ui_->enable->isChecked());
-  s.endGroup();
-
-}
-
-void DropboxSettingsPage::LoginClicked() {
-
-  Q_EMIT Authorize();
-
-  ui_->button_login->setEnabled(false);
-
-}
-
-bool DropboxSettingsPage::eventFilter(QObject *object, QEvent *event) {
-
-  if (object == dialog() && event->type() == QEvent::Enter) {
-    ui_->button_login->setEnabled(true);
-  }
-
-  return SettingsPage::eventFilter(object, event);
-
-}
-
-void DropboxSettingsPage::LogoutClicked() {
-
-  service_->ClearSession();
-  ui_->button_login->setEnabled(true);
-  ui_->login_state->SetLoggedIn(LoginStateWidget::State::LoggedOut);
-
-}
-
-void DropboxSettingsPage::LoginSuccess() {
-
-  if (!isVisible()) return;
-  ui_->login_state->SetLoggedIn(LoginStateWidget::State::LoggedIn);
-  ui_->button_login->setEnabled(true);
-
-}
-
-void DropboxSettingsPage::LoginFailure(const QString &failure_reason) {
-
-  if (!isVisible()) return;
-  QMessageBox::warning(this, tr("Authentication failed"), failure_reason);
-  ui_->button_login->setEnabled(true);
-
-}
-
-void DropboxSettingsPage::ResetClicked() {
-
-  service_->Reset();
-
-}

src/settings/dropboxsettingspage.h

@@ -1,58 +0,0 @@
-/*
- * Strawberry Music Player
- * Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
- *
- * Strawberry 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.
- *
- * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifndef DROPBOXSETTINGSPAGE_H
-#define DROPBOXSETTINGSPAGE_H
-
-#include <QObject>
-
-#include "includes/shared_ptr.h"
-#include "settingspage.h"
-
-class DropboxService;
-class Ui_DropboxSettingsPage;
-
-class DropboxSettingsPage : public SettingsPage {
-  Q_OBJECT
-
- public:
-  explicit DropboxSettingsPage(SettingsDialog *dialog, const SharedPtr<DropboxService> service, QWidget *parent);
-  ~DropboxSettingsPage();
-
-  void Load() override;
-  void Save() override;
-
-  bool eventFilter(QObject *object, QEvent *event) override;
-
- Q_SIGNALS:
-  void Authorize();
-
- private Q_SLOTS:
-  void LoginClicked();
-  void LogoutClicked();
-  void LoginSuccess();
-  void LoginFailure(const QString &failure_reason);
-  void ResetClicked();
-
- private:
-  Ui_DropboxSettingsPage *ui_;
-  const SharedPtr<DropboxService> service_;
-};
-
-#endif  // DROPBOXSETTINGSPAGE_H

src/settings/dropboxsettingspage.ui

@@ -1,125 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ui version="4.0">
- <class>DropboxSettingsPage</class>
- <widget class="QWidget" name="DropboxSettingsPage">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>569</width>
-    <height>491</height>
-   </rect>
-  </property>
-  <property name="windowTitle">
-   <string>Dropbox</string>
-  </property>
-  <layout class="QVBoxLayout" name="layout_dropboxsettingspage">
-   <item>
-    <widget class="QLabel" name="label_info">
-     <property name="text">
-      <string>Strawberry can play music that you have uploaded to Dropbox</string>
-     </property>
-     <property name="wordWrap">
-      <bool>true</bool>
-     </property>
-    </widget>
-   </item>
-   <item>
-    <widget class="QCheckBox" name="enable">
-     <property name="text">
-      <string>Enable</string>
-     </property>
-    </widget>
-   </item>
-   <item>
-    <widget class="LoginStateWidget" name="login_state" native="true"/>
-   </item>
-   <item>
-    <widget class="QWidget" name="widget_authorization" native="true">
-     <layout class="QVBoxLayout" name="verticalLayout">
-      <property name="leftMargin">
-       <number>28</number>
-      </property>
-      <property name="topMargin">
-       <number>0</number>
-      </property>
-      <property name="bottomMargin">
-       <number>0</number>
-      </property>
-      <item>
-       <layout class="QHBoxLayout" name="horizontalLayout">
-        <item>
-         <widget class="QPushButton" name="button_login">
-          <property name="text">
-           <string>Login</string>
-          </property>
-         </widget>
-        </item>
-        <item>
-         <spacer name="spacer_login">
-          <property name="orientation">
-           <enum>Qt::Horizontal</enum>
-          </property>
-          <property name="sizeHint" stdset="0">
-           <size>
-            <width>40</width>
-            <height>20</height>
-           </size>
-          </property>
-         </spacer>
-        </item>
-       </layout>
-      </item>
-     </layout>
-    </widget>
-   </item>
-   <item>
-    <layout class="QHBoxLayout" name="layout_buttons">
-     <item>
-      <widget class="QPushButton" name="button_reset">
-       <property name="text">
-        <string>Reset cursor and songs</string>
-       </property>
-      </widget>
-     </item>
-     <item>
-      <spacer name="spacer_buttons">
-       <property name="orientation">
-        <enum>Qt::Horizontal</enum>
-       </property>
-       <property name="sizeHint" stdset="0">
-        <size>
-         <width>40</width>
-         <height>20</height>
-        </size>
-       </property>
-      </spacer>
-     </item>
-    </layout>
-   </item>
-   <item>
-    <spacer name="spacer_bottom">
-     <property name="orientation">
-      <enum>Qt::Vertical</enum>
-     </property>
-     <property name="sizeHint" stdset="0">
-      <size>
-       <width>20</width>
-       <height>357</height>
-      </size>
-     </property>
-    </spacer>
-   </item>
-  </layout>
- </widget>
- <customwidgets>
-  <customwidget>
-   <class>LoginStateWidget</class>
-   <extends>QWidget</extends>
-   <header>widgets/loginstatewidget.h</header>
-   <container>1</container>
-  </customwidget>
- </customwidgets>
- <resources/>
- <connections/>
-</ui>

src/settings/settingsdialog.cpp

@@ -90,10 +90,6 @@
 #  include "qobuz/qobuzservice.h"
 #  include "qobuzsettingspage.h"
 #endif
-#ifdef HAVE_DROPBOX
-#  include "dropbox/dropboxservice.h"
-#  include "dropboxsettingspage.h"
-#endif
 
 #include "ui_settingsdialog.h"
 
@@ -148,7 +144,7 @@ SettingsDialog::SettingsDialog(const SharedPtr<Player> player,
   AddPage(Page::Moodbar, new MoodbarSettingsPage(this, this), iface);
 #endif
 
-#if defined(HAVE_SUBSONIC) || defined(HAVE_TIDAL) || defined(HAVE_SPOTIFY) || defined(HAVE_QOBUZ) || defined(HAVE_DROPBOX)
+#if defined(HAVE_SUBSONIC) || defined(HAVE_TIDAL) || defined(HAVE_SPOTIFY) || defined(HAVE_QOBUZ)
   QTreeWidgetItem *streaming = AddCategory(tr("Streaming"));
 #endif
 
@@ -164,9 +160,6 @@ SettingsDialog::SettingsDialog(const SharedPtr<Player> player,
 #ifdef HAVE_QOBUZ
   AddPage(Page::Qobuz, new QobuzSettingsPage(this, streaming_services->Service<QobuzService>(), this), streaming);
 #endif
-#ifdef HAVE_DROPBOX
-  AddPage(Page::Dropbox, new DropboxSettingsPage(this, streaming_services->Service<DropboxService>(), this), streaming);
-#endif
 
   // List box
   QObject::connect(ui_->list, &QTreeWidget::currentItemChanged, this, &SettingsDialog::CurrentItemChanged);

src/settings/settingsdialog.h

@@ -93,8 +93,6 @@ class SettingsDialog : public QDialog {
     Tidal,
     Qobuz,
     Spotify,
-    Dropbox,
-    OneDrive,
   };
 
   enum Role {

src/streaming/cloudstoragestreamingservice.cpp

@@ -1,134 +0,0 @@
-/*
- * Strawberry Music Player
- * Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
- *
- * Strawberry 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.
- *
- * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#include <memory>
-
-#include <QString>
-#include <QUrl>
-#include <QFileInfo>
-
-#include "core/logging.h"
-#include "core/database.h"
-#include "core/taskmanager.h"
-#include "core/song.h"
-#include "collection/collectionbackend.h"
-#include "collection/collectionmodel.h"
-#include "playlist/playlist.h"
-#include "cloudstoragestreamingservice.h"
-
-using namespace Qt::Literals::StringLiterals;
-using std::make_shared;
-
-CloudStorageStreamingService::CloudStorageStreamingService(const SharedPtr<TaskManager> task_manager,
-                                                           const SharedPtr<Database> database,
-                                                           const SharedPtr<TagReaderClient> tagreader_client,
-                                                           const SharedPtr<AlbumCoverLoader> albumcover_loader,
-                                                           const Song::Source source,
-                                                           const QString &name,
-                                                           const QString &url_scheme,
-                                                           const QString &settings_group,
-                                                           QObject *parent)
-    : StreamingService(source, name, url_scheme, settings_group, parent),
-      task_manager_(task_manager),
-      tagreader_client_(tagreader_client),
-      source_(source),
-      indexing_task_id_(-1),
-      indexing_task_progress_(0),
-      indexing_task_max_(0) {
-
-  collection_backend_ = make_shared<CollectionBackend>();
-  collection_backend_->moveToThread(database->thread());
-  collection_backend_->Init(database, task_manager, source, name + "_songs"_L1);
-  collection_model_ = new CollectionModel(collection_backend_, albumcover_loader, this);
-
-}
-
-void CloudStorageStreamingService::MaybeAddFileToDatabase(const QUrl &url, const QString &filename, const size_t size, const quint64 mtime, const QString &token_type, const QString &access_token) {
-
-  if (!IsSupportedFiletype(filename)) {
-    return;
-  }
-
-  if (indexing_task_id_ == -1) {
-    indexing_task_id_ = task_manager_->StartTask(tr("Indexing %1").arg(name()));
-    indexing_task_progress_ = 0;
-    indexing_task_max_ = 0;
-  }
-  indexing_task_max_++;
-  task_manager_->SetTaskProgress(indexing_task_id_, indexing_task_progress_, indexing_task_max_);
-
-  TagReaderReadStreamReplyPtr reply = tagreader_client_->ReadStreamAsync(url, filename, size, mtime, token_type, access_token);
-  pending_tagreader_replies_.append(reply);
-
-  SharedPtr<QMetaObject::Connection> connection = make_shared<QMetaObject::Connection>();
-  *connection = QObject::connect(&*reply, &TagReaderReadStreamReply::Finished, this, [this, reply, url, filename, connection]() {
-    ReadStreamFinished(reply, url, filename);
-    QObject::disconnect(*connection);
-  }, Qt::QueuedConnection);
-
-}
-
-void CloudStorageStreamingService::ReadStreamFinished(TagReaderReadStreamReplyPtr reply, const QUrl url, const QString filename) {
-
-  ++indexing_task_progress_;
-  if (indexing_task_progress_ >= indexing_task_max_) {
-    task_manager_->SetTaskFinished(indexing_task_id_);
-    indexing_task_id_ = -1;
-    Q_EMIT AllIndexingTasksFinished();
-  }
-  else {
-    task_manager_->SetTaskProgress(indexing_task_id_, indexing_task_progress_, indexing_task_max_);
-  }
-
-  if (!reply->result().success()) {
-    qLog(Error) << "Failed to read tags from stream, URL" << url << reply->result().error_string();
-    return;
-  }
-
-  Song song = reply->song();
-  song.set_source(source_);
-  song.set_directory_id(0);
-  QUrl song_url;
-  song_url.setScheme(url_scheme());
-  song_url.setPath(filename);
-  song.set_url(song_url);
-
-  collection_backend_->AddOrUpdateSongs(SongList() << song);
-
-}
-
-bool CloudStorageStreamingService::IsSupportedFiletype(const QString &filename) {
-
-  const QFileInfo fileinfo(filename);
-  return Song::kAcceptedExtensions.contains(fileinfo.suffix(), Qt::CaseInsensitive) && !Song::kRejectedExtensions.contains(fileinfo.suffix(), Qt::CaseInsensitive);
-
-}
-
-void CloudStorageStreamingService::AbortReadTagsReplies() {
-
-  qLog(Debug) << "Aborting the read tags replies";
-
-  pending_tagreader_replies_.clear();
-
-  task_manager_->SetTaskFinished(indexing_task_id_);
-  indexing_task_id_ = -1;
-
-  Q_EMIT AllIndexingTasksFinished();
-
-}

src/streaming/cloudstoragestreamingservice.h

@@ -1,89 +0,0 @@
-/*
- * Strawberry Music Player
- * Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
- *
- * Strawberry 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.
- *
- * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifndef CLOUDSTORAGESTREAMINGSERVICE_H
-#define CLOUDSTORAGESTREAMINGSERVICE_H
-
-#include <QList>
-
-#include "includes/shared_ptr.h"
-#include "tagreader/tagreaderclient.h"
-#include "streamingservice.h"
-#include "covermanager/albumcovermanager.h"
-#include "collection/collectionmodel.h"
-
-class TaskManager;
-class Database;
-class TagReaderClient;
-class AlbumCoverLoader;
-class CollectionBackend;
-class CollectionModel;
-class NetworkAccessManager;
-
-class CloudStorageStreamingService : public StreamingService {
-  Q_OBJECT
-
- public:
-  explicit CloudStorageStreamingService(const SharedPtr<TaskManager> task_manager,
-                                        const SharedPtr<Database> database,
-                                        const SharedPtr<TagReaderClient> tagreader_client,
-                                        const SharedPtr<AlbumCoverLoader> albumcover_loader,
-                                        const Song::Source source,
-                                        const QString &name,
-                                        const QString &url_scheme,
-                                        const QString &settings_group,
-                                        QObject *parent = nullptr);
-
-  bool is_indexing() const { return indexing_task_id_ != -1; }
-
-  SharedPtr<CollectionBackend> collection_backend() const { return collection_backend_; }
-  CollectionModel *collection_model() const { return collection_model_; }
-  CollectionFilter *collection_filter_model() const { return collection_model_->filter(); }
-
-  SharedPtr<CollectionBackend> songs_collection_backend() override { return collection_backend_; }
-  CollectionModel *songs_collection_model() override { return collection_model_; }
-  CollectionFilter *songs_collection_filter_model() override { return collection_model_->filter(); }
-
-  virtual void MaybeAddFileToDatabase(const QUrl &url, const QString &filename, const size_t size, const quint64 mtime, const QString &token_type = QString(), const QString &access_token = QString());
-  static bool IsSupportedFiletype(const QString &filename);
-
- Q_SIGNALS:
-  void AllIndexingTasksFinished();
-
- protected:
-  void AbortReadTagsReplies();
-
- protected Q_SLOTS:
-  void ReadStreamFinished(TagReaderReadStreamReplyPtr reply, const QUrl url, const QString filename);
-
- protected:
-  const SharedPtr<TaskManager> task_manager_;
-  const SharedPtr<TagReaderClient> tagreader_client_;
-  SharedPtr<CollectionBackend> collection_backend_;
-  CollectionModel *collection_model_;
-  QList<TagReaderReplyPtr> pending_tagreader_replies_;
-
- private:
-  Song::Source source_;
-  int indexing_task_id_;
-  int indexing_task_progress_;
-  int indexing_task_max_;
-};
-
-#endif  // CLOUDSTORAGESTREAMINGSERVICE_H

src/utilities/coverutils.cpp

@@ -142,8 +142,6 @@ QString CoverUtils::CoverFilenameFromSource(const Song::Source source, const QUr
     case Song::Source::Stream:
     case Song::Source::SomaFM:
     case Song::Source::RadioParadise:
-    case Song::Source::Dropbox:
-    case Song::Source::OneDrive:
     case Song::Source::Unknown:
       filename = QString::fromLatin1(Sha1CoverHash(artist, album).toHex());
       break;

src/widgets/collapsibleinfoheader.cpp

@@ -0,0 +1,174 @@
+/*
+ * Strawberry Music Player
+ * This file was part of Clementine.
+ * Copyright 2010, David Sansome <me@davidsansome.com>
+ *
+ * Strawberry 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.
+ *
+ * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <QWidget>
+#include <QApplication>
+#include <QString>
+#include <QIcon>
+#include <QPainter>
+#include <QPalette>
+#include <QColor>
+#include <QStyle>
+#include <QFont>
+#include <QPropertyAnimation>
+#include <QStyleOption>
+#include <QEnterEvent>
+#include <QPaintEvent>
+#include <QMouseEvent>
+#include <QEvent>
+
+#include "collapsibleinfoheader.h"
+
+const int CollapsibleInfoHeader::kHeight = 20;
+const int CollapsibleInfoHeader::kIconSize = 16;
+
+CollapsibleInfoHeader::CollapsibleInfoHeader(QWidget* parent)
+    : QWidget(parent),
+      expanded_(false),
+      hovering_(false),
+      animation_(new QPropertyAnimation(this, "opacity", this)),
+      opacity_(0.0) {
+
+  setMinimumHeight(kHeight);
+  setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
+  setCursor(QCursor(Qt::PointingHandCursor));
+
+}
+
+void CollapsibleInfoHeader::SetTitle(const QString &title) {
+  title_ = title;
+  update();
+}
+
+void CollapsibleInfoHeader::SetIcon(const QIcon &icon) {
+  icon_ = icon;
+  update();
+}
+
+void CollapsibleInfoHeader::SetExpanded(const bool expanded) {
+
+  expanded_ = expanded;
+
+  emit ExpandedToggled(expanded);
+  if (expanded)
+    emit Expanded();
+  else
+    emit Collapsed();
+}
+
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+void CollapsibleInfoHeader::enterEvent(QEnterEvent*) {
+#else
+void CollapsibleInfoHeader::enterEvent(QEvent*) {
+#endif
+
+  hovering_ = true;
+  if (!expanded_) {
+    animation_->stop();
+    animation_->setEndValue(1.0);
+    animation_->setDuration(80);
+    animation_->start();
+  }
+
+}
+
+void CollapsibleInfoHeader::leaveEvent(QEvent*) {
+
+  hovering_ = false;
+  if (!expanded_) {
+    animation_->stop();
+    animation_->setEndValue(0.0);
+    animation_->setDuration(160);
+    animation_->start();
+  }
+
+}
+
+void CollapsibleInfoHeader::set_opacity(const float opacity) {
+  opacity_ = opacity;
+  update();
+}
+
+void CollapsibleInfoHeader::paintEvent(QPaintEvent*) {
+
+  QPainter p(this);
+
+  QColor active_text_color(palette().color(QPalette::Active, QPalette::HighlightedText));
+  QColor inactive_text_color(palette().color(QPalette::Active, QPalette::Text));
+  QColor text_color;
+  if (expanded_) {
+    text_color = active_text_color;
+  }
+  else {
+    p.setOpacity(0.4 + opacity_ * 0.6);
+    text_color = QColor(active_text_color.red() * opacity_ + inactive_text_color.red() * (1.0 - opacity_), active_text_color.green() * opacity_ + inactive_text_color.green() * (1.0 - opacity_), active_text_color.blue() * opacity_ + inactive_text_color.blue() * (1.0 - opacity_));
+  }
+
+  QRect indicator_rect(0, 0, height(), height());
+  QRect icon_rect(height() + 2, (kHeight - kIconSize) / 2, kIconSize, kIconSize);
+  QRect text_rect(rect());
+  text_rect.setLeft(icon_rect.right() + 4);
+
+  // Draw the background
+  QColor highlight(palette().color(QPalette::Active, QPalette::Highlight));
+  const QColor bg_color_1(highlight.lighter(120));
+  const QColor bg_color_2(highlight.darker(120));
+  const QColor bg_border(palette().color(QPalette::Dark));
+  QLinearGradient bg_brush(rect().topLeft(), rect().bottomLeft());
+  bg_brush.setColorAt(0.0, bg_color_1);
+  bg_brush.setColorAt(0.5, bg_color_1);
+  bg_brush.setColorAt(0.5, bg_color_2);
+  bg_brush.setColorAt(1.0, bg_color_2);
+
+  p.setPen(Qt::NoPen);
+  p.fillRect(rect(), bg_brush);
+
+  p.setPen(bg_border);
+  p.drawLine(rect().topLeft(), rect().topRight());
+  p.drawLine(rect().bottomLeft(), rect().bottomRight());
+
+  // Draw the expand/collapse indicator
+  QStyleOption opt;
+  opt.initFrom(this);
+  opt.rect = indicator_rect;
+  opt.state |= QStyle::State_Children;
+  if (expanded_) opt.state |= QStyle::State_Open;
+  if (hovering_) opt.state |= QStyle::State_Active;
+
+  // Have to use the application's style here because using the widget's style
+  // will trigger QStyleSheetStyle's recursion guard (I don't know why).
+  QApplication::style()->drawPrimitive(QStyle::PE_IndicatorBranch, &opt, &p, this);
+
+  // Draw the icon
+  p.drawPixmap(icon_rect, icon_.pixmap(kIconSize));
+
+  // Draw the title text
+  QFont bold_font(font());
+  bold_font.setBold(true);
+  p.setFont(bold_font);
+
+  p.setPen(text_color);
+  p.drawText(text_rect, Qt::AlignLeft | Qt::AlignVCenter, title_);
+
+}
+
+void CollapsibleInfoHeader::mouseReleaseEvent(QMouseEvent*) {
+  SetExpanded(!expanded_);
+}

src/widgets/collapsibleinfoheader.h

@@ -0,0 +1,82 @@
+/*
+ * Strawberry Music Player
+ * This file was part of Clementine.
+ * Copyright 2010, David Sansome <me@davidsansome.com>
+ *
+ * Strawberry 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.
+ *
+ * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef COLLAPSIBLEINFOHEADER_H
+#define COLLAPSIBLEINFOHEADER_H
+
+#include <QWidget>
+#include <QString>
+#include <QIcon>
+
+class QPropertyAnimation;
+class QEnterEvent;
+class QEvent;
+class QPaintEvent;
+class QMouseEvent;
+
+class CollapsibleInfoHeader : public QWidget {
+  Q_OBJECT
+  Q_PROPERTY(float opacity READ opacity WRITE set_opacity)
+
+ public:
+  CollapsibleInfoHeader(QWidget *parent = nullptr);
+
+  static const int kHeight;
+  static const int kIconSize;
+
+  bool expanded() const { return expanded_; }
+  bool hovering() const { return hovering_; }
+  const QString &title() const { return title_; }
+  const QIcon &icon() const { return icon_; }
+
+  float opacity() const { return opacity_; }
+  void set_opacity(const float opacity);
+
+ public Q_SLOTS:
+  void SetExpanded(const bool expanded);
+  void SetTitle(const QString &title);
+  void SetIcon(const QIcon &icon);
+
+ Q_SIGNALS:
+  void Expanded();
+  void Collapsed();
+  void ExpandedToggled(const bool expanded);
+
+ protected:
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+  void enterEvent(QEnterEvent*) override;
+#else
+  void enterEvent(QEvent*) override;
+#endif
+  void leaveEvent(QEvent*) override;
+  void paintEvent(QPaintEvent*) override;
+  void mouseReleaseEvent(QMouseEvent*) override;
+
+ private:
+  bool expanded_;
+  bool hovering_;
+  QString title_;
+  QIcon icon_;
+
+  QPropertyAnimation *animation_;
+  float opacity_;
+};
+
+#endif  // COLLAPSIBLEINFOHEADER_H

src/widgets/collapsibleinfopane.cpp

@@ -0,0 +1,64 @@
+/*
+ * Strawberry Music Player
+ * This file was part of Clementine.
+ * Copyright 2010, David Sansome <me@davidsansome.com>
+ *
+ * Strawberry 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.
+ *
+ * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "collapsibleinfoheader.h"
+#include "collapsibleinfopane.h"
+
+#include <QVBoxLayout>
+
+CollapsibleInfoPane::CollapsibleInfoPane(const Data &data, QWidget *parent)
+    : QWidget(parent), data_(data), header_(new CollapsibleInfoHeader(this)) {
+
+  QVBoxLayout* layout = new QVBoxLayout(this);
+  layout->setContentsMargins(0, 0, 0, 0);
+  layout->setSpacing(3);
+  layout->setSizeConstraint(QLayout::SetMinAndMaxSize);
+  setLayout(layout);
+
+  layout->addWidget(header_);
+  layout->addWidget(data.contents_);
+  data.contents_->hide();
+
+  header_->SetTitle(data.title_);
+  header_->SetIcon(data.icon_);
+
+  setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Maximum);
+
+  connect(header_, SIGNAL(ExpandedToggled(bool)), SLOT(ExpandedToggled(bool)));
+  connect(header_, SIGNAL(ExpandedToggled(bool)), SIGNAL(Toggled(bool)));
+
+}
+
+void CollapsibleInfoPane::Collapse() { header_->SetExpanded(false); }
+
+void CollapsibleInfoPane::Expand() { header_->SetExpanded(true); }
+
+void CollapsibleInfoPane::ExpandedToggled(bool expanded) {
+  data_.contents_->setVisible(expanded);
+}
+
+bool CollapsibleInfoPane::Data::operator<(const CollapsibleInfoPane::Data &other) const {
+
+  const int my_score = (TypeCount - type_) * 1000 + relevance_;
+  const int other_score = (TypeCount - other.type_) * 1000 + other.relevance_;
+
+  return my_score > other_score;
+
+}

src/widgets/collapsibleinfopane.h

@@ -0,0 +1,72 @@
+/*
+ * Strawberry Music Player
+ * This file was part of Clementine.
+ * Copyright 2010, David Sansome <me@davidsansome.com>
+ *
+ * Strawberry 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.
+ *
+ * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef COLLAPSIBLEINFOPANE_H
+#define COLLAPSIBLEINFOPANE_H
+
+#include <QIcon>
+#include <QWidget>
+
+class CollapsibleInfoHeader;
+
+class CollapsibleInfoPane : public QWidget {
+  Q_OBJECT
+
+ public:
+  struct Data {
+    explicit Data() : type_(Type_Biography), relevance_(0) {}
+
+    bool operator<(const Data& other) const;
+
+    enum Type {
+      Type_Biography,
+      TypeCount
+    };
+
+    QString id_;
+    QString title_;
+    QIcon icon_;
+    Type type_;
+    int relevance_;
+
+    QWidget *contents_;
+    QObject *content_object_;
+  };
+
+  CollapsibleInfoPane(const Data &data, QWidget* parent = nullptr);
+
+  const Data &data() const { return data_; }
+
+ public Q_SLOTS:
+  void Expand();
+  void Collapse();
+
+ Q_SIGNALS:
+  void Toggled(const bool expanded);
+
+ private Q_SLOTS:
+  void ExpandedToggled(const bool expanded);
+
+ private:
+  Data data_;
+  CollapsibleInfoHeader *header_;
+};
+
+#endif  // COLLAPSIBLEINFOPANE_H

src/widgets/infotextview.cpp

@@ -0,0 +1,89 @@
+/*
+ * Strawberry Music Player
+ * This file was part of Clementine.
+ * Copyright 2010, David Sansome <me@davidsansome.com>
+ *
+ * Strawberry 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.
+ *
+ * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <QWidget>
+#include <QApplication>
+#include <QMenu>
+#include <QWheelEvent>
+#include <QRegularExpression>
+#include <QtDebug>
+
+#include "core/logging.h"
+#include "infotextview.h"
+
+InfoTextView::InfoTextView(QWidget *parent) : QTextBrowser(parent), last_width_(-1), recursion_filter_(false) {
+    
+  setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+  setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+  setOpenExternalLinks(true);
+
+}
+
+void InfoTextView::resizeEvent(QResizeEvent *e) {
+
+  const int w = qMax(100, width());
+  if (w == last_width_) return;
+  last_width_ = w;
+
+  document()->setTextWidth(w);
+  setMinimumHeight(document()->size().height());
+
+  QTextBrowser::resizeEvent(e);
+
+}
+
+QSize InfoTextView::sizeHint() const { return minimumSize(); }
+
+void InfoTextView::wheelEvent(QWheelEvent *e) { e->ignore(); }
+
+void InfoTextView::SetHtml(const QString &html) {
+
+  QString copy(html.trimmed());
+
+  // Simplify newlines
+  copy.replace(QRegularExpression(QStringLiteral("\\r\\n?")), QStringLiteral("\n"));
+
+  // Convert two or more newlines to <p>, convert single newlines to <br>
+  copy.replace(QRegularExpression(QStringLiteral("([^>])([\\t ]*\\n){2,}")), QStringLiteral("\\1<p>"));
+  copy.replace(QRegularExpression(QStringLiteral("([^>])[\\t ]*\\n")), QStringLiteral("\\1<br>"));
+
+  // Strip any newlines from the end
+  copy.replace(QRegularExpression(QStringLiteral("((<\\s*br\\s*/?\\s*>)|(<\\s*/?\\s*p\\s*/?\\s*>))+$")), QLatin1String(""));
+
+  setHtml(copy);
+
+}
+
+// Prevents QTextDocument from trying to load remote images before they are ready.
+QVariant InfoTextView::loadResource(int type, const QUrl &name) {
+
+  if (recursion_filter_) {
+    recursion_filter_ = false;
+    return QVariant();
+  }
+  recursion_filter_ = true;
+  if (type == QTextDocument::ImageResource && name.scheme() == QLatin1String("http")) {
+    if (document()->resource(type, name).isNull()) {
+      return QVariant();
+    }
+  }
+  return QTextBrowser::loadResource(type, name);
+
+}

src/widgets/infotextview.h

@@ -0,0 +1,52 @@
+/*
+ * Strawberry Music Player
+ * This file was part of Clementine.
+ * Copyright 2010, David Sansome <me@davidsansome.com>
+ *
+ * Strawberry 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.
+ *
+ * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef INFOTEXTVIEW_H
+#define INFOTEXTVIEW_H
+
+#include <QTextBrowser>
+#include <QString>
+#include <QUrl>
+
+class QResizeEvent;
+class QWheelEvent;
+
+class InfoTextView : public QTextBrowser {
+  Q_OBJECT
+
+ public:
+  explicit InfoTextView(QWidget *parent = nullptr);
+
+  QSize sizeHint() const override;
+
+ public Q_SLOTS:
+  void SetHtml(const QString &html);
+
+ protected:
+  void resizeEvent(QResizeEvent *e) override;
+  void wheelEvent(QWheelEvent *e) override;
+  QVariant loadResource(int type, const QUrl &name) override;
+
+ private:
+  int last_width_;
+  bool recursion_filter_;
+};
+
+#endif  // INFOTEXTVIEW_H

src/widgets/prettyimage.cpp

@@ -0,0 +1,257 @@
+/*
+ * Strawberry Music Player
+ * This file was part of Clementine.
+ * Copyright 2010, David Sansome <me@davidsansome.com>
+ *
+ * Strawberry 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.
+ *
+ * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <QApplication>
+#include <QWindow>
+#include <QScreen>
+#include <QtConcurrentRun>
+#include <QFuture>
+#include <QString>
+#include <QImage>
+#include <QPixmap>
+#include <QPainter>
+#include <QFileInfo>
+#include <QDir>
+#include <QFileDialog>
+#include <QNetworkAccessManager>
+#include <QNetworkReply>
+#include <QSettings>
+#include <QLabel>
+#include <QMenu>
+#include <QScrollArea>
+#include <QContextMenuEvent>
+
+#include "core/logging.h"
+#include "core/networkaccessmanager.h"
+#include "core/iconloader.h"
+
+#include "prettyimage.h"
+
+const int PrettyImage::kTotalHeight = 200;
+const int PrettyImage::kReflectionHeight = 40;
+const int PrettyImage::kImageHeight = PrettyImage::kTotalHeight - PrettyImage::kReflectionHeight;
+
+const int PrettyImage::kMaxImageWidth = 300;
+
+const char *PrettyImage::kSettingsGroup = "PrettyImageView";
+
+PrettyImage::PrettyImage(const QUrl &url, QNetworkAccessManager *network, QWidget *parent)
+    : QWidget(parent),
+      network_(network),
+      state_(State_WaitingForLazyLoad),
+      url_(url),
+      menu_(nullptr) {
+
+  setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
+
+  LazyLoad();
+
+}
+
+void PrettyImage::LazyLoad() {
+
+  if (state_ != State_WaitingForLazyLoad) return;
+
+  // Start fetching the image
+  QNetworkReply *reply = network_->get(QNetworkRequest(url_));
+  state_ = State_Fetching;
+  QObject::connect(reply, &QNetworkReply::finished, this, [this, reply]() { ImageFetched(reply); });
+
+}
+
+QSize PrettyImage::image_size() const {
+
+  if (state_ != State_Finished) return QSize(kImageHeight * 1.6, kImageHeight);
+
+  QSize ret = image_.size();
+  ret.scale(kMaxImageWidth, kImageHeight, Qt::KeepAspectRatio);
+  return ret;
+
+}
+
+QSize PrettyImage::sizeHint() const {
+  return QSize(image_size().width(), kTotalHeight);
+}
+
+void PrettyImage::ImageFetched(QNetworkReply *reply) {
+
+  reply->deleteLater();
+
+  QImage image = QImage::fromData(reply->readAll());
+  if (image.isNull()) {
+    qLog(Debug) << "Image failed to load" << reply->request().url() << reply->error();
+    deleteLater();
+  }
+  else {
+    state_ = State_CreatingThumbnail;
+    image_ = image;
+    (void)QtConcurrent::run([=]{ ImageScaled(image_.scaled(image_size(), Qt::KeepAspectRatio, Qt::SmoothTransformation)); });
+  }
+
+}
+
+void PrettyImage::ImageScaled(QImage image) {
+
+  thumbnail_ = QPixmap::fromImage(image);
+  state_ = State_Finished;
+
+  updateGeometry();
+  update();
+  emit Loaded();
+
+}
+
+void PrettyImage::paintEvent(QPaintEvent*) {
+
+  // Draw at the bottom of our area
+  QRect image_rect(QPoint(0, 0), image_size());
+  image_rect.moveBottom(kImageHeight);
+
+  QPainter p(this);
+
+  // Draw the main image
+  DrawThumbnail(&p, image_rect);
+
+  // Draw the reflection
+  // Figure out where to draw it
+  QRect reflection_rect(image_rect);
+  reflection_rect.moveTop(image_rect.bottom());
+
+  // Create the reflected pixmap
+  QImage reflection(reflection_rect.size(), QImage::Format_ARGB32_Premultiplied);
+  reflection.fill(palette().color(QPalette::Base).rgba());
+  QPainter reflection_painter(&reflection);
+
+  // Set up the transformation
+  QTransform transform;
+  transform.scale(1.0, -1.0);
+  transform.translate(0.0, -reflection_rect.height());
+  reflection_painter.setTransform(transform);
+
+  QRect fade_rect(reflection.rect().bottomLeft() - QPoint(0, kReflectionHeight), reflection.rect().bottomRight());
+
+  // Draw the reflection into the buffer
+  DrawThumbnail(&reflection_painter, reflection.rect());
+
+  // Make it fade out towards the bottom
+  QLinearGradient fade_gradient(fade_rect.topLeft(), fade_rect.bottomLeft());
+  fade_gradient.setColorAt(0.0, QColor(0, 0, 0, 0));
+  fade_gradient.setColorAt(1.0, QColor(0, 0, 0, 128));
+
+  reflection_painter.setCompositionMode(QPainter::CompositionMode_DestinationIn);
+  reflection_painter.fillRect(fade_rect, fade_gradient);
+
+  reflection_painter.end();
+
+  // Draw the reflection on the image
+  p.drawImage(reflection_rect, reflection);
+
+}
+
+void PrettyImage::DrawThumbnail(QPainter *p, const QRect &rect) {
+
+  switch (state_) {
+    case State_WaitingForLazyLoad:
+    case State_Fetching:
+    case State_CreatingThumbnail:
+      p->setPen(palette().color(QPalette::Disabled, QPalette::Text));
+      p->drawText(rect, Qt::AlignHCenter | Qt::AlignBottom, tr("Loading..."));
+      break;
+
+    case State_Finished:
+      p->drawPixmap(rect, thumbnail_);
+      break;
+  }
+
+}
+
+void PrettyImage::contextMenuEvent(QContextMenuEvent *e) {
+
+  if (e->pos().y() >= kImageHeight) return;
+
+  if (!menu_) {
+    menu_ = new QMenu(this);
+    menu_->addAction(IconLoader::Load(QStringLiteral("zoom-in")), tr("Show fullsize..."), this, &PrettyImage::ShowFullsize);
+    menu_->addAction(IconLoader::Load(QStringLiteral("document-save")), tr("Save image") + QLatin1String("..."), this, &PrettyImage::SaveAs);
+  }
+
+  menu_->popup(e->globalPos());
+
+}
+
+void PrettyImage::ShowFullsize() {
+
+  // Create the window
+  QScrollArea *pwindow = new QScrollArea;
+  pwindow->setAttribute(Qt::WA_DeleteOnClose, true);
+  pwindow->setWindowTitle(tr("%1 image viewer").arg(QLatin1String("Strawberry")));
+
+  // Work out how large to make the window, based on the size of the screen
+#if (QT_VERSION >= QT_VERSION_CHECK(5, 14, 0))
+  QScreen *screen = QWidget::screen();
+#else
+  QScreen *screen = (window() && window()->windowHandle() ? window()->windowHandle()->screen() : QGuiApplication::primaryScreen());
+#endif
+  if (screen) {
+    QRect desktop_rect(screen->availableGeometry());
+    QSize window_size(qMin(desktop_rect.width() - 20, image_.width()), qMin(desktop_rect.height() - 20, image_.height()));
+    pwindow->resize(window_size);
+  }
+
+  // Create the label that displays the image
+  QLabel *label = new QLabel(pwindow);
+  label->setPixmap(QPixmap::fromImage(image_));
+
+  // Show the label in the window
+  pwindow->setWidget(label);
+  pwindow->setFrameShape(QFrame::NoFrame);
+  pwindow->show();
+
+}
+
+void PrettyImage::SaveAs() {
+
+  QString filename = QFileInfo(url_.path()).fileName();
+
+  if (filename.isEmpty()) filename = QLatin1String("artwork.jpg");
+
+  QSettings s;
+  s.beginGroup(kSettingsGroup);
+  QString last_save_dir = s.value("last_save_dir", QDir::homePath()).toString();
+
+  QString path = last_save_dir.isEmpty() ? QDir::homePath() : last_save_dir;
+  QFileInfo path_info(path);
+  if (path_info.isDir()) {
+    path += QLatin1Char('/') + filename;
+  }
+  else {
+    path = path_info.path() + QLatin1Char('/') + filename;
+  }
+
+  filename = QFileDialog::getSaveFileName(this, tr("Save image"), path);
+  if (filename.isEmpty()) return;
+
+  image_.save(filename);
+
+  s.setValue("last_save_dir", last_save_dir);
+  
+  s.endGroup();
+
+}

src/widgets/prettyimage.h

@@ -0,0 +1,92 @@
+/*
+ * Strawberry Music Player
+ * This file was part of Clementine.
+ * Copyright 2010, David Sansome <me@davidsansome.com>
+ *
+ * Strawberry 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.
+ *
+ * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef PRETTYIMAGE_H
+#define PRETTYIMAGE_H
+
+#include <QWidget>
+#include <QString>
+#include <QUrl>
+#include <QImage>
+#include <QPixmap>
+#include <QPainter>
+
+class QMenu;
+class QNetworkAccessManager;
+class QNetworkReply;
+class QContextMenuEvent;
+class QPaintEvent;
+
+class PrettyImage : public QWidget {
+  Q_OBJECT
+
+ public:
+  PrettyImage(const QUrl &url, QNetworkAccessManager *network, QWidget *parent = nullptr);
+
+  static const int kTotalHeight;
+  static const int kReflectionHeight;
+  static const int kImageHeight;
+
+  static const int kMaxImageWidth;
+
+  static const char *kSettingsGroup;
+
+  QSize sizeHint() const override;
+  QSize image_size() const;
+
+signals:
+  void Loaded();
+
+ public slots:
+  void LazyLoad();
+  void SaveAs();
+  void ShowFullsize();
+
+ protected:
+  void contextMenuEvent(QContextMenuEvent*) override;
+  void paintEvent(QPaintEvent*) override;
+
+ private slots:
+  void ImageFetched(QNetworkReply *reply);
+  void ImageScaled(QImage image);
+
+ private:
+  enum State {
+    State_WaitingForLazyLoad,
+    State_Fetching,
+    State_CreatingThumbnail,
+    State_Finished,
+  };
+
+  void DrawThumbnail(QPainter *p, const QRect &rect);
+
+ private:
+  QNetworkAccessManager *network_;
+  State state_;
+  QUrl url_;
+
+  QImage image_;
+  QPixmap thumbnail_;
+
+  QMenu *menu_;
+  QString last_save_dir_;
+};
+
+#endif  // PRETTYIMAGE_H

src/widgets/prettyimageview.cpp

@@ -0,0 +1,189 @@
+/*
+ * Strawberry Music Player
+ * This file was part of Clementine.
+ * Copyright 2010, David Sansome <me@davidsansome.com>
+ *
+ * Strawberry 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.
+ *
+ * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <QObject>
+#include <QUrl>
+#include <QNetworkAccessManager>
+#include <QPropertyAnimation>
+#include <QAbstractSlider>
+#include <QHBoxLayout>
+#include <QScrollArea>
+#include <QScrollBar>
+#include <QTimer>
+#include <QMouseEvent>
+#include <QResizeEvent>
+#include <QWheelEvent>
+
+#include "core/networkaccessmanager.h"
+
+#include "prettyimage.h"
+#include "prettyimageview.h"
+
+PrettyImageView::PrettyImageView(QNetworkAccessManager *network, QWidget* parent)
+    : QScrollArea(parent),
+      network_(network),
+      container_(new QWidget(this)),
+      layout_(new QHBoxLayout(container_)),
+      current_index_(-1),
+      scroll_animation_(new QPropertyAnimation(horizontalScrollBar(), "value", this)),
+      recursion_filter_(false) {
+
+  setWidget(container_);
+  setWidgetResizable(true);
+  setMinimumHeight(PrettyImage::kTotalHeight + 10);
+  setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
+  setFrameShape(QFrame::NoFrame);
+  setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+
+  scroll_animation_->setDuration(250);
+  scroll_animation_->setEasingCurve(QEasingCurve::InOutCubic);
+  connect(horizontalScrollBar(), SIGNAL(sliderReleased()), SLOT(ScrollBarReleased()));
+  connect(horizontalScrollBar(), SIGNAL(actionTriggered(int)), SLOT(ScrollBarAction(int)));
+
+  layout_->setSizeConstraint(QLayout::SetMinAndMaxSize);
+  layout_->setContentsMargins(6, 6, 6, 6);
+  layout_->setSpacing(6);
+  layout_->addSpacing(200);
+  layout_->addSpacing(200);
+
+  container_->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
+
+}
+
+bool PrettyImageView::eventFilter(QObject *obj, QEvent *event) {
+
+  // Work around infinite recursion in QScrollArea resizes.
+  if (recursion_filter_) {
+    return false;
+  }
+  recursion_filter_ = true;
+  bool ret = QScrollArea::eventFilter(obj, event);
+  recursion_filter_ = false;
+  return ret;
+
+}
+
+void PrettyImageView::AddImage(const QUrl &url) {
+
+  PrettyImage *image = new PrettyImage(url, network_, container_);
+  connect(image, SIGNAL(destroyed()), SLOT(ScrollToCurrent()));
+  connect(image, SIGNAL(Loaded()), SLOT(ScrollToCurrent()));
+
+  layout_->insertWidget(layout_->count() - 1, image);
+  if (current_index_ == -1) ScrollTo(0);
+
+}
+
+void PrettyImageView::mouseReleaseEvent(QMouseEvent *e) {
+
+  // Find the image that was clicked on
+  QWidget *widget = container_->childAt(container_->mapFrom(this, e->pos()));
+  if (!widget) return;
+
+  // Get the index of that image
+  const int index = layout_->indexOf(widget) - 1;
+  if (index == -1) return;
+
+  if (index == current_index_) {
+    // Show the image fullsize
+    PrettyImage* pretty_image = qobject_cast<PrettyImage*>(widget);
+    if (pretty_image) {
+      pretty_image->ShowFullsize();
+    }
+  }
+  else {
+    // Scroll to the image
+    ScrollTo(index);
+  }
+
+}
+
+void PrettyImageView::ScrollTo(const int index, const bool smooth) {
+
+  current_index_ = qBound(0, index, layout_->count() - 3);
+  const int layout_index = current_index_ + 1;
+
+  const QWidget *target_widget = layout_->itemAt(layout_index)->widget();
+  if (!target_widget) return;
+
+  const int current_x = horizontalScrollBar()->value();
+  const int target_x = target_widget->geometry().center().x() - width() / 2;
+
+  if (current_x == target_x) return;
+
+  if (smooth) {
+    scroll_animation_->setStartValue(current_x);
+    scroll_animation_->setEndValue(target_x);
+    scroll_animation_->start();
+  }
+  else {
+    scroll_animation_->stop();
+    horizontalScrollBar()->setValue(target_x);
+  }
+
+}
+
+void PrettyImageView::ScrollToCurrent() { ScrollTo(current_index_); }
+
+void PrettyImageView::ScrollBarReleased() {
+
+  // Find the nearest widget to where the scroll bar was released
+  const int current_x = horizontalScrollBar()->value() + width() / 2;
+  int layout_index = 1;
+  for (; layout_index < layout_->count() - 1; ++layout_index) {
+    const QWidget *widget = layout_->itemAt(layout_index)->widget();
+    if (widget && widget->geometry().right() > current_x) {
+      break;
+    }
+  }
+
+  ScrollTo(layout_index - 1);
+
+}
+
+void PrettyImageView::ScrollBarAction(const int action) {
+
+  switch (action) {
+    case QAbstractSlider::SliderSingleStepAdd:
+    case QAbstractSlider::SliderPageStepAdd:
+      ScrollTo(current_index_ + 1);
+      break;
+
+    case QAbstractSlider::SliderSingleStepSub:
+    case QAbstractSlider::SliderPageStepSub:
+      ScrollTo(current_index_ - 1);
+      break;
+  }
+
+}
+
+void PrettyImageView::resizeEvent(QResizeEvent *e) {
+
+  QScrollArea::resizeEvent(e);
+  ScrollTo(current_index_, false);
+
+}
+
+void PrettyImageView::wheelEvent(QWheelEvent *e) {
+
+  const int d = e->angleDelta().x() > 0 ? -1 : 1;
+  ScrollTo(current_index_ + d, true);
+
+}

src/widgets/prettyimageview.h

@@ -0,0 +1,74 @@
+/*
+ * Strawberry Music Player
+ * This file was part of Clementine.
+ * Copyright 2010, David Sansome <me@davidsansome.com>
+ *
+ * Strawberry 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.
+ *
+ * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef PRETTYIMAGEVIEW_H
+#define PRETTYIMAGEVIEW_H
+
+#include <QScrollArea>
+#include <QMap>
+#include <QUrl>
+
+class QNetworkAccessManager;
+class QNetworkReply;
+class QMenu;
+class QHBoxLayout;
+class QPropertyAnimation;
+class QTimeLine;
+class QMouseEvent;
+class QResizeEvent;
+class QWheelEvent;
+
+class PrettyImageView : public QScrollArea {
+  Q_OBJECT
+
+ public:
+  PrettyImageView(QNetworkAccessManager *network, QWidget *parent = nullptr);
+
+  static const char* kSettingsGroup;
+
+ public Q_SLOTS:
+  void AddImage(const QUrl& url);
+
+ protected:
+  void mouseReleaseEvent(QMouseEvent*) override;
+  void resizeEvent(QResizeEvent *e) override;
+  void wheelEvent(QWheelEvent *e) override;
+
+ private Q_SLOTS:
+  void ScrollBarReleased();
+  void ScrollBarAction(const int action);
+  void ScrollTo(const int index, const bool smooth = true);
+  void ScrollToCurrent();
+
+ private:
+  bool eventFilter(QObject*, QEvent*) override;
+
+  QNetworkAccessManager *network_;
+
+  QWidget *container_;
+  QHBoxLayout *layout_;
+
+  int current_index_;
+  QPropertyAnimation *scroll_animation_;
+
+  bool recursion_filter_;
+};
+
+#endif  // PRETTYIMAGEVIEW_H

src/widgets/widgetfadehelper.cpp

@@ -0,0 +1,187 @@
+/*
+ * Strawberry Music Player
+ * This file was part of Clementine.
+ * Copyright 2010, David Sansome <me@davidsansome.com>
+ *
+ * Strawberry 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.
+ *
+ * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <QObject>
+#include <QWidget>
+#include <QImage>
+#include <QPixmap>
+#include <QPainter>
+#include <QTimeLine>
+#include <QResizeEvent>
+#include <QEvent>
+
+#include "widgetfadehelper.h"
+#include "core/qt_blurimage.h"
+
+const int WidgetFadeHelper::kLoadingPadding = 9;
+const int WidgetFadeHelper::kLoadingBorderRadius = 10;
+
+WidgetFadeHelper::WidgetFadeHelper(QWidget *parent, const int msec)
+    : QWidget(parent),
+      parent_(parent),
+      blur_timeline_(new QTimeLine(msec, this)),
+      fade_timeline_(new QTimeLine(msec, this)) {
+
+  parent->installEventFilter(this);
+
+  connect(blur_timeline_, SIGNAL(valueChanged(qreal)), SLOT(update()));
+  connect(fade_timeline_, SIGNAL(valueChanged(qreal)), SLOT(update()));
+  connect(fade_timeline_, SIGNAL(finished()), SLOT(FadeFinished()));
+
+  hide();
+
+}
+
+bool WidgetFadeHelper::eventFilter(QObject *obj, QEvent *event) {
+
+  // We're only interested in our parent's resize events
+  if (obj != parent_ || event->type() != QEvent::Resize) return false;
+
+  // Don't care if we're hidden
+  if (!isVisible()) return false;
+
+  QResizeEvent *re = static_cast<QResizeEvent*>(event);
+  if (re->oldSize() == re->size()) {
+    // Ignore phoney resize events
+    return false;
+  }
+
+  // Get a new capture of the parent
+  hide();
+  CaptureParent();
+  show();
+  return false;
+
+}
+
+void WidgetFadeHelper::StartBlur() {
+
+  CaptureParent();
+
+  // Cover the parent
+  raise();
+  show();
+
+  // Start the timeline
+  blur_timeline_->stop();
+  blur_timeline_->start();
+
+  setAttribute(Qt::WA_TransparentForMouseEvents, false);
+
+}
+
+void WidgetFadeHelper::CaptureParent() {
+
+  // Take a "screenshot" of the window
+  original_pixmap_ = parent_->grab();
+  QImage original_image = original_pixmap_.toImage();
+
+  // Blur it
+  QImage blurred(original_image.size(), QImage::Format_ARGB32_Premultiplied);
+  blurred.fill(Qt::transparent);
+
+  QPainter blur_painter(&blurred);
+  blur_painter.save();
+  qt_blurImage(&blur_painter, original_image, 10.0, true, false);
+  blur_painter.restore();
+
+  // Draw some loading text over the top
+  QFont loading_font(font());
+  loading_font.setBold(true);
+  QFontMetrics loading_font_metrics(loading_font);
+
+  const QString loading_text = tr("Loading...");
+#if (QT_VERSION >= QT_VERSION_CHECK(5, 11, 0))
+  const QSize loading_size(kLoadingPadding * 2 + loading_font_metrics.horizontalAdvance(loading_text), kLoadingPadding * 2 + loading_font_metrics.height());
+#else
+  const QSize loading_size(kLoadingPadding * 2 + loading_font_metrics.width(loading_text), kLoadingPadding * 2 + loading_font_metrics.height());
+#endif
+  const QRect loading_rect((blurred.width() - loading_size.width()) / 2, 100, loading_size.width(), loading_size.height());
+
+  blur_painter.setRenderHint(QPainter::Antialiasing);
+
+  blur_painter.translate(0.5, 0.5);
+  blur_painter.setPen(QColor(200, 200, 200, 255));
+  blur_painter.setBrush(QColor(200, 200, 200, 192));
+  blur_painter.drawRoundedRect(loading_rect, kLoadingBorderRadius, kLoadingBorderRadius);
+
+  blur_painter.setPen(palette().brush(QPalette::Text).color());
+  blur_painter.setFont(loading_font);
+  blur_painter.drawText(loading_rect.translated(-1, -1), Qt::AlignCenter, loading_text);
+  blur_painter.translate(-0.5, -0.5);
+
+  blur_painter.end();
+
+  blurred_pixmap_ = QPixmap::fromImage(blurred);
+
+  resize(parent_->size());
+
+}
+
+void WidgetFadeHelper::StartFade() {
+
+  if (blur_timeline_->state() == QTimeLine::Running) {
+    // Blur timeline is still running, so we need render the current state
+    // into a new pixmap.
+    QPixmap pixmap(original_pixmap_);
+    QPainter painter(&pixmap);
+    painter.setOpacity(blur_timeline_->currentValue());
+    painter.drawPixmap(0, 0, blurred_pixmap_);
+    painter.end();
+    blurred_pixmap_ = pixmap;
+  }
+  blur_timeline_->stop();
+  original_pixmap_ = QPixmap();
+
+  // Start the timeline
+  fade_timeline_->stop();
+  fade_timeline_->start();
+
+  setAttribute(Qt::WA_TransparentForMouseEvents, true);
+
+}
+
+void WidgetFadeHelper::paintEvent(QPaintEvent *event) {
+
+  Q_UNUSED(event)
+
+  QPainter p(this);
+
+  if (fade_timeline_->state() != QTimeLine::Running) {
+    // We're fading in the blur
+    p.drawPixmap(0, 0, original_pixmap_);
+    p.setOpacity(blur_timeline_->currentValue());
+  }
+  else {
+    // Fading out the blur into the new image
+    p.setOpacity(1.0 - fade_timeline_->currentValue());
+  }
+
+  p.drawPixmap(0, 0, blurred_pixmap_);
+
+}
+
+void WidgetFadeHelper::FadeFinished() {
+
+  hide();
+  original_pixmap_ = QPixmap();
+  blurred_pixmap_ = QPixmap();
+
+}

src/widgets/widgetfadehelper.h

@@ -0,0 +1,63 @@
+/*
+ * Strawberry Music Player
+ * This file was part of Clementine.
+ * Copyright 2010, David Sansome <me@davidsansome.com>
+ *
+ * Strawberry 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.
+ *
+ * Strawberry 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 Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef WIDGETFADEHELPER_H
+#define WIDGETFADEHELPER_H
+
+#include <QWidget>
+#include <QPixmap>
+
+class QTimeLine;
+class QPaintEvent;
+class QEvent;
+
+class WidgetFadeHelper : public QWidget {
+  Q_OBJECT
+
+ public:
+  WidgetFadeHelper(QWidget *parent, const int msec = 500);
+
+ public Q_SLOTS:
+  void StartBlur();
+  void StartFade();
+
+ protected:
+  void paintEvent(QPaintEvent *event) override;
+  bool eventFilter(QObject *obj, QEvent *event) override;
+
+ private Q_SLOTS:
+  void FadeFinished();
+
+ private:
+  void CaptureParent();
+
+ private:
+  static const int kLoadingPadding;
+  static const int kLoadingBorderRadius;
+
+  QWidget *parent_;
+  QTimeLine *blur_timeline_;
+  QTimeLine *fade_timeline_;
+
+  QPixmap original_pixmap_;
+  QPixmap blurred_pixmap_;
+};
+
+#endif  // WIDGETFADEHELPER_H