WFindOnWebMenu: Menu for to find track properties in online music databases

CMakeLists.txt

@@ -990,6 +990,7 @@ add_library(mixxx-lib STATIC EXCLUDE_FROM_ALL
   src/widget/weffectparameternamebase.cpp
   src/widget/weffectpushbutton.cpp
   src/widget/weffectselector.cpp
+  src/widget/wfindonwebmenu.cpp
   src/widget/whotcuebutton.cpp
   src/widget/wimagestore.cpp
   src/widget/wkey.cpp

src/widget/wfindonwebmenu.cpp

@@ -0,0 +1,171 @@
+#include "widget/wfindonwebmenu.h"
+
+#include <QDesktopServices>
+#include <QScreen>
+#include <QUrl>
+#include <QUrlQuery>
+#include <QtDebug>
+
+#include "track/track.h"
+#include "util/math.h"
+#include "util/parented_ptr.h"
+#include "util/qt.h"
+#include "util/widgethelper.h"
+
+namespace {
+
+QString composeActionText(const QString& prefix, const QString& trackProperty) {
+    return prefix + QStringLiteral(" | ") + trackProperty;
+}
+
+QString composeSearchQuery(const QString& trackAlbumOrTitle, const QString& artist) {
+    return trackAlbumOrTitle + QStringLiteral(" ") + artist;
+}
+
+QString composePrefixAction(WFindOnWebMenu::TrackSearchProperties trackSearchProperty) {
+    switch (trackSearchProperty) {
+    case WFindOnWebMenu::TrackSearchProperties::Title:
+        return QObject::tr("Title");
+    case WFindOnWebMenu::TrackSearchProperties::Artist:
+        return QObject::tr("Artist");
+    case WFindOnWebMenu::TrackSearchProperties::ArtistAndTitle:
+        return QObject::tr("Title + Artist");
+    case WFindOnWebMenu::TrackSearchProperties::ArtistAndAlbum:
+        return QObject::tr("Album + Artist");
+    default:
+        return QObject::tr("Album");
+    }
+}
+
+const QString kSearchUrlSoundCloudArtist = QStringLiteral("https://soundcloud.com/search/people?");
+
+const QString kSearchUrlSoundCloudTitle = QStringLiteral("https://soundcloud.com/search/sounds?");
+
+const QString kSearchUrlSoundCloudAlbum = QStringLiteral("https://soundcloud.com/search/albums?");
+
+const QString kSearchUrlDiscogsGen = QStringLiteral("https://www.discogs.com/search/?");
+
+const QString kSearchUrlLastFmArtist = QStringLiteral("https://www.last.fm/search/artists?");
+
+const QString kSearchUrlLastFmTitle = QStringLiteral("https://www.last.fm/search/tracks?");
+
+const QString kSearchUrlLastFmAlbum = QStringLiteral("https://www.last.fm/search/albums?");
+
+const QString kSearchUrlDefault = QStringLiteral("https://soundcloud.com/search?");
+
+QString getServiceUrl(WFindOnWebMenu::Service service,
+        WFindOnWebMenu::TrackSearchProperties trackSearchProperty) {
+    switch (service) {
+    case WFindOnWebMenu::Service::Discogs:
+        return kSearchUrlDiscogsGen;
+    case WFindOnWebMenu::Service::LastFm:
+        if (trackSearchProperty == WFindOnWebMenu::TrackSearchProperties::Title ||
+                trackSearchProperty == WFindOnWebMenu::TrackSearchProperties::ArtistAndTitle) {
+            return kSearchUrlLastFmTitle;
+        } else if (trackSearchProperty == WFindOnWebMenu::TrackSearchProperties::Artist) {
+            return kSearchUrlLastFmArtist;
+        } else {
+            return kSearchUrlLastFmAlbum;
+        }
+    case WFindOnWebMenu::Service::SoundCloud:
+        if (trackSearchProperty == WFindOnWebMenu::TrackSearchProperties::Title ||
+                trackSearchProperty == WFindOnWebMenu::TrackSearchProperties::ArtistAndTitle) {
+            return kSearchUrlSoundCloudTitle;
+        } else if (trackSearchProperty == WFindOnWebMenu::TrackSearchProperties::Artist) {
+            return kSearchUrlSoundCloudArtist;
+        } else {
+            return kSearchUrlSoundCloudAlbum;
+        }
+    default:
+        return kSearchUrlDefault;
+    }
+}
+} // namespace
+
+WFindOnWebMenu::WFindOnWebMenu(QWidget* parent)
+        : QMenu(tr("Find on Web"), parent) {
+}
+
+void WFindOnWebMenu::addSubmenusForServices(const Track& track) {
+    WFindOnWebMenu::populateFromTrackProperties(
+            track,
+            QString(tr("SoundCloud")),
+            Service::SoundCloud);
+    WFindOnWebMenu::populateFromTrackProperties(
+            track, QString(tr("LastFm")), Service::LastFm);
+    WFindOnWebMenu::populateFromTrackProperties(
+            track, QString(tr("Discogs")), Service::Discogs);
+}
+
+void WFindOnWebMenu::addActions(Service service,
+        const QString& trackProperty,
+        QMenu* pServiceMenu,
+        TrackSearchProperties trackSearchProperty) {
+    const QString prefixAction = composePrefixAction(trackSearchProperty);
+    pServiceMenu->addAction(
+            composeActionText(prefixAction, trackProperty),
+            this,
+            [this, service, trackSearchProperty, trackProperty]() {
+                emit triggerBrowser(service, trackSearchProperty, trackProperty);
+            });
+}
+
+void WFindOnWebMenu::openInBrowser(Service service,
+        TrackSearchProperties trackSearchProperty,
+        const QString& query) {
+    const QString serviceUrl = getServiceUrl(service, trackSearchProperty);
+    QUrlQuery urlQuery;
+    urlQuery.addQueryItem("q", query);
+    QUrl url(serviceUrl);
+    url.setQuery(urlQuery);
+    if (!QDesktopServices::openUrl(url)) {
+        qWarning() << "QDesktopServices::openUrl() failed for " << url;
+        DEBUG_ASSERT(false);
+    }
+}
+
+void WFindOnWebMenu::populateFromTrackProperties(
+        const Track& track,
+        const QString& serviceTitle,
+        Service service) {
+    const auto artist = track.getArtist();
+    const auto trackTitle = track.getTitle();
+    const auto album = track.getAlbum();
+    auto pServiceMenu = make_parented<QMenu>(this);
+    pServiceMenu->setTitle(serviceTitle);
+    addMenu(pServiceMenu);
+    addSeparator();
+    if (!artist.isEmpty()) {
+        addActions(service,
+                artist,
+                pServiceMenu,
+                WFindOnWebMenu::TrackSearchProperties::Artist);
+    }
+    if (!trackTitle.isEmpty()) {
+        if (!artist.isEmpty()) {
+            const auto artistWithTrackTitle = composeSearchQuery(trackTitle, artist);
+            addActions(service,
+                    artistWithTrackTitle,
+                    pServiceMenu,
+                    WFindOnWebMenu::TrackSearchProperties::ArtistAndTitle);
+        }
+        addActions(service,
+                trackTitle,
+                pServiceMenu,
+                WFindOnWebMenu::TrackSearchProperties::Title);
+    }
+    if (!album.isEmpty()) {
+        if (!artist.isEmpty()) {
+            const auto artistWithAlbum = composeSearchQuery(album, artist);
+            addActions(service,
+                    artistWithAlbum,
+                    pServiceMenu,
+                    WFindOnWebMenu::TrackSearchProperties::ArtistAndAlbum);
+        } else {
+            addActions(service,
+                    album,
+                    pServiceMenu,
+                    WFindOnWebMenu::TrackSearchProperties::Album);
+        }
+    }
+}

src/widget/wfindonwebmenu.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include <QAction>
+#include <QMenu>
+#include <QUrlQuery>
+
+class Track;
+
+class WFindOnWebMenu : public QMenu {
+    Q_OBJECT
+  public:
+    explicit WFindOnWebMenu(
+            QWidget* parent = nullptr);
+    ~WFindOnWebMenu() override = default;
+
+    enum class Service {
+        SoundCloud,
+        LastFm,
+        Discogs
+    };
+
+    enum class TrackSearchProperties {
+        Artist,
+        ArtistAndTitle,
+        ArtistAndAlbum,
+        Album,
+        Title
+    };
+
+    void openInBrowser(WFindOnWebMenu::Service service,
+            WFindOnWebMenu::TrackSearchProperties trackSearchProperty,
+            const QString& query);
+
+    void addSubmenusForServices(const Track& track);
+
+  signals:
+    void triggerBrowser(WFindOnWebMenu::Service service,
+            WFindOnWebMenu::TrackSearchProperties trackSearchProperty,
+            const QString& query);
+
+  private:
+    void populateFromTrackProperties(
+            const Track& track,
+            const QString& serviceTitle,
+            Service service);
+
+    void addActions(Service service,
+            const QString& trackProperty,
+            QMenu* pServiceMenu,
+            TrackSearchProperties trackSearchProperty);
+};

src/widget/wtrackmenu.cpp

@@ -37,6 +37,7 @@
 #include "widget/wcolorpickeraction.h"
 #include "widget/wcoverartlabel.h"
 #include "widget/wcoverartmenu.h"
+#include "widget/wfindonwebmenu.h"
 #include "widget/wsearchrelatedtracksmenu.h"
 #include "widget/wskincolor.h"
 #include "widget/wstarrating.h"
@@ -185,6 +186,38 @@ void WTrackMenu::createMenus() {
                 });
     }
 
