Clementine-audio-player-Mac-Linux-Windows/src/ui/edittagdialog.cpp

/* 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/>.
*/

#include "albumcovermanager.h"
#include "edittagdialog.h"
#include "trackselectiondialog.h"
#include "ui_edittagdialog.h"
#include "core/albumcoverloader.h"
#include "core/utilities.h"
#include "library/library.h"
#include "library/librarybackend.h"
#include "playlist/playlistdelegates.h"
#include "ui/albumcoverchoicecontroller.h"
#include "ui/coverfromurldialog.h"

#include <QDateTime>
#include <QDir>
#include <QFuture>
#include <QFutureWatcher>
#include <QLabel>
#include <QMenu>
#include <QMessageBox>
#include <QPushButton>
#include <QShortcut>
#include <QtConcurrentRun>
#include <QtDebug>

const char* EditTagDialog::kHintText = QT_TR_NOOP("(different across multiple songs)");

EditTagDialog::EditTagDialog(QWidget* parent)
  : QDialog(parent),
    ui_(new Ui_EditTagDialog),
    album_cover_choice_controller_(new AlbumCoverChoiceController(this)),
    backend_(NULL),
    loading_(false),
    ignore_edits_(false),
    tag_fetcher_(new TagFetcher(this)),
    cover_loader_(new BackgroundThreadImplementation<AlbumCoverLoader, AlbumCoverLoader>(this)),
    cover_art_id_(0),
    cover_art_is_set_(false),
    results_dialog_(new TrackSelectionDialog(this))
{
  cover_loader_->Start(true);
  cover_loader_->Worker()->SetDefaultOutputImage(QImage(":nocover.png"));
  connect(cover_loader_->Worker().get(), SIGNAL(ImageLoaded(quint64,QImage,QImage)),
          SLOT(ArtLoaded(quint64,QImage,QImage)));
  connect(tag_fetcher_, SIGNAL(ResultAvailable(Song, SongList)),
          results_dialog_, SLOT(FetchTagFinished(Songa, SongList)),
          Qt::QueuedConnection);
  connect(tag_fetcher_, SIGNAL(Progress(Song,QString)),
          results_dialog_, SLOT(FetchTagProgress(Song,QString)));
  connect(results_dialog_, SIGNAL(SongChosen(Song, Song)),
          SLOT(FetchTagSongChosen(Song, Song)));

  ui_->setupUi(this);
  ui_->splitter->setSizes(QList<int>() << 200 << width() - 200);
  ui_->loading_container->hide();
  ui_->fetch_tag->setVisible(false);

  // An editable field is one that has a label as a buddy.  The label is
  // important because it gets turned bold when the field is changed.
  foreach (QLabel* label, findChildren<QLabel*>()) {
    QWidget* widget = label->buddy();
    if (widget) {
      // Store information about the field
      fields_ << FieldData(label, widget, widget->objectName());

      // Connect the Reset signal
      if (dynamic_cast<ExtendedEditor*>(widget)) {
        connect(widget, SIGNAL(Reset()), SLOT(ResetField()));
      }

      // Connect the edited signal
      if (qobject_cast<QLineEdit*>(widget)) {
        connect(widget, SIGNAL(textChanged(QString)), SLOT(FieldValueEdited()));
      } else if (qobject_cast<QPlainTextEdit*>(widget)) {
        connect(widget, SIGNAL(textChanged()), SLOT(FieldValueEdited()));
      } else if (qobject_cast<QSpinBox*>(widget)) {
        connect(widget, SIGNAL(valueChanged(int)), SLOT(FieldValueEdited()));
      }
    }
  }

  // Set the colour of all the labels on the summary page
  const bool light = palette().color(QPalette::Base).value() > 128;
  const QColor color = palette().color(QPalette::Dark);
  QPalette summary_label_palette(palette());
  summary_label_palette.setColor(QPalette::WindowText,
      light ? color.darker(150) : color.lighter(125));

  foreach (QLabel* label, ui_->summary_tab->findChildren<QLabel*>()) {
    if (label->property("field_label").toBool()) {
      label->setPalette(summary_label_palette);
    }
  }

  // Pretend the summary text is just a label
  ui_->summary->setMaximumHeight(ui_->art->height() - ui_->summary_art_button->height() - 4);

  connect(ui_->song_list->selectionModel(),
          SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
          SLOT(SelectionChanged()));
  connect(ui_->button_box, SIGNAL(clicked(QAbstractButton*)),
                           SLOT(ButtonClicked(QAbstractButton*)));
  connect(ui_->rating, SIGNAL(RatingChanged(float)),
                       SLOT(SongRated(float)));
  connect(ui_->playcount_reset, SIGNAL(clicked()), SLOT(ResetPlayCounts()));
  connect(ui_->fetch_tag, SIGNAL(clicked()), SLOT(FetchTag()));

  // Set up the album cover menu
  cover_menu_ = new QMenu(this);

  QList<QAction*> actions = album_cover_choice_controller_->GetAllActions();

  connect(album_cover_choice_controller_->cover_from_file_action(),
          SIGNAL(triggered()), this, SLOT(LoadCoverFromFile()));
  connect(album_cover_choice_controller_->cover_to_file_action(),
          SIGNAL(triggered()), this, SLOT(SaveCoverToFile()));
  connect(album_cover_choice_controller_->cover_from_url_action(),
          SIGNAL(triggered()), this, SLOT(LoadCoverFromURL()));
  connect(album_cover_choice_controller_->search_for_cover_action(),
          SIGNAL(triggered()), this, SLOT(SearchForCover()));
  connect(album_cover_choice_controller_->unset_cover_action(),
          SIGNAL(triggered()), this, SLOT(UnsetCover()));
  connect(album_cover_choice_controller_->show_cover_action(),
          SIGNAL(triggered()), this, SLOT(ShowCover()));

  cover_menu_->addActions(actions);

  ui_->summary_art_button->setMenu(cover_menu_);

  ui_->art->installEventFilter(this);

  // Add the next/previous buttons
  previous_button_ = new QPushButton(IconLoader::Load("go-previous"), tr("Previous"), this);
  next_button_ = new QPushButton(IconLoader::Load("go-next"), tr("Next"), this);
  ui_->button_box->addButton(previous_button_, QDialogButtonBox::ResetRole);
  ui_->button_box->addButton(next_button_, QDialogButtonBox::ResetRole);

  connect(previous_button_, SIGNAL(clicked()), SLOT(PreviousSong()));
  connect(next_button_, SIGNAL(clicked()), SLOT(NextSong()));

  // Set some shortcuts for the buttons
  new QShortcut(QKeySequence::Back, previous_button_, SLOT(click()));
  new QShortcut(QKeySequence::Forward, next_button_, SLOT(click()));
  new QShortcut(QKeySequence::MoveToPreviousPage, previous_button_, SLOT(click()));
  new QShortcut(QKeySequence::MoveToNextPage, next_button_, SLOT(click()));
}

