2015-02-18 20:05:35 +01:00
|
|
|
/* This file is part of Clementine.
|
|
|
|
Copyright 2014, Andre Siviero <altsiviero@gmail.com>
|
2021-06-01 17:51:00 +02:00
|
|
|
Copyright 2021, Lukas Prediger <lumip@lumip.de>
|
2015-02-18 20:05:35 +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/>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "ripper/ripcddialog.h"
|
|
|
|
|
|
|
|
#include <QCheckBox>
|
2018-07-07 10:26:11 +02:00
|
|
|
#include <QCloseEvent>
|
2015-02-18 20:05:35 +01:00
|
|
|
#include <QFileDialog>
|
2015-02-19 21:09:42 +01:00
|
|
|
#include <QFileInfo>
|
2015-02-18 20:05:35 +01:00
|
|
|
#include <QLineEdit>
|
|
|
|
#include <QMessageBox>
|
|
|
|
#include <QSettings>
|
2018-07-06 11:14:56 +02:00
|
|
|
#include <QUrl>
|
2020-09-18 16:15:19 +02:00
|
|
|
#include <algorithm>
|
2015-02-18 20:05:35 +01:00
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
#include "core/logging.h"
|
2021-08-22 14:04:43 +02:00
|
|
|
#include "core/organiseformat.h"
|
2015-02-18 20:05:35 +01:00
|
|
|
#include "core/tagreaderclient.h"
|
2021-05-30 14:23:37 +02:00
|
|
|
#include "devices/cddadevice.h"
|
2018-07-05 14:40:48 +02:00
|
|
|
#include "devices/cddasongloader.h"
|
2021-06-01 17:51:00 +02:00
|
|
|
#include "devices/devicemanager.h"
|
2015-02-18 20:05:35 +01:00
|
|
|
#include "ripper/ripper.h"
|
|
|
|
#include "transcoder/transcoder.h"
|
|
|
|
#include "transcoder/transcoderoptionsdialog.h"
|
|
|
|
#include "ui/iconloader.h"
|
2018-07-05 16:42:45 +02:00
|
|
|
#include "ui_ripcddialog.h"
|
2015-02-18 20:05:35 +01:00
|
|
|
namespace {
|
|
|
|
bool ComparePresetsByName(const TranscoderPreset& left,
|
|
|
|
const TranscoderPreset& right) {
|
|
|
|
return left.name_ < right.name_;
|
|
|
|
}
|
|
|
|
|
|
|
|
const int kCheckboxColumn = 0;
|
|
|
|
const int kTrackNumberColumn = 1;
|
|
|
|
const int kTrackTitleColumn = 2;
|
2015-10-11 12:05:07 +02:00
|
|
|
const int kTrackDurationColumn = 3;
|
2021-08-23 16:18:49 +02:00
|
|
|
const int kTrackFilenamePreviewColumn = 4;
|
2018-07-07 10:26:11 +02:00
|
|
|
} // namespace
|
2015-02-18 20:05:35 +01:00
|
|
|
|
|
|
|
const char* RipCDDialog::kSettingsGroup = "Transcoder";
|
|
|
|
const int RipCDDialog::kMaxDestinationItems = 10;
|
|
|
|
|
2021-06-16 16:53:41 +02:00
|
|
|
RipCDDialog::RipCDDialog(DeviceManager* device_manager, QWidget* parent)
|
2015-02-18 20:07:05 +01:00
|
|
|
: QDialog(parent),
|
|
|
|
ui_(new Ui_RipCDDialog),
|
2021-06-01 17:51:00 +02:00
|
|
|
device_manager_(device_manager),
|
|
|
|
cdda_devices_(
|
2021-06-16 16:53:41 +02:00
|
|
|
device_manager->FindDevicesByUrlSchemes(CddaDevice::url_schemes())),
|
2018-07-05 14:40:48 +02:00
|
|
|
working_(false),
|
2021-07-30 14:58:44 +02:00
|
|
|
cdda_device_() {
|
2021-06-16 16:53:41 +02:00
|
|
|
Q_ASSERT(device_manager);
|
2015-02-18 20:05:35 +01:00
|
|
|
// Init
|
|
|
|
ui_->setupUi(this);
|
|
|
|
|
|
|
|
// Set column widths in the QTableWidget.
|
2015-04-16 17:16:34 +02:00
|
|
|
ui_->tableWidget->horizontalHeader()->setSectionResizeMode(
|
2015-02-18 20:05:35 +01:00
|
|
|
kCheckboxColumn, QHeaderView::ResizeToContents);
|
2015-04-16 17:16:34 +02:00
|
|
|
ui_->tableWidget->horizontalHeader()->setSectionResizeMode(
|
2015-02-18 20:05:35 +01:00
|
|
|
kTrackNumberColumn, QHeaderView::ResizeToContents);
|
2020-09-18 16:15:19 +02:00
|
|
|
ui_->tableWidget->horizontalHeader()->setSectionResizeMode(
|
2021-08-23 16:18:49 +02:00
|
|
|
kTrackDurationColumn, QHeaderView::ResizeToContents);
|
|
|
|
ui_->tableWidget->horizontalHeader()->setSectionResizeMode(
|
|
|
|
kTrackTitleColumn, QHeaderView::ResizeToContents);
|
|
|
|
ui_->tableWidget->horizontalHeader()->setSectionResizeMode(
|
|
|
|
kTrackFilenamePreviewColumn, QHeaderView::Stretch);
|
2015-02-18 20:05:35 +01:00
|
|
|
|
|
|
|
// Add a rip button
|
|
|
|
rip_button_ = ui_->button_box->addButton(tr("Start ripping"),
|
|
|
|
QDialogButtonBox::ActionRole);
|
|
|
|
cancel_button_ = ui_->button_box->button(QDialogButtonBox::Cancel);
|
|
|
|
close_button_ = ui_->button_box->button(QDialogButtonBox::Close);
|
|
|
|
|
|
|
|
// Hide elements
|
|
|
|
cancel_button_->hide();
|
|
|
|
ui_->progress_group->hide();
|
|
|
|
|
2021-08-22 14:04:43 +02:00
|
|
|
rip_button_->setEnabled(
|
|
|
|
false); // will be enabled by signal handlers if a valid device is
|
|
|
|
// selected by user and a list of tracks is loaded
|
2021-06-01 17:51:00 +02:00
|
|
|
|
2015-02-18 20:05:35 +01:00
|
|
|
connect(ui_->select_all_button, SIGNAL(clicked()), SLOT(SelectAll()));
|
|
|
|
connect(ui_->select_none_button, SIGNAL(clicked()), SLOT(SelectNone()));
|
|
|
|
connect(ui_->invert_selection_button, SIGNAL(clicked()),
|
|
|
|
SLOT(InvertSelection()));
|
|
|
|
connect(rip_button_, SIGNAL(clicked()), SLOT(ClickedRipButton()));
|
|
|
|
connect(close_button_, SIGNAL(clicked()), SLOT(hide()));
|
|
|
|
|
|
|
|
connect(ui_->options, SIGNAL(clicked()), SLOT(Options()));
|
|
|
|
connect(ui_->select, SIGNAL(clicked()), SLOT(AddDestination()));
|
|
|
|
|
2021-08-22 14:04:43 +02:00
|
|
|
connect(ui_->naming_group, SIGNAL(FormatStringChanged()),
|
|
|
|
SLOT(FormatStringUpdated()));
|
2021-08-23 16:18:49 +02:00
|
|
|
connect(ui_->naming_group, SIGNAL(OptionChanged()),
|
|
|
|
SLOT(FormatStringUpdated()));
|
2021-08-22 14:04:43 +02:00
|
|
|
|
2015-02-18 20:05:35 +01:00
|
|
|
setWindowTitle(tr("Rip CD"));
|
|
|
|
AddDestinationDirectory(QDir::homePath());
|
|
|
|
|
|
|
|
// Get presets
|
|
|
|
QList<TranscoderPreset> presets = Transcoder::GetAllPresets();
|
2018-10-05 17:19:05 +02:00
|
|
|
std::sort(presets.begin(), presets.end(), ComparePresetsByName);
|
2015-02-18 20:05:35 +01:00
|
|
|
for (const TranscoderPreset& preset : presets) {
|
|
|
|
ui_->format->addItem(
|
2015-02-19 13:31:53 +01:00
|
|
|
QString("%1 (.%2)").arg(preset.name_).arg(preset.extension_),
|
2015-02-18 20:05:35 +01:00
|
|
|
QVariant::fromValue(preset));
|
|
|
|
}
|
|
|
|
|
|
|
|
// Load settings
|
|
|
|
QSettings s;
|
|
|
|
s.beginGroup(kSettingsGroup);
|
|
|
|
last_add_dir_ = s.value("last_add_dir", QDir::homePath()).toString();
|
|
|
|
|
2021-08-23 17:22:55 +02:00
|
|
|
QString last_output_format =
|
|
|
|
s.value("last_output_format", "audio/x-vorbis").toString();
|
|
|
|
qLog(Debug) << "last_output_format loaded: " << last_output_format;
|
2015-02-18 20:05:35 +01:00
|
|
|
for (int i = 0; i < ui_->format->count(); ++i) {
|
|
|
|
if (last_output_format ==
|
2021-08-23 17:22:55 +02:00
|
|
|
ui_->format->itemData(i).value<TranscoderPreset>().codec_mimetype_) {
|
2015-02-18 20:05:35 +01:00
|
|
|
ui_->format->setCurrentIndex(i);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2021-08-23 16:18:49 +02:00
|
|
|
|
|
|
|
connect(ui_->format, SIGNAL(currentIndexChanged(int)),
|
2021-09-04 13:21:55 +02:00
|
|
|
SLOT(UpdateFileNamePreviews()));
|
|
|
|
|
|
|
|
connect(ui_->artistLineEdit, SIGNAL(textEdited(const QString&)),
|
|
|
|
SLOT(UpdateMetadataFromGUI()));
|
|
|
|
connect(ui_->albumLineEdit, SIGNAL(textEdited(const QString&)),
|
|
|
|
SLOT(UpdateMetadataFromGUI()));
|
|
|
|
connect(ui_->genreLineEdit, SIGNAL(textEdited(const QString&)),
|
|
|
|
SLOT(UpdateMetadataFromGUI()));
|
|
|
|
connect(ui_->yearLineEdit, SIGNAL(textEdited(const QString&)),
|
|
|
|
SLOT(YearEditChanged(const QString&)));
|
|
|
|
connect(ui_->discLineEdit, SIGNAL(textEdited(const QString&)),
|
|
|
|
SLOT(DiscEditChanged(const QString&)));
|
2021-07-30 15:17:16 +02:00
|
|
|
|
|
|
|
InitializeDevices();
|
2015-02-18 20:05:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
RipCDDialog::~RipCDDialog() {}
|
|
|
|
|
2018-07-07 10:26:11 +02:00
|
|
|
void RipCDDialog::closeEvent(QCloseEvent* event) {
|
|
|
|
if (working_) {
|
|
|
|
event->ignore();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-18 20:07:05 +01:00
|
|
|
void RipCDDialog::showEvent(QShowEvent* event) {
|
2021-06-01 18:15:10 +02:00
|
|
|
// No need to refresh track list here anymore. On first open this is initiated
|
|
|
|
// by InitializeDevices(). Afterwards track list is always updates when a disc
|
|
|
|
// change is detected due to working through CddaDevice
|
2015-02-18 20:07:05 +01:00
|
|
|
if (!working_) {
|
|
|
|
ui_->progress_group->hide();
|
|
|
|
}
|
|
|
|
}
|
2015-02-18 20:05:35 +01:00
|
|
|
|
2021-06-01 17:51:00 +02:00
|
|
|
void RipCDDialog::InitializeDevices() {
|
|
|
|
Q_ASSERT(!cdda_device_);
|
|
|
|
|
|
|
|
// add all devices to drop down selection
|
|
|
|
for (const DeviceInfo* device_info : cdda_devices_) {
|
|
|
|
ui_->cd_drive_selection->addItem(device_info->friendly_name_);
|
|
|
|
}
|
|
|
|
// ensure that selecting the first device below will emit a
|
|
|
|
// currentIndexChanged signal
|
|
|
|
ui_->cd_drive_selection->setCurrentIndex(-1);
|
|
|
|
|
|
|
|
connect(ui_->cd_drive_selection, SIGNAL(currentIndexChanged(int)),
|
|
|
|
SLOT(DeviceSelected(int)));
|
|
|
|
|
|
|
|
// look for any already connected device, guess that might be the one the user
|
|
|
|
// is interested in and make it the active selection
|
|
|
|
for (int i = 0; i < cdda_devices_.size(); ++i) {
|
|
|
|
DeviceInfo* device_info = cdda_devices_[i];
|
|
|
|
if (device_info->device_) {
|
|
|
|
// found one!
|
|
|
|
ui_->cd_drive_selection->setCurrentIndex(i);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// there is no device that is already connected; just select the first one
|
|
|
|
if (!cdda_devices_.isEmpty()) ui_->cd_drive_selection->setCurrentIndex(0);
|
|
|
|
}
|
|
|
|
|
2015-02-18 20:05:35 +01:00
|
|
|
void RipCDDialog::ClickedRipButton() {
|
2021-06-01 17:51:00 +02:00
|
|
|
Q_ASSERT(cdda_device_);
|
|
|
|
|
2021-08-22 14:04:43 +02:00
|
|
|
OrganiseFormat format = ui_->naming_group->format();
|
|
|
|
Q_ASSERT(format.IsValid());
|
|
|
|
|
|
|
|
QFileInfo path(
|
|
|
|
ui_->destination->itemData(ui_->destination->currentIndex()).toString());
|
|
|
|
|
2021-06-01 17:51:00 +02:00
|
|
|
// create and connect Ripper instance for this task
|
|
|
|
Ripper* ripper = new Ripper(cdda_device_->raw_cdio(), this);
|
|
|
|
connect(cancel_button_, SIGNAL(clicked()), ripper, SLOT(Cancel()));
|
|
|
|
|
2021-06-16 16:53:41 +02:00
|
|
|
connect(ripper, &Ripper::Finished, this,
|
|
|
|
[this, ripper]() { this->Finished(ripper); });
|
|
|
|
connect(ripper, &Ripper::Cancelled, this,
|
|
|
|
[this, ripper]() { this->Cancelled(ripper); });
|
2021-06-01 17:51:00 +02:00
|
|
|
connect(ripper, SIGNAL(ProgressInterval(int, int)),
|
|
|
|
SLOT(SetupProgressBarLimits(int, int)));
|
|
|
|
connect(ripper, SIGNAL(Progress(int)), SLOT(UpdateProgressBar(int)));
|
|
|
|
|
2015-02-18 20:05:35 +01:00
|
|
|
// Add tracks and album information to the ripper.
|
2021-06-01 17:51:00 +02:00
|
|
|
ripper->ClearTracks();
|
2015-02-18 20:05:35 +01:00
|
|
|
TranscoderPreset preset = ui_->format->itemData(ui_->format->currentIndex())
|
|
|
|
.value<TranscoderPreset>();
|
|
|
|
for (int i = 1; i <= ui_->tableWidget->rowCount(); ++i) {
|
|
|
|
if (!checkboxes_.value(i - 1)->isChecked()) {
|
|
|
|
continue;
|
|
|
|
}
|
2021-08-22 14:04:43 +02:00
|
|
|
Song& song = songs_[i - 1];
|
|
|
|
QString transcoded_filename = format.GetFilenameForSong(
|
|
|
|
song, preset, /*prefix_path=*/path.filePath());
|
|
|
|
ripper->AddTrack(i, song.title(), transcoded_filename, preset,
|
|
|
|
ui_->naming_group->overwrite_existing());
|
2015-02-18 20:05:35 +01:00
|
|
|
}
|
2021-08-22 14:04:43 +02:00
|
|
|
|
2021-06-01 17:51:00 +02:00
|
|
|
ripper->SetAlbumInformation(
|
2015-02-18 20:05:35 +01:00
|
|
|
ui_->albumLineEdit->text(), ui_->artistLineEdit->text(),
|
|
|
|
ui_->genreLineEdit->text(), ui_->yearLineEdit->text().toInt(),
|
|
|
|
ui_->discLineEdit->text().toInt(), preset.type_);
|
|
|
|
|
|
|
|
SetWorking(true);
|
2021-06-01 17:51:00 +02:00
|
|
|
ripper->Start();
|
2021-08-23 17:22:55 +02:00
|
|
|
|
|
|
|
// store settings
|
|
|
|
QSettings s;
|
|
|
|
s.beginGroup(kSettingsGroup);
|
|
|
|
s.setValue("last_output_format", preset.codec_mimetype_);
|
|
|
|
qLog(Debug) << "last_output_format stored: " << preset.codec_mimetype_;
|
|
|
|
|
|
|
|
ui_->naming_group->StoreSettings();
|
2015-02-18 20:05:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void RipCDDialog::Options() {
|
|
|
|
TranscoderPreset preset = ui_->format->itemData(ui_->format->currentIndex())
|
|
|
|
.value<TranscoderPreset>();
|
|
|
|
|
2021-01-31 08:34:01 +01:00
|
|
|
TranscoderOptionsDialog dialog(preset, this);
|
2021-01-31 09:36:47 +01:00
|
|
|
dialog.exec();
|
2015-02-18 20:05:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Adds a folder to the destination box.
|
|
|
|
void RipCDDialog::AddDestination() {
|
|
|
|
int index = ui_->destination->currentIndex();
|
|
|
|
QString initial_dir = (!ui_->destination->itemData(index).isNull()
|
|
|
|
? ui_->destination->itemData(index).toString()
|
|
|
|
: QDir::homePath());
|
|
|
|
QString dir =
|
|
|
|
QFileDialog::getExistingDirectory(this, tr("Add folder"), initial_dir);
|
|
|
|
|
|
|
|
if (!dir.isEmpty()) {
|
|
|
|
// Keep only a finite number of items in the box.
|
|
|
|
while (ui_->destination->count() >= kMaxDestinationItems) {
|
|
|
|
ui_->destination->removeItem(0); // The oldest item.
|
|
|
|
}
|
|
|
|
AddDestinationDirectory(dir);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Adds a directory to the 'destination' combo box.
|
|
|
|
void RipCDDialog::AddDestinationDirectory(QString dir) {
|
2015-10-14 03:01:08 +02:00
|
|
|
QIcon icon = IconLoader::Load("folder", IconLoader::Base);
|
2015-02-18 20:05:35 +01:00
|
|
|
QVariant data = QVariant::fromValue(dir);
|
|
|
|
// Do not insert duplicates.
|
|
|
|
int duplicate_index = ui_->destination->findData(data);
|
|
|
|
if (duplicate_index == -1) {
|
|
|
|
ui_->destination->addItem(icon, dir, data);
|
|
|
|
ui_->destination->setCurrentIndex(ui_->destination->count() - 1);
|
|
|
|
} else {
|
|
|
|
ui_->destination->setCurrentIndex(duplicate_index);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void RipCDDialog::SelectAll() {
|
|
|
|
for (QCheckBox* checkbox : checkboxes_) {
|
|
|
|
checkbox->setCheckState(Qt::Checked);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void RipCDDialog::SelectNone() {
|
|
|
|
for (QCheckBox* checkbox : checkboxes_) {
|
|
|
|
checkbox->setCheckState(Qt::Unchecked);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void RipCDDialog::InvertSelection() {
|
|
|
|
for (QCheckBox* checkbox : checkboxes_) {
|
2015-02-19 13:31:53 +01:00
|
|
|
checkbox->setCheckState(checkbox->isChecked() ? Qt::Unchecked
|
|
|
|
: Qt::Checked);
|
2015-02-18 20:05:35 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-06-01 17:51:00 +02:00
|
|
|
void RipCDDialog::DeviceSelected(int device_index) {
|
2021-07-30 14:58:44 +02:00
|
|
|
// disconnecting from previous device, if any
|
2021-06-01 17:51:00 +02:00
|
|
|
if (cdda_device_) disconnect(cdda_device_.get(), nullptr, this, nullptr);
|
|
|
|
|
|
|
|
ResetDialog();
|
2021-08-22 14:04:43 +02:00
|
|
|
EnableIfPossible();
|
2021-06-01 17:51:00 +02:00
|
|
|
if (device_index < 0)
|
|
|
|
return; // Invalid selection, probably no devices around
|
|
|
|
|
|
|
|
Q_ASSERT(device_index < cdda_devices_.size());
|
|
|
|
|
|
|
|
DeviceInfo* device_info = cdda_devices_[device_index];
|
|
|
|
std::shared_ptr<ConnectedDevice> device =
|
2021-06-16 16:53:41 +02:00
|
|
|
device_manager_->Connect(device_info);
|
2021-06-01 17:51:00 +02:00
|
|
|
cdda_device_ = std::dynamic_pointer_cast<CddaDevice>(device);
|
|
|
|
if (!cdda_device_) {
|
|
|
|
rip_button_->setEnabled(false);
|
|
|
|
QMessageBox cdio_fail(QMessageBox::Critical, tr("Error"),
|
|
|
|
tr("Failed reading CD drive"));
|
|
|
|
cdio_fail.exec();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-08-23 18:15:23 +02:00
|
|
|
SongList songs = cdda_device_->songs();
|
|
|
|
SongsLoaded(songs);
|
|
|
|
|
2021-06-01 17:51:00 +02:00
|
|
|
connect(cdda_device_.get(), SIGNAL(DiscChanged()), SLOT(DiscChanged()));
|
2021-07-30 14:58:44 +02:00
|
|
|
connect(cdda_device_.get(), SIGNAL(SongsDiscovered(SongList)),
|
|
|
|
SLOT(SongsLoaded(SongList)));
|
2021-06-01 17:51:00 +02:00
|
|
|
}
|
|
|
|
|
2021-06-16 16:53:41 +02:00
|
|
|
void RipCDDialog::Finished(Ripper* ripper) {
|
2021-06-01 17:51:00 +02:00
|
|
|
SetWorking(false);
|
|
|
|
ripper->deleteLater();
|
|
|
|
}
|
2015-02-18 20:05:35 +01:00
|
|
|
|
2021-06-16 16:53:41 +02:00
|
|
|
void RipCDDialog::Cancelled(Ripper* ripper) {
|
2015-02-18 20:05:35 +01:00
|
|
|
ui_->progress_bar->setValue(0);
|
2021-06-16 16:53:41 +02:00
|
|
|
Finished(ripper);
|
2015-02-18 20:05:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void RipCDDialog::SetupProgressBarLimits(int min, int max) {
|
|
|
|
ui_->progress_bar->setRange(min, max);
|
|
|
|
}
|
|
|
|
|
|
|
|
void RipCDDialog::UpdateProgressBar(int progress) {
|
|
|
|
ui_->progress_bar->setValue(progress);
|
|
|
|
}
|
|
|
|
|
2021-09-04 13:21:55 +02:00
|
|
|
void RipCDDialog::SongsLoaded(const SongList& songs) {
|
2021-08-22 14:04:43 +02:00
|
|
|
if (songs_.isEmpty() || songs_.length() == songs.length()) {
|
|
|
|
songs_ = songs;
|
|
|
|
UpdateTrackListTable();
|
2021-09-04 13:21:55 +02:00
|
|
|
UpdateMetadataEdits();
|
2021-08-22 14:04:43 +02:00
|
|
|
} else {
|
|
|
|
qLog(Error) << "Number of tracks in metadata does not match number of "
|
|
|
|
"songs on disc!";
|
|
|
|
}
|
|
|
|
EnableIfPossible();
|
|
|
|
}
|
|
|
|
|
|
|
|
void RipCDDialog::UpdateTrackListTable() {
|
2018-07-05 14:40:48 +02:00
|
|
|
checkboxes_.clear();
|
|
|
|
|
2021-08-22 14:04:43 +02:00
|
|
|
ui_->tableWidget->clear();
|
|
|
|
ui_->tableWidget->setRowCount(songs_.length());
|
2018-07-05 14:40:48 +02:00
|
|
|
int current_row = 0;
|
2021-08-22 14:04:43 +02:00
|
|
|
for (const Song& song : songs_) {
|
2018-07-05 14:40:48 +02:00
|
|
|
QCheckBox* checkbox = new QCheckBox(ui_->tableWidget);
|
|
|
|
checkbox->setCheckState(Qt::Checked);
|
|
|
|
checkboxes_.append(checkbox);
|
|
|
|
ui_->tableWidget->setCellWidget(current_row, kCheckboxColumn, checkbox);
|
|
|
|
ui_->tableWidget->setCellWidget(current_row, kTrackNumberColumn,
|
|
|
|
new QLabel(QString::number(song.track())));
|
|
|
|
QLineEdit* line_edit_track_title =
|
|
|
|
new QLineEdit(song.title(), ui_->tableWidget);
|
2021-08-22 14:04:43 +02:00
|
|
|
connect(line_edit_track_title, &QLineEdit::textChanged,
|
|
|
|
[this, current_row](const QString& text) {
|
|
|
|
songs_[current_row].set_title(text);
|
2021-08-23 16:18:49 +02:00
|
|
|
UpdateFileNamePreviews();
|
2021-08-22 14:04:43 +02:00
|
|
|
});
|
2018-07-05 14:40:48 +02:00
|
|
|
ui_->tableWidget->setCellWidget(current_row, kTrackTitleColumn,
|
|
|
|
line_edit_track_title);
|
|
|
|
ui_->tableWidget->setCellWidget(current_row, kTrackDurationColumn,
|
|
|
|
new QLabel(song.PrettyLength()));
|
|
|
|
current_row++;
|
|
|
|
}
|
2021-08-23 16:18:49 +02:00
|
|
|
UpdateFileNamePreviews();
|
|
|
|
}
|
|
|
|
|
|
|
|
void RipCDDialog::UpdateFileNamePreviews() {
|
|
|
|
OrganiseFormat format = ui_->naming_group->format();
|
|
|
|
TranscoderPreset preset = ui_->format->itemData(ui_->format->currentIndex())
|
|
|
|
.value<TranscoderPreset>();
|
|
|
|
|
|
|
|
int current_row = 0;
|
|
|
|
for (const Song& song : songs_) {
|
|
|
|
if (format.IsValid())
|
|
|
|
ui_->tableWidget->setCellWidget(
|
|
|
|
current_row, kTrackFilenamePreviewColumn,
|
|
|
|
new QLabel(format.GetFilenameForSong(song, preset)));
|
|
|
|
else
|
|
|
|
ui_->tableWidget->setCellWidget(current_row, kTrackFilenamePreviewColumn,
|
|
|
|
new QLabel(tr("Invalid format")));
|
|
|
|
current_row++;
|
|
|
|
}
|
2018-07-05 14:40:48 +02:00
|
|
|
}
|
|
|
|
|
2021-09-04 13:21:55 +02:00
|
|
|
void RipCDDialog::UpdateMetadataEdits() {
|
|
|
|
if (songs_.length() <= 0) return;
|
2018-07-05 14:40:48 +02:00
|
|
|
|
2021-09-04 13:21:55 +02:00
|
|
|
const Song& song = songs_.first();
|
2018-07-05 14:40:48 +02:00
|
|
|
ui_->albumLineEdit->setText(song.album());
|
2021-05-21 19:52:29 +02:00
|
|
|
if (!song.artist().isEmpty())
|
|
|
|
ui_->artistLineEdit->setText(song.artist());
|
|
|
|
else
|
|
|
|
ui_->artistLineEdit->setText(song.albumartist());
|
|
|
|
ui_->yearLineEdit->setText(song.PrettyYear());
|
|
|
|
ui_->genreLineEdit->setText(song.genre());
|
2018-07-05 14:40:48 +02:00
|
|
|
}
|
|
|
|
|
2021-05-30 14:23:37 +02:00
|
|
|
void RipCDDialog::DiscChanged() { ResetDialog(); }
|
|
|
|
|
2015-02-18 20:05:35 +01:00
|
|
|
void RipCDDialog::SetWorking(bool working) {
|
2015-02-18 20:07:05 +01:00
|
|
|
working_ = working;
|
2015-02-18 20:05:35 +01:00
|
|
|
rip_button_->setVisible(!working);
|
|
|
|
cancel_button_->setVisible(working);
|
|
|
|
close_button_->setVisible(!working);
|
|
|
|
ui_->input_group->setEnabled(!working);
|
|
|
|
ui_->output_group->setEnabled(!working);
|
|
|
|
ui_->progress_group->setVisible(true);
|
|
|
|
}
|
|
|
|
|
2018-07-05 14:40:48 +02:00
|
|
|
void RipCDDialog::ResetDialog() {
|
2021-08-22 14:04:43 +02:00
|
|
|
songs_.clear();
|
2018-07-05 14:40:48 +02:00
|
|
|
ui_->tableWidget->setRowCount(0);
|
|
|
|
ui_->albumLineEdit->clear();
|
|
|
|
ui_->artistLineEdit->clear();
|
|
|
|
ui_->genreLineEdit->clear();
|
|
|
|
ui_->yearLineEdit->clear();
|
|
|
|
ui_->discLineEdit->clear();
|
|
|
|
}
|
2021-08-22 14:04:43 +02:00
|
|
|
|
2021-08-23 16:18:49 +02:00
|
|
|
void RipCDDialog::FormatStringUpdated() {
|
|
|
|
UpdateFileNamePreviews();
|
|
|
|
EnableIfPossible();
|
|
|
|
}
|
2021-08-22 14:04:43 +02:00
|
|
|
|
|
|
|
void RipCDDialog::EnableIfPossible() {
|
2021-09-04 13:21:55 +02:00
|
|
|
bool disc_ok;
|
|
|
|
ui_->discLineEdit->text().toInt(&disc_ok);
|
|
|
|
disc_ok |= ui_->discLineEdit->text().isEmpty();
|
|
|
|
|
|
|
|
bool year_ok;
|
|
|
|
ui_->yearLineEdit->text().toInt(&year_ok);
|
|
|
|
year_ok |= ui_->yearLineEdit->text().isEmpty();
|
|
|
|
|
2021-08-22 14:04:43 +02:00
|
|
|
rip_button_->setEnabled(!songs_.isEmpty() &&
|
2021-09-04 13:21:55 +02:00
|
|
|
ui_->naming_group->format().IsValid() && disc_ok &&
|
|
|
|
year_ok);
|
|
|
|
}
|
|
|
|
|
|
|
|
void RipCDDialog::DiscEditChanged(const QString& disc_string) {
|
|
|
|
bool disc_ok = false;
|
|
|
|
disc_string.toInt(&disc_ok);
|
|
|
|
|
|
|
|
bool is_valid = disc_string.isEmpty() || disc_ok;
|
|
|
|
|
|
|
|
QString style;
|
|
|
|
if (!is_valid) {
|
|
|
|
style = "color: red;";
|
|
|
|
} else {
|
|
|
|
UpdateMetadataFromGUI();
|
|
|
|
}
|
|
|
|
ui_->discLineEdit->setStyleSheet(style);
|
|
|
|
EnableIfPossible();
|
|
|
|
}
|
|
|
|
|
|
|
|
void RipCDDialog::YearEditChanged(const QString& year_string) {
|
|
|
|
bool year_ok = false;
|
|
|
|
year_string.toInt(&year_ok);
|
|
|
|
|
|
|
|
bool is_valid = year_string.isEmpty() || year_ok;
|
|
|
|
|
|
|
|
QString style;
|
|
|
|
if (!is_valid) {
|
|
|
|
style = "color: red;";
|
|
|
|
} else {
|
|
|
|
UpdateMetadataFromGUI();
|
|
|
|
}
|
|
|
|
ui_->yearLineEdit->setStyleSheet(style);
|
|
|
|
EnableIfPossible();
|
|
|
|
}
|
|
|
|
|
|
|
|
void RipCDDialog::UpdateMetadataFromGUI() {
|
|
|
|
QString artist = ui_->artistLineEdit->text();
|
|
|
|
QString album = ui_->albumLineEdit->text();
|
|
|
|
QString genre = ui_->genreLineEdit->text();
|
|
|
|
bool disc_ok = false;
|
|
|
|
int disc = ui_->discLineEdit->text().toInt(&disc_ok);
|
|
|
|
bool year_ok = false;
|
|
|
|
int year = ui_->yearLineEdit->text().toInt(&year_ok);
|
|
|
|
|
|
|
|
for (Song& song : songs_) {
|
|
|
|
song.set_artist(artist);
|
|
|
|
song.set_album(album);
|
|
|
|
song.set_genre(genre);
|
|
|
|
if (disc_ok)
|
|
|
|
song.set_disc(disc);
|
|
|
|
else
|
|
|
|
song.set_disc(-1);
|
|
|
|
if (year_ok)
|
|
|
|
song.set_year(year);
|
|
|
|
else
|
|
|
|
song.set_year(-1);
|
|
|
|
}
|
|
|
|
UpdateFileNamePreviews();
|
2021-08-22 14:04:43 +02:00
|
|
|
}
|