+    if (featureIsEnabled(Feature::FindOnWeb)) {
+        DEBUG_ASSERT(!m_pFindOnMenu);
+        m_pFindOnMenu =
+                make_parented<WFindOnWebMenu>(this);
+
+        connect(m_pFindOnMenu,
+                &QMenu::aboutToShow,
+                this,
+                [this] {
+                    m_pFindOnMenu->clear();
+                    const auto pTrack = getFirstTrackPointer();
+                    const bool checkTrackProperties =
+                            (pTrack->getArtist().isEmpty() &&
+                                    pTrack->getAlbum().isEmpty() &&
+                                    pTrack->getTitle().isEmpty());
+                    if (pTrack && !checkTrackProperties) {
+                        m_pFindOnMenu->addSubmenusForServices(*pTrack);
+                        m_pFindOnMenu->setEnabled(
+                                !m_pFindOnMenu->isEmpty());
+                    }
+                });
+
+        connect(m_pFindOnMenu,
+                &WFindOnWebMenu::triggerBrowser,
+                this,
+                [this](WFindOnWebMenu::Service service,
+                        WFindOnWebMenu::TrackSearchProperties trackSearchProperty,
+                        const QString& query) {
+                    m_pFindOnMenu->openInBrowser(service, trackSearchProperty, query);
+                });
+    }
+
     if (featureIsEnabled(Feature::RemoveFromDisk)) {
         m_pRemoveFromDiskMenu = new QMenu(this);
         m_pRemoveFromDiskMenu->setTitle(tr("Delete Track Files"));
@@ -537,6 +570,10 @@ void WTrackMenu::setupActions() {
         }
 
         m_pMetadataMenu->addMenu(m_pCoverMenu);
+        if (featureIsEnabled(Feature::FindOnWeb)) {
+            m_pMetadataMenu->addMenu(m_pFindOnMenu);
+            addSeparator();
+        }
         addMenu(m_pMetadataMenu);
     }
 