EditTagDialog::~EditTagDialog() {
  delete ui_;
}

bool EditTagDialog::SetLoading(const QString& message) {
  const bool loading = !message.isEmpty();
  if (loading == loading_)
    return false;
  loading_ = loading;

  ui_->loading_container->setVisible(loading);
  ui_->button_box->setEnabled(!loading);
  ui_->tab_widget->setEnabled(!loading);
  ui_->song_list->setEnabled(!loading);
  ui_->fetch_tag->setEnabled(!loading);
  ui_->loading_label->setText(message);
  return true;
}

QList<EditTagDialog::Data> EditTagDialog::LoadData(const SongList& songs) const {
  QList<Data> ret;

  foreach (const Song& song, songs) {
    if (song.IsEditable()) {
      // Try reloading the tags from file
      Song copy(song);
      copy.InitFromFile(copy.filename(), copy.directory_id());

      if (copy.is_valid())
        ret << Data(copy);
    }
  }

  return ret;
}

void EditTagDialog::SetSongs(const SongList& s, const PlaylistItemList& items) {
  // Show the loading indicator
  if (!SetLoading(tr("Loading tracks") + "..."))
    return;

  data_.clear();
  playlist_items_ = items;
  ui_->song_list->clear();

  // Reload tags in the background
  QFuture<QList<Data> > future = QtConcurrent::run(this, &EditTagDialog::LoadData, s);
  QFutureWatcher<QList<Data> >* watcher = new QFutureWatcher<QList<Data> >(this);
  watcher->setFuture(future);
  connect(watcher, SIGNAL(finished()), SLOT(SetSongsFinished()));
}

