File indexing completed on 2025-02-23 04:34:19

 /**
  * \file servertrackimportdialog.cpp
  * Generic dialog for track based import from a server.
  *
  * \b Project: Kid3
  * \author Urs Fleisch
  * \date 13 Sep 2005
  *
  * Copyright (C) 2005-2024  Urs Fleisch
  *
  * This file is part of Kid3.
  *
  * Kid3 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 2 of the License, or
  * (at your option) any later version.
  *
  * Kid3 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 this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "servertrackimportdialog.h"
 #include <QLayout>
 #include <QPushButton>
 #include <QLineEdit>
 #include <QComboBox>
 #include <QCheckBox>
 #include <QLabel>
 #include <QStatusBar>
 #include <QTableView>
 #include <QHeaderView>
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QCoreApplication>
 #include "serverimporterconfig.h"
 #include "contexthelp.h"
 #include "servertrackimporter.h"
 #include "comboboxdelegate.h"
 #include "trackdatamodel.h"
 #include "standardtablemodel.h"
 
 namespace {
 
 class AlbumTableModel : public StandardTableModel {
 public:
   using StandardTableModel::StandardTableModel;
 
   Qt::ItemFlags flags(const QModelIndex& index) const override {
     Qt::ItemFlags itemFlags =
         QAbstractItemModel::flags(index) | Qt::ItemIsDropEnabled;
     if (index.isValid())
       itemFlags |= Qt::ItemIsDragEnabled;
     if (index.column() != 1)
       itemFlags |= Qt::ItemIsEditable;
     return itemFlags;
   }
 };
 
 }
 
 /**
  * Constructor.
  *
  * @param parent          parent widget
  * @param trackDataModel track data to be filled with imported values,
  *                        is passed with filenames set
  */
 ServerTrackImportDialog::ServerTrackImportDialog(QWidget* parent,
                                                  TrackDataModel* trackDataModel)
   : QDialog(parent), m_statusBar(nullptr),
     m_client(nullptr), m_trackDataModel(trackDataModel)
 {
   setObjectName(QLatin1String("ServerTrackImportDialog"));
   setModal(true);
 
   auto vlayout = new QVBoxLayout(this);
   auto serverLayout = new QHBoxLayout;
   m_serverLabel = new QLabel(tr("&Server:"), this);
   m_serverComboBox = new QComboBox(this);
   m_serverComboBox->setEditable(true);
   m_serverComboBox->setSizePolicy(
     QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum));
   m_serverLabel->setBuddy(m_serverComboBox);
   serverLayout->addWidget(m_serverLabel);
   serverLayout->addWidget(m_serverComboBox);
   vlayout->addLayout(serverLayout);
 
   m_albumTableModel = new AlbumTableModel(this);
   m_albumTableModel->setColumnCount(2);
   m_albumTableModel->setHorizontalHeaderLabels({
     QLatin1String("08 A Not So Short Title/Medium Sized Artist - And The Album Title [2005]"),
     QLatin1String("A Not So Short State")
   });
   m_albumTable = new QTableView(this);
   m_albumTable->setModel(m_albumTableModel);
   m_albumTable->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch);
   m_albumTable->setSelectionMode(QAbstractItemView::NoSelection);
   m_albumTable->resizeColumnsToContents();
   m_albumTable->setItemDelegateForColumn(0, new ComboBoxDelegate(this));
   m_albumTableModel->setHorizontalHeaderLabels({
     tr("Track Title/Artist - Album"),
     tr("State")
   });
   initTable();
   vlayout->addWidget(m_albumTable);
 
   auto hlayout = new QHBoxLayout;
   auto hspacer = new QSpacerItem(16, 0, QSizePolicy::Expanding,
                                          QSizePolicy::Minimum);
   m_helpButton = new QPushButton(tr("&Help"), this);
   m_helpButton->setAutoDefault(false);
   m_saveButton = new QPushButton(tr("&Save Settings"), this);
   m_saveButton->setAutoDefault(false);
   auto okButton = new QPushButton(tr("&OK"), this);
   auto applyButton = new QPushButton(tr("&Apply"), this);
   auto cancelButton = new QPushButton(tr("&Cancel"), this);
   hlayout->addWidget(m_helpButton);
   hlayout->addWidget(m_saveButton);
   hlayout->addItem(hspacer);
   hlayout->addWidget(okButton);
   hlayout->addWidget(applyButton);
   hlayout->addWidget(cancelButton);
   // auto default is switched off to use the return key to set the server
   // configuration
   okButton->setAutoDefault(false);
   okButton->setDefault(true);
   cancelButton->setAutoDefault(false);
   applyButton->setAutoDefault(false);
   connect(m_helpButton, &QAbstractButton::clicked, this, &ServerTrackImportDialog::showHelp);
   connect(m_saveButton, &QAbstractButton::clicked, this, &ServerTrackImportDialog::saveConfig);
   connect(okButton, &QAbstractButton::clicked, this, &ServerTrackImportDialog::accept);
   connect(cancelButton, &QAbstractButton::clicked, this, &ServerTrackImportDialog::reject);
   connect(applyButton, &QAbstractButton::clicked, this, &ServerTrackImportDialog::apply);
   vlayout->addLayout(hlayout);
 
   m_statusBar = new QStatusBar(this);
   vlayout->addWidget(m_statusBar);
   connect(m_albumTable->selectionModel(),
           &QItemSelectionModel::currentRowChanged,
           this, &ServerTrackImportDialog::showFilenameInStatusBar);
 }
 
 /**
  * Destructor.
  */
 ServerTrackImportDialog::~ServerTrackImportDialog()
 {
   stopClient();
 }
 
 /**
  * Set importer to be used.
  *
  * @param source  import source to use
  */
 void ServerTrackImportDialog::setImportSource(ServerTrackImporter* source)
 {
   if (m_client) {
     disconnect(m_client, &ServerTrackImporter::statusChanged,
                this, &ServerTrackImportDialog::setFileStatus);
     disconnect(m_client, &ServerTrackImporter::resultsReceived,
                this, &ServerTrackImportDialog::setResults);
   }
   m_client = source;
 
   if (m_client) {
     connect(m_client, &ServerTrackImporter::statusChanged,
             this, &ServerTrackImportDialog::setFileStatus);
     connect(m_client, &ServerTrackImporter::resultsReceived,
             this, &ServerTrackImportDialog::setResults);
 
     setWindowTitle(QCoreApplication::translate("@default", m_client->name()));
     if (m_client->defaultServer()) {
       m_serverLabel->show();
       m_serverComboBox->show();
       if (m_client->serverList()) {
         QStringList strList;
         for (const char** sl = m_client->serverList(); *sl != nullptr; ++sl) {
           strList += QString::fromLatin1(*sl); // clazy:exclude=reserve-candidates
         }
         m_serverComboBox->clear();
         m_serverComboBox->addItems(strList);
       }
     } else {
       m_serverLabel->hide();
       m_serverComboBox->hide();
     }
     if (m_client->helpAnchor()) {
       m_helpButton->show();
     } else {
       m_helpButton->hide();
     }
     if (m_client->config()) {
       m_saveButton->show();
     } else {
       m_saveButton->hide();
     }
   }
 }
 
 /**
  * Initialize the table model.
  * Has to be called before reusing the dialog with new track data.
  */
 void ServerTrackImportDialog::initTable()
 {
   if (m_client && m_client->config()) {
     setServer(m_client->config()->server());
   }
 
   int numRows = 0;
   const ImportTrackDataVector& trackDataVector(m_trackDataModel->trackData());
   for (auto it = trackDataVector.constBegin(); it != trackDataVector.constEnd(); ++it) {
     if (it->isEnabled()) {
       ++numRows;
     }
   }
 
   m_trackResults.resize(numRows);
   m_albumTableModel->clear();
   m_albumTableModel->insertRows(0, numRows);
   for (int i = 0; i < numRows; ++i) {
     QStringList cbItems;
     cbItems << tr("No result") << tr("Unknown");
     QModelIndex idx = m_albumTableModel->index(i, 0);
     m_albumTableModel->setData(idx, cbItems.first(), Qt::EditRole);
     m_albumTableModel->setData(idx, cbItems, Qt::UserRole);
     idx = m_albumTableModel->index(i, 1);
     m_albumTableModel->setData(idx, tr("Unknown"));
   }
   showFilenameInStatusBar(m_albumTable->currentIndex());
 }
 
 /**
  * Clear all results.
  */
 void ServerTrackImportDialog::clearResults()
 {
   const int numRows = m_trackResults.size();
   for (int i = 0; i < numRows; ++i) {
     m_trackResults[i].clear();
     setFileStatus(i, tr("Unknown"));
     updateFileTrackData(i);
   }
 }
 
 /**
  * Create and start the track import client.
  */
 void ServerTrackImportDialog::startClient()
 {
   if (m_client) {
     clearResults();
     ServerImporterConfig cfg;
     cfg.setServer(getServer());
     m_client->setConfig(&cfg);
     m_client->start();
   }
 }
 
 /**
  * Stop and destroy the track import client.
  */
 void ServerTrackImportDialog::stopClient()
 {
   if (m_client) {
     m_client->stop();
   }
 }
 
 /**
  * Hides the dialog and sets the result to QDialog::Accepted.
  */
 void ServerTrackImportDialog::accept()
 {
   apply();
   stopClient();
   QDialog::accept();
 }
 
 /**
  * Hides the dialog and sets the result to QDialog::Rejected.
  */
 void ServerTrackImportDialog::reject()
 {
   stopClient();
   QDialog::reject();
 }
 
 /**
  * Apply imported data.
  */
 void ServerTrackImportDialog::apply()
 {
   ImportTrackDataVector trackDataVector(m_trackDataModel->getTrackData());
   trackDataVector.setCoverArtUrl(QUrl());
   auto it = trackDataVector.begin();
   bool newTrackData = false;
   int numRows = m_albumTableModel->rowCount();
   for (int index = 0; index < numRows; ++index) {
     while (it != trackDataVector.end() && !it->isEnabled()) {
       ++it;
     }
     if (it == trackDataVector.end()) {
       break;
     }
     QModelIndex idx(m_albumTableModel->index(index, 0));
     if (idx.isValid()) {
       if (int selectedItem = idx.data(Qt::UserRole).toStringList().indexOf(
             idx.data(Qt::EditRole).toString());
           selectedItem > 0) {
         const ImportTrackData& selectedData =
           m_trackResults[index][selectedItem - 1];
         it->setTitle(selectedData.getTitle());
         it->setArtist(selectedData.getArtist());
         it->setAlbum(selectedData.getAlbum());
         it->setTrack(selectedData.getTrack());
         it->setYear(selectedData.getYear());
         it->setImportDuration(selectedData.getImportDuration());
         newTrackData = true;
       }
     }
     ++it;
   }
   if (newTrackData) {
     m_trackDataModel->setTrackData(trackDataVector);
     emit trackDataUpdated();
   }
 }
 
 /**
  * Shows the dialog as a modal dialog.
  */
 int ServerTrackImportDialog::exec()
 {
   startClient();
   return QDialog::exec();
 }
 
 /**
  * Set the status of a file.
  *
  * @param index  index of file
  * @param status status string
  */
 void ServerTrackImportDialog::setFileStatus(int index, const QString& status)
 {
   m_albumTableModel->setData(m_albumTableModel->index(index, 1),
                              status);
 }
 
 /**
  * Update the track data combo box of a file.
  *
  * @param index  index of file
  */
 void ServerTrackImportDialog::updateFileTrackData(int index)
 {
   QStringList stringList;
   const ImportTrackDataVector& trackData = m_trackResults.at(index);
   const int numResults = trackData.size();
   QString str(numResults == 0 ?
               tr("No result") : tr("No result selected"));
   stringList.push_back(str);
   for (auto it = trackData.constBegin(); it != trackData.constEnd(); ++it) {
     str = QString(QLatin1String("%1 "))
         .arg(it->getTrack(), 2, 10, QLatin1Char('0'));
     str += it->getTitle();
     str += QLatin1Char('/');
     str += it->getArtist();
     str += QLatin1String(" - ");
     str += it->getAlbum();
     if (it->getYear() > 0) {
       str += QString(QLatin1String(" [%1]")).arg(it->getYear());
     }
     stringList.push_back(str);
   }
   m_albumTableModel->setData(m_albumTableModel->index(index, 0),
                              stringList, Qt::UserRole);
   m_albumTableModel->setData(m_albumTableModel->index(index, 0),
                              stringList.at(numResults == 1 ? 1 : 0),
                              Qt::EditRole);
 }
 
 /**
  * Set result list for a file.
  *
  * @param index           index of file
  * @param trackDataVector result list
  */
 void ServerTrackImportDialog::setResults(
   int index, const ImportTrackDataVector& trackDataVector)
 {
   m_trackResults[index] = trackDataVector;
   updateFileTrackData(index);
 }
 
 /**
  * Get string with server and port.
  *
  * @return "servername:port".
  */
 QString ServerTrackImportDialog::getServer() const
 {
   QString server(m_serverComboBox->currentText());
   if (server.isEmpty() && m_client && m_client->defaultServer()) {
     server = QString::fromLatin1(m_client->defaultServer());
   }
   return server;
 }
 
 /**
  * Set string with server and port.
  *
  * @param srv "servername:port"
  */
 void ServerTrackImportDialog::setServer(const QString& srv)
 {
   if (int idx = m_serverComboBox->findText(srv); idx >= 0) {
     m_serverComboBox->setCurrentIndex(idx);
   } else {
     m_serverComboBox->addItem(srv);
     m_serverComboBox->setCurrentIndex(m_serverComboBox->count() - 1);
   }
 }
 
 /**
  * Save the local settings to the configuration.
  */
 void ServerTrackImportDialog::saveConfig()
 {
   if (m_client && m_client->config()) {
     m_client->config()->setServer(getServer());
   }
 }
 
 /**
  * Show help.
  */
 void ServerTrackImportDialog::showHelp()
 {
   if (m_client && m_client->helpAnchor()) {
     ContextHelp::displayHelp(QString::fromLatin1(m_client->helpAnchor()));
   }
 }
 
 /**
  * Show the name of the current track in the status bar.
  *
  * @param index model index
  */
 void ServerTrackImportDialog::showFilenameInStatusBar(const QModelIndex& index)
 {
   if (m_statusBar) {
     int row = index.row();
 
     int rowNr = 0;
     const ImportTrackDataVector& trackDataVector(m_trackDataModel->trackData());
     for (auto it = trackDataVector.constBegin();
          it != trackDataVector.constEnd();
          ++it) {
       if (it->isEnabled()) {
         if (rowNr == row) {
           m_statusBar->showMessage(it->getFilename());
           return;
         }
         ++rowNr;
       }
     }
     m_statusBar->clearMessage();
   }
 }