File indexing completed on 2024-05-05 05:45:46

 /*
     SPDX-FileCopyrightText: 2001-2005, 2009 Otto Bruggeman <bruggie@gmail.com>
     SPDX-FileCopyrightText: 2001-2003 John Firebaugh <jfirebaugh@kde.org>
     SPDX-FileCopyrightText: 2004 Jeff Snyder <jeff@caffeinated.me.uk>
     SPDX-FileCopyrightText: 2007-2011 Kevin Kofler <kevin.kofler@chello.at>
     SPDX-FileCopyrightText: 2012 Jean-Nicolas Artaud <jeannicolasartaud@gmail.com>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "kompare_part.h"
 
 #include <QDialog>
 #include <QLayout>
 #include <QWidget>
 #include <QMenu>
 #include <QPainter>
 #include <QPrinter>
 #include <QPageLayout>
 #include <QPrintDialog>
 #include <QPrintPreviewDialog>
 #include <QTemporaryDir>
 #include <QTemporaryFile>
 
 #include <KPluginMetaData>
 #include <KActionCollection>
 #include <KJobWidgets>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KSharedConfig>
 #include <KStandardAction>
 #include <KStandardShortcut>
 #include <KStandardGuiItem>
 #include <KXMLGUIFactory>
 
 #include <KIO/CopyJob>
 #include <KIO/StatJob>
 #include <KIO/FileCopyJob>
 #include <KIO/MkdirJob>
 
 #include <KompareDiff2/DiffModel>
 #include <KompareDiff2/DiffSettings>
 
 #include <komparepartdebug.h>
 #include "komparelistview.h"
 #include "kompareconnectwidget.h"
 #include "viewsettings.h"
 #include "kompareprefdlg.h"
 #include "komparesaveoptionswidget.h"
 #include "komparesplitter.h"
 #include "kompareview.h"
 
 using namespace KompareDiff2;
 
 ViewSettings* KomparePart::m_viewSettings = nullptr;
 KompareDiff2::DiffSettings* KomparePart::m_diffSettings = nullptr;
 
 KomparePart::KomparePart(QWidget* parentWidget, QObject* parent, const KPluginMetaData& metaData, Modus modus) :
     KParts::ReadWritePart(parent, metaData),
     m_info()
 {
     // set our XML-UI resource file
     setXMLFile(QStringLiteral("komparepartui.rc"));
 
     if (!m_viewSettings) {
         m_viewSettings = new ViewSettings(nullptr);
     }
     if (!m_diffSettings) {
         m_diffSettings = new KompareDiff2::DiffSettings();
     }
 
     readProperties(KSharedConfig::openConfig().data());
 
     m_view = new KompareView(m_viewSettings, parentWidget);
     m_view->setContextMenuPolicy(Qt::CustomContextMenu);
     connect(m_view, &QWidget::customContextMenuRequested,
             this, &KomparePart::onContextMenuRequested);
     setWidget(m_view);
     m_splitter = m_view->splitter();
 
     // This creates the "Model creator" and connects the signals and slots
     m_modelList = new KompareDiff2::ModelList(m_diffSettings, this, (modus == ReadWriteModus));
 
     const auto modelListActions = m_modelList->actionCollection()->actions();
     for (QAction* action : modelListActions) {
         actionCollection()->addAction(action->objectName(), action);
     }
     connect(m_modelList, &ModelList::status,
             this, &KomparePart::slotSetStatus);
     connect(m_modelList, &ModelList::setStatusBarModelInfo,
             this, &KomparePart::setStatusBarModelInfo);
     connect(m_modelList, &ModelList::error,
             this, &KomparePart::slotShowError);
     connect(m_modelList, &ModelList::applyAllDifferences,
             this, &KomparePart::updateActions);
     connect(m_modelList, static_cast<void(ModelList::*)(bool)>(&ModelList::applyDifference),
             this, &KomparePart::updateActions);
     connect(m_modelList, &ModelList::applyAllDifferences,
             this, &KomparePart::appliedChanged);
     connect(m_modelList, static_cast<void(ModelList::*)(bool)>(&ModelList::applyDifference),
             this, &KomparePart::appliedChanged);
     connect(m_modelList, &ModelList::updateActions, this, &KomparePart::updateActions);
 
     // This is the stuff to connect the "interface" of the kompare part to the model inside
     connect(m_modelList, &ModelList::modelsChanged,
             this, &KomparePart::modelsChanged);
 
     typedef void(ModelList::*void_ModelList_argModelDiff)(const DiffModel*, const Difference*);
     typedef void(ModelList::*void_ModelList_argDiffBool)(const Difference*, bool);
     typedef void(KompareSplitter::*void_KompareSplitter_argModelDiff)(const DiffModel*, const Difference*);
     typedef void(KompareSplitter::*void_KompareSplitter_argDiffBool)(const Difference*, bool);
     typedef void(KomparePart::*void_KomparePart_argModelDiff)(const DiffModel*, const Difference*);
     typedef void(KomparePart::*void_KomparePart_argDiffBool)(const Difference*, bool);
     connect(m_modelList, static_cast<void_ModelList_argModelDiff>(&ModelList::setSelection),
             this, static_cast<void_KomparePart_argModelDiff>(&KomparePart::setSelection));
     connect(this, static_cast<void_KomparePart_argModelDiff>(&KomparePart::selectionChanged),
             m_modelList, static_cast<void_ModelList_argModelDiff>(&ModelList::slotSelectionChanged));
 
     connect(m_modelList, static_cast<void(ModelList::*)(const Difference*)>(&ModelList::setSelection),
             this, static_cast<void(KomparePart::*)(const Difference*)>(&KomparePart::setSelection));
     connect(this, static_cast<void(KomparePart::*)(const Difference*)>(&KomparePart::selectionChanged),
             m_modelList, static_cast<void(ModelList::*)(const Difference*)>(&ModelList::slotSelectionChanged));
 
     connect(m_modelList, static_cast<void(ModelList::*)(bool)>(&ModelList::applyDifference),
             this, static_cast<void(KomparePart::*)(bool)>(&KomparePart::applyDifference));
     connect(m_modelList, &ModelList::applyAllDifferences,
             this, &KomparePart::applyAllDifferences);
     connect(m_modelList, static_cast<void_ModelList_argDiffBool>(&ModelList::applyDifference),
             this, static_cast<void_KomparePart_argDiffBool>(&KomparePart::applyDifference));
     connect(m_modelList, &ModelList::diffString,
             this, &KomparePart::diffString);
 
     connect(this, &KomparePart::kompareInfo, m_modelList, &ModelList::slotKompareInfo);
 
     // Here we connect the splitter to the modellist
     connect(m_modelList, static_cast<void_ModelList_argModelDiff>(&ModelList::setSelection),
             m_splitter,  static_cast<void_KompareSplitter_argModelDiff>(&KompareSplitter::slotSetSelection));
 //     connect(m_splitter,  SIGNAL(selectionChanged(const KompareDiff2::Difference*,const KompareDiff2::Difference*)),
 //             m_modelList, SLOT(slotSelectionChanged(const KompareDiff2::Difference*,const KompareDiff2::Difference*)));
     connect(m_modelList, static_cast<void(ModelList::*)(const Difference*)>(&ModelList::setSelection),
             m_splitter,  static_cast<void(KompareSplitter::*)(const Difference*)>(&KompareSplitter::slotSetSelection));
     connect(m_splitter,  static_cast<void(KompareSplitter::*)(const Difference*)>(&KompareSplitter::selectionChanged),
             m_modelList, static_cast<void(ModelList::*)(const Difference*)>(&ModelList::slotSelectionChanged));
 
     connect(m_modelList, static_cast<void(ModelList::*)(bool)>(&ModelList::applyDifference),
             m_splitter, static_cast<void(KompareSplitter::*)(bool)>(&KompareSplitter::slotApplyDifference));
     connect(m_modelList, &ModelList::applyAllDifferences,
             m_splitter, &KompareSplitter::slotApplyAllDifferences);
     connect(m_modelList, static_cast<void_ModelList_argDiffBool>(&ModelList::applyDifference),
             m_splitter, static_cast<void_KompareSplitter_argDiffBool>(&KompareSplitter::slotApplyDifference));
     connect(this, &KomparePart::configChanged, m_splitter, &KompareSplitter::configChanged);
 
     setupActions(modus);
 
     // we are read-write by default -> uhm what if we are opened by lets say konq in RO mode ?
     // Then we should not be doing this...
     setReadWrite((modus == ReadWriteModus));
 
     // we are not modified since we haven't done anything yet
     setModified(false);
 }
 
 KomparePart::~KomparePart()
 {
     // This is the only place allowed to call cleanUpTemporaryFiles
     // because before there might still be a use for them (when swapping)
     cleanUpTemporaryFiles();
 }
 
 void KomparePart::setupActions(Modus modus)
 {
     // create our actions
 
     if (modus == ReadWriteModus) {
         m_saveAll = actionCollection()->addAction(QStringLiteral("file_save_all"), this, &KomparePart::saveAll);
         m_saveAll->setIcon(QIcon::fromTheme(QStringLiteral("document-save-all")));
         m_saveAll->setText(i18nc("@action", "Save &All"));
         m_saveDiff = actionCollection()->addAction(QStringLiteral("file_save_diff"), this, &KomparePart::saveDiff);
         m_saveDiff->setText(i18nc("@action", "Save &Diff..."));
         m_swap = actionCollection()->addAction(QStringLiteral("file_swap"), this, &KomparePart::slotSwap);
         m_swap->setText(i18nc("@action", "Swap Source with Destination"));
     } else {
         m_saveAll = nullptr;
         m_saveDiff = nullptr;
         m_swap = nullptr;
     }
     m_diffStats = actionCollection()->addAction(QStringLiteral("file_diffstats"), this, &KomparePart::slotShowDiffstats);
     m_diffStats->setText(i18nc("@action", "Show Statistics"));
     m_diffRefresh = actionCollection()->addAction(QStringLiteral("file_refreshdiff"), this, &KomparePart::slotRefreshDiff);
     m_diffRefresh->setIcon(QIcon::fromTheme(QStringLiteral("view-refresh")));
     m_diffRefresh->setText(i18nc("@action", "Refresh Diff"));
     actionCollection()->setDefaultShortcuts(m_diffRefresh, KStandardShortcut::reload());
 
     m_print        = KStandardAction::print(this, &KomparePart::slotFilePrint, actionCollection());
     m_printPreview = KStandardAction::printPreview(this, &KomparePart::slotFilePrintPreview, actionCollection());
     KStandardAction::preferences(this, &KomparePart::optionsPreferences, actionCollection());
 }
 
 void KomparePart::updateActions()
 {
     if (m_saveAll) m_saveAll->setEnabled(m_modelList->hasUnsavedChanges());
     if (m_saveDiff) m_saveDiff->setEnabled(m_modelList->mode() == KompareDiff2::ComparingFiles || m_modelList->mode() == KompareDiff2::ComparingDirs);
     if (m_swap) m_swap->setEnabled(m_modelList->mode() == KompareDiff2::ComparingFiles || m_modelList->mode() == KompareDiff2::ComparingDirs);
     m_diffRefresh->setEnabled(m_modelList->mode() == KompareDiff2::ComparingFiles || m_modelList->mode() == KompareDiff2::ComparingDirs);
     m_diffStats->setEnabled(m_modelList->modelCount() > 0);
     m_print->setEnabled(m_modelList->modelCount() > 0);          // If modellist has models then we have something to print, it's that simple.
     m_printPreview->setEnabled(m_modelList);
 }
 
 void KomparePart::setEncoding(const QString& encoding)
 {
     qCDebug(KOMPAREPART) << "Encoding: " << encoding;
     m_modelList->setEncoding(encoding);
 }
 
 bool KomparePart::openDiff(const QUrl& url)
 {
     qCDebug(KOMPAREPART) << "Url = " << url.url();
 
     m_info.mode = KompareDiff2::ShowingDiff;
     m_info.source = url;
     bool result = false;
     fetchURL(url, true);
 
     Q_EMIT kompareInfo(&m_info);
 
     if (!m_info.localSource.isEmpty())
     {
         qCDebug(KOMPAREPART) << "Download succeeded ";
         result = m_modelList->openDiff(m_info.localSource);
         updateActions();
         updateCaption();
         updateStatus();
     }
     else
     {
         qCDebug(KOMPAREPART) << "Download failed !";
     }
 
     return result;
 }
 
 bool KomparePart::openDiff(const QString& diffOutput)
 {
     bool value = false;
 
     m_info.mode = KompareDiff2::ShowingDiff;
 
     Q_EMIT kompareInfo(&m_info);
 
     if (m_modelList->parseAndOpenDiff(diffOutput) == 0)
     {
         value = true;
         updateActions();
         updateCaption();
         updateStatus();
     }
 
     return value;
 }
 
 bool KomparePart::openDiff3(const QUrl& diff3Url)
 {
     // FIXME: Implement this !!!
     qCDebug(KOMPAREPART) << "Not implemented yet. Filename is: " << diff3Url;
     return false;
 }
 
 bool KomparePart::openDiff3(const QString& diff3Output)
 {
     // FIXME: Implement this !!!
     qCDebug(KOMPAREPART) << "Not implemented yet. diff3 output is: ";
     qCDebug(KOMPAREPART) << diff3Output;
     return false;
 }
 
 bool KomparePart::fetchURL(const QUrl& url, bool addToSource)
 {
     // Default value if there is an error is "", we rely on it!
     QString tempFileName;
     // Only in case of error do we set result to false, don't forget!!
     bool result = true;
     QTemporaryDir* tmpDir = nullptr;
 
     if (!url.isLocalFile())
     {
         KIO::StatJob* statJob = KIO::stat(url);
         KJobWidgets::setWindow(statJob, widget());
         if (statJob->exec())
         {
             KIO::UDSEntry node;
             node = statJob->statResult();
             if (!node.isDir())
             {
                 tmpDir = new QTemporaryDir(QDir::tempPath() + QLatin1String("/kompare"));
                 tmpDir->setAutoRemove(true);
                 tempFileName = tmpDir->path() + QLatin1Char('/') + url.fileName();
                 KIO::FileCopyJob* copyJob = KIO::file_copy(url, QUrl::fromLocalFile(tempFileName));
                 KJobWidgets::setWindow(copyJob, widget());
                 if (! copyJob->exec())
                 {
                     qDebug() << "download error " << copyJob->errorString();
                     slotShowError(i18n("<qt>The URL <b>%1</b> cannot be downloaded.</qt>", url.toDisplayString()));
                     tempFileName.clear(); // Not sure if download has already touched this tempFileName when there is an error
                     result = false;
                 }
             }
             else
             {
                 tmpDir = new QTemporaryDir(QDir::tempPath() + QLatin1String("/kompare"));
                 tmpDir->setAutoRemove(true);   // Yes this is the default but just to make sure
                 KIO::CopyJob* copyJob = KIO::copy(url, QUrl::fromLocalFile(tmpDir->path()));
                 KJobWidgets::setWindow(copyJob, widget());
                 if (! copyJob->exec())
                 {
                     slotShowError(i18n("<qt>The URL <b>%1</b> cannot be downloaded.</qt>", url.toDisplayString()));
                     delete tmpDir;
                     tmpDir = nullptr;
                     result = false;
                 }
                 else
                 {
                     tempFileName = tmpDir->path();
                     qCDebug(KOMPAREPART) << "tempFileName = " << tempFileName;
                     // If a directory is copied into QTemporaryDir then the directory in
                     // here is what I need to add to tempFileName
                     QDir dir(tempFileName);
                     QStringList entries = dir.entryList(QDir::Dirs | QDir::NoDotAndDotDot);
                     if (entries.size() == 1)   // More than 1 entry in here means big problems!!!
                     {
                         if (!tempFileName.endsWith(QLatin1Char('/')))
                             tempFileName += QLatin1Char('/');
                         tempFileName += entries.at(0);
                         tempFileName += QLatin1Char('/');
                     }
                     else
                     {
                         qCDebug(KOMPAREPART) << "Yikes, nothing downloaded?";
                         delete tmpDir;
                         tmpDir = nullptr;
                         tempFileName.clear();
                         result = false;
                     }
                 }
             }
         }
     }
     else
     {
         // is Local already, check if exists
         if (QFile::exists(url.toLocalFile())) {
             tempFileName = url.toLocalFile();
         } else {
             slotShowError(i18n("<qt>The URL <b>%1</b> does not exist on your system.</qt>", url.toDisplayString()));
             result = false;
         }
     }
 
     if (addToSource)
     {
         m_info.localSource = tempFileName;
         m_info.sourceQTempDir = tmpDir;
     }
     else
     {
         m_info.localDestination = tempFileName;
         m_info.destinationQTempDir = tmpDir;
     }
 
     return result;
 }
 
 void KomparePart::cleanUpTemporaryFiles()
 {
     qCDebug(KOMPAREPART) << "Cleaning temporary files.";
     if (!m_info.localSource.isEmpty())
     {
         if (m_info.sourceQTempDir)
         {
             delete m_info.sourceQTempDir;
             m_info.sourceQTempDir = nullptr;
         }
         m_info.localSource.clear();
     }
     if (!m_info.localDestination.isEmpty())
     {
         if (!m_info.destinationQTempDir)
         {
             delete m_info.destinationQTempDir;
             m_info.destinationQTempDir = nullptr;
         }
         m_info.localDestination.clear();
     }
 }
 
 void KomparePart::compare(const QUrl& source, const QUrl& destination)
 {
     // FIXME: This is silly, i can use NetAccess::stat to figure out what it is and not
     // wait until i am in the modellist to determine the mode we're supposed to be in.
     // That should make the code more readable
     // I should store the QTemporaryDir(s)/File(s) in the Info struct as well and delete it at the right time
     m_info.source = source;
     m_info.destination = destination;
 
     // FIXME: (Not urgent) But turn this into an enum, for now i cant find a nice name for the enum that has Source and Destination as values
     // For now we do not do error checking, user has already been notified and if the localString is empty then we do not diff
     fetchURL(source, true);
     fetchURL(destination, false);
 
     Q_EMIT kompareInfo(&m_info);
 
     compareAndUpdateAll();
 }
 
 void KomparePart::compareFileString(const QUrl& sourceFile, const QString& destination)
 {
     //Set the modeto specify that the source is a file, and the destination is a string
     m_info.mode = KompareDiff2::ComparingFileString;
 
     m_info.source = sourceFile;
     m_info.localDestination = destination;
 
     fetchURL(sourceFile, true);
 
     Q_EMIT kompareInfo(&m_info);
 
     compareAndUpdateAll();
 }
 
 void KomparePart::compareStringFile(const QString& source, const QUrl& destinationFile)
 {
     //Set the modeto specify that the source is a file, and the destination is a string
     m_info.mode = KompareDiff2::ComparingStringFile;
 
     m_info.localSource = source;
     m_info.destination = destinationFile;
 
     fetchURL(destinationFile, false);
 
     Q_EMIT kompareInfo(&m_info);
 
     compareAndUpdateAll();
 }
 
 void KomparePart::compareFiles(const QUrl& sourceFile, const QUrl& destinationFile)
 {
     m_info.mode = KompareDiff2::ComparingFiles;
 
     m_info.source = sourceFile;
     m_info.destination = destinationFile;
 
     // FIXME: (Not urgent) But turn this into an enum, for now i cant find a nice name for the enum that has Source and Destination as values
     // For now we do not do error checking, user has already been notified and if the localString is empty then we do not diff
     fetchURL(sourceFile, true);
     fetchURL(destinationFile, false);
 
     Q_EMIT kompareInfo(&m_info);
 
     compareAndUpdateAll();
 }
 
 void KomparePart::compareDirs(const QUrl& sourceDirectory, const QUrl& destinationDirectory)
 {
     m_info.mode = KompareDiff2::ComparingDirs;
 
     m_info.source = sourceDirectory;
     m_info.destination = destinationDirectory;
 
     fetchURL(sourceDirectory, true);
     fetchURL(destinationDirectory, false);
 
     Q_EMIT kompareInfo(&m_info);
 
     compareAndUpdateAll();
 }
 
 void KomparePart::compare3Files(const QUrl& /*originalFile*/, const QUrl& /*changedFile1*/, const QUrl& /*changedFile2*/)
 {
     // FIXME: actually implement this some day :)
     updateActions();
     updateCaption();
     updateStatus();
 }
 
 void KomparePart::openFileAndDiff(const QUrl& file, const QUrl& diffFile)
 {
     m_info.source = file;
     m_info.destination = diffFile;
 
     fetchURL(file, true);
     fetchURL(diffFile, false);
     m_info.mode = KompareDiff2::BlendingFile;
 
     Q_EMIT kompareInfo(&m_info);
 
     compareAndUpdateAll();
 }
 
 void KomparePart::openDirAndDiff(const QUrl& dir,  const QUrl& diffFile)
 {
     m_info.source = dir;
     m_info.destination = diffFile;
 
     fetchURL(dir, true);
     fetchURL(diffFile, false);
     m_info.mode = KompareDiff2::BlendingDir;
 
     Q_EMIT kompareInfo(&m_info);
 
     if (!m_info.localSource.isEmpty() && !m_info.localDestination.isEmpty())
     {
         m_modelList->openDirAndDiff();
         //Must this be in here? couldn't we use compareAndUpdateAll as well?
         updateActions();
         updateCaption();
         updateStatus();
     }
 }
 
 bool KomparePart::openFile()
 {
     // This is called from openURL
     // This is a little inefficient but i will do it anyway
     openDiff(url());
     return true;
 }
 
 bool KomparePart::saveAll()
 {
     bool result = m_modelList->saveAll();
     updateActions();
     updateCaption();
     updateStatus();
     return result;
 }
 
 void KomparePart::saveDiff()
 {
     QDialog dlg(widget());
     dlg.setObjectName(QStringLiteral("save_options"));
     dlg.setModal(true);
     dlg.setWindowTitle(i18nc("@title:window", "Diff Options"));
     QDialogButtonBox* buttons = new QDialogButtonBox(QDialogButtonBox::Save | QDialogButtonBox::Cancel, &dlg);
     connect(buttons, &QDialogButtonBox::accepted, &dlg, &QDialog::accept);
     connect(buttons, &QDialogButtonBox::rejected, &dlg, &QDialog::reject);
     KompareSaveOptionsWidget* w = new KompareSaveOptionsWidget(
         m_info.localSource,
         m_info.localDestination,
         m_diffSettings, &dlg);
     QVBoxLayout* layout = new QVBoxLayout(&dlg);
     layout->addWidget(w);
     layout->addWidget(buttons);
     dlg.setLayout(layout);
 
     if (dlg.exec()) {
         w->saveOptions();
         KSharedConfig::Ptr config = KSharedConfig::openConfig();
         saveProperties(config.data());
         config->sync();
 
         QUrl url = QFileDialog::getSaveFileUrl(widget(), i18nc("@title:window", "Save .diff"),
                                                m_info.destination,
                                                i18n("Patch Files (*.diff *.dif *.patch)"));
         qCDebug(KOMPAREPART) << "URL = " << url.toDisplayString();
         qCDebug(KOMPAREPART) << "Directory = " << w->directory();
         qCDebug(KOMPAREPART) << "DiffSettings = " << m_diffSettings;
 
         m_modelList->saveDiff(url.url(), w->directory(), m_diffSettings);
     }
 }
 
 void KomparePart::slotFilePrint()
 {
     QPrinter printer;
     printer.setPageOrientation(QPageLayout::Landscape);
     QPrintDialog* dlg = new QPrintDialog(&printer, nullptr);
 
     if (dlg->exec() == QDialog::Accepted)
     {
         // do some printing in qprinter
         slotPaintRequested(&printer);
     }
 
     delete dlg;
 }
 
 void KomparePart::slotFilePrintPreview()
 {
     QPrinter printer;
     printer.setPageOrientation(QPageLayout::Landscape);
     QPrintPreviewDialog dlg(&printer);
 
     connect(&dlg, &QPrintPreviewDialog::paintRequested, this, &KomparePart::slotPaintRequested);
 
     dlg.exec();
 }
 
 void KomparePart::slotPaintRequested(QPrinter* printer)
 {
     qCDebug(KOMPAREPART) << "Now paint something...";
     QPainter p;
     p.begin(printer);
 
     QSize widgetWidth = m_view->size();
     qCDebug(KOMPAREPART) << "printer.width()     = " << printer->width();
     qCDebug(KOMPAREPART) << "widgetWidth.width() = " << widgetWidth.width();
     qreal factor = ((qreal)printer->width()) / ((qreal)widgetWidth.width());
 
     qCDebug(KOMPAREPART) << "factor              = " << factor;
 
     p.scale(factor, factor);
     m_view->render(&p);
 
     p.end();
     qCDebug(KOMPAREPART) << "Done painting something...";
 }
 
 void KomparePart::slotSetStatus(enum KompareDiff2::Status status)
 {
     updateActions();
 
     switch (status) {
     case KompareDiff2::RunningDiff:
         Q_EMIT setStatusBarText(i18nc("@info:status", "Running diff..."));
         break;
     case KompareDiff2::Parsing:
         Q_EMIT setStatusBarText(i18nc("@info:status", "Parsing diff output..."));
         break;
     case KompareDiff2::FinishedParsing:
         updateStatus();
         break;
     case KompareDiff2::FinishedWritingDiff:
         updateStatus();
         Q_EMIT diffURLChanged();
         break;
     default:
         break;
     }
 }
 
 void KomparePart::onContextMenuRequested(const QPoint& pos)
 {
     QMenu* popup = static_cast<QMenu*>(factory()->container(QStringLiteral("mainPopUp"), this));
     if (popup)
         popup->exec(m_view->mapToGlobal(pos));
 }
 
 void KomparePart::updateCaption()
 {
     QString source = m_info.source.toDisplayString(QUrl::PreferLocalFile);
     QString destination = m_info.destination.toDisplayString(QUrl::PreferLocalFile);
 
     QString text;
 
     switch (m_info.mode)
     {
     case KompareDiff2::ComparingFiles :
     case KompareDiff2::ComparingDirs :
     case KompareDiff2::BlendingFile :
     case KompareDiff2::BlendingDir :
         text = source + QLatin1String(" -- ") + destination; // no need to translate this " -- "
         break;
     case KompareDiff2::ShowingDiff :
         text = source;
         break;
     default:
         break;
     }
 
     Q_EMIT setWindowCaption(text);
 }
 
 void KomparePart::updateStatus()
 {
     QString source = m_info.source.toDisplayString(QUrl::PreferLocalFile);
     QString destination = m_info.destination.toDisplayString(QUrl::PreferLocalFile);
 
     QString text;
 
     switch (m_info.mode)
     {
     case KompareDiff2::ComparingFiles :
         text = i18nc("@info:status", "Comparing file %1 with file %2" ,
                     source,
                     destination);
         break;
     case KompareDiff2::ComparingDirs :
         text = i18nc("@info:status", "Comparing files in %1 with files in %2" ,
                     source,
                     destination);
         break;
     case KompareDiff2::ShowingDiff :
         text = i18nc("@info:status", "Viewing diff output from %1", source);
         break;
     case KompareDiff2::BlendingFile :
         text = i18nc("@info:status", "Blending diff output from %1 into file %2" ,
                     source,
                     destination);
         break;
     case KompareDiff2::BlendingDir :
         text = i18nc("@info:status", "Blending diff output from %1 into folder %2" ,
                     m_info.source.toDisplayString(),
                     m_info.destination.toDisplayString());
         break;
     default:
         break;
     }
 
     Q_EMIT setStatusBarText(text);
 }
 
 void KomparePart::compareAndUpdateAll()
 {
     if (!m_info.localSource.isEmpty() && !m_info.localDestination.isEmpty())
     {
         switch (m_info.mode)
         {
         default:
         case KompareDiff2::UnknownMode:
             m_modelList->compare();
             break;
 
         case KompareDiff2::ComparingStringFile:
         case KompareDiff2::ComparingFileString:
         case KompareDiff2::ComparingFiles:
         case KompareDiff2::ComparingDirs:
             m_modelList->compare(m_info.mode);
             break;
 
         case KompareDiff2::BlendingFile:
             m_modelList->openFileAndDiff();
             break;
         }
         updateCaption();
         updateStatus();
     }
     updateActions();
 }
 
 void KomparePart::slotShowError(const QString& error)
 {
     KMessageBox::error(widget(), error);
 }
 
 void KomparePart::slotSwap()
 {
     if (m_modelList->hasUnsavedChanges())
     {
         int query = KMessageBox::warningTwoActionsCancel
                     (
                         widget(),
                         i18n("You have made changes to the destination file(s).\n"
                              "Would you like to save them?"),
                         i18nc("@title:window", "Save Changes?"),
                         KStandardGuiItem::save(),
                         KStandardGuiItem::discard()
                     );
 
         if (query == KMessageBox::PrimaryAction)
             m_modelList->saveAll();
 
         if (query == KMessageBox::Cancel)
             return; // Abort prematurely so no swapping
     }
 
     // Swap the info in the KompareDiff2::Info struct
     m_info.swapSourceWithDestination();
 
     // Update window caption and statusbar text
     updateCaption();
     updateStatus();
 
     m_modelList->swap();
 }
 
 void KomparePart::slotRefreshDiff()
 {
     if (m_modelList->hasUnsavedChanges())
     {
         int query = KMessageBox::warningTwoActionsCancel
                     (
                         widget(),
                         i18n("You have made changes to the destination file(s).\n"
                              "Would you like to save them?"),
                         i18nc("@title:window", "Save Changes?"),
                         KStandardGuiItem::save(),
                         KStandardGuiItem::discard(),
                         KStandardGuiItem::cancel()
                     );
 
         if (query == KMessageBox::Cancel)
             return; // Abort prematurely so no refreshing
 
         if (query == KMessageBox::PrimaryAction)
             m_modelList->saveAll();
     }
 
     // For this to work properly you have to refetch the files from their (remote) locations
     cleanUpTemporaryFiles();
     fetchURL(m_info.source, true);
     fetchURL(m_info.destination, false);
     m_modelList->refresh();
 }
 
 void KomparePart::slotShowDiffstats()
 {
     // Fetch all the args needed for komparestatsmessagebox
     // oldfile, newfile, diffformat, noofhunks, noofdiffs
 
     QString oldFile;
     QString newFile;
     QString diffFormat;
     int filesInDiff;
     int noOfHunks;
     int noOfDiffs;
 
     oldFile = m_modelList->selectedModel() ? m_modelList->selectedModel()->sourceFile()  : QString();
     newFile = m_modelList->selectedModel() ? m_modelList->selectedModel()->destinationFile() : QString();
 
     if (m_modelList->selectedModel())
     {
         switch (m_info.format) {
         case KompareDiff2::Unified :
             diffFormat = i18nc("@item diff format", "Unified");
             break;
         case KompareDiff2::Context :
             diffFormat = i18nc("@item diff format", "Context");
             break;
         case KompareDiff2::RCS :
             diffFormat = i18nc("@item diff format", "RCS");
             break;
         case KompareDiff2::Ed :
             diffFormat = i18nc("@item diff format", "Ed");
             break;
         case KompareDiff2::Normal :
             diffFormat = i18nc("@item diff format", "Normal");
             break;
         case KompareDiff2::UnknownFormat :
         default:
             diffFormat = i18nc("@item diff format", "Unknown");
             break;
         }
     }
     else
     {
         diffFormat.clear();
     }
 
     filesInDiff = m_modelList->modelCount();
 
     noOfHunks = m_modelList->selectedModel() ? m_modelList->selectedModel()->hunkCount() : 0;
     noOfDiffs = m_modelList->selectedModel() ? m_modelList->selectedModel()->differenceCount() : 0;
 
     if (m_modelList->modelCount() == 0) {   // no diff loaded yet
         KMessageBox::information(nullptr, i18n(
             "No diff file, or no 2 files have been diffed. "
             "Therefore no stats are available."),
             i18nc("@title:window", "Diff Statistics"), QString(), KMessageBox::Options());
     }
     else if (m_modelList->modelCount() == 1) {   // 1 file in diff, or 2 files compared
         KMessageBox::information(nullptr, i18n(
             "Statistics:\n"
             "\n"
             "Old file: %1\n"
             "New file: %2\n"
             "\n"
             "Format: %3\n"
             "Number of hunks: %4\n"
             "Number of differences: %5",
             oldFile, newFile, diffFormat,
             noOfHunks, noOfDiffs),
             i18nc("@title:window", "Diff Statistics"), QString(), KMessageBox::Options());
     } else { // more than 1 file in diff, or 2 directories compared
         KMessageBox::information(nullptr, ki18n(
             "Statistics:\n"
             "\n"
             "Number of files in diff file: %1\n"
             "Format: %2\n"
             "\n"
             "Current old file: %3\n"
             "Current new file: %4\n"
             "\n"
             "Number of hunks: %5\n"
             "Number of differences: %6")
             .subs(filesInDiff).subs(diffFormat).subs(oldFile)
             .subs(newFile).subs(noOfHunks).subs(noOfDiffs)
             .toString(),
             i18nc("@title:window", "Diff Statistics"), QString(), KMessageBox::Options());
     }
 }
 
 bool KomparePart::queryClose()
 {
     if (!m_modelList->hasUnsavedChanges()) return true;
 
     int query = KMessageBox::warningTwoActionsCancel
                 (
                     widget(),
                     i18n("You have made changes to the destination file(s).\n"
                          "Would you like to save them?"),
                     i18nc("@title:window", "Save Changes?"),
                     KStandardGuiItem::save(),
                     KStandardGuiItem::discard(),
                     KStandardGuiItem::cancel()
                 );
 
     if (query == KMessageBox::Cancel)
         return false;
 
     if (query == KMessageBox::PrimaryAction)
         return m_modelList->saveAll();
 
     return true;
 }
 
 void KomparePart::setReadWrite(bool readWrite)
 {
     m_modelList->setReadWrite(readWrite);
     KParts::ReadWritePart::setReadWrite(readWrite);
 }
 
 int KomparePart::readProperties(KConfig* config)
 {
     m_viewSettings->loadSettings(config);
     m_diffSettings->loadSettings(config);
     Q_EMIT configChanged();
     return 0;
 }
 
 int KomparePart::saveProperties(KConfig* config)
 {
     m_viewSettings->saveSettings(config);
     m_diffSettings->saveSettings(config);
     return 0;
 }
 
 void KomparePart::optionsPreferences()
 {
     // show preferences
     KomparePrefDlg pref(m_viewSettings, m_diffSettings);
 
     connect(&pref, &KomparePrefDlg::configChanged, this, &KomparePart::configChanged);
 
     if (pref.exec())
         Q_EMIT configChanged();
 }
 
 #include "moc_kompare_part.cpp"