void EditTagDialog::SetSongsFinished() {
  QFutureWatcher<QList<Data> >* watcher = dynamic_cast<QFutureWatcher<QList<Data> >*>(sender());
  if (!watcher)
    return;
  watcher->deleteLater();

  if (!SetLoading(QString()))
    return;

  data_ = watcher->result();
  if (data_.count() == 0)
    return;

  // Add the filenames to the list
  foreach (const Data& data, data_) {
    ui_->song_list->addItem(data.current_.basefilename());
  }

  // Select all
  ui_->song_list->setCurrentRow(0);
  ui_->song_list->selectAll();

  // Hide the list if there's only one song in it
  const bool multiple = data_.count() != 1;
  ui_->song_list->setVisible(multiple);
  previous_button_->setEnabled(multiple);
  next_button_->setEnabled(multiple);

  ui_->tab_widget->setCurrentWidget(multiple ? ui_->tags_tab : ui_->summary_tab);
}

void EditTagDialog::SetTagCompleter(LibraryBackend* backend) {
  backend_ = backend;
  album_cover_choice_controller_->SetLibrary(backend);

  new TagCompleter(backend, Playlist::Column_Artist, ui_->artist);
  new TagCompleter(backend, Playlist::Column_Album, ui_->album);
  new TagCompleter(backend, Playlist::Column_AlbumArtist, ui_->albumartist);
  new TagCompleter(backend, Playlist::Column_Genre, ui_->genre);
  new TagCompleter(backend, Playlist::Column_Composer, ui_->composer);
}

QVariant EditTagDialog::Data::value(const Song& song, const QString& id) {
  if (id == "title")       return song.title();
  if (id == "artist")      return song.artist();
  if (id == "album")       return song.album();
  if (id == "albumartist") return song.albumartist();
  if (id == "composer")    return song.composer();
  if (id == "genre")       return song.genre();
  if (id == "comment")     return song.comment();
  if (id == "track")       return song.track();
  if (id == "disc")        return song.disc();
  if (id == "year")        return song.year();
  qDebug() << "Unknown ID" << id;
  return QVariant();
}

void EditTagDialog::Data::set_value(const QString& id, const QVariant& value) {
  if (id == "title")       current_.set_title(value.toString());
  if (id == "artist")      current_.set_artist(value.toString());
  if (id == "album")       current_.set_album(value.toString());
  if (id == "albumartist") current_.set_albumartist(value.toString());
  if (id == "composer")    current_.set_composer(value.toString());
  if (id == "genre")       current_.set_genre(value.toString());
  if (id == "comment")     current_.set_comment(value.toString());
  if (id == "track")       current_.set_track(value.toInt());
  if (id == "disc")        current_.set_disc(value.toInt());
  if (id == "year")        current_.set_year(value.toInt());
}

bool EditTagDialog::DoesValueVary(const QModelIndexList& sel, const QString& id) const {
  QVariant value = data_[sel.first().row()].current_value(id);
  for (int i=1 ; i<sel.count() ; ++i) {
    if (value != data_[sel[i].row()].current_value(id))
      return true;
  }
  return false;
}

bool EditTagDialog::IsValueModified(const QModelIndexList& sel, const QString& id) const {
  foreach (const QModelIndex& i, sel) {
    if (data_[i.row()].original_value(id) != data_[i.row()].current_value(id))
      return true;
  }
  return false;
}

void EditTagDialog::InitFieldValue(const FieldData& field, const QModelIndexList& sel) {
  const bool varies = DoesValueVary(sel, field.id_);
  const bool modified = IsValueModified(sel, field.id_);

  if (ExtendedEditor* editor = dynamic_cast<ExtendedEditor*>(field.editor_)) {
    editor->clear();
    editor->clear_hint();
    if (varies) {
      editor->set_hint(EditTagDialog::kHintText);
    } else {
      editor->set_text(data_[sel[0].row()].current_value(field.id_).toString());
    }
  }

  QFont new_font(font());
  new_font.setBold(modified);
  field.label_->setFont(new_font);
  field.editor_->setFont(new_font);
}

void EditTagDialog::UpdateFieldValue(const FieldData& field, const QModelIndexList& sel) {
  // Get the value from the field
  QVariant value;
  if (ExtendedEditor* editor = dynamic_cast<ExtendedEditor*>(field.editor_)) {
    value = editor->text();
  }

  // Did we get it?
  if (!value.isValid()) {
    return;
  }

  // Set it in each selected song
  foreach (const QModelIndex& i, sel) {
    data_[i.row()].set_value(field.id_, value);
  }

  // Update the boldness
  const bool modified = IsValueModified(sel, field.id_);

  QFont new_font(font());
  new_font.setBold(modified);
  field.label_->setFont(new_font);
  field.editor_->setFont(new_font);
}

