2010-03-24 00:11:46 +01:00
|
|
|
/* This file is part of Clementine.
|
2010-11-20 14:27:10 +01:00
|
|
|
Copyright 2010, David Sansome <me@davidsansome.com>
|
2010-03-24 00:11:46 +01:00
|
|
|
|
|
|
|
Clementine 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.
|
|
|
|
|
|
|
|
Clementine 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 Clementine. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
2011-11-04 23:54:27 +01:00
|
|
|
#include "digitallyimportedservicebase.h"
|
2010-11-22 17:57:26 +01:00
|
|
|
#include "icecastservice.h"
|
2010-11-23 18:38:39 +01:00
|
|
|
#include "jamendoservice.h"
|
|
|
|
#include "magnatuneservice.h"
|
2011-07-15 15:27:50 +02:00
|
|
|
#include "internetmimedata.h"
|
|
|
|
#include "internetmodel.h"
|
|
|
|
#include "internetservice.h"
|
2010-02-24 23:26:01 +01:00
|
|
|
#include "savedradio.h"
|
2010-11-23 18:38:39 +01:00
|
|
|
#include "somafmservice.h"
|
2011-09-02 00:28:11 +02:00
|
|
|
#include "groovesharkservice.h"
|
2011-12-06 00:10:25 +01:00
|
|
|
#include "subsonicservice.h"
|
2011-04-22 18:50:29 +02:00
|
|
|
#include "core/logging.h"
|
|
|
|
#include "core/mergedproxymodel.h"
|
2011-11-29 13:57:35 +01:00
|
|
|
#include "smartplaylists/generatormimedata.h"
|
2009-12-26 22:35:45 +01:00
|
|
|
|
2010-12-18 18:28:02 +01:00
|
|
|
#ifdef HAVE_LIBLASTFM
|
|
|
|
#include "lastfmservice.h"
|
|
|
|
#endif
|
2011-04-25 21:16:26 +02:00
|
|
|
#ifdef HAVE_SPOTIFY
|
|
|
|
#include "spotifyservice.h"
|
|
|
|
#endif
|
2010-12-18 18:28:02 +01:00
|
|
|
|
2009-12-26 22:35:45 +01:00
|
|
|
#include <QMimeData>
|
|
|
|
#include <QtDebug>
|
|
|
|
|
2011-11-29 13:57:35 +01:00
|
|
|
using smart_playlists::Generator;
|
|
|
|
using smart_playlists::GeneratorMimeData;
|
|
|
|
using smart_playlists::GeneratorPtr;
|
|
|
|
|
2011-07-15 15:27:50 +02:00
|
|
|
QMap<QString, InternetService*>* InternetModel::sServices = NULL;
|
2009-12-26 16:13:38 +01:00
|
|
|
|
2011-07-15 15:27:50 +02:00
|
|
|
InternetModel::InternetModel(BackgroundThread<Database>* db_thread,
|
2011-04-28 17:10:28 +02:00
|
|
|
TaskManager* task_manager, PlayerInterface* player,
|
2011-09-24 15:44:23 +02:00
|
|
|
CoverProviders* cover_providers,
|
|
|
|
GlobalSearch* global_search, QObject* parent)
|
2011-01-09 19:27:41 +01:00
|
|
|
: QStandardItemModel(parent),
|
2010-06-02 17:58:07 +02:00
|
|
|
db_thread_(db_thread),
|
2010-05-10 13:12:44 +02:00
|
|
|
merged_model_(new MergedProxyModel(this)),
|
2011-04-28 17:10:28 +02:00
|
|
|
task_manager_(task_manager),
|
2011-07-23 20:34:41 +02:00
|
|
|
player_(player),
|
2011-09-24 15:44:23 +02:00
|
|
|
cover_providers_(cover_providers),
|
|
|
|
global_search_(global_search)
|
2009-12-26 16:13:38 +01:00
|
|
|
{
|
2011-01-02 15:49:55 +01:00
|
|
|
if (!sServices) {
|
2011-07-15 15:27:50 +02:00
|
|
|
sServices = new QMap<QString, InternetService*>;
|
2011-01-02 15:49:55 +01:00
|
|
|
}
|
|
|
|
Q_ASSERT(sServices->isEmpty());
|
2009-12-26 22:35:45 +01:00
|
|
|
|
2010-05-09 17:51:04 +02:00
|
|
|
merged_model_->setSourceModel(this);
|
2009-12-26 16:13:38 +01:00
|
|
|
|
2011-07-21 01:03:55 +02:00
|
|
|
AddService(new DigitallyImportedService(this));
|
|
|
|
AddService(new IcecastService(this));
|
|
|
|
AddService(new JamendoService(this));
|
2010-12-18 18:28:02 +01:00
|
|
|
#ifdef HAVE_LIBLASTFM
|
2009-12-26 22:35:45 +01:00
|
|
|
AddService(new LastFMService(this));
|
2011-04-25 21:16:26 +02:00
|
|
|
#endif
|
2011-11-04 23:54:27 +01:00
|
|
|
AddService(new GroovesharkService(this));
|
2010-05-08 22:56:39 +02:00
|
|
|
AddService(new MagnatuneService(this));
|
2010-02-24 23:26:01 +01:00
|
|
|
AddService(new SavedRadio(this));
|
2011-07-21 01:03:55 +02:00
|
|
|
AddService(new SkyFmService(this));
|
|
|
|
AddService(new SomaFMService(this));
|
|
|
|
#ifdef HAVE_SPOTIFY
|
|
|
|
AddService(new SpotifyService(this));
|
|
|
|
#endif
|
2011-12-06 00:10:25 +01:00
|
|
|
AddService(new SubsonicService(this));
|
2009-12-26 22:35:45 +01:00
|
|
|
}
|
|
|
|
|
2011-07-15 15:27:50 +02:00
|
|
|
void InternetModel::AddService(InternetService *service) {
|
2011-01-09 19:27:41 +01:00
|
|
|
QStandardItem* root = service->CreateRootItem();
|
2011-01-12 21:18:17 +01:00
|
|
|
if (!root) {
|
2011-07-15 15:27:50 +02:00
|
|
|
qLog(Warning) << "Internet service" << service->name() << "did not return a root item";
|
2011-01-09 19:27:41 +01:00
|
|
|
return;
|
2011-01-12 21:18:17 +01:00
|
|
|
}
|
2011-01-09 19:27:41 +01:00
|
|
|
|
|
|
|
root->setData(Type_Service, Role_Type);
|
|
|
|
root->setData(QVariant::fromValue(service), Role_Service);
|
|
|
|
|
|
|
|
invisibleRootItem()->appendRow(root);
|
2011-07-15 15:27:50 +02:00
|
|
|
qLog(Debug) << "Adding internet service:" << service->name();
|
2011-01-02 15:49:55 +01:00
|
|
|
sServices->insert(service->name(), service);
|
2009-12-26 22:35:45 +01:00
|
|
|
|
|
|
|
connect(service, SIGNAL(StreamError(QString)), SIGNAL(StreamError(QString)));
|
2009-12-26 23:15:57 +01:00
|
|
|
connect(service, SIGNAL(StreamMetadataFound(QUrl,Song)), SIGNAL(StreamMetadataFound(QUrl,Song)));
|
2010-08-27 17:42:58 +02:00
|
|
|
connect(service, SIGNAL(OpenSettingsAtPage(SettingsDialog::Page)), SIGNAL(OpenSettingsAtPage(SettingsDialog::Page)));
|
2011-01-10 23:26:13 +01:00
|
|
|
connect(service, SIGNAL(AddToPlaylistSignal(QMimeData*)), SIGNAL(AddToPlaylist(QMimeData*)));
|
2011-01-12 21:18:17 +01:00
|
|
|
connect(service, SIGNAL(destroyed()), SLOT(ServiceDeleted()));
|
2011-07-21 01:03:55 +02:00
|
|
|
|
|
|
|
service->ReloadSettings();
|
2011-01-12 21:18:17 +01:00
|
|
|
}
|
|
|
|
|
2011-07-15 15:27:50 +02:00
|
|
|
void InternetModel::RemoveService(InternetService* service) {
|
2011-01-12 21:18:17 +01:00
|
|
|
if (!sServices->contains(service->name()))
|
|
|
|
return;
|
|
|
|
|
|
|
|
// Find and remove the root item that this service created
|
|
|
|
for (int i=0 ; i<invisibleRootItem()->rowCount() ; ++i) {
|
2011-05-30 16:54:48 +02:00
|
|
|
QStandardItem* item = invisibleRootItem()->child(i);
|
2011-07-15 15:27:50 +02:00
|
|
|
if (!item || item->data(Role_Service).value<InternetService*>() == service) {
|
2011-01-12 21:18:17 +01:00
|
|
|
invisibleRootItem()->removeRow(i);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Remove the service from the list
|
|
|
|
sServices->remove(service->name());
|
|
|
|
|
|
|
|
// Disconnect the service
|
|
|
|
disconnect(service, 0, this, 0);
|
|
|
|
}
|
|
|
|
|
2011-07-15 15:27:50 +02:00
|
|
|
void InternetModel::ServiceDeleted() {
|
2011-07-21 01:17:37 +02:00
|
|
|
InternetService* service = qobject_cast<InternetService*>(sender());
|
2011-01-12 21:18:17 +01:00
|
|
|
if (service)
|
|
|
|
RemoveService(service);
|
2009-12-26 22:35:45 +01:00
|
|
|
}
|
|
|
|
|
2011-07-15 15:27:50 +02:00
|
|
|
InternetService* InternetModel::ServiceByName(const QString& name) {
|
2011-01-02 15:49:55 +01:00
|
|
|
if (sServices->contains(name))
|
|
|
|
return sServices->value(name);
|
2009-12-26 22:35:45 +01:00
|
|
|
return NULL;
|
2009-12-26 16:13:38 +01:00
|
|
|
}
|
|
|
|
|
2011-07-15 15:27:50 +02:00
|
|
|
InternetService* InternetModel::ServiceForItem(const QStandardItem* item) const {
|
2011-01-09 19:27:41 +01:00
|
|
|
return ServiceForIndex(indexFromItem(item));
|
2009-12-26 16:13:38 +01:00
|
|
|
}
|
|
|
|
|
2011-07-15 15:27:50 +02:00
|
|
|
InternetService* InternetModel::ServiceForIndex(const QModelIndex& index) const {
|
2011-01-09 19:27:41 +01:00
|
|
|
QModelIndex current_index = index;
|
|
|
|
while (current_index.isValid()) {
|
2011-07-15 15:27:50 +02:00
|
|
|
InternetService* service = current_index.data(Role_Service).value<InternetService*>();
|
2011-01-09 19:27:41 +01:00
|
|
|
if (service) {
|
|
|
|
return service;
|
|
|
|
}
|
|
|
|
current_index = current_index.parent();
|
2009-12-26 16:13:38 +01:00
|
|
|
}
|
2011-01-09 19:27:41 +01:00
|
|
|
return NULL;
|
2009-12-26 16:13:38 +01:00
|
|
|
}
|
2009-12-26 22:35:45 +01:00
|
|
|
|
2011-07-15 15:27:50 +02:00
|
|
|
Qt::ItemFlags InternetModel::flags(const QModelIndex& index) const {
|
2011-10-30 23:59:43 +01:00
|
|
|
Qt::ItemFlags flags = Qt::ItemIsSelectable |
|
|
|
|
Qt::ItemIsEnabled |
|
|
|
|
Qt::ItemIsDropEnabled;
|
|
|
|
if (IsPlayable(index)) {
|
|
|
|
flags |= Qt::ItemIsDragEnabled;
|
|
|
|
}
|
|
|
|
return flags;
|
2009-12-26 22:35:45 +01:00
|
|
|
}
|
|
|
|
|
2011-07-15 15:27:50 +02:00
|
|
|
bool InternetModel::hasChildren(const QModelIndex& parent) const {
|
2011-01-09 19:27:41 +01:00
|
|
|
if (parent.data(Role_CanLazyLoad).toBool())
|
|
|
|
return true;
|
|
|
|
return QStandardItemModel::hasChildren(parent);
|
|
|
|
}
|
|
|
|
|
2011-07-15 15:27:50 +02:00
|
|
|
int InternetModel::rowCount(const QModelIndex& parent) const {
|
2011-01-09 19:27:41 +01:00
|
|
|
if (parent.data(Role_CanLazyLoad).toBool()) {
|
|
|
|
QStandardItem* item = itemFromIndex(parent);
|
2011-07-15 15:27:50 +02:00
|
|
|
InternetService* service = ServiceForItem(item);
|
2011-01-09 19:27:41 +01:00
|
|
|
if (service) {
|
|
|
|
item->setData(false, Role_CanLazyLoad);
|
|
|
|
service->LazyPopulate(item);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return QStandardItemModel::rowCount(parent);
|
|
|
|
}
|
|
|
|
|
2011-07-15 15:27:50 +02:00
|
|
|
bool InternetModel::IsPlayable(const QModelIndex& index) const {
|
2011-01-09 19:27:41 +01:00
|
|
|
QVariant behaviour = index.data(Role_PlayBehaviour);
|
2011-04-29 13:24:58 +02:00
|
|
|
if (!behaviour.isValid())
|
2011-01-09 19:27:41 +01:00
|
|
|
return false;
|
2011-04-29 13:24:58 +02:00
|
|
|
|
|
|
|
PlayBehaviour pb = PlayBehaviour(behaviour.toInt());
|
|
|
|
return (pb == PlayBehaviour_SingleItem || PlayBehaviour_UseSongLoader);
|
2011-01-09 19:27:41 +01:00
|
|
|
}
|
|
|
|
|
2011-07-15 15:27:50 +02:00
|
|
|
QStringList InternetModel::mimeTypes() const {
|
2009-12-26 22:35:45 +01:00
|
|
|
return QStringList() << "text/uri-list";
|
|
|
|
}
|
|
|
|
|
2011-07-15 15:27:50 +02:00
|
|
|
QMimeData* InternetModel::mimeData(const QModelIndexList& indexes) const {
|
2011-04-29 13:24:58 +02:00
|
|
|
// Special case for when the user double clicked on a special item.
|
|
|
|
if (indexes.count() == 1 &&
|
|
|
|
indexes[0].data(Role_PlayBehaviour).toInt() ==
|
|
|
|
PlayBehaviour_DoubleClickAction) {
|
2011-07-15 15:27:50 +02:00
|
|
|
InternetModel::ServiceForIndex(indexes[0])->ItemDoubleClicked(itemFromIndex(indexes[0]));
|
2011-04-29 13:24:58 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2011-11-29 13:57:35 +01:00
|
|
|
if (indexes.count() == 1 &&
|
|
|
|
indexes[0].data(Role_Type).toInt() == Type_SmartPlaylist) {
|
|
|
|
GeneratorPtr generator =
|
|
|
|
InternetModel::ServiceForIndex(indexes[0])->CreateGenerator(itemFromIndex(indexes[0]));
|
|
|
|
if (!generator)
|
|
|
|
return NULL;
|
|
|
|
GeneratorMimeData* data = new GeneratorMimeData(generator);
|
|
|
|
data->setData(LibraryModel::kSmartPlaylistsMimeType, QByteArray());
|
|
|
|
data->name_for_new_playlist_ = this->data(indexes.first()).toString();
|
|
|
|
return data;
|
|
|
|
}
|
|
|
|
|
2009-12-26 22:35:45 +01:00
|
|
|
QList<QUrl> urls;
|
2011-10-14 00:10:18 +02:00
|
|
|
QModelIndexList new_indexes;
|
2009-12-26 22:35:45 +01:00
|
|
|
|
2011-02-16 19:29:35 +01:00
|
|
|
QModelIndex last_valid_index;
|
2009-12-26 22:35:45 +01:00
|
|
|
foreach (const QModelIndex& index, indexes) {
|
2011-01-09 19:27:41 +01:00
|
|
|
if (!IsPlayable(index))
|
2009-12-26 22:35:45 +01:00
|
|
|
continue;
|
|
|
|
|
2011-02-16 19:29:35 +01:00
|
|
|
last_valid_index = index;
|
2011-10-15 18:17:00 +02:00
|
|
|
if (index.data(Role_Type).toInt() == Type_UserPlaylist) {
|
|
|
|
// Get children
|
2011-10-14 00:10:18 +02:00
|
|
|
int row = 0;
|
|
|
|
int column = 0;
|
|
|
|
QModelIndex child = index.child(row, column);
|
|
|
|
while (child.isValid()) {
|
2012-01-30 19:56:34 +01:00
|
|
|
// If the playlist contains another playlist, expand it
|
|
|
|
if (child.data(Role_Type).toInt() == Type_UserPlaylist) {
|
|
|
|
// "List" of indexes to recurse on
|
|
|
|
QModelIndexList templist;
|
|
|
|
templist.append(child);
|
|
|
|
// We know this is going to be an InternetMimeData because we're calling
|
|
|
|
// ourselves with something that we always return InternetMimeData for!
|
|
|
|
InternetMimeData* recurse = qobject_cast<InternetMimeData*>(mimeData(templist));
|
|
|
|
// Add children if there were any
|
|
|
|
if (recurse) {
|
|
|
|
new_indexes.append(recurse->indexes);
|
|
|
|
urls.append(recurse->urls());
|
|
|
|
delete recurse;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
new_indexes << child;
|
|
|
|
urls << child.data(Role_Url).toUrl();
|
|
|
|
}
|
2011-10-14 00:10:18 +02:00
|
|
|
child = index.child(++row, column);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
new_indexes = indexes;
|
2011-10-15 18:17:00 +02:00
|
|
|
urls << index.data(Role_Url).toUrl();
|
2011-10-14 00:10:18 +02:00
|
|
|
}
|
2009-12-26 22:35:45 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (urls.isEmpty())
|
|
|
|
return NULL;
|
|
|
|
|
2011-07-15 15:27:50 +02:00
|
|
|
InternetMimeData* data = new InternetMimeData(this);
|
2009-12-26 22:35:45 +01:00
|
|
|
data->setUrls(urls);
|
2011-10-14 00:10:18 +02:00
|
|
|
data->indexes = new_indexes;
|
2011-07-15 15:27:50 +02:00
|
|
|
data->name_for_new_playlist_ = InternetModel::ServiceForIndex(last_valid_index)->name();
|
2009-12-26 22:35:45 +01:00
|
|
|
|
|
|
|
return data;
|
|
|
|
}
|
2009-12-29 20:22:02 +01:00
|
|
|
|
2011-10-30 23:59:43 +01:00
|
|
|
bool InternetModel::dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) {
|
|
|
|
if (action == Qt::IgnoreAction) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (parent.data(Role_CanBeModified).toBool()) {
|
|
|
|
InternetModel::ServiceForIndex(parent)->DropMimeData(data, parent);
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2011-07-15 15:27:50 +02:00
|
|
|
void InternetModel::ShowContextMenu(const QModelIndex& merged_model_index,
|
2010-05-09 19:53:27 +02:00
|
|
|
const QPoint& global_pos) {
|
2011-07-15 15:27:50 +02:00
|
|
|
InternetService* service = ServiceForIndex(merged_model_index);
|
2011-01-09 19:27:41 +01:00
|
|
|
if (service)
|
|
|
|
service->ShowContextMenu(merged_model_->mapToSource(merged_model_index), global_pos);
|
2009-12-30 00:01:07 +01:00
|
|
|
}
|
2010-02-03 19:32:48 +01:00
|
|
|
|
2011-07-15 15:27:50 +02:00
|
|
|
void InternetModel::ReloadSettings() {
|
|
|
|
foreach (InternetService* service, sServices->values()) {
|
2010-02-03 19:32:48 +01:00
|
|
|
service->ReloadSettings();
|
|
|
|
}
|
|
|
|
}
|