diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index b2205e7..b6a7b38 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -1,44 +1,44 @@
 # Free-bsd and windows are currently unsupport at invent.kde.org. Disabling so build will pass
 include:
   - https://invent.kde.org/sysadmin/ci-tooling/raw/master/invent/ci-before.yml
   - https://invent.kde.org/sysadmin/ci-tooling/raw/master/invent/ci-extragear-linux.yml
 #  - https://invent.kde.org/sysadmin/ci-tooling/raw/master/invent/ci-extragear-freebsd.yml
 #  - https://invent.kde.org/sysadmin/ci-tooling/raw/master/invent/ci-extragear-windows.yml
 
 #reenable test stage for our custom build was disabled by ci-tooling config
 stages:
   - build
   - test
 
 build_ubuntu_18_04:
   stage: build
   image: reporter123/cmake:bionic
 
   before_script:
      - apt-get update
-     - apt-get install -y libqt5test5 gettext qtbase5-dev extra-cmake-modules libkf5i18n-dev libkf5coreaddons-dev libkf5iconthemes-dev libkf5parts-dev libkf5doctools-dev libkf5crash-dev
+     - apt-get install -y libqt5test5 gettext qtbase5-dev extra-cmake-modules libkf5i18n-dev libkf5coreaddons-dev libkf5iconthemes-dev libkf5parts-dev libkf5doctools-dev libkf5crash-dev libboost-signals-dev
   script:
     - cmake -DBUILD_TESTING=YES .
     - make
   artifacts:
     untracked: true
   retry:
-    max: 2
+    max: 1
     when:
       - runner_system_failure
       - stuck_or_timeout_failure
 
 ubuntu_18_04_test:
     stage: test
     needs: ["build_ubuntu_18_04"]
     image: reporter123/cmake:bionic
     before_script:
       - apt-get update
       - apt-get install -y libqt5test5
     script:
       - make ARGS="-V -E appstreamtest" test #exclude appstreamtest this does not run properly in my image
     retry:
       max: 2
       when:
        - runner_system_failure
        - stuck_or_timeout_failure
diff --git a/.gitlab-nonkde.yml b/.gitlab-nonkde.yml
index 8abfe53..1b82f82 100644
--- a/.gitlab-nonkde.yml
+++ b/.gitlab-nonkde.yml
@@ -1,36 +1,36 @@
 stages:
   - build
   - test
 
 build_ubuntu_18_04:
   stage: build
   image: reporter123/cmake:bionic
 
   before_script:
      - apt-get update
-     - apt-get install -y libqt5test5 gettext qtbase5-dev extra-cmake-modules libkf5i18n-dev libkf5coreaddons-dev libkf5iconthemes-dev libkf5parts-dev libkf5doctools-dev libkf5crash-dev
+     - apt-get install -y libqt5test5 gettext qtbase5-dev extra-cmake-modules libkf5i18n-dev libkf5coreaddons-dev libkf5iconthemes-dev libkf5parts-dev libkf5doctools-dev libkf5crash-dev libboost-signals-dev
   script:
     - cmake -DBUILD_TESTING=YES .
     - make
   artifacts:
     untracked: true
   retry:
     max: 2
     when:
       - runner_system_failure
       - stuck_or_timeout_failure
 
 ubuntu_18_04_test:
     stage: test
     needs: ["build_ubuntu_18_04"]
     image: reporter123/cmake:bionic
     before_script:
       - apt-get update
       - apt-get install -y libqt5test5
     script:
       - make ARGS="-V -E appstreamtest" test #exclude appstreamtest this does not run properly in my image
     retry:
       max: 2
       when:
        - runner_system_failure
        - stuck_or_timeout_failure
diff --git a/CMakeLists.txt b/CMakeLists.txt
index a5472d8..3967fc8 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,127 +1,129 @@
 #cmake < 3.1 has no sane way of checking C++11 features and needed flags
 #need at least 3.8 for cxx_std_11.
 cmake_minimum_required(VERSION 3.8 FATAL_ERROR)
 
 project(kdiff3)
 
 set(CMAKE_CXX_EXTENSIONS ON ) #disable trigraphs in clang/gcc -- officially removed in c++17
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 set(ECM_MIN_VERSION "5.10.0")
 set(QT_MIN_VERSION "5.8.0")
 #KF5 5.27 fixes a crash bug triggered on exit.
 set(KF5_MIN_VERSION "5.27.0")
 
 find_package(ECM ${ECM_MIN_VERSION} CONFIG REQUIRED)
 set(
     CMAKE_MODULE_PATH
     ${CMAKE_MODULE_PATH}
     ${ECM_MODULE_PATH}
 )
 
 include(KDEInstallDirs)
 include(KDECompilerSettings NO_POLICY_SCOPE)
 include(KDECMakeSettings NO_POLICY_SCOPE)
 include(FeatureSummary)
 
 include(ECMInstallIcons)
 include(ECMAddAppIcon)
 include(ECMSetupVersion)
 include(ECMAddTests)
 
 ecm_setup_version(1.8.70 VARIABLE_PREFIX KDIFF3 VERSION_HEADER ${CMAKE_BINARY_DIR}/src/version.h)
 
+find_package(Boost 1.61 REQUIRED COMPONENTS signals)
+
 find_package(
     Qt5 ${QT_MIN_VERSION}
     CONFIG
     REQUIRED
     COMPONENTS
     Core
     Gui
     Widgets
     PrintSupport
 )
 
 find_package(
     KF5 ${KF5_MIN_VERSION}
     REQUIRED
     COMPONENTS
     I18n
     CoreAddons
     Crash
     IconThemes
     OPTIONAL_COMPONENTS
     DocTools
 )
 
 set_package_properties(KF5DocTools PROPERTIES PURPOSE "Allows generating and installing docs.")
 
 option(ENABLE_AUTO "Enable kdiff3's '--auto' flag" ON)
 option(ENABLE_CLANG_TIDY "Run clang-tidy if available and cmake version >=3.6" OFF)
 
-set(KDiff3_LIBRARIES ${Qt5PrintSupport_LIBRARIES} KF5::I18n KF5::CoreAddons KF5::IconThemes )
+set(KDiff3_LIBRARIES ${Qt5PrintSupport_LIBRARIES} KF5::I18n KF5::CoreAddons KF5::IconThemes Boost::signals )
 
 if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
     #Adjust clang specific  warnings
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wshadow")
     set(CLANG_WARNING_FLAGS "-Wno-trigraphs -Wno-invalid-pp-token -Wno-comment -Wshorten-64-to-32 -Wstring-conversion -Wc++11-narrowing -fstack-protector-all")
     set(CMAKE_CXX_FLAGS  "${CMAKE_CXX_FLAGS} ${CLANG_WARNING_FLAGS}")
 elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
     add_definitions(-DNOMINMAX) #Suppress MSVCs min/max macros
 elseif(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
     if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 8.0)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fstack-check")
     endif()
     if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 7.0)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wno-trigraphs -Wduplicated-cond -Wduplicated-branches -Wshadow")
     endif()
 endif()
 
 #new in cmake 3.6+ integrate clang-tidy
 if(ENABLE_CLANG_TIDY AND NOT ${CMAKE_VERSION} VERSION_LESS "3.6.0")
     find_program(CLANG_TIDY_EXE NAMES "clang-tidy" "clang-tidy-7" "clang-tidy-6.0" "clang-tidy-6" DOC "Path to clang-tidy executable")
     if(NOT CLANG_TIDY_EXE)
         message(STATUS "clang-tidy not found disabling integration.")
     else()
         message(STATUS "Found clang-tidy: ${CLANG_TIDY_EXE}")
         set(CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_EXE}" "-header-filter=.*")
     endif()
 endif()
 
 set(CMAKE_C_FLAGS  "${CMAKE_C_FLAGS} ${CMAKE_CXX_FLAGS}")
 
 set(
     needed_features
     cxx_std_11
 )
 
 if(ENABLE_AUTO)
     add_definitions(
         -DENABLE_AUTO
     )
 endif()
 
 add_definitions(
     -DQT_DEPRECATED_WARNINGS #Get warnings from QT about deprecated functions.
     -DQT_NO_URL_CAST_FROM_STRING # casting from string to url does not always behave as you might think
     -DQT_RESTRICTED_CAST_FROM_ASCII #casting from char*/QByteArray to QString can produce unexpected results for non-latin characters.
     -DQT_NO_KEYWORDS
     -DQT_NO_CAST_TO_ASCII
     -DQT_DISABLE_DEPRECATED_BEFORE=0x050800#disable depriated api for Qt<5.8.
     #KF5 5.64+ flags
     #Don't warn for API depreciated after 5.26.0 (below as hex.hex.hex number)
     -DKF_DEPRECATED_WARNINGS_SINCE=0x051A00
 )
 
 add_subdirectory(src)
 if(KF5DocTools_FOUND)
     add_subdirectory(doc)
     kdoctools_install(po)
 else()
     message(WARNING "DocTools not found.")
 endif()
 
 ki18n_install(po)
 
 add_subdirectory(kdiff3fileitemactionplugin)
 
 feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)
diff --git a/src/combiners.h b/src/combiners.h
new file mode 100644
index 0000000..b27d084
--- /dev/null
+++ b/src/combiners.h
@@ -0,0 +1,40 @@
+/*
+ * KDiff3 - Text Diff And Merge Tool
+ *
+ * SPDX-FileCopyrightText: 2018-2020 Michael Reeves reeves.87@gmail.com
+ * SPDX-License-Identifier: GPL-2.0-or-later
+*/
+
+#ifndef COMBINERS_H
+#define COMBINERS_H
+
+#include <boost/signals2.hpp>
+
+#include <QtGlobal>
+
+struct and
+{
+    typedef bool result_type;
+    template <typename InputIterator> bool operator()(InputIterator first, InputIterator last) const
+    {
+        // If there are no slots to call, just return true
+        if(first == last) return true;
+
+        bool ret = *first++;
+        //return first non-true as if && were used
+        while(ret && first != last)
+        {
+            ret = *first;
+            ++first;
+        }
+
+        return ret;
+    }
+};
+
+#ifdef BOOST_NO_EXCEPTIONS
+//Because boost doesn't define this
+inline void boost::throw_exception(std::exception const& e) { Q_UNUSED(e); std::terminate();}
+#endif
+
+#endif // !COMBINERS_H
diff --git a/src/difftextwindow.cpp b/src/difftextwindow.cpp
index 167f20c..2750e4c 100644
--- a/src/difftextwindow.cpp
+++ b/src/difftextwindow.cpp
@@ -1,2113 +1,2109 @@
 /*
  * KDiff3 - Text Diff And Merge Tool
  *
  * SPDX-FileCopyrightText: 2002-2011 Joachim Eibl, joachim.eibl at gmx.de
  * SPDX-FileCopyrightText: 2018-2020 Michael Reeves reeves.87@gmail.com
  * SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "difftextwindow.h"
 
 #include "FileNameLineEdit.h"
 #include "RLPainter.h"
 #include "SourceData.h" // for SourceData
 #include "Utils.h"      // for Utils
 #include "common.h"     // for getAtomic, max3, min3
 #include "kdiff3.h"
 #include "merger.h"
 #include "options.h"
 #include "progress.h"
 #include "selection.h"
 
 #include <algorithm>
 #include <cmath>
 #include <cstdlib>
 
 #include <KLocalizedString>
 #include <KMessageBox>
 
 #include <QDir>
 #include <QDragEnterEvent>
 #include <QFileDialog>
 #include <QLabel>
 #include <QLayout>
 #include <QLineEdit>
 #include <QMenu>
 #include <QMimeData>
 #include <QPushButton>
 #include <QRunnable>
 #include <QScrollBar>
 #include <QStatusBar>
 #include <QTextCodec>
 #include <QTextLayout>
 #include <QThreadPool>
 #include <QToolTip>
 #include <QUrl>
 #include <QtMath>
 
 QScrollBar* DiffTextWindow::mVScrollBar = nullptr;
 QList<RecalcWordWrapRunnable*> DiffTextWindow::s_runnables; //Used in startRunables and recalWordWrap
 
 class RecalcWordWrapRunnable : public QRunnable
 {
   private:
     static QAtomicInt s_runnableCount;
     DiffTextWindow* m_pDTW;
     int m_visibleTextWidth;
     int m_cacheIdx;
 
   public:
     static QAtomicInt s_maxNofRunnables;
     RecalcWordWrapRunnable(DiffTextWindow* p, int visibleTextWidth, int cacheIdx)
         : m_pDTW(p), m_visibleTextWidth(visibleTextWidth), m_cacheIdx(cacheIdx)
     {
         setAutoDelete(true);
         s_runnableCount.fetchAndAddOrdered(1);
     }
     void run() override
     {
         m_pDTW->recalcWordWrapHelper(0, m_visibleTextWidth, m_cacheIdx);
         int newValue = s_runnableCount.fetchAndAddOrdered(-1) - 1;
         g_pProgressDialog->setCurrent(s_maxNofRunnables - getAtomic(s_runnableCount));
         if(newValue == 0)
         {
             Q_EMIT m_pDTW->finishRecalcWordWrap(m_visibleTextWidth);
         }
     }
 };
 
 QAtomicInt RecalcWordWrapRunnable::s_runnableCount = 0;
 QAtomicInt RecalcWordWrapRunnable::s_maxNofRunnables = 0;
 
 class WrapLineCacheData
 {
   public:
     WrapLineCacheData() {}
     WrapLineCacheData(int d3LineIdx, int textStart, int textLength)
         : m_d3LineIdx(d3LineIdx), m_textStart(textStart), m_textLength(textLength) {}
     qint32 d3LineIdx() const { return m_d3LineIdx; }
     qint32 textStart() const { return m_textStart; }
     qint32 textLength() const { return m_textLength; }
 
   private:
     qint32 m_d3LineIdx = 0;
     qint32 m_textStart = 0;
     qint32 m_textLength = 0;
 };
 
 class DiffTextWindowData
 {
   public:
     explicit DiffTextWindowData(DiffTextWindow* p)
     {
         m_pDiffTextWindow = p;
 #if defined(Q_OS_WIN)
         m_eLineEndStyle = eLineEndStyleDos;
 #else
         m_eLineEndStyle = eLineEndStyleUnix;
 #endif
     }
 
     QString getString(int d3lIdx);
     QString getLineString(int line);
 
     void writeLine(
         RLPainter& p, const LineData* pld,
         const DiffList* pLineDiff1, const DiffList* pLineDiff2, const LineRef& line,
         const ChangeFlags whatChanged, const ChangeFlags whatChanged2, const LineRef& srcLineIdx,
         int wrapLineOffset, int wrapLineLength, bool bWrapLine, const QRect& invalidRect);
 
     void draw(RLPainter& p, const QRect& invalidRect, int beginLine, int endLine);
 
     void myUpdate(int afterMilliSecs);
 
     int leftInfoWidth() const { return 4 + m_lineNumberWidth; } // Nr of information columns on left side
     int convertLineOnScreenToLineInSource(int lineOnScreen, e_CoordType coordType, bool bFirstLine);
 
     void prepareTextLayout(QTextLayout& textLayout, int visibleTextWidth = -1);
 
     bool isThreeWay() const { return KDiff3App::isTripleDiff(); };
     const QString& getFileName() { return m_filename; }
 
     const Diff3LineVector* getDiff3LineVector() { return m_pDiff3LineVector; }
 
     const QSharedPointer<Options>& getOptions() { return m_pOptions; }
 
   private:
     //TODO: Remove friend classes after creating accessors. Please don't add new classes here
     friend DiffTextWindow;
     DiffTextWindow* m_pDiffTextWindow;
     QTextCodec* m_pTextCodec = nullptr;
     e_LineEndStyle m_eLineEndStyle;
 
     const QVector<LineData>* m_pLineData = nullptr;
     int m_size = 0;
     QString m_filename;
     bool m_bWordWrap = false;
     int m_delayedDrawTimer = 0;
 
     const Diff3LineVector* m_pDiff3LineVector = nullptr;
     Diff3WrapLineVector m_diff3WrapLineVector;
     const ManualDiffHelpList* m_pManualDiffHelpList = nullptr;
     QList<QVector<WrapLineCacheData>> m_wrapLineCacheList;
 
     QSharedPointer<Options> m_pOptions;
     QColor m_cThis;
     QColor m_cDiff1;
     QColor m_cDiff2;
     QColor m_cDiffBoth;
 
     int m_fastSelectorLine1 = 0;
     int m_fastSelectorNofLines = 0;
 
     e_SrcSelector m_winIdx = e_SrcSelector::None;
     int m_firstLine = 0;
     int m_oldFirstLine = -1;
     int m_horizScrollOffset = 0;
     int m_lineNumberWidth = 0;
     QAtomicInt m_maxTextWidth = -1;
 
     Selection m_selection;
 
     int m_scrollDeltaX = 0;
     int m_scrollDeltaY = 0;
 
     bool m_bMyUpdate = false;
 
     bool m_bSelectionInProgress = false;
     QPoint m_lastKnownMousePos;
 
     QSharedPointer<SourceData> sourceData;
 };
 
 void DiffTextWindow::setSourceData(const QSharedPointer<SourceData>& inData) { d->sourceData = inData; }
 bool DiffTextWindow::isThreeWay() const { return d->isThreeWay(); };
 const QString& DiffTextWindow::getFileName() const { return d->getFileName(); }
 
 e_SrcSelector DiffTextWindow::getWindowIndex() const { return d->m_winIdx; };
 
 const QString DiffTextWindow::getEncodingDisplayString() const { return d->m_pTextCodec != nullptr ? QLatin1String(d->m_pTextCodec->name()) : QString(); }
 e_LineEndStyle DiffTextWindow::getLineEndStyle() const { return d->m_eLineEndStyle; }
 
 const Diff3LineVector* DiffTextWindow::getDiff3LineVector() const { return d->getDiff3LineVector(); }
 
 qint32 DiffTextWindow::getLineNumberWidth() const { return (int)log10((double)std::max(d->m_size, 1)) + 1; }
 
 DiffTextWindow::DiffTextWindow(
     DiffTextWindowFrame* pParent,
     const QSharedPointer<Options>& pOptions,
     e_SrcSelector winIdx)
     : QWidget(pParent)
 {
     setObjectName(QString("DiffTextWindow%1").arg((int)winIdx));
     setAttribute(Qt::WA_OpaquePaintEvent);
     setUpdatesEnabled(false);
 
     d = new DiffTextWindowData(this);
     setFocusPolicy(Qt::ClickFocus);
     setAcceptDrops(true);
 
     d->m_pOptions = pOptions;
     init(QString(""), nullptr, d->m_eLineEndStyle, nullptr, 0, nullptr, nullptr);
 
     setMinimumSize(QSize(20, 20));
 
     setUpdatesEnabled(true);
     d->m_bWordWrap = false;
     d->m_winIdx = winIdx;
 
     setFont(d->getOptions()->m_font);
 }
 
 DiffTextWindow::~DiffTextWindow()
 {
     delete d;
 }
 
 void DiffTextWindow::init(
     const QString& filename,
     QTextCodec* pTextCodec,
     e_LineEndStyle eLineEndStyle,
     const QVector<LineData>* pLineData,
     int size,
     const Diff3LineVector* pDiff3LineVector,
     const ManualDiffHelpList* pManualDiffHelpList)
 {
     d->m_filename = filename;
     d->m_pLineData = pLineData;
     d->m_size = size;
     d->m_pDiff3LineVector = pDiff3LineVector;
     d->m_diff3WrapLineVector.clear();
     d->m_pManualDiffHelpList = pManualDiffHelpList;
 
     d->m_firstLine = 0;
     d->m_oldFirstLine = -1;
     d->m_horizScrollOffset = 0;
     d->m_scrollDeltaX = 0;
     d->m_scrollDeltaY = 0;
     d->m_bMyUpdate = false;
     d->m_fastSelectorLine1 = 0;
     d->m_fastSelectorNofLines = 0;
     d->m_lineNumberWidth = 0;
     d->m_maxTextWidth = -1;
 
     d->m_pTextCodec = pTextCodec;
     d->m_eLineEndStyle = eLineEndStyle;
 
     update();
 }
 
 void DiffTextWindow::setupConnections(const KDiff3App* app) const
 {
     Q_ASSERT(qobject_cast<DiffTextWindowFrame*>(parent()) != nullptr);
 
     connect(this, &DiffTextWindow::scrollVertically, mVScrollBar, &QScrollBar::setValue);
 
     connect(this, &DiffTextWindow::firstLineChanged, dynamic_cast<DiffTextWindowFrame*>(parent()), &DiffTextWindowFrame::setFirstLine);
     connect(this, &DiffTextWindow::newSelection, app, &KDiff3App::slotSelectionStart);
     connect(this, &DiffTextWindow::selectionEnd, app, &KDiff3App::slotSelectionEnd);
     connect(this, &DiffTextWindow::scrollDiffTextWindow, app, &KDiff3App::scrollDiffTextWindow);
     connect(this, &DiffTextWindow::finishRecalcWordWrap, app, &KDiff3App::slotFinishRecalcWordWrap, Qt::QueuedConnection);
-    connect(this, &DiffTextWindow::checkIfCanContinue, app, &KDiff3App::slotCheckIfCanContinue);
+
     connect(this, &DiffTextWindow::finishDrop, app, &KDiff3App::slotFinishDrop);
 
     connect(this, &DiffTextWindow::statusBarMessage, app, &KDiff3App::slotStatusMsg);
 
     connect(app, &KDiff3App::showWhiteSpaceToggled, this, static_cast<void (DiffTextWindow::*)(void)>(&DiffTextWindow::update));
     connect(app, &KDiff3App::showLineNumbersToggled, this, static_cast<void (DiffTextWindow::*)(void)>(&DiffTextWindow::update));
     connect(app, &KDiff3App::doRefresh, this, &DiffTextWindow::slotRefresh);
     connect(app, &KDiff3App::selectAll, this, &DiffTextWindow::slotSelectAll);
 }
 
 void DiffTextWindow::reset()
 {
     d->m_pLineData = nullptr;
     d->m_size = 0;
     d->m_pDiff3LineVector = nullptr;
     d->m_filename = "";
     d->m_diff3WrapLineVector.clear();
 }
 
 void DiffTextWindow::slotRefresh()
 {
     setFont(d->getOptions()->m_font);
     update();
 }
 
 void DiffTextWindow::slotSelectAll()
 {
     LineRef l;
     int p = 0; // needed as dummy return values
 
     if(hasFocus())
     {
         setSelection(0, 0, getNofLines(), 0, l, p);
     }
 }
 
 void DiffTextWindow::setPaintingAllowed(bool bAllowPainting)
 {
     if(updatesEnabled() != bAllowPainting)
     {
         setUpdatesEnabled(bAllowPainting);
         if(bAllowPainting)
             update();
         else
             reset();
     }
 }
 
 void DiffTextWindow::dragEnterEvent(QDragEnterEvent* e)
 {
     e->setAccepted(e->mimeData()->hasUrls() || e->mimeData()->hasText());
 }
 
 void DiffTextWindow::dropEvent(QDropEvent* dropEvent)
 {
     dropEvent->accept();
 
     if(dropEvent->mimeData()->hasUrls())
     {
         QList<QUrl> urlList = dropEvent->mimeData()->urls();
 
-        bool bShouldConintue = false;
-        Q_EMIT checkIfCanContinue(bShouldConintue);
-        if(bShouldConintue && !urlList.isEmpty())
+        if(KDiff3App::shouldContinue() && !urlList.isEmpty())
         {
             QString filename = urlList.first().toLocalFile();
 
             d->sourceData->setFilename(filename);
 
             Q_EMIT finishDrop();
         }
     }
     else if(dropEvent->mimeData()->hasText())
     {
         QString text = dropEvent->mimeData()->text();
-        bool bShouldConintue = false;
-        Q_EMIT checkIfCanContinue(bShouldConintue);
 
-        if(bShouldConintue)
+        if(KDiff3App::shouldContinue())
         {
             QString error;
 
             error = d->sourceData->setData(text);
 
             if(!error.isEmpty())
             {
                 KMessageBox::error(this, error);
             }
 
             Q_EMIT finishDrop();
         }
     }
 }
 
 void DiffTextWindow::printWindow(RLPainter& painter, const QRect& view, const QString& headerText, int line, int linesPerPage, const QColor& fgColor)
 {
     QRect clipRect = view;
     clipRect.setTop(0);
     painter.setClipRect(clipRect);
     painter.translate(view.left(), 0);
     QFontMetrics fm = painter.fontMetrics();
     //if ( fm.width(headerText) > view.width() )
     {
         // A simple wrapline algorithm
         int l = 0;
         for(int p = 0; p < headerText.length();)
         {
             QString s = headerText.mid(p);
             int i;
             for(i = 2; i < s.length(); ++i)
                 if(Utils::getHorizontalAdvance(fm, s, i) > view.width())
                 {
                     --i;
                     break;
                 }
 
             painter.drawText(0, l * fm.height() + fm.ascent(), s.left(i));
             p += i;
             ++l;
         }
         painter.setPen(fgColor);
         painter.drawLine(0, view.top() - 2, view.width(), view.top() - 2);
     }
 
     painter.translate(0, view.top());
     print(painter, view, line, linesPerPage);
     painter.resetTransform();
 }
 
 void DiffTextWindow::setFirstLine(QtNumberType firstLine)
 {
     int fontHeight = fontMetrics().lineSpacing();
 
     LineRef newFirstLine = std::max(0, firstLine);
 
     int deltaY = fontHeight * (d->m_firstLine - newFirstLine);
 
     d->m_firstLine = newFirstLine;
 
     if(d->m_bSelectionInProgress && d->m_selection.isValidFirstLine())
     {
         LineRef line;
         int pos;
         convertToLinePos(d->m_lastKnownMousePos.x(), d->m_lastKnownMousePos.y(), line, pos);
         d->m_selection.end(line, pos);
         update();
     }
     else
     {
         scroll(0, deltaY);
     }
 
     Q_EMIT firstLineChanged(d->m_firstLine);
 }
 
 int DiffTextWindow::getFirstLine()
 {
     return d->m_firstLine;
 }
 
 void DiffTextWindow::setHorizScrollOffset(int horizScrollOffset)
 {
     int fontWidth = Utils::getHorizontalAdvance(fontMetrics(), '0');
     int xOffset = d->leftInfoWidth() * fontWidth;
 
     int deltaX = d->m_horizScrollOffset - std::max(0, horizScrollOffset);
 
     d->m_horizScrollOffset = std::max(0, horizScrollOffset);
 
     if(d->m_bSelectionInProgress && d->m_selection.isValidFirstLine())
     {
         LineRef line;
         int pos;
         convertToLinePos(d->m_lastKnownMousePos.x(), d->m_lastKnownMousePos.y(), line, pos);
         d->m_selection.end(line, pos);
     }
     else
     {
         QRect r(xOffset, 0, width(), height());
 
         if(d->getOptions()->m_bRightToLeftLanguage)
         {
             deltaX = -deltaX;
             r = QRect(width() - xOffset - 2, 0, -(width()), height()).normalized();
         }
 
         scroll(deltaX, 0, r);
     }
 
     update();
 }
 
 int DiffTextWindow::getMaxTextWidth()
 {
     if(d->m_bWordWrap)
     {
         return getVisibleTextAreaWidth();
     }
     else if(getAtomic(d->m_maxTextWidth) < 0)
     {
         d->m_maxTextWidth = 0;
         QTextLayout textLayout(QString(), font(), this);
         for(int i = 0; i < d->m_size; ++i)
         {
             textLayout.clearLayout();
             textLayout.setText(d->getString(i));
             d->prepareTextLayout(textLayout);
             if(textLayout.maximumWidth() > getAtomic(d->m_maxTextWidth))
                 d->m_maxTextWidth = qCeil(textLayout.maximumWidth());
         }
     }
     return getAtomic(d->m_maxTextWidth);
 }
 
 LineCount DiffTextWindow::getNofLines()
 {
     return d->m_bWordWrap ? d->m_diff3WrapLineVector.size() : d->m_pDiff3LineVector->size();
 }
 
 int DiffTextWindow::convertLineToDiff3LineIdx(LineRef line)
 {
     if(line.isValid() && d->m_bWordWrap && d->m_diff3WrapLineVector.size() > 0)
         return d->m_diff3WrapLineVector[std::min((LineRef::LineType)line, d->m_diff3WrapLineVector.size() - 1)].diff3LineIndex;
     else
         return line;
 }
 
 LineRef DiffTextWindow::convertDiff3LineIdxToLine(int d3lIdx)
 {
     if(d->m_bWordWrap && d->m_pDiff3LineVector != nullptr && d->m_pDiff3LineVector->size() > 0)
         return (*d->m_pDiff3LineVector)[std::min(d3lIdx, (int)d->m_pDiff3LineVector->size() - 1)]->sumLinesNeededForDisplay();
     else
         return d3lIdx;
 }
 
 /** Returns a line number where the linerange [line, line+nofLines] can
     be displayed best. If it fits into the currently visible range then
     the returned value is the current firstLine.
 */
 int getBestFirstLine(int line, int nofLines, int firstLine, int visibleLines)
 {
     int newFirstLine = firstLine;
     if(line < firstLine || line + nofLines + 2 > firstLine + visibleLines)
     {
         if(nofLines > visibleLines || nofLines <= (2 * visibleLines / 3 - 1))
             newFirstLine = line - visibleLines / 3;
         else
             newFirstLine = line - (visibleLines - nofLines);
     }
 
     return newFirstLine;
 }
 
 void DiffTextWindow::setFastSelectorRange(int line1, int nofLines)
 {
     d->m_fastSelectorLine1 = line1;
     d->m_fastSelectorNofLines = nofLines;
     if(isVisible())
     {
         int newFirstLine = getBestFirstLine(
             convertDiff3LineIdxToLine(d->m_fastSelectorLine1),
             convertDiff3LineIdxToLine(d->m_fastSelectorLine1 + d->m_fastSelectorNofLines) - convertDiff3LineIdxToLine(d->m_fastSelectorLine1),
             d->m_firstLine,
             getNofVisibleLines());
         if(newFirstLine != d->m_firstLine)
         {
             Q_EMIT scrollVertically(newFirstLine - d->m_firstLine);
         }
 
         update();
     }
 }
 /*
     Takes the line number estimated from mouse position and converts it to the actual line in
     the file. Then sets the status message accordingly.
 
     emits lineClicked signal.
 */
 void DiffTextWindow::showStatusLine(const LineRef aproxLine)
 {
     int d3lIdx = convertLineToDiff3LineIdx(aproxLine);
 
     if(d->m_pDiff3LineVector != nullptr && d3lIdx >= 0 && d3lIdx < (int)d->m_pDiff3LineVector->size())
     {
         const Diff3Line* pD3l = (*d->m_pDiff3LineVector)[d3lIdx];
         if(pD3l != nullptr)
         {
             LineRef actualLine = pD3l->getLineInFile(d->m_winIdx);
 
             QString message;
             if(actualLine.isValid())
                 message = i18n("File %1: Line %2", d->m_filename, actualLine + 1);
             else
                 message = i18n("File %1: Line not available", d->m_filename);
             Q_EMIT statusBarMessage(message);
 
             Q_EMIT lineClicked(d->m_winIdx, actualLine);
         }
     }
 }
 
 void DiffTextWindow::focusInEvent(QFocusEvent* e)
 {
     Q_EMIT gotFocus();
     QWidget::focusInEvent(e);
 }
 
 void DiffTextWindow::mousePressEvent(QMouseEvent* e)
 {
     if(e->button() == Qt::LeftButton)
     {
         LineRef line;
         int pos;
         convertToLinePos(e->x(), e->y(), line, pos);
 
         int fontWidth = Utils::getHorizontalAdvance(fontMetrics(), '0');
         int xOffset = d->leftInfoWidth() * fontWidth;
 
         if((!d->getOptions()->m_bRightToLeftLanguage && e->x() < xOffset) || (d->getOptions()->m_bRightToLeftLanguage && e->x() > width() - xOffset))
         {
             Q_EMIT setFastSelectorLine(convertLineToDiff3LineIdx(line));
             d->m_selection.reset(); // Disable current d->m_selection
         }
         else
         { // Selection
             resetSelection();
             d->m_selection.start(line, pos);
             d->m_selection.end(line, pos);
             d->m_bSelectionInProgress = true;
             d->m_lastKnownMousePos = e->pos();
 
             showStatusLine(line);
         }
     }
 }
 
 void DiffTextWindow::mouseDoubleClickEvent(QMouseEvent* e)
 {
     d->m_bSelectionInProgress = false;
     d->m_lastKnownMousePos = e->pos();
     if(e->button() == Qt::LeftButton)
     {
         LineRef line;
         int pos;
         convertToLinePos(e->x(), e->y(), line, pos);
 
         // Get the string data of the current line
         QString s;
         if(d->m_bWordWrap)
         {
             if(!line.isValid() || line >= (int)d->m_diff3WrapLineVector.size())
                 return;
             const Diff3WrapLine& d3wl = d->m_diff3WrapLineVector[line];
             s = d->getString(d3wl.diff3LineIndex).mid(d3wl.wrapLineOffset, d3wl.wrapLineLength);
         }
         else
         {
             if(!line.isValid() || line >= (int)d->m_pDiff3LineVector->size())
                 return;
             s = d->getString(line);
         }
 
         if(!s.isEmpty())
         {
             int pos1, pos2;
             Utils::calcTokenPos(s, pos, pos1, pos2);
 
             resetSelection();
             d->m_selection.start(line, pos1);
             d->m_selection.end(line, pos2);
             update();
             // Q_EMIT d->m_selectionEnd() happens in the mouseReleaseEvent.
             showStatusLine(line);
         }
     }
 }
 
 void DiffTextWindow::mouseReleaseEvent(QMouseEvent* e)
 {
     d->m_bSelectionInProgress = false;
     d->m_lastKnownMousePos = e->pos();
     //if ( e->button() == LeftButton )
     {
         if(d->m_delayedDrawTimer)
             killTimer(d->m_delayedDrawTimer);
         d->m_delayedDrawTimer = 0;
         if(d->m_selection.isValidFirstLine())
         {
             Q_EMIT selectionEnd();
         }
     }
     d->m_scrollDeltaX = 0;
     d->m_scrollDeltaY = 0;
 }
 
 void DiffTextWindow::mouseMoveEvent(QMouseEvent* e)
 {//Handles selection highlighting.
     LineRef line;
     int pos;
     convertToLinePos(e->x(), e->y(), line, pos);
     d->m_lastKnownMousePos = e->pos();
 
     if(d->m_selection.isValidFirstLine())
     {
         d->m_selection.end(line, pos);
 
         showStatusLine(line);
 
         // Scroll because mouse moved out of the window
         const QFontMetrics& fm = fontMetrics();
         int fontWidth = Utils::getHorizontalAdvance(fm, '0');
         int deltaX = 0;
         int deltaY = 0;
         if(!d->getOptions()->m_bRightToLeftLanguage)
         {
             if(e->x() < d->leftInfoWidth() * fontWidth) deltaX = -1 - abs(e->x() - d->leftInfoWidth() * fontWidth) / fontWidth;
             if(e->x() > width()) deltaX = +1 + abs(e->x() - width()) / fontWidth;
         }
         else
         {
             if(e->x() > width() - 1 - d->leftInfoWidth() * fontWidth) deltaX = +1 + abs(e->x() - (width() - 1 - d->leftInfoWidth() * fontWidth)) / fontWidth;
             if(e->x() < fontWidth) deltaX = -1 - abs(e->x() - fontWidth) / fontWidth;
         }
         if(e->y() < 0) deltaY = -1 - (int)std::pow<int, int>(e->y(), 2) / (int)std::pow(fm.lineSpacing(), 2);
         if(e->y() > height()) deltaY = 1 + (int)std::pow(e->y() - height(), 2) / (int)std::pow(fm.lineSpacing(), 2);
         if((deltaX != 0 && d->m_scrollDeltaX != deltaX) || (deltaY != 0 && d->m_scrollDeltaY != deltaY))
         {
             d->m_scrollDeltaX = deltaX;
             d->m_scrollDeltaY = deltaY;
             Q_EMIT scrollDiffTextWindow(deltaX, deltaY);
             if(d->m_delayedDrawTimer)
                 killTimer(d->m_delayedDrawTimer);
             d->m_delayedDrawTimer = startTimer(50);
         }
         else
         {
             d->m_scrollDeltaX = deltaX;
             d->m_scrollDeltaY = deltaY;
             d->myUpdate(0);
         }
     }
 }
 
 void DiffTextWindow::wheelEvent(QWheelEvent* pWheelEvent)
 {
     QPoint delta = pWheelEvent->angleDelta();
 
     //Block diagonal scrolling easily generated unintentionally with track pads.
     if(delta.y() != 0 && abs(delta.y()) > abs(delta.x()) && mVScrollBar != nullptr)
     {
         pWheelEvent->accept();
         QCoreApplication::postEvent(mVScrollBar, new QWheelEvent(*pWheelEvent));
     }
 }
 
 void DiffTextWindowData::myUpdate(int afterMilliSecs)
 {
     if(m_delayedDrawTimer)
         m_pDiffTextWindow->killTimer(m_delayedDrawTimer);
     m_bMyUpdate = true;
     m_delayedDrawTimer = m_pDiffTextWindow->startTimer(afterMilliSecs);
 }
 
 void DiffTextWindow::timerEvent(QTimerEvent*)
 {
     killTimer(d->m_delayedDrawTimer);
     d->m_delayedDrawTimer = 0;
 
     if(d->m_bMyUpdate)
     {
         int fontHeight = fontMetrics().lineSpacing();
 
         if(d->m_selection.getOldLastLine().isValid())
         {
             int lastLine;
             int firstLine;
             if(d->m_selection.getOldFirstLine().isValid())
             {
                 firstLine = min3(d->m_selection.getOldFirstLine(), d->m_selection.getLastLine(), d->m_selection.getOldLastLine());
                 lastLine = max3(d->m_selection.getOldFirstLine(), d->m_selection.getLastLine(), d->m_selection.getOldLastLine());
             }
             else
             {
                 firstLine = std::min(d->m_selection.getLastLine(), d->m_selection.getOldLastLine());
                 lastLine = std::max(d->m_selection.getLastLine(), d->m_selection.getOldLastLine());
             }
             int y1 = (firstLine - d->m_firstLine) * fontHeight;
             int y2 = std::min(height(), (lastLine - d->m_firstLine + 1) * fontHeight);
 
             if(y1 < height() && y2 > 0)
             {
                 QRect invalidRect = QRect(0, y1 - 1, width(), y2 - y1 + fontHeight); // Some characters in exotic exceed the regular bottom.
                 update(invalidRect);
             }
         }
 
         d->m_bMyUpdate = false;
     }
 
     if(d->m_scrollDeltaX != 0 || d->m_scrollDeltaY != 0)
     {
         d->m_selection.end(d->m_selection.getLastLine() + d->m_scrollDeltaY, d->m_selection.getLastPos() + d->m_scrollDeltaX);
         Q_EMIT scrollDiffTextWindow(d->m_scrollDeltaX, d->m_scrollDeltaY);
         killTimer(d->m_delayedDrawTimer);
         d->m_delayedDrawTimer = startTimer(50);
     }
 }
 
 void DiffTextWindow::resetSelection()
 {
     d->m_selection.reset();
     update();
 }
 
 void DiffTextWindow::convertToLinePos(int x, int y, LineRef& line, int& pos)
 {
     const QFontMetrics& fm = fontMetrics();
     int fontHeight = fm.lineSpacing();
 
     int yOffset = -d->m_firstLine * fontHeight;
 
     line = (y - yOffset) / fontHeight;
     if(line.isValid() && (!d->getOptions()->wordWrapOn() || line < d->m_diff3WrapLineVector.count()))
     {
         QString s = d->getLineString(line);
         QTextLayout textLayout(s, font(), this);
         d->prepareTextLayout(textLayout);
         pos = textLayout.lineAt(0).xToCursor(x - textLayout.position().x());
     }
     else
         pos = -1;
 }
 
 class FormatRangeHelper
 {
   private:
     QFont m_font;
     QPen m_pen;
     QColor m_background;
     int m_currentPos;
 
     QVector<QTextLayout::FormatRange> m_formatRanges;
 
   public:
     inline operator QVector<QTextLayout::FormatRange>() { return m_formatRanges; }
     FormatRangeHelper()
     {
         m_pen = QColor(Qt::black);
         m_background = QColor(Qt::white);
         m_currentPos = 0;
     }
     void setFont(const QFont& f)
     {
         m_font = f;
     }
     void setPen(const QPen& pen)
     {
         m_pen = pen;
     }
     void setBackground(const QColor& background)
     {
         m_background = background;
     }
 
     void next()
     {
         if(m_formatRanges.isEmpty() || m_formatRanges.back().format.foreground().color() != m_pen.color() || m_formatRanges.back().format.background().color() != m_background)
         {
             QTextLayout::FormatRange fr;
             fr.length = 1;
             fr.start = m_currentPos;
             fr.format.setForeground(m_pen.color());
             fr.format.setBackground(m_background);
             m_formatRanges.append(fr);
         }
         else
         {
             ++m_formatRanges.back().length;
         }
         ++m_currentPos;
     }
 };
 
 void DiffTextWindowData::prepareTextLayout(QTextLayout& textLayout, int visibleTextWidth)
 {
     QTextOption textOption;
 #if QT_VERSION < QT_VERSION_CHECK(5, 10, 0)
     textOption.setTabStop(QFontMetricsF(m_pDiffTextWindow->font()).width(' ') * m_pOptions->m_tabSize);
 #else
     textOption.setTabStopDistance(QFontMetricsF(m_pDiffTextWindow->font()).width(' ') * m_pOptions->m_tabSize);
 #endif
     if(m_pOptions->m_bShowWhiteSpaceCharacters)
         textOption.setFlags(QTextOption::ShowTabsAndSpaces);
     if(m_pOptions->m_bRightToLeftLanguage)
         textOption.setAlignment(Qt::AlignRight); // only relevant for multi line text layout
     if(visibleTextWidth >= 0)
         textOption.setWrapMode(QTextOption::WrapAtWordBoundaryOrAnywhere);
 
     textLayout.setTextOption(textOption);
 
     if(m_pOptions->m_bShowWhiteSpaceCharacters)
     {
         // This additional format is only necessary for the tab arrow
         QVector<QTextLayout::FormatRange> formats;
         QTextLayout::FormatRange formatRange;
         formatRange.start = 0;
         formatRange.length = textLayout.text().length();
         formatRange.format.setFont(m_pDiffTextWindow->font());
         formats.append(formatRange);
         textLayout.setFormats(formats);
     }
     textLayout.beginLayout();
 
     int leading = m_pDiffTextWindow->fontMetrics().leading();
     int height = 0;
 
     int fontWidth = Utils::getHorizontalAdvance(m_pDiffTextWindow->fontMetrics(), '0');
     int xOffset = leftInfoWidth() * fontWidth - m_horizScrollOffset;
     int textWidth = visibleTextWidth;
     if(textWidth < 0)
         textWidth = m_pDiffTextWindow->width() - xOffset;
 
     int indentation = 0;
     while(true)
     {
         QTextLine line = textLayout.createLine();
         if(!line.isValid())
             break;
 
         height += leading;
         //if ( !bFirstLine )
         //   indentation = m_pDiffTextWindow->fontMetrics().width(' ') * m_pOptions->m_tabSize;
         if(visibleTextWidth >= 0)
         {
             line.setLineWidth(visibleTextWidth - indentation);
             line.setPosition(QPointF(indentation, height));
             height += qCeil(line.height());
             //bFirstLine = false;
         }
         else // only one line
         {
             line.setPosition(QPointF(indentation, height));
             break;
         }
     }
 
     textLayout.endLayout();
     if(m_pOptions->m_bRightToLeftLanguage)
         textLayout.setPosition(QPointF(textWidth - textLayout.maximumWidth(), 0));
     else
         textLayout.setPosition(QPointF(xOffset, 0));
 }
 
 /*
     Don't try to use invalid rect to block drawing of lines based on there apparent horizontal dementions.
     This does not always work for very long lines being scrolled horzontally. (Causes blanking of diff text area)
 */
 void DiffTextWindowData::writeLine(
     RLPainter& p,
     const LineData* pld,
     const DiffList* pLineDiff1,
     const DiffList* pLineDiff2,
     const LineRef& line,
     const ChangeFlags whatChanged,
     const ChangeFlags whatChanged2,
     const LineRef& srcLineIdx,
     int wrapLineOffset,
     int wrapLineLength,
     bool bWrapLine,
     const QRect& invalidRect)
 {
     QFont normalFont = p.font();
 
     const QFontMetrics& fm = p.fontMetrics();
     int fontHeight = fm.lineSpacing();
     int fontAscent = fm.ascent();
     int fontWidth = Utils::getHorizontalAdvance(fm, '0');
 
     int xOffset = 0;
     int yOffset = (line - m_firstLine) * fontHeight;
 
     int fastSelectorLine1 = m_pDiffTextWindow->convertDiff3LineIdxToLine(m_fastSelectorLine1);
     int fastSelectorLine2 = m_pDiffTextWindow->convertDiff3LineIdxToLine(m_fastSelectorLine1 + m_fastSelectorNofLines) - 1;
 
     bool bFastSelectionRange = (line >= fastSelectorLine1 && line <= fastSelectorLine2);
     QColor bgColor = m_pOptions->m_bgColor;
     QColor diffBgColor = m_pOptions->m_diffBgColor;
 
     if(bFastSelectionRange)
     {
         bgColor = m_pOptions->m_currentRangeBgColor;
         diffBgColor = m_pOptions->m_currentRangeDiffBgColor;
     }
 
     if(yOffset + fontHeight < invalidRect.top() || invalidRect.bottom() < yOffset - fontHeight)
         return;
 
     ChangeFlags changed = whatChanged;
     if(pLineDiff1 != nullptr) changed |= AChanged;
     if(pLineDiff2 != nullptr) changed |= BChanged;
 
     QColor penColor = m_pOptions->m_fgColor;
     p.setPen(penColor);
     if(changed == BChanged)
     {
         penColor = m_cDiff2;
     }
     else if(changed == AChanged)
     {
         penColor = m_cDiff1;
     }
     else if(changed == Both)
     {
         penColor = m_cDiffBoth;
     }
 
     if(pld != nullptr)
     {
         // First calculate the "changed" information for each character.
         int i = 0;
         QString lineString = pld->getLine();
         if(!lineString.isEmpty())
         {
             switch(lineString[lineString.length() - 1].unicode())
             {
                 case '\n':
                     lineString[lineString.length() - 1] = 0x00B6;
                     break; // "Pilcrow", "paragraph mark"
                 case '\r':
                     lineString[lineString.length() - 1] = 0x00A4;
                     break; // Currency sign ;0x2761 "curved stem paragraph sign ornament"
                 //case '\0b' : lineString[lineString.length()-1] = 0x2756; break; // some other nice looking character
             }
         }
         QVector<ChangeFlags> charChanged(pld->size());
         Merger merger(pLineDiff1, pLineDiff2);
         while(!merger.isEndReached() && i < pld->size())
         {
             if(i < pld->size())
             {
                 charChanged[i] = merger.whatChanged();
                 ++i;
             }
             merger.next();
         }
 
         int outPos = 0;
 
         int lineLength = m_bWordWrap ? wrapLineOffset + wrapLineLength : lineString.length();
 
         FormatRangeHelper frh;
 
         for(i = wrapLineOffset; i < lineLength; ++i)
         {
             penColor = m_pOptions->m_fgColor;
             ChangeFlags cchanged = charChanged[i] | whatChanged;
 
             if(cchanged == BChanged)
             {
                 penColor = m_cDiff2;
             }
             else if(cchanged == AChanged)
             {
                 penColor = m_cDiff1;
             }
             else if(cchanged == Both)
             {
                 penColor = m_cDiffBoth;
             }
 
             if(penColor != m_pOptions->m_fgColor && whatChanged2 == NoChange && !m_pOptions->m_bShowWhiteSpace)
             {
                 // The user doesn't want to see highlighted white space.
                 penColor = m_pOptions->m_fgColor;
             }
 
             frh.setBackground(bgColor);
             if(!m_selection.within(line, outPos))
             {
                 if(penColor != m_pOptions->m_fgColor)
                 {
                     QColor lightc = diffBgColor;
                     frh.setBackground(lightc);
                     // Setting italic font here doesn't work: Changing the font only when drawing is too late
                 }
 
                 frh.setPen(penColor);
                 frh.next();
                 frh.setFont(normalFont);
             }
             else
             {
                 frh.setBackground(m_pDiffTextWindow->palette().highlight().color());
                 frh.setPen(m_pDiffTextWindow->palette().highlightedText().color());
                 frh.next();
 
                 m_selection.bSelectionContainsData = true;
             }
 
             ++outPos;
         } // end for
 
         QTextLayout textLayout(lineString.mid(wrapLineOffset, lineLength - wrapLineOffset), m_pDiffTextWindow->font(), m_pDiffTextWindow);
         prepareTextLayout(textLayout);
         textLayout.draw(&p, QPoint(0, yOffset), frh /*, const QRectF & clip = QRectF() */);
     }
 
     p.fillRect(0, yOffset, leftInfoWidth() * fontWidth, fontHeight, m_pOptions->m_bgColor);
 
     xOffset = (m_lineNumberWidth + 2) * fontWidth;
     int xLeft = m_lineNumberWidth * fontWidth;
     p.setPen(m_pOptions->m_fgColor);
     if(pld != nullptr)
     {
         if(m_pOptions->m_bShowLineNumbers && !bWrapLine)
         {
             QString num = QString::number(srcLineIdx + 1);
             Q_ASSERT(!num.isEmpty());
             p.drawText(0, yOffset + fontAscent, num);
         }
         if(!bWrapLine || wrapLineLength > 0)
         {
             Qt::PenStyle wrapLinePenStyle = Qt::DotLine;
 
             p.setPen(QPen(m_pOptions->m_fgColor, 0, bWrapLine ? wrapLinePenStyle : Qt::SolidLine));
             p.drawLine(xOffset + 1, yOffset, xOffset + 1, yOffset + fontHeight - 1);
             p.setPen(QPen(m_pOptions->m_fgColor, 0, Qt::SolidLine));
         }
     }
     if(penColor != m_pOptions->m_fgColor && whatChanged2 == NoChange)
     {
         if(m_pOptions->m_bShowWhiteSpace)
         {
             p.setBrushOrigin(0, 0);
             p.fillRect(xLeft, yOffset, fontWidth * 2 - 1, fontHeight, QBrush(penColor, Qt::Dense5Pattern));
         }
     }
     else
     {
         p.fillRect(xLeft, yOffset, fontWidth * 2 - 1, fontHeight, penColor == m_pOptions->m_fgColor ? bgColor : penColor);
     }
 
     if(bFastSelectionRange)
     {
         p.fillRect(xOffset + fontWidth - 1, yOffset, 3, fontHeight, m_pOptions->m_fgColor);
     }
 
     // Check if line needs a manual diff help mark
     ManualDiffHelpList::const_iterator ci;
     for(ci = m_pManualDiffHelpList->begin(); ci != m_pManualDiffHelpList->end(); ++ci)
     {
         const ManualDiffHelpEntry& mdhe = *ci;
         LineRef rangeLine1;
         LineRef rangeLine2;
 
         mdhe.getRangeForUI(m_winIdx, &rangeLine1, &rangeLine2);
         if(rangeLine1.isValid() && rangeLine2.isValid() && srcLineIdx >= rangeLine1 && srcLineIdx <= rangeLine2)
         {
             p.fillRect(xOffset - fontWidth, yOffset, fontWidth - 1, fontHeight, m_pOptions->m_manualHelpRangeColor);
             break;
         }
     }
 }
 
 void DiffTextWindow::paintEvent(QPaintEvent* e)
 {
     QRect invalidRect = e->rect();
     if(invalidRect.isEmpty())
         return;
 
     if(d->m_pDiff3LineVector == nullptr || (d->m_diff3WrapLineVector.empty() && d->m_bWordWrap))
     {
         QPainter p(this);
         p.fillRect(invalidRect, d->getOptions()->m_bgColor);
         return;
     }
 
     bool bOldSelectionContainsData = d->m_selection.bSelectionContainsData;
     d->m_selection.bSelectionContainsData = false;
 
     int endLine = std::min(d->m_firstLine + getNofVisibleLines() + 2, getNofLines());
 
     RLPainter p(this, d->getOptions()->m_bRightToLeftLanguage, width(), Utils::getHorizontalAdvance(fontMetrics(), '0'));
 
     p.setFont(font());
     p.QPainter::fillRect(invalidRect, d->getOptions()->m_bgColor);
 
     d->draw(p, invalidRect, d->m_firstLine, endLine);
     p.end();
 
     d->m_oldFirstLine = d->m_firstLine;
     d->m_selection.clearOldSelection();
 
     if(!bOldSelectionContainsData && d->m_selection.selectionContainsData())
         Q_EMIT newSelection();
 }
 
 void DiffTextWindow::print(RLPainter& p, const QRect&, int firstLine, int nofLinesPerPage)
 {
     if(d->m_pDiff3LineVector == nullptr || !updatesEnabled() ||
        (d->m_diff3WrapLineVector.empty() && d->m_bWordWrap))
         return;
     resetSelection();
     int oldFirstLine = d->m_firstLine;
     d->m_firstLine = firstLine;
     QRect invalidRect = QRect(0, 0, 1000000000, 1000000000);
     QColor bgColor = d->getOptions()->m_bgColor;
     d->getOptions()->m_bgColor = Qt::white;
     d->draw(p, invalidRect, firstLine, std::min(firstLine + nofLinesPerPage, getNofLines()));
     d->getOptions()->m_bgColor = bgColor;
     d->m_firstLine = oldFirstLine;
 }
 
 void DiffTextWindowData::draw(RLPainter& p, const QRect& invalidRect, int beginLine, int endLine)
 {
     m_lineNumberWidth = m_pOptions->m_bShowLineNumbers ? (int)log10((double)std::max(m_size, 1)) + 1 : 0;
 
     if(m_winIdx == e_SrcSelector::A)
     {
         m_cThis = m_pOptions->m_colorA;
         m_cDiff1 = m_pOptions->m_colorB;
         m_cDiff2 = m_pOptions->m_colorC;
     }
     if(m_winIdx == e_SrcSelector::B)
     {
         m_cThis = m_pOptions->m_colorB;
         m_cDiff1 = m_pOptions->m_colorC;
         m_cDiff2 = m_pOptions->m_colorA;
     }
     if(m_winIdx == e_SrcSelector::C)
     {
         m_cThis = m_pOptions->m_colorC;
         m_cDiff1 = m_pOptions->m_colorA;
         m_cDiff2 = m_pOptions->m_colorB;
     }
     m_cDiffBoth = m_pOptions->m_colorForConflict; // Conflict color
 
     p.setPen(m_cThis);
 
     for(int line = beginLine; line < endLine; ++line)
     {
         int wrapLineOffset = 0;
         int wrapLineLength = 0;
         const Diff3Line* d3l = nullptr;
         bool bWrapLine = false;
         if(m_bWordWrap)
         {
             Diff3WrapLine& d3wl = m_diff3WrapLineVector[line];
             wrapLineOffset = d3wl.wrapLineOffset;
             wrapLineLength = d3wl.wrapLineLength;
             d3l = d3wl.pD3L;
             bWrapLine = line > 0 && m_diff3WrapLineVector[line - 1].pD3L == d3l;
         }
         else
         {
             d3l = (*m_pDiff3LineVector)[line];
         }
         DiffList* pFineDiff1;
         DiffList* pFineDiff2;
         ChangeFlags changed = NoChange;
         ChangeFlags changed2 = NoChange;
 
         LineRef srcLineIdx;
         d3l->getLineInfo(m_winIdx, KDiff3App::isTripleDiff(), srcLineIdx, pFineDiff1, pFineDiff2, changed, changed2);
 
         writeLine(
             p,                                                             // QPainter
             !srcLineIdx.isValid() ? nullptr : &(*m_pLineData)[srcLineIdx], // Text in this line
             pFineDiff1,
             pFineDiff2,
             line, // Line on the screen
             changed,
             changed2,
             srcLineIdx,
             wrapLineOffset,
             wrapLineLength,
             bWrapLine,
             invalidRect);
     }
 }
 
 QString DiffTextWindowData::getString(int d3lIdx)
 {
     if(d3lIdx < 0 || d3lIdx >= m_pDiff3LineVector->size())
         return QString();
 
     const Diff3Line* d3l = (*m_pDiff3LineVector)[d3lIdx];
     DiffList* pFineDiff1;
     DiffList* pFineDiff2;
     ChangeFlags changed = NoChange;
     ChangeFlags changed2 = NoChange;
     LineRef lineIdx;
 
     d3l->getLineInfo(m_winIdx, KDiff3App::isTripleDiff(), lineIdx, pFineDiff1, pFineDiff2, changed, changed2);
 
     if(!lineIdx.isValid())
         return QString();
 
     return (*m_pLineData)[lineIdx].getLine();
 }
 
 QString DiffTextWindowData::getLineString(int line)
 {
     if(m_bWordWrap)
     {
         if(line < m_diff3WrapLineVector.count())
         {
             int d3LIdx = m_pDiffTextWindow->convertLineToDiff3LineIdx(line);
             return getString(d3LIdx).mid(m_diff3WrapLineVector[line].wrapLineOffset, m_diff3WrapLineVector[line].wrapLineLength);
         }
         else
             return QString();
     }
     else
     {
         return getString(line);
     }
 }
 
 void DiffTextWindow::resizeEvent(QResizeEvent* e)
 {
     QSize s = e->size();
     QFontMetrics fm = fontMetrics();
     int visibleLines = s.height() / fm.lineSpacing() - 2;
     int visibleColumns = s.width() / Utils::getHorizontalAdvance(fm, '0') - d->leftInfoWidth();
     if(e->size().height() != e->oldSize().height())
         Q_EMIT resizeHeightChangedSignal(visibleLines);
     if(e->size().width() != e->oldSize().width())
         Q_EMIT resizeWidthChangedSignal(visibleColumns);
     QWidget::resizeEvent(e);
 }
 
 int DiffTextWindow::getNofVisibleLines()
 {
     QFontMetrics fm = fontMetrics();
     int fmh = fm.lineSpacing();
     int h = height();
     return h / fmh - 1;
 }
 
 int DiffTextWindow::getVisibleTextAreaWidth()
 {
     QFontMetrics fm = fontMetrics();
     return width() - d->leftInfoWidth() * Utils::getHorizontalAdvance(fm, '0');
 }
 
 QString DiffTextWindow::getSelection()
 {
     if(d->m_pLineData == nullptr)
         return QString();
 
     QString selectionString;
 
     int line = 0;
     int lineIdx = 0;
 
     int it;
     int vectorSize = d->m_bWordWrap ? d->m_diff3WrapLineVector.size() : d->m_pDiff3LineVector->size();
     for(it = 0; it < vectorSize; ++it)
     {
         const Diff3Line* d3l = d->m_bWordWrap ? d->m_diff3WrapLineVector[it].pD3L : (*d->m_pDiff3LineVector)[it];
 
         Q_ASSERT(d->m_winIdx >= e_SrcSelector::A && d->m_winIdx <= e_SrcSelector::C);
 
         if(d->m_winIdx == e_SrcSelector::A)
         {
             lineIdx = d3l->getLineA();
         }
         else if(d->m_winIdx == e_SrcSelector::B)
         {
             lineIdx = d3l->getLineB();
         }
         else if(d->m_winIdx == e_SrcSelector::C)
         {
             lineIdx = d3l->getLineC();
         }
 
         if(lineIdx != -1)
         {
             int size = (*d->m_pLineData)[lineIdx].size();
             QString lineString = (*d->m_pLineData)[lineIdx].getLine();
 
             if(d->m_bWordWrap)
             {
                 size = d->m_diff3WrapLineVector[it].wrapLineLength;
                 lineString = lineString.mid(d->m_diff3WrapLineVector[it].wrapLineOffset, size);
             }
 
             for(int i = 0; i < size; ++i)
             {
                 if(d->m_selection.within(line, i))
                 {
                     selectionString += lineString[i];
                 }
             }
 
             if(d->m_selection.within(line, size) &&
                !(d->m_bWordWrap && it + 1 < vectorSize && d3l == d->m_diff3WrapLineVector[it + 1].pD3L))
             {
 #if defined(Q_OS_WIN)
                 selectionString += '\r';
 #endif
                 selectionString += '\n';
             }
         }
 
         ++line;
     }
 
     return selectionString;
 }
 
 bool DiffTextWindow::findString(const QString& s, LineRef& d3vLine, int& posInLine, bool bDirDown, bool bCaseSensitive)
 {
     int it = d3vLine;
     int endIt = bDirDown ? d->m_pDiff3LineVector->size() : -1;
     int step = bDirDown ? 1 : -1;
     int startPos = posInLine;
 
     for(; it != endIt; it += step)
     {
         QString line = d->getString(it);
         if(!line.isEmpty())
         {
             int pos = line.indexOf(s, startPos, bCaseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive);
             if(pos != -1)
             {
                 d3vLine = it;
                 posInLine = pos;
                 return true;
             }
 
             startPos = 0;
         }
     }
     return false;
 }
 
 void DiffTextWindow::convertD3LCoordsToLineCoords(int d3LIdx, int d3LPos, int& line, int& pos)
 {
     if(d->m_bWordWrap)
     {
         int wrapPos = d3LPos;
         int wrapLine = convertDiff3LineIdxToLine(d3LIdx);
         while(wrapPos > d->m_diff3WrapLineVector[wrapLine].wrapLineLength)
         {
             wrapPos -= d->m_diff3WrapLineVector[wrapLine].wrapLineLength;
             ++wrapLine;
         }
         pos = wrapPos;
         line = wrapLine;
     }
     else
     {
         pos = d3LPos;
         line = d3LIdx;
     }
 }
 
 void DiffTextWindow::convertLineCoordsToD3LCoords(int line, int pos, int& d3LIdx, int& d3LPos)
 {
     if(d->m_bWordWrap)
     {
         d3LPos = pos;
         d3LIdx = convertLineToDiff3LineIdx(line);
         int wrapLine = convertDiff3LineIdxToLine(d3LIdx); // First wrap line belonging to this d3LIdx
         while(wrapLine < line)
         {
             d3LPos += d->m_diff3WrapLineVector[wrapLine].wrapLineLength;
             ++wrapLine;
         }
     }
     else
     {
         d3LPos = pos;
         d3LIdx = line;
     }
 }
 
 void DiffTextWindow::setSelection(LineRef firstLine, int startPos, LineRef lastLine, int endPos, LineRef& l, int& p)
 {
     d->m_selection.reset();
     if(lastLine >= getNofLines())
     {
         lastLine = getNofLines() - 1;
 
         const Diff3Line* d3l = (*d->m_pDiff3LineVector)[convertLineToDiff3LineIdx(lastLine)];
         LineRef line;
         if(d->m_winIdx == e_SrcSelector::A) line = d3l->getLineA();
         if(d->m_winIdx == e_SrcSelector::B) line = d3l->getLineB();
         if(d->m_winIdx == e_SrcSelector::C) line = d3l->getLineC();
         if(line.isValid())
             endPos = (*d->m_pLineData)[line].width(d->getOptions()->m_tabSize);
     }
 
     if(d->m_bWordWrap && d->m_pDiff3LineVector != nullptr)
     {
         QString s1 = d->getString(firstLine);
         int firstWrapLine = convertDiff3LineIdxToLine(firstLine);
         int wrapStartPos = startPos;
         while(wrapStartPos > d->m_diff3WrapLineVector[firstWrapLine].wrapLineLength)
         {
             wrapStartPos -= d->m_diff3WrapLineVector[firstWrapLine].wrapLineLength;
             s1 = s1.mid(d->m_diff3WrapLineVector[firstWrapLine].wrapLineLength);
             ++firstWrapLine;
         }
 
         QString s2 = d->getString(lastLine);
         int lastWrapLine = convertDiff3LineIdxToLine(lastLine);
         int wrapEndPos = endPos;
         while(wrapEndPos > d->m_diff3WrapLineVector[lastWrapLine].wrapLineLength)
         {
             wrapEndPos -= d->m_diff3WrapLineVector[lastWrapLine].wrapLineLength;
             s2 = s2.mid(d->m_diff3WrapLineVector[lastWrapLine].wrapLineLength);
             ++lastWrapLine;
         }
 
         d->m_selection.start(firstWrapLine, wrapStartPos);
         d->m_selection.end(lastWrapLine, wrapEndPos);
         l = firstWrapLine;
         p = wrapStartPos;
     }
     else
     {
         if(d->m_pDiff3LineVector != nullptr)
         {
             d->m_selection.start(firstLine, startPos);
             d->m_selection.end(lastLine, endPos);
             l = firstLine;
             p = startPos;
         }
     }
     update();
 }
 
 int DiffTextWindowData::convertLineOnScreenToLineInSource(int lineOnScreen, e_CoordType coordType, bool bFirstLine)
 {
     LineRef line;
     if(lineOnScreen >= 0)
     {
         if(coordType == eWrapCoords) return lineOnScreen;
         int d3lIdx = m_pDiffTextWindow->convertLineToDiff3LineIdx(lineOnScreen);
         if(!bFirstLine && d3lIdx >= m_pDiff3LineVector->size())
             d3lIdx = m_pDiff3LineVector->size() - 1;
         if(coordType == eD3LLineCoords) return d3lIdx;
         while(!line.isValid() && d3lIdx < m_pDiff3LineVector->size() && d3lIdx >= 0)
         {
             const Diff3Line* d3l = (*m_pDiff3LineVector)[d3lIdx];
             if(m_winIdx == e_SrcSelector::A) line = d3l->getLineA();
             if(m_winIdx == e_SrcSelector::B) line = d3l->getLineB();
             if(m_winIdx == e_SrcSelector::C) line = d3l->getLineC();
             if(bFirstLine)
                 ++d3lIdx;
             else
                 --d3lIdx;
         }
         if(coordType == eFileCoords) return line;
     }
     return line;
 }
 
 void DiffTextWindow::getSelectionRange(LineRef* pFirstLine, LineRef* pLastLine, e_CoordType coordType)
 {
     if(pFirstLine)
         *pFirstLine = d->convertLineOnScreenToLineInSource(d->m_selection.beginLine(), coordType, true);
     if(pLastLine)
         *pLastLine = d->convertLineOnScreenToLineInSource(d->m_selection.endLine(), coordType, false);
 }
 
 void DiffTextWindow::convertSelectionToD3LCoords()
 {
     if(d->m_pDiff3LineVector == nullptr || !updatesEnabled() || !isVisible() || d->m_selection.isEmpty())
     {
         return;
     }
 
     // convert the d->m_selection to unwrapped coordinates: Later restore to new coords
     int firstD3LIdx, firstD3LPos;
     QString s = d->getLineString(d->m_selection.beginLine());
     int firstPosInText = d->m_selection.beginPos();
     convertLineCoordsToD3LCoords(d->m_selection.beginLine(), firstPosInText, firstD3LIdx, firstD3LPos);
 
     int lastD3LIdx, lastD3LPos;
     s = d->getLineString(d->m_selection.endLine());
     int lastPosInText = d->m_selection.endPos();
     convertLineCoordsToD3LCoords(d->m_selection.endLine(), lastPosInText, lastD3LIdx, lastD3LPos);
 
     d->m_selection.start(firstD3LIdx, firstD3LPos);
     d->m_selection.end(lastD3LIdx, lastD3LPos);
 }
 
 bool DiffTextWindow::startRunnables()
 {
     if(s_runnables.count() == 0)
     {
         return false;
     }
     else
     {
         g_pProgressDialog->setStayHidden(true);
         g_pProgressDialog->push();
         g_pProgressDialog->setMaxNofSteps(s_runnables.count());
         RecalcWordWrapRunnable::s_maxNofRunnables = s_runnables.count();
         g_pProgressDialog->setCurrent(0);
 
         for(int i = 0; i < s_runnables.count(); ++i)
         {
             QThreadPool::globalInstance()->start(s_runnables[i]);
         }
 
         s_runnables.clear();
         return true;
     }
 }
 
 void DiffTextWindow::recalcWordWrap(bool bWordWrap, int wrapLineVectorSize, int visibleTextWidth)
 {
     if(d->m_pDiff3LineVector == nullptr || !isVisible())
     {
         d->m_bWordWrap = bWordWrap;
         if(!bWordWrap) d->m_diff3WrapLineVector.resize(0);
         return;
     }
 
     d->m_bWordWrap = bWordWrap;
 
     if(bWordWrap)
     {
         d->m_lineNumberWidth = d->getOptions()->m_bShowLineNumbers ? (int)log10((double)std::max(d->m_size, 1)) + 1 : 0;
 
         d->m_diff3WrapLineVector.resize(wrapLineVectorSize);
 
         if(wrapLineVectorSize == 0)
         {
             d->m_wrapLineCacheList.clear();
             setUpdatesEnabled(false);
             for(int i = 0, j = 0; i < d->m_pDiff3LineVector->size(); i += s_linesPerRunnable, ++j)
             {
                 d->m_wrapLineCacheList.append(QVector<WrapLineCacheData>());
                 s_runnables.push_back(new RecalcWordWrapRunnable(this, visibleTextWidth, j));
             }
         }
         else
         {
             recalcWordWrapHelper(wrapLineVectorSize, visibleTextWidth, 0);
             setUpdatesEnabled(true);
         }
     }
     else
     {
         if(wrapLineVectorSize == 0 && getAtomic(d->m_maxTextWidth) < 0)
         {
             d->m_diff3WrapLineVector.resize(0);
             d->m_wrapLineCacheList.clear();
             setUpdatesEnabled(false);
             for(int i = 0, j = 0; i < d->m_pDiff3LineVector->size(); i += s_linesPerRunnable, ++j)
             {
                 s_runnables.push_back(new RecalcWordWrapRunnable(this, visibleTextWidth, j));
             }
         }
         else
         {
             setUpdatesEnabled(true);
         }
     }
 }
 
 void DiffTextWindow::recalcWordWrapHelper(int wrapLineVectorSize, int visibleTextWidth, int cacheListIdx)
 {
     if(d->m_bWordWrap)
     {
         if(g_pProgressDialog->wasCancelled())
             return;
         if(visibleTextWidth < 0)
             visibleTextWidth = getVisibleTextAreaWidth();
         else
             visibleTextWidth -= d->leftInfoWidth() * Utils::getHorizontalAdvance(fontMetrics(), '0');
         int i;
         int wrapLineIdx = 0;
         int size = d->m_pDiff3LineVector->size();
         int firstD3LineIdx = wrapLineVectorSize > 0 ? 0 : cacheListIdx * s_linesPerRunnable;
         int endIdx = wrapLineVectorSize > 0 ? size : std::min(firstD3LineIdx + s_linesPerRunnable, size);
         QVector<WrapLineCacheData>& wrapLineCache = d->m_wrapLineCacheList[cacheListIdx];
         int cacheListIdx2 = 0;
         QTextLayout textLayout(QString(), font(), this);
         for(i = firstD3LineIdx; i < endIdx; ++i)
         {
             if(g_pProgressDialog->wasCancelled())
                 return;
 
             int linesNeeded = 0;
             if(wrapLineVectorSize == 0)
             {
                 QString s = d->getString(i);
                 textLayout.clearLayout();
                 textLayout.setText(s);
                 d->prepareTextLayout(textLayout, visibleTextWidth);
                 linesNeeded = textLayout.lineCount();
                 for(int l = 0; l < linesNeeded; ++l)
                 {
                     QTextLine line = textLayout.lineAt(l);
                     wrapLineCache.push_back(WrapLineCacheData(i, line.textStart(), line.textLength()));
                 }
             }
             else if(wrapLineVectorSize > 0 && cacheListIdx2 < d->m_wrapLineCacheList.count())
             {
                 WrapLineCacheData* pWrapLineCache = d->m_wrapLineCacheList[cacheListIdx2].data();
                 int cacheIdx = 0;
                 int clc = d->m_wrapLineCacheList.count() - 1;
                 int cllc = d->m_wrapLineCacheList.last().count();
                 int curCount = d->m_wrapLineCacheList[cacheListIdx2].count() - 1;
                 int l = 0;
                 while((cacheListIdx2 < clc || (cacheListIdx2 == clc && cacheIdx < cllc)) && pWrapLineCache->d3LineIdx() <= i)
                 {
                     if(pWrapLineCache->d3LineIdx() == i)
                     {
                         Diff3WrapLine* pDiff3WrapLine = &d->m_diff3WrapLineVector[wrapLineIdx + l];
                         pDiff3WrapLine->wrapLineOffset = pWrapLineCache->textStart();
                         pDiff3WrapLine->wrapLineLength = pWrapLineCache->textLength();
                         ++l;
                     }
                     if(cacheIdx < curCount)
                     {
                         ++cacheIdx;
                         ++pWrapLineCache;
                     }
                     else
                     {
                         ++cacheListIdx2;
                         if(cacheListIdx2 >= d->m_wrapLineCacheList.count())
                             break;
                         pWrapLineCache = d->m_wrapLineCacheList[cacheListIdx2].data();
                         curCount = d->m_wrapLineCacheList[cacheListIdx2].count();
                         cacheIdx = 0;
                     }
                 }
                 linesNeeded = l;
             }
 
             Diff3Line& d3l = *(*d->m_pDiff3LineVector)[i];
             if(d3l.linesNeededForDisplay() < linesNeeded)
             {
                 Q_ASSERT(wrapLineVectorSize == 0);
                 d3l.setLinesNeeded(linesNeeded);
             }
 
             if(wrapLineVectorSize > 0)
             {
                 int j;
                 for(j = 0; j < d3l.linesNeededForDisplay(); ++j, ++wrapLineIdx)
                 {
                     Diff3WrapLine& d3wl = d->m_diff3WrapLineVector[wrapLineIdx];
                     d3wl.diff3LineIndex = i;
                     d3wl.pD3L = (*d->m_pDiff3LineVector)[i];
                     if(j >= linesNeeded)
                     {
                         d3wl.wrapLineOffset = 0;
                         d3wl.wrapLineLength = 0;
                     }
                 }
             }
         }
 
         if(wrapLineVectorSize > 0)
         {
             d->m_firstLine = std::min(d->m_firstLine, wrapLineVectorSize - 1);
             d->m_horizScrollOffset = 0;
 
             Q_EMIT firstLineChanged(d->m_firstLine);
         }
     }
     else // no word wrap, just calc the maximum text width
     {
         if(g_pProgressDialog->wasCancelled())
             return;
         int size = d->m_pDiff3LineVector->size();
         int firstD3LineIdx = cacheListIdx * s_linesPerRunnable;
         int endIdx = std::min(firstD3LineIdx + s_linesPerRunnable, size);
 
         int maxTextWidth = getAtomic(d->m_maxTextWidth); // current value
         QTextLayout textLayout(QString(), font(), this);
         for(int i = firstD3LineIdx; i < endIdx; ++i)
         {
             if(g_pProgressDialog->wasCancelled())
                 return;
             textLayout.clearLayout();
             textLayout.setText(d->getString(i));
             d->prepareTextLayout(textLayout);
             if(textLayout.maximumWidth() > maxTextWidth)
                 maxTextWidth = qCeil(textLayout.maximumWidth());
         }
 
         for(;;)
         {
             int prevMaxTextWidth = d->m_maxTextWidth.fetchAndStoreOrdered(maxTextWidth);
             if(prevMaxTextWidth <= maxTextWidth)
                 break;
             maxTextWidth = prevMaxTextWidth;
         }
     }
 
     if(!d->m_selection.isEmpty() && (!d->m_bWordWrap || wrapLineVectorSize > 0))
     {
         // Assume unwrapped coordinates
         //( Why? ->Conversion to unwrapped coords happened a few lines above in this method.
         //  Also see KDiff3App::recalcWordWrap() on the role of wrapLineVectorSize)
 
         // Wrap them now.
 
         // convert the d->m_selection to unwrapped coordinates.
         int firstLine, firstPos;
         convertD3LCoordsToLineCoords(d->m_selection.beginLine(), d->m_selection.beginPos(), firstLine, firstPos);
 
         int lastLine, lastPos;
         convertD3LCoordsToLineCoords(d->m_selection.endLine(), d->m_selection.endPos(), lastLine, lastPos);
 
         d->m_selection.start(firstLine, firstPos);
         d->m_selection.end(lastLine, lastPos);
     }
 }
 
 class DiffTextWindowFrameData
 {
   public:
     DiffTextWindowFrameData(DiffTextWindowFrame* frame, const QSharedPointer<Options>& pOptions, const e_SrcSelector winIdx)
     {
         m_winIdx = winIdx;
 
         m_pOptions = pOptions;
         m_pTopLineWidget = new QWidget(frame);
         m_pFileSelection = new FileNameLineEdit(m_pTopLineWidget);
         m_pBrowseButton = new QPushButton("...", m_pTopLineWidget);
         m_pBrowseButton->setFixedWidth(30);
 
         m_pFileSelection->setAcceptDrops(true);
 
         m_pLabel = new QLabel("A:", m_pTopLineWidget);
         m_pTopLine = new QLabel(m_pTopLineWidget);
     }
 
     const QPushButton* getBrowseButton() const { return m_pBrowseButton; }
     const FileNameLineEdit* getFileSelectionField() const { return m_pFileSelection; }
     const QWidget* getTopLineWidget() const { return m_pTopLineWidget; }
     const QLabel* getLabel() const { return m_pLabel; }
 
     const QSharedPointer<Options> getOptions() { return m_pOptions; }
 
   private:
     friend DiffTextWindowFrame;
     DiffTextWindow* m_pDiffTextWindow;
     FileNameLineEdit* m_pFileSelection;
     QPushButton* m_pBrowseButton;
     QSharedPointer<Options> m_pOptions;
     QLabel* m_pLabel;
     QLabel* m_pTopLine;
     QLabel* m_pEncoding;
     QLabel* m_pLineEndStyle;
     QWidget* m_pTopLineWidget;
     e_SrcSelector m_winIdx;
 
     QSharedPointer<SourceData> mSourceData;
 };
 
 DiffTextWindowFrame::DiffTextWindowFrame(QWidget* pParent, const QSharedPointer<Options>& pOptions, e_SrcSelector winIdx, QSharedPointer<SourceData> psd)
     : QWidget(pParent)
 {
     d = new DiffTextWindowFrameData(this, pOptions, winIdx);
     d->mSourceData = psd;
     setAutoFillBackground(true);
     connect(d->getBrowseButton(), &QPushButton::clicked, this, &DiffTextWindowFrame::slotBrowseButtonClicked);
     connect(d->getFileSelectionField(), &QLineEdit::returnPressed, this, &DiffTextWindowFrame::slotReturnPressed);
 
     d->m_pDiffTextWindow = new DiffTextWindow(this, pOptions, winIdx);
     d->m_pDiffTextWindow->setSourceData(psd);
     QVBoxLayout* pVTopLayout = new QVBoxLayout(const_cast<QWidget*>(d->getTopLineWidget()));
     pVTopLayout->setMargin(2);
     pVTopLayout->setSpacing(0);
     QHBoxLayout* pHL = new QHBoxLayout();
     QHBoxLayout* pHL2 = new QHBoxLayout();
     pVTopLayout->addLayout(pHL);
     pVTopLayout->addLayout(pHL2);
 
     // Upper line:
     pHL->setMargin(0);
     pHL->setSpacing(2);
 
     pHL->addWidget(const_cast<QLabel*>(d->getLabel()), 0);
     pHL->addWidget(const_cast<FileNameLineEdit*>(d->getFileSelectionField()), 1);
     pHL->addWidget(const_cast<QPushButton*>(d->getBrowseButton()), 0);
     pHL->addWidget(d->m_pTopLine, 0);
 
     // Lower line
     pHL2->setMargin(0);
     pHL2->setSpacing(2);
     pHL2->addWidget(d->m_pTopLine, 0);
     d->m_pEncoding = new EncodingLabel(i18n("Encoding:"), psd, pOptions);
     //EncodeLabel::EncodingChanged should be handled asyncroniously.
     connect((EncodingLabel*)d->m_pEncoding, &EncodingLabel::encodingChanged, this, &DiffTextWindowFrame::slotEncodingChanged, Qt::QueuedConnection);
 
     d->m_pLineEndStyle = new QLabel(i18n("Line end style:"));
     pHL2->addWidget(d->m_pEncoding);
     pHL2->addWidget(d->m_pLineEndStyle);
 
     QVBoxLayout* pVL = new QVBoxLayout(this);
     pVL->setMargin(0);
     pVL->setSpacing(0);
     pVL->addWidget(const_cast<QWidget*>(d->getTopLineWidget()), 0);
     pVL->addWidget(d->m_pDiffTextWindow, 1);
 
     d->m_pDiffTextWindow->installEventFilter(this);
     d->m_pFileSelection->installEventFilter(this);
     d->m_pBrowseButton->installEventFilter(this);
     init();
 }
 
 DiffTextWindowFrame::~DiffTextWindowFrame()
 {
     delete d;
 }
 
 void DiffTextWindowFrame::init()
 {
     DiffTextWindow* pDTW = d->m_pDiffTextWindow;
     if(pDTW)
     {
         QString s = QDir::toNativeSeparators(pDTW->getFileName());
         d->m_pFileSelection->setText(s);
         QString winId = pDTW->getWindowIndex() == e_SrcSelector::A ? (pDTW->isThreeWay() ? i18n("A (Base)") : i18n("A")) : (pDTW->getWindowIndex() == e_SrcSelector::B ? i18n("B") : i18n("C"));
         d->m_pLabel->setText(winId + ':');
         d->m_pEncoding->setText(i18n("Encoding: %1", pDTW->getEncodingDisplayString()));
         d->m_pLineEndStyle->setText(i18n("Line end style: %1", pDTW->getLineEndStyle() == eLineEndStyleDos ? i18n("DOS") : i18n("Unix")));
     }
 }
 
 void DiffTextWindowFrame::setupConnections(const KDiff3App* app)
 {
     connect(this, &DiffTextWindowFrame::fileNameChanged, app, &KDiff3App::slotFileNameChanged);
     connect(this, &DiffTextWindowFrame::encodingChanged, app, &KDiff3App::slotEncodingChanged);
     connect(this, &DiffTextWindowFrame::encodingChanged, d->mSourceData.data(), &SourceData::setEncoding);
 }
 
 // Search for the first visible line (search loop needed when no line exists for this file.)
 LineRef DiffTextWindow::calcTopLineInFile(const LineRef firstLine)
 {
     LineRef currentLine;
     for(int i = convertLineToDiff3LineIdx(firstLine); i < (int)d->m_pDiff3LineVector->size(); ++i)
     {
         const Diff3Line* d3l = (*d->m_pDiff3LineVector)[i];
         currentLine = d3l->getLineInFile(d->m_winIdx);
         if(currentLine.isValid()) break;
     }
     return currentLine;
 }
 
 void DiffTextWindowFrame::setFirstLine(QtNumberType firstLine)
 {
     DiffTextWindow* pDTW = d->m_pDiffTextWindow;
     if(pDTW && pDTW->getDiff3LineVector())
     {
         QString s = i18n("Top line");
         int lineNumberWidth = pDTW->getLineNumberWidth();
 
         LineRef topVisiableLine = pDTW->calcTopLineInFile(firstLine);
 
         int w = Utils::getHorizontalAdvance(d->m_pTopLine->fontMetrics(), s + ' ' + QString().fill('0', lineNumberWidth));
         d->m_pTopLine->setMinimumWidth(w);
 
         if(!topVisiableLine.isValid())
             s = i18n("End");
         else
             s += ' ' + QString::number(topVisiableLine + 1);
 
         d->m_pTopLine->setText(s);
         d->m_pTopLine->repaint();
     }
 }
 
 DiffTextWindow* DiffTextWindowFrame::getDiffTextWindow()
 {
     return d->m_pDiffTextWindow;
 }
 
 bool DiffTextWindowFrame::eventFilter(QObject* o, QEvent* e)
 {
     Q_UNUSED(o);
     if(e->type() == QEvent::FocusIn || e->type() == QEvent::FocusOut)
     {
         QColor c1 = d->getOptions()->m_bgColor;
         QColor c2;
         if(d->m_winIdx == e_SrcSelector::A)
             c2 = d->getOptions()->m_colorA;
         else if(d->m_winIdx == e_SrcSelector::B)
             c2 = d->getOptions()->m_colorB;
         else if(d->m_winIdx == e_SrcSelector::C)
             c2 = d->getOptions()->m_colorC;
 
         QPalette p = d->m_pTopLineWidget->palette();
         if(e->type() == QEvent::FocusOut)
             std::swap(c1, c2);
 
         p.setColor(QPalette::Window, c2);
         setPalette(p);
 
         p.setColor(QPalette::WindowText, c1);
         d->m_pLabel->setPalette(p);
         d->m_pTopLine->setPalette(p);
         d->m_pEncoding->setPalette(p);
         d->m_pLineEndStyle->setPalette(p);
     }
 
     return false;
 }
 
 void DiffTextWindowFrame::slotReturnPressed()
 {
     DiffTextWindow* pDTW = d->m_pDiffTextWindow;
     if(pDTW->getFileName() != d->m_pFileSelection->text())
     {
         Q_EMIT fileNameChanged(d->m_pFileSelection->text(), pDTW->getWindowIndex());
     }
 }
 
 void DiffTextWindowFrame::slotBrowseButtonClicked()
 {
     QString current = d->m_pFileSelection->text();
 
     QUrl newURL = QFileDialog::getOpenFileUrl(this, i18n("Open File"), QUrl::fromUserInput(current, QString(), QUrl::AssumeLocalFile));
     if(!newURL.isEmpty())
     {
         DiffTextWindow* pDTW = d->m_pDiffTextWindow;
         Q_EMIT fileNameChanged(newURL.url(), pDTW->getWindowIndex());
     }
 }
 
 EncodingLabel::EncodingLabel(const QString& text, QSharedPointer<SourceData> pSD, const QSharedPointer<Options>& pOptions)
     : QLabel(text)
 {
     m_pOptions = pOptions;
     m_pSourceData = pSD;
     m_pContextEncodingMenu = nullptr;
     setMouseTracking(true);
 }
 
 void EncodingLabel::mouseMoveEvent(QMouseEvent*)
 {
     // When there is no data to display or it came from clipboard,
     // we will be use UTF-8 only,
     // in that case there is no possibility to change the encoding in the SourceData
     // so, we should hide the HandCursor and display usual ArrowCursor
     if(m_pSourceData->isFromBuffer() || m_pSourceData->isEmpty())
         setCursor(QCursor(Qt::ArrowCursor));
     else
         setCursor(QCursor(Qt::PointingHandCursor));
 }
 
 void EncodingLabel::mousePressEvent(QMouseEvent*)
 {
     if(!(m_pSourceData->isFromBuffer() || m_pSourceData->isEmpty()))
     {
         delete m_pContextEncodingMenu;
         m_pContextEncodingMenu = new QMenu(this);
         QMenu* pContextEncodingSubMenu = new QMenu(m_pContextEncodingMenu);
 
         int currentTextCodecEnum = m_pSourceData->getEncoding()->mibEnum(); // the codec that will be checked in the context menu
         QList<int> mibs = QTextCodec::availableMibs();
         QList<int> codecEnumList;
 
         // Adding "main" encodings
         insertCodec(i18n("Unicode, 8 bit"), QTextCodec::codecForName("UTF-8"), codecEnumList, m_pContextEncodingMenu, currentTextCodecEnum);
         if(QTextCodec::codecForName("System"))
         {
             insertCodec(QString(), QTextCodec::codecForName("System"), codecEnumList, m_pContextEncodingMenu, currentTextCodecEnum);
         }
 
         // Adding recent encodings
         if(m_pOptions != nullptr)
         {
             QStringList& recentEncodings = m_pOptions->m_recentEncodings;
             for(const QString& s : recentEncodings)
             {
                 insertCodec("", QTextCodec::codecForName(s.toLatin1()), codecEnumList, m_pContextEncodingMenu, currentTextCodecEnum);
             }
         }
         // Submenu to add the rest of available encodings
         pContextEncodingSubMenu->setTitle(i18n("Other"));
         for(int i : mibs)
         {
             QTextCodec* c = QTextCodec::codecForMib(i);
             if(c != nullptr)
                 insertCodec("", c, codecEnumList, pContextEncodingSubMenu, currentTextCodecEnum);
         }
 
         m_pContextEncodingMenu->addMenu(pContextEncodingSubMenu);
 
         m_pContextEncodingMenu->exec(QCursor::pos());
     }
 }
 
 void EncodingLabel::insertCodec(const QString& visibleCodecName, QTextCodec* pCodec, QList<int>& codecEnumList, QMenu* pMenu, int currentTextCodecEnum) const
 {
     int CodecMIBEnum = pCodec->mibEnum();
     if(pCodec != nullptr && !codecEnumList.contains(CodecMIBEnum))
     {
         QAction* pAction = new QAction(pMenu); // menu takes ownership, so deleting the menu deletes the action too.
         QByteArray nameArray = pCodec->name();
         QLatin1String codecName = QLatin1String(nameArray);
 
         pAction->setText(visibleCodecName.isEmpty() ? codecName : visibleCodecName + QLatin1String(" (") + codecName + QLatin1String(")"));
         pAction->setData(CodecMIBEnum);
         pAction->setCheckable(true);
         if(currentTextCodecEnum == CodecMIBEnum)
             pAction->setChecked(true);
         pMenu->addAction(pAction);
         connect(pAction, &QAction::triggered, this, &EncodingLabel::slotSelectEncoding);
         codecEnumList.append(CodecMIBEnum);
     }
 }
 
 void EncodingLabel::slotSelectEncoding()
 {
     QAction* pAction = qobject_cast<QAction*>(sender());
     if(pAction)
     {
         QTextCodec* pCodec = QTextCodec::codecForMib(pAction->data().toInt());
         if(pCodec != nullptr)
         {
             QString s(QLatin1String(pCodec->name()));
             QStringList& recentEncodings = m_pOptions->m_recentEncodings;
             if(!recentEncodings.contains(s) && s != "UTF-8" && s != "System")
             {
                 int itemsToRemove = recentEncodings.size() - m_maxRecentEncodings + 1;
                 for(int i = 0; i < itemsToRemove; ++i)
                 {
                     recentEncodings.removeFirst();
                 }
                 recentEncodings.append(s);
             }
         }
 
         Q_EMIT encodingChanged(pCodec);
     }
 }
diff --git a/src/difftextwindow.h b/src/difftextwindow.h
index 8ceceeb..e3c6a39 100644
--- a/src/difftextwindow.h
+++ b/src/difftextwindow.h
@@ -1,208 +1,206 @@
 /*
  * KDiff3 - Text Diff And Merge Tool
- * 
+ *
  * SPDX-FileCopyrightText: 2002-2011 Joachim Eibl, joachim.eibl at gmx.de
  * SPDX-FileCopyrightText: 2018-2020 Michael Reeves reeves.87@gmail.com
  * SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #ifndef DIFFTEXTWINDOW_H
 #define DIFFTEXTWINDOW_H
 
 #include "diff.h"
 
 #include <QLabel>
 #include <QSharedPointer>  // for QSharedPointer
 #include <QString>         // for QString
 
 class QMenu;
 class RecalcWordWrapRunnable;
 class QScrollBar;
 class QStatusBar;
 class Options;
 class DiffTextWindowData;
 class DiffTextWindowFrame;
 class EncodingLabel;
 class RLPainter;
 
 class KDiff3App;
 
 class DiffTextWindow : public QWidget
 {
     Q_OBJECT
   public:
     //Using this as a scoped global
     static QScrollBar* mVScrollBar;
-    
+
     DiffTextWindow(DiffTextWindowFrame* pParent, const QSharedPointer<Options> &pOptions, e_SrcSelector winIdx);
     ~DiffTextWindow() override;
     void init(
         const QString& fileName,
         QTextCodec* pTextCodec,
         e_LineEndStyle eLineEndStyle,
         const QVector<LineData>* pLineData,
         int size,
         const Diff3LineVector* pDiff3LineVector,
         const ManualDiffHelpList* pManualDiffHelpList
     );
 
     void setupConnections(const KDiff3App *app) const;
 
     void reset();
     void convertToLinePos(int x, int y, LineRef& line, int& pos);
 
     QString getSelection();
     int getFirstLine();
     LineRef calcTopLineInFile(const LineRef firstLine);
 
     int getMaxTextWidth();
     LineCount getNofLines();
     int getNofVisibleLines();
     int getVisibleTextAreaWidth();
 
     int convertLineToDiff3LineIdx(LineRef line);
     LineRef convertDiff3LineIdxToLine(int d3lIdx);
 
     void convertD3LCoordsToLineCoords(int d3LIdx, int d3LPos, int& line, int& pos);
     void convertLineCoordsToD3LCoords(int line, int pos, int& d3LIdx, int& d3LPos);
 
     void convertSelectionToD3LCoords();
 
     bool findString(const QString& s, LineRef& d3vLine, int& posInLine, bool bDirDown, bool bCaseSensitive);
     void setSelection(LineRef firstLine, int startPos, LineRef lastLine, int endPos, LineRef& l, int& p);
     void getSelectionRange(LineRef* firstLine, LineRef* lastLine, e_CoordType coordType);
 
     void setPaintingAllowed(bool bAllowPainting);
     void recalcWordWrap(bool bWordWrap, int wrapLineVectorSize, int visibleTextWidth);
     void recalcWordWrapHelper(int wrapLineVectorSize, int visibleTextWidth, int cacheListIdx);
 
     void printWindow(RLPainter& painter, const QRect& view, const QString& headerText, int line, int linesPerPage, const QColor& fgColor);
     void print(RLPainter& painter, const QRect& r, int firstLine, int nofLinesPerPage);
 
     static bool startRunnables();
 
     bool isThreeWay() const;
     const QString& getFileName() const;
 
     e_SrcSelector getWindowIndex() const;
-    
+
     const QString getEncodingDisplayString() const;
     e_LineEndStyle getLineEndStyle() const;
     const Diff3LineVector* getDiff3LineVector() const;
 
     qint32 getLineNumberWidth() const;
 
     void setSourceData(const QSharedPointer<SourceData>& inData);
   Q_SIGNALS:
     void statusBarMessage(const QString& message);
     void scrollVertically(QtNumberType deltaY);
     void resizeHeightChangedSignal(int nofVisibleLines);
     void resizeWidthChangedSignal(int nofVisibleColumns);
     void scrollDiffTextWindow(int deltaX, int deltaY);
     void newSelection();
     void selectionEnd();
     void setFastSelectorLine(LineIndex line);
     void gotFocus();
     void lineClicked(e_SrcSelector winIdx, LineRef line);
 
     void finishRecalcWordWrap(int visibleTextWidthForPrinting);
 
-    void checkIfCanContinue(bool& pbContinue);
-
     void finishDrop();
 
     void firstLineChanged(QtNumberType firstLine);
   public Q_SLOTS:
     void setFirstLine(QtNumberType line);
     void setHorizScrollOffset(int horizScrollOffset);
     void resetSelection();
     void setFastSelectorRange(int line1, int nofLines);
     void slotRefresh();
 
     void slotSelectAll();
 
   protected:
     void mousePressEvent(QMouseEvent*) override;
     void mouseReleaseEvent(QMouseEvent*) override;
     void mouseMoveEvent(QMouseEvent*) override;
     void mouseDoubleClickEvent(QMouseEvent* e) override;
 
     void wheelEvent(QWheelEvent*) override;
 
     void paintEvent(QPaintEvent*) override;
     void dragEnterEvent(QDragEnterEvent* e) override;
 
     void dropEvent(QDropEvent* dropEvent) override;
     void focusInEvent(QFocusEvent* e) override;
 
     void resizeEvent(QResizeEvent*) override;
     void timerEvent(QTimerEvent*) override;
 
   private:
     static QList<RecalcWordWrapRunnable*> s_runnables;
     static constexpr int s_linesPerRunnable = 2000;
 
     DiffTextWindowData* d;
     void showStatusLine(const LineRef lineFromPos);
 };
 
 class DiffTextWindowFrameData;
 
 class DiffTextWindowFrame : public QWidget
 {
     Q_OBJECT
   public:
     DiffTextWindowFrame(QWidget* pParent, const QSharedPointer<Options> &pOptions, e_SrcSelector winIdx, QSharedPointer<SourceData> psd);
     ~DiffTextWindowFrame() override;
     DiffTextWindow* getDiffTextWindow();
     void init();
 
     void setupConnections(const KDiff3App *app);
 
   Q_SIGNALS:
     void fileNameChanged(const QString&, e_SrcSelector);
     void encodingChanged(QTextCodec*);
 
   public Q_SLOTS:
     void setFirstLine(QtNumberType firstLine);
 
   protected:
     bool eventFilter(QObject*, QEvent*) override;
     //void paintEvent(QPaintEvent*);
   private Q_SLOTS:
     void slotReturnPressed();
     void slotBrowseButtonClicked();
 
     void slotEncodingChanged(QTextCodec* c) { Q_EMIT encodingChanged(c); };//relay signal from encoding label
 
 
   private:
     DiffTextWindowFrameData* d;
 };
 
 class EncodingLabel : public QLabel
 {
     Q_OBJECT
   public:
     EncodingLabel(const QString& text, QSharedPointer<SourceData> psd, const QSharedPointer<Options> &pOptions);
 
   protected:
     void mouseMoveEvent(QMouseEvent* ev) override;
     void mousePressEvent(QMouseEvent* ev) override;
 
   Q_SIGNALS:
     void encodingChanged(QTextCodec*);
 
   private Q_SLOTS:
     void slotSelectEncoding();
 
   private:
     QMenu* m_pContextEncodingMenu;
     QSharedPointer<SourceData> m_pSourceData; //SourceData to get access to "isEmpty()" and "isFromBuffer()" functions
     static const int m_maxRecentEncodings = 5;
     QSharedPointer<Options> m_pOptions;
 
     void insertCodec(const QString& visibleCodecName, QTextCodec* pCodec, QList<int>& CodecEnumList, QMenu* pMenu, int currentTextCodecEnum) const;
 };
 
 #endif
diff --git a/src/directorymergewindow.cpp b/src/directorymergewindow.cpp
index cb9c209..24c6036 100644
--- a/src/directorymergewindow.cpp
+++ b/src/directorymergewindow.cpp
@@ -1,3072 +1,3067 @@
 /*
  * KDiff3 - Text Diff And Merge Tool
  *
  * SPDX-FileCopyrightText: 2002-2011 Joachim Eibl, joachim.eibl at gmx.de
  * SPDX-FileCopyrightText: 2018-2020 Michael Reeves reeves.87@gmail.com
  * SPDX-License-Identifier: GPL-2.0-or-later
 */
 #include "directorymergewindow.h"
 
 #include "DirectoryInfo.h"
 #include "MergeFileInfos.h"
 #include "PixMapUtils.h"
 #include "Utils.h"
 #include "guiutils.h"
 #include "kdiff3.h"
 #include "options.h"
 #include "progress.h"
 
 #include <algorithm>
 #include <map>
 #include <vector>
 
 #include <QAction>
 #include <QApplication>
 #include <QDialogButtonBox>
 #include <QDir>
 #include <QElapsedTimer>
 #include <QFileDialog>
 #include <QImage>
 #include <QKeyEvent>
 #include <QLabel>
 #include <QLayout>
 #include <QMenu>
 #include <QPainter>
 #include <QPushButton>
 #include <QRegExp>
 #include <QSplitter>
 #include <QStyledItemDelegate>
 #include <QTextStream>
 
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KTextEdit>
 #include <KToggleAction>
 
 struct DirectoryMergeWindow::t_ItemInfo {
     bool bExpanded;
     bool bOperationComplete;
     QString status;
     e_MergeOperation eMergeOperation;
 };
 
 class StatusInfo : public QDialog
 {
   private:
     KTextEdit* m_pTextEdit;
 
   public:
     explicit StatusInfo(QWidget* pParent)
         : QDialog(pParent)
     {
         QVBoxLayout* pVLayout = new QVBoxLayout(this);
         m_pTextEdit = new KTextEdit(this);
         pVLayout->addWidget(m_pTextEdit);
         setObjectName("StatusInfo");
         setWindowFlags(Qt::Dialog);
         m_pTextEdit->setWordWrapMode(QTextOption::NoWrap);
         m_pTextEdit->setReadOnly(true);
         QDialogButtonBox* box = new QDialogButtonBox(QDialogButtonBox::Close, this);
         connect(box, &QDialogButtonBox::rejected, this, &QDialog::accept);
         pVLayout->addWidget(box);
     }
 
     bool isEmpty()
     {
         return m_pTextEdit->toPlainText().isEmpty();
     }
 
     void addText(const QString& s)
     {
         m_pTextEdit->append(s);
     }
 
     void clear()
     {
         m_pTextEdit->clear();
     }
 
     void setVisible(bool bVisible) override
     {
         if(bVisible)
         {
             m_pTextEdit->moveCursor(QTextCursor::End);
             m_pTextEdit->moveCursor(QTextCursor::StartOfLine);
             m_pTextEdit->ensureCursorVisible();
         }
 
         QDialog::setVisible(bVisible);
         if(bVisible)
             setWindowState(windowState() | Qt::WindowMaximized);
     }
 };
 
 enum Columns
 {
     s_NameCol = 0,
     s_ACol = 1,
     s_BCol = 2,
     s_CCol = 3,
     s_OpCol = 4,
     s_OpStatusCol = 5,
     s_UnsolvedCol = 6, // Nr of unsolved conflicts (for 3 input files)
     s_SolvedCol = 7,   // Nr of auto-solvable conflicts (for 3 input files)
     s_NonWhiteCol = 8, // Nr of nonwhite deltas (for 2 input files)
     s_WhiteCol = 9     // Nr of white deltas (for 2 input files)
 };
 
 static Qt::CaseSensitivity s_eCaseSensitivity = Qt::CaseSensitive;
 
 //TODO: clean up this mess.
 class DirectoryMergeWindow::DirectoryMergeWindowPrivate : public QAbstractItemModel
 {
     friend class DirMergeItem;
 
   public:
     DirectoryMergeWindow* mWindow;
     explicit DirectoryMergeWindowPrivate(DirectoryMergeWindow* pDMW)
     {
         mWindow = pDMW;
         m_pStatusInfo = new StatusInfo(mWindow);
         m_pStatusInfo->hide();
     }
     ~DirectoryMergeWindowPrivate() override
     {
         delete m_pRoot;
     }
     // Implement QAbstractItemModel
     QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
     //Qt::ItemFlags flags ( const QModelIndex & index ) const
     QModelIndex parent(const QModelIndex& index) const override
     {
         MergeFileInfos* pMFI = getMFI(index);
         if(pMFI == nullptr || pMFI == m_pRoot || pMFI->parent() == m_pRoot)
             return QModelIndex();
 
         MergeFileInfos* pParentsParent = pMFI->parent()->parent();
         return createIndex(pParentsParent->children().indexOf(pMFI->parent()), 0, pMFI->parent());
     }
     int rowCount(const QModelIndex& parent = QModelIndex()) const override
     {
         MergeFileInfos* pParentMFI = getMFI(parent);
         if(pParentMFI != nullptr)
             return pParentMFI->children().count();
         else
             return m_pRoot->children().count();
     }
     int columnCount(const QModelIndex& /*parent*/) const override
     {
         return 10;
     }
     QModelIndex index(int row, int column, const QModelIndex& parent) const override
     {
         MergeFileInfos* pParentMFI = getMFI(parent);
         if(pParentMFI == nullptr && row < m_pRoot->children().count())
             return createIndex(row, column, m_pRoot->children()[row]);
         else if(pParentMFI != nullptr && row < pParentMFI->children().count())
             return createIndex(row, column, pParentMFI->children()[row]);
         else
             return QModelIndex();
     }
     QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
     void sort(int column, Qt::SortOrder order) override;
     // private data and helper methods
     MergeFileInfos* getMFI(const QModelIndex& mi) const
     {
         if(mi.isValid())
             return (MergeFileInfos*)mi.internalPointer();
         else
             return nullptr;
     }
 
     bool isThreeWay() const
     {
         if(rootMFI() == nullptr) return false;
         return rootMFI()->isThreeWay();
     }
     MergeFileInfos* rootMFI() const { return m_pRoot; }
 
     QSharedPointer<Options> m_pOptions = nullptr;
 
     void calcDirStatus(bool bThreeDirs, const QModelIndex& mi,
                        int& nofFiles, int& nofDirs, int& nofEqualFiles, int& nofManualMerges);
 
     void mergeContinue(bool bStart, bool bVerbose);
 
     void prepareListView(ProgressProxy& pp);
     void calcSuggestedOperation(const QModelIndex& mi, e_MergeOperation eDefaultMergeOp);
     void setAllMergeOperations(e_MergeOperation eDefaultOperation);
 
     bool canContinue();
     QModelIndex treeIterator(QModelIndex mi, bool bVisitChildren = true, bool bFindInvisible = false);
     void prepareMergeStart(const QModelIndex& miBegin, const QModelIndex& miEnd, bool bVerbose);
     bool executeMergeOperation(MergeFileInfos& mfi, bool& bSingleFileMerge);
 
     void scanDirectory(const QString& dirName, t_DirectoryList& dirList);
     void scanLocalDirectory(const QString& dirName, t_DirectoryList& dirList);
 
     void setMergeOperation(const QModelIndex& mi, e_MergeOperation eMergeOp, bool bRecursive = true);
     bool isDir(const QModelIndex& mi) const;
     QString getFileName(const QModelIndex& mi) const;
 
     bool copyFLD(const QString& srcName, const QString& destName);
     bool deleteFLD(const QString& name, bool bCreateBackup);
     bool makeDir(const QString& name, bool bQuiet = false);
     bool renameFLD(const QString& srcName, const QString& destName);
     bool mergeFLD(const QString& nameA, const QString& nameB, const QString& nameC,
                   const QString& nameDest, bool& bSingleFileMerge);
 
     void buildMergeMap(const QSharedPointer<DirectoryInfo>& dirInfo);
 
   private:
     class FileKey
     {
       private:
         const FileAccess* m_pFA;
 
       public:
         explicit FileKey(const FileAccess& fa)
             : m_pFA(&fa) {}
 
         quint32 getParents(const FileAccess* pFA, const FileAccess* v[], quint32 maxSize) const
         {
             quint32 s = 0;
             for(s = 0; pFA->parent() != nullptr; pFA = pFA->parent(), ++s)
             {
                 if(s == maxSize)
                     break;
                 v[s] = pFA;
             }
             return s;
         }
 
         // This is essentially the same as
         // int r = filePath().compare( fa.filePath() )
         // if ( r<0 ) return true;
         // if ( r==0 ) return m_col < fa.m_col;
         // return false;
         bool operator<(const FileKey& fk) const
         {
             const FileAccess* v1[100];
             const FileAccess* v2[100];
             quint32 v1Size = getParents(m_pFA, v1, 100);
             quint32 v2Size = getParents(fk.m_pFA, v2, 100);
 
             for(quint32 i = 0; i < v1Size && i < v2Size; ++i)
             {
                 int r = v1[v1Size - i - 1]->fileName().compare(v2[v2Size - i - 1]->fileName(), s_eCaseSensitivity);
                 if(r < 0)
                     return true;
                 else if(r > 0)
                     return false;
             }
 
             return v1Size < v2Size;
         }
     };
 
     typedef QMap<FileKey, MergeFileInfos> t_fileMergeMap;
 
     MergeFileInfos* m_pRoot = new MergeFileInfos();
 
     t_fileMergeMap m_fileMergeMap;
 
   public:
     bool m_bFollowDirLinks = false;
     bool m_bFollowFileLinks = false;
     bool m_bSimulatedMergeStarted = false;
     bool m_bRealMergeStarted = false;
     bool m_bError = false;
     bool m_bSyncMode = false;
     bool m_bDirectoryMerge = false; // if true, then merge is the default operation, otherwise it's diff.
     bool m_bCaseSensitive = true;
     bool m_bUnfoldSubdirs = false;
     bool m_bSkipDirStatus = false;
     bool m_bScanning = false; // true while in init()
 
     DirectoryMergeInfo* m_pDirectoryMergeInfo = nullptr;
     StatusInfo* m_pStatusInfo = nullptr;
 
     typedef std::list<QModelIndex> MergeItemList; // linked list
     MergeItemList m_mergeItemList;
     MergeItemList::iterator m_currentIndexForOperation;
 
     QModelIndex m_selection1Index;
     QModelIndex m_selection2Index;
     QModelIndex m_selection3Index;
     void selectItemAndColumn(const QModelIndex& mi, bool bContextMenu);
 
     QPointer<QAction> m_pDirStartOperation;
     QPointer<QAction> m_pDirRunOperationForCurrentItem;
     QPointer<QAction> m_pDirCompareCurrent;
     QPointer<QAction> m_pDirMergeCurrent;
     QPointer<QAction> m_pDirRescan;
     QPointer<QAction> m_pDirChooseAEverywhere;
     QPointer<QAction> m_pDirChooseBEverywhere;
     QPointer<QAction> m_pDirChooseCEverywhere;
     QPointer<QAction> m_pDirAutoChoiceEverywhere;
     QPointer<QAction> m_pDirDoNothingEverywhere;
     QPointer<QAction> m_pDirFoldAll;
     QPointer<QAction> m_pDirUnfoldAll;
 
     KToggleAction* m_pDirShowIdenticalFiles;
     KToggleAction* m_pDirShowDifferentFiles;
     KToggleAction* m_pDirShowFilesOnlyInA;
     KToggleAction* m_pDirShowFilesOnlyInB;
     KToggleAction* m_pDirShowFilesOnlyInC;
 
     KToggleAction* m_pDirSynchronizeDirectories;
     KToggleAction* m_pDirChooseNewerFiles;
 
     QPointer<QAction> m_pDirCompareExplicit;
     QPointer<QAction> m_pDirMergeExplicit;
 
     QPointer<QAction> m_pDirCurrentDoNothing;
     QPointer<QAction> m_pDirCurrentChooseA;
     QPointer<QAction> m_pDirCurrentChooseB;
     QPointer<QAction> m_pDirCurrentChooseC;
     QPointer<QAction> m_pDirCurrentMerge;
     QPointer<QAction> m_pDirCurrentDelete;
 
     QPointer<QAction> m_pDirCurrentSyncDoNothing;
     QPointer<QAction> m_pDirCurrentSyncCopyAToB;
     QPointer<QAction> m_pDirCurrentSyncCopyBToA;
     QPointer<QAction> m_pDirCurrentSyncDeleteA;
     QPointer<QAction> m_pDirCurrentSyncDeleteB;
     QPointer<QAction> m_pDirCurrentSyncDeleteAAndB;
     QPointer<QAction> m_pDirCurrentSyncMergeToA;
     QPointer<QAction> m_pDirCurrentSyncMergeToB;
     QPointer<QAction> m_pDirCurrentSyncMergeToAAndB;
 
     QPointer<QAction> m_pDirSaveMergeState;
     QPointer<QAction> m_pDirLoadMergeState;
 
     bool init(const QSharedPointer<DirectoryInfo>& dirInfo, bool bDirectoryMerge, bool bReload);
     void setOpStatus(const QModelIndex& mi, e_OperationStatus eOpStatus)
     {
         if(MergeFileInfos* pMFI = getMFI(mi))
         {
             pMFI->setOpStatus(eOpStatus);
             Q_EMIT dataChanged(mi, mi);
         }
     }
 
     QModelIndex nextSibling(const QModelIndex& mi);
 };
 
 QVariant DirectoryMergeWindow::DirectoryMergeWindowPrivate::data(const QModelIndex& index, int role) const
 {
     MergeFileInfos* pMFI = getMFI(index);
     if(pMFI)
     {
         if(role == Qt::DisplayRole)
         {
             switch(index.column())
             {
                 case s_NameCol:
                     return QFileInfo(pMFI->subPath()).fileName();
                 case s_ACol:
                     return i18n("A");
                 case s_BCol:
                     return i18n("B");
                 case s_CCol:
                     return i18n("C");
                 //case s_OpCol:       return i18n("Operation");
                 //case s_OpStatusCol: return i18n("Status");
                 case s_UnsolvedCol:
                     return pMFI->diffStatus().getUnsolvedConflicts();
                 case s_SolvedCol:
                     return pMFI->diffStatus().getSolvedConflicts();
                 case s_NonWhiteCol:
                     return pMFI->diffStatus().getNonWhitespaceConflicts();
                 case s_WhiteCol:
                     return pMFI->diffStatus().getWhitespaceConflicts();
                     //default :           return QVariant();
             }
 
             if(s_OpCol == index.column())
             {
                 bool bDir = pMFI->hasDir();
                 switch(pMFI->getOperation())
                 {
                     case eNoOperation:
                         return "";
                         break;
                     case eCopyAToB:
                         return i18n("Copy A to B");
                         break;
                     case eCopyBToA:
                         return i18n("Copy B to A");
                         break;
                     case eDeleteA:
                         return i18n("Delete A");
                         break;
                     case eDeleteB:
                         return i18n("Delete B");
                         break;
                     case eDeleteAB:
                         return i18n("Delete A & B");
                         break;
                     case eMergeToA:
                         return i18n("Merge to A");
                         break;
                     case eMergeToB:
                         return i18n("Merge to B");
                         break;
                     case eMergeToAB:
                         return i18n("Merge to A & B");
                         break;
                     case eCopyAToDest:
                         return i18n("A");
                         break;
                     case eCopyBToDest:
                         return i18n("B");
                         break;
                     case eCopyCToDest:
                         return i18n("C");
                         break;
                     case eDeleteFromDest:
                         return i18n("Delete (if exists)");
                         break;
                     case eMergeABCToDest:
                     case eMergeABToDest:
                         return bDir ? i18n("Merge") : i18n("Merge (manual)");
                         break;
                     case eConflictingFileTypes:
                         return i18n("Error: Conflicting File Types");
                         break;
                     case eChangedAndDeleted:
                         return i18n("Error: Changed and Deleted");
                         break;
                     case eConflictingAges:
                         return i18n("Error: Dates are equal but files are not.");
                         break;
                     default:
                         Q_ASSERT(true);
                         break;
                 }
             }
             if(s_OpStatusCol == index.column())
             {
                 switch(pMFI->getOpStatus())
                 {
                     case eOpStatusNone:
                         return "";
                     case eOpStatusDone:
                         return i18n("Done");
                     case eOpStatusError:
                         return i18n("Error");
                     case eOpStatusSkipped:
                         return i18n("Skipped.");
                     case eOpStatusNotSaved:
                         return i18n("Not saved.");
                     case eOpStatusInProgress:
                         return i18n("In progress...");
                     case eOpStatusToDo:
                         return i18n("To do.");
                 }
             }
         }
         else if(role == Qt::DecorationRole)
         {
             if(s_NameCol == index.column())
             {
                 return PixMapUtils::getOnePixmap(eAgeEnd, pMFI->hasLink(), pMFI->hasDir());
             }
 
             if(s_ACol == index.column())
             {
                 return PixMapUtils::getOnePixmap(pMFI->getAgeA(), pMFI->isLinkA(), pMFI->isDirA());
             }
             if(s_BCol == index.column())
             {
                 return PixMapUtils::getOnePixmap(pMFI->getAgeB(), pMFI->isLinkB(), pMFI->isDirB());
             }
             if(s_CCol == index.column())
             {
                 return PixMapUtils::getOnePixmap(pMFI->getAgeC(), pMFI->isLinkC(), pMFI->isDirC());
             }
         }
         else if(role == Qt::TextAlignmentRole)
         {
             if(s_UnsolvedCol == index.column() || s_SolvedCol == index.column() || s_NonWhiteCol == index.column() || s_WhiteCol == index.column())
                 return Qt::AlignRight;
         }
     }
     return QVariant();
 }
 
 QVariant DirectoryMergeWindow::DirectoryMergeWindowPrivate::headerData(int section, Qt::Orientation orientation, int role) const
 {
     if(orientation == Qt::Horizontal && section >= 0 && section < columnCount(QModelIndex()) && role == Qt::DisplayRole)
     {
         switch(section)
         {
             case s_NameCol:
                 return i18n("Name");
             case s_ACol:
                 return i18n("A");
             case s_BCol:
                 return i18n("B");
             case s_CCol:
                 return i18n("C");
             case s_OpCol:
                 return i18n("Operation");
             case s_OpStatusCol:
                 return i18n("Status");
             case s_UnsolvedCol:
                 return i18n("Unsolved");
             case s_SolvedCol:
                 return i18n("Solved");
             case s_NonWhiteCol:
                 return i18n("Nonwhite");
             case s_WhiteCol:
                 return i18n("White");
             default:
                 return QVariant();
         }
     }
     return QVariant();
 }
 
 int DirectoryMergeWindow::getIntFromIndex(const QModelIndex& index) const
 {
     return index == d->m_selection1Index ? 1 : index == d->m_selection2Index ? 2 : index == d->m_selection3Index ? 3 : 0;
 }
 
 const QSharedPointer<Options>& DirectoryMergeWindow::getOptions() const
 {
     return d->m_pOptions;
 }
 
 // Previously  Q3ListViewItem::paintCell(p,cg,column,width,align);
 class DirectoryMergeWindow::DirMergeItemDelegate : public QStyledItemDelegate
 {
   private:
     DirectoryMergeWindow* m_pDMW;
     const QSharedPointer<Options>& getOptions() const { return m_pDMW->getOptions(); }
 
   public:
     explicit DirMergeItemDelegate(DirectoryMergeWindow* pParent)
         : QStyledItemDelegate(pParent), m_pDMW(pParent)
     {
     }
     void paint(QPainter* thePainter, const QStyleOptionViewItem& option, const QModelIndex& index) const override
     {
         QtNumberType column = index.column();
         if(column == s_ACol || column == s_BCol || column == s_CCol)
         {
             QVariant value = index.data(Qt::DecorationRole);
             QPixmap icon;
             if(value.isValid())
             {
                 if(value.type() == QVariant::Icon)
                 {
                     icon = qvariant_cast<QIcon>(value).pixmap(16, 16);
                     //icon = qvariant_cast<QIcon>(value);
                     //decorationRect = QRect(QPoint(0, 0), icon.actualSize(option.decorationSize, iconMode, iconState));
                 }
                 else
                 {
                     icon = qvariant_cast<QPixmap>(value);
                     //decorationRect = QRect(QPoint(0, 0), option.decorationSize).intersected(pixmap.rect());
                 }
             }
 
             int x = option.rect.left();
             int y = option.rect.top();
             //QPixmap icon = value.value<QPixmap>(); //pixmap(column);
             if(!icon.isNull())
             {
                 int yOffset = (sizeHint(option, index).height() - icon.height()) / 2;
                 thePainter->drawPixmap(x + 2, y + yOffset, icon);
 
                 int i = m_pDMW->getIntFromIndex(index);
                 if(i != 0)
                 {
                     QColor c(i == 1 ? getOptions()->m_colorA : i == 2 ? getOptions()->m_colorB : getOptions()->m_colorC);
                     thePainter->setPen(c); // highlight() );
                     thePainter->drawRect(x + 2, y + yOffset, icon.width(), icon.height());
                     thePainter->setPen(QPen(c, 0, Qt::DotLine));
                     thePainter->drawRect(x + 1, y + yOffset - 1, icon.width() + 2, icon.height() + 2);
                     thePainter->setPen(Qt::white);
                     QString s(QChar('A' + i - 1));
 
                     thePainter->drawText(x + 2 + (icon.width() - Utils::getHorizontalAdvance(thePainter->fontMetrics(), s)) / 2,
                                          y + yOffset + (icon.height() + thePainter->fontMetrics().ascent()) / 2 - 1,
                                          s);
                 }
                 else
                 {
                     thePainter->setPen(m_pDMW->palette().window().color());
                     thePainter->drawRect(x + 1, y + yOffset - 1, icon.width() + 2, icon.height() + 2);
                 }
                 return;
             }
         }
 
         QStyleOptionViewItem option2 = option;
         if(column >= s_UnsolvedCol)
         {
             option2.displayAlignment = Qt::AlignRight;
         }
         QStyledItemDelegate::paint(thePainter, option2, index);
     }
     QSize sizeHint(const QStyleOptionViewItem& option, const QModelIndex& index) const override
     {
         QSize sz = QStyledItemDelegate::sizeHint(option, index);
         return sz.expandedTo(QSize(0, 18));
     }
 };
 
 DirectoryMergeWindow::DirectoryMergeWindow(QWidget* pParent, const QSharedPointer<Options>& pOptions)
     : QTreeView(pParent)
 {
     d = new DirectoryMergeWindowPrivate(this);
     setModel(d);
     setItemDelegate(new DirMergeItemDelegate(this));
     connect(this, &DirectoryMergeWindow::doubleClicked, this, &DirectoryMergeWindow::onDoubleClick);
     connect(this, &DirectoryMergeWindow::expanded, this, &DirectoryMergeWindow::onExpanded);
 
     d->m_pOptions = pOptions;
 
     setSortingEnabled(true);
 }
 
 DirectoryMergeWindow::~DirectoryMergeWindow()
 {
     delete d;
 }
 
 void DirectoryMergeWindow::setDirectoryMergeInfo(DirectoryMergeInfo* p)
 {
     d->m_pDirectoryMergeInfo = p;
 }
 bool DirectoryMergeWindow::isDirectoryMergeInProgress()
 {
     return d->m_bRealMergeStarted;
 }
 bool DirectoryMergeWindow::isSyncMode()
 {
     return d->m_bSyncMode;
 }
 bool DirectoryMergeWindow::isScanning()
 {
     return d->m_bScanning;
 }
 
 int DirectoryMergeWindow::totalColumnWidth()
 {
     int w = 0;
     for(int i = 0; i < s_OpStatusCol; ++i)
     {
         w += columnWidth(i);
     }
     return w;
 }
 
 void DirectoryMergeWindow::reload()
 {
     if(isDirectoryMergeInProgress())
     {
         int result = KMessageBox::warningYesNo(this,
                                                i18n("You are currently doing a folder merge. Are you sure, you want to abort the merge and rescan the folder?"),
                                                i18n("Warning"),
                                                KGuiItem(i18n("Rescan")),
                                                KGuiItem(i18n("Continue Merging")));
         if(result != KMessageBox::Yes)
             return;
     }
 
     init(d->rootMFI()->getDirectoryInfo(), true);
     //fix file visibilities after reload or menu will be out of sync with display if changed from defaults.
     updateFileVisibilities();
 }
 
 void DirectoryMergeWindow::DirectoryMergeWindowPrivate::calcDirStatus(bool bThreeDirs, const QModelIndex& mi,
                                                                       int& nofFiles, int& nofDirs, int& nofEqualFiles, int& nofManualMerges)
 {
     MergeFileInfos* pMFI = getMFI(mi);
     if(pMFI->hasDir())
     {
         ++nofDirs;
     }
     else
     {
         ++nofFiles;
         if(pMFI->isEqualAB() && (!bThreeDirs || pMFI->isEqualAC()))
         {
             ++nofEqualFiles;
         }
         else
         {
             if(pMFI->getOperation() == eMergeABCToDest || pMFI->getOperation() == eMergeABToDest)
                 ++nofManualMerges;
         }
     }
     for(int childIdx = 0; childIdx < rowCount(mi); ++childIdx)
         calcDirStatus(bThreeDirs, index(childIdx, 0, mi), nofFiles, nofDirs, nofEqualFiles, nofManualMerges);
 }
 
 bool DirectoryMergeWindow::init(
     const QSharedPointer<DirectoryInfo>& dirInfo,
     bool bDirectoryMerge,
     bool bReload)
 {
     return d->init(dirInfo, bDirectoryMerge, bReload);
 }
 
 void DirectoryMergeWindow::DirectoryMergeWindowPrivate::buildMergeMap(const QSharedPointer<DirectoryInfo>& dirInfo)
 {
     t_DirectoryList::iterator dirIterator;
 
     if(dirInfo->dirA().isValid())
     {
         for(dirIterator = dirInfo->getDirListA().begin(); dirIterator != dirInfo->getDirListA().end(); ++dirIterator)
         {
             MergeFileInfos& mfi = m_fileMergeMap[FileKey(*dirIterator)];
 
             mfi.setFileInfoA(&(*dirIterator));
             mfi.setDirectoryInfo(dirInfo);
         }
     }
 
     if(dirInfo->dirB().isValid())
     {
         for(dirIterator = dirInfo->getDirListB().begin(); dirIterator != dirInfo->getDirListB().end(); ++dirIterator)
         {
             MergeFileInfos& mfi = m_fileMergeMap[FileKey(*dirIterator)];
 
             mfi.setFileInfoB(&(*dirIterator));
             mfi.setDirectoryInfo(dirInfo);
         }
     }
 
     if(dirInfo->dirC().isValid())
     {
         for(dirIterator = dirInfo->getDirListC().begin(); dirIterator != dirInfo->getDirListC().end(); ++dirIterator)
         {
             MergeFileInfos& mfi = m_fileMergeMap[FileKey(*dirIterator)];
 
             mfi.setFileInfoC(&(*dirIterator));
             mfi.setDirectoryInfo(dirInfo);
         }
     }
 }
 
 bool DirectoryMergeWindow::DirectoryMergeWindowPrivate::init(
     const QSharedPointer<DirectoryInfo>& dirInfo,
     bool bDirectoryMerge,
     bool bReload)
 {
     //set root data now that we have the directory info.
     rootMFI()->setDirectoryInfo(dirInfo);
 
     if(m_pOptions->m_bDmFullAnalysis)
     {
         // A full analysis uses the same resources that a normal text-diff/merge uses.
         // So make sure that the user saves his data first.
-        bool bCanContinue = false;
-        Q_EMIT mWindow->checkIfCanContinue(bCanContinue);
-        if(!bCanContinue)
+        if(!KDiff3App::shouldContinue())
             return false;
         Q_EMIT mWindow->startDiffMerge("", "", "", "", "", "", "", nullptr); // hide main window
     }
 
     mWindow->show();
     mWindow->setUpdatesEnabled(true);
 
     std::map<QString, t_ItemInfo> expandedDirsMap;
 
     if(bReload)
     {
         // Remember expanded items TODO
         //QTreeWidgetItemIterator it( this );
         //while ( *it )
         //{
         //   DirMergeItem* pDMI = static_cast<DirMergeItem*>( *it );
         //   t_ItemInfo& ii = expandedDirsMap[ pDMI->m_pMFI->subPath() ];
         //   ii.bExpanded = pDMI->isExpanded();
         //   ii.bOperationComplete = pDMI->m_pMFI->m_bOperationComplete;
         //   ii.status = pDMI->text( s_OpStatusCol );
         //   ii.eMergeOperation = pDMI->m_pMFI->getOperation();
         //   ++it;
         //}
     }
 
     ProgressProxy pp;
     m_bFollowDirLinks = m_pOptions->m_bDmFollowDirLinks;
     m_bFollowFileLinks = m_pOptions->m_bDmFollowFileLinks;
     m_bSimulatedMergeStarted = false;
     m_bRealMergeStarted = false;
     m_bError = false;
     m_bDirectoryMerge = bDirectoryMerge;
     m_selection1Index = QModelIndex();
     m_selection2Index = QModelIndex();
     m_selection3Index = QModelIndex();
     m_bCaseSensitive = m_pOptions->m_bDmCaseSensitiveFilenameComparison;
     m_bUnfoldSubdirs = m_pOptions->m_bDmUnfoldSubdirs;
     m_bSkipDirStatus = m_pOptions->m_bDmSkipDirStatus;
 
     beginResetModel();
     m_pRoot->clear();
     m_mergeItemList.clear();
     endResetModel();
 
     m_currentIndexForOperation = m_mergeItemList.end();
 
     if(!bReload)
     {
         m_pDirShowIdenticalFiles->setChecked(true);
         m_pDirShowDifferentFiles->setChecked(true);
         m_pDirShowFilesOnlyInA->setChecked(true);
         m_pDirShowFilesOnlyInB->setChecked(true);
         m_pDirShowFilesOnlyInC->setChecked(true);
     }
     Q_ASSERT(dirInfo != nullptr);
     FileAccess dirA = dirInfo->dirA();
     FileAccess dirB = dirInfo->dirB();
     FileAccess dirC = dirInfo->dirC();
     const FileAccess dirDest = dirInfo->destDir();
     // Check if all input directories exist and are valid. The dest dir is not tested now.
     // The test will happen only when we are going to write to it.
     if(!dirA.isDir() || !dirB.isDir() ||
        (dirC.isValid() && !dirC.isDir()))
     {
         QString text(i18n("Opening of folders failed:"));
         text += "\n\n";
         if(!dirA.isDir())
         {
             text += i18n("Folder A \"%1\" does not exist or is not a folder.\n", dirA.prettyAbsPath());
         }
 
         if(!dirB.isDir())
         {
             text += i18n("Folder B \"%1\" does not exist or is not a folder.\n", dirB.prettyAbsPath());
         }
 
         if(dirC.isValid() && !dirC.isDir())
         {
             text += i18n("Folder C \"%1\" does not exist or is not a folder.\n", dirC.prettyAbsPath());
         }
 
         KMessageBox::sorry(mWindow, text, i18n("Folder Opening Error"));
         return false;
     }
 
     if(dirC.isValid() &&
        (dirDest.prettyAbsPath() == dirA.prettyAbsPath() || dirDest.prettyAbsPath() == dirB.prettyAbsPath()))
     {
         KMessageBox::error(mWindow,
                            i18n("The destination folder must not be the same as A or B when "
                                 "three folders are merged.\nCheck again before continuing."),
                            i18n("Parameter Warning"));
         return false;
     }
 
     m_bScanning = true;
     Q_EMIT mWindow->statusBarMessage(i18n("Scanning folders..."));
 
     m_bSyncMode = m_pOptions->m_bDmSyncMode && dirInfo->allowSyncMode();
 
     m_fileMergeMap.clear();
     s_eCaseSensitivity = m_bCaseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive;
     // calc how many directories will be read:
     double nofScans = (dirA.isValid() ? 1 : 0) + (dirB.isValid() ? 1 : 0) + (dirC.isValid() ? 1 : 0);
     int currentScan = 0;
 
     //TODO   setColumnWidthMode(s_UnsolvedCol, Q3ListView::Manual);
     //   setColumnWidthMode(s_SolvedCol,   Q3ListView::Manual);
     //   setColumnWidthMode(s_WhiteCol,    Q3ListView::Manual);
     //   setColumnWidthMode(s_NonWhiteCol, Q3ListView::Manual);
     mWindow->setColumnHidden(s_CCol, !dirC.isValid());
     mWindow->setColumnHidden(s_WhiteCol, !m_pOptions->m_bDmFullAnalysis);
     mWindow->setColumnHidden(s_NonWhiteCol, !m_pOptions->m_bDmFullAnalysis);
     mWindow->setColumnHidden(s_UnsolvedCol, !m_pOptions->m_bDmFullAnalysis);
     mWindow->setColumnHidden(s_SolvedCol, !(m_pOptions->m_bDmFullAnalysis && dirC.isValid()));
 
     bool bListDirSuccessA = true;
     bool bListDirSuccessB = true;
     bool bListDirSuccessC = true;
 
     if(dirA.isValid())
     {
         pp.setInformation(i18n("Reading Folder A"));
         pp.setSubRangeTransformation(currentScan / nofScans, (currentScan + 1) / nofScans);
         ++currentScan;
 
         bListDirSuccessA = dirInfo->listDirA(*m_pOptions);
     }
 
     if(dirB.isValid())
     {
         pp.setInformation(i18n("Reading Folder B"));
         pp.setSubRangeTransformation(currentScan / nofScans, (currentScan + 1) / nofScans);
         ++currentScan;
 
         bListDirSuccessB = dirInfo->listDirB(*m_pOptions);
     }
 
     e_MergeOperation eDefaultMergeOp;
     if(dirC.isValid())
     {
         pp.setInformation(i18n("Reading Folder C"));
         pp.setSubRangeTransformation(currentScan / nofScans, (currentScan + 1) / nofScans);
         ++currentScan;
 
         bListDirSuccessC = dirInfo->listDirC(*m_pOptions);
 
         eDefaultMergeOp = eMergeABCToDest;
     }
     else
         eDefaultMergeOp = m_bSyncMode ? eMergeToAB : eMergeABToDest;
 
     buildMergeMap(dirInfo);
 
     bool bContinue = true;
     if(!bListDirSuccessA || !bListDirSuccessB || !bListDirSuccessC)
     {
         QString s = i18n("Some subfolders were not readable in");
         if(!bListDirSuccessA) s += "\nA: " + dirA.prettyAbsPath();
         if(!bListDirSuccessB) s += "\nB: " + dirB.prettyAbsPath();
         if(!bListDirSuccessC) s += "\nC: " + dirC.prettyAbsPath();
         s += '\n';
         s += i18n("Check the permissions of the subfolders.");
         bContinue = KMessageBox::Continue == KMessageBox::warningContinueCancel(mWindow, s);
     }
 
     if(bContinue)
     {
         prepareListView(pp);
 
         mWindow->updateFileVisibilities();
 
         for(int childIdx = 0; childIdx < rowCount(); ++childIdx)
         {
             QModelIndex mi = index(childIdx, 0, QModelIndex());
             calcSuggestedOperation(mi, eDefaultMergeOp);
         }
     }
 
     mWindow->sortByColumn(0, Qt::AscendingOrder);
 
     for(int column = 0; column < columnCount(QModelIndex()); ++column)
         mWindow->resizeColumnToContents(column);
 
     // Try to improve the view a little bit.
     QWidget* pParent = mWindow->parentWidget();
     QSplitter* pSplitter = static_cast<QSplitter*>(pParent);
     if(pSplitter != nullptr)
     {
         QList<int> sizes = pSplitter->sizes();
         int total = sizes[0] + sizes[1];
         if(total < 10)
             total = 100;
         sizes[0] = total * 6 / 10;
         sizes[1] = total - sizes[0];
         pSplitter->setSizes(sizes);
     }
 
     m_bScanning = false;
     Q_EMIT mWindow->statusBarMessage(i18n("Ready."));
 
     if(bContinue && !m_bSkipDirStatus)
     {
         // Generate a status report
         int nofFiles = 0;
         int nofDirs = 0;
         int nofEqualFiles = 0;
         int nofManualMerges = 0;
         //TODO
         for(int childIdx = 0; childIdx < rowCount(); ++childIdx)
             calcDirStatus(dirC.isValid(), index(childIdx, 0, QModelIndex()),
                           nofFiles, nofDirs, nofEqualFiles, nofManualMerges);
 
         QString s;
         s = i18n("Folder Comparison Status\n\n"
                  "Number of subfolders: %1\n"
                  "Number of equal files: %2\n"
                  "Number of different files: %3",
                  nofDirs, nofEqualFiles, nofFiles - nofEqualFiles);
 
         if(dirC.isValid())
             s += '\n' + i18n("Number of manual merges: %1", nofManualMerges);
         KMessageBox::information(mWindow, s);
         //
         //TODO
         //if ( topLevelItemCount()>0 )
         //{
         //   topLevelItem(0)->setSelected(true);
         //   setCurrentItem( topLevelItem(0) );
         //}
     }
 
     if(bReload)
     {
         // Remember expanded items
         //TODO
         //QTreeWidgetItemIterator it( this );
         //while ( *it )
         //{
         //   DirMergeItem* pDMI = static_cast<DirMergeItem*>( *it );
         //   std::map<QString,t_ItemInfo>::iterator i = expandedDirsMap.find( pDMI->m_pMFI->subPath() );
         //   if ( i!=expandedDirsMap.end() )
         //   {
         //      t_ItemInfo& ii = i->second;
         //      pDMI->setExpanded( ii.bExpanded );
         //      //pDMI->m_pMFI->setMergeOperation( ii.eMergeOperation, false ); unsafe, might have changed
         //      pDMI->m_pMFI->m_bOperationComplete = ii.bOperationComplete;
         //      pDMI->setText( s_OpStatusCol, ii.status );
         //   }
         //   ++it;
         //}
     }
     else if(m_bUnfoldSubdirs)
     {
         m_pDirUnfoldAll->trigger();
     }
 
     return true;
 }
 
 inline QString DirectoryMergeWindow::getDirNameA() const
 {
     return d->rootMFI()->getDirectoryInfo()->dirA().prettyAbsPath();
 }
 inline QString DirectoryMergeWindow::getDirNameB() const
 {
     return d->rootMFI()->getDirectoryInfo()->dirB().prettyAbsPath();
 }
 inline QString DirectoryMergeWindow::getDirNameC() const
 {
     return d->rootMFI()->getDirectoryInfo()->dirC().prettyAbsPath();
 }
 inline QString DirectoryMergeWindow::getDirNameDest() const
 {
     return d->rootMFI()->getDirectoryInfo()->destDir().prettyAbsPath();
 }
 
 void DirectoryMergeWindow::onExpanded()
 {
     resizeColumnToContents(s_NameCol);
 }
 
 void DirectoryMergeWindow::slotChooseAEverywhere()
 {
     d->setAllMergeOperations(eCopyAToDest);
 }
 
 void DirectoryMergeWindow::slotChooseBEverywhere()
 {
     d->setAllMergeOperations(eCopyBToDest);
 }
 
 void DirectoryMergeWindow::slotChooseCEverywhere()
 {
     d->setAllMergeOperations(eCopyCToDest);
 }
 
 void DirectoryMergeWindow::slotAutoChooseEverywhere()
 {
     e_MergeOperation eDefaultMergeOp = d->isThreeWay() ? eMergeABCToDest : d->m_bSyncMode ? eMergeToAB : eMergeABToDest;
     d->setAllMergeOperations(eDefaultMergeOp);
 }
 
 void DirectoryMergeWindow::slotNoOpEverywhere()
 {
     d->setAllMergeOperations(eNoOperation);
 }
 
 void DirectoryMergeWindow::slotFoldAllSubdirs()
 {
     collapseAll();
 }
 
 void DirectoryMergeWindow::slotUnfoldAllSubdirs()
 {
     expandAll();
 }
 
 // Merge current item (merge mode)
 void DirectoryMergeWindow::slotCurrentDoNothing()
 {
     d->setMergeOperation(currentIndex(), eNoOperation);
 }
 void DirectoryMergeWindow::slotCurrentChooseA()
 {
     d->setMergeOperation(currentIndex(), d->m_bSyncMode ? eCopyAToB : eCopyAToDest);
 }
 void DirectoryMergeWindow::slotCurrentChooseB()
 {
     d->setMergeOperation(currentIndex(), d->m_bSyncMode ? eCopyBToA : eCopyBToDest);
 }
 void DirectoryMergeWindow::slotCurrentChooseC()
 {
     d->setMergeOperation(currentIndex(), eCopyCToDest);
 }
 void DirectoryMergeWindow::slotCurrentMerge()
 {
     bool bThreeDirs = d->isThreeWay();
     d->setMergeOperation(currentIndex(), bThreeDirs ? eMergeABCToDest : eMergeABToDest);
 }
 void DirectoryMergeWindow::slotCurrentDelete()
 {
     d->setMergeOperation(currentIndex(), eDeleteFromDest);
 }
 // Sync current item
 void DirectoryMergeWindow::slotCurrentCopyAToB()
 {
     d->setMergeOperation(currentIndex(), eCopyAToB);
 }
 void DirectoryMergeWindow::slotCurrentCopyBToA()
 {
     d->setMergeOperation(currentIndex(), eCopyBToA);
 }
 void DirectoryMergeWindow::slotCurrentDeleteA()
 {
     d->setMergeOperation(currentIndex(), eDeleteA);
 }
 void DirectoryMergeWindow::slotCurrentDeleteB()
 {
     d->setMergeOperation(currentIndex(), eDeleteB);
 }
 void DirectoryMergeWindow::slotCurrentDeleteAAndB()
 {
     d->setMergeOperation(currentIndex(), eDeleteAB);
 }
 void DirectoryMergeWindow::slotCurrentMergeToA()
 {
     d->setMergeOperation(currentIndex(), eMergeToA);
 }
 void DirectoryMergeWindow::slotCurrentMergeToB()
 {
     d->setMergeOperation(currentIndex(), eMergeToB);
 }
 void DirectoryMergeWindow::slotCurrentMergeToAAndB()
 {
     d->setMergeOperation(currentIndex(), eMergeToAB);
 }
 
 void DirectoryMergeWindow::keyPressEvent(QKeyEvent* e)
 {
     if((e->QInputEvent::modifiers() & Qt::ControlModifier) != 0)
     {
         MergeFileInfos* pMFI = d->getMFI(currentIndex());
         if(pMFI == nullptr)
             return;
 
         bool bThreeDirs = pMFI->isThreeWay();
         bool bMergeMode = bThreeDirs || !d->m_bSyncMode;
         bool bFTConflict = pMFI == nullptr ? false : pMFI->conflictingFileTypes();
 
         if(bMergeMode)
         {
             switch(e->key())
             {
                 case Qt::Key_1:
                     if(pMFI->existsInA())
                     {
                         slotCurrentChooseA();
                     }
                     return;
                 case Qt::Key_2:
                     if(pMFI->existsInB())
                     {
                         slotCurrentChooseB();
                     }
                     return;
                 case Qt::Key_3:
                     if(pMFI->existsInC())
                     {
                         slotCurrentChooseC();
                     }
                     return;
                 case Qt::Key_Space:
                     slotCurrentDoNothing();
                     return;
                 case Qt::Key_4:
                     if(!bFTConflict)
                     {
                         slotCurrentMerge();
                     }
                     return;
                 case Qt::Key_Delete:
                     slotCurrentDelete();
                     return;
                 default:
                     break;
             }
         }
         else
         {
             switch(e->key())
             {
                 case Qt::Key_1:
                     if(pMFI->existsInA())
                     {
                         slotCurrentCopyAToB();
                     }
                     return;
                 case Qt::Key_2:
                     if(pMFI->existsInB())
                     {
                         slotCurrentCopyBToA();
                     }
                     return;
                 case Qt::Key_Space:
                     slotCurrentDoNothing();
                     return;
                 case Qt::Key_4:
                     if(!bFTConflict)
                     {
                         slotCurrentMergeToAAndB();
                     }
                     return;
                 case Qt::Key_Delete:
                     if(pMFI->existsInA() && pMFI->existsInB())
                         slotCurrentDeleteAAndB();
                     else if(pMFI->existsInA())
                         slotCurrentDeleteA();
                     else if(pMFI->existsInB())
                         slotCurrentDeleteB();
                     return;
                 default:
                     break;
             }
         }
     }
     else if(e->key() == Qt::Key_Return || e->key() == Qt::Key_Enter)
     {
         onDoubleClick(currentIndex());
         return;
     }
 
     QTreeView::keyPressEvent(e);
 }
 
 void DirectoryMergeWindow::focusInEvent(QFocusEvent*)
 {
     Q_EMIT updateAvailabilities();
 }
 void DirectoryMergeWindow::focusOutEvent(QFocusEvent*)
 {
     Q_EMIT updateAvailabilities();
 }
 
 void DirectoryMergeWindow::DirectoryMergeWindowPrivate::setAllMergeOperations(e_MergeOperation eDefaultOperation)
 {
     if(KMessageBox::Yes == KMessageBox::warningYesNo(mWindow,
                                                      i18n("This affects all merge operations."),
                                                      i18n("Changing All Merge Operations"),
                                                      KStandardGuiItem::cont(),
                                                      KStandardGuiItem::cancel()))
     {
         for(int i = 0; i < rowCount(); ++i)
         {
             calcSuggestedOperation(index(i, 0, QModelIndex()), eDefaultOperation);
         }
     }
 }
 
 QModelIndex DirectoryMergeWindow::DirectoryMergeWindowPrivate::nextSibling(const QModelIndex& mi)
 {
     QModelIndex miParent = mi.parent();
     int currentIdx = mi.row();
     if(currentIdx + 1 < mi.model()->rowCount(miParent))
         return mi.model()->index(mi.row() + 1, 0, miParent); // next child of parent
     return QModelIndex();
 }
 
 // Iterate through the complete tree. Start by specifying QListView::firstChild().
 QModelIndex DirectoryMergeWindow::DirectoryMergeWindowPrivate::treeIterator(QModelIndex mi, bool bVisitChildren, bool bFindInvisible)
 {
     if(mi.isValid())
     {
         do
         {
             if(bVisitChildren && mi.model()->rowCount(mi) != 0)
                 mi = mi.model()->index(0, 0, mi);
             else
             {
                 QModelIndex miNextSibling = nextSibling(mi);
                 if(miNextSibling.isValid())
                     mi = miNextSibling;
                 else
                 {
                     mi = mi.parent();
                     while(mi.isValid())
                     {
                         miNextSibling = nextSibling(mi);
                         if(miNextSibling.isValid())
                         {
                             mi = miNextSibling;
                             break;
                         }
                         else
                         {
                             mi = mi.parent();
                         }
                     }
                 }
             }
         } while(mi.isValid() && mWindow->isRowHidden(mi.row(), mi.parent()) && !bFindInvisible);
     }
     return mi;
 }
 
 void DirectoryMergeWindow::DirectoryMergeWindowPrivate::prepareListView(ProgressProxy& pp)
 {
     QStringList errors;
     //TODO   clear();
     PixMapUtils::initPixmaps(m_pOptions->m_newestFileColor, m_pOptions->m_oldestFileColor,
                              m_pOptions->m_midAgeFileColor, m_pOptions->m_missingFileColor);
 
     mWindow->setRootIsDecorated(true);
 
     t_fileMergeMap::iterator j;
     int nrOfFiles = m_fileMergeMap.size();
     int currentIdx = 1;
     QElapsedTimer t;
     t.start();
     pp.setMaxNofSteps(nrOfFiles);
 
     for(j = m_fileMergeMap.begin(); j != m_fileMergeMap.end(); ++j)
     {
         MergeFileInfos& mfi = j.value();
 
         // const QString& fileName = j->first;
         const QString& fileName = mfi.subPath();
 
         pp.setInformation(
             i18n("Processing %1 / %2\n%3", currentIdx, nrOfFiles, fileName), currentIdx, false);
         if(pp.wasCancelled()) break;
         ++currentIdx;
 
         // The comparisons and calculations for each file take place here.
         mfi.compareFilesAndCalcAges(errors, m_pOptions, mWindow);
         // Get dirname from fileName: Search for "/" from end:
         int pos = fileName.lastIndexOf('/');
         QString dirPart;
         QString filePart;
         if(pos == -1)
         {
             // Top dir
             filePart = fileName;
         }
         else
         {
             dirPart = fileName.left(pos);
             filePart = fileName.mid(pos + 1);
         }
 
         if(dirPart.isEmpty()) // Top level
         {
             m_pRoot->addChild(&mfi); //new DirMergeItem( this, filePart, &mfi );
             mfi.setParent(m_pRoot);
         }
         else
         {
             FileAccess* pFA = mfi.getFileInfoA() ? mfi.getFileInfoA() : mfi.getFileInfoB() ? mfi.getFileInfoB() : mfi.getFileInfoC();
             MergeFileInfos& dirMfi = pFA->parent() ? m_fileMergeMap[FileKey(*pFA->parent())] : *m_pRoot; // parent
 
             dirMfi.addChild(&mfi); //new DirMergeItem( dirMfi.m_pDMI, filePart, &mfi );
             mfi.setParent(&dirMfi);
 
             //   // Equality for parent dirs is set in updateFileVisibilities()
         }
 
         mfi.updateAge();
     }
 
     if(errors.size() > 0)
     {
         if(errors.size() < 15)
         {
             KMessageBox::errorList(mWindow, i18n("Some files could not be processed."), errors);
         }
         else
         {
             KMessageBox::error(mWindow, i18n("Some files could not be processed."));
         }
     }
 
     beginResetModel();
     endResetModel();
 }
 
 void DirectoryMergeWindow::DirectoryMergeWindowPrivate::calcSuggestedOperation(const QModelIndex& mi, e_MergeOperation eDefaultMergeOp)
 {
     MergeFileInfos* pMFI = getMFI(mi);
     if(pMFI == nullptr)
         return;
 
     bool bCheckC = pMFI->isThreeWay();
     bool bCopyNewer = m_pOptions->m_bDmCopyNewer;
     bool bOtherDest = !((pMFI->getDirectoryInfo()->destDir().absoluteFilePath() == pMFI->getDirectoryInfo()->dirA().absoluteFilePath()) ||
                         (pMFI->getDirectoryInfo()->destDir().absoluteFilePath() == pMFI->getDirectoryInfo()->dirB().absoluteFilePath()) ||
                         (bCheckC && pMFI->getDirectoryInfo()->destDir().absoluteFilePath() == pMFI->getDirectoryInfo()->dirC().absoluteFilePath()));
 
     if(eDefaultMergeOp == eMergeABCToDest && !bCheckC)
     {
         eDefaultMergeOp = eMergeABToDest;
     }
     if(eDefaultMergeOp == eMergeToAB && bCheckC)
     {
         Q_ASSERT(true);
     }
 
     if(eDefaultMergeOp == eMergeToA || eDefaultMergeOp == eMergeToB ||
        eDefaultMergeOp == eMergeABCToDest || eDefaultMergeOp == eMergeABToDest || eDefaultMergeOp == eMergeToAB)
     {
         if(!bCheckC)
         {
             if(pMFI->isEqualAB())
             {
                 setMergeOperation(mi, bOtherDest ? eCopyBToDest : eNoOperation);
             }
             else if(pMFI->existsInA() && pMFI->existsInB())
             {
                 if(!bCopyNewer || pMFI->isDirA())
                     setMergeOperation(mi, eDefaultMergeOp);
                 else if(bCopyNewer && pMFI->conflictingAges())
                 {
                     setMergeOperation(mi, eConflictingAges);
                 }
                 else
                 {
                     if(pMFI->getAgeA() == eNew)
                         setMergeOperation(mi, eDefaultMergeOp == eMergeToAB ? eCopyAToB : eCopyAToDest);
                     else
                         setMergeOperation(mi, eDefaultMergeOp == eMergeToAB ? eCopyBToA : eCopyBToDest);
                 }
             }
             else if(!pMFI->existsInA() && pMFI->existsInB())
             {
                 if(eDefaultMergeOp == eMergeABToDest)
                     setMergeOperation(mi, eCopyBToDest);
                 else if(eDefaultMergeOp == eMergeToB)
                     setMergeOperation(mi, eNoOperation);
                 else
                     setMergeOperation(mi, eCopyBToA);
             }
             else if(pMFI->existsInA() && !pMFI->existsInB())
             {
                 if(eDefaultMergeOp == eMergeABToDest)
                     setMergeOperation(mi, eCopyAToDest);
                 else if(eDefaultMergeOp == eMergeToA)
                     setMergeOperation(mi, eNoOperation);
                 else
                     setMergeOperation(mi, eCopyAToB);
             }
             else //if ( !pMFI->existsInA() && !pMFI->existsInB() )
             {
                 setMergeOperation(mi, eNoOperation);
             }
         }
         else
         {
             if(pMFI->isEqualAB() && pMFI->isEqualAC())
             {
                 setMergeOperation(mi, bOtherDest ? eCopyCToDest : eNoOperation);
             }
             else if(pMFI->existsInA() && pMFI->existsInB() && pMFI->existsInC())
             {
                 if(pMFI->isEqualAB() || pMFI->isEqualBC())
                     setMergeOperation(mi, eCopyCToDest);
                 else if(pMFI->isEqualAC())
                     setMergeOperation(mi, eCopyBToDest);
                 else
                     setMergeOperation(mi, eMergeABCToDest);
             }
             else if(pMFI->existsInA() && pMFI->existsInB() && !pMFI->existsInC())
             {
                 if(pMFI->isEqualAB())
                     setMergeOperation(mi, eDeleteFromDest);
                 else
                     setMergeOperation(mi, eChangedAndDeleted);
             }
             else if(pMFI->existsInA() && !pMFI->existsInB() && pMFI->existsInC())
             {
                 if(pMFI->isEqualAC())
                     setMergeOperation(mi, eDeleteFromDest);
                 else
                     setMergeOperation(mi, eChangedAndDeleted);
             }
             else if(!pMFI->existsInA() && pMFI->existsInB() && pMFI->existsInC())
             {
                 if(pMFI->isEqualBC())
                     setMergeOperation(mi, eCopyCToDest);
                 else
                     setMergeOperation(mi, eMergeABCToDest);
             }
             else if(!pMFI->existsInA() && !pMFI->existsInB() && pMFI->existsInC())
             {
                 setMergeOperation(mi, eCopyCToDest);
             }
             else if(!pMFI->existsInA() && pMFI->existsInB() && !pMFI->existsInC())
             {
                 setMergeOperation(mi, eCopyBToDest);
             }
             else if(pMFI->existsInA() && !pMFI->existsInB() && !pMFI->existsInC())
             {
                 setMergeOperation(mi, eDeleteFromDest);
             }
             else //if ( !pMFI->existsInA() && !pMFI->existsInB() && !pMFI->existsInC() )
             {
                 setMergeOperation(mi, eNoOperation);
             }
         }
 
         // Now check if file/dir-types fit.
         if(pMFI->conflictingFileTypes())
         {
             setMergeOperation(mi, eConflictingFileTypes);
         }
     }
     else
     {
         e_MergeOperation eMO = eDefaultMergeOp;
         switch(eDefaultMergeOp)
         {
             case eConflictingFileTypes:
             case eChangedAndDeleted:
             case eConflictingAges:
             case eDeleteA:
             case eDeleteB:
             case eDeleteAB:
             case eDeleteFromDest:
             case eNoOperation:
                 break;
             case eCopyAToB:
                 if(!pMFI->existsInA())
                 {
                     eMO = eDeleteB;
                 }
                 break;
             case eCopyBToA:
                 if(!pMFI->existsInB())
                 {
                     eMO = eDeleteA;
                 }
                 break;
             case eCopyAToDest:
                 if(!pMFI->existsInA())
                 {
                     eMO = eDeleteFromDest;
                 }
                 break;
             case eCopyBToDest:
                 if(!pMFI->existsInB())
                 {
                     eMO = eDeleteFromDest;
                 }
                 break;
             case eCopyCToDest:
                 if(!pMFI->existsInC())
                 {
                     eMO = eDeleteFromDest;
                 }
                 break;
 
             case eMergeToA:
             case eMergeToB:
             case eMergeToAB:
             case eMergeABCToDest:
             case eMergeABToDest:
                 break;
             default:
                 Q_ASSERT(true);
                 break;
         }
         setMergeOperation(mi, eMO);
     }
 }
 
 void DirectoryMergeWindow::onDoubleClick(const QModelIndex& mi)
 {
     if(!mi.isValid())
         return;
 
     d->m_bSimulatedMergeStarted = false;
     if(d->m_bDirectoryMerge)
         mergeCurrentFile();
     else
         compareCurrentFile();
 }
 
 void DirectoryMergeWindow::currentChanged(const QModelIndex& current, const QModelIndex& previous)
 {
     QTreeView::currentChanged(current, previous);
     MergeFileInfos* pMFI = d->getMFI(current);
     if(pMFI == nullptr)
         return;
 
     d->m_pDirectoryMergeInfo->setInfo(pMFI->getDirectoryInfo()->dirA(), pMFI->getDirectoryInfo()->dirB(), pMFI->getDirectoryInfo()->dirC(), pMFI->getDirectoryInfo()->destDir(), *pMFI);
 }
 
 void DirectoryMergeWindow::mousePressEvent(QMouseEvent* e)
 {
     QTreeView::mousePressEvent(e);
     QModelIndex mi = indexAt(e->pos());
     int c = mi.column();
     QPoint p = e->globalPos();
     MergeFileInfos* pMFI = d->getMFI(mi);
     if(pMFI == nullptr)
         return;
 
     if(c == s_OpCol)
     {
         bool bThreeDirs = d->isThreeWay();
 
         QMenu m(this);
         if(bThreeDirs)
         {
             m.addAction(d->m_pDirCurrentDoNothing);
             int count = 0;
             if(pMFI->existsInA())
             {
                 m.addAction(d->m_pDirCurrentChooseA);
                 ++count;
             }
             if(pMFI->existsInB())
             {
                 m.addAction(d->m_pDirCurrentChooseB);
                 ++count;
             }
             if(pMFI->existsInC())
             {
                 m.addAction(d->m_pDirCurrentChooseC);
                 ++count;
             }
             if(!pMFI->conflictingFileTypes() && count > 1) m.addAction(d->m_pDirCurrentMerge);
             m.addAction(d->m_pDirCurrentDelete);
         }
         else if(d->m_bSyncMode)
         {
             m.addAction(d->m_pDirCurrentSyncDoNothing);
             if(pMFI->existsInA()) m.addAction(d->m_pDirCurrentSyncCopyAToB);
             if(pMFI->existsInB()) m.addAction(d->m_pDirCurrentSyncCopyBToA);
             if(pMFI->existsInA()) m.addAction(d->m_pDirCurrentSyncDeleteA);
             if(pMFI->existsInB()) m.addAction(d->m_pDirCurrentSyncDeleteB);
             if(pMFI->existsInA() && pMFI->existsInB())
             {
                 m.addAction(d->m_pDirCurrentSyncDeleteAAndB);
                 if(!pMFI->conflictingFileTypes())
                 {
                     m.addAction(d->m_pDirCurrentSyncMergeToA);
                     m.addAction(d->m_pDirCurrentSyncMergeToB);
                     m.addAction(d->m_pDirCurrentSyncMergeToAAndB);
                 }
             }
         }
         else
         {
             m.addAction(d->m_pDirCurrentDoNothing);
             if(pMFI->existsInA())
             {
                 m.addAction(d->m_pDirCurrentChooseA);
             }
             if(pMFI->existsInB())
             {
                 m.addAction(d->m_pDirCurrentChooseB);
             }
             if(!pMFI->conflictingFileTypes() && pMFI->existsInA() && pMFI->existsInB()) m.addAction(d->m_pDirCurrentMerge);
             m.addAction(d->m_pDirCurrentDelete);
         }
 
         m.exec(p);
     }
     else if(c == s_ACol || c == s_BCol || c == s_CCol)
     {
         QString itemPath;
         if(c == s_ACol && pMFI->existsInA())
         {
             itemPath = pMFI->fullNameA();
         }
         else if(c == s_BCol && pMFI->existsInB())
         {
             itemPath = pMFI->fullNameB();
         }
         else if(c == s_CCol && pMFI->existsInC())
         {
             itemPath = pMFI->fullNameC();
         }
 
         if(!itemPath.isEmpty())
         {
             d->selectItemAndColumn(mi, e->button() == Qt::RightButton);
         }
     }
 }
 
 #ifndef QT_NO_CONTEXTMENU
 void DirectoryMergeWindow::contextMenuEvent(QContextMenuEvent* e)
 {
     QModelIndex mi = indexAt(e->pos());
     int c = mi.column();
 
     MergeFileInfos* pMFI = d->getMFI(mi);
     if(pMFI == nullptr)
         return;
     if(c == s_ACol || c == s_BCol || c == s_CCol)
     {
         QString itemPath;
         if(c == s_ACol && pMFI->existsInA())
         {
             itemPath = pMFI->fullNameA();
         }
         else if(c == s_BCol && pMFI->existsInB())
         {
             itemPath = pMFI->fullNameB();
         }
         else if(c == s_CCol && pMFI->existsInC())
         {
             itemPath = pMFI->fullNameC();
         }
 
         if(!itemPath.isEmpty())
         {
             d->selectItemAndColumn(mi, true);
             QMenu m(this);
             m.addAction(d->m_pDirCompareExplicit);
             m.addAction(d->m_pDirMergeExplicit);
 
             m.popup(e->globalPos());
         }
     }
 }
 #endif
 
 QString DirectoryMergeWindow::DirectoryMergeWindowPrivate::getFileName(const QModelIndex& mi) const
 {
     MergeFileInfos* pMFI = getMFI(mi);
     if(pMFI != nullptr)
     {
         return mi.column() == s_ACol ? pMFI->getFileInfoA()->absoluteFilePath() : mi.column() == s_BCol ? pMFI->getFileInfoB()->absoluteFilePath() : mi.column() == s_CCol ? pMFI->getFileInfoC()->absoluteFilePath() : QString("");
     }
     return QString();
 }
 
 bool DirectoryMergeWindow::DirectoryMergeWindowPrivate::isDir(const QModelIndex& mi) const
 {
     MergeFileInfos* pMFI = getMFI(mi);
     if(pMFI != nullptr)
     {
         return mi.column() == s_ACol ? pMFI->isDirA() : mi.column() == s_BCol ? pMFI->isDirB() : pMFI->isDirC();
     }
     return false;
 }
 
 void DirectoryMergeWindow::DirectoryMergeWindowPrivate::selectItemAndColumn(const QModelIndex& mi, bool bContextMenu)
 {
     if(bContextMenu && (mi == m_selection1Index || mi == m_selection2Index || mi == m_selection3Index))
         return;
 
     QModelIndex old1 = m_selection1Index;
     QModelIndex old2 = m_selection2Index;
     QModelIndex old3 = m_selection3Index;
 
     bool bReset = false;
 
     if(m_selection1Index.isValid())
     {
         if(isDir(m_selection1Index) != isDir(mi))
             bReset = true;
     }
 
     if(bReset || m_selection3Index.isValid() || mi == m_selection1Index || mi == m_selection2Index || mi == m_selection3Index)
     {
         // restart
         m_selection1Index = QModelIndex();
         m_selection2Index = QModelIndex();
         m_selection3Index = QModelIndex();
     }
     else if(!m_selection1Index.isValid())
     {
         m_selection1Index = mi;
         m_selection2Index = QModelIndex();
         m_selection3Index = QModelIndex();
     }
     else if(!m_selection2Index.isValid())
     {
         m_selection2Index = mi;
         m_selection3Index = QModelIndex();
     }
     else if(!m_selection3Index.isValid())
     {
         m_selection3Index = mi;
     }
     if(old1.isValid()) Q_EMIT dataChanged(old1, old1);
     if(old2.isValid()) Q_EMIT dataChanged(old2, old2);
     if(old3.isValid()) Q_EMIT dataChanged(old3, old3);
     if(m_selection1Index.isValid()) Q_EMIT dataChanged(m_selection1Index, m_selection1Index);
     if(m_selection2Index.isValid()) Q_EMIT dataChanged(m_selection2Index, m_selection2Index);
     if(m_selection3Index.isValid()) Q_EMIT dataChanged(m_selection3Index, m_selection3Index);
     Q_EMIT mWindow->updateAvailabilities();
 }
 
 //TODO
 //void DirMergeItem::init(MergeFileInfos* pMFI)
 //{
 //   pMFI->m_pDMI = this; //no not here
 //   m_pMFI = pMFI;
 //   TotalDiffStatus& tds = pMFI->m_totalDiffStatus;
 //   if ( m_pMFI->dirA() || m_pMFI->dirB() || m_pMFI->isDirC() )
 //   {
 //   }
 //   else
 //   {
 //      setText( s_UnsolvedCol, QString::number( tds.getUnsolvedConflicts() ) );
 //      setText( s_SolvedCol,   QString::number( tds.getSolvedConflicts() ) );
 //      setText( s_NonWhiteCol, QString::number( tds.getUnsolvedConflicts() + tds.getSolvedConflicts() - tds.getWhitespaceConflicts() ) );
 //      setText( s_WhiteCol,    QString::number( tds.getWhitespaceConflicts() ) );
 //   }
 //   setSizeHint( s_ACol, QSize(17,17) ); // Iconsize
 //   setSizeHint( s_BCol, QSize(17,17) ); // Iconsize
 //   setSizeHint( s_CCol, QSize(17,17) ); // Iconsize
 //}
 
 void DirectoryMergeWindow::DirectoryMergeWindowPrivate::sort(int column, Qt::SortOrder order)
 {
     Q_UNUSED(column);
     beginResetModel();
     m_pRoot->sort(order);
     endResetModel();
 }
 
 void DirectoryMergeWindow::DirectoryMergeWindowPrivate::setMergeOperation(const QModelIndex& mi, e_MergeOperation eMergeOp, bool bRecursive)
 {
     MergeFileInfos* pMFI = getMFI(mi);
     if(pMFI == nullptr)
         return;
 
     if(eMergeOp != pMFI->getOperation())
     {
         pMFI->startOperation();
         setOpStatus(mi, eOpStatusNone);
     }
 
     pMFI->setOperation(eMergeOp);
     if(bRecursive)
     {
         e_MergeOperation eChildrenMergeOp = pMFI->getOperation();
         if(eChildrenMergeOp == eConflictingFileTypes) eChildrenMergeOp = eMergeABCToDest;
 
         for(int childIdx = 0; childIdx < pMFI->children().count(); ++childIdx)
         {
             calcSuggestedOperation(index(childIdx, 0, mi), eChildrenMergeOp);
         }
     }
 }
 
 void DirectoryMergeWindow::compareCurrentFile()
 {
     if(!d->canContinue()) return;
 
     if(d->m_bRealMergeStarted)
     {
         KMessageBox::sorry(this, i18n("This operation is currently not possible."), i18n("Operation Not Possible"));
         return;
     }
 
     if(MergeFileInfos* pMFI = d->getMFI(currentIndex()))
     {
         if(!(pMFI->hasDir()))
         {
             Q_EMIT startDiffMerge(
                 pMFI->existsInA() ? pMFI->getFileInfoA()->absoluteFilePath() : QString(""),
                 pMFI->existsInB() ? pMFI->getFileInfoB()->absoluteFilePath() : QString(""),
                 pMFI->existsInC() ? pMFI->getFileInfoC()->absoluteFilePath() : QString(""),
                 "",
                 "", "", "", nullptr);
         }
     }
     Q_EMIT updateAvailabilities();
 }
 
 void DirectoryMergeWindow::slotCompareExplicitlySelectedFiles()
 {
     if(!d->isDir(d->m_selection1Index) && !d->canContinue()) return;
 
     if(d->m_bRealMergeStarted)
     {
         KMessageBox::sorry(this, i18n("This operation is currently not possible."), i18n("Operation Not Possible"));
         return;
     }
 
     Q_EMIT startDiffMerge(
         d->getFileName(d->m_selection1Index),
         d->getFileName(d->m_selection2Index),
         d->getFileName(d->m_selection3Index),
         "",
         "", "", "", nullptr);
     d->m_selection1Index = QModelIndex();
     d->m_selection2Index = QModelIndex();
     d->m_selection3Index = QModelIndex();
 
     Q_EMIT updateAvailabilities();
     update();
 }
 
 void DirectoryMergeWindow::slotMergeExplicitlySelectedFiles()
 {
     if(!d->isDir(d->m_selection1Index) && !d->canContinue()) return;
 
     if(d->m_bRealMergeStarted)
     {
         KMessageBox::sorry(this, i18n("This operation is currently not possible."), i18n("Operation Not Possible"));
         return;
     }
 
     QString fn1 = d->getFileName(d->m_selection1Index);
     QString fn2 = d->getFileName(d->m_selection2Index);
     QString fn3 = d->getFileName(d->m_selection3Index);
 
     Q_EMIT startDiffMerge(fn1, fn2, fn3,
                           fn3.isEmpty() ? fn2 : fn3,
                           "", "", "", nullptr);
     d->m_selection1Index = QModelIndex();
     d->m_selection2Index = QModelIndex();
     d->m_selection3Index = QModelIndex();
 
     Q_EMIT updateAvailabilities();
     update();
 }
 
 bool DirectoryMergeWindow::isFileSelected()
 {
     if(MergeFileInfos* pMFI = d->getMFI(currentIndex()))
     {
         return !(pMFI->hasDir() || pMFI->conflictingFileTypes());
     }
     return false;
 }
 
 void DirectoryMergeWindow::mergeResultSaved(const QString& fileName)
 {
     QModelIndex mi = (d->m_mergeItemList.empty() || d->m_currentIndexForOperation == d->m_mergeItemList.end())
                          ? QModelIndex()
                          : *d->m_currentIndexForOperation;
 
     MergeFileInfos* pMFI = d->getMFI(mi);
     if(pMFI == nullptr)
     {
         // This can happen if the same file is saved and modified and saved again. Nothing to do then.
         return;
     }
     if(fileName == pMFI->fullNameDest())
     {
         if(pMFI->getOperation() == eMergeToAB)
         {
             bool bSuccess = d->copyFLD(pMFI->fullNameB(), pMFI->fullNameA());
             if(!bSuccess)
             {
                 KMessageBox::error(this, i18n("An error occurred while copying."));
                 d->m_pStatusInfo->setWindowTitle(i18n("Merge Error"));
                 d->m_pStatusInfo->exec();
                 //if ( m_pStatusInfo->firstChild()!=0 )
                 //   m_pStatusInfo->ensureItemVisible( m_pStatusInfo->last() );
                 d->m_bError = true;
                 d->setOpStatus(mi, eOpStatusError);
                 pMFI->setOperation(eCopyBToA);
                 return;
             }
         }
         d->setOpStatus(mi, eOpStatusDone);
         pMFI->endOperation();
         if(d->m_mergeItemList.size() == 1)
         {
             d->m_mergeItemList.clear();
             d->m_bRealMergeStarted = false;
         }
     }
 
     Q_EMIT updateAvailabilities();
 }
 
 bool DirectoryMergeWindow::DirectoryMergeWindowPrivate::canContinue()
 {
-    bool bCanContinue = false;
-
-    Q_EMIT mWindow->checkIfCanContinue(bCanContinue);
-
-    if(bCanContinue && !m_bError)
+    if(KDiff3App::shouldContinue() && !m_bError)
     {
         QModelIndex mi = (m_mergeItemList.empty() || m_currentIndexForOperation == m_mergeItemList.end()) ? QModelIndex() : *m_currentIndexForOperation;
         MergeFileInfos* pMFI = getMFI(mi);
         if(pMFI && pMFI->isOperationRunning())
         {
             setOpStatus(mi, eOpStatusNotSaved);
             pMFI->endOperation();
             if(m_mergeItemList.size() == 1)
             {
                 m_mergeItemList.clear();
                 m_bRealMergeStarted = false;
             }
         }
+
+        return true;
     }
-    return bCanContinue;
+    return false;
 }
 
 bool DirectoryMergeWindow::DirectoryMergeWindowPrivate::executeMergeOperation(MergeFileInfos& mfi, bool& bSingleFileMerge)
 {
     bool bCreateBackups = m_pOptions->m_bDmCreateBakFiles;
     // First decide destname
     QString destName;
     switch(mfi.getOperation())
     {
         case eNoOperation:
         case eDeleteAB:
             break;
         case eMergeToAB: // let the user save in B. In mergeResultSaved() the file will be copied to A.
         case eMergeToB:
         case eDeleteB:
         case eCopyAToB:
             destName = mfi.fullNameB();
             break;
         case eMergeToA:
         case eDeleteA:
         case eCopyBToA:
             destName = mfi.fullNameA();
             break;
         case eMergeABToDest:
         case eMergeABCToDest:
         case eCopyAToDest:
         case eCopyBToDest:
         case eCopyCToDest:
         case eDeleteFromDest:
             destName = mfi.fullNameDest();
             break;
         default:
             KMessageBox::error(mWindow, i18n("Unknown merge operation. (This must never happen!)"));
     }
 
     bool bSuccess = false;
     bSingleFileMerge = false;
     switch(mfi.getOperation())
     {
         case eNoOperation:
             bSuccess = true;
             break;
         case eCopyAToDest:
         case eCopyAToB:
             bSuccess = copyFLD(mfi.fullNameA(), destName);
             break;
         case eCopyBToDest:
         case eCopyBToA:
             bSuccess = copyFLD(mfi.fullNameB(), destName);
             break;
         case eCopyCToDest:
             bSuccess = copyFLD(mfi.fullNameC(), destName);
             break;
         case eDeleteFromDest:
         case eDeleteA:
         case eDeleteB:
             bSuccess = deleteFLD(destName, bCreateBackups);
             break;
         case eDeleteAB:
             bSuccess = deleteFLD(mfi.fullNameA(), bCreateBackups) &&
                        deleteFLD(mfi.fullNameB(), bCreateBackups);
             break;
         case eMergeABToDest:
         case eMergeToA:
         case eMergeToAB:
         case eMergeToB:
             bSuccess = mergeFLD(mfi.fullNameA(), mfi.fullNameB(), "",
                                 destName, bSingleFileMerge);
             break;
         case eMergeABCToDest:
             bSuccess = mergeFLD(
                 mfi.existsInA() ? mfi.fullNameA() : QString(""),
                 mfi.existsInB() ? mfi.fullNameB() : QString(""),
                 mfi.existsInC() ? mfi.fullNameC() : QString(""),
                 destName, bSingleFileMerge);
             break;
         default:
             KMessageBox::error(mWindow, i18n("Unknown merge operation."));
     }
 
     return bSuccess;
 }
 
 // Check if the merge can start, and prepare the m_mergeItemList which then contains all
 // items that must be merged.
 void DirectoryMergeWindow::DirectoryMergeWindowPrivate::prepareMergeStart(const QModelIndex& miBegin, const QModelIndex& miEnd, bool bVerbose)
 {
     if(bVerbose)
     {
         int status = KMessageBox::warningYesNoCancel(mWindow,
                                                      i18n("The merge is about to begin.\n\n"
                                                           "Choose \"Do it\" if you have read the instructions and know what you are doing.\n"
                                                           "Choosing \"Simulate it\" will tell you what would happen.\n\n"
                                                           "Be aware that this program still has beta status "
                                                           "and there is NO WARRANTY whatsoever! Make backups of your vital data!"),
                                                      i18n("Starting Merge"),
                                                      KGuiItem(i18n("Do It")),
                                                      KGuiItem(i18n("Simulate It")));
         if(status == KMessageBox::Yes)
             m_bRealMergeStarted = true;
         else if(status == KMessageBox::No)
             m_bSimulatedMergeStarted = true;
         else
             return;
     }
     else
     {
         m_bRealMergeStarted = true;
     }
 
     m_mergeItemList.clear();
     if(!miBegin.isValid())
         return;
 
     for(QModelIndex mi = miBegin; mi != miEnd; mi = treeIterator(mi))
     {
         MergeFileInfos* pMFI = getMFI(mi);
         if(pMFI && pMFI->isOperationRunning())
         {
             m_mergeItemList.push_back(mi);
             QString errorText;
             if(pMFI->getOperation() == eConflictingFileTypes)
             {
                 errorText = i18n("The highlighted item has a different type in the different folders. Select what to do.");
             }
             if(pMFI->getOperation() == eConflictingAges)
             {
                 errorText = i18n("The modification dates of the file are equal but the files are not. Select what to do.");
             }
             if(pMFI->getOperation() == eChangedAndDeleted)
             {
                 errorText = i18n("The highlighted item was changed in one folder and deleted in the other. Select what to do.");
             }
             if(!errorText.isEmpty())
             {
                 mWindow->scrollTo(mi, QAbstractItemView::EnsureVisible);
                 mWindow->setCurrentIndex(mi);
                 KMessageBox::error(mWindow, errorText);
                 m_mergeItemList.clear();
                 m_bRealMergeStarted = false;
                 return;
             }
         }
     }
 
     m_currentIndexForOperation = m_mergeItemList.begin();
 }
 
 void DirectoryMergeWindow::slotRunOperationForCurrentItem()
 {
     if(!d->canContinue()) return;
 
     bool bVerbose = false;
     if(d->m_mergeItemList.empty())
     {
         QModelIndex miBegin = currentIndex();
         QModelIndex miEnd = d->treeIterator(miBegin, false, false); // find next visible sibling (no children)
 
         d->prepareMergeStart(miBegin, miEnd, bVerbose);
         d->mergeContinue(true, bVerbose);
     }
     else
         d->mergeContinue(false, bVerbose);
 }
 
 void DirectoryMergeWindow::slotRunOperationForAllItems()
 {
     if(!d->canContinue()) return;
 
     bool bVerbose = true;
     if(d->m_mergeItemList.empty())
     {
         QModelIndex miBegin = d->rowCount() > 0 ? d->index(0, 0, QModelIndex()) : QModelIndex();
 
         d->prepareMergeStart(miBegin, QModelIndex(), bVerbose);
         d->mergeContinue(true, bVerbose);
     }
     else
         d->mergeContinue(false, bVerbose);
 }
 
 void DirectoryMergeWindow::mergeCurrentFile()
 {
     if(!d->canContinue()) return;
 
     if(d->m_bRealMergeStarted)
     {
         KMessageBox::sorry(this, i18n("This operation is currently not possible because folder merge is currently running."), i18n("Operation Not Possible"));
         return;
     }
 
     if(isFileSelected())
     {
         MergeFileInfos* pMFI = d->getMFI(currentIndex());
         if(pMFI != nullptr)
         {
             d->m_mergeItemList.clear();
             d->m_mergeItemList.push_back(currentIndex());
             d->m_currentIndexForOperation = d->m_mergeItemList.begin();
             bool bDummy = false;
             d->mergeFLD(
                 pMFI->existsInA() ? pMFI->getFileInfoA()->absoluteFilePath() : QString(""),
                 pMFI->existsInB() ? pMFI->getFileInfoB()->absoluteFilePath() : QString(""),
                 pMFI->existsInC() ? pMFI->getFileInfoC()->absoluteFilePath() : QString(""),
                 pMFI->fullNameDest(),
                 bDummy);
         }
     }
     Q_EMIT updateAvailabilities();
 }
 
 // When bStart is true then m_currentIndexForOperation must still be processed.
 // When bVerbose is true then a messagebox will tell when the merge is complete.
 void DirectoryMergeWindow::DirectoryMergeWindowPrivate::mergeContinue(bool bStart, bool bVerbose)
 {
     ProgressProxy pp;
     if(m_mergeItemList.empty())
         return;
 
     int nrOfItems = 0;
     int nrOfCompletedItems = 0;
     int nrOfCompletedSimItems = 0;
 
     // Count the number of completed items (for the progress bar).
     for(const QModelIndex& i : m_mergeItemList)
     {
         MergeFileInfos* pMFI = getMFI(i);
         ++nrOfItems;
         if(!pMFI->isOperationRunning())
             ++nrOfCompletedItems;
         if(!pMFI->isSimOpRunning())
             ++nrOfCompletedSimItems;
     }
 
     m_pStatusInfo->hide();
     m_pStatusInfo->clear();
 
     QModelIndex miCurrent = m_currentIndexForOperation == m_mergeItemList.end() ? QModelIndex() : *m_currentIndexForOperation;
 
     bool bContinueWithCurrentItem = bStart; // true for first item, else false
     bool bSkipItem = false;
     if(!bStart && m_bError && miCurrent.isValid())
     {
         int status = KMessageBox::warningYesNoCancel(mWindow,
                                                      i18n("There was an error in the last step.\n"
                                                           "Do you want to continue with the item that caused the error or do you want to skip this item?"),
                                                      i18n("Continue merge after an error"),
                                                      KGuiItem(i18n("Continue With Last Item")),
                                                      KGuiItem(i18n("Skip Item")));
         if(status == KMessageBox::Yes)
             bContinueWithCurrentItem = true;
         else if(status == KMessageBox::No)
             bSkipItem = true;
         else
             return;
         m_bError = false;
     }
 
     pp.setMaxNofSteps(nrOfItems);
 
     bool bSuccess = true;
     bool bSingleFileMerge = false;
     bool bSim = m_bSimulatedMergeStarted;
     while(bSuccess)
     {
         MergeFileInfos* pMFI = getMFI(miCurrent);
         if(pMFI == nullptr)
         {
             m_mergeItemList.clear();
             m_bRealMergeStarted = false;
             break;
         }
 
         if(pMFI != nullptr && !bContinueWithCurrentItem)
         {
             if(bSim)
             {
                 if(rowCount(miCurrent) == 0)
                 {
                     pMFI->endSimOp();
                 }
             }
             else
             {
                 if(rowCount(miCurrent) == 0)
                 {
                     if(pMFI->isOperationRunning())
                     {
                         setOpStatus(miCurrent, bSkipItem ? eOpStatusSkipped : eOpStatusDone);
                         pMFI->endOperation();
                         bSkipItem = false;
                     }
                 }
                 else
                 {
                     setOpStatus(miCurrent, eOpStatusInProgress);
                 }
             }
         }
 
         if(!bContinueWithCurrentItem)
         {
             // Depth first
             QModelIndex miPrev = miCurrent;
             ++m_currentIndexForOperation;
             miCurrent = m_currentIndexForOperation == m_mergeItemList.end() ? QModelIndex() : *m_currentIndexForOperation;
             if((!miCurrent.isValid() || miCurrent.parent() != miPrev.parent()) && miPrev.parent().isValid())
             {
                 // Check if the parent may be set to "Done"
                 QModelIndex miParent = miPrev.parent();
                 bool bDone = true;
                 while(bDone && miParent.isValid())
                 {
                     for(int childIdx = 0; childIdx < rowCount(miParent); ++childIdx)
                     {
                         pMFI = getMFI(index(childIdx, 0, miParent));
                         if((!bSim && pMFI->isOperationRunning()) || (bSim && !pMFI->isSimOpRunning()))
                         {
                             bDone = false;
                             break;
                         }
                     }
                     if(bDone)
                     {
                         pMFI = getMFI(miParent);
                         if(bSim)
                             pMFI->endSimOp();
                         else
                         {
                             setOpStatus(miParent, eOpStatusDone);
                             pMFI->endOperation();
                         }
                     }
                     miParent = miParent.parent();
                 }
             }
         }
 
         if(!miCurrent.isValid()) // end?
         {
             if(m_bRealMergeStarted)
             {
                 if(bVerbose)
                 {
                     KMessageBox::information(mWindow, i18n("Merge operation complete."), i18n("Merge Complete"));
                 }
                 m_bRealMergeStarted = false;
                 m_pStatusInfo->setWindowTitle(i18n("Merge Complete"));
             }
             if(m_bSimulatedMergeStarted)
             {
                 m_bSimulatedMergeStarted = false;
                 QModelIndex mi = rowCount() > 0 ? index(0, 0, QModelIndex()) : QModelIndex();
                 for(; mi.isValid(); mi = treeIterator(mi))
                 {
                     getMFI(mi)->startSimOp();
                 }
                 m_pStatusInfo->setWindowTitle(i18n("Simulated merge complete: Check if you agree with the proposed operations."));
                 m_pStatusInfo->exec();
             }
             m_mergeItemList.clear();
             m_bRealMergeStarted = false;
             return;
         }
 
         pMFI = getMFI(miCurrent);
 
         pp.setInformation(pMFI->subPath(),
                           bSim ? nrOfCompletedSimItems : nrOfCompletedItems,
                           false // bRedrawUpdate
         );
 
         bSuccess = executeMergeOperation(*pMFI, bSingleFileMerge); // Here the real operation happens.
 
         if(bSuccess)
         {
             if(bSim)
                 ++nrOfCompletedSimItems;
             else
                 ++nrOfCompletedItems;
             bContinueWithCurrentItem = false;
         }
 
         if(pp.wasCancelled())
             break;
     } // end while
 
     //g_pProgressDialog->hide();
 
     mWindow->setCurrentIndex(miCurrent);
     mWindow->scrollTo(miCurrent, EnsureVisible);
     if(!bSuccess && !bSingleFileMerge)
     {
         KMessageBox::error(mWindow, i18n("An error occurred. Press OK to see detailed information."));
         m_pStatusInfo->setWindowTitle(i18n("Merge Error"));
         m_pStatusInfo->exec();
         //if ( m_pStatusInfo->firstChild()!=0 )
         //   m_pStatusInfo->ensureItemVisible( m_pStatusInfo->last() );
         m_bError = true;
 
         setOpStatus(miCurrent, eOpStatusError);
     }
     else
     {
         m_bError = false;
     }
     Q_EMIT mWindow->updateAvailabilities();
 
     if(m_currentIndexForOperation == m_mergeItemList.end())
     {
         m_mergeItemList.clear();
         m_bRealMergeStarted = false;
     }
 }
 
 bool DirectoryMergeWindow::DirectoryMergeWindowPrivate::deleteFLD(const QString& name, bool bCreateBackup)
 {
     FileAccess fi(name, true);
     if(!fi.exists())
         return true;
 
     if(bCreateBackup)
     {
         bool bSuccess = renameFLD(name, name + ".orig");
         if(!bSuccess)
         {
             m_pStatusInfo->addText(i18n("Error: While deleting %1: Creating backup failed.", name));
             return false;
         }
     }
     else
     {
         if(fi.isDir() && !fi.isSymLink())
             m_pStatusInfo->addText(i18n("delete folder recursively( %1 )", name));
         else
             m_pStatusInfo->addText(i18n("delete( %1 )", name));
 
         if(m_bSimulatedMergeStarted)
         {
             return true;
         }
 
         if(fi.isDir() && !fi.isSymLink()) // recursive directory delete only for real dirs, not symlinks
         {
             t_DirectoryList dirList;
             bool bSuccess = fi.listDir(&dirList, false, true, "*", "", "", false, false); // not recursive, find hidden files
 
             if(!bSuccess)
             {
                 // No Permission to read directory or other error.
                 m_pStatusInfo->addText(i18n("Error: delete folder operation failed while trying to read the folder."));
                 return false;
             }
 
             t_DirectoryList::iterator it; // create list iterator
 
             for(it = dirList.begin(); it != dirList.end(); ++it) // for each file...
             {
                 FileAccess& fi2 = *it;
                 Q_ASSERT(fi2.fileName() != "." && fi2.fileName() != "..");
 
                 bSuccess = deleteFLD(fi2.absoluteFilePath(), false);
                 if(!bSuccess) break;
             }
             if(bSuccess)
             {
                 bSuccess = FileAccess::removeDir(name);
                 if(!bSuccess)
                 {
                     m_pStatusInfo->addText(i18n("Error: rmdir( %1 ) operation failed.", name)); // krazy:exclude=syscalls
                     return false;
                 }
             }
         }
         else
         {
             bool bSuccess = fi.removeFile();
             if(!bSuccess)
             {
                 m_pStatusInfo->addText(i18n("Error: delete operation failed."));
                 return false;
             }
         }
     }
     return true;
 }
 
 bool DirectoryMergeWindow::DirectoryMergeWindowPrivate::mergeFLD(const QString& nameA, const QString& nameB, const QString& nameC, const QString& nameDest, bool& bSingleFileMerge)
 {
     FileAccess fi(nameA);
     if(fi.isDir())
     {
         return makeDir(nameDest);
     }
 
     // Make sure that the dir exists, into which we will save the file later.
     int pos = nameDest.lastIndexOf('/');
     if(pos > 0)
     {
         QString parentName = nameDest.left(pos);
         bool bSuccess = makeDir(parentName, true /*quiet*/);
         if(!bSuccess)
             return false;
     }
 
     m_pStatusInfo->addText(i18n("manual merge( %1, %2, %3 -> %4)", nameA, nameB, nameC, nameDest));
     if(m_bSimulatedMergeStarted)
     {
         m_pStatusInfo->addText(i18n("     Note: After a manual merge the user should continue by pressing F7."));
         return true;
     }
 
     bSingleFileMerge = true;
     setOpStatus(*m_currentIndexForOperation, eOpStatusInProgress);
     mWindow->scrollTo(*m_currentIndexForOperation, EnsureVisible);
 
     Q_EMIT mWindow->startDiffMerge(nameA, nameB, nameC, nameDest, "", "", "", nullptr);
 
     return false;
 }
 
 bool DirectoryMergeWindow::DirectoryMergeWindowPrivate::copyFLD(const QString& srcName, const QString& destName)
 {
     bool bSuccess = false;
 
     if(srcName == destName)
         return true;
 
     FileAccess fi(srcName);
     FileAccess faDest(destName, true);
     if(faDest.exists() && !(fi.isDir() && faDest.isDir() && (fi.isSymLink() == faDest.isSymLink())))
     {
         bSuccess = deleteFLD(destName, m_pOptions->m_bDmCreateBakFiles);
         if(!bSuccess)
         {
             m_pStatusInfo->addText(i18n("Error: copy( %1 -> %2 ) failed."
                                         "Deleting existing destination failed.",
                                         srcName, destName));
             return bSuccess;
         }
     }
 
     if(fi.isSymLink() && ((fi.isDir() && !m_bFollowDirLinks) || (!fi.isDir() && !m_bFollowFileLinks)))
     {
         m_pStatusInfo->addText(i18n("copyLink( %1 -> %2 )", srcName, destName));
 
         if(m_bSimulatedMergeStarted)
         {
             return true;
         }
         FileAccess destFi(destName);
         if(!destFi.isLocal() || !fi.isLocal())
         {
             m_pStatusInfo->addText(i18n("Error: copyLink failed: Remote links are not yet supported."));
             return false;
         }
 
         bSuccess = false;
         QString linkTarget = fi.readLink();
         if(!linkTarget.isEmpty())
         {
             bSuccess = FileAccess::symLink(linkTarget, destName);
             if(!bSuccess)
                 m_pStatusInfo->addText(i18n("Error: copyLink failed."));
         }
         return bSuccess;
     }
 
     if(fi.isDir())
     {
         if(faDest.exists())
             return true;
 
         bSuccess = makeDir(destName);
         return bSuccess;
     }
 
     int pos = destName.lastIndexOf('/');
     if(pos > 0)
     {
         QString parentName = destName.left(pos);
         bSuccess = makeDir(parentName, true /*quiet*/);
         if(!bSuccess)
             return false;
     }
 
     m_pStatusInfo->addText(i18n("copy( %1 -> %2 )", srcName, destName));
 
     if(m_bSimulatedMergeStarted)
     {
         return true;
     }
 
     FileAccess faSrc(srcName);
     bSuccess = faSrc.copyFile(destName);
     if(!bSuccess) m_pStatusInfo->addText(faSrc.getStatusText());
     return bSuccess;
 }
 
 // Rename is not an operation that can be selected by the user.
 // It will only be used to create backups.
 // Hence it will delete an existing destination without making a backup (of the old backup.)
 bool DirectoryMergeWindow::DirectoryMergeWindowPrivate::renameFLD(const QString& srcName, const QString& destName)
 {
     if(srcName == destName)
         return true;
     FileAccess destFile = FileAccess(destName, true);
     if(destFile.exists())
     {
         bool bSuccess = deleteFLD(destName, false /*no backup*/);
         if(!bSuccess)
         {
             m_pStatusInfo->addText(i18n("Error during rename( %1 -> %2 ): "
                                         "Cannot delete existing destination.",
                                         srcName, destName));
             return false;
         }
     }
 
     m_pStatusInfo->addText(i18n("rename( %1 -> %2 )", srcName, destName));
     if(m_bSimulatedMergeStarted)
     {
         return true;
     }
 
     bool bSuccess = FileAccess(srcName).rename(destFile);
     if(!bSuccess)
     {
         m_pStatusInfo->addText(i18n("Error: Rename failed."));
         return false;
     }
 
     return true;
 }
 
 bool DirectoryMergeWindow::DirectoryMergeWindowPrivate::makeDir(const QString& name, bool bQuiet)
 {
     FileAccess fi(name, true);
     if(fi.exists() && fi.isDir())
         return true;
 
     if(fi.exists() && !fi.isDir())
     {
         bool bSuccess = deleteFLD(name, true);
         if(!bSuccess)
         {
             m_pStatusInfo->addText(i18n("Error during makeDir of %1. "
                                         "Cannot delete existing file.",
                                         name));
             return false;
         }
     }
 
     int pos = name.lastIndexOf('/');
     if(pos > 0)
     {
         QString parentName = name.left(pos);
         bool bSuccess = makeDir(parentName, true);
         if(!bSuccess)
             return false;
     }
 
     if(!bQuiet)
         m_pStatusInfo->addText(i18n("makeDir( %1 )", name));
 
     if(m_bSimulatedMergeStarted)
     {
         return true;
     }
 
     bool bSuccess = FileAccess::makeDir(name);
     if(!bSuccess)
     {
         m_pStatusInfo->addText(i18n("Error while creating folder."));
         return false;
     }
     return true;
 }
 
 DirectoryMergeInfo::DirectoryMergeInfo(QWidget* pParent)
     : QFrame(pParent)
 {
     QVBoxLayout* topLayout = new QVBoxLayout(this);
     topLayout->setMargin(0);
 
     QGridLayout* grid = new QGridLayout();
     topLayout->addLayout(grid);
     grid->setColumnStretch(1, 10);
 
     int line = 0;
 
     m_pA = new QLabel(i18n("A"), this);
     grid->addWidget(m_pA, line, 0);
     m_pInfoA = new QLabel(this);
     grid->addWidget(m_pInfoA, line, 1);
     ++line;
 
     m_pB = new QLabel(i18n("B"), this);
     grid->addWidget(m_pB, line, 0);
     m_pInfoB = new QLabel(this);
     grid->addWidget(m_pInfoB, line, 1);
     ++line;
 
     m_pC = new QLabel(i18n("C"), this);
     grid->addWidget(m_pC, line, 0);
     m_pInfoC = new QLabel(this);
     grid->addWidget(m_pInfoC, line, 1);
     ++line;
 
     m_pDest = new QLabel(i18n("Dest"), this);
     grid->addWidget(m_pDest, line, 0);
     m_pInfoDest = new QLabel(this);
     grid->addWidget(m_pInfoDest, line, 1);
     ++line;
 
     m_pInfoList = new QTreeWidget(this);
     topLayout->addWidget(m_pInfoList);
     m_pInfoList->setHeaderLabels({i18n("Folder"), i18n("Type"), i18n("Size"),
                                   i18n("Attr"), i18n("Last Modification"), i18n("Link-Destination")});
     setMinimumSize(100, 100);
 
     m_pInfoList->installEventFilter(this);
     m_pInfoList->setRootIsDecorated(false);
 }
 
 bool DirectoryMergeInfo::eventFilter(QObject* o, QEvent* e)
 {
     if(e->type() == QEvent::FocusIn && o == m_pInfoList)
         Q_EMIT gotFocus();
     return false;
 }
 
 void DirectoryMergeInfo::addListViewItem(const QString& dir, const QString& basePath, FileAccess* fi)
 {
     if(basePath.isEmpty())
     {
         return;
     }
 
     if(fi != nullptr && fi->exists())
     {
         QString dateString = fi->lastModified().toString(QLocale::system().dateTimeFormat());
 
         m_pInfoList->addTopLevelItem(new QTreeWidgetItem(
             m_pInfoList,
             {dir, QString(fi->isDir() ? i18n("Folder") : i18n("File")) + (fi->isSymLink() ? i18n("-Link") : ""), QString::number(fi->size()), QLatin1String(fi->isReadable() ? "r" : " ") + QLatin1String(fi->isWritable() ? "w" : " ") + QLatin1String((fi->isExecutable() ? "x" : " ")), dateString, QString(fi->isSymLink() ? (" -> " + fi->readLink()) : QString(""))}));
     }
     else
     {
         m_pInfoList->addTopLevelItem(new QTreeWidgetItem(
             m_pInfoList,
             {dir, i18n("not available"), "", "", "", ""}));
     }
 }
 
 void DirectoryMergeInfo::setInfo(
     const FileAccess& dirA,
     const FileAccess& dirB,
     const FileAccess& dirC,
     const FileAccess& dirDest,
     MergeFileInfos& mfi)
 {
     bool bHideDest = false;
     if(dirA.absoluteFilePath() == dirDest.absoluteFilePath())
     {
         m_pA->setText(i18n("A (Dest): "));
         bHideDest = true;
     }
     else
         m_pA->setText(!dirC.isValid() ? i18n("A:    ") : i18n("A (Base): "));
 
     m_pInfoA->setText(dirA.prettyAbsPath());
 
     if(dirB.absoluteFilePath() == dirDest.absoluteFilePath())
     {
         m_pB->setText(i18n("B (Dest): "));
         bHideDest = true;
     }
     else
         m_pB->setText(i18n("B:    "));
     m_pInfoB->setText(dirB.prettyAbsPath());
 
     if(dirC.absoluteFilePath() == dirDest.absoluteFilePath())
     {
         m_pC->setText(i18n("C (Dest): "));
         bHideDest = true;
     }
     else
         m_pC->setText(i18n("C:    "));
     m_pInfoC->setText(dirC.prettyAbsPath());
 
     m_pDest->setText(i18n("Dest: "));
     m_pInfoDest->setText(dirDest.prettyAbsPath());
 
     if(!dirC.isValid())
     {
         m_pC->hide();
         m_pInfoC->hide();
     }
     else
     {
         m_pC->show();
         m_pInfoC->show();
     }
 
     if(!dirDest.isValid() || bHideDest)
     {
         m_pDest->hide();
         m_pInfoDest->hide();
     }
     else
     {
         m_pDest->show();
         m_pInfoDest->show();
     }
 
     m_pInfoList->clear();
     addListViewItem(i18n("A"), dirA.prettyAbsPath(), mfi.getFileInfoA());
     addListViewItem(i18n("B"), dirB.prettyAbsPath(), mfi.getFileInfoB());
     addListViewItem(i18n("C"), dirC.prettyAbsPath(), mfi.getFileInfoC());
     if(!bHideDest)
     {
         FileAccess fiDest(dirDest.prettyAbsPath() + '/' + mfi.subPath(), true);
         addListViewItem(i18n("Dest"), dirDest.prettyAbsPath(), &fiDest);
     }
     for(int i = 0; i < m_pInfoList->columnCount(); ++i)
         m_pInfoList->resizeColumnToContents(i);
 }
 
 void DirectoryMergeWindow::slotSaveMergeState()
 {
     //slotStatusMsg(i18n("Saving Directory Merge State ..."));
 
     QString dirMergeStateFilename = QFileDialog::getSaveFileName(this, i18n("Save Folder Merge State As..."), QDir::currentPath());
     if(!dirMergeStateFilename.isEmpty())
     {
         QFile file(dirMergeStateFilename);
         bool bSuccess = file.open(QIODevice::WriteOnly);
         if(bSuccess)
         {
             QTextStream ts(&file);
 
             QModelIndex mi(d->index(0, 0, QModelIndex()));
             while(mi.isValid())
             {
                 MergeFileInfos* pMFI = d->getMFI(mi);
                 ts << *pMFI;
                 mi = d->treeIterator(mi, true, true);
             }
         }
     }
 
     //slotStatusMsg(i18n("Ready."));
 }
 
 void DirectoryMergeWindow::slotLoadMergeState()
 {
 }
 
 void DirectoryMergeWindow::updateFileVisibilities()
 {
     bool bShowIdentical = d->m_pDirShowIdenticalFiles->isChecked();
     bool bShowDifferent = d->m_pDirShowDifferentFiles->isChecked();
     bool bShowOnlyInA = d->m_pDirShowFilesOnlyInA->isChecked();
     bool bShowOnlyInB = d->m_pDirShowFilesOnlyInB->isChecked();
     bool bShowOnlyInC = d->m_pDirShowFilesOnlyInC->isChecked();
     bool bThreeDirs = d->isThreeWay();
     d->m_selection1Index = QModelIndex();
     d->m_selection2Index = QModelIndex();
     d->m_selection3Index = QModelIndex();
 
     // in first run set all dirs to equal and determine if they are not equal.
     // on second run don't change the equal-status anymore; it is needed to
     // set the visibility (when bShowIdentical is false).
     for(int loop = 0; loop < 2; ++loop)
     {
         QModelIndex mi = d->rowCount() > 0 ? d->index(0, 0, QModelIndex()) : QModelIndex();
         while(mi.isValid())
         {
             MergeFileInfos* pMFI = d->getMFI(mi);
             bool bDir = pMFI->hasDir();
             if(loop == 0 && bDir)
             { //Treat all links and directories to equal by default.
                 pMFI->updateDirectoryOrLink();
             }
 
             bool bVisible =
                 (bShowIdentical && pMFI->existsEveryWhere() && pMFI->isEqualAB() && (pMFI->isEqualAC() || !bThreeDirs)) ||
                 ((bShowDifferent || bDir) && pMFI->existsCount() >= 2 && (!pMFI->isEqualAB() || !(pMFI->isEqualAC() || !bThreeDirs))) ||
                 (bShowOnlyInA && pMFI->onlyInA()) || (bShowOnlyInB && pMFI->onlyInB()) || (bShowOnlyInC && pMFI->onlyInC());
 
             QString fileName = pMFI->fileName();
             bVisible = bVisible && ((bDir && !Utils::wildcardMultiMatch(d->m_pOptions->m_DmDirAntiPattern, fileName, d->m_bCaseSensitive)) || (Utils::wildcardMultiMatch(d->m_pOptions->m_DmFilePattern, fileName, d->m_bCaseSensitive) && !Utils::wildcardMultiMatch(d->m_pOptions->m_DmFileAntiPattern, fileName, d->m_bCaseSensitive)));
 
             if(loop != 0)
                 setRowHidden(mi.row(), mi.parent(), !bVisible);
 
             bool bEqual = bThreeDirs ? pMFI->isEqualAB() && pMFI->isEqualAC() : pMFI->isEqualAB();
             if(!bEqual && bVisible && loop == 0) // Set all parents to "not equal"
             {
                 pMFI->updateParents();
             }
             mi = d->treeIterator(mi, true, true);
         }
     }
 }
 
 void DirectoryMergeWindow::slotShowIdenticalFiles()
 {
     d->m_pOptions->m_bDmShowIdenticalFiles = d->m_pDirShowIdenticalFiles->isChecked();
     updateFileVisibilities();
 }
 void DirectoryMergeWindow::slotShowDifferentFiles()
 {
     updateFileVisibilities();
 }
 void DirectoryMergeWindow::slotShowFilesOnlyInA()
 {
     updateFileVisibilities();
 }
 void DirectoryMergeWindow::slotShowFilesOnlyInB()
 {
     updateFileVisibilities();
 }
 void DirectoryMergeWindow::slotShowFilesOnlyInC()
 {
     updateFileVisibilities();
 }
 
 void DirectoryMergeWindow::slotSynchronizeDirectories() {}
 void DirectoryMergeWindow::slotChooseNewerFiles() {}
 
 void DirectoryMergeWindow::initDirectoryMergeActions(KDiff3App* pKDiff3App, KActionCollection* ac)
 {
 #include "xpm/showequalfiles.xpm"
 #include "xpm/showfilesonlyina.xpm"
 #include "xpm/showfilesonlyinb.xpm"
 #include "xpm/showfilesonlyinc.xpm"
 #include "xpm/startmerge.xpm"
 
     d->m_pDirStartOperation = GuiUtils::createAction<QAction>(i18n("Start/Continue Folder Merge"), QKeySequence(Qt::Key_F7), this, &DirectoryMergeWindow::slotRunOperationForAllItems, ac, "dir_start_operation");
     d->m_pDirRunOperationForCurrentItem = GuiUtils::createAction<QAction>(i18n("Run Operation for Current Item"), QKeySequence(Qt::Key_F6), this, &DirectoryMergeWindow::slotRunOperationForCurrentItem, ac, "dir_run_operation_for_current_item");
     d->m_pDirCompareCurrent = GuiUtils::createAction<QAction>(i18n("Compare Selected File"), this, &DirectoryMergeWindow::compareCurrentFile, ac, "dir_compare_current");
     d->m_pDirMergeCurrent = GuiUtils::createAction<QAction>(i18n("Merge Current File"), QIcon(QPixmap(startmerge)), i18n("Merge\nFile"), pKDiff3App, &KDiff3App::slotMergeCurrentFile, ac, "merge_current");
     d->m_pDirFoldAll = GuiUtils::createAction<QAction>(i18n("Fold All Subfolders"), this, &DirectoryMergeWindow::collapseAll, ac, "dir_fold_all");
     d->m_pDirUnfoldAll = GuiUtils::createAction<QAction>(i18n("Unfold All Subfolders"), this, &DirectoryMergeWindow::expandAll, ac, "dir_unfold_all");
     d->m_pDirRescan = GuiUtils::createAction<QAction>(i18n("Rescan"), QKeySequence(Qt::SHIFT + Qt::Key_F5), this, &DirectoryMergeWindow::reload, ac, "dir_rescan");
     d->m_pDirSaveMergeState = nullptr; //GuiUtils::createAction< QAction >(i18n("Save Directory Merge State ..."), 0, this, &DirectoryMergeWindow::slotSaveMergeState, ac, "dir_save_merge_state");
     d->m_pDirLoadMergeState = nullptr; //GuiUtils::createAction< QAction >(i18n("Load Directory Merge State ..."), 0, this, &DirectoryMergeWindow::slotLoadMergeState, ac, "dir_load_merge_state");
     d->m_pDirChooseAEverywhere = GuiUtils::createAction<QAction>(i18n("Choose A for All Items"), this, &DirectoryMergeWindow::slotChooseAEverywhere, ac, "dir_choose_a_everywhere");
     d->m_pDirChooseBEverywhere = GuiUtils::createAction<QAction>(i18n("Choose B for All Items"), this, &DirectoryMergeWindow::slotChooseBEverywhere, ac, "dir_choose_b_everywhere");
     d->m_pDirChooseCEverywhere = GuiUtils::createAction<QAction>(i18n("Choose C for All Items"), this, &DirectoryMergeWindow::slotChooseCEverywhere, ac, "dir_choose_c_everywhere");
     d->m_pDirAutoChoiceEverywhere = GuiUtils::createAction<QAction>(i18n("Auto-Choose Operation for All Items"), this, &DirectoryMergeWindow::slotAutoChooseEverywhere, ac, "dir_autochoose_everywhere");
     d->m_pDirDoNothingEverywhere = GuiUtils::createAction<QAction>(i18n("No Operation for All Items"), this, &DirectoryMergeWindow::slotNoOpEverywhere, ac, "dir_nothing_everywhere");
 
     //   d->m_pDirSynchronizeDirectories = GuiUtils::createAction< KToggleAction >(i18n("Synchronize Directories"), 0, this, &DirectoryMergeWindow::slotSynchronizeDirectories, ac, "dir_synchronize_directories");
     //   d->m_pDirChooseNewerFiles = GuiUtils::createAction< KToggleAction >(i18n("Copy Newer Files Instead of Merging"), 0, this, &DirectoryMergeWindow::slotChooseNewerFiles, ac, "dir_choose_newer_files");
 
     d->m_pDirShowIdenticalFiles = GuiUtils::createAction<KToggleAction>(i18n("Show Identical Files"), QIcon(QPixmap(showequalfiles)), i18n("Identical\nFiles"), this, &DirectoryMergeWindow::slotShowIdenticalFiles, ac, "dir_show_identical_files");
     d->m_pDirShowDifferentFiles = GuiUtils::createAction<KToggleAction>(i18n("Show Different Files"), this, &DirectoryMergeWindow::slotShowDifferentFiles, ac, "dir_show_different_files");
     d->m_pDirShowFilesOnlyInA = GuiUtils::createAction<KToggleAction>(i18n("Show Files only in A"), QIcon(QPixmap(showfilesonlyina)), i18n("Files\nonly in A"), this, &DirectoryMergeWindow::slotShowFilesOnlyInA, ac, "dir_show_files_only_in_a");
     d->m_pDirShowFilesOnlyInB = GuiUtils::createAction<KToggleAction>(i18n("Show Files only in B"), QIcon(QPixmap(showfilesonlyinb)), i18n("Files\nonly in B"), this, &DirectoryMergeWindow::slotShowFilesOnlyInB, ac, "dir_show_files_only_in_b");
     d->m_pDirShowFilesOnlyInC = GuiUtils::createAction<KToggleAction>(i18n("Show Files only in C"), QIcon(QPixmap(showfilesonlyinc)), i18n("Files\nonly in C"), this, &DirectoryMergeWindow::slotShowFilesOnlyInC, ac, "dir_show_files_only_in_c");
 
     d->m_pDirShowIdenticalFiles->setChecked(d->m_pOptions->m_bDmShowIdenticalFiles);
 
     d->m_pDirCompareExplicit = GuiUtils::createAction<QAction>(i18n("Compare Explicitly Selected Files"), this, &DirectoryMergeWindow::slotCompareExplicitlySelectedFiles, ac, "dir_compare_explicitly_selected_files");
     d->m_pDirMergeExplicit = GuiUtils::createAction<QAction>(i18n("Merge Explicitly Selected Files"), this, &DirectoryMergeWindow::slotMergeExplicitlySelectedFiles, ac, "dir_merge_explicitly_selected_files");
 
     d->m_pDirCurrentDoNothing = GuiUtils::createAction<QAction>(i18n("Do Nothing"), this, &DirectoryMergeWindow::slotCurrentDoNothing, ac, "dir_current_do_nothing");
     d->m_pDirCurrentChooseA = GuiUtils::createAction<QAction>(i18n("A"), this, &DirectoryMergeWindow::slotCurrentChooseA, ac, "dir_current_choose_a");
     d->m_pDirCurrentChooseB = GuiUtils::createAction<QAction>(i18n("B"), this, &DirectoryMergeWindow::slotCurrentChooseB, ac, "dir_current_choose_b");
     d->m_pDirCurrentChooseC = GuiUtils::createAction<QAction>(i18n("C"), this, &DirectoryMergeWindow::slotCurrentChooseC, ac, "dir_current_choose_c");
     d->m_pDirCurrentMerge = GuiUtils::createAction<QAction>(i18n("Merge"), this, &DirectoryMergeWindow::slotCurrentMerge, ac, "dir_current_merge");
     d->m_pDirCurrentDelete = GuiUtils::createAction<QAction>(i18n("Delete (if exists)"), this, &DirectoryMergeWindow::slotCurrentDelete, ac, "dir_current_delete");
 
     d->m_pDirCurrentSyncDoNothing = GuiUtils::createAction<QAction>(i18n("Do Nothing"), this, &DirectoryMergeWindow::slotCurrentDoNothing, ac, "dir_current_sync_do_nothing");
     d->m_pDirCurrentSyncCopyAToB = GuiUtils::createAction<QAction>(i18n("Copy A to B"), this, &DirectoryMergeWindow::slotCurrentCopyAToB, ac, "dir_current_sync_copy_a_to_b");
     d->m_pDirCurrentSyncCopyBToA = GuiUtils::createAction<QAction>(i18n("Copy B to A"), this, &DirectoryMergeWindow::slotCurrentCopyBToA, ac, "dir_current_sync_copy_b_to_a");
     d->m_pDirCurrentSyncDeleteA = GuiUtils::createAction<QAction>(i18n("Delete A"), this, &DirectoryMergeWindow::slotCurrentDeleteA, ac, "dir_current_sync_delete_a");
     d->m_pDirCurrentSyncDeleteB = GuiUtils::createAction<QAction>(i18n("Delete B"), this, &DirectoryMergeWindow::slotCurrentDeleteB, ac, "dir_current_sync_delete_b");
     d->m_pDirCurrentSyncDeleteAAndB = GuiUtils::createAction<QAction>(i18n("Delete A && B"), this, &DirectoryMergeWindow::slotCurrentDeleteAAndB, ac, "dir_current_sync_delete_a_and_b");
     d->m_pDirCurrentSyncMergeToA = GuiUtils::createAction<QAction>(i18n("Merge to A"), this, &DirectoryMergeWindow::slotCurrentMergeToA, ac, "dir_current_sync_merge_to_a");
     d->m_pDirCurrentSyncMergeToB = GuiUtils::createAction<QAction>(i18n("Merge to B"), this, &DirectoryMergeWindow::slotCurrentMergeToB, ac, "dir_current_sync_merge_to_b");
     d->m_pDirCurrentSyncMergeToAAndB = GuiUtils::createAction<QAction>(i18n("Merge to A && B"), this, &DirectoryMergeWindow::slotCurrentMergeToAAndB, ac, "dir_current_sync_merge_to_a_and_b");
 }
 
 void DirectoryMergeWindow::setupConnections(const KDiff3App* app)
 {
     connect(this, &DirectoryMergeWindow::startDiffMerge, app, &KDiff3App::slotFileOpen2);
     connect(selectionModel(), &QItemSelectionModel::selectionChanged, app, &KDiff3App::slotUpdateAvailabilities);
     connect(selectionModel(), &QItemSelectionModel::currentChanged, app, &KDiff3App::slotUpdateAvailabilities);
-    connect(this, &DirectoryMergeWindow::checkIfCanContinue, app, &KDiff3App::slotCheckIfCanContinue);
     connect(this, static_cast<void (DirectoryMergeWindow::*) (void)>(&DirectoryMergeWindow::updateAvailabilities), app, &KDiff3App::slotUpdateAvailabilities);
     connect(this, &DirectoryMergeWindow::statusBarMessage, app, &KDiff3App::slotStatusMsg);
     connect(app, &KDiff3App::doRefresh, this, &DirectoryMergeWindow::slotRefresh);
 }
 
 void DirectoryMergeWindow::updateAvailabilities(bool bDirCompare, bool bDiffWindowVisible,
                                                 KToggleAction* chooseA, KToggleAction* chooseB, KToggleAction* chooseC)
 {
     d->m_pDirStartOperation->setEnabled(bDirCompare);
     d->m_pDirRunOperationForCurrentItem->setEnabled(bDirCompare);
     d->m_pDirFoldAll->setEnabled(bDirCompare);
     d->m_pDirUnfoldAll->setEnabled(bDirCompare);
 
     d->m_pDirCompareCurrent->setEnabled(bDirCompare && isVisible() && isFileSelected());
 
     d->m_pDirMergeCurrent->setEnabled((bDirCompare && isVisible() && isFileSelected()) || bDiffWindowVisible);
 
     d->m_pDirRescan->setEnabled(bDirCompare);
 
     bool bThreeDirs = d->isThreeWay();
     d->m_pDirAutoChoiceEverywhere->setEnabled(bDirCompare && isVisible());
     d->m_pDirDoNothingEverywhere->setEnabled(bDirCompare && isVisible());
     d->m_pDirChooseAEverywhere->setEnabled(bDirCompare && isVisible());
     d->m_pDirChooseBEverywhere->setEnabled(bDirCompare && isVisible());
     d->m_pDirChooseCEverywhere->setEnabled(bDirCompare && isVisible() && bThreeDirs);
 
     MergeFileInfos* pMFI = d->getMFI(currentIndex());
 
     bool bItemActive = bDirCompare && isVisible() && pMFI != nullptr; //  &&  hasFocus();
     bool bMergeMode = bThreeDirs || !d->m_bSyncMode;
     bool bFTConflict = pMFI == nullptr ? false : pMFI->conflictingFileTypes();
 
     bool bDirWindowHasFocus = isVisible() && hasFocus();
 
     d->m_pDirShowIdenticalFiles->setEnabled(bDirCompare && isVisible());
     d->m_pDirShowDifferentFiles->setEnabled(bDirCompare && isVisible());
     d->m_pDirShowFilesOnlyInA->setEnabled(bDirCompare && isVisible());
     d->m_pDirShowFilesOnlyInB->setEnabled(bDirCompare && isVisible());
     d->m_pDirShowFilesOnlyInC->setEnabled(bDirCompare && isVisible() && bThreeDirs);
 
     d->m_pDirCompareExplicit->setEnabled(bDirCompare && isVisible() && d->m_selection2Index.isValid());
     d->m_pDirMergeExplicit->setEnabled(bDirCompare && isVisible() && d->m_selection2Index.isValid());
 
     d->m_pDirCurrentDoNothing->setEnabled(bItemActive && bMergeMode);
     d->m_pDirCurrentChooseA->setEnabled(bItemActive && bMergeMode && pMFI->existsInA());
     d->m_pDirCurrentChooseB->setEnabled(bItemActive && bMergeMode && pMFI->existsInB());
     d->m_pDirCurrentChooseC->setEnabled(bItemActive && bMergeMode && pMFI->existsInC());
     d->m_pDirCurrentMerge->setEnabled(bItemActive && bMergeMode && !bFTConflict);
     d->m_pDirCurrentDelete->setEnabled(bItemActive && bMergeMode);
     if(bDirWindowHasFocus)
     {
         chooseA->setEnabled(bItemActive && pMFI->existsInA());
         chooseB->setEnabled(bItemActive && pMFI->existsInB());
         chooseC->setEnabled(bItemActive && pMFI->existsInC());
         chooseA->setChecked(false);
         chooseB->setChecked(false);
         chooseC->setChecked(false);
     }
 
     d->m_pDirCurrentSyncDoNothing->setEnabled(bItemActive && !bMergeMode);
     d->m_pDirCurrentSyncCopyAToB->setEnabled(bItemActive && !bMergeMode && pMFI->existsInA());
     d->m_pDirCurrentSyncCopyBToA->setEnabled(bItemActive && !bMergeMode && pMFI->existsInB());
     d->m_pDirCurrentSyncDeleteA->setEnabled(bItemActive && !bMergeMode && pMFI->existsInA());
     d->m_pDirCurrentSyncDeleteB->setEnabled(bItemActive && !bMergeMode && pMFI->existsInB());
     d->m_pDirCurrentSyncDeleteAAndB->setEnabled(bItemActive && !bMergeMode && pMFI->existsInA() && pMFI->existsInB());
     d->m_pDirCurrentSyncMergeToA->setEnabled(bItemActive && !bMergeMode && !bFTConflict);
     d->m_pDirCurrentSyncMergeToB->setEnabled(bItemActive && !bMergeMode && !bFTConflict);
     d->m_pDirCurrentSyncMergeToAAndB->setEnabled(bItemActive && !bMergeMode && !bFTConflict);
 }
 
 //#include "directorymergewindow.moc"
diff --git a/src/directorymergewindow.h b/src/directorymergewindow.h
index 8bf75b8..41c06f6 100644
--- a/src/directorymergewindow.h
+++ b/src/directorymergewindow.h
@@ -1,172 +1,171 @@
 /*
  * KDiff3 - Text Diff And Merge Tool
- * 
+ *
  * SPDX-FileCopyrightText: 2002-2011 Joachim Eibl, joachim.eibl at gmx.de
  * SPDX-FileCopyrightText: 2018-2020 Michael Reeves reeves.87@gmail.com
  * SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #ifndef DIRECTORY_MERGE_WINDOW_H
 #define DIRECTORY_MERGE_WINDOW_H
 
 #include "common.h"
 #include "fileaccess.h"
 #include "diff.h" //TotalDiffStatus
 
 #include <QTreeWidget>
 #include <QEvent>
 
 #include <list>
 #include <map>
 
 class Options;
 class KIconLoader;
 class StatusInfo;
 class DirectoryMergeInfo;
 class OneDirectoryInfo;
 class QLabel;
 class QAction;
 class KToggleAction;
 class KActionCollection;
 class TotalDiffStatus;
 class DirectoryInfo;
 
 class MergeFileInfos;
 
 class KDiff3App;
 class DirectoryMergeWindow : public QTreeView
 {
    Q_OBJECT
  public:
    struct t_ItemInfo;
 
    DirectoryMergeWindow(QWidget* pParent, const QSharedPointer<Options>& pOptions);
    ~DirectoryMergeWindow() override;
    void setDirectoryMergeInfo(DirectoryMergeInfo* p);
    bool init(
       const QSharedPointer<DirectoryInfo>& dirInfo,
       bool bDirectoryMerge,
       bool bReload = false
    );
    bool isFileSelected();
    bool isDirectoryMergeInProgress();
    int totalColumnWidth();
    bool isSyncMode();
    bool isScanning();
    void initDirectoryMergeActions(KDiff3App* pKDiff3App, KActionCollection* ac);
 
    void setupConnections(const KDiff3App* app);
    void updateAvailabilities(bool bDirCompare, bool bDiffWindowVisible,
       KToggleAction* chooseA, KToggleAction* chooseB, KToggleAction* chooseC);
    void updateFileVisibilities();
 
    void mousePressEvent(QMouseEvent* e) override;
    void keyPressEvent(QKeyEvent* e) override;
    void focusInEvent(QFocusEvent* e) override;
    void focusOutEvent(QFocusEvent* e) override;
    void contextMenuEvent(QContextMenuEvent* e) override;
 
    QString getDirNameA() const;
    QString getDirNameB() const;
    QString getDirNameC() const;
    QString getDirNameDest() const;
 
  public Q_SLOTS:
    void reload();
    void mergeCurrentFile();
    void compareCurrentFile();
    void slotRunOperationForAllItems();
    void slotRunOperationForCurrentItem();
    void mergeResultSaved(const QString& fileName);
    void slotChooseAEverywhere();
    void slotChooseBEverywhere();
    void slotChooseCEverywhere();
    void slotAutoChooseEverywhere();
    void slotNoOpEverywhere();
    void slotFoldAllSubdirs();
    void slotUnfoldAllSubdirs();
    void slotShowIdenticalFiles();
    void slotShowDifferentFiles();
    void slotShowFilesOnlyInA();
    void slotShowFilesOnlyInB();
    void slotShowFilesOnlyInC();
 
    void slotSynchronizeDirectories();
    void slotChooseNewerFiles();
 
    void slotCompareExplicitlySelectedFiles();
    void slotMergeExplicitlySelectedFiles();
 
    // Merge current item (merge mode)
    void slotCurrentDoNothing();
    void slotCurrentChooseA();
    void slotCurrentChooseB();
    void slotCurrentChooseC();
    void slotCurrentMerge();
    void slotCurrentDelete();
    // Sync current item
    void slotCurrentCopyAToB();
    void slotCurrentCopyBToA();
    void slotCurrentDeleteA();
    void slotCurrentDeleteB();
    void slotCurrentDeleteAAndB();
    void slotCurrentMergeToA();
    void slotCurrentMergeToB();
    void slotCurrentMergeToAAndB();
 
    void slotSaveMergeState();
    void slotLoadMergeState();
 
    inline void slotRefresh() { updateFileVisibilities(); };
 
 Q_SIGNALS:
    void startDiffMerge(const QString& fn1, const QString& fn2, const QString& fn3, const QString& ofn, const QString&, const QString&, const QString&, TotalDiffStatus*);
-   void checkIfCanContinue(bool& pbContinue);
    void updateAvailabilities();
    void statusBarMessage(const QString& msg);
 protected Q_SLOTS:
    void onDoubleClick(const QModelIndex&);
    void onExpanded();
    void currentChanged(const QModelIndex& current, const QModelIndex& previous) override; // override
 private:
   int getIntFromIndex(const QModelIndex& index) const;
   const QSharedPointer<Options>& getOptions() const;
 
   class DirectoryMergeWindowPrivate;
   DirectoryMergeWindowPrivate* d;
   class DirMergeItemDelegate;
 };
 
 class DirectoryMergeInfo : public QFrame
 {
    Q_OBJECT
 public:
    explicit DirectoryMergeInfo(QWidget* pParent);
    void setInfo(
       const FileAccess& dirA,
       const FileAccess& dirB,
       const FileAccess& dirC,
       const FileAccess& dirDest,
       MergeFileInfos& mfi);
    QTreeWidget* getInfoList() { return m_pInfoList; }
    bool eventFilter(QObject* o, QEvent* e) override;
 Q_SIGNALS:
    void gotFocus();
 
 private:
    void addListViewItem(const QString& dir, const QString& basePath, FileAccess* fi);
 
    QLabel* m_pInfoA;
    QLabel* m_pInfoB;
    QLabel* m_pInfoC;
    QLabel* m_pInfoDest;
 
    QLabel* m_pA;
    QLabel* m_pB;
    QLabel* m_pC;
    QLabel* m_pDest;
 
    QTreeWidget* m_pInfoList;
 };
 
 #endif
diff --git a/src/kdiff3.cpp b/src/kdiff3.cpp
index f2d9f0c..6f8d46b 100644
--- a/src/kdiff3.cpp
+++ b/src/kdiff3.cpp
@@ -1,1059 +1,1060 @@
 /*
  *  This file is part of KDiff3.
  *
  * SPDX-FileCopyrightText: 2002-2011 Joachim Eibl, joachim.eibl at gmx.de
  * SPDX-FileCopyrightText: 2018-2020 Michael Reeves reeves.87@gmail.com
  * SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 // application specific includes
 #include "kdiff3.h"
 
 #include "directorymergewindow.h"
 #include "fileaccess.h"
 #include "guiutils.h"
 #include "kdiff3_part.h"
 #include "kdiff3_shell.h"
 #include "optiondialog.h"
 #include "progress.h"
 #include "smalldialogs.h"
 #include "difftextwindow.h"
 #include "mergeresultwindow.h"
 #include "RLPainter.h"
 #include "Utils.h"
 
 #ifndef Q_OS_WIN
 #include <unistd.h>
 #endif
 
 // include files for QT
 #include <QClipboard>
 #include <QCheckBox>
 #include <QCommandLineParser>
 #include <QDesktopWidget>
 #include <QDir>
 #include <QFileDialog>
 #include <QLabel>
 #include <QLayout>
 #include <QLineEdit>
 #include <QMenu>
 #include <QMenuBar>
 #include <QPaintDevice>
 #include <QPainter>
 #include <QPointer>
 #include <QPrintDialog>
 #include <QPrinter>
 #include <QPushButton>
 #include <QSplitter>
 #include <QStatusBar>
 #include <QTextStream>
 #include <QUrl>
 // include files for KDE
 #include <KCrash>
 #include <KConfig>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KStandardAction>
 #include <KActionCollection>
 #include <KIconLoader>
 #include <KTextEdit>
 #include <KToggleAction>
 #include <KToolBar>
 
 bool KDiff3App::m_bTripleDiff = false;
+boost::signals2::signal<bool (), and> KDiff3App::shouldContinue;
 
 #define ID_STATUS_MSG 1
 #define MAIN_TOOLBAR_NAME QLatin1String("mainToolBar")
 
 KActionCollection* KDiff3App::actionCollection() const
 {
     if(m_pKDiff3Shell == nullptr)
         return m_pKDiff3Part->actionCollection();
     else
         return m_pKDiff3Shell->actionCollection();
 }
 
 QStatusBar* KDiff3App::statusBar()
 {
     if(m_pKDiff3Shell == nullptr)
         return nullptr;
     else
         return m_pKDiff3Shell->statusBar();
 }
 
 KToolBar* KDiff3App::toolBar(const QLatin1String toolBarId)
 {
     if(m_pKDiff3Shell == nullptr)
         return nullptr;
     else
         return m_pKDiff3Shell->toolBar(toolBarId);
 }
 
 bool KDiff3App::isPart()
 {
     return m_pKDiff3Shell == nullptr;
 }
 
 bool KDiff3App::isFileSaved()
 {
     return m_bFileSaved;
 }
 
 bool KDiff3App::isDirComparison()
 {
     return m_bDirCompare;
 }
 
 /*
     Don't call completeInit from here it will be called in KDiff3Shell as needed.
 */
 KDiff3App::KDiff3App(QWidget* pParent, const QString& name, KDiff3Part* pKDiff3Part)
     : QSplitter(pParent) //previously KMainWindow
 {
     setObjectName(name);
     m_pKDiff3Part = pKDiff3Part;
     m_pKDiff3Shell = qobject_cast<KParts::MainWindow*>(pParent);
 
     setWindowTitle("KDiff3");
     setOpaqueResize(false); // faster resizing
     setUpdatesEnabled(false);
     KCrash::initialize();
 
     // set Disabled to same color as enabled to prevent flicker in DirectoryMergeWindow
     QPalette pal;
     pal.setBrush(QPalette::Base, pal.brush(QPalette::Active, QPalette::Base));
     pal.setColor(QPalette::Text, pal.color(QPalette::Active, QPalette::Text));
     setPalette(pal);
 
     // Needed before any file operations via FileAccess happen.
     if(g_pProgressDialog == nullptr)
     {
         g_pProgressDialog = new ProgressDialog(this, statusBar());
         g_pProgressDialog->setStayHidden(true);
     }
 
     // All default values must be set before calling readOptions().
     m_pOptionDialog = new OptionDialog(m_pKDiff3Shell != nullptr, this);
     connect(m_pOptionDialog, &OptionDialog::applyDone, this, &KDiff3App::slotRefresh);
 
     // This is just a convenience variable to make code that accesses options more readable
     m_pOptions = m_pOptionDialog->getOptions();
 
     m_pOptionDialog->readOptions(KSharedConfig::openConfig());
 
     // Option handling: Only when pParent==0 (no parent)
     int argCount = KDiff3Shell::getParser()->optionNames().count() + KDiff3Shell::getParser()->positionalArguments().count();
     bool hasArgs = !isPart() && argCount > 0;
     if(hasArgs) {
         QString s;
         QString title;
         if(KDiff3Shell::getParser()->isSet("confighelp"))
         {
             s = m_pOptionDialog->calcOptionHelp();
             title = i18n("Current Configuration:");
         }
         else
         {
             s = m_pOptionDialog->parseOptions(KDiff3Shell::getParser()->values("cs"));
             title = i18n("Config Option Error:");
         }
         if(!s.isEmpty())
         {
             //KMessageBox::information(0, s,i18n("KDiff3-Usage"));
 #ifndef Q_OS_WIN
             if(isatty(fileno(stderr)) != 1)
 #endif
             {
                 QPointer<QDialog> pDialog = QPointer<QDialog>(new QDialog(this));
                 pDialog->setAttribute(Qt::WA_DeleteOnClose);
                 pDialog->setModal(true);
                 pDialog->setWindowTitle(title);
                 QVBoxLayout* pVBoxLayout = new QVBoxLayout(pDialog);
                 QPointer<KTextEdit> pTextEdit = QPointer<KTextEdit>(new KTextEdit(pDialog));
                 pTextEdit->setText(s);
                 pTextEdit->setReadOnly(true);
                 pTextEdit->setWordWrapMode(QTextOption::NoWrap);
                 pVBoxLayout->addWidget(pTextEdit);
                 pDialog->resize(600, 400);
                 pDialog->exec();
             }
 #if !defined(Q_OS_WIN)
             else
             {
                 // Launched from a console
                 QTextStream outStream(stdout);
                 outStream << title << "\n";
                 outStream << s;//newline already appended by parseOptions
             }
 #endif
             exit(1);
         }
     }
 
     m_sd1->setOptions(m_pOptions);
     m_sd2->setOptions(m_pOptions);
     m_sd3->setOptions(m_pOptions);
 
 #ifdef ENABLE_AUTO
     m_bAutoFlag = hasArgs && KDiff3Shell::getParser()->isSet("auto") && !KDiff3Shell::getParser()->isSet("noauto");
 #else
     m_bAutoFlag = false;
 #endif
 
     m_bAutoMode = m_bAutoFlag || m_pOptions->m_bAutoSaveAndQuitOnMergeWithoutConflicts;
     if(hasArgs) {
         m_outputFilename = KDiff3Shell::getParser()->value("output");
 
         if(m_outputFilename.isEmpty())
             m_outputFilename = KDiff3Shell::getParser()->value("out");
 
         if(!m_outputFilename.isEmpty())
             m_outputFilename = FileAccess(m_outputFilename, true).absoluteFilePath();
 
         if(m_bAutoMode && m_outputFilename.isEmpty())
         {
             if(m_bAutoFlag)
             {
                 QTextStream(stderr) << i18n("Option --auto used, but no output file specified.") << "\n";
             }
             m_bAutoMode = false;
         }
 
         if(m_outputFilename.isEmpty() && KDiff3Shell::getParser()->isSet("merge"))
         {
             m_outputFilename = "unnamed.txt";
             m_bDefaultFilename = true;
         }
         else
         {
             m_bDefaultFilename = false;
         }
 
         g_bAutoSolve = !KDiff3Shell::getParser()->isSet("qall"); // Note that this is effective only once.
         QStringList args = KDiff3Shell::getParser()->positionalArguments();
 
         m_sd1->setFilename(KDiff3Shell::getParser()->value("base"));
         if(m_sd1->isEmpty()) {
             if(args.count() > 0) m_sd1->setFilename(args[0]); // args->arg(0)
             if(args.count() > 1) m_sd2->setFilename(args[1]);
             if(args.count() > 2) m_sd3->setFilename(args[2]);
         }
         else
         {
             if(args.count() > 0) m_sd2->setFilename(args[0]);
             if(args.count() > 1) m_sd3->setFilename(args[1]);
         }
         //Set m_bDirCompare flag
         m_bDirCompare = m_sd1->isDir();
 
         QStringList aliasList = KDiff3Shell::getParser()->values( "fname" );
         QStringList::Iterator ali = aliasList.begin();
 
         QString an1 = KDiff3Shell::getParser()->value("L1");
         if(!an1.isEmpty()) {
             m_sd1->setAliasName(an1);
         }
         else if(ali != aliasList.end())
         {
             m_sd1->setAliasName(*ali);
             ++ali;
         }
 
         QString an2 = KDiff3Shell::getParser()->value("L2");
         if(!an2.isEmpty()) {
             m_sd2->setAliasName(an2);
         }
         else if(ali != aliasList.end())
         {
             m_sd2->setAliasName(*ali);
             ++ali;
         }
 
         QString an3 = KDiff3Shell::getParser()->value("L3");
         if(!an3.isEmpty()) {
             m_sd3->setAliasName(an3);
         }
         else if(ali != aliasList.end())
         {
             m_sd3->setAliasName(*ali);
             ++ali;
         }
     }
     else
     {
         m_bDefaultFilename = false;
         g_bAutoSolve = false;
     }
     g_pProgressDialog->setStayHidden(m_bAutoMode);
 
     ///////////////////////////////////////////////////////////////////
     // call inits to invoke all other construction parts
     initActions(actionCollection());
     //Warning: Call this before connecting KDiff3App::slotUpdateAvailabilities or calling KXMLGUIClient::setXMLFile
     MergeResultWindow::initActions(actionCollection());
 
     initStatusBar();
 
     m_pFindDialog = new FindDialog(this);
     connect(m_pFindDialog, &FindDialog::findNext, this, &KDiff3App::slotEditFindNext);
 
     autoAdvance->setChecked(m_pOptions->m_bAutoAdvance);
     showWhiteSpaceCharacters->setChecked(m_pOptions->m_bShowWhiteSpaceCharacters);
     showWhiteSpace->setChecked(m_pOptions->m_bShowWhiteSpace);
     showWhiteSpaceCharacters->setEnabled(m_pOptions->m_bShowWhiteSpace);
     showLineNumbers->setChecked(m_pOptions->m_bShowLineNumbers);
     wordWrap->setChecked(m_pOptions->wordWrapOn());
     if(!isPart())
     {
         viewStatusBar->setChecked(m_pOptions->isStatusBarVisable());
         slotViewStatusBar();
 
         KToolBar *mainToolBar = toolBar(MAIN_TOOLBAR_NAME);
         if(mainToolBar != nullptr){
             mainToolBar->mainWindow()->addToolBar(m_pOptions->getToolbarPos(), mainToolBar);
         }
         //   TODO restore window size/pos?
         /*      QSize size = m_pOptions->m_geometry;
               QPoint pos = m_pOptions->m_position;
               if(!size.isEmpty())
               {
                  m_pKDiff3Shell->resize( size );
                  QRect visibleRect = QRect( pos, size ) & QApplication::desktop()->rect();
                  if ( visibleRect.width()>100 && visibleRect.height()>100 )
                     m_pKDiff3Shell->move( pos );
               }*/
     }
     slotRefresh();
 
     m_pMainSplitter = this;
     m_pMainSplitter->setOrientation(Qt::Vertical);
     //   setCentralWidget( m_pMainSplitter );
     m_pDirectoryMergeSplitter = new QSplitter(m_pMainSplitter);
     m_pDirectoryMergeSplitter->setObjectName("DirectoryMergeSplitter");
     m_pMainSplitter->addWidget(m_pDirectoryMergeSplitter);
     m_pDirectoryMergeSplitter->setOrientation(Qt::Horizontal);
     m_pDirectoryMergeWindow = new DirectoryMergeWindow(m_pDirectoryMergeSplitter, m_pOptions);
     m_pDirectoryMergeSplitter->addWidget(m_pDirectoryMergeWindow);
     m_pDirectoryMergeInfo = new DirectoryMergeInfo(m_pDirectoryMergeSplitter);
     m_pDirectoryMergeWindow->setDirectoryMergeInfo(m_pDirectoryMergeInfo);
     m_pDirectoryMergeSplitter->addWidget(m_pDirectoryMergeInfo);
     //Warning: Make sure DirectoryMergeWindow::initActions is called before this point or we can crash when selectionChanged is sent.
     m_pDirectoryMergeWindow->setupConnections(this);
 
     connect(QApplication::clipboard(), &QClipboard::dataChanged, this, &KDiff3App::slotClipboardChanged);
     connect(this, &KDiff3App::sigRecalcWordWrap, this, &KDiff3App::slotRecalcWordWrap, Qt::QueuedConnection);
-    connect(this, &KDiff3App::checkIfCanContinue, this, &KDiff3App::slotCheckIfCanContinue);
+    connections.push_back(shouldContinue.connect(boost::bind(&KDiff3App::canContinue, this)));
     connect(this, &KDiff3App::finishDrop, this, &KDiff3App::slotFinishDrop);
 
     m_pDirectoryMergeWindow->initDirectoryMergeActions(this, actionCollection());
 
     delete KDiff3Shell::getParser();
 }
 
 void KDiff3App::completeInit(const QString& fn1, const QString& fn2, const QString& fn3)
 {
     if(m_pKDiff3Shell != nullptr)
     {
         QSize size = m_pOptions->getGeometry();
         QPoint pos = m_pOptions->getPosition();
         if(!size.isEmpty())
         {
             m_pKDiff3Shell->resize(size);
 
             QRect visibleRect = QRect(pos, size) & QApplication::desktop()->rect();
             if(visibleRect.width() > 100 && visibleRect.height() > 100)
                 m_pKDiff3Shell->move(pos);
             if(!m_bAutoMode)
             {
                 //Here we want the extra setup showMaximized does since the window has not be shown before
                 if(m_pOptions->isMaximised())
                     m_pKDiff3Shell->showMaximized();// krazy:exclude=qmethods
                 else
                     m_pKDiff3Shell->show();
             }
         }
     }
     if(!fn1.isEmpty()) {
         m_sd1->setFilename(fn1);
         m_bDirCompare = m_sd1->isDir();
     }
     if(!fn2.isEmpty()) {
         m_sd2->setFilename(fn2);
     }
     if(!fn3.isEmpty()) {
         m_sd3->setFilename(fn3);
     }
 
     //should not happen now.
     Q_ASSERT(m_bDirCompare == m_sd1->isDir());
     bool bSuccess = improveFilenames(false);
 
     if(m_bAutoFlag && m_bAutoMode && m_bDirCompare)
     {
         QTextStream(stderr) << i18n("Option --auto ignored for folder comparison.") << "\n";
         m_bAutoMode = false;
     }
     if(!m_bDirCompare)
     {
         m_pDirectoryMergeSplitter->hide();
 
         mainInit();
         if(m_bAutoMode)
         {
             QSharedPointer<SourceData> pSD = nullptr;
             if(m_sd3->isEmpty()) {
                 if(m_totalDiffStatus.isBinaryEqualAB()) {
                     pSD = m_sd1;
                 }
             }
             else
             {
                 if(m_totalDiffStatus.isBinaryEqualBC() || m_totalDiffStatus.isBinaryEqualAB())
                 {
                     //if B==C (assume A is old), if A==B then C has changed
                     pSD = m_sd3;
                 }
                 else if(m_totalDiffStatus.isBinaryEqualAC())
                 {
                     pSD = m_sd2; // assuming B has changed
                 }
             }
 
             if(pSD != nullptr)
             {
                 // Save this file directly, not via the merge result window.
                 FileAccess fa(m_outputFilename);
                 if(m_pOptions->m_bDmCreateBakFiles && fa.exists())
                 {
                     fa.createBackup(".orig");
                 }
 
                 bSuccess = pSD->saveNormalDataAs(m_outputFilename);
                 if(bSuccess)
                     ::exit(0);
                 else
                     KMessageBox::error(this, i18n("Saving failed."));
             }
             else if(m_pMergeResultWindow->getNrOfUnsolvedConflicts() == 0)
             {
                 bSuccess = m_pMergeResultWindow->saveDocument(m_pMergeResultWindowTitle->getFileName(), m_pMergeResultWindowTitle->getEncoding(), m_pMergeResultWindowTitle->getLineEndStyle());
                 if(bSuccess) ::exit(0);
             }
         }
     }
     m_bAutoMode = false;
 
     if(m_pKDiff3Shell != nullptr)
     {
         if(m_pOptions->isMaximised())
             //We want showMaximized here as the window has never been shown.
             m_pKDiff3Shell->showMaximized();// krazy:exclude=qmethods
         else
             m_pKDiff3Shell->show();
     }
 
     g_pProgressDialog->setStayHidden(false);
 
     if(statusBar() != nullptr)
         statusBar()->setSizeGripEnabled(true);
 
     slotClipboardChanged(); // For initialisation.
 
     slotUpdateAvailabilities();
 
     if(!m_bDirCompare && m_pKDiff3Shell != nullptr)
     {
         bool bFileOpenError = false;
         if((!m_sd1->isEmpty() && !m_sd1->hasData()) ||
            (!m_sd2->isEmpty() && !m_sd2->hasData()) ||
            (!m_sd3->isEmpty() && !m_sd3->hasData()))
         {
             QString text(i18n("Opening of these files failed:"));
             text += "\n\n";
             if(!m_sd1->isEmpty() && !m_sd1->hasData())
                 text += " - " + m_sd1->getAliasName() + '\n';
             if(!m_sd2->isEmpty() && !m_sd2->hasData())
                 text += " - " + m_sd2->getAliasName() + '\n';
             if(!m_sd3->isEmpty() && !m_sd3->hasData())
                 text += " - " + m_sd3->getAliasName() + '\n';
 
             KMessageBox::sorry(this, text, i18n("File Open Error"));
             bFileOpenError = true;
         }
 
         if(m_sd1->isEmpty() || m_sd2->isEmpty() || bFileOpenError)
             slotFileOpen();
     }
     else if(!bSuccess) // Directory open failed
     {
         slotFileOpen();
     }
 }
 
 KDiff3App::~KDiff3App()
 {
 }
 
 /**
  * Helper function used to create actions into the ac collection
  */
 
 void KDiff3App::initActions(KActionCollection* ac)
 {
     if(ac == nullptr){
         KMessageBox::error(nullptr, "actionCollection==0");
         exit(-1);//we cannot recover from this.
     }
     fileOpen = KStandardAction::open(this, &KDiff3App::slotFileOpen, ac);
     fileOpen->setStatusTip(i18n("Opens documents for comparison..."));
 
     fileReload = GuiUtils::createAction<QAction>(i18n("Reload"), QKeySequence(QKeySequence::Refresh), this, &KDiff3App::slotReload, ac, QLatin1String("file_reload"));
 
     fileSave = KStandardAction::save(this, &KDiff3App::slotFileSave, ac);
     fileSave->setStatusTip(i18n("Saves the merge result. All conflicts must be solved!"));
     fileSaveAs = KStandardAction::saveAs(this, &KDiff3App::slotFileSaveAs, ac);
     fileSaveAs->setStatusTip(i18n("Saves the current document as..."));
 #ifndef QT_NO_PRINTER
     filePrint = KStandardAction::print(this, &KDiff3App::slotFilePrint, ac);
     filePrint->setStatusTip(i18n("Print the differences"));
 #endif
     fileQuit = KStandardAction::quit(this, &KDiff3App::slotFileQuit, ac);
     fileQuit->setStatusTip(i18n("Quits the application"));
     editCut = KStandardAction::cut(this, &KDiff3App::slotEditCut, ac);
     editCut->setShortcuts(QKeySequence::Cut);
     editCut->setStatusTip(i18n("Cuts the selected section and puts it to the clipboard"));
     editCopy = KStandardAction::copy(this, &KDiff3App::slotEditCopy, ac);
     editCopy->setShortcut(QKeySequence::Copy);
     editCopy->setStatusTip(i18n("Copies the selected section to the clipboard"));
     editPaste = KStandardAction::paste(this, &KDiff3App::slotEditPaste, ac);
     editPaste->setStatusTip(i18n("Pastes the clipboard contents to current position"));
     editPaste->setShortcut(QKeySequence::Paste);
     editSelectAll = KStandardAction::selectAll(this, &KDiff3App::slotEditSelectAll, ac);
     editSelectAll->setStatusTip(i18n("Select everything in current window"));
     editFind = KStandardAction::find(this, &KDiff3App::slotEditFind, ac);
     editFind->setShortcut(QKeySequence::Find);
     editFind->setStatusTip(i18n("Search for a string"));
     editFindNext = KStandardAction::findNext(this, &KDiff3App::slotEditFindNext, ac);
     editFindNext->setStatusTip(i18n("Search again for the string"));
     /*   FIXME figure out how to implement this action
        viewToolBar = KStandardAction::showToolbar(this, &KDiff3App::slotViewToolBar, ac);
        viewToolBar->setStatusTip(i18n("Enables/disables the toolbar")); */
     viewStatusBar = KStandardAction::showStatusbar(this, &KDiff3App::slotViewStatusBar, ac);
     viewStatusBar->setStatusTip(i18n("Enables/disables the statusbar"));
     KStandardAction::keyBindings(this, &KDiff3App::slotConfigureKeys, ac);
     QAction* pAction = KStandardAction::preferences(this, &KDiff3App::slotConfigure, ac);
     if(isPart())
         pAction->setText(i18n("Configure KDiff3..."));
 
 #include "xpm/autoadvance.xpm"
 #include "xpm/currentpos.xpm"
 #include "xpm/down1arrow.xpm"
 #include "xpm/down2arrow.xpm"
 #include "xpm/downend.xpm"
 #include "xpm/iconA.xpm"
 #include "xpm/iconB.xpm"
 #include "xpm/iconC.xpm"
 #include "xpm/nextunsolved.xpm"
 #include "xpm/prevunsolved.xpm"
 #include "xpm/showlinenumbers.xpm"
 #include "xpm/showwhitespace.xpm"
 #include "xpm/showwhitespacechars.xpm"
 #include "xpm/up1arrow.xpm"
 #include "xpm/up2arrow.xpm"
 #include "xpm/upend.xpm"
 
     mGoCurrent = GuiUtils::createAction<QAction>(i18n("Go to Current Delta"), QIcon(QPixmap(currentpos)), i18n("Current\nDelta"), QKeySequence(Qt::CTRL + Qt::Key_Space), this, &KDiff3App::slotGoCurrent, ac, "go_current");
 
     mGoTop = GuiUtils::createAction<QAction>(i18n("Go to First Delta"), QIcon(QPixmap(upend)), i18n("First\nDelta"), this, &KDiff3App::slotGoTop, ac, "go_top");
 
     mGoBottom = GuiUtils::createAction<QAction>(i18n("Go to Last Delta"), QIcon(QPixmap(downend)), i18n("Last\nDelta"), this, &KDiff3App::slotGoBottom, ac, "go_bottom");
 
     QString omitsWhitespace = ".\n" + i18n("(Skips white space differences when \"Show White Space\" is disabled.)");
     QString includeWhitespace = ".\n" + i18n("(Does not skip white space differences even when \"Show White Space\" is disabled.)");
     mGoPrevDelta = GuiUtils::createAction<QAction>(i18n("Go to Previous Delta"), QIcon(QPixmap(up1arrow)), i18n("Prev\nDelta"), QKeySequence(Qt::CTRL + Qt::Key_Up), this, &KDiff3App::slotGoPrevDelta, ac, "go_prev_delta");
     mGoPrevDelta->setToolTip(mGoPrevDelta->text() + omitsWhitespace);
     mGoNextDelta = GuiUtils::createAction<QAction>(i18n("Go to Next Delta"), QIcon(QPixmap(down1arrow)), i18n("Next\nDelta"), QKeySequence(Qt::CTRL + Qt::Key_Down), this, &KDiff3App::slotGoNextDelta, ac, "go_next_delta");
     mGoNextDelta->setToolTip(mGoNextDelta->text() + omitsWhitespace);
     mGoPrevConflict = GuiUtils::createAction<QAction>(i18n("Go to Previous Conflict"), QIcon(QPixmap(up2arrow)), i18n("Prev\nConflict"), QKeySequence(Qt::CTRL + Qt::Key_PageUp), this, &KDiff3App::slotGoPrevConflict, ac, "go_prev_conflict");
     mGoPrevConflict->setToolTip(mGoPrevConflict->text() + omitsWhitespace);
     mGoNextConflict = GuiUtils::createAction<QAction>(i18n("Go to Next Conflict"), QIcon(QPixmap(down2arrow)), i18n("Next\nConflict"), QKeySequence(Qt::CTRL + Qt::Key_PageDown), this, &KDiff3App::slotGoNextConflict, ac, "go_next_conflict");
     mGoNextConflict->setToolTip(mGoNextConflict->text() + omitsWhitespace);
     mGoPrevUnsolvedConflict = GuiUtils::createAction<QAction>(i18n("Go to Previous Unsolved Conflict"), QIcon(QPixmap(prevunsolved)), i18n("Prev\nUnsolved"), this, &KDiff3App::slotGoPrevUnsolvedConflict, ac, "go_prev_unsolved_conflict");
     mGoPrevUnsolvedConflict->setToolTip(mGoPrevUnsolvedConflict->text() + includeWhitespace);
     mGoNextUnsolvedConflict = GuiUtils::createAction<QAction>(i18n("Go to Next Unsolved Conflict"), QIcon(QPixmap(nextunsolved)), i18n("Next\nUnsolved"), this, &KDiff3App::slotGoNextUnsolvedConflict, ac, "go_next_unsolved_conflict");
     mGoNextUnsolvedConflict->setToolTip(mGoNextUnsolvedConflict->text() + includeWhitespace);
     chooseA = GuiUtils::createAction<KToggleAction>(i18n("Select Line(s) From A"), QIcon(QPixmap(iconA)), i18n("Choose\nA"), QKeySequence(Qt::CTRL + Qt::Key_1), this, &KDiff3App::slotChooseA, ac, "merge_choose_a");
     chooseB = GuiUtils::createAction<KToggleAction>(i18n("Select Line(s) From B"), QIcon(QPixmap(iconB)), i18n("Choose\nB"), QKeySequence(Qt::CTRL + Qt::Key_2), this, &KDiff3App::slotChooseB, ac, "merge_choose_b");
     chooseC = GuiUtils::createAction<KToggleAction>(i18n("Select Line(s) From C"), QIcon(QPixmap(iconC)), i18n("Choose\nC"), QKeySequence(Qt::CTRL + Qt::Key_3), this, &KDiff3App::slotChooseC, ac, "merge_choose_c");
     autoAdvance = GuiUtils::createAction<KToggleAction>(i18n("Automatically Go to Next Unsolved Conflict After Source Selection"), QIcon(QPixmap(autoadvance)), i18n("Auto\nNext"), this, &KDiff3App::slotAutoAdvanceToggled, ac, "merge_autoadvance");
 
     showWhiteSpaceCharacters = GuiUtils::createAction<KToggleAction>(i18n("Show Space && Tabulator Characters"), QIcon(QPixmap(showwhitespacechars)), i18n("White\nCharacters"), this, &KDiff3App::slotShowWhiteSpaceToggled, ac, "diff_show_whitespace_characters");
     showWhiteSpace = GuiUtils::createAction<KToggleAction>(i18n("Show White Space"), QIcon(QPixmap(showwhitespace)), i18n("White\nDeltas"), this, &KDiff3App::slotShowWhiteSpaceToggled, ac, "diff_show_whitespace");
 
     showLineNumbers = GuiUtils::createAction<KToggleAction>(i18n("Show Line Numbers"), QIcon(QPixmap(showlinenumbers)), i18n("Line\nNumbers"), this, &KDiff3App::slotShowLineNumbersToggled, ac, "diff_showlinenumbers");
 
     mAutoSolve = GuiUtils::createAction<QAction>(i18n("Automatically Solve Simple Conflicts"), this, &KDiff3App::slotAutoSolve, ac, "merge_autosolve");
     mUnsolve = GuiUtils::createAction<QAction>(i18n("Set Deltas to Conflicts"), this, &KDiff3App::slotUnsolve, ac, "merge_autounsolve");
     mergeRegExp = GuiUtils::createAction<QAction>(i18n("Run Regular Expression Auto Merge"), this, &KDiff3App::slotRegExpAutoMerge, ac, "merge_regexp_automerge");
     mMergeHistory = GuiUtils::createAction<QAction>(i18n("Automatically Solve History Conflicts"), this, &KDiff3App::slotMergeHistory, ac, "merge_versioncontrol_history");
     splitDiff = GuiUtils::createAction<QAction>(i18n("Split Diff At Selection"), this, &KDiff3App::slotSplitDiff, ac, "merge_splitdiff");
     joinDiffs = GuiUtils::createAction<QAction>(i18n("Join Selected Diffs"), this, &KDiff3App::slotJoinDiffs, ac, "merge_joindiffs");
 
     showWindowA = GuiUtils::createAction<KToggleAction>(i18n("Show Window A"), this, &KDiff3App::slotShowWindowAToggled, ac, "win_show_a");
     showWindowB = GuiUtils::createAction<KToggleAction>(i18n("Show Window B"), this, &KDiff3App::slotShowWindowBToggled, ac, "win_show_b");
     showWindowC = GuiUtils::createAction<KToggleAction>(i18n("Show Window C"), this, &KDiff3App::slotShowWindowCToggled, ac, "win_show_c");
 
     overviewModeNormal = GuiUtils::createAction<KToggleAction>(i18n("Normal Overview"), this, &KDiff3App::slotOverviewNormal, ac, "diff_overview_normal");
     overviewModeAB = GuiUtils::createAction<KToggleAction>(i18n("A vs. B Overview"), this, &KDiff3App::slotOverviewAB, ac, "diff_overview_ab");
     overviewModeAC = GuiUtils::createAction<KToggleAction>(i18n("A vs. C Overview"), this, &KDiff3App::slotOverviewAC, ac, "diff_overview_ac");
     overviewModeBC = GuiUtils::createAction<KToggleAction>(i18n("B vs. C Overview"), this, &KDiff3App::slotOverviewBC, ac, "diff_overview_bc");
     wordWrap = GuiUtils::createAction<KToggleAction>(i18n("Word Wrap Diff Windows"), this, &KDiff3App::slotWordWrapToggled, ac, "diff_wordwrap");
     addManualDiffHelp = GuiUtils::createAction<QAction>(i18n("Add Manual Diff Alignment"), QKeySequence(Qt::CTRL + Qt::Key_Y), this, &KDiff3App::slotAddManualDiffHelp, ac, "diff_add_manual_diff_help");
     clearManualDiffHelpList = GuiUtils::createAction<QAction>(i18n("Clear All Manual Diff Alignments"), QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_Y), this, &KDiff3App::slotClearManualDiffHelpList, ac, "diff_clear_manual_diff_help_list");
 
     winFocusNext = GuiUtils::createAction<QAction>(i18n("Focus Next Window"), QKeySequence(Qt::ALT + Qt::Key_Right), this, &KDiff3App::slotWinFocusNext, ac, "win_focus_next");
     winFocusPrev = GuiUtils::createAction<QAction>(i18n("Focus Prev Window"), QKeySequence(Qt::ALT + Qt::Key_Left), this, &KDiff3App::slotWinFocusPrev, ac, "win_focus_prev");
     winToggleSplitOrientation = GuiUtils::createAction<QAction>(i18n("Toggle Split Orientation"), this, &KDiff3App::slotWinToggleSplitterOrientation, ac, "win_toggle_split_orientation");
 
     dirShowBoth = GuiUtils::createAction<KToggleAction>(i18n("Folder && Text Split Screen View"), this, &KDiff3App::slotDirShowBoth, ac, "win_dir_show_both");
     dirShowBoth->setChecked(true);
     dirViewToggle = GuiUtils::createAction<QAction>(i18n("Toggle Between Folder && Text View"), this, &KDiff3App::slotDirViewToggle, ac, "win_dir_view_toggle");
 
     m_pMergeEditorPopupMenu = new QMenu(this);
     /*   chooseA->plug( m_pMergeEditorPopupMenu );
        chooseB->plug( m_pMergeEditorPopupMenu );
        chooseC->plug( m_pMergeEditorPopupMenu );*/
     m_pMergeEditorPopupMenu->addAction(chooseA);
     m_pMergeEditorPopupMenu->addAction(chooseB);
     m_pMergeEditorPopupMenu->addAction(chooseC);
 }
 
 void KDiff3App::showPopupMenu(const QPoint& point)
 {
     m_pMergeEditorPopupMenu->popup(point);
 }
 
 void KDiff3App::initStatusBar()
 {
     ///////////////////////////////////////////////////////////////////
     // STATUSBAR
     if(statusBar() != nullptr)
         statusBar()->showMessage(i18n("Ready."));
 }
 
 void KDiff3App::saveOptions(KSharedConfigPtr config)
 {
     if(!m_bAutoMode)
     {
         if(!isPart())
         {
             m_pOptions->setMaximised(m_pKDiff3Shell->isMaximized());
             if(!m_pKDiff3Shell->isMaximized() && m_pKDiff3Shell->isVisible())
             {
                 m_pOptions->setGeometry(m_pKDiff3Shell->size());
                 m_pOptions->setPosition(m_pKDiff3Shell->pos());
             }
             /*  TODO change this option as now KToolbar uses QToolbar positioning style
                      if ( toolBar(MAIN_TOOLBAR_NAME)!=0 )
                         m_pOptionDialog->m_toolBarPos = (int) toolBar(MAIN_TOOLBAR_NAME)->allowedAreas();*/
         }
 
         m_pOptionDialog->saveOptions(std::move(config));
     }
 }
 
 bool KDiff3App::queryClose()
 {
     saveOptions(KSharedConfig::openConfig());
 
     if(m_bOutputModified)
     {
         int result = KMessageBox::warningYesNoCancel(this,
                                                      i18n("The merge result has not been saved."),
                                                      i18n("Warning"),
                                                      KGuiItem(i18n("Save && Quit")),
                                                      KGuiItem(i18n("Quit Without Saving")));
         if(result == KMessageBox::Cancel)
             return false;
         else if(result == KMessageBox::Yes)
         {
             slotFileSave();
             if(m_bOutputModified)
             {
                 KMessageBox::sorry(this, i18n("Saving the merge result failed."), i18n("Warning"));
                 return false;
             }
         }
     }
 
     m_bOutputModified = false;
 
     if(m_pDirectoryMergeWindow->isDirectoryMergeInProgress())
     {
         int result = KMessageBox::warningYesNo(this,
                                                i18n("You are currently doing a folder merge. Are you sure, you want to abort?"),
                                                i18n("Warning"),
                                                KStandardGuiItem::quit(),
                                                KStandardGuiItem::cont() /* i18n("Continue Merging") */);
         if(result != KMessageBox::Yes)
             return false;
     }
 
     return true;
 }
 
 /////////////////////////////////////////////////////////////////////
 // SLOT IMPLEMENTATION
 /////////////////////////////////////////////////////////////////////
 
 void KDiff3App::slotFileSave()
 {
     if(m_bDefaultFilename)
     {
         slotFileSaveAs();
     }
     else
     {
         slotStatusMsg(i18n("Saving file..."));
 
         bool bSuccess = m_pMergeResultWindow->saveDocument(m_outputFilename, m_pMergeResultWindowTitle->getEncoding(), m_pMergeResultWindowTitle->getLineEndStyle());
         if(bSuccess)
         {
             m_bFileSaved = true;
             m_bOutputModified = false;
             if(m_bDirCompare)
                 m_pDirectoryMergeWindow->mergeResultSaved(m_outputFilename);
         }
 
         slotStatusMsg(i18n("Ready."));
     }
 }
 
 void KDiff3App::slotFileSaveAs()
 {
     slotStatusMsg(i18n("Saving file with a new filename..."));
 
     QString s = QFileDialog::getSaveFileUrl(this, i18n("Save As..."), QUrl::fromLocalFile(QDir::currentPath())).url(QUrl::PreferLocalFile);
     if(!s.isEmpty()) {
         m_outputFilename = s;
         m_pMergeResultWindowTitle->setFileName(m_outputFilename);
         bool bSuccess = m_pMergeResultWindow->saveDocument(m_outputFilename, m_pMergeResultWindowTitle->getEncoding(), m_pMergeResultWindowTitle->getLineEndStyle());
         if(bSuccess)
         {
             m_bOutputModified = false;
             if(m_bDirCompare)
                 m_pDirectoryMergeWindow->mergeResultSaved(m_outputFilename);
         }
         //setWindowTitle(url.fileName(),doc->isModified());
 
         m_bDefaultFilename = false;
     }
 
     slotStatusMsg(i18n("Ready."));
 }
 
 void KDiff3App::slotFilePrint()
 {
     if(m_pDiffTextWindow1 == nullptr || m_pDiffTextWindow2 == nullptr)
         return;
 #ifdef QT_NO_PRINTER
     slotStatusMsg(i18n("Printing not implemented."));
 #else
     QPrinter printer;
     QPointer<QPrintDialog> printDialog=QPointer<QPrintDialog>(new QPrintDialog(&printer, this));
 
     LineRef firstSelectionD3LIdx;
     LineRef lastSelectionD3LIdx;
 
     m_pDiffTextWindow1->getSelectionRange(&firstSelectionD3LIdx, &lastSelectionD3LIdx, eD3LLineCoords);
 
     if(!firstSelectionD3LIdx.isValid()) {
         m_pDiffTextWindow2->getSelectionRange(&firstSelectionD3LIdx, &lastSelectionD3LIdx, eD3LLineCoords);
     }
     if(!firstSelectionD3LIdx.isValid() && m_pDiffTextWindow3 != nullptr) {
         m_pDiffTextWindow3->getSelectionRange(&firstSelectionD3LIdx, &lastSelectionD3LIdx, eD3LLineCoords);
     }
 
     printDialog->setOption(QPrintDialog::PrintCurrentPage);
 
     if(firstSelectionD3LIdx.isValid()) {
         printDialog->setOption(QPrintDialog::PrintSelection);
         printDialog->setPrintRange(QAbstractPrintDialog::Selection);
     }
 
     if(!firstSelectionD3LIdx.isValid())
         printDialog->setPrintRange(QAbstractPrintDialog::AllPages);
     //printDialog.setMinMax(0,0);
     printDialog->setFromTo(0, 0);
 
     int currentFirstLine = m_pDiffTextWindow1->getFirstLine();
     int currentFirstD3LIdx = m_pDiffTextWindow1->convertLineToDiff3LineIdx(currentFirstLine);
 
     // do some printer initialization
     printer.setFullPage(false);
 
     // initialize the printer using the print dialog
     if(printDialog->exec() == QDialog::Accepted)
     {
         slotStatusMsg(i18n("Printing..."));
         // create a painter to paint on the printer object
         RLPainter painter(&printer, m_pOptions->m_bRightToLeftLanguage, width(), Utils::getHorizontalAdvance(fontMetrics(),'W'));
 
         QPaintDevice* pPaintDevice = painter.device();
         int dpiy = pPaintDevice->logicalDpiY();
         int columnDistance = qRound((0.5 / 2.54) * dpiy); // 0.5 cm between the columns
 
         int columns = m_bTripleDiff ? 3 : 2;
         int columnWidth = (pPaintDevice->width() - (columns - 1) * columnDistance) / columns;
 
         QFont f = m_pOptions->m_font;
         f.setPointSizeF(f.pointSizeF() - 1); // Print with slightly smaller font.
         painter.setFont(f);
         QFontMetrics fm = painter.fontMetrics();
 
         QString topLineText = i18n("Top line");
 
         //int headerWidth = fm.width( m_sd1->getAliasName() + ", "+topLineText+": 01234567" );
         int headerLines = Utils::getHorizontalAdvance(fm, m_sd1->getAliasName() + ", " + topLineText + ": 01234567") / columnWidth + 1;
 
         int headerMargin = headerLines * fm.height() + 3; // Text + one horizontal line
         int footerMargin = fm.height() + 3;
 
         QRect view(0, headerMargin, pPaintDevice->width(), pPaintDevice->height() - (headerMargin + footerMargin));
         QRect view1(0 * (columnWidth + columnDistance), view.top(), columnWidth, view.height());
         QRect view2(1 * (columnWidth + columnDistance), view.top(), columnWidth, view.height());
         QRect view3(2 * (columnWidth + columnDistance), view.top(), columnWidth, view.height());
 
         int linesPerPage = view.height() / fm.lineSpacing();
 
         m_pEventLoopForPrinting = QPointer<QEventLoop>(new QEventLoop());
         if(m_pOptions->wordWrapOn())
         {
             // For printing the lines are wrapped differently (this invalidates the first line)
             recalcWordWrap(columnWidth);
             m_pEventLoopForPrinting->exec();
         }
 
         LineCount totalNofLines = std::max(m_pDiffTextWindow1->getNofLines(), m_pDiffTextWindow2->getNofLines());
 
         if(m_bTripleDiff && m_pDiffTextWindow3 != nullptr)
             totalNofLines = std::max(totalNofLines, m_pDiffTextWindow3->getNofLines());
 
         QList<int> pageList; // = printer.pageList();
 
         bool bPrintCurrentPage = false;
         bool bFirstPrintedPage = false;
 
         bool bPrintSelection = false;
         int totalNofPages = (totalNofLines + linesPerPage - 1) / linesPerPage;
         LineRef line;
         LineRef selectionEndLine;
 
         if(printer.printRange() == QPrinter::AllPages) {
             pageList.clear();
             for(int i = 0; i < totalNofPages; ++i)
             {
                 pageList.push_back(i + 1);
             }
         }
         else if(printer.printRange() == QPrinter::PageRange)
         {
             pageList.clear();
 
             int from = printer.fromPage(), to = printer.toPage();
             /*
                 Per Qt docs QPrinter::fromPage and QPrinter::toPage return 0 to indicate they are not set.
                 Account for this and other invalid settings the user may try.
             */
             if(from == 0) from = 1;
             if(from > totalNofPages) from = totalNofPages;
             if(to == 0 || to > totalNofPages) to = totalNofPages;
             if(from > to) to = from;
 
             for(int i = from; i <= to; ++i)
             {
                 pageList.push_back(i);
             }
         }
         else if(printer.printRange() == QPrinter::CurrentPage)
         {
             bPrintCurrentPage = true;
             totalNofPages = 1;
         }
         else if(printer.printRange() == QPrinter::Selection)
         {
             bPrintSelection = true;
             if(firstSelectionD3LIdx.isValid())
             {
                 line = m_pDiffTextWindow1->convertDiff3LineIdxToLine(firstSelectionD3LIdx);
                 selectionEndLine = m_pDiffTextWindow1->convertDiff3LineIdxToLine(lastSelectionD3LIdx + 1);
                 totalNofPages = (selectionEndLine - line + linesPerPage - 1) / linesPerPage;
             }
         }
 
         int page = 1;
 
         ProgressProxy pp;
         pp.setMaxNofSteps(totalNofPages);
         QList<int>::iterator pageListIt = pageList.begin();
         for(;;) {
             pp.setInformation(i18n("Printing page %1 of %2", page, totalNofPages), false);
             pp.setCurrent(page - 1);
             if(pp.wasCancelled())
             {
                 printer.abort();
                 break;
             }
             if(!bPrintSelection) {
                 if(pageListIt == pageList.end())
                     break;
                 page = *pageListIt;
                 line = (page - 1) * linesPerPage;
 
                 if(bPrintCurrentPage)
                 {
                     // Detect the first visible line in the window.
                     line = m_pDiffTextWindow1->convertDiff3LineIdxToLine(currentFirstD3LIdx);
                 }
             }
             else
             {
                 if(line >= selectionEndLine) {
                     break;
                 }
                 else
                 {
                     if(selectionEndLine - line < linesPerPage)
                         linesPerPage = selectionEndLine - line;
                 }
             }
             if(line.isValid() && line < totalNofLines)
             {
                 if(bFirstPrintedPage)
                     printer.newPage();
 
                 painter.setClipping(true);
 
                 painter.setPen(m_pOptions->m_colorA);
                 QString headerText1 = m_sd1->getAliasName() + ", " + topLineText + ": " + QString::number(m_pDiffTextWindow1->calcTopLineInFile(line) + 1);
                 m_pDiffTextWindow1->printWindow(painter, view1, headerText1, line, linesPerPage, m_pOptions->m_fgColor);
 
                 painter.setPen(m_pOptions->m_colorB);
                 QString headerText2 = m_sd2->getAliasName() + ", " + topLineText + ": " + QString::number(m_pDiffTextWindow2->calcTopLineInFile(line) + 1);
                 m_pDiffTextWindow2->printWindow(painter, view2, headerText2, line, linesPerPage, m_pOptions->m_fgColor);
 
                 if(m_bTripleDiff && m_pDiffTextWindow3 != nullptr)
                 {
                     painter.setPen(m_pOptions->m_colorC);
                     QString headerText3 = m_sd3->getAliasName() + ", " + topLineText + ": " + QString::number(m_pDiffTextWindow3->calcTopLineInFile(line) + 1);
                     m_pDiffTextWindow3->printWindow(painter, view3, headerText3, line, linesPerPage, m_pOptions->m_fgColor);
                 }
                 painter.setClipping(false);
 
                 painter.setPen(m_pOptions->m_fgColor);
                 painter.drawLine(0, view.bottom() + 3, view.width(), view.bottom() + 3);
                 QString s = bPrintCurrentPage ? QString("")
                                               : QString::number(page) + '/' + QString::number(totalNofPages);
                 if(bPrintSelection) s += i18n(" (Selection)");
                 painter.drawText((view.right() - Utils::getHorizontalAdvance(painter.fontMetrics(), s)) / 2,
                                  view.bottom() + painter.fontMetrics().ascent() + 5, s);
 
                 bFirstPrintedPage = true;
                 if(bPrintCurrentPage) break;
             }
 
             if(bPrintSelection)
             {
                 line += linesPerPage;
                 ++page;
             }
             else
             {
                 ++pageListIt;
             }
         }
 
         painter.end();
 
         if(m_pOptions->wordWrapOn())
         {
             recalcWordWrap();
             m_pEventLoopForPrinting->exec();
             DiffTextWindow::mVScrollBar->setValue(m_pDiffTextWindow1->convertDiff3LineIdxToLine(currentFirstD3LIdx));
         }
         m_pEventLoopForPrinting.clear();
 
         slotStatusMsg(i18n("Printing completed."));
     }
     else
     {
         slotStatusMsg(i18n("Printing aborted."));
     }
 #endif
 }
 
 void KDiff3App::slotFileQuit()
 {
     slotStatusMsg(i18n("Exiting..."));
 
     if(!queryClose())
         return; // Don't quit
 
     QApplication::exit(isFileSaved() || isDirComparison() ? 0 : 1);
 }
 
 void KDiff3App::slotViewToolBar()
 {
     Q_ASSERT(viewToolBar != nullptr);
     slotStatusMsg(i18n("Toggling toolbar..."));
     m_pOptions->setToolbarState(viewToolBar->isChecked());
     ///////////////////////////////////////////////////////////////////
     // turn Toolbar on or off
     if(toolBar(MAIN_TOOLBAR_NAME) != nullptr)
     {
         if(!m_pOptions->isToolBarVisable())
         {
             toolBar(MAIN_TOOLBAR_NAME)->hide();
         }
         else
         {
             toolBar(MAIN_TOOLBAR_NAME)->show();
         }
     }
 
     slotStatusMsg(i18n("Ready."));
 }
 
 void KDiff3App::slotViewStatusBar()
 {
     slotStatusMsg(i18n("Toggle the statusbar..."));
     m_pOptions->setStatusBarState(viewStatusBar->isChecked());
     ///////////////////////////////////////////////////////////////////
     //turn Statusbar on or off
     if(statusBar() != nullptr)
     {
         if(!viewStatusBar->isChecked())
         {
             statusBar()->hide();
         }
         else
         {
             statusBar()->show();
         }
     }
 
     slotStatusMsg(i18n("Ready."));
 }
 
 void KDiff3App::slotStatusMsg(const QString& text)
 {
     ///////////////////////////////////////////////////////////////////
     // change status message permanently
     if(statusBar() != nullptr)
     {
         statusBar()->clearMessage();
         statusBar()->showMessage(text);
     }
 }
 
 //#include "kdiff3.moc"
diff --git a/src/kdiff3.h b/src/kdiff3.h
index 04c2944..76c45c2 100644
--- a/src/kdiff3.h
+++ b/src/kdiff3.h
@@ -1,440 +1,448 @@
 /*
  * KDiff3 - Text Diff And Merge Tool
  *
  * SPDX-FileCopyrightText: 2002-2011 Joachim Eibl, joachim.eibl at gmx.de
  * SPDX-FileCopyrightText: 2018-2020 Michael Reeves reeves.87@gmail.com
  * SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #ifndef KDIFF3_H
 #define KDIFF3_H
 
 #include "diff.h"
 
+#include "combiners.h"
+
+#include <boost/signals2.hpp>
+
 // include files for Qt
 #include <QAction>
 #include <QApplication>
 #include <QEventLoop>
 #include <QPointer>
 #include <QScrollBar>
 #include <QSplitter>
 
 // include files for KDE
 #include <KConfigGroup>
 #include <KMainWindow>
 #include <KParts/MainWindow>
 #include <KSharedConfig>
 #include <KToggleAction>
 // forward declaration of the KDiff3 classes
 class OptionDialog;
 
 class Overview;
 enum class e_OverviewMode;
 class FindDialog;
 //class ManualDiffHelpDialog;
 class DiffTextWindow;
 class DiffTextWindowFrame;
 class MergeResultWindow;
 class WindowTitleWidget;
 
 class QStatusBar;
 class QMenu;
 
 class KToggleAction;
 class KToolBar;
 class KActionCollection;
 
 namespace KParts {
 class MainWindow;
 }
 
 class KDiff3Part;
 class DirectoryMergeWindow;
 class DirectoryMergeInfo;
 
 class ReversibleScrollBar : public QScrollBar
 {
     Q_OBJECT
     bool* m_pbRightToLeftLanguage;
     int m_realVal;
 
   public:
     ReversibleScrollBar(Qt::Orientation o, bool* pbRightToLeftLanguage)
         : QScrollBar(o)
     {
         m_pbRightToLeftLanguage = pbRightToLeftLanguage;
         m_realVal = 0;
         connect(this, &ReversibleScrollBar::valueChanged, this, &ReversibleScrollBar::slotValueChanged);
     }
     void setAgain() { setValue(m_realVal); }
 
     void setValue(int i)
     {
         if(m_pbRightToLeftLanguage != nullptr && *m_pbRightToLeftLanguage)
             QScrollBar::setValue(maximum() - (i - minimum()));
         else
             QScrollBar::setValue(i);
     }
 
     int value() const
     {
         return m_realVal;
     }
   public Q_SLOTS:
     void slotValueChanged(int i)
     {
         m_realVal = i;
         if(m_pbRightToLeftLanguage != nullptr && *m_pbRightToLeftLanguage)
             m_realVal = maximum() - (i - minimum());
         Q_EMIT valueChanged2(m_realVal);
     }
 
   Q_SIGNALS:
     void valueChanged2(int);
 };
 
 class KDiff3App : public QSplitter
 {
     Q_OBJECT
 
   public:
     /** constructor of KDiff3App, calls all init functions to create the application.
      */
     KDiff3App(QWidget* parent, const QString& name, KDiff3Part* pKDiff3Part);
     ~KDiff3App() override;
 
     bool isPart();
 
     /** initializes the KActions of the application */
     void initActions(KActionCollection*);
 
     /** save general Options like all bar positions and status as well as the geometry
         and the recent file list to the configuration file */
     void saveOptions(KSharedConfigPtr);
 
     /** read general Options again and initialize all variables like the recent file list */
     void readOptions(KSharedConfigPtr);
 
     // Finish initialisation (virtual, so that it can be called from the shell too.)
     virtual void completeInit(const QString& fn1 = QString(), const QString& fn2 = QString(), const QString& fn3 = QString());
 
     /** queryClose is called by KMainWindow on each closeEvent of a window. Against the
      * default implementation (only returns true), this calles saveModified() on the document object to ask if the document shall
      * be saved if Modified; on cancel the closeEvent is rejected.
      * @see KMainWindow#queryClose
      * @see KMainWindow#closeEvent
      */
     virtual bool queryClose();
     virtual bool isFileSaved();
     virtual bool isDirComparison();
 
     static bool isTripleDiff() { return m_bTripleDiff; }
 
     KActionCollection* actionCollection() const;
+
+    static boost::signals2::signal<bool (), and> shouldContinue;
   Q_SIGNALS:
     void createNewInstance(const QString& fn1, const QString& fn2, const QString& fn3);
 
     void sigRecalcWordWrap();
 
-    void checkIfCanContinue(bool& pbContinue);
-
     void finishDrop();
 
     void showWhiteSpaceToggled();
     void showLineNumbersToggled();
     void doRefresh();
 
     void autoSolve();
     void unsolve();
     void mergeHistory();
     void regExpAutoMerge();
 
     void goCurrent();
     void goTop();
     void goBottom();
     void goPrevUnsolvedConflict();
 
     void goNextUnsolvedConflict();
     void goPrevConflict();
 
     void goNextConflict();
     void goPrevDelta();
     void goNextDelta();
 
     void cut();
 
     void selectAll();
 
     void changeOverViewMode(e_OverviewMode);
 public Q_SLOTS:
 
     /** open a file and load it into the document*/
     void slotFileOpen();
     void slotFileOpen2(const QString& fn1, const QString& fn2, const QString& fn3, const QString& ofn,
                        const QString& an1, const QString& an2, const QString& an3, TotalDiffStatus* pTotalDiffStatus);
 
     void slotFileNameChanged(const QString& fileName, e_SrcSelector winIdx);
 
     /** save a document */
     void slotFileSave();
     /** save a document by a new filename*/
     void slotFileSaveAs();
 
     void slotFilePrint();
 
     /** closes all open windows by calling close() on each memberList item until the list is empty, then quits the application.
      * If queryClose() returns false because the user canceled the saveModified() dialog, the closing breaks.
      */
     void slotFileQuit();
     /** put the marked text/object into the clipboard and remove
      *  it from the document
      */
     void slotEditCut();
     /** put the marked text/object into the clipboard
      */
     void slotEditCopy();
     /** paste the clipboard into the document
      */
     void slotEditPaste();
     /** toggles the toolbar
      */
     void slotViewToolBar();
     /** toggles the statusbar
      */
     void slotViewStatusBar();
     /** changes the statusbar contents for the standard label permanently, used to indicate current actions.
      * @param text the text that is displayed in the statusbar
      */
     void slotStatusMsg(const QString& text);
 
     void resizeDiffTextWindowHeight(int newHeight);
     void slotRecalcWordWrap();
     void postRecalcWordWrap();
     void slotFinishRecalcWordWrap(int visibleTextWidth);
 
     void showPopupMenu(const QPoint& point);
 
     void scrollDiffTextWindow(int deltaX, int deltaY);
     void scrollMergeResultWindow(int deltaX, int deltaY);
     void sourceMask(int srcMask, int enabledMask);
 
     void slotDirShowBoth();
     void slotDirViewToggle();
 
     void slotUpdateAvailabilities();
     void slotEditSelectAll();
     void slotEditFind();
     void slotEditFindNext();
     void slotGoCurrent();
     void slotGoTop();
     void slotGoBottom();
     void slotGoPrevUnsolvedConflict();
     void slotGoNextUnsolvedConflict();
     void slotGoPrevConflict();
     void slotGoNextConflict();
     void slotGoPrevDelta();
     void slotGoNextDelta();
     void slotChooseA();
     void slotChooseB();
     void slotChooseC();
     void slotAutoSolve();
     void slotUnsolve();
     void slotMergeHistory();
     void slotRegExpAutoMerge();
     void slotConfigure();
     void slotConfigureKeys();
     void slotRefresh();
     void slotSelectionEnd();
     void slotSelectionStart();
     void slotClipboardChanged();
     void slotOutputModified(bool);
     void slotFinishMainInit();
     void slotMergeCurrentFile();
     void slotReload();
-    void slotCheckIfCanContinue(bool& pbContinue);
     void slotShowWhiteSpaceToggled();
     void slotShowLineNumbersToggled();
     void slotAutoAdvanceToggled();
     void slotWordWrapToggled();
     void slotShowWindowAToggled();
     void slotShowWindowBToggled();
     void slotShowWindowCToggled();
     void slotWinFocusNext();
     void slotWinFocusPrev();
     void slotWinToggleSplitterOrientation();
     void slotOverviewNormal();
     void slotOverviewAB();
     void slotOverviewAC();
     void slotOverviewBC();
     void slotSplitDiff();
     void slotJoinDiffs();
     void slotAddManualDiffHelp();
     void slotClearManualDiffHelpList();
     void slotNoRelevantChangesDetected();
     void slotEncodingChanged(QTextCodec*);
 
     void slotFinishDrop();
 
     void setHScrollBarRange();
 
   protected:
     void setLockPainting(bool bLock);
     void createCaption();
     void initDirectoryMergeActions();
     /** sets up the statusbar for the main window by initialzing a statuslabel. */
     void initStatusBar();
 
     /** creates the centerwidget of the KMainWindow instance and sets it as the view */
     void initView();
 
   private:
     void mainInit(TotalDiffStatus* pTotalDiffStatus = nullptr, bool bLoadFiles = true, bool bUseCurrentEncoding = false);
 
     void mainWindowEnable(bool bEnable);
     virtual void wheelEvent(QWheelEvent* pWheelEvent) override;
     virtual void keyPressEvent(QKeyEvent* event) override;
     void resizeEvent(QResizeEvent*) override;
 
     bool improveFilenames(bool bCreateNewInstance);
 
     bool canContinue();
 
     void choose(e_SrcSelector choice);
 
     QStatusBar* statusBar();
     KToolBar* toolBar(QLatin1String);
     void recalcWordWrap(int visibleTextWidthForPrinting = -1);
 
     /** the configuration object of the application */
     //KConfig *config;
 
     // QAction pointers to enable/disable actions
     QPointer<QAction> fileOpen;
     QPointer<QAction> fileSave;
     QPointer<QAction> fileSaveAs;
     QPointer<QAction> filePrint;
     QPointer<QAction> fileQuit;
     QPointer<QAction> fileReload;
     QPointer<QAction> editCut;
     QPointer<QAction> editCopy;
     QPointer<QAction> editPaste;
     QPointer<QAction> editSelectAll;
     KToggleAction* viewToolBar = nullptr;
     KToggleAction* viewStatusBar;
 
     ////////////////////////////////////////////////////////////////////////
     // Special KDiff3 specific stuff starts here
     QPointer<QAction> editFind;
     QPointer<QAction> editFindNext;
 
     QPointer<QAction> mGoCurrent;
     QPointer<QAction> mGoTop;
     QPointer<QAction> mGoBottom;
     QPointer<QAction> mGoPrevUnsolvedConflict;
     QPointer<QAction> mGoNextUnsolvedConflict;
     QPointer<QAction> mGoPrevConflict;
     QPointer<QAction> mGoNextConflict;
     QPointer<QAction> mGoPrevDelta;
     QPointer<QAction> mGoNextDelta;
     KToggleAction* chooseA;
     KToggleAction* chooseB;
     KToggleAction* chooseC;
     KToggleAction* autoAdvance;
     KToggleAction* wordWrap;
     QPointer<QAction> splitDiff;
     QPointer<QAction> joinDiffs;
     QPointer<QAction> addManualDiffHelp;
     QPointer<QAction> clearManualDiffHelpList;
     KToggleAction* showWhiteSpaceCharacters;
     KToggleAction* showWhiteSpace;
     KToggleAction* showLineNumbers;
     QPointer<QAction> mAutoSolve;
     QPointer<QAction> mUnsolve;
     QPointer<QAction> mMergeHistory;
     QPointer<QAction> mergeRegExp;
     KToggleAction* showWindowA;
     KToggleAction* showWindowB;
     KToggleAction* showWindowC;
     QPointer<QAction> winFocusNext;
     QPointer<QAction> winFocusPrev;
     QPointer<QAction> winToggleSplitOrientation;
     KToggleAction* dirShowBoth;
     QPointer<QAction> dirViewToggle;
     KToggleAction* overviewModeNormal;
     KToggleAction* overviewModeAB;
     KToggleAction* overviewModeAC;
     KToggleAction* overviewModeBC;
 
     QMenu* m_pMergeEditorPopupMenu;
 
     QSplitter* m_pMainSplitter = nullptr;
     QWidget* m_pMainWidget = nullptr;
     QWidget* m_pMergeWindowFrame = nullptr;
     ReversibleScrollBar* m_pHScrollBar = nullptr;
 
     DiffTextWindow* m_pDiffTextWindow1 = nullptr;
     DiffTextWindow* m_pDiffTextWindow2 = nullptr;
     DiffTextWindow* m_pDiffTextWindow3 = nullptr;
     DiffTextWindowFrame* m_pDiffTextWindowFrame1 = nullptr;
     DiffTextWindowFrame* m_pDiffTextWindowFrame2 = nullptr;
     DiffTextWindowFrame* m_pDiffTextWindowFrame3 = nullptr;
     QSplitter* m_pDiffWindowSplitter = nullptr;
 
     MergeResultWindow* m_pMergeResultWindow = nullptr;
     WindowTitleWidget* m_pMergeResultWindowTitle;
     static bool m_bTripleDiff;
 
     QSplitter* m_pDirectoryMergeSplitter = nullptr;
     DirectoryMergeWindow* m_pDirectoryMergeWindow = nullptr;
     DirectoryMergeInfo* m_pDirectoryMergeInfo;
     bool m_bDirCompare = false;
 
     Overview* m_pOverview = nullptr;
 
     QWidget* m_pCornerWidget = nullptr;
 
     TotalDiffStatus m_totalDiffStatus;
 
     QSharedPointer<SourceData> m_sd1 = QSharedPointer<SourceData>::create();
     QSharedPointer<SourceData> m_sd2 = QSharedPointer<SourceData>::create();
     QSharedPointer<SourceData> m_sd3 = QSharedPointer<SourceData>::create();
 
     QSharedPointer<class DirectoryInfo> m_dirinfo;
 
     QString m_outputFilename;
     bool m_bDefaultFilename;
 
     DiffList m_diffList12;
     DiffList m_diffList23;
     DiffList m_diffList13;
 
     QSharedPointer<DiffBufferInfo> m_diffBufferInfo = QSharedPointer<DiffBufferInfo>::create();
     Diff3LineList m_diff3LineList;
     Diff3LineVector m_diff3LineVector;
     //ManualDiffHelpDialog* m_pManualDiffHelpDialog;
     ManualDiffHelpList m_manualDiffHelpList;
 
     int m_neededLines;
     int m_DTWHeight;
     bool m_bOutputModified = false;
     bool m_bFileSaved = false;
     bool m_bTimerBlock = false; // Synchronization
 
     OptionDialog* m_pOptionDialog = nullptr;
     QSharedPointer<Options> m_pOptions = nullptr;
     FindDialog* m_pFindDialog = nullptr;
 
     bool m_bFinishMainInit = false;
     bool m_bLoadFiles = false;
 
     KDiff3Part* m_pKDiff3Part = nullptr;
     KParts::MainWindow* m_pKDiff3Shell = nullptr;
     bool m_bAutoFlag = false;
     bool m_bAutoMode = false;
     bool m_bRecalcWordWrapPosted = false;
 
     int m_firstD3LIdx;                 // only needed during recalcWordWrap
     QPointer<QEventLoop> m_pEventLoopForPrinting;
+
+    /*
+      This list exists solely to auto disconnect boost signals.
+    */
+    std::list<boost::signals2::scoped_connection> connections;
 };
 
 #endif // KDIFF3_H
diff --git a/src/pdiff.cpp b/src/pdiff.cpp
index 8ff3727..0f1e13a 100644
--- a/src/pdiff.cpp
+++ b/src/pdiff.cpp
@@ -1,2191 +1,2173 @@
 /*
  *  This file is part of KDiff3.
  *
  * SPDX-FileCopyrightText: 2002-2011 Joachim Eibl, joachim.eibl at gmx.de
  * SPDX-FileCopyrightText: 2018-2020 Michael Reeves reeves.87@gmail.com
  * SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "difftextwindow.h"
 #include "DirectoryInfo.h"
 #include "directorymergewindow.h"
 #include "fileaccess.h"
 #include "Logging.h"
 #include "kdiff3.h"
 #include "optiondialog.h"
 #include "progress.h"
 #include "Utils.h"
 
 #include "mergeresultwindow.h"
 #include "smalldialogs.h"
 
 #include <algorithm>
 #include <cstdio>
 #include <list>
 
 #include <QCheckBox>
 #include <QClipboard>
 #include <QComboBox>
 #include <QDialog>
 #include <QDir>
 #include <QEvent> // QKeyEvent, QDropEvent, QInputEvent
 #include <QFile>
 #include <QLayout>
 #include <QLineEdit>
 #include <QMimeData>
 #include <QPointer>
 #include <QProcess>
 #include <QScrollBar>
 #include <QSplitter>
 #include <QStatusBar>
 #include <QStringList>
 #include <QTextCodec>
 #include <QUrl>
 
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KShortcutsDialog>
 
 // Function uses setMinSize( sizeHint ) before adding the widget.
 // void addWidget(QBoxLayout* layout, QWidget* widget);
 template <class W, class L>
 void addWidget(L* layout, W* widget)
 {
     QSize s = widget->sizeHint();
     widget->setMinimumSize(QSize(std::max(s.width(), 0), std::max(s.height(), 0)));
     layout->addWidget(widget);
 }
 
 void KDiff3App::mainInit(TotalDiffStatus* pTotalDiffStatus, bool bLoadFiles, bool bUseCurrentEncoding)
 {
     ProgressProxy pp;
     QStringList errors;
     // When doing a full analysis in the directory-comparison, then the statistics-results
     // will be stored in the given TotalDiffStatus. Otherwise it will be 0.
     bool bGUI = pTotalDiffStatus == nullptr;
     if(pTotalDiffStatus == nullptr)
         pTotalDiffStatus = &m_totalDiffStatus;
 
     //bool bPreserveCarriageReturn = m_pOptions->m_bPreserveCarriageReturn;
 
     bool bVisibleMergeResultWindow = !m_outputFilename.isEmpty();
     if(bVisibleMergeResultWindow && bGUI)
     {
         //bPreserveCarriageReturn = false;
 
         QString msg;
 
         if(!m_pOptions->m_PreProcessorCmd.isEmpty())
         {
             msg += "- " + i18n("PreprocessorCmd: ") + m_pOptions->m_PreProcessorCmd + '\n';
         }
         if(!msg.isEmpty())
         {
             int result = KMessageBox::warningYesNo(this,
                                                    i18n("The following option(s) you selected might change data:\n") + msg +
                                                        i18n("\nMost likely this is not wanted during a merge.\n"
                                                             "Do you want to disable these settings or continue with these settings active?"),
                                                    i18n("Option Unsafe for Merging"),
                                                    KGuiItem(i18n("Use These Options During Merge")),
                                                    KGuiItem(i18n("Disable Unsafe Options")));
 
             if(result == KMessageBox::No)
             {
                 m_pOptions->m_PreProcessorCmd = "";
             }
         }
     }
 
     // Because of the progressdialog paintevents can occur, but data is invalid,
     // so painting must be suppressed
     if(bGUI) setLockPainting(true);
 
     //insure merge result window never has stale iterators.
     if(m_pMergeResultWindow) m_pMergeResultWindow->clearMergeList();
     m_diff3LineList.clear();
     m_diff3LineVector.clear();
 
     if(bLoadFiles)
     {
         m_manualDiffHelpList.clear();
 
         if(m_sd3->isEmpty())
             pp.setMaxNofSteps(4); // Read 2 files, 1 comparison, 1 finediff
         else
             pp.setMaxNofSteps(9); // Read 3 files, 3 comparisons, 3 finediffs
 
         // First get all input data.
         pp.setInformation(i18n("Loading A"));
         qCInfo(kdiffMain) << i18n("Loading A: %1", m_sd1->getFilename());
 
         if(bUseCurrentEncoding)
             errors = m_sd1->readAndPreprocess(m_sd1->getEncoding(), false);
         else
             errors = m_sd1->readAndPreprocess(m_pOptions->m_pEncodingA, m_pOptions->m_bAutoDetectUnicodeA);
 
         if(!errors.isEmpty())
         {
             KMessageBox::errorList(m_pOptionDialog, i18n("Errors occurred during pre-processing of file A."), errors);
         }
 
         pp.step();
 
         pp.setInformation(i18n("Loading B"));
         qCInfo(kdiffMain) << i18n("Loading B: %1", m_sd2->getFilename());
 
         if(bUseCurrentEncoding)
             errors = m_sd2->readAndPreprocess(m_sd2->getEncoding(), false);
         else
             errors = m_sd2->readAndPreprocess(m_pOptions->m_pEncodingB, m_pOptions->m_bAutoDetectUnicodeB);
 
         if(!errors.isEmpty())
             KMessageBox::errorList(m_pOptionDialog, i18n("Errors occurred during pre-processing of file B."), errors);
 
         pp.step();
     }
     else
     {
         if(m_sd3->isEmpty())
             pp.setMaxNofSteps(2); // 1 comparison, 1 finediff
         else
             pp.setMaxNofSteps(6); // 3 comparisons, 3 finediffs
     }
 
     if(pTotalDiffStatus)
         pTotalDiffStatus->reset();
     if(errors.isEmpty())
     {
         // Run the diff.
         if(m_sd3->isEmpty())
         {
             pTotalDiffStatus->setBinaryEqualAB(m_sd1->isBinaryEqualWith(m_sd2));
 
             if(m_sd1->isText() && m_sd2->isText())
             {
                 pp.setInformation(i18n("Diff: A <-> B"));
                 qCInfo(kdiffMain) << i18n("Diff: A <-> B");
                 m_manualDiffHelpList.runDiff(m_sd1->getLineDataForDiff(), m_sd1->getSizeLines(), m_sd2->getLineDataForDiff(), m_sd2->getSizeLines(), m_diffList12, e_SrcSelector::A, e_SrcSelector::B,
                                              m_pOptionDialog->getOptions());
 
                 pp.step();
 
                 pp.setInformation(i18n("Linediff: A <-> B"));
                 qCInfo(kdiffMain) << i18n("Linediff: A <-> B");
                 m_diff3LineList.calcDiff3LineListUsingAB(&m_diffList12);
                 pTotalDiffStatus->setTextEqualAB(m_diff3LineList.fineDiff(e_SrcSelector::A, m_sd1->getLineDataForDisplay(), m_sd2->getLineDataForDisplay()));
                 if(m_sd1->getSizeBytes() == 0) pTotalDiffStatus->setTextEqualAB(false);
 
                 pp.step();
             }
             else
             {
                 pp.step();
                 pp.step();
             }
         }
         else
         {
             if(bLoadFiles)
             {
                 pp.setInformation(i18n("Loading C"));
                 qCInfo(kdiffMain) << i18n("Loading C: %1", m_sd2->getFilename());
 
                 if(bUseCurrentEncoding)
                     errors = m_sd3->readAndPreprocess(m_sd3->getEncoding(), false);
                 else
                     errors = m_sd3->readAndPreprocess(m_pOptions->m_pEncodingC, m_pOptions->m_bAutoDetectUnicodeC);
 
                 if(!errors.isEmpty())
                     KMessageBox::errorList(m_pOptionDialog, i18n("Errors occurred during pre-processing of file C."), errors);
 
                 pp.step();
             }
 
             pTotalDiffStatus->setBinaryEqualAB(m_sd1->isBinaryEqualWith(m_sd2));
             pTotalDiffStatus->setBinaryEqualAC(m_sd1->isBinaryEqualWith(m_sd3));
             pTotalDiffStatus->setBinaryEqualBC(m_sd3->isBinaryEqualWith(m_sd2));
 
             pp.setInformation(i18n("Diff: A <-> B"));
             qCInfo(kdiffMain) << i18n("Diff: A <-> B");
 
             if(m_sd1->isText() && m_sd2->isText())
             {
                 m_manualDiffHelpList.runDiff(m_sd1->getLineDataForDiff(), m_sd1->getSizeLines(), m_sd2->getLineDataForDiff(), m_sd2->getSizeLines(), m_diffList12, e_SrcSelector::A, e_SrcSelector::B,
                                              m_pOptionDialog->getOptions());
 
                 m_diff3LineList.calcDiff3LineListUsingAB(&m_diffList12);
             }
             pp.step();
 
             pp.setInformation(i18n("Diff: A <-> C"));
             qCInfo(kdiffMain) << i18n("Diff: A <-> C");
 
             if(m_sd1->isText() && m_sd3->isText())
             {
                 m_manualDiffHelpList.runDiff(m_sd1->getLineDataForDiff(), m_sd1->getSizeLines(), m_sd3->getLineDataForDiff(), m_sd3->getSizeLines(), m_diffList13, e_SrcSelector::A, e_SrcSelector::C,
                                              m_pOptionDialog->getOptions());
 
                 m_diff3LineList.calcDiff3LineListUsingAC(&m_diffList13);
                 m_diff3LineList.correctManualDiffAlignment(&m_manualDiffHelpList);
                 m_diff3LineList.calcDiff3LineListTrim(m_sd1->getLineDataForDiff(), m_sd2->getLineDataForDiff(), m_sd3->getLineDataForDiff(), &m_manualDiffHelpList);
             }
             pp.step();
 
             pp.setInformation(i18n("Diff: B <-> C"));
             qCInfo(kdiffMain) << i18n("Diff: B <-> C");
 
             if(m_sd2->isText() && m_sd3->isText())
             {
                 m_manualDiffHelpList.runDiff(m_sd2->getLineDataForDiff(), m_sd2->getSizeLines(), m_sd3->getLineDataForDiff(), m_sd3->getSizeLines(), m_diffList23, e_SrcSelector::B, e_SrcSelector::C,
                                              m_pOptionDialog->getOptions());
                 if(m_pOptions->m_bDiff3AlignBC)
                 {
                     m_diff3LineList.calcDiff3LineListUsingBC(&m_diffList23);
                     m_diff3LineList.correctManualDiffAlignment(&m_manualDiffHelpList);
                     m_diff3LineList.calcDiff3LineListTrim(m_sd1->getLineDataForDiff(), m_sd2->getLineDataForDiff(), m_sd3->getLineDataForDiff(), &m_manualDiffHelpList);
                 }
             }
             pp.step();
 
             m_diff3LineList.debugLineCheck(m_sd1->getSizeLines(), e_SrcSelector::A);
             m_diff3LineList.debugLineCheck(m_sd2->getSizeLines(), e_SrcSelector::B);
             m_diff3LineList.debugLineCheck(m_sd3->getSizeLines(), e_SrcSelector::C);
 
             pp.setInformation(i18n("Linediff: A <-> B"));
             qCInfo(kdiffMain) << i18n("Linediff: A <-> B");
             if(m_sd1->hasData() && m_sd2->hasData() && m_sd1->isText() && m_sd2->isText())
                 pTotalDiffStatus->setTextEqualAB(m_diff3LineList.fineDiff(e_SrcSelector::A, m_sd1->getLineDataForDisplay(), m_sd2->getLineDataForDisplay()));
             pp.step();
 
             pp.setInformation(i18n("Linediff: B <-> C"));
             qCInfo(kdiffMain) << i18n("Linediff: B <-> C");
             if(m_sd2->hasData() && m_sd3->hasData() && m_sd2->isText() && m_sd3->isText())
                 pTotalDiffStatus->setTextEqualBC(m_diff3LineList.fineDiff(e_SrcSelector::B, m_sd2->getLineDataForDisplay(), m_sd3->getLineDataForDisplay()));
             pp.step();
 
             pp.setInformation(i18n("Linediff: A <-> C"));
             qCInfo(kdiffMain) << i18n("Linediff: A <-> C");
             if(m_sd1->hasData() && m_sd3->hasData() && m_sd1->isText() && m_sd3->isText())
                 pTotalDiffStatus->setTextEqualAC(m_diff3LineList.fineDiff(e_SrcSelector::C, m_sd3->getLineDataForDisplay(), m_sd1->getLineDataForDisplay()));
             m_diff3LineList.debugLineCheck(m_sd2->getSizeLines(), e_SrcSelector::B);
             m_diff3LineList.debugLineCheck(m_sd3->getSizeLines(), e_SrcSelector::C);
 
             pp.setInformation(i18n("Linediff: A <-> B"));
             if(m_sd1->hasData() && m_sd2->hasData() && m_sd1->isText() && m_sd2->isText())
                 pTotalDiffStatus->setTextEqualAB(m_diff3LineList.fineDiff(e_SrcSelector::A, m_sd1->getLineDataForDisplay(), m_sd2->getLineDataForDisplay()));
             pp.step();
 
             pp.setInformation(i18n("Linediff: B <-> C"));
             if(m_sd3->hasData() && m_sd2->hasData() && m_sd3->isText() && m_sd2->isText())
                 pTotalDiffStatus->setTextEqualBC(m_diff3LineList.fineDiff(e_SrcSelector::B, m_sd2->getLineDataForDisplay(), m_sd3->getLineDataForDisplay()));
             pp.step();
 
             pp.setInformation(i18n("Linediff: A <-> C"));
             if(m_sd1->hasData() && m_sd3->hasData() && m_sd1->isText() && m_sd3->isText())
                 pTotalDiffStatus->setTextEqualAC(m_diff3LineList.fineDiff(e_SrcSelector::C, m_sd3->getLineDataForDisplay(), m_sd1->getLineDataForDisplay()));
             pp.step();
             if(m_sd1->getSizeBytes() == 0)
             {
                 pTotalDiffStatus->setTextEqualAB(false);
                 pTotalDiffStatus->setTextEqualAC(false);
             }
             if(m_sd2->getSizeBytes() == 0)
             {
                 pTotalDiffStatus->setTextEqualAB(false);
                 pTotalDiffStatus->setTextEqualBC(false);
             }
         }
     }
     else
     {
         pp.clear();
     }
 
     if(errors.isEmpty() && m_sd1->isText() && m_sd2->isText())
     {
         m_diffBufferInfo->init(&m_diff3LineList, &m_diff3LineVector,
                                m_sd1->getLineDataForDiff(), m_sd1->getSizeLines(),
                                m_sd2->getLineDataForDiff(), m_sd2->getSizeLines(),
                                m_sd3->getLineDataForDiff(), m_sd3->getSizeLines());
         Diff3Line::m_pDiffBufferInfo = m_diffBufferInfo;
 
         m_diff3LineList.calcWhiteDiff3Lines(m_sd1->getLineDataForDiff(), m_sd2->getLineDataForDiff(), m_sd3->getLineDataForDiff());
         m_diff3LineList.calcDiff3LineVector(m_diff3LineVector);
     }
 
     // Calc needed lines for display
     m_neededLines = m_diff3LineList.size();
 
     QList<int> oldHeights;
     if(m_pDirectoryMergeSplitter->isVisible())
         oldHeights = m_pMainSplitter->sizes();
 
     initView();
     m_pMergeResultWindow->connectActions();
 
     if(m_pDirectoryMergeSplitter->isVisible())
     {
         if(oldHeights.count() < 2)
             oldHeights.append(0);
         if(oldHeights[1] == 0) // Distribute the available space evenly between the two widgets.
         {
             oldHeights[1] = oldHeights[0] / 2;
             oldHeights[0] -= oldHeights[1];
         }
         if(oldHeights[0] == 0 && oldHeights[1] == 0)
         {
             oldHeights[1] = 100;
             oldHeights[0] = 100;
         }
         m_pMainSplitter->setSizes(oldHeights);
     }
 
     m_pMainWidget->setVisible(bGUI);
 
     m_bTripleDiff = !m_sd3->isEmpty();
 
     m_pMergeResultWindowTitle->setEncodings(m_sd1->getEncoding(), m_sd2->getEncoding(), m_sd3->getEncoding());
     if(!m_pOptions->m_bAutoSelectOutEncoding)
         m_pMergeResultWindowTitle->setEncoding(m_pOptions->m_pEncodingOut);
 
     m_pMergeResultWindowTitle->setLineEndStyles(m_sd1->getLineEndStyle(), m_sd2->getLineEndStyle(), m_sd3->getLineEndStyle());
 
     if(bGUI)
     {
         const ManualDiffHelpList* pMDHL = &m_manualDiffHelpList;
         m_pDiffTextWindow1->init(m_sd1->getAliasName(), m_sd1->getEncoding(), m_sd1->getLineEndStyle(),
                                  m_sd1->getLineDataForDisplay(), m_sd1->getSizeLines(), &m_diff3LineVector, pMDHL);
         m_pDiffTextWindowFrame1->init();
 
         m_pDiffTextWindow2->init(m_sd2->getAliasName(), m_sd2->getEncoding(), m_sd2->getLineEndStyle(),
                                  m_sd2->getLineDataForDisplay(), m_sd2->getSizeLines(), &m_diff3LineVector, pMDHL);
         m_pDiffTextWindowFrame2->init();
 
         m_pDiffTextWindow3->init(m_sd3->getAliasName(), m_sd3->getEncoding(), m_sd3->getLineEndStyle(),
                                  m_sd3->getLineDataForDisplay(), m_sd3->getSizeLines(), &m_diff3LineVector, pMDHL);
         m_pDiffTextWindowFrame3->init();
 
         m_pDiffTextWindowFrame3->setVisible(m_bTripleDiff);
     }
 
     m_bOutputModified = bVisibleMergeResultWindow;
 
     m_pMergeResultWindow->init(
         m_sd1->getLineDataForDisplay(), m_sd1->getSizeLines(),
         m_sd2->getLineDataForDisplay(), m_sd2->getSizeLines(),
         m_bTripleDiff ? m_sd3->getLineDataForDisplay() : nullptr, m_sd3->getSizeLines(),
         &m_diff3LineList,
         pTotalDiffStatus);
     m_pMergeResultWindowTitle->setFileName(m_outputFilename.isEmpty() ? QString("unnamed.txt") : m_outputFilename);
 
     if(!bGUI)
     {
         // We now have all needed information. The rest below is only for GUI-activation.
         m_sd1->reset();
         m_sd2->reset();
         m_sd3->reset();
     }
     else
     {
         m_pOverview->init(&m_diff3LineList);
         DiffTextWindow::mVScrollBar->setValue(0);
         m_pHScrollBar->setValue(0);
         MergeResultWindow::mVScrollBar->setValue(0);
         setLockPainting(false);
 
         if(!bVisibleMergeResultWindow)
             m_pMergeWindowFrame->hide();
         else
             m_pMergeWindowFrame->show();
 
         // Try to create a meaningful but not too long caption
         if(!isPart() && errors.isEmpty())
         {
             createCaption();
         }
         m_bFinishMainInit = true; // call slotFinishMainInit after finishing the word wrap
         m_bLoadFiles = bLoadFiles;
         postRecalcWordWrap();
     }
 }
 
 void KDiff3App::setLockPainting(bool bLock)
 {
     if(m_pDiffTextWindow1) m_pDiffTextWindow1->setPaintingAllowed(!bLock);
     if(m_pDiffTextWindow2) m_pDiffTextWindow2->setPaintingAllowed(!bLock);
     if(m_pDiffTextWindow3) m_pDiffTextWindow3->setPaintingAllowed(!bLock);
     if(m_pOverview) m_pOverview->setPaintingAllowed(!bLock);
     if(m_pMergeResultWindow) m_pMergeResultWindow->setPaintingAllowed(!bLock);
 }
 
 void KDiff3App::createCaption()
 {
     // Try to create a meaningful but not too long caption
     // 1. If the filenames are equal then show only one filename
     QString caption;
     QString f1 = m_sd1->getAliasName();
     QString f2 = m_sd2->getAliasName();
     QString f3 = m_sd3->getAliasName();
     int p;
 
     if((p = f1.lastIndexOf('/')) >= 0 || (p = f1.lastIndexOf('\\')) >= 0)
         f1 = f1.mid(p + 1);
     if((p = f2.lastIndexOf('/')) >= 0 || (p = f2.lastIndexOf('\\')) >= 0)
         f2 = f2.mid(p + 1);
     if((p = f3.lastIndexOf('/')) >= 0 || (p = f3.lastIndexOf('\\')) >= 0)
         f3 = f3.mid(p + 1);
 
     if(!f1.isEmpty())
     {
         if((f2.isEmpty() && f3.isEmpty()) ||
            (f2.isEmpty() && f1 == f3) || (f3.isEmpty() && f1 == f2) || (f1 == f2 && f1 == f3))
             caption = f1;
     }
     else if(!f2.isEmpty())
     {
         if(f3.isEmpty() || f2 == f3)
             caption = f2;
     }
     else if(!f3.isEmpty())
         caption = f3;
 
     // 2. If the files don't have the same name then show all names
     if(caption.isEmpty() && (!f1.isEmpty() || !f2.isEmpty() || !f3.isEmpty()))
     {
         caption = (f1.isEmpty() ? QString("") : f1);
         caption += QLatin1String(caption.isEmpty() || f2.isEmpty() ? "" : " <-> ") + (f2.isEmpty() ? QString("") : f2);
         caption += QLatin1String(caption.isEmpty() || f3.isEmpty() ? "" : " <-> ") + (f3.isEmpty() ? QString("") : f3);
     }
 
     m_pKDiff3Shell->setWindowTitle(caption.isEmpty() ? QString("KDiff3") : caption + QString(" - KDiff3"));
 }
 
 void KDiff3App::setHScrollBarRange()
 {
     int w1 = m_pDiffTextWindow1 != nullptr && m_pDiffTextWindow1->isVisible() ? m_pDiffTextWindow1->getMaxTextWidth() : 0;
     int w2 = m_pDiffTextWindow2 != nullptr && m_pDiffTextWindow2->isVisible() ? m_pDiffTextWindow2->getMaxTextWidth() : 0;
     int w3 = m_pDiffTextWindow3 != nullptr && m_pDiffTextWindow3->isVisible() ? m_pDiffTextWindow3->getMaxTextWidth() : 0;
 
     int wm = m_pMergeResultWindow != nullptr && m_pMergeResultWindow->isVisible() ? m_pMergeResultWindow->getMaxTextWidth() : 0;
 
     int v1 = m_pDiffTextWindow1 != nullptr && m_pDiffTextWindow1->isVisible() ? m_pDiffTextWindow1->getVisibleTextAreaWidth() : 0;
     int v2 = m_pDiffTextWindow2 != nullptr && m_pDiffTextWindow2->isVisible() ? m_pDiffTextWindow2->getVisibleTextAreaWidth() : 0;
     int v3 = m_pDiffTextWindow3 != nullptr && m_pDiffTextWindow3->isVisible() ? m_pDiffTextWindow3->getVisibleTextAreaWidth() : 0;
     int vm = m_pMergeResultWindow != nullptr && m_pMergeResultWindow->isVisible() ? m_pMergeResultWindow->getVisibleTextAreaWidth() : 0;
 
     // Find the minimum, but don't consider 0.
     int pageStep = 0;
     if((pageStep == 0 || pageStep > v1) && v1 > 0)
         pageStep = v1;
     if((pageStep == 0 || pageStep > v2) && v2 > 0)
         pageStep = v2;
     if((pageStep == 0 || pageStep > v3) && v3 > 0)
         pageStep = v3;
     if((pageStep == 0 || pageStep > vm) && vm > 0)
         pageStep = vm;
 
     int rangeMax = 0;
     if(w1 > v1 && w1 - v1 > rangeMax && v1 > 0)
         rangeMax = w1 - v1;
     if(w2 > v2 && w2 - v2 > rangeMax && v2 > 0)
         rangeMax = w2 - v2;
     if(w3 > v3 && w3 - v3 > rangeMax && v3 > 0)
         rangeMax = w3 - v3;
     if(wm > vm && wm - vm > rangeMax && vm > 0)
         rangeMax = wm - vm;
 
     m_pHScrollBar->setRange(0, rangeMax);
     m_pHScrollBar->setPageStep(pageStep);
 }
 
 void KDiff3App::resizeDiffTextWindowHeight(int newHeight)
 {
     m_DTWHeight = newHeight;
 
     DiffTextWindow::mVScrollBar->setRange(0, std::max(0, m_neededLines + 1 - newHeight));
     DiffTextWindow::mVScrollBar->setPageStep(newHeight);
     m_pOverview->setRange(DiffTextWindow::mVScrollBar->value(), DiffTextWindow::mVScrollBar->pageStep());
 
     setHScrollBarRange();
 }
 
 void KDiff3App::scrollDiffTextWindow(int deltaX, int deltaY)
 {
     if(deltaY != 0 && DiffTextWindow::mVScrollBar != nullptr)
     {
         DiffTextWindow::mVScrollBar->setValue(DiffTextWindow::mVScrollBar->value() + deltaY);
     }
     if(deltaX != 0 && m_pHScrollBar != nullptr)
         m_pHScrollBar->QScrollBar::setValue(m_pHScrollBar->value() + deltaX);
 }
 
 void KDiff3App::scrollMergeResultWindow(int deltaX, int deltaY)
 {
     if(deltaY != 0)
         MergeResultWindow::mVScrollBar->setValue(MergeResultWindow::mVScrollBar->value() + deltaY);
     if(deltaX != 0)
         m_pHScrollBar->setValue(m_pHScrollBar->value() + deltaX);
 }
 
 void KDiff3App::sourceMask(int srcMask, int enabledMask)
 {
     chooseA->blockSignals(true);
     chooseB->blockSignals(true);
     chooseC->blockSignals(true);
     chooseA->setChecked((srcMask & 1) != 0);
     chooseB->setChecked((srcMask & 2) != 0);
     chooseC->setChecked((srcMask & 4) != 0);
     chooseA->blockSignals(false);
     chooseB->blockSignals(false);
     chooseC->blockSignals(false);
     chooseA->setEnabled((enabledMask & 1) != 0);
     chooseB->setEnabled((enabledMask & 2) != 0);
     chooseC->setEnabled((enabledMask & 4) != 0);
 }
 
 void KDiff3App::initView()
 {
     // set the main widget here
     if(m_pMainWidget != nullptr)
     {
         return;
         //delete m_pMainWidget;
     }
     m_pMainWidget = new QWidget(); // Contains vertical splitter and horiz scrollbar
     m_pMainSplitter->addWidget(m_pMainWidget);
     m_pMainWidget->setObjectName("MainWidget");
     QVBoxLayout* pVLayout = new QVBoxLayout(m_pMainWidget);
     pVLayout->setMargin(0);
     pVLayout->setSpacing(0);
 
     QSplitter* pVSplitter = new QSplitter();
     pVSplitter->setObjectName("VSplitter");
     pVSplitter->setOpaqueResize(false);
     pVSplitter->setOrientation(Qt::Vertical);
     pVLayout->addWidget(pVSplitter);
 
     QWidget* pDiffWindowFrame = new QWidget(); // Contains diff windows, overview and vert scrollbar
     pDiffWindowFrame->setObjectName("DiffWindowFrame");
     QHBoxLayout* pDiffHLayout = new QHBoxLayout(pDiffWindowFrame);
     pDiffHLayout->setMargin(0);
     pDiffHLayout->setSpacing(0);
     pVSplitter->addWidget(pDiffWindowFrame);
 
     m_pDiffWindowSplitter = new QSplitter();
     m_pDiffWindowSplitter->setObjectName("DiffWindowSplitter");
     m_pDiffWindowSplitter->setOpaqueResize(false);
 
     m_pDiffWindowSplitter->setOrientation(m_pOptions->m_bHorizDiffWindowSplitting ? Qt::Horizontal : Qt::Vertical);
     pDiffHLayout->addWidget(m_pDiffWindowSplitter);
 
     m_pOverview = new Overview(m_pOptionDialog->getOptions());
     m_pOverview->setObjectName("Overview");
     pDiffHLayout->addWidget(m_pOverview);
 
     connect(m_pOverview, &Overview::setLine, DiffTextWindow::mVScrollBar, &QScrollBar::setValue);
     connect(this, &KDiff3App::showWhiteSpaceToggled, m_pOverview, &Overview::slotRedraw);
     connect(this, &KDiff3App::changeOverViewMode, m_pOverview, &Overview::setOverviewMode);
 
     DiffTextWindow::mVScrollBar = new QScrollBar(Qt::Vertical, pDiffWindowFrame);
     pDiffHLayout->addWidget(DiffTextWindow::mVScrollBar);
 
     m_pDiffTextWindowFrame1 = new DiffTextWindowFrame(m_pDiffWindowSplitter, m_pOptionDialog->getOptions(), e_SrcSelector::A, m_sd1);
     m_pDiffWindowSplitter->addWidget(m_pDiffTextWindowFrame1);
     m_pDiffTextWindowFrame2 = new DiffTextWindowFrame(m_pDiffWindowSplitter, m_pOptionDialog->getOptions(), e_SrcSelector::B, m_sd2);
     m_pDiffWindowSplitter->addWidget(m_pDiffTextWindowFrame2);
     m_pDiffTextWindowFrame3 = new DiffTextWindowFrame(m_pDiffWindowSplitter, m_pOptionDialog->getOptions(), e_SrcSelector::C, m_sd3);
     m_pDiffWindowSplitter->addWidget(m_pDiffTextWindowFrame3);
     m_pDiffTextWindow1 = m_pDiffTextWindowFrame1->getDiffTextWindow();
     m_pDiffTextWindow2 = m_pDiffTextWindowFrame2->getDiffTextWindow();
     m_pDiffTextWindow3 = m_pDiffTextWindowFrame3->getDiffTextWindow();
 
     m_pDiffTextWindowFrame1->setupConnections(this);
     m_pDiffTextWindowFrame2->setupConnections(this);
     m_pDiffTextWindowFrame3->setupConnections(this);
 
     // Merge window
     m_pMergeWindowFrame = new QWidget(pVSplitter);
     m_pMergeWindowFrame->setObjectName("MergeWindowFrame");
     pVSplitter->addWidget(m_pMergeWindowFrame);
     QHBoxLayout* pMergeHLayout = new QHBoxLayout(m_pMergeWindowFrame);
     pMergeHLayout->setMargin(0);
     pMergeHLayout->setSpacing(0);
     QVBoxLayout* pMergeVLayout = new QVBoxLayout();
     pMergeHLayout->addLayout(pMergeVLayout, 1);
 
     m_pMergeResultWindowTitle = new WindowTitleWidget(m_pOptionDialog->getOptions());
     pMergeVLayout->addWidget(m_pMergeResultWindowTitle);
 
     m_pMergeResultWindow = new MergeResultWindow(m_pMergeWindowFrame, m_pOptionDialog->getOptions(), statusBar());
     pMergeVLayout->addWidget(m_pMergeResultWindow, 1);
 
     MergeResultWindow::mVScrollBar = new QScrollBar(Qt::Vertical, m_pMergeWindowFrame);
     pMergeHLayout->addWidget(MergeResultWindow::mVScrollBar);
 
     m_pMainSplitter->addWidget(m_pMainWidget);
 
     autoAdvance->setEnabled(true);
 
     QList<int> sizes = pVSplitter->sizes();
     int total = sizes[0] + sizes[1];
     if(total < 10)
         total = 100;
     sizes[0] = total / 2;
     sizes[1] = total / 2;
     pVSplitter->setSizes(sizes);
 
     QList<int> hSizes;
     hSizes << 1 << 1 << 1;
     m_pDiffWindowSplitter->setSizes(hSizes);
 
     m_pMergeResultWindow->installEventFilter(m_pMergeResultWindowTitle); // for focus tracking
 
     QHBoxLayout* pHScrollBarLayout = new QHBoxLayout();
     pVLayout->addLayout(pHScrollBarLayout);
     m_pHScrollBar = new ReversibleScrollBar(Qt::Horizontal, &m_pOptions->m_bRightToLeftLanguage);
     pHScrollBarLayout->addWidget(m_pHScrollBar);
     m_pCornerWidget = new QWidget(m_pMainWidget);
     pHScrollBarLayout->addWidget(m_pCornerWidget);
 
     connect(DiffTextWindow::mVScrollBar, &QScrollBar::valueChanged, m_pOverview, &Overview::setFirstLine);
     connect(DiffTextWindow::mVScrollBar, &QScrollBar::valueChanged, m_pDiffTextWindow1, &DiffTextWindow::setFirstLine);
     connect(m_pHScrollBar, &ReversibleScrollBar::valueChanged2, m_pDiffTextWindow1, &DiffTextWindow::setHorizScrollOffset);
     m_pDiffTextWindow1->setupConnections(this);
 
     connect(DiffTextWindow::mVScrollBar, &QScrollBar::valueChanged, m_pDiffTextWindow2, &DiffTextWindow::setFirstLine);
     connect(m_pHScrollBar, &ReversibleScrollBar::valueChanged2, m_pDiffTextWindow2, &DiffTextWindow::setHorizScrollOffset);
     m_pDiffTextWindow2->setupConnections(this);
 
     connect(DiffTextWindow::mVScrollBar, &QScrollBar::valueChanged, m_pDiffTextWindow3, &DiffTextWindow::setFirstLine);
     connect(m_pHScrollBar, &ReversibleScrollBar::valueChanged2, m_pDiffTextWindow3, &DiffTextWindow::setHorizScrollOffset);
     m_pDiffTextWindow3->setupConnections(this);
 
     MergeResultWindow* p = m_pMergeResultWindow;
     connect(MergeResultWindow::mVScrollBar, &QScrollBar::valueChanged, p, &MergeResultWindow::setFirstLine);
 
     connect(m_pHScrollBar, &ReversibleScrollBar::valueChanged2, p, &MergeResultWindow::setHorizScrollOffset);
     connect(p, &MergeResultWindow::modifiedChanged, m_pMergeResultWindowTitle, &WindowTitleWidget::slotSetModified);
     p->setupConnections(this);
     sourceMask(0, 0);
 
     connect(p, &MergeResultWindow::setFastSelectorRange, m_pDiffTextWindow1, &DiffTextWindow::setFastSelectorRange);
     connect(p, &MergeResultWindow::setFastSelectorRange, m_pDiffTextWindow2, &DiffTextWindow::setFastSelectorRange);
     connect(p, &MergeResultWindow::setFastSelectorRange, m_pDiffTextWindow3, &DiffTextWindow::setFastSelectorRange);
     connect(m_pDiffTextWindow1, &DiffTextWindow::setFastSelectorLine, p, &MergeResultWindow::slotSetFastSelectorLine);
     connect(m_pDiffTextWindow2, &DiffTextWindow::setFastSelectorLine, p, &MergeResultWindow::slotSetFastSelectorLine);
     connect(m_pDiffTextWindow3, &DiffTextWindow::setFastSelectorLine, p, &MergeResultWindow::slotSetFastSelectorLine);
     connect(m_pDiffTextWindow1, &DiffTextWindow::gotFocus, p, &MergeResultWindow::updateSourceMask);
     connect(m_pDiffTextWindow2, &DiffTextWindow::gotFocus, p, &MergeResultWindow::updateSourceMask);
     connect(m_pDiffTextWindow3, &DiffTextWindow::gotFocus, p, &MergeResultWindow::updateSourceMask);
     connect(m_pDirectoryMergeInfo, &DirectoryMergeInfo::gotFocus, p, &MergeResultWindow::updateSourceMask);
 
     connect(m_pDiffTextWindow1, &DiffTextWindow::resizeHeightChangedSignal, this, &KDiff3App::resizeDiffTextWindowHeight);
     // The following two connects cause the wordwrap to be recalced thrice, just to make sure. Better than forgetting one.
     connect(m_pDiffTextWindow1, &DiffTextWindow::resizeWidthChangedSignal, this, &KDiff3App::postRecalcWordWrap);
     connect(m_pDiffTextWindow2, &DiffTextWindow::resizeWidthChangedSignal, this, &KDiff3App::postRecalcWordWrap);
     connect(m_pDiffTextWindow3, &DiffTextWindow::resizeWidthChangedSignal, this, &KDiff3App::postRecalcWordWrap);
 
     m_pDiffTextWindow1->setFocus();
     m_pMainWidget->setMinimumSize(50, 50);
     m_pCornerWidget->setFixedSize(DiffTextWindow::mVScrollBar->width(), m_pHScrollBar->height());
     showWindowA->setChecked(true);
     showWindowB->setChecked(true);
     showWindowC->setChecked(true);
 }
 
 // called after word wrap is complete
 void KDiff3App::slotFinishMainInit()
 {
     Q_ASSERT(m_pDiffTextWindow1 != nullptr && DiffTextWindow::mVScrollBar != nullptr && m_pOverview != nullptr);
 
     setHScrollBarRange();
 
     int newHeight = m_pDiffTextWindow1->getNofVisibleLines();
     /*int newWidth  = m_pDiffTextWindow1->getNofVisibleColumns();*/
     m_DTWHeight = newHeight;
 
     DiffTextWindow::mVScrollBar->setRange(0, std::max(0, m_neededLines + 1 - newHeight));
     DiffTextWindow::mVScrollBar->setPageStep(newHeight);
     m_pOverview->setRange(DiffTextWindow::mVScrollBar->value(), DiffTextWindow::mVScrollBar->pageStep());
 
     int d3l = -1;
     if(!m_manualDiffHelpList.empty())
         d3l = m_manualDiffHelpList.front().calcManualDiffFirstDiff3LineIdx(m_diff3LineVector);
     if(d3l >= 0 && m_pDiffTextWindow1)
     {
         int line = m_pDiffTextWindow1->convertDiff3LineIdxToLine(d3l);
         DiffTextWindow::mVScrollBar->setValue(std::max(0, line - 1));
     }
     else
     {
         m_pMergeResultWindow->slotGoTop();
         if(!m_outputFilename.isEmpty() && !m_pMergeResultWindow->isUnsolvedConflictAtCurrent())
             m_pMergeResultWindow->slotGoNextUnsolvedConflict();
     }
 
     if(m_pCornerWidget)
         m_pCornerWidget->setFixedSize(DiffTextWindow::mVScrollBar->width(), m_pHScrollBar->height());
 
     slotUpdateAvailabilities();
     setUpdatesEnabled(true);
 
     bool bVisibleMergeResultWindow = !m_outputFilename.isEmpty();
     TotalDiffStatus* pTotalDiffStatus = &m_totalDiffStatus;
 
     if(m_bLoadFiles)
     {
         if(bVisibleMergeResultWindow)
             m_pMergeResultWindow->showNrOfConflicts();
         else if(
             // Avoid showing this message during startup without parameters.
             !(m_sd1->getAliasName().isEmpty() && m_sd2->getAliasName().isEmpty() && m_sd3->getAliasName().isEmpty()) &&
             (m_sd1->isValid() && m_sd2->isValid() && m_sd3->isValid()))
         {
             QString totalInfo;
             if(pTotalDiffStatus->isBinaryEqualAB() && pTotalDiffStatus->isBinaryEqualAC())
                 totalInfo += i18n("All input files are binary equal.");
             else if(pTotalDiffStatus->isTextEqualAB() && pTotalDiffStatus->isTextEqualAC())
                 totalInfo += i18n("All input files contain the same text, but are not binary equal.");
             else
             {
                 if(pTotalDiffStatus->isBinaryEqualAB())
                     totalInfo += i18n("Files %1 and %2 are binary equal.\n", i18n("A"), i18n("B"));
                 else if(pTotalDiffStatus->isTextEqualAB())
                     totalInfo += i18n("Files %1 and %2 have equal text, but are not binary equal. \n", i18n("A"), i18n("B"));
                 if(pTotalDiffStatus->isBinaryEqualAC())
                     totalInfo += i18n("Files %1 and %2 are binary equal.\n", i18n("A"), i18n("C"));
                 else if(pTotalDiffStatus->isTextEqualAC())
                     totalInfo += i18n("Files %1 and %2 have equal text, but are not binary equal. \n", i18n("A"), i18n("C"));
                 if(pTotalDiffStatus->isBinaryEqualBC())
                     totalInfo += i18n("Files %1 and %2 are binary equal.\n", i18n("B"), i18n("C"));
                 else if(pTotalDiffStatus->isTextEqualBC())
                     totalInfo += i18n("Files %1 and %2 have equal text, but are not binary equal. \n", i18n("B"), i18n("C"));
             }
 
             if(!totalInfo.isEmpty())
                 KMessageBox::information(this, totalInfo);
         }
 
         if(bVisibleMergeResultWindow && (!m_sd1->isText() || !m_sd2->isText() || !m_sd3->isText()))
         {
             KMessageBox::information(this, i18n(
                                                "Some input files do not seem to be pure text files.\n"
                                                "Note that the KDiff3 merge was not meant for binary data.\n"
                                                "Continue at your own risk."));
         }
         if(m_sd1->isIncompleteConversion() || m_sd2->isIncompleteConversion() || m_sd3->isIncompleteConversion())
         {
             QString files;
             if(m_sd1->isIncompleteConversion())
                 files += i18n("A");
             if(m_sd2->isIncompleteConversion())
                 files += files.isEmpty() ? i18n("B") : i18n(", B");
             if(m_sd3->isIncompleteConversion())
                 files += files.isEmpty() ? i18n("C") : i18n(", C");
 
             KMessageBox::information(this, i18n("Some input characters could not be converted to valid unicode.\n"
                                                 "You might be using the wrong codec. (e.g. UTF-8 for non UTF-8 files).\n"
                                                 "Do not save the result if unsure. Continue at your own risk.\n"
                                                 "Affected input files are in %1.", files));
         }
     }
 
     if(bVisibleMergeResultWindow && m_pMergeResultWindow)
     {
         m_pMergeResultWindow->setFocus();
     }
     else if(m_pDiffTextWindow1)
     {
         m_pDiffTextWindow1->setFocus();
     }
 }
 
 void KDiff3App::resizeEvent(QResizeEvent* e)
 {
     QSplitter::resizeEvent(e);
     if(m_pCornerWidget)
         m_pCornerWidget->setFixedSize(DiffTextWindow::mVScrollBar->width(), m_pHScrollBar->height());
 }
 
 void KDiff3App::wheelEvent(QWheelEvent* pWheelEvent)
 {
     pWheelEvent->accept();
     QPoint delta = pWheelEvent->angleDelta();
 
     //Block diagonal scrolling easily generated unintentionally with track pads.
     if(delta.x() != 0 && abs(delta.y()) < abs(delta.x()) && m_pHScrollBar != nullptr)
         QCoreApplication::postEvent(m_pHScrollBar, new QWheelEvent(*pWheelEvent));
 }
 
 void KDiff3App::keyPressEvent(QKeyEvent* keyEvent)
 {
     if(keyEvent->key() == Qt::Key_Escape && m_pKDiff3Shell && m_pOptions->m_bEscapeKeyQuits)
     {
         m_pKDiff3Shell->close();
         return;
     }
 
     bool bCtrl = (keyEvent->QInputEvent::modifiers() & Qt::ControlModifier) != 0;
 
     switch(keyEvent->key())
     {
         case Qt::Key_Down:
         case Qt::Key_Up:
         case Qt::Key_PageDown:
         case Qt::Key_PageUp:
             if(DiffTextWindow::mVScrollBar != nullptr)
                 QCoreApplication::postEvent(DiffTextWindow::mVScrollBar, new QKeyEvent(*keyEvent));
             return;
         case Qt::Key_Left:
         case Qt::Key_Right:
             if(m_pHScrollBar != nullptr)
                 QCoreApplication::postEvent(m_pHScrollBar, new QKeyEvent(*keyEvent));
 
             break;
         case Qt::Key_End:
         case Qt::Key_Home:
             if(bCtrl)
             {
                 if(DiffTextWindow::mVScrollBar != nullptr)
                     QCoreApplication::postEvent(DiffTextWindow::mVScrollBar, new QKeyEvent(*keyEvent));
             }
             else
             {
                 if(m_pHScrollBar != nullptr)
                     QCoreApplication::postEvent(m_pHScrollBar, new QKeyEvent(*keyEvent));
             }
             break;
         default:
             break;
     }
 }
 
 void KDiff3App::slotFinishDrop()
 {
     raise();
     mainInit();
 }
 
 void KDiff3App::slotFileOpen()
 {
-    bool bShouldConintue = false;
-    Q_EMIT checkIfCanContinue(bShouldConintue);
-    if(!bShouldConintue) return;
+    if(!shouldContinue()) return;
     //create dummy DirectoryInfo record for first run so we don't crash.
     if(m_dirinfo == nullptr)
         m_dirinfo = QSharedPointer<DirectoryInfo>::create();
 
     if(m_pDirectoryMergeWindow->isDirectoryMergeInProgress())
     {
         int result = KMessageBox::warningYesNo(this,
                                                i18n("You are currently doing a folder merge. Are you sure, you want to abort?"),
                                                i18n("Warning"),
                                                KGuiItem(i18n("Abort")),
                                                KGuiItem(i18n("Continue Merging")));
         if(result != KMessageBox::Yes)
             return;
     }
 
     slotStatusMsg(i18n("Opening files..."));
 
     for(;;)
     {
          QPointer<OpenDialog> d = QPointer<OpenDialog>(new OpenDialog(this,
                      QDir::toNativeSeparators(m_bDirCompare ? m_dirinfo->dirA().prettyAbsPath() : m_sd1->isFromBuffer() ? QString("") : m_sd1->getAliasName()),
                      QDir::toNativeSeparators(m_bDirCompare ? m_dirinfo->dirB().prettyAbsPath() : m_sd2->isFromBuffer() ? QString("") : m_sd2->getAliasName()),
                      QDir::toNativeSeparators(m_bDirCompare ? m_dirinfo->dirC().prettyAbsPath() : m_sd3->isFromBuffer() ? QString("") : m_sd3->getAliasName()),
                      m_bDirCompare ? !m_dirinfo->destDir().prettyAbsPath().isEmpty() : !m_outputFilename.isEmpty(),
                      QDir::toNativeSeparators(m_bDefaultFilename ? QString("") : m_outputFilename), m_pOptionDialog->getOptions()));
 
         int status = d->exec();
         if(status == QDialog::Accepted)
         {
             m_sd1->setFilename(d->m_pLineA->currentText());
             m_sd2->setFilename(d->m_pLineB->currentText());
             m_sd3->setFilename(d->m_pLineC->currentText());
 
             if(d->m_pMerge->isChecked())
             {
                 if(d->m_pLineOut->currentText().isEmpty())
                 {
                     m_outputFilename = "unnamed.txt";
                     m_bDefaultFilename = true;
                 }
                 else
                 {
                     m_outputFilename = d->m_pLineOut->currentText();
                     m_bDefaultFilename = false;
                 }
             }
             else
                 m_outputFilename = "";
 
             m_bDirCompare = m_sd1->isDir();
             bool bSuccess = improveFilenames(false);
 
             if(!bSuccess)
                 continue;
 
             if(m_bDirCompare)
             {
                 m_pDirectoryMergeSplitter->show();
                 if(m_pMainWidget != nullptr)
                 {
                     m_pMainWidget->hide();
                 }
                 break;
             }
             else
             {
                 m_pDirectoryMergeSplitter->hide();
                 mainInit();
 
                 if((!m_sd1->isEmpty() && !m_sd1->hasData()) ||
                    (!m_sd2->isEmpty() && !m_sd2->hasData()) ||
                    (!m_sd3->isEmpty() && !m_sd3->hasData()))
                 {
                     QString text(i18n("Opening of these files failed:"));
                     text += "\n\n";
                     if(!m_sd1->isEmpty() && !m_sd1->hasData())
                         text += " - " + m_sd1->getAliasName() + '\n';
                     if(!m_sd2->isEmpty() && !m_sd2->hasData())
                         text += " - " + m_sd2->getAliasName() + '\n';
                     if(!m_sd3->isEmpty() && !m_sd3->hasData())
                         text += " - " + m_sd3->getAliasName() + '\n';
 
                     KMessageBox::sorry(this, text, i18n("File open error"));
                     continue;
                 }
             }
         }
         break;
     }
 
     slotUpdateAvailabilities();
     slotStatusMsg(i18n("Ready."));
 }
 
 void KDiff3App::slotFileOpen2(const QString& fn1, const QString& fn2, const QString& fn3, const QString& ofn,
                               const QString& an1, const QString& an2, const QString& an3, TotalDiffStatus* pTotalDiffStatus)
 {
-    bool bShouldConintue = false;
-    Q_EMIT checkIfCanContinue(bShouldConintue);
-    if(!bShouldConintue) return;
+    if(!shouldContinue()) return;
 
     if(fn1.isEmpty() && fn2.isEmpty() && fn3.isEmpty() && ofn.isEmpty() && m_pMainWidget != nullptr)
     {
         m_pMainWidget->hide();
         return;
     }
 
     slotStatusMsg(i18n("Opening files..."));
 
     m_sd1->setFilename(fn1);
     m_sd2->setFilename(fn2);
     m_sd3->setFilename(fn3);
 
     m_sd1->setAliasName(an1);
     m_sd2->setAliasName(an2);
     m_sd3->setAliasName(an3);
 
     if(!ofn.isEmpty())
     {
         m_outputFilename = ofn;
         m_bDefaultFilename = false;
     }
     else
     {
         m_outputFilename = "";
         m_bDefaultFilename = true;
     }
 
     improveFilenames(true); // Create new window for KDiff3 for directory comparison.
 
     if(!m_sd1->isDir())
     {
         mainInit(pTotalDiffStatus);
 
         if(pTotalDiffStatus != nullptr)
             return;
 
         if(!((!m_sd1->isEmpty() && !m_sd1->hasData()) ||
            (!m_sd2->isEmpty() && !m_sd2->hasData()) ||
            (!m_sd3->isEmpty() && !m_sd3->hasData())))
         {
             if(m_pDirectoryMergeWindow != nullptr && m_pDirectoryMergeWindow->isVisible() && !dirShowBoth->isChecked())
             {
                 slotDirViewToggle();
             }
         }
     }
     slotStatusMsg(i18n("Ready."));
 }
 
 void KDiff3App::slotFileNameChanged(const QString& fileName, e_SrcSelector winIdx)
 {
     QString fn1 = m_sd1->getFilename();
     QString an1 = m_sd1->getAliasName();
     QString fn2 = m_sd2->getFilename();
     QString an2 = m_sd2->getAliasName();
     QString fn3 = m_sd3->getFilename();
     QString an3 = m_sd3->getAliasName();
     if(winIdx == e_SrcSelector::A)
     {
         fn1 = fileName;
         an1 = "";
     }
     if(winIdx == e_SrcSelector::B)
     {
         fn2 = fileName;
         an2 = "";
     }
     if(winIdx == e_SrcSelector::C)
     {
         fn3 = fileName;
         an3 = "";
     }
 
     slotFileOpen2(fn1, fn2, fn3, m_outputFilename, an1, an2, an3, nullptr);
 }
 
 void KDiff3App::slotEditCut()
 {
     slotStatusMsg(i18n("Cutting selection..."));
     Q_EMIT cut();
     slotStatusMsg(i18n("Ready."));
 }
 
 void KDiff3App::slotEditCopy()
 {
     slotStatusMsg(i18n("Copying selection to clipboard..."));
     QString s;
     if(m_pDiffTextWindow1 != nullptr) s = m_pDiffTextWindow1->getSelection();
     if(s.isEmpty() && m_pDiffTextWindow2 != nullptr) s = m_pDiffTextWindow2->getSelection();
     if(s.isEmpty() && m_pDiffTextWindow3 != nullptr) s = m_pDiffTextWindow3->getSelection();
     if(s.isEmpty() && m_pMergeResultWindow != nullptr) s = m_pMergeResultWindow->getSelection();
     if(!s.isEmpty())
     {
         QApplication::clipboard()->setText(s, QClipboard::Clipboard);
     }
 
     slotStatusMsg(i18n("Ready."));
 }
 
 void KDiff3App::slotEditPaste()
 {
     slotStatusMsg(i18n("Inserting clipboard contents..."));
 
     if(m_pMergeResultWindow != nullptr && m_pMergeResultWindow->isVisible())
     {
         m_pMergeResultWindow->pasteClipboard(false);
     }
     else
     {
-        bool bShouldConintue = false;
-        Q_EMIT checkIfCanContinue(bShouldConintue);
-        if(bShouldConintue)
+        if(shouldContinue())
         {
             QString error;
             bool do_init = false;
 
             if(m_pDiffTextWindow1->hasFocus())
             {
                 error = m_sd1->setData(QApplication::clipboard()->text(QClipboard::Clipboard));
                 do_init = true;
             }
             else if(m_pDiffTextWindow2->hasFocus())
             {
                 error = m_sd2->setData(QApplication::clipboard()->text(QClipboard::Clipboard));
                 do_init = true;
             }
             else if(m_pDiffTextWindow3->hasFocus())
             {
                 error = m_sd3->setData(QApplication::clipboard()->text(QClipboard::Clipboard));
                 do_init = true;
             }
 
             if(!error.isEmpty())
             {
                 KMessageBox::error(m_pOptionDialog, error);
             }
 
             if(do_init)
             {
                 mainInit();
             }
         }
     }
 
     slotStatusMsg(i18n("Ready."));
 }
 
 void KDiff3App::slotEditSelectAll()
 {
 
     Q_EMIT selectAll();
 
     slotStatusMsg(i18n("Ready."));
 }
 
 void KDiff3App::slotGoCurrent()
 {
     Q_EMIT goCurrent();
 }
 void KDiff3App::slotGoTop()
 {
     Q_EMIT goTop();
 }
 void KDiff3App::slotGoBottom()
 {
     Q_EMIT goBottom();
 }
 void KDiff3App::slotGoPrevUnsolvedConflict()
 {
     Q_EMIT goPrevUnsolvedConflict();
 }
 void KDiff3App::slotGoNextUnsolvedConflict()
 {
     m_bTimerBlock = false;
     Q_EMIT goNextUnsolvedConflict();
 }
 void KDiff3App::slotGoPrevConflict()
 {
     Q_EMIT goPrevConflict();
 }
 void KDiff3App::slotGoNextConflict()
 {
     m_bTimerBlock = false;
     Q_EMIT goNextConflict();
 }
 void KDiff3App::slotGoPrevDelta()
 {
     Q_EMIT goPrevDelta();
 }
 void KDiff3App::slotGoNextDelta()
 {
     Q_EMIT goNextDelta();
 }
 
 void KDiff3App::choose(e_SrcSelector choice)
 {
     if(!m_bTimerBlock)
     {
         if(m_pDirectoryMergeWindow && m_pDirectoryMergeWindow->hasFocus())
         {
             if(choice == e_SrcSelector::A) m_pDirectoryMergeWindow->slotCurrentChooseA();
             if(choice == e_SrcSelector::B) m_pDirectoryMergeWindow->slotCurrentChooseB();
             if(choice == e_SrcSelector::C) m_pDirectoryMergeWindow->slotCurrentChooseC();
 
             chooseA->setChecked(false);
             chooseB->setChecked(false);
             chooseC->setChecked(false);
         }
         else if(m_pMergeResultWindow)
         {
             m_pMergeResultWindow->choose(choice);
             if(autoAdvance->isChecked())
             {
                 m_bTimerBlock = true;
                 QTimer::singleShot(m_pOptions->m_autoAdvanceDelay, this, &KDiff3App::slotGoNextUnsolvedConflict);
             }
         }
     }
 }
 
 void KDiff3App::slotChooseA()
 {
     choose(e_SrcSelector::A);
 }
 void KDiff3App::slotChooseB()
 {
     choose(e_SrcSelector::B);
 }
 void KDiff3App::slotChooseC()
 {
     choose(e_SrcSelector::C);
 }
 
 void KDiff3App::slotAutoSolve()
 {
     Q_EMIT autoSolve();
 
     slotUpdateAvailabilities();
 }
 
 void KDiff3App::slotUnsolve()
 {
     Q_EMIT unsolve();
 }
 
 void KDiff3App::slotMergeHistory()
 {
     Q_EMIT mergeHistory();
 }
 
 void KDiff3App::slotRegExpAutoMerge()
 {
     Q_EMIT regExpAutoMerge();
 }
 
 void KDiff3App::slotSplitDiff()
 {
     LineRef firstLine;
     LineRef lastLine;
     DiffTextWindow* pDTW = nullptr;
     if(m_pDiffTextWindow1)
     {
         pDTW = m_pDiffTextWindow1;
         pDTW->getSelectionRange(&firstLine, &lastLine, eD3LLineCoords);
     }
     if(!firstLine.isValid() && m_pDiffTextWindow2)
     {
         pDTW = m_pDiffTextWindow2;
         pDTW->getSelectionRange(&firstLine, &lastLine, eD3LLineCoords);
     }
     if(!firstLine.isValid() && m_pDiffTextWindow3)
     {
         pDTW = m_pDiffTextWindow3;
         pDTW->getSelectionRange(&firstLine, &lastLine, eD3LLineCoords);
     }
     if(pDTW && firstLine.isValid() && m_pMergeResultWindow)
     {
         pDTW->resetSelection();
 
         m_pMergeResultWindow->slotSplitDiff(firstLine, lastLine);
     }
 }
 
 void KDiff3App::slotJoinDiffs()
 {
     LineRef firstLine;
     LineRef lastLine;
     DiffTextWindow* pDTW = nullptr;
     if(m_pDiffTextWindow1)
     {
         pDTW = m_pDiffTextWindow1;
         pDTW->getSelectionRange(&firstLine, &lastLine, eD3LLineCoords);
     }
     if(!firstLine.isValid() && m_pDiffTextWindow2)
     {
         pDTW = m_pDiffTextWindow2;
         pDTW->getSelectionRange(&firstLine, &lastLine, eD3LLineCoords);
     }
     if(!firstLine.isValid() && m_pDiffTextWindow3)
     {
         pDTW = m_pDiffTextWindow3;
         pDTW->getSelectionRange(&firstLine, &lastLine, eD3LLineCoords);
     }
     if(pDTW && firstLine.isValid() && m_pMergeResultWindow)
     {
         pDTW->resetSelection();
 
         m_pMergeResultWindow->slotJoinDiffs(firstLine, lastLine);
     }
 }
 
 void KDiff3App::slotConfigure()
 {
     m_pOptionDialog->setState();
     m_pOptionDialog->setMinimumHeight(m_pOptionDialog->minimumHeight() + 40);
     m_pOptionDialog->exec();
     slotRefresh();
 }
 
 void KDiff3App::slotConfigureKeys()
 {
     KShortcutsDialog::configure(actionCollection(), KShortcutsEditor::LetterShortcutsAllowed, this);
 }
 
 void KDiff3App::slotRefresh()
 {
     QApplication::setFont(m_pOptions->m_appFont);
 
     Q_EMIT doRefresh();
 
     if(m_pHScrollBar != nullptr)
     {
         m_pHScrollBar->setAgain();
     }
     if(m_pDiffWindowSplitter != nullptr)
     {
         m_pDiffWindowSplitter->setOrientation(m_pOptions->m_bHorizDiffWindowSplitting ? Qt::Horizontal : Qt::Vertical);
     }
 }
 
 void KDiff3App::slotSelectionStart()
 {
     //editCopy->setEnabled( false );
     //editCut->setEnabled( false );
 
     const QObject* s = sender();
     if(m_pDiffTextWindow1 && s != m_pDiffTextWindow1) m_pDiffTextWindow1->resetSelection();
     if(m_pDiffTextWindow2 && s != m_pDiffTextWindow2) m_pDiffTextWindow2->resetSelection();
     if(m_pDiffTextWindow3 && s != m_pDiffTextWindow3) m_pDiffTextWindow3->resetSelection();
     if(m_pMergeResultWindow && s != m_pMergeResultWindow) m_pMergeResultWindow->resetSelection();
 }
 
 void KDiff3App::slotSelectionEnd()
 {
     //const QObject* s = sender();
     //editCopy->setEnabled(true);
     //editCut->setEnabled( s==m_pMergeResultWindow );
     if(m_pOptions->m_bAutoCopySelection)
     {
         slotEditCopy();
     }
     else
     {
         QClipboard* clipBoard = QApplication::clipboard();
 
         if(clipBoard->supportsSelection())
         {
             QString s;
             if(m_pDiffTextWindow1 != nullptr) s = m_pDiffTextWindow1->getSelection();
             if(s.isEmpty() && m_pDiffTextWindow2 != nullptr) s = m_pDiffTextWindow2->getSelection();
             if(s.isEmpty() && m_pDiffTextWindow3 != nullptr) s = m_pDiffTextWindow3->getSelection();
             if(s.isEmpty() && m_pMergeResultWindow != nullptr) s = m_pMergeResultWindow->getSelection();
             if(!s.isEmpty())
             {
                 clipBoard->setText(s, QClipboard::Selection);
             }
         }
     }
 }
 
 void KDiff3App::slotClipboardChanged()
 {
     const QClipboard* clipboard = QApplication::clipboard();
     const QMimeData* mimeData = clipboard->mimeData();
     if(mimeData->hasText())
     {
         QString s = clipboard->text();
         editPaste->setEnabled(!s.isEmpty());
     }
     else
     {
         editPaste->setEnabled(false);
     }
 }
 
 void KDiff3App::slotOutputModified(bool bModified)
 {
     if(bModified && !m_bOutputModified)
     {
         m_bOutputModified = true;
         slotUpdateAvailabilities();
     }
 }
 
 void KDiff3App::slotAutoAdvanceToggled()
 {
     m_pOptions->m_bAutoAdvance = autoAdvance->isChecked();
 }
 
 void KDiff3App::slotWordWrapToggled()
 {
     m_pOptions->setWordWrap(wordWrap->isChecked());
     postRecalcWordWrap();
 }
 
 // Enable or disable all widgets except the status bar widget.
 void KDiff3App::mainWindowEnable(bool bEnable)
 {
     if(QMainWindow* pWindow = dynamic_cast<QMainWindow*>(window()))
     {
         QWidget* pStatusBarWidget = pWindow->statusBar();
         pWindow->setEnabled(bEnable);
         pStatusBarWidget->setEnabled(true);
     }
 }
 
 void KDiff3App::postRecalcWordWrap()
 {
     if(!m_bRecalcWordWrapPosted)
     {
         m_bRecalcWordWrapPosted = true;
         m_firstD3LIdx = -1;
         Q_EMIT sigRecalcWordWrap();
     }
     else
     {
         g_pProgressDialog->cancel(ProgressDialog::eResize);
     }
 }
 
 void KDiff3App::slotRecalcWordWrap()
 {
     recalcWordWrap();
 }
 
 // visibleTextWidthForPrinting is >=0 only for printing, otherwise the really visible width is used
 void KDiff3App::recalcWordWrap(int visibleTextWidthForPrinting)
 {
     m_bRecalcWordWrapPosted = true;
     mainWindowEnable(false);
 
     if(m_firstD3LIdx < 0)
     {
         m_firstD3LIdx = 0;
         if(m_pDiffTextWindow1)
             m_firstD3LIdx = m_pDiffTextWindow1->convertLineToDiff3LineIdx(m_pDiffTextWindow1->getFirstLine());
     }
 
     // Convert selection to D3L-coords (converting back happens in DiffTextWindow::recalcWordWrap()
     if(m_pDiffTextWindow1)
         m_pDiffTextWindow1->convertSelectionToD3LCoords();
     if(m_pDiffTextWindow2)
         m_pDiffTextWindow2->convertSelectionToD3LCoords();
     if(m_pDiffTextWindow3)
         m_pDiffTextWindow3->convertSelectionToD3LCoords();
 
     g_pProgressDialog->clearCancelState(); // clear cancelled state if previously set
 
     if(!m_diff3LineList.empty())
     {
         if(m_pOptions->wordWrapOn())
         {
             m_diff3LineList.recalcWordWrap(true);
 
             // Let every window calc how many lines will be needed.
             if(m_pDiffTextWindow1)
             {
                 m_pDiffTextWindow1->recalcWordWrap(true, 0, visibleTextWidthForPrinting);
             }
             if(m_pDiffTextWindow2)
             {
                 m_pDiffTextWindow2->recalcWordWrap(true, 0, visibleTextWidthForPrinting);
             }
             if(m_pDiffTextWindow3)
             {
                 m_pDiffTextWindow3->recalcWordWrap(true, 0, visibleTextWidthForPrinting);
             }
         }
         else
         {
             m_neededLines = m_diff3LineVector.size();
             if(m_pDiffTextWindow1)
                 m_pDiffTextWindow1->recalcWordWrap(false, 0, 0);
             if(m_pDiffTextWindow2)
                 m_pDiffTextWindow2->recalcWordWrap(false, 0, 0);
             if(m_pDiffTextWindow3)
                 m_pDiffTextWindow3->recalcWordWrap(false, 0, 0);
         }
         bool bRunnablesStarted = DiffTextWindow::startRunnables();
         if(!bRunnablesStarted)
             slotFinishRecalcWordWrap(visibleTextWidthForPrinting);
         else
         {
             g_pProgressDialog->setInformation(m_pOptions->wordWrapOn()
                                                   ? i18n("Word wrap (Cancel disables word wrap)")
                                                   : i18n("Calculating max width for horizontal scrollbar"),
                                               false);
         }
     }
     else
     {
         //don't leave proccessing incomplete if m_diff3LineList isEmpty as when an error occures during reading.
         slotFinishRecalcWordWrap(visibleTextWidthForPrinting);
     }
 }
 
 void KDiff3App::slotFinishRecalcWordWrap(int visibleTextWidthForPrinting)
 {
     g_pProgressDialog->pop();
 
     if(m_pOptions->wordWrapOn() && g_pProgressDialog->wasCancelled())
     {
         if(g_pProgressDialog->cancelReason() == ProgressDialog::eUserAbort)
         {
             wordWrap->setChecked(false);
             m_pOptions->setWordWrap(wordWrap->isChecked());
         }
 
         Q_EMIT sigRecalcWordWrap();
         return;
     }
     else
     {
         m_bRecalcWordWrapPosted = false;
     }
 
     g_pProgressDialog->setStayHidden(false);
 
     bool bPrinting = visibleTextWidthForPrinting >= 0;
 
     if(!m_diff3LineList.empty())
     {
         if(m_pOptions->wordWrapOn())
         {
             LineCount sumOfLines = m_diff3LineList.recalcWordWrap(false);
 
             // Finish the word wrap
             if(m_pDiffTextWindow1)
                 m_pDiffTextWindow1->recalcWordWrap(true, sumOfLines, visibleTextWidthForPrinting);
             if(m_pDiffTextWindow2)
                 m_pDiffTextWindow2->recalcWordWrap(true, sumOfLines, visibleTextWidthForPrinting);
             if(m_pDiffTextWindow3)
                 m_pDiffTextWindow3->recalcWordWrap(true, sumOfLines, visibleTextWidthForPrinting);
 
             m_neededLines = sumOfLines;
         }
         else
         {
             if(m_pDiffTextWindow1)
                 m_pDiffTextWindow1->recalcWordWrap(false, 1, 0);
             if(m_pDiffTextWindow2)
                 m_pDiffTextWindow2->recalcWordWrap(false, 1, 0);
             if(m_pDiffTextWindow3)
                 m_pDiffTextWindow3->recalcWordWrap(false, 1, 0);
         }
         slotStatusMsg(QString());
     }
 
     if(!bPrinting)
     {
         if(m_pOverview)
             m_pOverview->slotRedraw();
         if(DiffTextWindow::mVScrollBar)
             DiffTextWindow::mVScrollBar->setRange(0, std::max(0, m_neededLines + 1 - m_DTWHeight));
         if(m_pDiffTextWindow1)
         {
             if(DiffTextWindow::mVScrollBar)
                 DiffTextWindow::mVScrollBar->setValue(m_pDiffTextWindow1->convertDiff3LineIdxToLine(m_firstD3LIdx));
 
             setHScrollBarRange();
             m_pHScrollBar->setValue(0);
         }
     }
     mainWindowEnable(true);
 
     if(m_bFinishMainInit)
     {
         m_bFinishMainInit = false;
         slotFinishMainInit();
     }
     if(m_pEventLoopForPrinting)
         m_pEventLoopForPrinting->quit();
 }
 
 void KDiff3App::slotShowWhiteSpaceToggled()
 {
     m_pOptions->m_bShowWhiteSpaceCharacters = showWhiteSpaceCharacters->isChecked();
     m_pOptions->m_bShowWhiteSpace = showWhiteSpace->isChecked();
 
     Q_EMIT showWhiteSpaceToggled();
 }
 
 void KDiff3App::slotShowLineNumbersToggled()
 {
     m_pOptions->m_bShowLineNumbers = showLineNumbers->isChecked();
 
     if(wordWrap->isChecked())
         recalcWordWrap();
 
     Q_EMIT showLineNumbersToggled();
 }
 
 /// Return true for success, else false
 bool KDiff3App::improveFilenames(bool bCreateNewInstance)
 {
     FileAccess f1(m_sd1->getFilename());
     FileAccess f2(m_sd2->getFilename());
     FileAccess f3(m_sd3->getFilename());
     FileAccess f4(m_outputFilename);
 
     if(f1.isFile() && f1.exists())
     {
         if(f2.isDir())
         {
             f2.addPath(f1.fileName());
             if(f2.isFile() && f2.exists())
                 m_sd2->setFileAccess(f2);
         }
         if(f3.isDir())
         {
             f3.addPath(f1.fileName());
             if(f3.isFile() && f3.exists())
                 m_sd3->setFileAccess(f3);
         }
         if(f4.isDir())
         {
             f4.addPath(f1.fileName());
             if(f4.isFile() && f4.exists())
                 m_outputFilename = f4.absoluteFilePath();
         }
     }
     else if(f1.isDir())
     {
         if(bCreateNewInstance)
         {
             Q_EMIT createNewInstance(f1.absoluteFilePath(), f2.absoluteFilePath(), f3.absoluteFilePath());
         }
         else
         {
             bool bDirCompare = m_bDirCompare;
             FileAccess destDir;
 
             if(!m_bDefaultFilename) destDir = f4;
             m_pDirectoryMergeSplitter->show();
             if(m_pMainWidget != nullptr) m_pMainWidget->hide();
             setUpdatesEnabled(true);
 
             m_dirinfo = QSharedPointer<DirectoryInfo>::create(f1, f2, f3, destDir);
             bool bSuccess = m_pDirectoryMergeWindow->init(
                 m_dirinfo,
                 !m_outputFilename.isEmpty());
             //This is a bug if it still happens.
             Q_ASSERT(m_bDirCompare == bDirCompare);
 
             if(bSuccess)
             {
                 m_sd1->reset();
                 if(m_pDiffTextWindow1 != nullptr)
                 {
                     m_pDiffTextWindow1->init(QString(""), nullptr, eLineEndStyleDos, nullptr, 0, nullptr, nullptr);
                     m_pDiffTextWindowFrame1->init();
                 }
                 m_sd2->reset();
                 if(m_pDiffTextWindow2 != nullptr)
                 {
                     m_pDiffTextWindow2->init(QString(""), nullptr, eLineEndStyleDos, nullptr, 0, nullptr, nullptr);
                     m_pDiffTextWindowFrame2->init();
                 }
                 m_sd3->reset();
                 if(m_pDiffTextWindow3 != nullptr)
                 {
                     m_pDiffTextWindow3->init(QString(""), nullptr, eLineEndStyleDos, nullptr, 0, nullptr, nullptr);
                     m_pDiffTextWindowFrame3->init();
                 }
             }
             slotUpdateAvailabilities();
             return bSuccess;
         }
     }
     return true;
 }
 
 void KDiff3App::slotReload()
 {
-    bool bShouldConintue = false;
-    Q_EMIT checkIfCanContinue(bShouldConintue);
-    if(!bShouldConintue) return;
+    if(!shouldContinue()) return;
 
     mainInit();
 }
 
 bool KDiff3App::canContinue()
 {
     // First test if anything must be saved.
     if(m_bOutputModified)
     {
         int result = KMessageBox::warningYesNoCancel(this,
                                                      i18n("The merge result has not been saved."),
                                                      i18n("Warning"),
                                                      KGuiItem(i18n("Save && Continue")),
                                                      KGuiItem(i18n("Continue Without Saving")));
         if(result == KMessageBox::Cancel)
             return false;
         else if(result == KMessageBox::Yes)
         {
             slotFileSave();
             if(m_bOutputModified)
             {
                 KMessageBox::sorry(this, i18n("Saving the merge result failed."), i18n("Warning"));
                 return false;
             }
         }
     }
 
     m_bOutputModified = false;
     return true;
 }
 
-/*
-    Translate canContinue return value to out param because Qt does not support return values on slots.
-*/
-void KDiff3App::slotCheckIfCanContinue(bool& pbContinue)
-{
-    pbContinue = canContinue();
-}
-
 void KDiff3App::slotDirShowBoth()
 {
     if(dirShowBoth->isChecked())
     {
         if(m_pDirectoryMergeSplitter)
             m_pDirectoryMergeSplitter->setVisible(m_bDirCompare);
 
         if(m_pMainWidget != nullptr)
             m_pMainWidget->show();
     }
     else
     {
         bool bTextDataAvailable = (m_sd1->hasData() || m_sd2->hasData() || m_sd3->hasData());
         if(m_pMainWidget != nullptr && bTextDataAvailable)
         {
             m_pMainWidget->show();
             m_pDirectoryMergeSplitter->hide();
         }
         else if(m_bDirCompare)
         {
             m_pDirectoryMergeSplitter->show();
         }
     }
 
     slotUpdateAvailabilities();
 }
 
 void KDiff3App::slotDirViewToggle()
 {
     if(m_bDirCompare)
     {
         if(!m_pDirectoryMergeSplitter->isVisible())
         {
             m_pDirectoryMergeSplitter->show();
             if(m_pMainWidget != nullptr)
                 m_pMainWidget->hide();
         }
         else
         {
             if(m_pMainWidget != nullptr)
             {
                 m_pDirectoryMergeSplitter->hide();
                 m_pMainWidget->show();
             }
         }
     }
     slotUpdateAvailabilities();
 }
 
 void KDiff3App::slotShowWindowAToggled()
 {
     if(m_pDiffTextWindow1 != nullptr)
     {
         m_pDiffTextWindowFrame1->setVisible(showWindowA->isChecked());
         slotUpdateAvailabilities();
     }
 }
 
 void KDiff3App::slotShowWindowBToggled()
 {
     if(m_pDiffTextWindow2 != nullptr)
     {
         m_pDiffTextWindowFrame2->setVisible(showWindowB->isChecked());
         slotUpdateAvailabilities();
     }
 }
 
 void KDiff3App::slotShowWindowCToggled()
 {
     if(m_pDiffTextWindow3 != nullptr)
     {
         m_pDiffTextWindowFrame3->setVisible(showWindowC->isChecked());
         slotUpdateAvailabilities();
     }
 }
 
 void KDiff3App::slotEditFind()
 {
     m_pFindDialog->currentLine = 0;
     m_pFindDialog->currentPos = 0;
     m_pFindDialog->currentWindow = 1;
 
     // Use currently selected text:
     QString s;
     if(m_pDiffTextWindow1 != nullptr) s = m_pDiffTextWindow1->getSelection();
     if(s.isEmpty() && m_pDiffTextWindow2 != nullptr) s = m_pDiffTextWindow2->getSelection();
     if(s.isEmpty() && m_pDiffTextWindow3 != nullptr) s = m_pDiffTextWindow3->getSelection();
     if(s.isEmpty() && m_pMergeResultWindow != nullptr) s = m_pMergeResultWindow->getSelection();
     if(!s.isEmpty() && !s.contains('\n'))
     {
         m_pFindDialog->m_pSearchString->setText(s);
     }
 
     if(QDialog::Accepted == m_pFindDialog->exec())
     {
         slotEditFindNext();
     }
 }
 
 void KDiff3App::slotEditFindNext()
 {
     QString s = m_pFindDialog->m_pSearchString->text();
     if(s.isEmpty())
     {
         slotEditFind();
         return;
     }
 
     bool bDirDown = true;
     bool bCaseSensitive = m_pFindDialog->m_pCaseSensitive->isChecked();
 
     LineRef d3vLine = m_pFindDialog->currentLine;
     int posInLine = m_pFindDialog->currentPos;
     LineRef l = 0;
     int p = 0;
     if(m_pFindDialog->currentWindow == 1)
     {
         if(m_pFindDialog->m_pSearchInA->isChecked() && m_pDiffTextWindow1 != nullptr &&
            m_pDiffTextWindow1->findString(s, d3vLine, posInLine, bDirDown, bCaseSensitive))
         {
             m_pDiffTextWindow1->setSelection(d3vLine, posInLine, d3vLine, posInLine + s.length(), l, p);
             DiffTextWindow::mVScrollBar->setValue(l - DiffTextWindow::mVScrollBar->pageStep() / 2);
             m_pHScrollBar->setValue(std::max(0, p + s.length() - m_pHScrollBar->pageStep()));
             m_pFindDialog->currentLine = d3vLine;
             m_pFindDialog->currentPos = posInLine + 1;
             return;
         }
         m_pFindDialog->currentWindow = 2;
         m_pFindDialog->currentLine = 0;
         m_pFindDialog->currentPos = 0;
     }
 
     d3vLine = m_pFindDialog->currentLine;
     posInLine = m_pFindDialog->currentPos;
     if(m_pFindDialog->currentWindow == 2)
     {
         if(m_pFindDialog->m_pSearchInB->isChecked() && m_pDiffTextWindow2 != nullptr &&
            m_pDiffTextWindow2->findString(s, d3vLine, posInLine, bDirDown, bCaseSensitive))
         {
             m_pDiffTextWindow2->setSelection(d3vLine, posInLine, d3vLine, posInLine + s.length(), l, p);
             DiffTextWindow::mVScrollBar->setValue(l - DiffTextWindow::mVScrollBar->pageStep() / 2);
             m_pHScrollBar->setValue(std::max(0, p + s.length() - m_pHScrollBar->pageStep()));
             m_pFindDialog->currentLine = d3vLine;
             m_pFindDialog->currentPos = posInLine + 1;
             return;
         }
         m_pFindDialog->currentWindow = 3;
         m_pFindDialog->currentLine = 0;
         m_pFindDialog->currentPos = 0;
     }
 
     d3vLine = m_pFindDialog->currentLine;
     posInLine = m_pFindDialog->currentPos;
     if(m_pFindDialog->currentWindow == 3)
     {
         if(m_pFindDialog->m_pSearchInC->isChecked() && m_pDiffTextWindow3 != nullptr &&
            m_pDiffTextWindow3->findString(s, d3vLine, posInLine, bDirDown, bCaseSensitive))
         {
             m_pDiffTextWindow3->setSelection(d3vLine, posInLine, d3vLine, posInLine + s.length(), l, p);
             DiffTextWindow::mVScrollBar->setValue(l - DiffTextWindow::mVScrollBar->pageStep() / 2);
             m_pHScrollBar->setValue(std::max(0, p + s.length() - m_pHScrollBar->pageStep()));
             m_pFindDialog->currentLine = d3vLine;
             m_pFindDialog->currentPos = posInLine + 1;
             return;
         }
         m_pFindDialog->currentWindow = 4;
         m_pFindDialog->currentLine = 0;
         m_pFindDialog->currentPos = 0;
     }
 
     d3vLine = m_pFindDialog->currentLine;
     posInLine = m_pFindDialog->currentPos;
     if(m_pFindDialog->currentWindow == 4)
     {
         if(m_pFindDialog->m_pSearchInOutput->isChecked() && m_pMergeResultWindow != nullptr && m_pMergeResultWindow->isVisible() &&
            m_pMergeResultWindow->findString(s, d3vLine, posInLine, bDirDown, bCaseSensitive))
         {
             m_pMergeResultWindow->setSelection(d3vLine, posInLine, d3vLine, posInLine + s.length());
             MergeResultWindow::mVScrollBar->setValue(d3vLine - MergeResultWindow::mVScrollBar->pageStep() / 2);
             m_pHScrollBar->setValue(std::max(0, posInLine + s.length() - m_pHScrollBar->pageStep()));
             m_pFindDialog->currentLine = d3vLine;
             m_pFindDialog->currentPos = posInLine + 1;
             return;
         }
         m_pFindDialog->currentWindow = 5;
         m_pFindDialog->currentLine = 0;
         m_pFindDialog->currentPos = 0;
     }
 
     KMessageBox::information(this, i18n("Search complete."), i18n("Search Complete"));
     m_pFindDialog->currentWindow = 1;
     m_pFindDialog->currentLine = 0;
     m_pFindDialog->currentPos = 0;
 }
 
 void KDiff3App::slotMergeCurrentFile()
 {
     if(m_bDirCompare && m_pDirectoryMergeWindow->isVisible() && m_pDirectoryMergeWindow->isFileSelected())
     {
         m_pDirectoryMergeWindow->mergeCurrentFile();
     }
     else if(m_pMainWidget != nullptr && m_pMainWidget->isVisible())
     {
-        bool bShouldConintue = false;
-        Q_EMIT checkIfCanContinue(bShouldConintue);
-        if(!bShouldConintue) return;
+        if(!shouldContinue()) return;
 
         if(m_outputFilename.isEmpty())
         {
             if(!m_sd3->isEmpty() && !m_sd3->isFromBuffer())
             {
                 m_outputFilename = m_sd3->getFilename();
             }
             else if(!m_sd2->isEmpty() && !m_sd2->isFromBuffer())
             {
                 m_outputFilename = m_sd2->getFilename();
             }
             else if(!m_sd1->isEmpty() && !m_sd1->isFromBuffer())
             {
                 m_outputFilename = m_sd1->getFilename();
             }
             else
             {
                 m_outputFilename = "unnamed.txt";
                 m_bDefaultFilename = true;
             }
         }
         mainInit();
     }
 }
 
 void KDiff3App::slotWinFocusNext()
 {
     QWidget* focus = qApp->focusWidget();
     if(focus == m_pDirectoryMergeWindow && m_pDirectoryMergeWindow->isVisible() && !dirShowBoth->isChecked())
     {
         slotDirViewToggle();
     }
 
     std::list<QWidget*> visibleWidgetList;
     if(m_pDiffTextWindow1 && m_pDiffTextWindow1->isVisible()) visibleWidgetList.push_back(m_pDiffTextWindow1);
     if(m_pDiffTextWindow2 && m_pDiffTextWindow2->isVisible()) visibleWidgetList.push_back(m_pDiffTextWindow2);
     if(m_pDiffTextWindow3 && m_pDiffTextWindow3->isVisible()) visibleWidgetList.push_back(m_pDiffTextWindow3);
     if(m_pMergeResultWindow && m_pMergeResultWindow->isVisible()) visibleWidgetList.push_back(m_pMergeResultWindow);
     if(m_bDirCompare /*m_pDirectoryMergeWindow->isVisible()*/) visibleWidgetList.push_back(m_pDirectoryMergeWindow);
     //if ( m_pDirectoryMergeInfo->isVisible() ) visibleWidgetList.push_back(m_pDirectoryMergeInfo->getInfoList());
     if(visibleWidgetList.empty())
         return;
 
     std::list<QWidget*>::iterator i = std::find(visibleWidgetList.begin(), visibleWidgetList.end(), focus);
     ++i;
     if(i == visibleWidgetList.end())
         i = visibleWidgetList.begin();
 
     if(*i == m_pDirectoryMergeWindow && !dirShowBoth->isChecked())
     {
         slotDirViewToggle();
     }
     (*i)->setFocus();
 }
 
 void KDiff3App::slotWinFocusPrev()
 {
     QWidget* focus = qApp->focusWidget();
     if(focus == m_pDirectoryMergeWindow && m_pDirectoryMergeWindow->isVisible() && !dirShowBoth->isChecked())
     {
         slotDirViewToggle();
     }
 
     std::list<QWidget*> visibleWidgetList;
     if(m_pDiffTextWindow1 && m_pDiffTextWindow1->isVisible()) visibleWidgetList.push_back(m_pDiffTextWindow1);
     if(m_pDiffTextWindow2 && m_pDiffTextWindow2->isVisible()) visibleWidgetList.push_back(m_pDiffTextWindow2);
     if(m_pDiffTextWindow3 && m_pDiffTextWindow3->isVisible()) visibleWidgetList.push_back(m_pDiffTextWindow3);
     if(m_pMergeResultWindow && m_pMergeResultWindow->isVisible()) visibleWidgetList.push_back(m_pMergeResultWindow);
     if(m_bDirCompare /* m_pDirectoryMergeWindow->isVisible() */) visibleWidgetList.push_back(m_pDirectoryMergeWindow);
     //if ( m_pDirectoryMergeInfo->isVisible() ) visibleWidgetList.push_back(m_pDirectoryMergeInfo->getInfoList());
     if(visibleWidgetList.empty())
         return;
 
     std::list<QWidget*>::iterator i = std::find(visibleWidgetList.begin(), visibleWidgetList.end(), focus);
     if(i == visibleWidgetList.begin())
         i = visibleWidgetList.end();
     --i;
     //i will never be
     if(*i == m_pDirectoryMergeWindow && !dirShowBoth->isChecked())
     {
         slotDirViewToggle();
     }
     (*i)->setFocus();
 }
 
 void KDiff3App::slotWinToggleSplitterOrientation()
 {
     if(m_pDiffWindowSplitter != nullptr)
     {
         m_pDiffWindowSplitter->setOrientation(
             m_pDiffWindowSplitter->orientation() == Qt::Vertical ? Qt::Horizontal : Qt::Vertical);
 
         m_pOptions->m_bHorizDiffWindowSplitting = m_pDiffWindowSplitter->orientation() == Qt::Horizontal;
     }
 }
 
 void KDiff3App::slotOverviewNormal()
 {
     Q_EMIT changeOverViewMode(e_OverviewMode::eOMNormal);
 
     slotUpdateAvailabilities();
 }
 
 void KDiff3App::slotOverviewAB()
 {
     Q_EMIT changeOverViewMode(e_OverviewMode::eOMAvsB);
 
     slotUpdateAvailabilities();
 }
 
 void KDiff3App::slotOverviewAC()
 {
     Q_EMIT changeOverViewMode(e_OverviewMode::eOMAvsC);
 
     slotUpdateAvailabilities();
 }
 
 void KDiff3App::slotOverviewBC()
 {
     Q_EMIT changeOverViewMode(e_OverviewMode::eOMBvsC);
 
     slotUpdateAvailabilities();
 }
 
 void KDiff3App::slotNoRelevantChangesDetected()
 {
     if(m_bTripleDiff && !m_outputFilename.isEmpty())
     {
         //KMessageBox::information( this, "No relevant changes detected", "KDiff3" );
         if(!m_pOptions->m_IrrelevantMergeCmd.isEmpty())
         {
             /*
                 QProcess doesn't check for single quotes and uses non-standard escaping syntax for double quotes.
                     The distinction between single and double quotes is purely a command shell issue. So
                     we split the command string ourselves.
             */
             QStringList args;
             QString program;
             Utils::getArguments(m_pOptions->m_IrrelevantMergeCmd, program, args);
             QProcess process;
             process.start(program, args);
             process.waitForFinished(-1);
         }
     }
 }
 
 void KDiff3App::slotAddManualDiffHelp()
 {
     LineRef firstLine;
     LineRef lastLine;
     e_SrcSelector winIdx = e_SrcSelector::Invalid;
     if(m_pDiffTextWindow1)
     {
         m_pDiffTextWindow1->getSelectionRange(&firstLine, &lastLine, eFileCoords);
         winIdx = e_SrcSelector::A;
     }
     if(!firstLine.isValid() && m_pDiffTextWindow2)
     {
         m_pDiffTextWindow2->getSelectionRange(&firstLine, &lastLine, eFileCoords);
         winIdx = e_SrcSelector::B;
     }
     if(!firstLine.isValid() && m_pDiffTextWindow3)
     {
         m_pDiffTextWindow3->getSelectionRange(&firstLine, &lastLine, eFileCoords);
         winIdx = e_SrcSelector::C;
     }
 
     if(!firstLine.isValid() || !lastLine.isValid() || lastLine < firstLine)
         KMessageBox::information(this, i18n("Nothing is selected in either diff input window."), i18n("Error while adding manual diff range"));
     else
     {
         m_manualDiffHelpList.insertEntry(winIdx, firstLine, lastLine);
 
         mainInit(nullptr, false); // Init without reload
         slotRefresh();
     }
 }
 
 void KDiff3App::slotClearManualDiffHelpList()
 {
     m_manualDiffHelpList.clear();
     mainInit(nullptr, false); // Init without reload
     slotRefresh();
 }
 
 void KDiff3App::slotEncodingChanged(QTextCodec* c)
 {
     Q_UNUSED(c);
     mainInit(nullptr, true, true); // Init with reload
     slotRefresh();
 }
 
 void KDiff3App::slotUpdateAvailabilities()
 {
     if(m_pMainSplitter == nullptr || m_pDiffTextWindow2 == nullptr || m_pDiffTextWindow1 == nullptr || m_pDiffTextWindow3 == nullptr)
         return;
 
     bool bTextDataAvailable = (m_sd1->hasData() || m_sd2->hasData() || m_sd3->hasData());
 
     if(dirShowBoth->isChecked())
     {
         if(m_pDirectoryMergeSplitter != nullptr)
             m_pDirectoryMergeSplitter->setVisible(m_bDirCompare);
 
         if(m_pMainWidget != nullptr && !m_pMainWidget->isVisible() &&
            bTextDataAvailable && !m_pDirectoryMergeWindow->isScanning())
             m_pMainWidget->show();
     }
 
     bool bDiffWindowVisible = m_pMainWidget != nullptr && m_pMainWidget->isVisible();
     bool bMergeEditorVisible = m_pMergeWindowFrame != nullptr && m_pMergeWindowFrame->isVisible() && m_pMergeResultWindow != nullptr;
 
     m_pDirectoryMergeWindow->updateAvailabilities(m_bDirCompare, bDiffWindowVisible, chooseA, chooseB, chooseC);
 
     dirShowBoth->setEnabled(m_bDirCompare);
     dirViewToggle->setEnabled(
         m_bDirCompare &&
         ((m_pDirectoryMergeSplitter != nullptr && m_pMainWidget != nullptr) &&
          ((!m_pDirectoryMergeSplitter->isVisible() && m_pMainWidget->isVisible()) ||
           (m_pDirectoryMergeSplitter->isVisible() && !m_pMainWidget->isVisible() && bTextDataAvailable))));
 
     bool bDirWindowHasFocus = m_pDirectoryMergeSplitter != nullptr && m_pDirectoryMergeSplitter->isVisible() && m_pDirectoryMergeWindow->hasFocus();
 
     showWhiteSpaceCharacters->setEnabled(bDiffWindowVisible);
     autoAdvance->setEnabled(bMergeEditorVisible);
     mAutoSolve->setEnabled(bMergeEditorVisible && m_bTripleDiff);
     mUnsolve->setEnabled(bMergeEditorVisible);
     if(!bDirWindowHasFocus)
     {
         chooseA->setEnabled(bMergeEditorVisible);
         chooseB->setEnabled(bMergeEditorVisible);
         chooseC->setEnabled(bMergeEditorVisible && m_bTripleDiff);
     }
 
     if(m_pMergeResultWindow != nullptr)
     {
         m_pMergeResultWindow->slotUpdateAvailabilities(this);
     }
 
     mMergeHistory->setEnabled(bMergeEditorVisible);
     mergeRegExp->setEnabled(bMergeEditorVisible);
     showWindowA->setEnabled(bDiffWindowVisible && (m_pDiffTextWindow2->isVisible() || m_pDiffTextWindow3->isVisible()));
     showWindowB->setEnabled(bDiffWindowVisible && (m_pDiffTextWindow1->isVisible() || m_pDiffTextWindow3->isVisible()));
     showWindowC->setEnabled(bDiffWindowVisible && m_bTripleDiff && (m_pDiffTextWindow1->isVisible() || m_pDiffTextWindow2->isVisible()));
     editFind->setEnabled(bDiffWindowVisible);
     editFindNext->setEnabled(bDiffWindowVisible);
     m_pFindDialog->m_pSearchInC->setEnabled(m_bTripleDiff);
     m_pFindDialog->m_pSearchInOutput->setEnabled(bMergeEditorVisible);
 
     bool bSavable = bMergeEditorVisible && m_pMergeResultWindow->getNrOfUnsolvedConflicts() == 0;
     fileSave->setEnabled(m_bOutputModified && bSavable);
     fileSaveAs->setEnabled(bSavable);
 
     mGoTop->setEnabled(bDiffWindowVisible && m_pMergeResultWindow != nullptr && m_pMergeResultWindow->isDeltaAboveCurrent());
     mGoBottom->setEnabled(bDiffWindowVisible && m_pMergeResultWindow != nullptr && m_pMergeResultWindow->isDeltaBelowCurrent());
     mGoCurrent->setEnabled(bDiffWindowVisible);
     mGoPrevUnsolvedConflict->setEnabled(bMergeEditorVisible && m_pMergeResultWindow->isUnsolvedConflictAboveCurrent());
     mGoNextUnsolvedConflict->setEnabled(bMergeEditorVisible && m_pMergeResultWindow->isUnsolvedConflictBelowCurrent());
     mGoPrevConflict->setEnabled(bDiffWindowVisible && bMergeEditorVisible && m_pMergeResultWindow->isConflictAboveCurrent());
     mGoNextConflict->setEnabled(bDiffWindowVisible && bMergeEditorVisible && m_pMergeResultWindow->isConflictBelowCurrent());
     mGoPrevDelta->setEnabled(bDiffWindowVisible && m_pMergeResultWindow != nullptr && m_pMergeResultWindow->isDeltaAboveCurrent());
     mGoNextDelta->setEnabled(bDiffWindowVisible && m_pMergeResultWindow != nullptr && m_pMergeResultWindow->isDeltaBelowCurrent());
 
     overviewModeNormal->setEnabled(m_bTripleDiff && bDiffWindowVisible);
     overviewModeAB->setEnabled(m_bTripleDiff && bDiffWindowVisible);
     overviewModeAC->setEnabled(m_bTripleDiff && bDiffWindowVisible);
     overviewModeBC->setEnabled(m_bTripleDiff && bDiffWindowVisible);
     e_OverviewMode overviewMode = m_pOverview == nullptr ? e_OverviewMode::eOMNormal : m_pOverview->getOverviewMode();
     overviewModeNormal->setChecked(overviewMode == e_OverviewMode::eOMNormal);
     overviewModeAB->setChecked(overviewMode == e_OverviewMode::eOMAvsB);
     overviewModeAC->setChecked(overviewMode == e_OverviewMode::eOMAvsC);
     overviewModeBC->setChecked(overviewMode == e_OverviewMode::eOMBvsC);
 
     winToggleSplitOrientation->setEnabled(bDiffWindowVisible && m_pDiffWindowSplitter != nullptr);
 }