void EditTagDialog::ResetFieldValue(const FieldData& field, const QModelIndexList& sel) {
  // Reset each selected song
  foreach (const QModelIndex& i, sel) {
    Data& data = data_[i.row()];
    data.set_value(field.id_, data.original_value(field.id_));
  }

  // Reset the field
  InitFieldValue(field, sel);
}

void EditTagDialog::SelectionChanged() {
  const QModelIndexList sel = ui_->song_list->selectionModel()->selectedIndexes();
  if (sel.isEmpty())
    return;

  // Set the editable fields
  ignore_edits_ = true;
  foreach (const FieldData& field, fields_) {
    InitFieldValue(field, sel);
  }
  ignore_edits_ = false;

  // If we're editing multiple songs then we have to disable certain tabs
  const bool multiple = sel.count() > 1;
  ui_->tab_widget->setTabEnabled(ui_->tab_widget->indexOf(ui_->summary_tab), !multiple);

  if (!multiple) {
    const Song& song = data_[sel.first().row()].original_;
    UpdateSummaryTab(song);
    UpdateStatisticsTab(song);
  }
}

static void SetText(QLabel* label, int value, const QString& suffix, const QString& def = QString()) {
  label->setText(value <= 0 ? def : (QString::number(value) + " " + suffix));
}

void EditTagDialog::UpdateSummaryTab(const Song& song) {
  cover_art_id_ = cover_loader_->Worker()->LoadImageAsync(song);

  QString summary = "<b>" + Qt::escape(song.PrettyTitleWithArtist()) + "</b><br/>";

  bool art_is_set = true;
  if (song.has_manually_unset_cover()) {
    summary += Qt::escape(tr("Cover art manually unset"));
    art_is_set = false;
  } else if (!song.art_manual().isEmpty()) {
    summary += Qt::escape(tr("Cover art set from %1").arg(song.art_manual()));
  } else if (song.has_embedded_cover()) {
    summary += Qt::escape(tr("Cover art from embedded image"));
  } else if (!song.art_automatic().isEmpty()) {
    summary += Qt::escape(tr("Cover art loaded automatically from %1").arg(song.art_manual()));
  } else {
    summary += Qt::escape(tr("Cover art not set"));
    art_is_set = false;
  }

  ui_->summary->setText(summary);

#ifndef HAVE_LIBLASTFM
  album_cover_choice_controller_->cover_from_file_action()->setEnabled(false);
  album_cover_choice_controller_->search_for_cover_action()->setEnabled(false);
#endif

  album_cover_choice_controller_->unset_cover_action()->setEnabled(art_is_set);
  album_cover_choice_controller_->show_cover_action()->setEnabled(art_is_set);
  ui_->summary_art_button->setEnabled(song.id() != -1);

  ui_->length->setText(Utilities::PrettyTimeNanosec(song.length_nanosec()));
  SetText(ui_->bpm, song.bpm(), tr("bpm"));
  SetText(ui_->samplerate, song.samplerate(), "Hz");
  SetText(ui_->bitrate, song.bitrate(), tr("kbps"));
  ui_->mtime->setText(QDateTime::fromTime_t(song.mtime()).toString(
        QLocale::system().dateTimeFormat(QLocale::LongFormat)));
  ui_->ctime->setText(QDateTime::fromTime_t(song.ctime()).toString(
        QLocale::system().dateTimeFormat(QLocale::LongFormat)));
  ui_->filesize->setText(Utilities::PrettySize(song.filesize()));
  ui_->filetype->setText(song.TextForFiletype());
  ui_->filename->setText(QDir::toNativeSeparators(song.filename()));
}

void EditTagDialog::UpdateStatisticsTab(const Song& song) {
  ui_->playcount->setText(QString::number(qMax(0, song.playcount())));
  ui_->skipcount->setText(QString::number(qMax(0, song.skipcount())));
  ui_->score->setText(QString::number(qMax(0, song.score())));
  ui_->rating->set_rating(song.rating());

  ui_->lastplayed->setText(song.lastplayed() <= 0 ? tr("Never") :
      QDateTime::fromTime_t(song.lastplayed()).toString(
          QLocale::system().dateTimeFormat(QLocale::LongFormat)));
}

