2011-01-24 01:09:57 +01:00
|
|
|
/* This file is part of Clementine.
|
|
|
|
|
|
|
|
Copyright 2010, David Sansome <me@davidsansome.com>
|
|
|
|
|
|
|
|
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/>.
|
|
|
|
*/
|
|
|
|
|
2012-02-12 14:41:50 +01:00
|
|
|
#include "core/application.h"
|
2011-07-07 16:20:34 +02:00
|
|
|
#include "core/logging.h"
|
2013-12-31 15:21:50 +01:00
|
|
|
#include "core/utilities.h"
|
2011-04-02 15:34:06 +02:00
|
|
|
#include "covers/albumcoverfetcher.h"
|
|
|
|
#include "covers/albumcoverloader.h"
|
2012-02-13 21:44:04 +01:00
|
|
|
#include "covers/currentartloader.h"
|
2011-01-24 18:53:31 +01:00
|
|
|
#include "library/librarybackend.h"
|
2011-01-24 01:09:57 +01:00
|
|
|
#include "ui/albumcoverchoicecontroller.h"
|
|
|
|
#include "ui/albumcovermanager.h"
|
2011-04-27 21:10:37 +02:00
|
|
|
#include "ui/albumcoversearcher.h"
|
2011-01-24 01:09:57 +01:00
|
|
|
#include "ui/coverfromurldialog.h"
|
|
|
|
#include "ui/iconloader.h"
|
|
|
|
|
2011-01-26 00:33:27 +01:00
|
|
|
#include <QAction>
|
2014-05-01 18:26:48 +02:00
|
|
|
#include <QDesktopWidget>
|
2011-01-24 01:09:57 +01:00
|
|
|
#include <QDialog>
|
2011-03-14 21:01:27 +01:00
|
|
|
#include <QDragEnterEvent>
|
2011-01-24 01:09:57 +01:00
|
|
|
#include <QFileDialog>
|
2011-02-02 17:22:04 +01:00
|
|
|
#include <QImageWriter>
|
2011-01-24 01:09:57 +01:00
|
|
|
#include <QLabel>
|
2011-01-26 00:33:27 +01:00
|
|
|
#include <QList>
|
|
|
|
#include <QMenu>
|
2011-03-14 21:01:27 +01:00
|
|
|
#include <QUrl>
|
2011-01-24 01:09:57 +01:00
|
|
|
|
2014-02-07 16:34:20 +01:00
|
|
|
const char* AlbumCoverChoiceController::kLoadImageFileFilter = QT_TR_NOOP(
|
|
|
|
"Images (*.png *.jpg *.jpeg *.bmp *.gif *.xpm *.pbm *.pgm *.ppm *.xbm)");
|
2011-02-02 17:22:04 +01:00
|
|
|
const char* AlbumCoverChoiceController::kSaveImageFileFilter =
|
2014-02-07 16:34:20 +01:00
|
|
|
QT_TR_NOOP("Images (*.png *.jpg *.jpeg *.bmp *.xpm *.pbm *.ppm *.xbm)");
|
2011-01-24 01:09:57 +01:00
|
|
|
const char* AlbumCoverChoiceController::kAllFilesFilter =
|
2014-02-07 16:34:20 +01:00
|
|
|
QT_TR_NOOP("All files (*)");
|
2011-01-24 01:09:57 +01:00
|
|
|
|
2014-02-06 16:49:49 +01:00
|
|
|
QSet<QString>* AlbumCoverChoiceController::sImageExtensions = nullptr;
|
2011-03-14 21:01:27 +01:00
|
|
|
|
2011-01-26 00:33:27 +01:00
|
|
|
AlbumCoverChoiceController::AlbumCoverChoiceController(QWidget* parent)
|
2014-02-07 16:34:20 +01:00
|
|
|
: QWidget(parent),
|
|
|
|
app_(nullptr),
|
|
|
|
cover_searcher_(nullptr),
|
|
|
|
cover_fetcher_(nullptr),
|
|
|
|
save_file_dialog_(nullptr),
|
|
|
|
cover_from_url_dialog_(nullptr) {
|
2017-03-03 19:07:01 +01:00
|
|
|
cover_from_file_ =
|
|
|
|
new QAction(IconLoader::Load("document-open", IconLoader::Base),
|
|
|
|
tr("Load cover from disk..."), this);
|
|
|
|
cover_to_file_ =
|
|
|
|
new QAction(IconLoader::Load("document-save", IconLoader::Base),
|
|
|
|
tr("Save cover to disk..."), this);
|
2015-10-14 03:01:08 +02:00
|
|
|
cover_from_url_ = new QAction(IconLoader::Load("download", IconLoader::Base),
|
2014-02-07 16:34:20 +01:00
|
|
|
tr("Load cover from URL..."), this);
|
2017-03-27 13:57:24 +02:00
|
|
|
search_for_cover_ =
|
|
|
|
new QAction(IconLoader::Load("edit-find", IconLoader::Base),
|
|
|
|
tr("Search for album covers..."), this);
|
2017-03-03 19:07:01 +01:00
|
|
|
unset_cover_ = new QAction(IconLoader::Load("list-remove", IconLoader::Base),
|
|
|
|
tr("Unset cover"), this);
|
|
|
|
show_cover_ = new QAction(IconLoader::Load("zoom-in", IconLoader::Base),
|
|
|
|
tr("Show fullsize..."), this);
|
|
|
|
|
2017-03-27 13:57:24 +02:00
|
|
|
search_cover_auto_ = new QAction(tr("Search automatically"), this);
|
2013-12-30 23:50:57 +01:00
|
|
|
search_cover_auto_->setCheckable(true);
|
|
|
|
search_cover_auto_->setChecked(false);
|
|
|
|
|
2011-02-02 17:22:04 +01:00
|
|
|
separator_ = new QAction(this);
|
|
|
|
separator_->setSeparator(true);
|
2011-01-24 01:09:57 +01:00
|
|
|
}
|
|
|
|
|
2014-02-07 16:34:20 +01:00
|
|
|
AlbumCoverChoiceController::~AlbumCoverChoiceController() {}
|
2011-01-24 01:09:57 +01:00
|
|
|
|
2012-02-12 14:41:50 +01:00
|
|
|
void AlbumCoverChoiceController::SetApplication(Application* app) {
|
|
|
|
app_ = app;
|
|
|
|
|
|
|
|
cover_fetcher_ = new AlbumCoverFetcher(app_->cover_providers(), this);
|
|
|
|
cover_searcher_ = new AlbumCoverSearcher(QIcon(":/nocover.png"), app, this);
|
2011-07-23 20:34:41 +02:00
|
|
|
cover_searcher_->Init(cover_fetcher_);
|
2013-12-30 23:50:57 +01:00
|
|
|
|
2014-02-07 16:34:20 +01:00
|
|
|
connect(cover_fetcher_,
|
|
|
|
SIGNAL(AlbumCoverFetched(quint64, QImage, CoverSearchStatistics)),
|
|
|
|
this,
|
|
|
|
SLOT(AlbumCoverFetched(quint64, QImage, CoverSearchStatistics)));
|
2011-07-23 20:34:41 +02:00
|
|
|
}
|
|
|
|
|
2011-01-26 00:33:27 +01:00
|
|
|
QList<QAction*> AlbumCoverChoiceController::GetAllActions() {
|
2014-02-07 16:34:20 +01:00
|
|
|
return QList<QAction*>() << cover_from_file_ << cover_to_file_ << separator_
|
2011-02-02 17:22:04 +01:00
|
|
|
<< cover_from_url_ << search_for_cover_
|
2011-01-31 21:53:38 +01:00
|
|
|
<< unset_cover_ << show_cover_;
|
2011-01-26 00:33:27 +01:00
|
|
|
}
|
|
|
|
|
2011-01-24 18:53:31 +01:00
|
|
|
QString AlbumCoverChoiceController::LoadCoverFromFile(Song* song) {
|
2011-01-24 01:09:57 +01:00
|
|
|
QString cover = QFileDialog::getOpenFileName(
|
2014-02-07 16:34:20 +01:00
|
|
|
this, tr("Load cover from disk"),
|
|
|
|
GetInitialPathForFileDialog(*song, QString()),
|
2011-02-02 17:22:04 +01:00
|
|
|
tr(kLoadImageFileFilter) + ";;" + tr(kAllFilesFilter));
|
2011-01-24 01:09:57 +01:00
|
|
|
|
2014-02-07 16:34:20 +01:00
|
|
|
if (cover.isNull()) return QString();
|
2011-01-24 01:09:57 +01:00
|
|
|
|
|
|
|
// Can we load the image?
|
|
|
|
QImage image(cover);
|
|
|
|
|
2014-02-07 16:34:20 +01:00
|
|
|
if (!image.isNull()) {
|
2011-01-24 18:53:31 +01:00
|
|
|
SaveCover(song, cover);
|
|
|
|
return cover;
|
|
|
|
} else {
|
|
|
|
return QString();
|
|
|
|
}
|
2011-01-24 01:09:57 +01:00
|
|
|
}
|
|
|
|
|
2014-02-07 16:34:20 +01:00
|
|
|
void AlbumCoverChoiceController::SaveCoverToFile(const Song& song,
|
|
|
|
const QImage& image) {
|
|
|
|
QString initial_file_name =
|
2017-03-07 12:46:54 +01:00
|
|
|
"/" + (song.effective_album().isEmpty() ? tr("Unknown")
|
|
|
|
: song.effective_album()) +
|
|
|
|
".jpg";
|
2011-02-02 17:22:04 +01:00
|
|
|
|
2011-02-08 00:53:32 +01:00
|
|
|
QString save_filename = QFileDialog::getSaveFileName(
|
2014-02-07 16:34:20 +01:00
|
|
|
this, tr("Save album cover"),
|
|
|
|
GetInitialPathForFileDialog(song, initial_file_name),
|
2011-02-08 00:53:32 +01:00
|
|
|
tr(kSaveImageFileFilter) + ";;" + tr(kAllFilesFilter));
|
2011-02-02 17:22:04 +01:00
|
|
|
|
2014-02-07 16:34:20 +01:00
|
|
|
if (save_filename.isNull()) return;
|
2011-02-02 17:22:04 +01:00
|
|
|
|
|
|
|
QString extension = save_filename.right(4);
|
|
|
|
if (!extension.startsWith('.') ||
|
2014-02-07 16:34:20 +01:00
|
|
|
!QImageWriter::supportedImageFormats().contains(
|
2014-05-03 15:54:19 +02:00
|
|
|
extension.right(3).toUtf8())) {
|
2011-02-02 17:22:04 +01:00
|
|
|
save_filename.append(".jpg");
|
|
|
|
}
|
|
|
|
|
|
|
|
image.save(save_filename);
|
|
|
|
}
|
|
|
|
|
2014-02-07 16:34:20 +01:00
|
|
|
QString AlbumCoverChoiceController::GetInitialPathForFileDialog(
|
|
|
|
const Song& song, const QString& filename) {
|
2011-02-08 00:53:32 +01:00
|
|
|
// art automatic is first to show user which cover the album may be
|
|
|
|
// using now; the song is using it if there's no manual path but we
|
|
|
|
// cannot use manual path here because it can contain cached paths
|
|
|
|
if (!song.art_automatic().isEmpty() && !song.has_embedded_cover()) {
|
|
|
|
return song.art_automatic();
|
|
|
|
|
2014-02-07 16:34:20 +01:00
|
|
|
// if no automatic art, start in the song's folder
|
2011-04-28 14:27:53 +02:00
|
|
|
} else if (!song.url().isEmpty() && song.url().toLocalFile().contains('/')) {
|
|
|
|
return song.url().toLocalFile().section('/', 0, -2) + filename;
|
2011-02-08 00:53:32 +01:00
|
|
|
|
2014-02-07 16:34:20 +01:00
|
|
|
// fallback - start in home
|
2011-02-08 00:53:32 +01:00
|
|
|
} else {
|
|
|
|
return QDir::home().absolutePath() + filename;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-01-24 18:53:31 +01:00
|
|
|
QString AlbumCoverChoiceController::LoadCoverFromURL(Song* song) {
|
2014-02-07 16:34:20 +01:00
|
|
|
if (!cover_from_url_dialog_) {
|
2011-01-24 01:09:57 +01:00
|
|
|
cover_from_url_dialog_ = new CoverFromURLDialog(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
QImage image = cover_from_url_dialog_->Exec();
|
2011-01-24 18:53:31 +01:00
|
|
|
|
2014-02-07 16:34:20 +01:00
|
|
|
if (!image.isNull()) {
|
2017-03-07 12:46:54 +01:00
|
|
|
QString cover = SaveCoverInCache(song->artist(), song->album(), image);
|
2011-01-24 18:53:31 +01:00
|
|
|
SaveCover(song, cover);
|
|
|
|
|
|
|
|
return cover;
|
|
|
|
} else {
|
|
|
|
return QString();
|
|
|
|
}
|
2011-01-24 01:09:57 +01:00
|
|
|
}
|
|
|
|
|
2011-01-24 18:53:31 +01:00
|
|
|
QString AlbumCoverChoiceController::SearchForCover(Song* song) {
|
2017-03-07 12:46:54 +01:00
|
|
|
// Get something sensible to stick in the search box.
|
|
|
|
// We search for the 'effective' values, but we cache the covers with the
|
|
|
|
// Song's artist() and album().
|
2017-03-04 19:23:38 +01:00
|
|
|
QImage image = cover_searcher_->Exec(song->effective_albumartist(),
|
|
|
|
song->effective_album());
|
2011-01-24 18:53:31 +01:00
|
|
|
|
2014-02-07 16:34:20 +01:00
|
|
|
if (!image.isNull()) {
|
2017-03-07 12:46:54 +01:00
|
|
|
QString cover = SaveCoverInCache(song->artist(), song->album(), image);
|
2011-01-24 18:53:31 +01:00
|
|
|
SaveCover(song, cover);
|
|
|
|
|
|
|
|
return cover;
|
|
|
|
} else {
|
|
|
|
return QString();
|
|
|
|
}
|
2011-01-24 01:09:57 +01:00
|
|
|
}
|
|
|
|
|
2011-01-24 18:53:31 +01:00
|
|
|
QString AlbumCoverChoiceController::UnsetCover(Song* song) {
|
2011-02-02 22:01:08 +01:00
|
|
|
QString cover = Song::kManuallyUnsetCover;
|
2011-01-24 18:53:31 +01:00
|
|
|
SaveCover(song, cover);
|
|
|
|
|
|
|
|
return cover;
|
2011-01-24 01:09:57 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void AlbumCoverChoiceController::ShowCover(const Song& song) {
|
|
|
|
QDialog* dialog = new QDialog(this);
|
|
|
|
dialog->setAttribute(Qt::WA_DeleteOnClose, true);
|
2011-11-13 01:59:44 +01:00
|
|
|
|
2017-03-07 12:46:54 +01:00
|
|
|
// Use (Album)Artist - Album as the window title
|
|
|
|
QString title_text(song.effective_albumartist());
|
|
|
|
if (!song.effective_album().isEmpty())
|
|
|
|
title_text += " - " + song.effective_album();
|
2011-11-13 01:59:44 +01:00
|
|
|
|
2011-01-24 01:09:57 +01:00
|
|
|
QLabel* label = new QLabel(dialog);
|
|
|
|
label->setPixmap(AlbumCoverLoader::TryLoadPixmap(
|
2011-04-28 14:27:53 +02:00
|
|
|
song.art_automatic(), song.art_manual(), song.url().toLocalFile()));
|
2011-01-24 01:09:57 +01:00
|
|
|
|
2014-05-01 18:26:48 +02:00
|
|
|
// add (WxHpx) to the title before possibly resizing
|
2014-05-03 15:54:19 +02:00
|
|
|
title_text += " (" + QString::number(label->pixmap()->width()) + "x" +
|
|
|
|
QString::number(label->pixmap()->height()) + "px)";
|
2014-05-01 18:26:48 +02:00
|
|
|
|
|
|
|
// if the cover is larger than the screen, resize the window
|
|
|
|
// 85% seems to be enough to account for title bar and taskbar etc.
|
|
|
|
QDesktopWidget desktop;
|
2015-05-21 23:47:58 +02:00
|
|
|
int current_screen = desktop.screenNumber(this);
|
|
|
|
int desktop_height = desktop.screenGeometry(current_screen).height();
|
|
|
|
int desktop_width = desktop.screenGeometry(current_screen).width();
|
2014-05-03 15:54:19 +02:00
|
|
|
|
|
|
|
// resize differently if monitor is in portrait mode
|
|
|
|
if (desktop_width < desktop_height) {
|
|
|
|
const int new_width = (double)desktop_width * 0.95;
|
|
|
|
if (new_width < label->pixmap()->width()) {
|
|
|
|
label->setPixmap(
|
|
|
|
label->pixmap()->scaledToWidth(new_width, Qt::SmoothTransformation));
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
const int new_height = (double)desktop_height * 0.85;
|
|
|
|
if (new_height < label->pixmap()->height()) {
|
|
|
|
label->setPixmap(label->pixmap()->scaledToHeight(
|
|
|
|
new_height, Qt::SmoothTransformation));
|
|
|
|
}
|
2014-05-01 18:26:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
dialog->setWindowTitle(title_text);
|
|
|
|
dialog->setFixedSize(label->pixmap()->size());
|
2011-01-24 01:09:57 +01:00
|
|
|
dialog->show();
|
|
|
|
}
|
2011-01-24 18:53:31 +01:00
|
|
|
|
2013-12-30 23:50:57 +01:00
|
|
|
void AlbumCoverChoiceController::SearchCoverAutomatically(const Song& song) {
|
2017-03-03 19:07:01 +01:00
|
|
|
qint64 id = cover_fetcher_->FetchAlbumCover(song.effective_albumartist(),
|
2017-03-04 19:23:38 +01:00
|
|
|
song.effective_album());
|
2013-12-30 23:50:57 +01:00
|
|
|
cover_fetching_tasks_[id] = song;
|
|
|
|
}
|
|
|
|
|
2014-02-07 16:34:20 +01:00
|
|
|
void AlbumCoverChoiceController::AlbumCoverFetched(
|
|
|
|
quint64 id, const QImage& image, const CoverSearchStatistics& statistics) {
|
2013-12-30 23:50:57 +01:00
|
|
|
Song song;
|
|
|
|
if (cover_fetching_tasks_.contains(id)) {
|
|
|
|
song = cover_fetching_tasks_.take(id);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!image.isNull()) {
|
2017-03-07 12:46:54 +01:00
|
|
|
QString cover = SaveCoverInCache(song.artist(), song.album(), image);
|
2013-12-30 23:50:57 +01:00
|
|
|
SaveCover(&song, cover);
|
|
|
|
}
|
|
|
|
|
|
|
|
emit AutomaticCoverSearchDone();
|
|
|
|
}
|
|
|
|
|
2014-02-07 16:34:20 +01:00
|
|
|
void AlbumCoverChoiceController::SaveCover(Song* song, const QString& cover) {
|
|
|
|
if (song->is_valid() && song->id() != -1) {
|
2011-01-24 18:53:31 +01:00
|
|
|
song->set_art_manual(cover);
|
2017-03-03 19:07:01 +01:00
|
|
|
app_->library_backend()->UpdateManualAlbumArtAsync(
|
2017-03-04 00:16:27 +01:00
|
|
|
song->artist(), song->albumartist(), song->album(), cover);
|
2012-02-13 21:44:04 +01:00
|
|
|
|
|
|
|
if (song->url() == app_->current_art_loader()->last_song().url()) {
|
|
|
|
app_->current_art_loader()->LoadArt(*song);
|
|
|
|
}
|
2011-01-24 18:53:31 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-07 16:34:20 +01:00
|
|
|
QString AlbumCoverChoiceController::SaveCoverInCache(const QString& artist,
|
|
|
|
const QString& album,
|
|
|
|
const QImage& image) {
|
2011-01-24 18:53:31 +01:00
|
|
|
// Hash the artist and album into a filename for the image
|
2013-12-31 15:21:50 +01:00
|
|
|
QString filename(Utilities::Sha1CoverHash(artist, album).toHex() + ".jpg");
|
2012-02-20 21:59:11 +01:00
|
|
|
QString path(AlbumCoverLoader::ImageCacheDir() + "/" + filename);
|
2011-01-24 18:53:31 +01:00
|
|
|
|
|
|
|
// Make sure this directory exists first
|
|
|
|
QDir dir;
|
|
|
|
dir.mkdir(AlbumCoverLoader::ImageCacheDir());
|
|
|
|
|
|
|
|
// Save the image to disk
|
|
|
|
image.save(path, "JPG");
|
|
|
|
|
|
|
|
return path;
|
2011-03-14 21:01:27 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
bool AlbumCoverChoiceController::IsKnownImageExtension(const QString& suffix) {
|
|
|
|
if (!sImageExtensions) {
|
|
|
|
sImageExtensions = new QSet<QString>();
|
2014-02-07 16:34:20 +01:00
|
|
|
(*sImageExtensions) << "png"
|
|
|
|
<< "jpg"
|
|
|
|
<< "jpeg"
|
|
|
|
<< "bmp"
|
|
|
|
<< "gif"
|
|
|
|
<< "xpm"
|
|
|
|
<< "pbm"
|
|
|
|
<< "pgm"
|
|
|
|
<< "ppm"
|
|
|
|
<< "xbm";
|
2011-03-14 21:01:27 +01:00
|
|
|
}
|
2011-01-24 18:53:31 +01:00
|
|
|
|
2011-03-14 21:01:27 +01:00
|
|
|
return sImageExtensions->contains(suffix);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool AlbumCoverChoiceController::CanAcceptDrag(const QDragEnterEvent* e) {
|
2014-02-10 14:29:07 +01:00
|
|
|
for (const QUrl& url : e->mimeData()->urls()) {
|
2011-03-14 21:01:27 +01:00
|
|
|
const QString suffix = QFileInfo(url.toLocalFile()).suffix().toLower();
|
2014-02-07 16:34:20 +01:00
|
|
|
if (IsKnownImageExtension(suffix)) return true;
|
2011-03-14 21:01:27 +01:00
|
|
|
}
|
2011-07-07 16:20:34 +02:00
|
|
|
if (e->mimeData()->hasImage()) {
|
|
|
|
return true;
|
|
|
|
}
|
2011-03-14 21:01:27 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
QString AlbumCoverChoiceController::SaveCover(Song* song, const QDropEvent* e) {
|
2014-02-10 14:29:07 +01:00
|
|
|
for (const QUrl& url : e->mimeData()->urls()) {
|
2011-03-14 21:01:27 +01:00
|
|
|
const QString filename = url.toLocalFile();
|
|
|
|
const QString suffix = QFileInfo(filename).suffix().toLower();
|
|
|
|
|
|
|
|
if (IsKnownImageExtension(suffix)) {
|
|
|
|
SaveCover(song, filename);
|
|
|
|
return filename;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-07-07 16:20:34 +02:00
|
|
|
if (e->mimeData()->hasImage()) {
|
|
|
|
QImage image = qvariant_cast<QImage>(e->mimeData()->imageData());
|
|
|
|
if (!image.isNull()) {
|
2014-02-07 16:34:20 +01:00
|
|
|
QString cover_path =
|
2017-03-07 12:46:54 +01:00
|
|
|
SaveCoverInCache(song->artist(), song->album(), image);
|
2011-07-07 16:20:34 +02:00
|
|
|
SaveCover(song, cover_path);
|
|
|
|
return cover_path;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-03-14 21:01:27 +01:00
|
|
|
return QString();
|
2011-01-24 18:53:31 +01:00
|
|
|
}
|