@@ -2202,6 +2239,8 @@ bool WTrackMenu::featureIsEnabled(Feature flag) const {
         return m_pTrackModel->hasCapabilities(TrackModel::Capability::RemoveFromDisk);
     case Feature::FileBrowser:
         return true;
+    case Feature::FindOnWeb:
+        return true;
     case Feature::Properties:
         return m_pTrackModel->hasCapabilities(TrackModel::Capability::EditMetadata);
     case Feature::SearchRelated:

src/widget/wtrackmenu.h

@@ -24,6 +24,7 @@ class TrackModel;
 class WColorPickerAction;
 class WCoverArtMenu;
 class WSearchRelatedTracksMenu;
+class WFindOnWebMenu;
 
 /// A context menu for track(s).
 /// Can be used with individual track type widgets based on TrackPointer
@@ -52,10 +53,12 @@ class WTrackMenu : public QMenu {
         UpdateReplayGainFromPregain = 1 << 14,
         SelectInLibrary = 1 << 15,
         Analyze = 1 << 16,
+        FindOnWeb = 1 << 17,
         TrackModelFeatures = Remove | HideUnhidePurge,
         All = AutoDJ | LoadTo | Playlist | Crate | Remove | Metadata | Reset | Analyze |
                 BPM | Color | HideUnhidePurge | RemoveFromDisk | FileBrowser |
-                Properties | SearchRelated | UpdateReplayGainFromPregain | SelectInLibrary
+                Properties | SearchRelated | UpdateReplayGainFromPregain | SelectInLibrary |
+                FindOnWeb
     };
     Q_DECLARE_FLAGS(Features, Feature)
 
@@ -228,6 +231,7 @@ class WTrackMenu : public QMenu {
     QMenu* m_pColorMenu{};
     WCoverArtMenu* m_pCoverMenu{};
     parented_ptr<WSearchRelatedTracksMenu> m_pSearchRelatedMenu;
+    parented_ptr<WFindOnWebMenu> m_pFindOnMenu;
     QMenu* m_pRemoveFromDiskMenu{};
 
     // Update ReplayGain from Track

src/widget/wtrackproperty.cpp

@@ -23,6 +23,7 @@ constexpr WTrackMenu::Features kTrackMenuFeatures =
         WTrackMenu::Feature::FileBrowser |
         WTrackMenu::Feature::Properties |
         WTrackMenu::Feature::UpdateReplayGainFromPregain |
+        WTrackMenu::Feature::FindOnWeb |
         WTrackMenu::Feature::SelectInLibrary;
 } // namespace
 

src/widget/wtracktext.cpp

@@ -22,6 +22,7 @@ constexpr WTrackMenu::Features kTrackMenuFeatures =
         WTrackMenu::Feature::FileBrowser |
         WTrackMenu::Feature::Properties |
         WTrackMenu::Feature::UpdateReplayGainFromPregain |
+        WTrackMenu::Feature::FindOnWeb |
         WTrackMenu::Feature::SelectInLibrary;
 } // namespace
 

src/widget/wtrackwidgetgroup.cpp

@@ -26,6 +26,7 @@ constexpr WTrackMenu::Features kTrackMenuFeatures =
         WTrackMenu::Feature::FileBrowser |
         WTrackMenu::Feature::Properties |
         WTrackMenu::Feature::UpdateReplayGainFromPregain |
+        WTrackMenu::Feature::FindOnWeb |
         WTrackMenu::Feature::SelectInLibrary;
 
 } // anonymous namespace