void EditTagDialog::ArtLoaded(quint64 id, const QImage& scaled, const QImage& original) {
  if (id == cover_art_id_) {
    ui_->art->setPixmap(QPixmap::fromImage(scaled));
    original_ = original;
  }
}

void EditTagDialog::FieldValueEdited() {
  if (ignore_edits_)
    return;

  const QModelIndexList sel = ui_->song_list->selectionModel()->selectedIndexes();
  if (sel.isEmpty())
    return;

  QWidget* w = qobject_cast<QWidget*>(sender());

  // Find the field
  foreach (const FieldData& field, fields_) {
    if (field.editor_ == w) {
      UpdateFieldValue(field, sel);
      return;
    }
  }
}

void EditTagDialog::ResetField() {
  const QModelIndexList sel = ui_->song_list->selectionModel()->selectedIndexes();
  if (sel.isEmpty())
    return;

  QWidget* w = qobject_cast<QWidget*>(sender());

  // Find the field
  foreach (const FieldData& field, fields_) {
    if (field.editor_ == w) {
      ignore_edits_ = true;
      ResetFieldValue(field, sel);
      ignore_edits_ = false;
      return;
    }
  }
}

Song* EditTagDialog::GetFirstSelected() {
  const QModelIndexList sel = ui_->song_list->selectionModel()->selectedIndexes();
  if (sel.isEmpty())
    return NULL;
  return &data_[sel.first().row()].original_;
}

void EditTagDialog::LoadCoverFromFile() {
  Song* song = GetFirstSelected();
  if(!song)
    return;

  const QModelIndexList sel = ui_->song_list->selectionModel()->selectedIndexes();

  QString cover = album_cover_choice_controller_->LoadCoverFromFile(song);

  if(!cover.isEmpty())
    UpdateCoverOf(*song, sel, cover);
}

void EditTagDialog::SaveCoverToFile() {
  Song* song = GetFirstSelected();
  if(!song)
    return;

  album_cover_choice_controller_->SaveCoverToFile(*song, original_);
}

void EditTagDialog::LoadCoverFromURL() {
  Song* song = GetFirstSelected();
  if(!song)
    return;

  const QModelIndexList sel = ui_->song_list->selectionModel()->selectedIndexes();

  QString cover = album_cover_choice_controller_->LoadCoverFromURL(song);

  if(!cover.isEmpty())
    UpdateCoverOf(*song, sel, cover);
}

void EditTagDialog::SearchForCover() {
  Song* song = GetFirstSelected();
  if(!song)
    return;

  const QModelIndexList sel = ui_->song_list->selectionModel()->selectedIndexes();

  QString cover = album_cover_choice_controller_->SearchForCover(song);

  if(!cover.isEmpty())
    UpdateCoverOf(*song, sel, cover);
}

void EditTagDialog::UnsetCover() {
  Song* song = GetFirstSelected();
  if(!song)
    return;

  const QModelIndexList sel = ui_->song_list->selectionModel()->selectedIndexes();

  QString cover = album_cover_choice_controller_->UnsetCover(song);
  UpdateCoverOf(*song, sel, cover);
}

void EditTagDialog::ShowCover() {
  Song* song = GetFirstSelected();
  if(!song) {
    return;
  }

  album_cover_choice_controller_->ShowCover(*song);
}

void EditTagDialog::UpdateCoverOf(const Song& selected, const QModelIndexList& sel,
                                  const QString& cover) {
  if (!selected.is_valid() || selected.id() == -1)
    return;

  UpdateSummaryTab(selected);

  // Now check if we have any other songs cached that share that artist and
  // album (and would therefore be changed as well)
  for (int i=0 ; i<data_.count() ; ++i) {
    if (i == sel.first().row()) // Already changed this one
      continue;

    Song* other_song = &data_[i].original_;
    if (selected.artist() == other_song->artist() &&
        selected.album()  == other_song->album()) {
      other_song->set_art_manual(cover);
    }
  }
}

void EditTagDialog::NextSong() {
  int row = (ui_->song_list->currentRow() + 1) % ui_->song_list->count();
  ui_->song_list->setCurrentRow(row);
}

void EditTagDialog::PreviousSong() {
  int row = (ui_->song_list->currentRow() - 1 + ui_->song_list->count()) % ui_->song_list->count();
  ui_->song_list->setCurrentRow(row);
}

void EditTagDialog::ButtonClicked(QAbstractButton* button) {
  if (button == ui_->button_box->button(QDialogButtonBox::Discard)) {
    reject();
  }
}

void EditTagDialog::SaveData(const QList<Data>& data) {
  for (int i=0 ; i<data.count() ; ++i) {
    const Data& ref = data[i];
    if (ref.current_.IsMetadataEqual(ref.original_))
      continue;

    if (!ref.current_.Save()) {
      emit Error(tr("An error occurred writing metadata to '%1'").arg(ref.current_.filename()));
    }
  }
}

void EditTagDialog::accept() {
  // Show the loading indicator
  if (!SetLoading(tr("Saving tracks") + "..."))
    return;

  // Save tags in the background
  QFuture<void> future = QtConcurrent::run(this, &EditTagDialog::SaveData, data_);
  QFutureWatcher<void>* watcher = new QFutureWatcher<void>(this);
  watcher->setFuture(future);
  connect(watcher, SIGNAL(finished()), SLOT(AcceptFinished()));
}

void EditTagDialog::AcceptFinished() {
  QFutureWatcher<void>* watcher = dynamic_cast<QFutureWatcher<void>*>(sender());
  if (!watcher)
    return;
  watcher->deleteLater();

  if (!SetLoading(QString()))
    return;

  QDialog::accept();
}

bool EditTagDialog::eventFilter(QObject* o, QEvent* e) {
  if (o == ui_->art && e->type() == QEvent::MouseButtonRelease) {
    cover_menu_->popup(static_cast<QMouseEvent*>(e)->globalPos());
  }
  return false;
}

void EditTagDialog::showEvent(QShowEvent* e) {
  // Set the dialog's height to the smallest possible
  resize(width(), sizeHint().height());

  QDialog::showEvent(e);
}

void EditTagDialog::SongRated(float rating) {
  const QModelIndexList sel = ui_->song_list->selectionModel()->selectedIndexes();
  if (sel.isEmpty())
    return;
  Song* song = &data_[sel.first().row()].original_;
  if (!song->is_valid() || song->id() == -1)
    return;

  song->set_rating(rating);
  backend_->UpdateSongRatingAsync(song->id(), rating);
}

void EditTagDialog::ResetPlayCounts() {
  const QModelIndexList sel = ui_->song_list->selectionModel()->selectedIndexes();
  if (sel.isEmpty())
    return;
  Song* song = &data_[sel.first().row()].original_;
  if (!song->is_valid() || song->id() == -1)
    return;

  if (QMessageBox::question(this, tr("Reset play counts"),
        tr("Are you sure you want to reset this song's statistics?"),
        QMessageBox::Reset, QMessageBox::Cancel) != QMessageBox::Reset) {
    return;
  }

  song->set_playcount(0);
  song->set_skipcount(0);
  song->set_lastplayed(-1);
  song->set_score(0);
  backend_->ResetStatisticsAsync(song->id());
  UpdateStatisticsTab(*song);
}

void EditTagDialog::FetchTag() {
  const QModelIndexList sel = ui_->song_list->selectionModel()->selectedIndexes();

  SongList songs;

  foreach (const QModelIndex& index, sel) {
    Song song = data_[index.row()].original_;
    if (!song.is_valid()) {
      continue;
    }

    songs << song;
  }

  if (songs.isEmpty())
    return;

  results_dialog_->Init(songs);
  tag_fetcher_->StartFetch(songs);

  results_dialog_->show();
}

void EditTagDialog::FetchTagSongChosen(const Song& original_song, const Song& new_metadata) {
  const QString filename = original_song.filename();

  // Find the song with this filename
  for (int i=0 ; i<data_.count() ; ++i) {
    Data* data = &data_[i];
    if (data->original_.filename() != filename)
      continue;

    // Is it currently being displayed in the UI?
    if (ui_->song_list->currentRow() == i) {
      // Yes!  We can just set the fields in the UI
      ui_->title->set_text(new_metadata.title());
      ui_->artist->set_text(new_metadata.artist());
      ui_->album->set_text(new_metadata.album());
      ui_->track->setValue(new_metadata.track());
    } else {
      data->current_.set_title(new_metadata.title());
      data->current_.set_artist(new_metadata.artist());
      data->current_.set_album(new_metadata.album());
      data->current_.set_track(new_metadata.track());
    }

    break;
  }
}