diff --git a/kdiff3fileitemactionplugin/kdiff3fileitemaction.h b/kdiff3fileitemactionplugin/kdiff3fileitemaction.h
index a6629ff..6af4033 100644
--- a/kdiff3fileitemactionplugin/kdiff3fileitemaction.h
+++ b/kdiff3fileitemactionplugin/kdiff3fileitemaction.h
@@ -1,55 +1,52 @@
 /* This file is part of the KDiff3 project
 
    Copyright (C) 2008 Joachim Eibl <Joachim dot Eibl at gmx dot de>
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public
    License as published by the Free Software Foundation; version 2
    of the License.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #ifndef KDIFF3FILEITEMACTIONPLUGIN_H
 #define KDIFF3FILEITEMACTIONPLUGIN_H
 
 #include <KAbstractFileItemActionPlugin>
 #include <KFileItemListProperties>
-#include <QStringList>
-
-class QStringList;
 
 class KDiff3FileItemAction : public KAbstractFileItemActionPlugin
 {
    Q_OBJECT
 public:
   KDiff3FileItemAction (QObject* pParent, const QVariantList & args);
   ~KDiff3FileItemAction() override;
   // implement pure virtual method from KonqPopupMenuPlugin
   QList<QAction*> actions( const KFileItemListProperties& fileItemInfos, QWidget* pParentWidget ) override;
 
 private Q_SLOTS:
    void slotCompareWith();
    void slotCompareTwoFiles();
    void slotCompareThreeFiles();
    void slotMergeWith();
    void slotMergeThreeWay();
    void slotSaveForLater();
    void slotClearList();
    void slotCompareWithHistoryItem();
    void slotAbout();
 
 private:
    QList<QUrl> m_list;
    QWidget* m_pParentWidget = nullptr;
    //KFileItemListProperties m_fileItemInfos;
 };
 #endif
diff --git a/src/MergeEditLine.h b/src/MergeEditLine.h
index 7bd1e1d..5e46f69 100644
--- a/src/MergeEditLine.h
+++ b/src/MergeEditLine.h
@@ -1,139 +1,138 @@
 
 /***************************************************************************
  *   Copyright (C) 2002-2007 by Joachim Eibl <joachim.eibl at gmx.de>      *
  *   Copyright (C) 2018 Michael Reeves reeves.87@gmail.com                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #ifndef MERGEEDITLINE_H
 #include "diff.h"
 
 #include <QString>
-
-class MergeResultWindow;
+#include <QVector>
 
 class MergeEditLine
 {
   public:
     explicit MergeEditLine(const Diff3LineList::const_iterator& i, e_SrcSelector src = None)
     {
         m_id3l = i;
         m_src = src;
         m_bLineRemoved = false;
     }
     void setConflict()
     {
         m_src = None;
         m_bLineRemoved = false;
         m_str = QString();
     }
     bool isConflict() { return m_src == None && !m_bLineRemoved && m_str.isEmpty(); }
     void setRemoved(e_SrcSelector src = None)
     {
         m_src = src;
         m_bLineRemoved = true;
         m_str = QString();
     }
     bool isRemoved() { return m_bLineRemoved; }
     bool isEditableText() { return !isConflict() && !isRemoved(); }
     void setString(const QString& s)
     {
         m_str = s;
         m_bLineRemoved = false;
         m_src = None;
     }
     QString getString(const QVector<LineData>* pLineDataA, const QVector<LineData>* pLineDataB, const QVector<LineData>* pLineDataC);
     bool isModified() { return !m_str.isEmpty() || (m_bLineRemoved && m_src == None); }
 
     void setSource(e_SrcSelector src, bool bLineRemoved)
     {
         m_src = src;
         m_bLineRemoved = bLineRemoved;
     }
     e_SrcSelector src() { return m_src; }
     Diff3LineList::const_iterator id3l() { return m_id3l; }
   private:
     Diff3LineList::const_iterator m_id3l;
     e_SrcSelector m_src; // 1, 2 or 3 for A, B or C respectively, or 0 when line is from neither source.
     QString m_str;       // String when modified by user or null-string when orig data is used.
     bool m_bLineRemoved;
 };
 
 class MergeEditLineList :public std::list<MergeEditLine>
 { // I want to know the size immediately!
   private:
     typedef std::list<MergeEditLine> BASE;
 
   public:
     typedef std::list<MergeEditLine>::iterator iterator;
     typedef std::list<MergeEditLine>::reverse_iterator reverse_iterator;
     typedef std::list<MergeEditLine>::const_iterator const_iterator;
 
 
     int size()
     {
         return (int)BASE::size();
     }
 };
 
 class MergeLine
 {
   public:
     Diff3LineList::const_iterator id3l;
     LineIndex d3lLineIdx = -1;    // Needed to show the correct window pos.
     LineCount srcRangeLength = 0; // how many src-lines have this properties
     e_MergeDetails mergeDetails = eDefault;
     bool bConflict = false;
     bool bWhiteSpaceConflict = false;
     bool bDelta = false;
     e_SrcSelector srcSelect = None;
     MergeEditLineList mergeEditLineList;
     void split(MergeLine& ml2, int d3lLineIdx2) // The caller must insert the ml2 after this ml in the m_mergeLineList
     {
         if(d3lLineIdx2 < d3lLineIdx || d3lLineIdx2 >= d3lLineIdx + srcRangeLength)
             return; //Error
         ml2.mergeDetails = mergeDetails;
         ml2.bConflict = bConflict;
         ml2.bWhiteSpaceConflict = bWhiteSpaceConflict;
         ml2.bDelta = bDelta;
         ml2.srcSelect = srcSelect;
 
         ml2.d3lLineIdx = d3lLineIdx2;
         ml2.srcRangeLength = srcRangeLength - (d3lLineIdx2 - d3lLineIdx);
         srcRangeLength = d3lLineIdx2 - d3lLineIdx; // current MergeLine controls fewer lines
         ml2.id3l = id3l;
         for(int i = 0; i < srcRangeLength; ++i)
             ++ml2.id3l;
 
         ml2.mergeEditLineList.clear();
         // Search for best place to splice
         for(MergeEditLineList::iterator i = mergeEditLineList.begin(); i != mergeEditLineList.end(); ++i)
         {
             if(i->id3l() == ml2.id3l)
             {
                 ml2.mergeEditLineList.splice(ml2.mergeEditLineList.begin(), mergeEditLineList, i, mergeEditLineList.end());
                 return;
             }
         }
         ml2.mergeEditLineList.push_back(MergeEditLine(ml2.id3l));
     }
     void join(MergeLine& ml2) // The caller must remove the ml2 from the m_mergeLineList after this call
     {
         srcRangeLength += ml2.srcRangeLength;
         ml2.mergeEditLineList.clear();
         mergeEditLineList.clear();
         mergeEditLineList.push_back(MergeEditLine(id3l)); // Create a simple conflict
         if(ml2.bConflict) bConflict = true;
         if(!ml2.bWhiteSpaceConflict) bWhiteSpaceConflict = false;
         if(ml2.bDelta) bDelta = true;
     }
 };
 
 typedef std::list<MergeLine> MergeLineList;
 
 #endif
diff --git a/src/Overview.cpp b/src/Overview.cpp
index 2574272..ff8066c 100644
--- a/src/Overview.cpp
+++ b/src/Overview.cpp
@@ -1,317 +1,318 @@
 /***************************************************************************
  *   Copyright (C) 2003-2007 by Joachim Eibl <joachim.eibl at gmx.de>      *
  *   Copyright (C) 2018 Michael Reeves reeves.87@gmail.com                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 #include "Overview.h"
 
 #include "diff.h"
-#include "mergeresultwindow.h"
 #include "options.h"
 
+#include <algorithm>    // for max
+
 #include <QColor>
 #include <QMouseEvent>
 #include <QPainter>
 #include <QPixmap>
 #include <QSize>
 
 Overview::Overview(const QSharedPointer<Options> &pOptions)
 //: QWidget( pParent, 0, Qt::WNoAutoErase )
 {
     m_pDiff3LineList = nullptr;
     m_pOptions = pOptions;
     m_bTripleDiff = false;
     m_eOverviewMode = eOMNormal;
     m_nofLines = 1;
     setUpdatesEnabled(false);
     m_firstLine = 0;
     m_pageHeight = 0;
 
     setFixedWidth(20);
 }
 
 void Overview::init(Diff3LineList* pDiff3LineList, bool bTripleDiff)
 {
     m_pDiff3LineList = pDiff3LineList;
     m_bTripleDiff = bTripleDiff;
     m_pixmap = QPixmap(QSize(0, 0)); // make sure that a redraw happens
     update();
 }
 
 void Overview::reset()
 {
     m_pDiff3LineList = nullptr;
 }
 
 void Overview::slotRedraw()
 {
     m_pixmap = QPixmap(QSize(0, 0)); // make sure that a redraw happens
     update();
 }
 
 void Overview::setRange(QtNumberType firstLine, QtNumberType pageHeight)
 {
     m_firstLine = firstLine;
     m_pageHeight = pageHeight;
     update();
 }
 void Overview::setFirstLine(QtNumberType firstLine)
 {
     m_firstLine = firstLine;
     update();
 }
 
 void Overview::setOverviewMode(e_OverviewMode eOverviewMode)
 {
     m_eOverviewMode = eOverviewMode;
     slotRedraw();
 }
 
 Overview::e_OverviewMode Overview::getOverviewMode()
 {
     return m_eOverviewMode;
 }
 
 void Overview::mousePressEvent(QMouseEvent* e)
 {
     int h = height() - 1;
     int h1 = h * m_pageHeight / std::max(1, m_nofLines) + 3;
     if(h > 0)
         emit setLine((e->y() - h1 / 2) * m_nofLines / h);
 }
 
 void Overview::mouseMoveEvent(QMouseEvent* e)
 {
     mousePressEvent(e);
 }
 
 void Overview::setPaintingAllowed(bool bAllowPainting)
 {
     if(updatesEnabled() != bAllowPainting)
     {
 
         setUpdatesEnabled(bAllowPainting);
         if(bAllowPainting)
             update();
         else
             reset();
     }
 }
 
 void Overview::drawColumn(QPainter& p, e_OverviewMode eOverviewMode, int x, int w, int h, int nofLines)
 {
     p.setPen(Qt::black);
     p.drawLine(x, 0, x, h);
 
     if(nofLines == 0) return;
 
     int line = 0;
     int oldY = 0;
     int oldConflictY = -1;
     int wrapLineIdx = 0;
     Diff3LineList::const_iterator i;
     for(i = m_pDiff3LineList->begin(); i != m_pDiff3LineList->end();)
     {
         const Diff3Line& d3l = *i;
         int y = h * (line + 1) / nofLines;
         e_MergeDetails md;
         bool bConflict;
         bool bLineRemoved;
         e_SrcSelector src;
         d3l.mergeOneLine(md, bConflict, bLineRemoved, src, !m_bTripleDiff);
 
         QColor c = m_pOptions->m_bgColor;
         bool bWhiteSpaceChange = false;
         //if( bConflict )  c=m_pOptions->m_colorForConflict;
         //else
         if(eOverviewMode == eOMNormal)
         {
             switch(md)
             {
             case eDefault:
             case eNoChange:
                 c = m_pOptions->m_bgColor;
                 break;
 
             case eBAdded:
             case eBDeleted:
             case eBChanged:
                 c = bConflict ? m_pOptions->m_colorForConflict : m_pOptions->m_colorB;
                 bWhiteSpaceChange = d3l.isEqualAB() || (d3l.bWhiteLineA && d3l.bWhiteLineB);
                 break;
 
             case eCAdded:
             case eCDeleted:
             case eCChanged:
                 bWhiteSpaceChange = d3l.isEqualAC() || (d3l.bWhiteLineA && d3l.bWhiteLineC);
                 c = bConflict ? m_pOptions->m_colorForConflict : m_pOptions->m_colorC;
                 break;
 
             case eBCChanged:         // conflict
             case eBCChangedAndEqual: // possible conflict
             case eBCDeleted:         // possible conflict
             case eBChanged_CDeleted: // conflict
             case eCChanged_BDeleted: // conflict
             case eBCAdded:           // conflict
             case eBCAddedAndEqual:   // possible conflict
                 c = m_pOptions->m_colorForConflict;
                 break;
             default:
                 Q_ASSERT(true);
                 break;
             }
         }
         else if(eOverviewMode == eOMAvsB)
         {
             switch(md)
             {
             case eDefault:
             case eNoChange:
             case eCAdded:
             case eCDeleted:
             case eCChanged:
                 break;
             default:
                 c = m_pOptions->m_colorForConflict;
                 bWhiteSpaceChange = d3l.isEqualAB() || (d3l.bWhiteLineA && d3l.bWhiteLineB);
                 break;
             }
         }
         else if(eOverviewMode == eOMAvsC)
         {
             switch(md)
             {
             case eDefault:
             case eNoChange:
             case eBAdded:
             case eBDeleted:
             case eBChanged:
                 break;
             default:
                 c = m_pOptions->m_colorForConflict;
                 bWhiteSpaceChange = d3l.isEqualAC() || (d3l.bWhiteLineA && d3l.bWhiteLineC);
                 break;
             }
         }
         else if(eOverviewMode == eOMBvsC)
         {
             switch(md)
             {
             case eDefault:
             case eNoChange:
             case eBCChangedAndEqual:
             case eBCDeleted:
             case eBCAddedAndEqual:
                 break;
             default:
                 c = m_pOptions->m_colorForConflict;
                 bWhiteSpaceChange = d3l.isEqualBC() || (d3l.bWhiteLineB && d3l.bWhiteLineC);
                 break;
             }
         }
 
         int x2 = x;
         int w2 = w;
 
         if(!m_bTripleDiff)
         {
             if(!d3l.getLineA().isValid() && d3l.getLineB().isValid())
             {
                 c = m_pOptions->m_colorA;
                 x2 = w / 2;
                 w2 = x2;
             }
             if(d3l.getLineA().isValid() && !d3l.getLineB().isValid())
             {
                 c = m_pOptions->m_colorB;
                 w2 = w / 2;
             }
         }
 
         if(!bWhiteSpaceChange || m_pOptions->m_bShowWhiteSpace)
         {
             // Make sure that lines with conflict are not overwritten.
             if(c == m_pOptions->m_colorForConflict)
             {
                 p.fillRect(x2 + 1, oldY, w2, std::max(1, y - oldY), bWhiteSpaceChange ? QBrush(c, Qt::Dense4Pattern) : QBrush(c));
                 oldConflictY = oldY;
             }
             else if(c != m_pOptions->m_bgColor && oldY > oldConflictY)
             {
                 p.fillRect(x2 + 1, oldY, w2, std::max(1, y - oldY), bWhiteSpaceChange ? QBrush(c, Qt::Dense4Pattern) : QBrush(c));
             }
         }
 
         oldY = y;
 
         ++line;
         if(m_pOptions->m_bWordWrap)
         {
             ++wrapLineIdx;
             if(wrapLineIdx >= d3l.linesNeededForDisplay)
             {
                 wrapLineIdx = 0;
                 ++i;
             }
         }
         else
         {
             ++i;
         }
     }
 }
 
 void Overview::paintEvent(QPaintEvent*)
 {
     if(m_pDiff3LineList == nullptr) return;
     int h = height() - 1;
     int w = width();
 
     if(m_pixmap.size() != size())
     {
         if(m_pOptions->m_bWordWrap)
         {
             m_nofLines = 0;
             Diff3LineList::const_iterator i;
             for(i = m_pDiff3LineList->begin(); i != m_pDiff3LineList->end(); ++i)
             {
                 m_nofLines += i->linesNeededForDisplay;
             }
         }
         else
         {
             m_nofLines = m_pDiff3LineList->size();
         }
 
         m_pixmap = QPixmap(size());
 
         QPainter p(&m_pixmap);
         p.fillRect(rect(), m_pOptions->m_bgColor);
 
         if(!m_bTripleDiff || m_eOverviewMode == eOMNormal)
         {
             drawColumn(p, eOMNormal, 0, w, h, m_nofLines);
         }
         else
         {
             drawColumn(p, eOMNormal, 0, w / 2, h, m_nofLines);
             drawColumn(p, m_eOverviewMode, w / 2, w / 2, h, m_nofLines);
         }
     }
 
     QPainter painter(this);
     painter.drawPixmap(0, 0, m_pixmap);
     int y1=0, h1=0;
     if(m_nofLines > 0)
     {
         y1 = h * m_firstLine / m_nofLines - 1;
         h1 = h * m_pageHeight / m_nofLines + 3;
     }
     painter.setPen(Qt::black);
     painter.drawRect(1, y1, w - 1, h1);
 }
diff --git a/src/Overview.h b/src/Overview.h
index 96df72d..bae508d 100644
--- a/src/Overview.h
+++ b/src/Overview.h
@@ -1,64 +1,68 @@
 /***************************************************************************
  *   Copyright (C) 2003-2007 by Joachim Eibl <joachim.eibl at gmx.de>      *
  *   Copyright (C) 2018 Michael Reeves reeves.87@gmail.com                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 #ifndef OVERVIEW_H
 #define OVERVIEW_H
 
-#include "diff.h"
-#include "options.h"
+#include "LineRef.h"       // for LineRef
+#include "TypeUtils.h"     // for QtNumberType
 
+#include <QString>         // for QString
 #include <QPixmap>
 #include <QWidget>
 
+class Diff3LineList;
+class Options;
+
 class Overview : public QWidget
 {
     Q_OBJECT
   public:
     enum e_OverviewMode
     {
         eOMNormal,
         eOMAvsB,
         eOMAvsC,
         eOMBvsC
     };
 
     explicit Overview(const QSharedPointer<Options> &pOptions);
 
     void init(Diff3LineList* pDiff3LineList, bool bTripleDiff);
     void reset();
     void setRange(QtNumberType firstLine, QtNumberType pageHeight);
     void setPaintingAllowed(bool bAllowPainting);
 
     void setOverviewMode(e_OverviewMode eOverviewMode);
     e_OverviewMode getOverviewMode();
 
   public Q_SLOTS:
     void setFirstLine(QtNumberType firstLine);
     void slotRedraw();
   Q_SIGNALS:
     void setLine(LineRef);
 
   private:
     const Diff3LineList* m_pDiff3LineList;
     QSharedPointer<Options> m_pOptions;
     bool m_bTripleDiff;
     LineRef m_firstLine;
     int m_pageHeight;
     QPixmap m_pixmap;
     e_OverviewMode m_eOverviewMode;
     int m_nofLines;
 
     void paintEvent(QPaintEvent* e) override;
     void mousePressEvent(QMouseEvent* e) override;
     void mouseMoveEvent(QMouseEvent* e) override;
     void drawColumn(QPainter& p, e_OverviewMode eOverviewMode, int x, int w, int h, int nofLines);
 };
 
 #endif // !OVERVIEW_H
diff --git a/src/Utils.cpp b/src/Utils.cpp
index 067fd63..00d0226 100644
--- a/src/Utils.cpp
+++ b/src/Utils.cpp
@@ -1,125 +1,126 @@
 /**
  * Copyright (C) 2003-2007 by Joachim Eibl <joachim.eibl at gmx.de>
  * Copyright (C) 2018 Michael Reeves reeves.87@gmail.com
- * 
+ *
  * This file is part of KDiff3.
- * 
+ *
  * KDiff3 is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
- * 
+ *
  * KDiff3 is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU General Public License
  * along with KDiff3.  If not, see <http://www.gnu.org/licenses/>.
- * 
+ *
  */
 #include "Utils.h"
 
+#include <KLocalizedString>
+
 #include <QString>
 #include <QStringList>
 #include <QHash>
 #include <QRegExp>
-#include <KLocalizedString>
 
 /* Split the command line into arguments.
  * Normally split at white space separators except when quoting with " or '.
  * Backslash is treated as meta character within single quotes ' only.
  * Detect parsing errors like unclosed quotes.
  * The first item in the list will be the command itself.
  * Returns the error reasor as string or an empty string on success.
  * Eg. >"1" "2"<           => >1<, >2<
  * Eg. >'\'\\'<            => >'\<   backslash is a meta character between single quotes
  * Eg. > "\\" <            => >\\<   but not between double quotes
  * Eg. >"c:\sed" 's/a/\' /g'<  => >c:\sed<, >s/a/' /g<
  */
 QString Utils::getArguments(QString cmd, QString& program, QStringList& args)
 {
     program = QString();
     args.clear();
     for(int i = 0; i < cmd.length(); ++i)
     {
         while(i < cmd.length() && cmd[i].isSpace())
         {
             ++i;
         }
         if(cmd[i] == '"' || cmd[i] == '\'') // argument beginning with a quote
         {
             QChar quoteChar = cmd[i];
             ++i;
             int argStart = i;
             bool bSkip = false;
             while(i < cmd.length() && (cmd[i] != quoteChar || bSkip))
             {
                 if(bSkip)
                 {
                     bSkip = false;
                     //Don't emulate bash here we are not talking to it.
                     //For us all quotes are the same.
                     if(cmd[i] == '\\' || cmd[i] == '\'' || cmd[i] == '"')
                     {
                         cmd.remove(i - 1, 1); // remove the backslash '\'
                         continue;
                     }
                 }
                 else if(cmd[i] == '\\')
                     bSkip = true;
                 ++i;
             }
             if(i < cmd.length())
             {
                 args << cmd.mid(argStart, i - argStart);
                 if(i + 1 < cmd.length() && !cmd[i + 1].isSpace())
                     return i18n("Expecting space after closing quote.");
             }
             else
                 return i18n("Unmatched quote.");
             continue;
         }
         else
         {
             int argStart = i;
             while(i < cmd.length() && (!cmd[i].isSpace() /*|| bSkip*/))
             {
                 if(cmd[i] == '"' || cmd[i] == '\'')
                     return i18n("Unexpected quote character within argument.");
                 ++i;
             }
             args << cmd.mid(argStart, i - argStart);
         }
     }
     if(args.isEmpty())
         return i18n("No program specified.");
     else
     {
         program = args[0];
         args.pop_front();
     }
     return QString();
 }
 
 bool Utils::wildcardMultiMatch(const QString& wildcard, const QString& testString, bool bCaseSensitive)
 {
     static QHash<QString, QRegExp> s_patternMap;
 
     QStringList sl = wildcard.split(QChar(';'));
 
     for(QStringList::Iterator it = sl.begin(); it != sl.end(); ++it)
     {
         QHash<QString, QRegExp>::iterator patIt = s_patternMap.find(*it);
         if(patIt == s_patternMap.end())
         {
             QRegExp pattern(*it, bCaseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive, QRegExp::Wildcard);
             patIt = s_patternMap.insert(*it, pattern);
         }
 
         if(patIt.value().exactMatch(testString))
             return true;
     }
 
     return false;
 }
diff --git a/src/Utils.h b/src/Utils.h
index bc684cb..a027245 100644
--- a/src/Utils.h
+++ b/src/Utils.h
@@ -1,56 +1,57 @@
 /**
  * Copyright (C) 2018 Michael Reeves reeves.87@gmail.com
  *
  * This file is part of KDiff3.
  *
  * KDiff3 is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * KDiff3 is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with KDiff3.  If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #ifndef UTILS_H
 #define UTILS_H
 
+#include <QChar>
 #include <QFontMetrics>
-#include <QStringList>
 #include <QString>
+#include <QStringList>
 
 class Utils{
     public:
       static bool wildcardMultiMatch(const QString& wildcard, const QString& testString, bool bCaseSensitive);
       static QString getArguments(QString cmd, QString& program, QStringList& args);
       inline static bool isEndOfLine( QChar c ) { return c=='\n' || c=='\r' || c=='\x0b'; }
 
       //Where posiable use QTextLayout in place of these functions especially when dealing with non-latin scripts.
       inline static int getHorizontalAdvance(const QFontMetrics &metrics, const QString& s, int len = -1)
       {
         //Warning: The Qt API used here is not accurate for some non-latin characters.
         #if QT_VERSION < QT_VERSION_CHECK(5,12,0)
           return metrics.width(s, len);
         #else
           return metrics.horizontalAdvance(s, len);
         #endif
       }
 
       inline static int getHorizontalAdvance(const QFontMetrics &metrics, const QChar& c)
       {
         //Warning: The Qt API used here is not accurate for some non-latin characters.
         #if QT_VERSION < QT_VERSION_CHECK(5,12,0)
           return metrics.width(c);
         #else
           return metrics.horizontalAdvance(c);
         #endif
       }
 };
 
 #endif
diff --git a/src/diff.cpp b/src/diff.cpp
index 04d584c..7221796 100644
--- a/src/diff.cpp
+++ b/src/diff.cpp
@@ -1,1469 +1,1468 @@
 /***************************************************************************
  *   Copyright (C) 2003-2007 by Joachim Eibl <joachim.eibl at gmx.de>      *
  *   Copyright (C) 2018 Michael Reeves reeves.87@gmail.com                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #include "diff.h"
 
-#include "Utils.h"
-#include "fileaccess.h"
 #include "gnudiff_diff.h"
 #include "options.h"
 #include "progress.h"
 
 #include <cstdlib>
 #include <ctype.h>
-#include <map>
 
 #include <KLocalizedString>
 #include <KMessageBox>
-#include <qglobal.h>
+
+#include <QtGlobal>
+#include <QSharedPointer>
 
 int LineData::width(int tabSize) const
 {
     QString pLine = getLine();
     int w = 0;
     int j = 0;
     for(int i = 0; i < size(); ++i)
     {
         if(pLine[i] == '\t')
         {
             for(j %= tabSize; j < tabSize; ++j)
                 ++w;
             j = 0;
         }
         else
         {
             ++w;
             ++j;
         }
     }
     return w;
 }
 
 // The bStrict flag is true during the test where a nonmatching area ends.
 // Then the equal()-function requires that the match has more than 2 nonwhite characters.
 // This is to avoid matches on trivial lines (e.g. with white space only).
 // This choice is good for C/C++.
 bool LineData::equal(const LineData& l1, const LineData& l2, bool bStrict)
 {
     if(l1.getLine() == nullptr || l2.getLine() == nullptr) return false;
 
     if(bStrict && g_bIgnoreTrivialMatches)
         return false;
 
     // Ignore white space diff
     QString::const_iterator p1 = l1.getLine().begin();
     QString::const_iterator p1End = l1.getLine().end();
 
     QString::const_iterator p2 = l2.getLine().begin();
     QString::const_iterator p2End = l2.getLine().end();
 
     if(g_bIgnoreWhiteSpace)
     {
         int nonWhite = 0;
         for(;;)
         {
             while(isWhite(*p1) && p1 != p1End) ++p1;
             while(isWhite(*p2) && p2 != p2End) ++p2;
 
             if(p1 == p1End && p2 == p2End)
             {
                 if(bStrict && g_bIgnoreTrivialMatches)
                 { // Then equality is not enough
                     return nonWhite > 2;
                 }
                 else // equality is enough
                     return true;
             }
             else if(p1 == p1End || p2 == p2End)
                 return false;
 
             if(*p1 != *p2)
                 return false;
             ++p1;
             ++p2;
             ++nonWhite;
         }
     }
     else
     {
         return (l1.size() == l2.size() && QString::compare(l1.getLine(), l2.getLine()) == 0);
     }
 }
 
 // First step
 void calcDiff3LineListUsingAB(
     const DiffList* pDiffListAB,
     Diff3LineList& d3ll)
 {
     // First make d3ll for AB (from pDiffListAB)
 
     DiffList::const_iterator i = pDiffListAB->begin();
     LineRef::LineType lineA = 0;
     LineRef::LineType lineB = 0;
     Diff d(0, 0, 0);
 
     qCInfo(kdiffMain) << "Enter: calcDiff3LineListUsingAB" ;
     for(;;)
     {
         if(d.numberOfEquals() == 0 && d.diff1() == 0 && d.diff2() == 0)
         {
             if(i != pDiffListAB->end())
             {
                 d = *i;
                 ++i;
             }
             else
                 break;
         }
 
         Diff3Line d3l;
         if(d.numberOfEquals() > 0)
         {
             d3l.bAEqB = true;
             d3l.setLineA(lineA);
             d3l.setLineB(lineB);
             d.adjustNumberOfEquals(-1);
             ++lineA;
             ++lineB;
         }
         else if(d.diff1() > 0 && d.diff2() > 0)
         {
             d3l.setLineA(lineA);
             d3l.setLineB(lineB);
             d.adjustDiff1(-1);
             d.adjustDiff2(-1);
             ++lineA;
             ++lineB;
         }
         else if(d.diff1() > 0)
         {
             d3l.setLineA(lineA);
             d.adjustDiff1(-1);
             ++lineA;
         }
         else if(d.diff2() > 0)
         {
             d3l.setLineB(lineB);
             d.adjustDiff2(-1);
             ++lineB;
         }
 
         Q_ASSERT(d.numberOfEquals() >= 0);
 
         qCDebug(kdiffCore) << "lineA = " << d3l.getLineA() << ", lineB = " << d3l.getLineB() ;
         d3ll.push_back(d3l);
     }
     qCInfo(kdiffMain) << "Leave: calcDiff3LineListUsingAB" ;
 }
 
 // Second step
 void calcDiff3LineListUsingAC(
     const DiffList* pDiffListAC,
     Diff3LineList& d3ll)
 {
     ////////////////
     // Now insert data from C using pDiffListAC
 
     DiffList::const_iterator i = pDiffListAC->begin();
     Diff3LineList::iterator i3 = d3ll.begin();
     LineRef::LineType lineA = 0;
     LineRef::LineType lineC = 0;
     Diff d(0, 0, 0);
 
     for(;;)
     {
         if(d.numberOfEquals() == 0 && d.diff1() == 0 && d.diff2() == 0)
         {
             if(i != pDiffListAC->end())
             {
                 d = *i;
                 ++i;
             }
             else
                 break;
         }
 
         Diff3Line d3l;
         if(d.numberOfEquals() > 0)
         {
             // Find the corresponding lineA
             while(i3->getLineA() != lineA)
                 ++i3;
 
             i3->setLineC(lineC);
             i3->bAEqC = true;
             i3->bBEqC = i3->isEqualAB();
 
             d.adjustNumberOfEquals(-1);
             ++lineA;
             ++lineC;
             ++i3;
         }
         else if(d.diff1() > 0 && d.diff2() > 0)
         {
             d3l.setLineC(lineC);
             d3ll.insert(i3, d3l);
             d.adjustDiff1(-1);
             d.adjustDiff2(-1);
             ++lineA;
             ++lineC;
         }
         else if(d.diff1() > 0)
         {
             d.adjustDiff1(-1);
             ++lineA;
         }
         else if(d.diff2() > 0)
         {
             d3l.setLineC(lineC);
             d3ll.insert(i3, d3l);
             d.adjustDiff2(-1);
             ++lineC;
         }
     }
 }
 
 // Third step
 void calcDiff3LineListUsingBC(
     const DiffList* pDiffListBC,
     Diff3LineList& d3ll)
 {
     ////////////////
     // Now improve the position of data from C using pDiffListBC
     // If a line from C equals a line from A then it is in the
     // same Diff3Line already.
     // If a line from C equals a line from B but not A, this
     // information will be used here.
 
     DiffList::const_iterator i = pDiffListBC->begin();
     Diff3LineList::iterator i3b = d3ll.begin();
     Diff3LineList::iterator i3c = d3ll.begin();
     LineRef::LineType lineB = 0;
     LineRef::LineType lineC = 0;
     Diff d(0, 0, 0);
 
     for(;;)
     {
         if(d.numberOfEquals() == 0 && d.diff1() == 0 && d.diff2() == 0)
         {
             if(i != pDiffListBC->end())
             {
                 d = *i;
                 ++i;
             }
             else
                 break;
         }
 
         Diff3Line d3l;
         if(d.numberOfEquals() > 0)
         {
             // Find the corresponding lineB and lineC
             while(i3b != d3ll.end() && i3b->getLineB() != lineB)
                 ++i3b;
 
             while(i3c != d3ll.end() && i3c->getLineC() != lineC)
                 ++i3c;
 
             Q_ASSERT(i3b != d3ll.end());
             Q_ASSERT(i3c != d3ll.end());
 
             if(i3b == i3c)
             {
                 Q_ASSERT(i3b->getLineC() == lineC);
                 i3b->bBEqC = true;
             }
             else
             {
                 // Is it possible to move this line up?
                 // Test if no other B's are used between i3c and i3b
 
                 // First test which is before: i3c or i3b ?
                 Diff3LineList::iterator i3c1 = i3c;
                 Diff3LineList::iterator i3b1 = i3b;
                 while(i3c1 != i3b && i3b1 != i3c)
                 {
                     Q_ASSERT(i3b1 != d3ll.end() || i3c1 != d3ll.end());
                     if(i3c1 != d3ll.end()) ++i3c1;
                     if(i3b1 != d3ll.end()) ++i3b1;
                 }
 
                 if(i3c1 == i3b && !i3b->isEqualAB()) // i3c before i3b
                 {
                     Diff3LineList::iterator i3 = i3c;
                     int nofDisturbingLines = 0;
                     while(i3 != i3b && i3 != d3ll.end())
                     {
                         if(i3->getLineB().isValid())
                             ++nofDisturbingLines;
                         ++i3;
                     }
 
                     if(nofDisturbingLines > 0) //&& nofDisturbingLines < d.nofEquals*d.nofEquals+4 )
                     {
                         Diff3LineList::iterator i3_last_equal_A = d3ll.end();
 
                         i3 = i3c;
                         while(i3 != i3b)
                         {
                             if(i3->isEqualAB())
                             {
                                 i3_last_equal_A = i3;
                             }
                             ++i3;
                         }
 
                         /* If i3_last_equal_A isn't still set to d3ll.end(), then
                    * we've found a line in A that is equal to one in B
                    * somewhere between i3c and i3b
                    */
                         bool before_or_on_equal_line_in_A = (i3_last_equal_A != d3ll.end());
 
                         // Move the disturbing lines up, out of sight.
                         i3 = i3c;
                         while(i3 != i3b)
                         {
                             if(i3->getLineB().isValid() ||
                                (before_or_on_equal_line_in_A && i3->getLineA().isValid()))
                             {
                                 d3l.setLineB(i3->getLineB());
                                 i3->getLineB().invalidate();
 
                                 // Move A along if it matched B
                                 if(before_or_on_equal_line_in_A)
                                 {
                                     d3l.setLineA(i3->getLineA());
                                     d3l.bAEqB = i3->isEqualAB();
                                     i3->getLineA().invalidate();
                                     i3->bAEqC = false;
                                 }
 
                                 i3->bAEqB = false;
                                 i3->bBEqC = false;
                                 d3ll.insert(i3c, d3l);
                             }
 
                             if(i3 == i3_last_equal_A)
                             {
                                 before_or_on_equal_line_in_A = false;
                             }
 
                             ++i3;
                         }
                         nofDisturbingLines = 0;
                     }
 
                     if(nofDisturbingLines == 0)
                     {
                         // Yes, the line from B can be moved.
                         i3b->getLineB().invalidate(); // This might leave an empty line: removed later.
                         i3b->bAEqB = false;
                         i3b->bBEqC = false;
                         i3c->setLineB(lineB);
                         i3c->bBEqC = true;
                         i3c->bAEqB = i3c->isEqualAC();
                     }
                 }
                 else if(i3b1 == i3c && !i3c->isEqualAC())
                 {
                     Diff3LineList::iterator i3 = i3b;
                     int nofDisturbingLines = 0;
                     while(i3 != i3c && i3 != d3ll.end())
                     {
                         if(i3->getLineC().isValid())
                             ++nofDisturbingLines;
                         ++i3;
                     }
 
                     if(nofDisturbingLines > 0) //&& nofDisturbingLines < d.nofEquals*d.nofEquals+4 )
                     {
                         Diff3LineList::iterator i3_last_equal_A = d3ll.end();
 
                         i3 = i3b;
                         while(i3 != i3c)
                         {
                             if(i3->isEqualAC())
                             {
                                 i3_last_equal_A = i3;
                             }
                             ++i3;
                         }
 
                         /* If i3_last_equal_A isn't still set to d3ll.end(), then
                    * we've found a line in A that is equal to one in C
                    * somewhere between i3b and i3c
                    */
                         bool before_or_on_equal_line_in_A = (i3_last_equal_A != d3ll.end());
 
                         // Move the disturbing lines up.
                         i3 = i3b;
                         while(i3 != i3c)
                         {
                             if(i3->getLineC().isValid() ||
                                (before_or_on_equal_line_in_A && i3->getLineA().isValid()))
                             {
                                 d3l.setLineC(i3->getLineC());
                                 i3->getLineC().invalidate();
 
                                 // Move A along if it matched C
                                 if(before_or_on_equal_line_in_A)
                                 {
                                     d3l.setLineA(i3->getLineA());
                                     d3l.bAEqC = i3->isEqualAC();
                                     i3->getLineA().invalidate();
                                     i3->bAEqB = false;
                                 }
 
                                 i3->bAEqC = false;
                                 i3->bBEqC = false;
                                 d3ll.insert(i3b, d3l);
                             }
 
                             if(i3 == i3_last_equal_A)
                             {
                                 before_or_on_equal_line_in_A = false;
                             }
 
                             ++i3;
                         }
                         nofDisturbingLines = 0;
                     }
 
                     if(nofDisturbingLines == 0)
                     {
                         // Yes, the line from C can be moved.
                         i3c->getLineC().invalidate(); // This might leave an empty line: removed later.
                         i3c->bAEqC = false;
                         i3c->bBEqC = false;
                         i3b->setLineC(lineC);
                         i3b->bBEqC = true;
                         i3b->bAEqC = i3b->isEqualAB();
                     }
                 }
             }
 
             d.adjustNumberOfEquals(-1);
             ++lineB;
             ++lineC;
             ++i3b;
             ++i3c;
         }
         else if(d.diff1() > 0)
         {
             Diff3LineList::iterator i3 = i3b;
             while(i3->getLineB() != lineB)
                 ++i3;
             if(i3 != i3b && !i3->isEqualAB())
             {
                 // Take B from this line and move it up as far as possible
                 d3l.setLineB(lineB);
                 d3ll.insert(i3b, d3l);
                 i3->getLineB().invalidate();
             }
             else
             {
                 i3b = i3;
             }
             d.adjustDiff1(-1);
             ++lineB;
             ++i3b;
 
             if(d.diff2() > 0)
             {
                 d.adjustDiff2(-1);
                 ++lineC;
             }
         }
         else if(d.diff2() > 0)
         {
             d.adjustDiff2(-1);
             ++lineC;
         }
     }
     /*
    Diff3LineList::iterator it = d3ll.begin();
    int li=0;
    for( ; it!=d3ll.end(); ++it, ++li )
    {
       printf( "%4d %4d %4d %4d  A%c=B A%c=C B%c=C\n",
          li, it->getLineA(), it->getLineB(), it->getLineC(),
          it->isEqualAB() ? '=' : '!', it->isEqualAC() ? '=' : '!', it->isEqualBC() ? '=' : '!' );
    }
    printf("\n");*/
 }
 
 // Test if the move would pass a barrier. Return true if not.
 bool ManualDiffHelpList::isValidMove(int line1, int line2, e_SrcSelector winIdx1, e_SrcSelector winIdx2) const
 {
     if(line1 >= 0 && line2 >= 0)
     {
         ManualDiffHelpList::const_iterator i;
         for(i = begin(); i != end(); ++i)
         {
             const ManualDiffHelpEntry& mdhe = *i;
 
             if(!mdhe.isValidMove(line1, line2, winIdx1, winIdx2)) return false;
         }
     }
     return true; // no barrier passed.
 }
 
 bool ManualDiffHelpEntry::isValidMove(int line1, int line2, e_SrcSelector winIdx1, e_SrcSelector winIdx2) const
 {
     // Barrier
     int l1 = winIdx1 == A ? lineA1 : winIdx1 == B ? lineB1 : lineC1;
     int l2 = winIdx2 == A ? lineA1 : winIdx2 == B ? lineB1 : lineC1;
 
     if(l1 >= 0 && l2 >= 0)
     {
         if((line1 >= l1 && line2 < l2) || (line1 < l1 && line2 >= l2))
             return false;
         l1 = winIdx1 == A ? lineA2 : winIdx1 == B ? lineB2 : lineC2;
         l2 = winIdx2 == A ? lineA2 : winIdx2 == B ? lineB2 : lineC2;
         ++l1;
         ++l2;
         if((line1 >= l1 && line2 < l2) || (line1 < l1 && line2 >= l2))
             return false;
     }
 
     return true;
 }
 
 static bool runDiff(const QVector<LineData>* p1, const qint32 index1, LineRef size1, const QVector<LineData>* p2, const qint32 index2, LineRef size2, DiffList& diffList,
                     const QSharedPointer<Options> &pOptions)
 {
     ProgressProxy pp;
     static GnuDiff gnuDiff; // All values are initialized with zeros.
 
     pp.setCurrent(0);
 
     diffList.clear();
     if(p1 == nullptr || (*p1)[index1].getLine() == nullptr || p2 == nullptr || (*p2)[index2].getLine() == nullptr || size1 == 0 || size2 == 0)
     {
         if(p1 != nullptr && p2 != nullptr && (*p1)[index1].getLine() == nullptr && (*p2)[index2].getLine() == nullptr && size1 == size2)
             diffList.push_back(Diff(size1, 0, 0));
         else
         {
             diffList.push_back(Diff(0, size1, size2));
         }
     }
     else
     {
         GnuDiff::comparison comparisonInput;
         memset(&comparisonInput, 0, sizeof(comparisonInput));
         comparisonInput.parent = nullptr;
         comparisonInput.file[0].buffer = (*p1)[index1].getBuffer()->unicode() + (*p1)[index1].getOffset();                                                      //ptr to buffer
         comparisonInput.file[0].buffered = ((*p1)[size1].getOffset() - 1); // size of buffer
         comparisonInput.file[1].buffer = (*p2)[index2].getBuffer()->unicode() + (*p2)[index2].getOffset();                                                      //ptr to buffer
         comparisonInput.file[1].buffered = ((*p2)[size2].getOffset() - 1); // size of buffer
 
         gnuDiff.ignore_white_space = GnuDiff::IGNORE_ALL_SPACE; // I think nobody needs anything else ...
         gnuDiff.bIgnoreWhiteSpace = true;
         gnuDiff.bIgnoreNumbers = pOptions->m_bIgnoreNumbers;
         gnuDiff.minimal = pOptions->m_bTryHard;
         gnuDiff.ignore_case = false;
         GnuDiff::change* script = gnuDiff.diff_2_files(&comparisonInput);
 
         LineRef equalLinesAtStart = (LineRef)comparisonInput.file[0].prefix_lines;
         LineRef currentLine1 = 0;
         LineRef currentLine2 = 0;
         GnuDiff::change* p = nullptr;
         for(GnuDiff::change* e = script; e; e = p)
         {
             Diff d((LineRef)(e->line0 - currentLine1), e->deleted, e->inserted);
             Q_ASSERT(d.numberOfEquals() == e->line1 - currentLine2);
 
             currentLine1 += (LineRef)(d.numberOfEquals() + d.diff1());
             currentLine2 += (LineRef)(d.numberOfEquals() + d.diff2());
             diffList.push_back(d);
 
             p = e->link;
             free(e);
         }
 
         if(diffList.empty())
         {
             qint32 numofEquals = std::min(size1, size2);
             Diff d(numofEquals, size1 - numofEquals, size2 - numofEquals);
 
             diffList.push_back(d);
         }
         else
         {
             diffList.front().adjustNumberOfEquals(equalLinesAtStart);
             currentLine1 += equalLinesAtStart;
             currentLine2 += equalLinesAtStart;
 
             LineRef nofEquals = std::min(size1 - currentLine1, size2 - currentLine2);
             if(nofEquals == 0)
             {
                 diffList.back().adjustDiff1(size1 - currentLine1);
                 diffList.back().adjustDiff2(size2 - currentLine2);
             }
             else
             {
                 Diff d(nofEquals, size1 - currentLine1 - nofEquals, size2 - currentLine2 - nofEquals);
                 diffList.push_back(d);
             }
         }
     }
 
     // Verify difflist
     {
         LineRef::LineType l1 = 0;
         LineRef::LineType l2 = 0;
         DiffList::iterator i;
         for(i = diffList.begin(); i != diffList.end(); ++i)
         {
             l1 += i->numberOfEquals() + i->diff1();
             l2 += i->numberOfEquals() + i->diff2();
         }
 
         Q_ASSERT(l1 == size1 && l2 == size2);
     }
 
     pp.setCurrent(1);
 
     return true;
 }
 
 bool ManualDiffHelpList::runDiff(const QVector<LineData>* p1, LineRef size1, const QVector<LineData>* p2, LineRef size2, DiffList& diffList,
                                  e_SrcSelector winIdx1, e_SrcSelector winIdx2,
                                  const QSharedPointer<Options> &pOptions)
 {
     diffList.clear();
     DiffList diffList2;
 
     int l1begin = 0;
     int l2begin = 0;
     ManualDiffHelpList::const_iterator i;
     for(i = begin(); i != end(); ++i)
     {
         const ManualDiffHelpEntry& mdhe = *i;
 
         int l1end = mdhe.getLine1(winIdx1);
         int l2end = mdhe.getLine1(winIdx2);
 
         if(l1end >= 0 && l2end >= 0)
         {
             ::runDiff(p1, l1begin, l1end - l1begin, p2, l2begin, l2end - l2begin, diffList2, pOptions);
             diffList.splice(diffList.end(), diffList2);
             l1begin = l1end;
             l2begin = l2end;
 
             l1end = mdhe.getLine2(winIdx1);
             l2end = mdhe.getLine2(winIdx2);
 
             if(l1end >= 0 && l2end >= 0)
             {
                 ++l1end; // point to line after last selected line
                 ++l2end;
                 ::runDiff(p1, l1begin, l1end - l1begin, p2, l2begin, l2end - l2begin, diffList2, pOptions);
                 diffList.splice(diffList.end(), diffList2);
                 l1begin = l1end;
                 l2begin = l2end;
             }
         }
     }
     ::runDiff(p1, l1begin, size1 - l1begin, p2, l2begin, size2 - l2begin, diffList2, pOptions);
     diffList.splice(diffList.end(), diffList2);
     return true;
 }
 
 void correctManualDiffAlignment(Diff3LineList& d3ll, ManualDiffHelpList* pManualDiffHelpList)
 {
     if(pManualDiffHelpList->empty())
         return;
 
     // If a line appears unaligned in comparison to the manual alignment, correct this.
 
     ManualDiffHelpList::iterator iMDHL;
     for(iMDHL = pManualDiffHelpList->begin(); iMDHL != pManualDiffHelpList->end(); ++iMDHL)
     {
         Diff3LineList::iterator i3 = d3ll.begin();
         e_SrcSelector missingWinIdx = None;
         int alignedSum = (iMDHL->getLine1(A) < 0 ? 0 : 1) + (iMDHL->getLine1(B) < 0 ? 0 : 1) + (iMDHL->getLine1(C) < 0 ? 0 : 1);
         if(alignedSum == 2)
         {
             // If only A & B are aligned then let C rather be aligned with A
             // If only A & C are aligned then let B rather be aligned with A
             // If only B & C are aligned then let A rather be aligned with B
             missingWinIdx = iMDHL->getLine1(A) < 0 ? A : (iMDHL->getLine1(B) < 0 ? B : C);
         }
         else if(alignedSum <= 1)
         {
             return;
         }
 
         // At the first aligned line, move up the two other lines into new d3ls until the second input is aligned
         // Then move up the third input until all three lines are aligned.
         int wi = None;
         for(; i3 != d3ll.end(); ++i3)
         {
             for(wi = A; wi <= Max; ++wi)
             {
                 if(i3->getLineInFile((e_SrcSelector)wi) >= 0 && iMDHL->firstLine((e_SrcSelector)wi) == i3->getLineInFile((e_SrcSelector)wi))
                     break;
             }
             if(wi <= Max)
                 break;
         }
 
         if(wi >= A && wi <= Max)
         {
             // Found manual alignment for one source
             Diff3LineList::iterator iDest = i3;
 
             // Move lines up until the next firstLine is found. Omit wi from move and search.
             int wi2 = None;
             for(; i3 != d3ll.end(); ++i3)
             {
                 for(wi2 = A; wi2 <= C; ++wi2)
                 {
                     if(wi != wi2 && i3->getLineInFile((e_SrcSelector)wi2) >= 0 && iMDHL->firstLine((e_SrcSelector)wi2) == i3->getLineInFile((e_SrcSelector)wi2))
                         break;
                 }
                 if(wi2 > C)
                 { // Not yet found
                     // Move both others up
                     Diff3Line d3l;
                     // Move both up
                     if(wi == A) // Move B and C up
                     {
                         d3l.bBEqC = i3->isEqualBC();
                         d3l.setLineB(i3->getLineB());
                         d3l.setLineC(i3->getLineC());
                         i3->getLineB().invalidate();
                         i3->getLineC().invalidate();
                     }
                     if(wi == B) // Move A and C up
                     {
                         d3l.bAEqC = i3->isEqualAC();
                         d3l.setLineA(i3->getLineA());
                         d3l.setLineC(i3->getLineC());
                         i3->getLineA().invalidate();
                         i3->getLineC().invalidate();
                     }
                     if(wi == C) // Move A and B up
                     {
                         d3l.bAEqB = i3->isEqualAB();
                         d3l.setLineA(i3->getLineA());
                         d3l.setLineB(i3->getLineB());
                         i3->getLineA().invalidate();
                         i3->getLineB().invalidate();
                     }
                     i3->bAEqB = false;
                     i3->bAEqC = false;
                     i3->bBEqC = false;
                     d3ll.insert(iDest, d3l);
                 }
                 else
                 {
                     // align the found line with the line we already have here
                     if(i3 != iDest)
                     {
                         if(wi2 == A)
                         {
                             iDest->setLineA(i3->getLineA());
                             i3->getLineA().invalidate();
                             i3->bAEqB = false;
                             i3->bAEqC = false;
                         }
                         else if(wi2 == B)
                         {
                             iDest->setLineB(i3->getLineB());
                             i3->getLineB().invalidate();
                             i3->bAEqB = false;
                             i3->bBEqC = false;
                         }
                         else if(wi2 == C)
                         {
                             iDest->setLineC(i3->getLineC());
                             i3->getLineC().invalidate();
                             i3->bBEqC = false;
                             i3->bAEqC = false;
                         }
                     }
 
                     if(missingWinIdx != 0)
                     {
                         for(; i3 != d3ll.end(); ++i3)
                         {
                             e_SrcSelector wi3 = missingWinIdx;
                             if(i3->getLineInFile((e_SrcSelector)wi3) >= 0)
                             {
                                 // not found, move the line before iDest
                                 Diff3Line d3l;
                                 if(wi3 == A)
                                 {
                                     if(i3->isEqualAB()) // Stop moving lines up if one equal is found.
                                         break;
                                     d3l.setLineA(i3->getLineA());
                                     i3->getLineA().invalidate();
                                     i3->bAEqB = false;
                                     i3->bAEqC = false;
                                 }
                                 if(wi3 == B)
                                 {
                                     if(i3->isEqualAB())
                                         break;
                                     d3l.setLineB(i3->getLineB());
                                     i3->getLineB().invalidate();
                                     i3->bAEqB = false;
                                     i3->bBEqC = false;
                                 }
                                 if(wi3 == C)
                                 {
                                     if(i3->isEqualAC())
                                         break;
                                     d3l.setLineC(i3->getLineC());
                                     i3->getLineC().invalidate();
                                     i3->bAEqC = false;
                                     i3->bBEqC = false;
                                 }
                                 d3ll.insert(iDest, d3l);
                             }
                         } // for(), searching for wi3
                     }
                     break;
                 }
             } // for(), searching for wi2
         }     // if, wi found
     }         // for (iMDHL)
 }
 
 // Fourth step
 void calcDiff3LineListTrim(
     Diff3LineList& d3ll, const QVector<LineData>* pldA, const QVector<LineData>* pldB, const QVector<LineData>* pldC, ManualDiffHelpList* pManualDiffHelpList)
 {
     const Diff3Line d3l_empty;
     d3ll.remove(d3l_empty);
 
     Diff3LineList::iterator i3 = d3ll.begin();
     Diff3LineList::iterator i3A = d3ll.begin();
     Diff3LineList::iterator i3B = d3ll.begin();
     Diff3LineList::iterator i3C = d3ll.begin();
 
     int line = 0;  // diff3line counters
     int lineA = 0; //
     int lineB = 0;
     int lineC = 0;
 
     ManualDiffHelpList::iterator iMDHL = pManualDiffHelpList->begin();
     // The iterator i3 and the variable line look ahead.
     // The iterators i3A, i3B, i3C and corresponding lineA, lineB and lineC stop at empty lines, if found.
     // If possible, then the texts from the look ahead will be moved back to the empty places.
 
     for(; i3 != d3ll.end(); ++i3, ++line)
     {
         if(iMDHL != pManualDiffHelpList->end())
         {
             if((i3->getLineA().isValid() && i3->getLineA() == iMDHL->getLine1(A)) ||
                (i3->getLineB().isValid() && i3->getLineB() == iMDHL->getLine1(B)) ||
                (i3->getLineC().isValid() && i3->getLineC() == iMDHL->getLine1(C)))
             {
                 i3A = i3;
                 i3B = i3;
                 i3C = i3;
                 lineA = line;
                 lineB = line;
                 lineC = line;
                 ++iMDHL;
             }
         }
 
         if(line > lineA && i3->getLineA().isValid() && i3A->getLineB().isValid() && i3A->isEqualBC() &&
            LineData::equal((*pldA)[i3->getLineA()], (*pldB)[i3A->getLineB()], false) &&
            pManualDiffHelpList->isValidMove(i3->getLineA(), i3A->getLineB(), A, B) &&
            pManualDiffHelpList->isValidMove(i3->getLineA(), i3A->getLineC(), A, C))
         {
             // Empty space for A. A matches B and C in the empty line. Move it up.
             i3A->setLineA(i3->getLineA());
             i3A->bAEqB = true;
             i3A->bAEqC = true;
 
             i3->getLineA().invalidate();
             i3->bAEqB = false;
             i3->bAEqC = false;
             ++i3A;
             ++lineA;
         }
 
         if(line > lineB && i3->getLineB().isValid() && i3B->getLineA().isValid() && i3B->isEqualAC() &&
            LineData::equal((*pldB)[i3->getLineB()], (*pldA)[i3B->getLineA()], false) &&
            pManualDiffHelpList->isValidMove(i3->getLineB(), i3B->getLineA(), B, A) &&
            pManualDiffHelpList->isValidMove(i3->getLineB(), i3B->getLineC(), B, C))
         {
             // Empty space for B. B matches A and C in the empty line. Move it up.
             i3B->setLineB(i3->getLineB());
             i3B->bAEqB = true;
             i3B->bBEqC = true;
             i3->getLineB().invalidate();
             i3->bAEqB = false;
             i3->bBEqC = false;
             ++i3B;
             ++lineB;
         }
 
         if(line > lineC && i3->getLineC().isValid() && i3C->getLineA().isValid() && i3C->isEqualAB() &&
            LineData::equal((*pldC)[i3->getLineC()], (*pldA)[i3C->getLineA()], false) &&
            pManualDiffHelpList->isValidMove(i3->getLineC(), i3C->getLineA(), C, A) &&
            pManualDiffHelpList->isValidMove(i3->getLineC(), i3C->getLineB(), C, B))
         {
             // Empty space for C. C matches A and B in the empty line. Move it up.
             i3C->setLineC(i3->getLineC());
             i3C->bAEqC = true;
             i3C->bBEqC = true;
             i3->getLineC().invalidate();
             i3->bAEqC = false;
             i3->bBEqC = false;
             ++i3C;
             ++lineC;
         }
 
         if(line > lineA && i3->getLineA().isValid() && !i3->isEqualAB() && !i3->isEqualAC() &&
            pManualDiffHelpList->isValidMove(i3->getLineA(), i3A->getLineB(), A, B) &&
            pManualDiffHelpList->isValidMove(i3->getLineA(), i3A->getLineC(), A, C))
         {
             // Empty space for A. A doesn't match B or C. Move it up.
             i3A->setLineA(i3->getLineA());
             i3->getLineA().invalidate();
 
             if(i3A->getLineB().isValid() && LineData::equal((*pldA)[i3A->getLineA()], (*pldB)[i3A->getLineB()], false))
             {
                 i3A->bAEqB = true;
             }
             if((i3A->isEqualAB() && i3A->isEqualBC()) ||
                (i3A->getLineC().isValid() && LineData::equal((*pldA)[i3A->getLineA()], (*pldC)[i3A->getLineC()], false)))
             {
                 i3A->bAEqC = true;
             }
 
             ++i3A;
             ++lineA;
         }
 
         if(line > lineB && i3->getLineB().isValid() && !i3->isEqualAB() && !i3->isEqualBC() &&
            pManualDiffHelpList->isValidMove(i3->getLineB(), i3B->getLineA(), B, A) &&
            pManualDiffHelpList->isValidMove(i3->getLineB(), i3B->getLineC(), B, C))
         {
             // Empty space for B. B matches neither A nor C. Move B up.
             i3B->setLineB(i3->getLineB());
             i3->getLineB().invalidate();
 
             if(i3B->getLineA().isValid() && LineData::equal((*pldA)[i3B->getLineA()], (*pldB)[i3B->getLineB()], false))
             {
                 i3B->bAEqB = true;
             }
             if((i3B->isEqualAB() && i3B->isEqualAC()) ||
                (i3B->getLineC().isValid() && LineData::equal((*pldB)[i3B->getLineB()], (*pldC)[i3B->getLineC()], false)))
             {
                 i3B->bBEqC = true;
             }
 
             ++i3B;
             ++lineB;
         }
 
         if(line > lineC && i3->getLineC().isValid() && !i3->isEqualAC() && !i3->isEqualBC() &&
            pManualDiffHelpList->isValidMove(i3->getLineC(), i3C->getLineA(), C, A) &&
            pManualDiffHelpList->isValidMove(i3->getLineC(), i3C->getLineB(), C, B))
         {
             // Empty space for C. C matches neither A nor B. Move C up.
             i3C->setLineC(i3->getLineC());
             i3->getLineC().invalidate();
 
             if(i3C->getLineA().isValid() && LineData::equal((*pldA)[i3C->getLineA()], (*pldC)[i3C->getLineC()], false))
             {
                 i3C->bAEqC = true;
             }
             if((i3C->isEqualAC() && i3C->isEqualAB()) ||
                (i3C->getLineB().isValid() && LineData::equal((*pldB)[i3C->getLineB()], (*pldC)[i3C->getLineC()], false)))
             {
                 i3C->bBEqC = true;
             }
 
             ++i3C;
             ++lineC;
         }
 
         if(line > lineA && line > lineB && i3->getLineA().isValid() && i3->isEqualAB() && !i3->isEqualAC())
         {
             // Empty space for A and B. A matches B, but not C. Move A & B up.
             Diff3LineList::iterator i = lineA > lineB ? i3A : i3B;
             int l = lineA > lineB ? lineA : lineB;
 
             if(pManualDiffHelpList->isValidMove(i->getLineC(), i3->getLineA(), C, A) &&
                pManualDiffHelpList->isValidMove(i->getLineC(), i3->getLineB(), C, B))
             {
                 i->setLineA(i3->getLineA());
                 i->setLineB(i3->getLineB());
                 i->bAEqB = true;
 
                 if(i->getLineC().isValid() && LineData::equal((*pldA)[i->getLineA()], (*pldC)[i->getLineC()], false))
                 {
                     i->bAEqC = true;
                     i->bBEqC = true;
                 }
 
                 i3->getLineA().invalidate();
                 i3->getLineB().invalidate();
                 i3->bAEqB = false;
                 i3A = i;
                 i3B = i;
                 ++i3A;
                 ++i3B;
                 lineA = l + 1;
                 lineB = l + 1;
             }
         }
         else if(line > lineA && line > lineC && i3->getLineA().isValid() && i3->isEqualAC() && !i3->isEqualAB())
         {
             // Empty space for A and C. A matches C, but not B. Move A & C up.
             Diff3LineList::iterator i = lineA > lineC ? i3A : i3C;
             int l = lineA > lineC ? lineA : lineC;
 
             if(pManualDiffHelpList->isValidMove(i->getLineB(), i3->getLineA(), B, A) &&
                pManualDiffHelpList->isValidMove(i->getLineB(), i3->getLineC(), B, C))
             {
                 i->setLineA(i3->getLineA());
                 i->setLineC(i3->getLineC());
                 i->bAEqC = true;
 
                 if(i->getLineB().isValid() && LineData::equal((*pldA)[i->getLineA()], (*pldB)[i->getLineB()], false))
                 {
                     i->bAEqB = true;
                     i->bBEqC = true;
                 }
 
                 i3->getLineA().invalidate();
                 i3->getLineC().invalidate();
                 i3->bAEqC = false;
                 i3A = i;
                 i3C = i;
                 ++i3A;
                 ++i3C;
                 lineA = l + 1;
                 lineC = l + 1;
             }
         }
         else if(line > lineB && line > lineC && i3->getLineB().isValid() && i3->isEqualBC() && !i3->isEqualAC())
         {
             // Empty space for B and C. B matches C, but not A. Move B & C up.
             Diff3LineList::iterator i = lineB > lineC ? i3B : i3C;
             int l = lineB > lineC ? lineB : lineC;
 
             if(pManualDiffHelpList->isValidMove(i->getLineA(), i3->getLineB(), A, B) &&
                pManualDiffHelpList->isValidMove(i->getLineA(), i3->getLineC(), A, C))
             {
                 i->setLineB(i3->getLineB());
                 i->setLineC(i3->getLineC());
                 i->bBEqC = true;
 
                 if(i->getLineA().isValid() && LineData::equal((*pldA)[i->getLineA()], (*pldB)[i->getLineB()], false))
                 {
                     i->bAEqB = true;
                     i->bAEqC = true;
                 }
 
                 i3->getLineB().invalidate();
                 i3->getLineC().invalidate();
                 i3->bBEqC = false;
                 i3B = i;
                 i3C = i;
                 ++i3B;
                 ++i3C;
                 lineB = l + 1;
                 lineC = l + 1;
             }
         }
 
         if(i3->getLineA().isValid())
         {
             lineA = line + 1;
             i3A = i3;
             ++i3A;
         }
         if(i3->getLineB().isValid())
         {
             lineB = line + 1;
             i3B = i3;
             ++i3B;
         }
         if(i3->getLineC().isValid())
         {
             lineC = line + 1;
             i3C = i3;
             ++i3C;
         }
     }
 
     d3ll.remove(d3l_empty);
 
     /*
 
    Diff3LineList::iterator it = d3ll.begin();
    int li=0;
    for( ; it!=d3ll.end(); ++it, ++li )
    {
       printf( "%4d %4d %4d %4d  A%c=B A%c=C B%c=C\n",
          li, it->getLineA(), it->getLineB(), it->getLineC(),
          it->isEqualAB() ? '=' : '!', it->isEqualAC() ? '=' : '!', it->isEqualBC() ? '=' : '!' );
 
    }
 */
 }
 
 void DiffBufferInfo::init(Diff3LineList* pD3ll, const Diff3LineVector* pD3lv,
                           const QVector<LineData>* pldA, LineCount sizeA, const QVector<LineData>* pldB, LineCount sizeB, const QVector<LineData>* pldC, LineCount sizeC)
 {
     m_pDiff3LineList = pD3ll;
     m_pDiff3LineVector = pD3lv;
     m_pLineDataA = pldA;
     m_pLineDataB = pldB;
     m_pLineDataC = pldC;
     m_sizeA = sizeA;
     m_sizeB = sizeB;
     m_sizeC = sizeC;
     Diff3LineList::iterator i3 = pD3ll->begin();
     for(; i3 != pD3ll->end(); ++i3)
     {
         i3->m_pDiffBufferInfo = this;
     }
 }
 
 void Diff3LineList::calcWhiteDiff3Lines(
     const QVector<LineData>* pldA, const QVector<LineData>* pldB, const QVector<LineData>* pldC)
 {
     Diff3LineList::iterator i3;
 
     for(i3 = begin(); i3 != end(); ++i3)
     {
         i3->bWhiteLineA = (!i3->getLineA().isValid() || pldA == nullptr || (*pldA)[i3->getLineA()].whiteLine() || (*pldA)[i3->getLineA()].isPureComment());
         i3->bWhiteLineB = (!i3->getLineB().isValid() || pldB == nullptr || (*pldB)[i3->getLineB()].whiteLine() || (*pldB)[i3->getLineB()].isPureComment());
         i3->bWhiteLineC = (!i3->getLineC().isValid() || pldC == nullptr || (*pldC)[i3->getLineC()].whiteLine() || (*pldC)[i3->getLineC()].isPureComment());
     }
 }
 
 // My own diff-invention:
 void calcDiff(const QString& line1, const QString& line2, DiffList& diffList, int match, int maxSearchRange)
 {
     diffList.clear();
 
     QString::const_iterator p1=line1.begin(), p2=line2.begin();
 
     /*
         This loop should never reach the exit condition specified here. However it must have a hard wired
         stopping point to prevent runaway allocation if something unexpected happens.
         diffList is therefor hard capped at aprox 50 MB in size.
      */
     for(; diffList.size() * sizeof(Diff) + sizeof(DiffList) < (50 << 20);)
     {
         int nofEquals = 0;
         while(p1 != line1.end() && p2 != line2.end() &&  *p1 == *p2)
         {
             ++p1;
             ++p2;
             ++nofEquals;
         }
 
         bool bBestValid = false;
         int bestI1 = 0;
         int bestI2 = 0;
         int i1 = 0;
         int i2 = 0;
 
         for(i1 = 0;; ++i1)
         {
             if(p1[i1] == *line1.end() || (bBestValid && i1 >= bestI1 + bestI2))
             {
                 break;
             }
             for(i2 = 0; i2 < maxSearchRange; ++i2)
             {
                 if(p2[i2] == *line2.end() || (bBestValid && i1 + i2 >= bestI1 + bestI2))
                 {
                     break;
                 }
                 else if(p2[i2] == p1[i1] &&
                         (match == 1 || abs(i1 - i2) < 3 || (p2[i2 + 1] == *line2.end() && p1[i1 + 1] == *line1.end()) ||
                          (p2[i2 + 1] != *line2.end() && p1[i1 + 1] != *line1.end() && p2[i2 + 1] == p1[i1 + 1])))
                 {
                     if(i1 + i2 < bestI1 + bestI2 || !bBestValid)
                     {
                         bestI1 = i1;
                         bestI2 = i2;
                         bBestValid = true;
                         break;
                     }
                 }
             }
         }
 
         // The match was found using the strict search. Go back if there are non-strict
         // matches.
         while(bestI1 >= 1 && bestI2 >= 1 && p1[bestI1 - 1] == p2[bestI2 - 1])
         {
             --bestI1;
             --bestI2;
         }
 
         bool bEndReached = false;
         if(bBestValid)
         {
             // continue somehow
             Diff d(nofEquals, bestI1, bestI2);
             Q_ASSERT(nofEquals + bestI1 + bestI2 != 0);
             diffList.push_back(d);
 
             p1 += bestI1;
             p2 += bestI2;
         }
         else
         {
             // Nothing else to match.
             Diff d(nofEquals, line1.end() - p1, line2.end() - p2);
             diffList.push_back(d);
 
             bEndReached = true; //break;
         }
 
         // Sometimes the algorithm that chooses the first match unfortunately chooses
         // a match where later actually equal parts don't match anymore.
         // A different match could be achieved, if we start at the end.
         // Do it, if it would be a better match.
         int nofUnmatched = 0;
         QString::const_iterator pu1 = p1 - 1;
         QString::const_iterator pu2 = p2 - 1;
 
         while(pu1 >= line1.begin() && pu2 >= line2.begin() && *pu1 == *pu2)
         {
             ++nofUnmatched;
             --pu1;
             --pu2;
         }
 
         Diff d = diffList.back();
         if(nofUnmatched > 0)
         {
             // We want to go backwards the nofUnmatched elements and redo
             // the matching
             d = diffList.back();
             Diff origBack = d;
             diffList.pop_back();
 
             while(nofUnmatched > 0)
             {
                 if(d.diff1() > 0 && d.diff2() > 0)
                 {
                     d.adjustDiff1(-1);
                     d.adjustDiff2(-1);
                     --nofUnmatched;
                 }
                 else if(d.numberOfEquals() > 0)
                 {
                     d.adjustNumberOfEquals(-1);
                     --nofUnmatched;
                 }
 
                 if(d.numberOfEquals() == 0 && (d.diff1() == 0 || d.diff2() == 0) && nofUnmatched > 0)
                 {
                     if(diffList.empty())
                         break;
                     d.adjustNumberOfEquals(diffList.back().numberOfEquals());
                     d.adjustDiff1(diffList.back().diff1());
                     d.adjustDiff2(diffList.back().diff2());
                     diffList.pop_back();
                     bEndReached = false;
                 }
             }
 
             if(bEndReached)
                 diffList.push_back(origBack);
             else
             {
 
                 p1 = pu1 + 1 + nofUnmatched;
                 p2 = pu2 + 1 + nofUnmatched;
                 diffList.push_back(d);
             }
         }
         if(bEndReached)
             break;
     }
 
     Q_ASSERT(diffList.size() * sizeof(Diff) + sizeof(DiffList) <= (50 << 20));
 
     // Verify difflist
     {
         qint32 l1 = 0;
         qint32 l2 = 0;
         DiffList::const_iterator it;
         for(it = diffList.begin(); it != diffList.end(); ++it)
         {
             l1 += (it->numberOfEquals() + it->diff1());
             l2 += (it->numberOfEquals() + it->diff2());
         }
 
         Q_ASSERT(l1 == line1.size() && l2 == line2.size());
     }
 }
 
 bool Diff3Line::fineDiff(bool inBTextsTotalEqual, const e_SrcSelector selector, const QVector<LineData>* v1, const QVector<LineData>* v2)
 {
     LineRef k1 = 0;
     LineRef k2 = 0;
     int maxSearchLength = 500;
     bool bTextsTotalEqual = inBTextsTotalEqual;
 
     Q_ASSERT(selector == A || selector == B || selector == C);
 
     if(selector == A)
     {
         k1 = getLineA();
         k2 = getLineB();
     }
     else if(selector == B)
     {
         k1 = getLineB();
         k2 = getLineC();
     }
     else if(selector == C)
     {
         k1 = getLineC();
         k2 = getLineA();
     }
 
     qDebug(kdiffCore) << "k1 = " << k1 << ", k2 = " << k2;
     if((!k1.isValid() && k2.isValid()) || (k1.isValid() && !k2.isValid())) bTextsTotalEqual = false;
     if(k1.isValid() && k2.isValid())
     {
         if((*v1)[k1].size() != (*v2)[k2].size() || QString::compare((*v1)[k1].getLine(), (*v2)[k2].getLine()) != 0)
         {
             bTextsTotalEqual = false;
             DiffList* pDiffList = new DiffList;
             calcDiff((*v1)[k1].getLine(), (*v2)[k2].getLine(), *pDiffList, 2, maxSearchLength);
 
             // Optimize the diff list.
             DiffList::iterator dli;
             bool bUsefulFineDiff = false;
             for(dli = pDiffList->begin(); dli != pDiffList->end(); ++dli)
             {
                 if(dli->numberOfEquals() >= 4)
                 {
                     bUsefulFineDiff = true;
                     break;
                 }
             }
 
             for(dli = pDiffList->begin(); dli != pDiffList->end(); ++dli)
             {
                 if(dli->numberOfEquals() < 4 && (dli->diff1() > 0 || dli->diff2() > 0) && !(bUsefulFineDiff && dli == pDiffList->begin()))
                 {
                     dli->adjustDiff1(dli->numberOfEquals());
                     dli->adjustDiff2(dli->numberOfEquals());
                     dli->setNumberOfEquals(0);
                 }
             }
 
             setFineDiff(selector, pDiffList);
         }
 
         if(((*v1)[k1].isPureComment() || (*v1)[k1].whiteLine()) && ((*v2)[k2].isPureComment() || (*v2)[k2].whiteLine()))
         {
             if(selector == A)
             {
                 bAEqB = true;
             }
             else if(selector == B)
             {
                 bBEqC = true;
             }
             else if(selector == C)
             {
                 bAEqC = true;
             }
         }
     }
 
     return bTextsTotalEqual;
 }
 
 void Diff3Line::getLineInfo(const e_SrcSelector winIdx, const bool isTriple, int& lineIdx,
                             DiffList*& pFineDiff1, DiffList*& pFineDiff2, // return values
                             int& changed, int& changed2) const
 {
     changed = 0;
     changed2 = 0;
     bool bAEqualB = this->isEqualAB() || (bWhiteLineA && bWhiteLineB);
     bool bAEqualC = this->isEqualAC() || (bWhiteLineA && bWhiteLineC);
     bool bBEqualC = this->isEqualBC() || (bWhiteLineB && bWhiteLineC);
 
     Q_ASSERT(winIdx >= A && winIdx <= C);
     if(winIdx == A)
     {
         lineIdx = getLineA();
         pFineDiff1 = pFineAB;
         pFineDiff2 = pFineCA;
         changed |= ((!getLineB().isValid()) != (lineIdx == -1) ? 1 : 0) +
                    ((!getLineC().isValid()) != (lineIdx == -1) && isTriple ? 2 : 0);
         changed2 |= (bAEqualB ? 0 : 1) + (bAEqualC || !isTriple ? 0 : 2);
     }
     else if(winIdx == B)
     {
         lineIdx = getLineB();
         pFineDiff1 = pFineBC;
         pFineDiff2 = pFineAB;
         changed |= ((!getLineC().isValid()) != (lineIdx == -1) && isTriple ? 1 : 0) +
                    ((!getLineA().isValid()) != (lineIdx == -1) ? 2 : 0);
         changed2 |= (bBEqualC || !isTriple ? 0 : 1) + (bAEqualB ? 0 : 2);
     }
     else if(winIdx == C)
     {
         lineIdx = getLineC();
         pFineDiff1 = pFineCA;
         pFineDiff2 = pFineBC;
         changed |= ((!getLineA().isValid()) != (lineIdx == -1) ? 1 : 0) +
                    ((!getLineB().isValid()) != (lineIdx == -1) ? 2 : 0);
         changed2 |= (bAEqualC ? 0 : 1) + (bBEqualC ? 0 : 2);
     }
 }
 
 bool Diff3LineList::fineDiff(const e_SrcSelector selector, const QVector<LineData>* v1, const QVector<LineData>* v2)
 {
     // Finetuning: Diff each line with deltas
     ProgressProxy pp;
     Diff3LineList::iterator i;
     bool bTextsTotalEqual = true;
     int listSize = size();
     pp.setMaxNofSteps(listSize);
     int listIdx = 0;
     for(i = begin(); i != end(); ++i)
     {
         bTextsTotalEqual = i->fineDiff(bTextsTotalEqual, selector, v1, v2);
         ++listIdx;
         pp.step();
     }
     return bTextsTotalEqual;
 }
 
 // Convert the list to a vector of pointers
 void Diff3LineList::calcDiff3LineVector(Diff3LineVector& d3lv)
 {
     d3lv.resize(size());
     Diff3LineList::iterator i;
     int j = 0;
     for(i = begin(); i != end(); ++i, ++j)
     {
         d3lv[j] = &(*i);
     }
     Q_ASSERT(j == d3lv.size());
 }
diff --git a/src/diff.h b/src/diff.h
index 8bfe00f..5da276c 100644
--- a/src/diff.h
+++ b/src/diff.h
@@ -1,461 +1,462 @@
 /***************************************************************************
  *   Copyright (C) 2003-2007 by Joachim Eibl <joachim.eibl at gmx.de>      *
  *   Copyright (C) 2018 Michael Reeves reeves.87@gmail.com                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #ifndef DIFF_H
 #define DIFF_H
 
 #include "common.h"
 #include "fileaccess.h"
-#include "options.h"
-#include "gnudiff_diff.h"
+#include "LineRef.h"
 #include "SourceData.h"
 #include "Logging.h"
 
 #include <QList>
 
+class Options;
+
 //enum must be sequential with no gaps to allow loop interiation of values
 enum e_SrcSelector
 {
    Min = -1,
    Invalid=-1,
    None=0,
    A = 1,
    B = 2,
    C = 3,
    Max=C
 };
 
 enum e_MergeDetails
 {
    eDefault,
    eNoChange,
    eBChanged,
    eCChanged,
    eBCChanged,         // conflict
    eBCChangedAndEqual, // possible conflict
    eBDeleted,
    eCDeleted,
    eBCDeleted,         // possible conflict
 
    eBChanged_CDeleted, // conflict
    eCChanged_BDeleted, // conflict
    eBAdded,
    eCAdded,
    eBCAdded,           // conflict
    eBCAddedAndEqual    // possible conflict
 };
 
 // Each range with matching elements is followed by a range with differences on either side.
 // Then again range of matching elements should follow.
 class Diff
 {
   private:
     qint32 nofEquals = 0;
 
     qint64 mDiff1 = 0;
     qint64 mDiff2 = 0;
   public:
     Diff(qint32 eq, const qint64 inDiff1, const qint64 inDiff2)
     {
         nofEquals = eq;
         mDiff1 = inDiff1;
         mDiff2 = inDiff2;
     }
 
     inline qint32 numberOfEquals() const { return nofEquals; };
 
     inline qint64 diff1() const { return mDiff1; };
     inline qint64 diff2() const { return mDiff2; };
 
     inline void setNumberOfEquals(const qint32 inNumOfEquals) { nofEquals = inNumOfEquals; }
 
     inline void adjustNumberOfEquals(const qint64 delta) { nofEquals += delta; }
     inline void adjustDiff1(const qint64 delta) { mDiff1 += delta; }
     inline void adjustDiff2(const qint64 delta) { mDiff2 += delta; }
 };
 
 typedef std::list<Diff> DiffList;
 
 class LineData
 {
   private:
     QSharedPointer<QString> mBuffer;
     //QString pLine;
     QtNumberType mFirstNonWhiteChar = 0;
     qint64 mOffset = 0;
     QtNumberType mSize = 0;
     bool bContainsPureComment = false;//TODO: Move me
 
   public:
     explicit LineData() = default; // needed for Qt internal reasons should not be used.
     inline LineData(const QSharedPointer<QString> &buffer, const qint64 inOffset, QtNumberType inSize = 0)
     {
         mBuffer = buffer;
         mOffset = inOffset;
         mSize = inSize;
     }
     Q_REQUIRED_RESULT inline int size() const { return mSize; }
     inline void setFirstNonWhiteChar(const qint32 firstNonWhiteChar) { mFirstNonWhiteChar = firstNonWhiteChar;}
     Q_REQUIRED_RESULT inline qint32 getFirstNonWhiteChar() const { return mFirstNonWhiteChar; }
 
     /*
         QString::fromRawData allows us to create a light weight QString backed by the buffer memmory.
     */
     Q_REQUIRED_RESULT inline const QString getLine() const { return QString::fromRawData(mBuffer->data() + mOffset, mSize); }
     Q_REQUIRED_RESULT inline const QSharedPointer<QString>& getBuffer() const { return mBuffer; }
 
     Q_REQUIRED_RESULT inline qint64 getOffset() const { return mOffset; }
     Q_REQUIRED_RESULT int width(int tabSize) const; // Calcs width considering tabs.
     //int occurrences;
     inline bool whiteLine() const { return mFirstNonWhiteChar == mSize - 1; }
 
     inline bool isPureComment() const { return bContainsPureComment; }
     inline void setPureComment(const bool bPureComment) { bContainsPureComment = bPureComment; }
 
     static bool equal(const LineData& l1, const LineData& l2, bool bStrict);
 };
 
 class Diff3LineList;
 class Diff3LineVector;
 
 class DiffBufferInfo
 {
   public:
     const QVector<LineData>* m_pLineDataA;
     const QVector<LineData>* m_pLineDataB;
     const QVector<LineData>* m_pLineDataC;
     LineCount m_sizeA;
     LineCount m_sizeB;
     LineCount m_sizeC;
     const Diff3LineList* m_pDiff3LineList;
     const Diff3LineVector* m_pDiff3LineVector;
     void init(Diff3LineList* d3ll, const Diff3LineVector* d3lv,
               const QVector<LineData>* pldA, LineCount sizeA, const QVector<LineData>* pldB, LineCount sizeB, const QVector<LineData>* pldC, LineCount sizeC);
 };
 
 class Diff3Line
 {
   private:
     LineRef lineA;
     LineRef lineB;
     LineRef lineC;
   public:
 
     bool bAEqC = false; // These are true if equal or only white-space changes exist.
     bool bBEqC = false;
     bool bAEqB = false;
 
     bool bWhiteLineA  = false;
     bool bWhiteLineB  = false;
     bool bWhiteLineC  = false;
 
     DiffList* pFineAB = nullptr; // These are 0 only if completely equal or if either source doesn't exist.
     DiffList* pFineBC = nullptr;
     DiffList* pFineCA = nullptr;
 
     int linesNeededForDisplay = 1;    // Due to wordwrap
     int sumLinesNeededForDisplay = 0; // For fast conversion to m_diff3WrapLineVector
 
     DiffBufferInfo* m_pDiffBufferInfo = nullptr; // For convenience
 
     ~Diff3Line()
     {
         if(pFineAB != nullptr) delete pFineAB;
         if(pFineBC != nullptr) delete pFineBC;
         if(pFineCA != nullptr) delete pFineCA;
         pFineAB = nullptr;
         pFineBC = nullptr;
         pFineCA = nullptr;
     }
 
     LineRef getLineA() const { return lineA; }
     LineRef getLineB() const { return lineB; }
     LineRef getLineC() const { return lineC; }
 
     inline void setLineA(const LineRef& line) { lineA = line; }
     inline void setLineB(const LineRef& line) { lineB = line; }
     inline void setLineC(const LineRef& line) { lineC = line; }
 
     inline bool isEqualAB() const { return bAEqB; }
     inline bool isEqualAC() const { return bAEqC; }
     inline bool isEqualBC() const { return bBEqC; }
 
     bool operator==(const Diff3Line& d3l) const
     {
         return lineA == d3l.lineA && lineB == d3l.lineB && lineC == d3l.lineC && bAEqB == d3l.bAEqB && bAEqC == d3l.bAEqC && bBEqC == d3l.bBEqC;
     }
 
     const LineData* getLineData(e_SrcSelector src) const
     {
         Q_ASSERT(m_pDiffBufferInfo != nullptr);
         if(src == A && lineA >= 0) return &(*m_pDiffBufferInfo->m_pLineDataA)[lineA];
         if(src == B && lineB >= 0) return &(*m_pDiffBufferInfo->m_pLineDataB)[lineB];
         if(src == C && lineC >= 0) return &(*m_pDiffBufferInfo->m_pLineDataC)[lineC];
         return nullptr;
     }
     const QString getString(const e_SrcSelector src) const
     {
         const LineData* pld = getLineData(src);
         if(pld)
             return pld->getLine();
         else
             return QString();
     }
     LineRef getLineInFile(e_SrcSelector src) const
     {
         if(src == A) return lineA;
         if(src == B) return lineB;
         if(src == C) return lineC;
         return -1;
     }
 
     bool fineDiff(bool bTextsTotalEqual, const e_SrcSelector selector, const QVector<LineData>* v1, const QVector<LineData>* v2);
     void mergeOneLine(e_MergeDetails& mergeDetails, bool& bConflict, bool& bLineRemoved, e_SrcSelector& src, bool bTwoInputs) const;
 
     void getLineInfo(const e_SrcSelector winIdx, const bool isTriple, int& lineIdx,
         DiffList*& pFineDiff1, DiffList*& pFineDiff2, // return values
         int& changed, int& changed2) const;
 
   private:
     void setFineDiff(const e_SrcSelector selector, DiffList* pDiffList)
     {
         Q_ASSERT(selector == A || selector == B || selector == C);
         if(selector == A)
         {
             if(pFineAB != nullptr)
                 delete pFineAB;
             pFineAB = pDiffList;
         }
         else if(selector == B)
         {
             if(pFineBC != nullptr)
                 delete pFineBC;
             pFineBC = pDiffList;
         }
         else if(selector == C)
         {
             if(pFineCA)
                 delete pFineCA;
             pFineCA = pDiffList;
         }
     }
 };
 
 class Diff3LineList : public std::list<Diff3Line>
 {
   public:
     bool fineDiff(const e_SrcSelector selector, const QVector<LineData>* v1, const QVector<LineData>* v2);
     void calcDiff3LineVector(Diff3LineVector& d3lv);
     void calcWhiteDiff3Lines(const QVector<LineData>* pldA, const QVector<LineData>* pldB, const QVector<LineData>* pldC);
     //TODO: Add safety guards to prevent list from getting too large. Same problem as with QLinkedList.
     int size() const
     {
         if(std::list<Diff3Line>::size() > (size_t)std::numeric_limits<int>::max())//explicit cast to silence gcc
         {
             qCDebug(kdiffMain) << "Diff3Line: List too large. size=" << std::list<Diff3Line>::size();
             Q_ASSERT(false); //Unsupported size
             return 0;
         }
         return (int)std::list<Diff3Line>::size();
     } //safe for small files same limit as exited with QLinkedList. This should ultimatly be removed.
 
     void debugLineCheck(const LineCount size, const e_SrcSelector srcSelector) const;
 };
 
 class Diff3LineVector : public QVector<Diff3Line*>
 {
 };
 
 class Diff3WrapLine
 {
   public:
     Diff3Line* pD3L;
     int diff3LineIndex;
     int wrapLineOffset;
     int wrapLineLength;
 };
 
 typedef QVector<Diff3WrapLine> Diff3WrapLineVector;
 
 class TotalDiffStatus
 {
   public:
     inline void reset()
     {
         bBinaryAEqC = false;
         bBinaryBEqC = false;
         bBinaryAEqB = false;
         bTextAEqC = false;
         bTextBEqC = false;
         bTextAEqB = false;
         nofUnsolvedConflicts = 0;
         nofSolvedConflicts = 0;
         nofWhitespaceConflicts = 0;
     }
 
     inline int getUnsolvedConflicts() const { return nofUnsolvedConflicts; }
     inline void setUnsolvedConflicts(const int unsolved) { nofUnsolvedConflicts = unsolved; }
 
     inline int getSolvedConflicts() const { return nofSolvedConflicts; }
     inline void setSolvedConflicts(const int solved) { nofSolvedConflicts = solved; }
 
     inline int getWhitespaceConflicts() const { return nofWhitespaceConflicts; }
     inline void setWhitespaceConflicts(const int wintespace) { nofWhitespaceConflicts = wintespace; }
 
     inline int getNonWhitespaceConflicts() { return getUnsolvedConflicts() + getSolvedConflicts() - getWhitespaceConflicts(); }
 
     bool isBinaryEqualAC() const { return bBinaryAEqC; }
     bool isBinaryEqualBC() const { return bBinaryBEqC; }
     bool isBinaryEqualAB() const { return bBinaryAEqB; }
 
     bool bBinaryAEqC = false;
     bool bBinaryBEqC = false;
     bool bBinaryAEqB = false;
 
     bool bTextAEqC = false;
     bool bTextBEqC = false;
     bool bTextAEqB = false;
 
   private:
     int nofUnsolvedConflicts = 0;
     int nofSolvedConflicts = 0;
     int nofWhitespaceConflicts = 0;
 };
 
 class ManualDiffHelpList; // A list of corresponding ranges
 // Three corresponding ranges. (Minimum size of a valid range is one line.)
 class ManualDiffHelpEntry
 {
   private:
     LineRef lineA1;
     LineRef lineA2;
     LineRef lineB1;
     LineRef lineB2;
     LineRef lineC1;
     LineRef lineC2;
 
   public:
     LineRef& firstLine(e_SrcSelector winIdx)
     {
         return winIdx == A ? lineA1 : (winIdx == B ? lineB1 : lineC1);
     }
     LineRef& lastLine(e_SrcSelector winIdx)
     {
         return winIdx == A ? lineA2 : (winIdx == B ? lineB2 : lineC2);
     }
     bool isLineInRange(LineRef line, e_SrcSelector winIdx)
     {
         return line >= 0 && line >= firstLine(winIdx) && line <= lastLine(winIdx);
     }
     bool operator==(const ManualDiffHelpEntry& r) const
     {
         return lineA1 == r.lineA1 && lineB1 == r.lineB1 && lineC1 == r.lineC1 &&
                lineA2 == r.lineA2 && lineB2 == r.lineB2 && lineC2 == r.lineC2;
     }
 
     int calcManualDiffFirstDiff3LineIdx(const Diff3LineVector& d3lv);
 
     void getRangeForUI(const e_SrcSelector winIdx, int *rangeLine1, int *rangeLine2) const {
         if(winIdx == A) {
             *rangeLine1 = lineA1;
             *rangeLine2 = lineA2;
         }
         if(winIdx == B) {
             *rangeLine1 = lineB1;
             *rangeLine2 = lineB2;
         }
         if(winIdx == C) {
             *rangeLine1 = lineC1;
             *rangeLine2 = lineC2;
         }
     }
 
     inline int getLine1(const e_SrcSelector winIdx) const { return winIdx == A ? lineA1 : winIdx == B ? lineB1 : lineC1;}
     inline int getLine2(const e_SrcSelector winIdx) const { return winIdx == A ? lineA2 : winIdx == B ? lineB2 : lineC2;}
     bool isValidMove(int line1, int line2, e_SrcSelector winIdx1, e_SrcSelector winIdx2) const;
 };
 
 // A list of corresponding ranges
 class ManualDiffHelpList: public std::list<ManualDiffHelpEntry>
 {
     public:
         bool isValidMove(int line1, int line2, e_SrcSelector winIdx1, e_SrcSelector winIdx2) const;
         void insertEntry(e_SrcSelector winIdx, LineRef firstLine, LineRef lastLine);
 
         bool runDiff(const QVector<LineData>* p1, LineRef size1, const QVector<LineData>* p2, LineRef size2, DiffList& diffList,
                      e_SrcSelector winIdx1, e_SrcSelector winIdx2,
                      const QSharedPointer<Options> &pOptions);
 };
 
 void calcDiff(const QString &line1, const QString &line2, DiffList& diffList, int match, int maxSearchRange);
 
 void calcDiff3LineListUsingAB(
     const DiffList* pDiffListAB,
     Diff3LineList& d3ll);
 
 void calcDiff3LineListUsingAC(
     const DiffList* pDiffListAC,
     Diff3LineList& d3ll);
 
 void calcDiff3LineListUsingBC(
     const DiffList* pDiffListBC,
     Diff3LineList& d3ll);
 
 void correctManualDiffAlignment(Diff3LineList& d3ll, ManualDiffHelpList* pManualDiffHelpList);
 
 void calcDiff3LineListTrim(Diff3LineList& d3ll, const QVector<LineData>* pldA, const QVector<LineData>* pldB, const QVector<LineData>* pldC, ManualDiffHelpList* pManualDiffHelpList);
 
 
 
 bool fineDiff(
     Diff3LineList& diff3LineList,
     int selector,
     const QVector<LineData>* v1,
     const QVector<LineData>* v2);
 
 inline bool isWhite(QChar c)
 {
     return c == ' ' || c == '\t' || c == '\r';
 }
 
 /** Returns the number of equivalent spaces at position outPos.
 */
 inline int tabber(int outPos, int tabSize)
 {
     return tabSize - (outPos % tabSize);
 }
 
 /** 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);
 
 extern bool g_bIgnoreWhiteSpace;
 extern bool g_bIgnoreTrivialMatches;
 extern bool g_bAutoSolve;
 
 // Cursor conversions that consider g_tabSize.
 int convertToPosInText(const QString& s, int posOnScreen, int tabSize);
 int convertToPosOnScreen(const QString& s, int posInText, int tabSize);
 
 enum e_CoordType
 {
     eFileCoords,
     eD3LLineCoords,
     eWrapCoords
 };
 
 void calcTokenPos(const QString&, int posOnScreen, int& pos1, int& pos2, int tabSize);
 
 QString calcHistorySortKey(const QString& keyOrder, QRegExp& matchedRegExpr, const QStringList& parenthesesGroupList);
 bool findParenthesesGroups(const QString& s, QStringList& sl);
 #endif
diff --git a/src/difftextwindow.cpp b/src/difftextwindow.cpp
index b8913fc..a9908da 100644
--- a/src/difftextwindow.cpp
+++ b/src/difftextwindow.cpp
@@ -1,2023 +1,2026 @@
 /***************************************************************************
  *   Copyright (C) 2003-2007 by Joachim Eibl                               *
  *   joachim.eibl at gmx.de                                                *
  *   Copyright (C) 2018 Michael Reeves reeves.87@gmail.com                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #include "difftextwindow.h"
 
+#include "common.h"            // for getAtomic, max3, min3
 #include "FileNameLineEdit.h"
 #include "kdiff3.h"
 #include "merger.h"
 #include "options.h"
 #include "progress.h"
 #include "RLPainter.h"
 #include "selection.h"
+#include "SourceData.h"        // for SourceData
+#include "Utils.h"             // for Utils
 
 #include <algorithm>
 #include <cmath>
 #include <cstdlib>
 
+#include <KLocalizedString>
+
 #include <QtMath>
 #include <QDir>
 #include <QDragEnterEvent>
 #include <QFileDialog>
 #include <QLabel>
 #include <QLayout>
 #include <QLineEdit>
 #include <QMenu>
 #include <QMimeData>
 #include <QPushButton>
 #include <QRunnable>
 #include <QStatusBar>
 #include <QTextCodec>
 #include <QTextLayout>
 #include <QThreadPool>
 #include <QToolTip>
 #include <QUrl>
 
-#include <KLocalizedString>
-
 QAtomicInt s_runnableCount = 0;
 
 class DiffTextWindowData
 {
   public:
     explicit DiffTextWindowData(DiffTextWindow* p)
     {
         m_pDiffTextWindow = p;
         m_pLineData = nullptr;
         m_size = 0;
         m_bWordWrap = false;
         m_delayedDrawTimer = 0;
         m_pDiff3LineVector = nullptr;
         m_pManualDiffHelpList = nullptr;
         m_pOptions = nullptr;
         m_fastSelectorLine1 = 0;
         m_fastSelectorNofLines = 0;
         m_bTriple = false;
         m_winIdx = None;
         m_firstLine = 0;
         m_oldFirstLine = 0;
         m_horizScrollOffset = 0;
         m_lineNumberWidth = 0;
         m_maxTextWidth = -1;
         m_pStatusBar = nullptr;
         m_scrollDeltaX = 0;
         m_scrollDeltaY = 0;
         m_bMyUpdate = false;
         m_bSelectionInProgress = false;
         m_pTextCodec = nullptr;
 #if defined(Q_OS_WIN)
         m_eLineEndStyle = eLineEndStyleDos;
 #else
         m_eLineEndStyle = eLineEndStyleUnix;
 #endif
     }
     DiffTextWindow* m_pDiffTextWindow;
     DiffTextWindowFrame* m_pDiffTextWindowFrame = nullptr;
     QTextCodec* m_pTextCodec;
     e_LineEndStyle m_eLineEndStyle;
 
     const QVector<LineData>* m_pLineData;
     int m_size;
     QString m_filename;
     bool m_bWordWrap;
     int m_delayedDrawTimer;
 
     const Diff3LineVector* m_pDiff3LineVector = nullptr;
     Diff3WrapLineVector m_diff3WrapLineVector;
     const ManualDiffHelpList* m_pManualDiffHelpList;
 
     class WrapLineCacheData
     {
       public:
         WrapLineCacheData()  {}
         WrapLineCacheData(int d3LineIdx, int textStart, int textLength)
             : m_d3LineIdx(d3LineIdx), m_textStart(textStart), m_textLength(textLength) {}
         int m_d3LineIdx = 0;
         int m_textStart = 0;
         int m_textLength = 0;
     };
     QList<QVector<WrapLineCacheData>> m_wrapLineCacheList;
 
     QSharedPointer<Options> m_pOptions;
     QColor m_cThis;
     QColor m_cDiff1;
     QColor m_cDiff2;
     QColor m_cDiffBoth;
 
     int m_fastSelectorLine1;
     int m_fastSelectorNofLines;
 
     bool m_bTriple;
     e_SrcSelector m_winIdx;
     int m_firstLine;
     int m_oldFirstLine;
     int m_horizScrollOffset;
     int m_lineNumberWidth;
     QAtomicInt m_maxTextWidth;
 
     void getLineInfo(
         const Diff3Line& d,
         int& lineIdx,
         DiffList*& pFineDiff1, DiffList*& pFineDiff2, // return values
         int& changed, int& changed2);
 
     QString getString(int d3lIdx);
     QString getLineString(int line);
 
     void writeLine(
         RLPainter& p, const LineData* pld,
         const DiffList* pLineDiff1, const DiffList* pLineDiff2, int line,
         int whatChanged, int whatChanged2, int srcLineIdx,
         int wrapLineOffset, int wrapLineLength, bool bWrapLine, const QRect& invalidRect, int deviceWidth);
 
     void draw(RLPainter& p, const QRect& invalidRect, int deviceWidth, int beginLine, int endLine);
 
     QStatusBar* m_pStatusBar;
 
     Selection m_selection;
 
     int m_scrollDeltaX;
     int m_scrollDeltaY;
 
     bool m_bMyUpdate;
     void myUpdate(int afterMilliSecs);
 
     int leftInfoWidth() { return 4 + m_lineNumberWidth; } // Nr of information columns on left side
     int convertLineOnScreenToLineInSource(int lineOnScreen, e_CoordType coordType, bool bFirstLine);
 
     bool m_bSelectionInProgress;
     QPoint m_lastKnownMousePos;
     void prepareTextLayout(QTextLayout& textLayout, bool bFirstLine, int visibleTextWidth = -1);
 };
 
 DiffTextWindow::DiffTextWindow(
     DiffTextWindowFrame* pParent,
     QStatusBar* pStatusBar,
     const QSharedPointer<Options> &pOptions,
     e_SrcSelector winIdx)
     : QWidget(pParent)
 {
     setObjectName(QString("DiffTextWindow%1").arg(winIdx));
     setAttribute(Qt::WA_OpaquePaintEvent);
     //setAttribute( Qt::WA_PaintOnScreen );
     setUpdatesEnabled(false);
 
     d = new DiffTextWindowData(this);
     d->m_pDiffTextWindowFrame = pParent;
     setFocusPolicy(Qt::ClickFocus);
     setAcceptDrops(true);
 
     d->m_pOptions = pOptions;
     init(QString(""), nullptr, d->m_eLineEndStyle, nullptr, 0, nullptr, nullptr, false);
 
     setMinimumSize(QSize(20, 20));
 
     d->m_pStatusBar = pStatusBar;
     setUpdatesEnabled(true);
     d->m_bWordWrap = false;
     d->m_winIdx = winIdx;
 
     setFont(d->m_pOptions->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,
     bool bTriple)
 {
     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_bTriple = bTriple;
     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();
     d->m_pDiffTextWindowFrame->init();
 }
 
 void DiffTextWindow::reset()
 {
     d->m_pLineData = nullptr;
     d->m_size = 0;
     d->m_pDiff3LineVector = nullptr;
     d->m_filename = "";
     d->m_diff3WrapLineVector.clear();
 }
 
 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());
     // TODO: Move this to DiffTextWindow::dropEvent
     // Note that the corresponding drop is handled in KDiff3App::eventFilter().
 }
 
 void DiffTextWindow::setFirstLine(int 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);
     }
     d->m_pDiffTextWindowFrame->setFirstLine(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);
 
     QRect r(xOffset, 0, width() - xOffset, height());
 
     if(d->m_pOptions->m_bRightToLeftLanguage)
     {
         deltaX = -deltaX;
         r = QRect(width() - xOffset - 2, 0, -(width() - xOffset), height()).normalized();
     }
 
     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(deltaX, 0, r);
     }
 }
 
 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, true);
             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 >= 0 && 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)
         {
             emit scrollDiffTextWindow(0, newFirstLine - d->m_firstLine);
         }
 
         update();
     }
 }
 
 void DiffTextWindow::showStatusLine(int line)
 {
     int d3lIdx = convertLineToDiff3LineIdx(line);
     if(d->m_pDiff3LineVector != nullptr && d3lIdx >= 0 && d3lIdx < (int)d->m_pDiff3LineVector->size())
     {
         const Diff3Line* pD3l = (*d->m_pDiff3LineVector)[d3lIdx];
         if(pD3l != nullptr)
         {
             int l = pD3l->getLineInFile(d->m_winIdx);
 
             QString s;
             if(l != -1)
                 s = i18n("File %1: Line %2", d->m_filename, l + 1);
             else
                 s = i18n("File %1: Line not available", d->m_filename);
             if(d->m_pStatusBar != nullptr) d->m_pStatusBar->showMessage(s);
 
             emit lineClicked(d->m_winIdx, l);
         }
     }
 }
 
 void DiffTextWindow::focusInEvent(QFocusEvent* e)
 {
     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->m_pOptions->m_bRightToLeftLanguage && e->x() < xOffset) || (d->m_pOptions->m_bRightToLeftLanguage && e->x() > width() - xOffset))
         {
             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);
         }
     }
 }
 
 bool isCTokenChar(QChar c)
 {
     return (c == '_') ||
            (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') ||
            (c >= '0' && c <= '9');
 }
 
 /// Calculate where a token starts and ends, given the x-position on screen.
 void calcTokenPos(const QString& s, int posOnScreen, int& pos1, int& pos2, int tabSize)
 {
     // Cursor conversions that consider g_tabSize
     int pos = convertToPosInText(s, std::max(0, posOnScreen), tabSize);
     if(pos >= (int)s.length())
     {
         pos1 = s.length();
         pos2 = s.length();
         return;
     }
 
     pos1 = pos;
     pos2 = pos + 1;
 
     if(isCTokenChar(s[pos1]))
     {
         while(pos1 >= 0 && isCTokenChar(s[pos1]))
             --pos1;
         ++pos1;
 
         while(pos2 < (int)s.length() && isCTokenChar(s[pos2]))
             ++pos2;
     }
 }
 
 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 < 0 || 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 < 0 || line >= (int)d->m_pDiff3LineVector->size())
                 return;
             s = d->getString(line);
         }
 
         if(!s.isEmpty())
         {
             int pos1, pos2;
             calcTokenPos(s, pos, pos1, pos2, d->m_pOptions->m_tabSize);
 
             resetSelection();
             d->m_selection.start(line, convertToPosOnScreen(s, pos1, d->m_pOptions->m_tabSize));
             d->m_selection.end(line, convertToPosOnScreen(s, pos2, d->m_pOptions->m_tabSize));
             update();
             // 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())
         {
             emit selectionEnd();
         }
     }
     d->m_scrollDeltaX = 0;
     d->m_scrollDeltaY = 0;
 }
 
 inline int sqr(int x) { return x * x; }
 
 void DiffTextWindow::mouseMoveEvent(QMouseEvent* e)
 {
     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->m_pOptions->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 - sqr(e->y()) / sqr(fm.lineSpacing());
         if(e->y() > height()) deltaY = +1 + sqr(e->y() - height()) / sqr(fm.lineSpacing());
         if((deltaX != 0 && d->m_scrollDeltaX != deltaX) || (deltaY != 0 && d->m_scrollDeltaY != deltaY))
         {
             d->m_scrollDeltaX = deltaX;
             d->m_scrollDeltaY = deltaY;
             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 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() != -1)
         {
             int lastLine;
             int firstLine;
             if(d->m_selection.getOldFirstLine() != -1)
             {
                 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);
         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 >= 0 && (!d->m_pOptions->m_bWordWrap || line < d->m_diff3WrapLineVector.count()))
     {
         QString s = d->getLineString(line);
         QTextLayout textLayout(s, font(), this);
         d->prepareTextLayout(textLayout, !d->m_pOptions->m_bWordWrap || d->m_diff3WrapLineVector[line].wrapLineOffset == 0);
         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, bool /*bFirstLine*/, 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));
 }
 
 void DiffTextWindowData::writeLine(
     RLPainter& p,
     const LineData* pld,
     const DiffList* pLineDiff1,
     const DiffList* pLineDiff2,
     int line,
     int whatChanged,
     int whatChanged2,
     int srcLineIdx,
     int wrapLineOffset,
     int wrapLineLength,
     bool bWrapLine,
     const QRect& invalidRect,
     int deviceWidth)
 {
     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 = leftInfoWidth() * fontWidth - m_horizScrollOffset;
     int yOffset = (line - m_firstLine) * fontHeight;
 
     QRect lineRect(xOffset, yOffset, deviceWidth, fontHeight);
     if(!invalidRect.intersects(lineRect))
     {
         return;
     }
 
     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;
 
     int changed = whatChanged;
     if(pLineDiff1 != nullptr) changed |= 1;
     if(pLineDiff2 != nullptr) changed |= 2;
 
     QColor c = m_pOptions->m_fgColor;
     p.setPen(c);
     if(changed == 2) {
         c = m_cDiff2;
     }
     else if(changed == 1)
     {
         c = m_cDiff1;
     }
     else if(changed == 3)
     {
         c = 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<quint8> 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)
         {
             c = m_pOptions->m_fgColor;
             int cchanged = charChanged[i] | whatChanged;
 
             if(cchanged == 2) {
                 c = m_cDiff2;
             }
             else if(cchanged == 1)
             {
                 c = m_cDiff1;
             }
             else if(cchanged == 3)
             {
                 c = m_cDiffBoth;
             }
 
             if(c != m_pOptions->m_fgColor && whatChanged2 == 0 && !m_pOptions->m_bShowWhiteSpace)
             {
                 // The user doesn't want to see highlighted white space.
                 c = m_pOptions->m_fgColor;
             }
 
             {
                 frh.setBackground(bgColor);
                 if(!m_selection.within(line, outPos))
                 {
 
                     if(c != 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(c);
                     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, !m_bWordWrap || wrapLineOffset == 0);
         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;
             num.sprintf("%0*d", m_lineNumberWidth, srcLineIdx + 1);
             p.drawText(0, yOffset + fontAscent, num);
             //p.drawLine( xLeft -1, yOffset, xLeft -1, yOffset+fontHeight-1 );
         }
         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(c != m_pOptions->m_fgColor && whatChanged2 == 0) //&& whatChanged==0 )
     {
         if(m_pOptions->m_bShowWhiteSpace)
         {
             p.setBrushOrigin(0, 0);
             p.fillRect(xLeft, yOffset, fontWidth * 2 - 1, fontHeight, QBrush(c, Qt::Dense5Pattern));
         }
     }
     else
     {
         p.fillRect(xLeft, yOffset, fontWidth * 2 - 1, fontHeight, c == m_pOptions->m_fgColor ? bgColor : c);
     }
 
     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;
         int rangeLine1 = -1;
         int rangeLine2 = -1;
 
         mdhe.getRangeForUI(m_winIdx, &rangeLine1, &rangeLine2);
         if(rangeLine1 >= 0 && rangeLine2 >= 0 && 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->m_pOptions->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->m_pOptions->m_bRightToLeftLanguage, width(), Utils::getHorizontalAdvance(fontMetrics(), '0'));
 
     p.setFont(font());
     p.QPainter::fillRect(invalidRect, d->m_pOptions->m_bgColor);
 
     d->draw(p, invalidRect, width(), d->m_firstLine, endLine);
     p.end();
 
     d->m_oldFirstLine = d->m_firstLine;
     d->m_selection.clearOldSelection();
 
     if(!bOldSelectionContainsData && d->m_selection.selectionContainsData())
         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->m_pOptions->m_bgColor;
     d->m_pOptions->m_bgColor = Qt::white;
     d->draw(p, invalidRect, p.window().width(), firstLine, std::min(firstLine + nofLinesPerPage, getNofLines()));
     d->m_pOptions->m_bgColor = bgColor;
     d->m_firstLine = oldFirstLine;
 }
 
 void DiffTextWindowData::draw(RLPainter& p, const QRect& invalidRect, int deviceWidth, int beginLine, int endLine)
 {
     m_lineNumberWidth = m_pOptions->m_bShowLineNumbers ? (int)log10((double)std::max(m_size, 1)) + 1 : 0;
 
     if(m_winIdx == A)
     {
         m_cThis = m_pOptions->m_colorA;
         m_cDiff1 = m_pOptions->m_colorB;
         m_cDiff2 = m_pOptions->m_colorC;
     }
     if(m_winIdx == B)
     {
         m_cThis = m_pOptions->m_colorB;
         m_cDiff1 = m_pOptions->m_colorC;
         m_cDiff2 = m_pOptions->m_colorA;
     }
     if(m_winIdx == 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;
         int changed = 0;
         int changed2 = 0;
 
         int srcLineIdx = -1;
         getLineInfo(*d3l, srcLineIdx, pFineDiff1, pFineDiff2, changed, changed2);
 
         writeLine(
             p,                                               // QPainter
             srcLineIdx == -1 ? nullptr : &(*m_pLineData)[srcLineIdx], // Text in this line
             pFineDiff1,
             pFineDiff2,
             line, // Line on the screen
             changed,
             changed2,
             srcLineIdx,
             wrapLineOffset,
             wrapLineLength,
             bWrapLine,
             invalidRect,
             deviceWidth);
     }
 }
 
 QString DiffTextWindowData::getString(int d3lIdx)
 {
     if(d3lIdx < 0 || d3lIdx >= (int)m_pDiff3LineVector->size())
         return QString();
 
     const Diff3Line* d3l = (*m_pDiff3LineVector)[d3lIdx];
     DiffList* pFineDiff1;
     DiffList* pFineDiff2;
     int changed = 0;
     int changed2 = 0;
     int lineIdx = -1;
 
     getLineInfo(*d3l, lineIdx, pFineDiff1, pFineDiff2, changed, changed2);
 
     if(lineIdx == -1)
         return QString();
     else
     {
         const LineData* ld = &(*m_pLineData)[lineIdx];
         return ld->getLine();
     }
     return QString();
 }
 
 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 DiffTextWindowData::getLineInfo(
     const Diff3Line& d3l,
     int& lineIdx,
     DiffList*& pFineDiff1, DiffList*& pFineDiff2, // return values
     int& changed, int& changed2)
 {
     d3l.getLineInfo(m_winIdx, m_bTriple, lineIdx, pFineDiff1, pFineDiff2, changed, changed2);
 }
 
 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())
         emit resizeHeightChangedSignal(visibleLines);
     if(e->size().width() != e->oldSize().width())
         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 >= 1 && d->m_winIdx <= 3);
 
         if(d->m_winIdx == A) {
             lineIdx = d3l->getLineA();
         }
         else if(d->m_winIdx == B)
         {
             lineIdx = d3l->getLineB();
         }
         else if(d->m_winIdx == 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 == A) line = d3l->getLineA();
         if(d->m_winIdx == B) line = d3l->getLineB();
         if(d->m_winIdx == C) line = d3l->getLineC();
         if(line.isValid())
             endPos = (*d->m_pLineData)[line].width(d->m_pOptions->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, convertToPosOnScreen(s1, wrapStartPos, d->m_pOptions->m_tabSize));
         d->m_selection.end(lastWrapLine, convertToPosOnScreen(s2, wrapEndPos, d->m_pOptions->m_tabSize));
         l = firstWrapLine;
         p = wrapStartPos;
     }
     else
     {
         if(d->m_pDiff3LineVector != nullptr){
             d->m_selection.start(firstLine, convertToPosOnScreen(d->getString(firstLine), startPos, d->m_pOptions->m_tabSize));
             d->m_selection.end(lastLine, convertToPosOnScreen(d->getString(lastLine), endPos, d->m_pOptions->m_tabSize));
             l = firstLine;
             p = startPos;
         }
     }
     update();
 }
 
 int DiffTextWindowData::convertLineOnScreenToLineInSource(int lineOnScreen, e_CoordType coordType, bool bFirstLine)
 {
     LineRef line = -1;
     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 < 0 && d3lIdx < m_pDiff3LineVector->size() && d3lIdx >= 0)
         {
             const Diff3Line* d3l = (*m_pDiff3LineVector)[d3lIdx];
             if(m_winIdx == A) line = d3l->getLineA();
             if(m_winIdx == B) line = d3l->getLineB();
             if(m_winIdx == 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 = convertToPosInText(s, d->m_selection.beginPos(), d->m_pOptions->m_tabSize);
     convertLineCoordsToD3LCoords(d->m_selection.beginLine(), firstPosInText, firstD3LIdx, firstD3LPos);
 
     int lastD3LIdx, lastD3LPos;
     s = d->getLineString(d->m_selection.endLine());
     int lastPosInText = convertToPosInText(s, d->m_selection.endPos(), d->m_pOptions->m_tabSize);
     convertLineCoordsToD3LCoords(d->m_selection.endLine(), lastPosInText, lastD3LIdx, lastD3LPos);
 
     d->m_selection.start(firstD3LIdx, firstD3LPos);
     d->m_selection.end(lastD3LIdx, lastD3LPos);
 }
 
 int s_maxNofRunnables = 0;
 
 class RecalcWordWrapRunnable : public QRunnable
 {
     DiffTextWindow* m_pDTW;
     // DiffTextWindowData* m_pDTWData; // TODO unused?
     int m_visibleTextWidth;
     int m_cacheIdx;
 
   public:
     RecalcWordWrapRunnable(DiffTextWindow* p, DiffTextWindowData* pData, int visibleTextWidth, int cacheIdx)
         : m_pDTW(p), /* m_pDTWData(pData),*/ m_visibleTextWidth(visibleTextWidth), m_cacheIdx(cacheIdx)
     {
         Q_UNUSED(pData) // TODO really unused?
         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)
         {
             QWidget* p = m_pDTW;
             while(p)
             {
                 p = p->parentWidget();
                 if(KDiff3App* pKDiff3App = dynamic_cast<KDiff3App*>(p))
                 {
                     QMetaObject::invokeMethod(pKDiff3App, "slotFinishRecalcWordWrap", Qt::QueuedConnection, Q_ARG(int, m_visibleTextWidth));
                     break;
                 }
             }
         }
     }
 };
 
 QList<QRunnable*> s_runnables;
 
 bool startRunnables()
 {
     if(s_runnables.count() == 0)
     {
         return false;
     }
     else
     {
         g_pProgressDialog->setStayHidden(true);
         g_pProgressDialog->push();
         g_pProgressDialog->setMaxNofSteps(s_runnables.count());
         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;
     }
 }
 // Use conexpr when supported. QT
 const int s_linesPerRunnable = 2000;
 
 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->m_pOptions->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)
             //int i=0;
             {
                 d->m_wrapLineCacheList.append(QVector<DiffTextWindowData::WrapLineCacheData>());
                 s_runnables.push_back(new RecalcWordWrapRunnable(this, d, 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, d, 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<DiffTextWindowData::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, true, visibleTextWidth);
                 linesNeeded = textLayout.lineCount();
                 for(int l = 0; l < linesNeeded; ++l)
                 {
                     QTextLine line = textLayout.lineAt(l);
                     wrapLineCache.push_back(DiffTextWindowData::WrapLineCacheData(i, line.textStart(), line.textLength()));
                 }
             }
             else if(wrapLineVectorSize > 0 && cacheListIdx2 < d->m_wrapLineCacheList.count())
             {
                 DiffTextWindowData::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->m_d3LineIdx <= i)
                 {
                     if(pWrapLineCache->m_d3LineIdx == i)
                     {
                         Diff3WrapLine* pDiff3WrapLine = &d->m_diff3WrapLineVector[wrapLineIdx + l];
                         pDiff3WrapLine->wrapLineOffset = pWrapLineCache->m_textStart;
                         pDiff3WrapLine->wrapLineLength = pWrapLineCache->m_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.linesNeededForDisplay = 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;
             d->m_pDiffTextWindowFrame->setFirstLine(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, true);
             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, convertToPosOnScreen(d->getLineString(firstLine), firstPos, d->m_pOptions->m_tabSize));
         d->m_selection.end(lastLine, convertToPosOnScreen(d->getLineString(lastLine), lastPos, d->m_pOptions->m_tabSize));
     }
 }
 
 class DiffTextWindowFrameData
 {
   public:
     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;
 };
 
 DiffTextWindowFrame::DiffTextWindowFrame(QWidget* pParent, QStatusBar* pStatusBar, const QSharedPointer<Options> &pOptions, e_SrcSelector winIdx, SourceData* psd)
     : QWidget(pParent)
 {
     d = new DiffTextWindowFrameData;
     d->m_winIdx = winIdx;
     setAutoFillBackground(true);
     d->m_pOptions = pOptions;
     d->m_pTopLineWidget = new QWidget(this);
     d->m_pFileSelection = new FileNameLineEdit(d->m_pTopLineWidget);
     d->m_pBrowseButton = new QPushButton("...", d->m_pTopLineWidget);
     d->m_pBrowseButton->setFixedWidth(30);
     connect(d->m_pBrowseButton, &QPushButton::clicked, this, &DiffTextWindowFrame::slotBrowseButtonClicked);
     connect(d->m_pFileSelection, &QLineEdit::returnPressed, this, &DiffTextWindowFrame::slotReturnPressed);
 
     d->m_pFileSelection->setAcceptDrops(true);
 
     d->m_pLabel = new QLabel("A:", d->m_pTopLineWidget);
     d->m_pTopLine = new QLabel(d->m_pTopLineWidget);
     d->m_pDiffTextWindow = nullptr;
     d->m_pDiffTextWindow = new DiffTextWindow(this, pStatusBar, pOptions, winIdx);
 
     QVBoxLayout* pVTopLayout = new QVBoxLayout(d->m_pTopLineWidget);
     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(d->m_pLabel, 0);
     pHL->addWidget(d->m_pFileSelection, 1);
     pHL->addWidget(d->m_pBrowseButton, 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:"), this, psd, pOptions);
 
     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(d->m_pTopLineWidget, 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->d->m_filename);
         d->m_pFileSelection->setText(s);
         QString winId = pDTW->d->m_winIdx == A ? (pDTW->d->m_bTriple ? i18n("A (Base)") : i18n("A")) : (pDTW->d->m_winIdx == B ? i18n("B") : i18n("C"));
         d->m_pLabel->setText(winId + ':');
         d->m_pEncoding->setText(i18n("Encoding: %1", pDTW->d->m_pTextCodec != nullptr ? QLatin1String(pDTW->d->m_pTextCodec->name()) : QString()));
         d->m_pLineEndStyle->setText(i18n("Line end style: %1", pDTW->d->m_eLineEndStyle == eLineEndStyleDos ? i18n("DOS") : i18n("Unix")));
     }
 }
 
 // Search for the first visible line (search loop needed when no line exist for this file.)
 int DiffTextWindow::calcTopLineInFile(int firstLine)
 {
     int l = -1;
     for(int i = convertLineToDiff3LineIdx(firstLine); i < (int)d->m_pDiff3LineVector->size(); ++i)
     {
         const Diff3Line* d3l = (*d->m_pDiff3LineVector)[i];
         l = d3l->getLineInFile(d->m_winIdx);
         if(l != -1) break;
     }
     return l;
 }
 
 void DiffTextWindowFrame::setFirstLine(int firstLine)
 {
     DiffTextWindow* pDTW = d->m_pDiffTextWindow;
     if(pDTW && pDTW->d->m_pDiff3LineVector)
     {
         QString s = i18n("Top line");
         int lineNumberWidth = (int)log10((double)std::max(pDTW->d->m_size, 1)) + 1;
 
         int l = pDTW->calcTopLineInFile(firstLine);
 
         int w = Utils::getHorizontalAdvance(d->m_pTopLine->fontMetrics(), s + ' ' + QString().fill('0', lineNumberWidth));
         d->m_pTopLine->setMinimumWidth(w);
 
         if(l == -1)
             s = i18n("End");
         else
             s += ' ' + QString::number(l + 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->m_pOptions->m_bgColor;
         QColor c2;
         if(d->m_winIdx == A)
             c2 = d->m_pOptions->m_colorA;
         else if(d->m_winIdx == B)
             c2 = d->m_pOptions->m_colorB;
         else if(d->m_winIdx == C)
             c2 = d->m_pOptions->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->d->m_filename != d->m_pFileSelection->text())
     {
         emit fileNameChanged(d->m_pFileSelection->text(), pDTW->d->m_winIdx);
     }
 }
 
 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;
         emit fileNameChanged(newURL.url(), pDTW->d->m_winIdx);
     }
 }
 
 void DiffTextWindowFrame::sendEncodingChangedSignal(QTextCodec* c)
 {
     emit encodingChanged(c);
 }
 
 EncodingLabel::EncodingLabel(const QString& text, DiffTextWindowFrame* pDiffTextWindowFrame, SourceData* pSD, const QSharedPointer<Options> &pOptions)
     : QLabel(text)
 {
     m_pDiffTextWindowFrame = pDiffTextWindowFrame;
     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;
             foreach(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"));
         foreach(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)
 {
     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.
         QLatin1String codecName(pCodec->name());
         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::slotEncodingChanged);
         codecEnumList.append(CodecMIBEnum);
     }
 }
 
 void EncodingLabel::slotEncodingChanged()
 {
     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);
             }
         }
         m_pDiffTextWindowFrame->sendEncodingChangedSignal(pCodec);
     }
 }
diff --git a/src/difftextwindow.h b/src/difftextwindow.h
index 3ba67f5..f596bc2 100644
--- a/src/difftextwindow.h
+++ b/src/difftextwindow.h
@@ -1,158 +1,160 @@
 /***************************************************************************
  *   Copyright (C) 2003-2007 by Joachim Eibl                               *
  *   joachim.eibl at gmx.de                                                *
  *   Copyright (C) 2018 Michael Reeves reeves.87@gmail.com                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #ifndef DIFFTEXTWINDOW_H
 #define DIFFTEXTWINDOW_H
 
 #include "diff.h"
 
 #include <QLabel>
+#include <QSharedPointer>  // for QSharedPointer
+#include <QString>         // for QString
 
 class QMenu;
 class QStatusBar;
 class Options;
 class DiffTextWindowData;
 class DiffTextWindowFrame;
 class EncodingLabel;
 class RLPainter;
 
 class DiffTextWindow : public QWidget
 {
     Q_OBJECT
   public:
     DiffTextWindow(DiffTextWindowFrame* pParent, QStatusBar* pStatusBar, 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,
         bool bTriple
         );
     void reset();
     void convertToLinePos(int x, int y, LineRef& line, int& pos);
 
     QString getSelection();
     int getFirstLine();
     int calcTopLineInFile(int 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 print(RLPainter& painter, const QRect& r, int firstLine, int nofLinesPerPage);
   Q_SIGNALS:
     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, int line);
 
   public Q_SLOTS:
     void setFirstLine(int line);
     void setHorizScrollOffset(int horizScrollOffset);
     void resetSelection();
     void setFastSelectorRange(int line1, int nofLines);
 
   protected:
     void mousePressEvent(QMouseEvent*) override;
     void mouseReleaseEvent(QMouseEvent*) override;
     void mouseMoveEvent(QMouseEvent*) override;
     void mouseDoubleClickEvent(QMouseEvent* e) override;
 
     void paintEvent(QPaintEvent*) override;
     void dragEnterEvent(QDragEnterEvent* e) override;
     void focusInEvent(QFocusEvent* e) override;
 
     void resizeEvent(QResizeEvent*) override;
     void timerEvent(QTimerEvent*) override;
 
   private:
     DiffTextWindowData* d;
     void showStatusLine(int line);
     friend class DiffTextWindowFrame;
 };
 
 class DiffTextWindowFrameData;
 
 class DiffTextWindowFrame : public QWidget
 {
     Q_OBJECT
   public:
     DiffTextWindowFrame(QWidget* pParent, QStatusBar* pStatusBar, const QSharedPointer<Options> &pOptions, e_SrcSelector winIdx, SourceData* psd);
     ~DiffTextWindowFrame() override;
     DiffTextWindow* getDiffTextWindow();
     void init();
     void setFirstLine(int firstLine);
     void sendEncodingChangedSignal(QTextCodec* c);
   Q_SIGNALS:
     void fileNameChanged(const QString&, e_SrcSelector);
     void encodingChanged(QTextCodec*);
 
   protected:
     bool eventFilter(QObject*, QEvent*) override;
     //void paintEvent(QPaintEvent*);
   private Q_SLOTS:
     void slotReturnPressed();
     void slotBrowseButtonClicked();
 
   private:
     DiffTextWindowFrameData* d;
 };
 
 class EncodingLabel : public QLabel
 {
     Q_OBJECT
   public:
     EncodingLabel(const QString& text, DiffTextWindowFrame* pDiffTextWindowFrame, SourceData* psd, const QSharedPointer<Options> &pOptions);
 
   protected:
     void mouseMoveEvent(QMouseEvent* ev) override;
     void mousePressEvent(QMouseEvent* ev) override;
   private Q_SLOTS:
     void slotEncodingChanged();
 
   private:
     DiffTextWindowFrame* m_pDiffTextWindowFrame; //To send "EncodingChanged" signal
     QMenu* m_pContextEncodingMenu;
     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);
 };
 
 bool startRunnables();
 
 #endif
diff --git a/src/gnudiff_analyze.cpp b/src/gnudiff_analyze.cpp
index 9f21b07..5a75d88 100644
--- a/src/gnudiff_analyze.cpp
+++ b/src/gnudiff_analyze.cpp
@@ -1,860 +1,861 @@
 /* Analyze file differences for GNU DIFF.
 
    Modified for KDiff3 by Joachim Eibl <joachim.eibl at gmx.de> 2003.
    The original file was part of GNU DIFF.
 
    Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995, 1998, 2001, 2002
    Free Software Foundation, Inc.
 
    GNU DIFF is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2, or (at your option)
    any later version.
 
    GNU DIFF is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; see the file COPYING.
    If not, write to the Free Software Foundation,
    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
 
 /* The basic algorithm is described in:
    "An O(ND) Difference Algorithm and its Variations", Eugene Myers,
    Algorithmica Vol. 1 No. 2, 1986, pp. 251-266;
    see especially section 4.2, which describes the variation used below.
    Unless the --minimal option is specified, this code uses the TOO_EXPENSIVE
    heuristic, by Paul Eggert, to limit the cost to O(N**1.5 log N)
    at the price of producing suboptimal output for large inputs with
    many differences.
 
    The basic algorithm was independently discovered as described in:
    "Algorithms for Approximate String Matching", E. Ukkonen,
    Information and Control Vol. 64, 1985, pp. 100-118.  */
 
 #define GDIFF_MAIN
 
-#include "common.h"
 #include "gnudiff_diff.h"
-//#include <error.h>
+
+#include <algorithm>       // for max, min
 #include <stdlib.h>
 
+
 static GNULineRef *xvec, *yvec;  /* Vectors being compared. */
 static GNULineRef *fdiag;        /* Vector, indexed by diagonal, containing
                    1 + the X coordinate of the point furthest
                    along the given diagonal in the forward
                    search of the edit matrix. */
 static GNULineRef *bdiag;        /* Vector, indexed by diagonal, containing
                    the X coordinate of the point furthest
                    along the given diagonal in the backward
                    search of the edit matrix. */
 static GNULineRef too_expensive; /* Edit scripts longer than this are too
                    expensive to compute.  */
 
 #define SNAKE_LIMIT 20 /* Snakes bigger than this are considered `big'.  */
 
 struct partition {
     GNULineRef xmid, ymid; /* Midpoints of this partition.  */
     bool lo_minimal;       /* Nonzero if low half will be analyzed minimally.  */
     bool hi_minimal;       /* Likewise for high half.  */
 };
 
 /* Find the midpoint of the shortest edit script for a specified
    portion of the two files.
 
    Scan from the beginnings of the files, and simultaneously from the ends,
    doing a breadth-first search through the space of edit-sequence.
    When the two searches meet, we have found the midpoint of the shortest
    edit sequence.
 
    If FIND_MINIMAL is nonzero, find the minimal edit script regardless
    of expense.  Otherwise, if the search is too expensive, use
    heuristics to stop the search and report a suboptimal answer.
 
    Set PART->(xmid,ymid) to the midpoint (XMID,YMID).  The diagonal number
    XMID - YMID equals the number of inserted lines minus the number
    of deleted lines (counting only lines before the midpoint).
    Return the approximate edit cost; this is the total number of
    lines inserted or deleted (counting only lines before the midpoint),
    unless a heuristic is used to terminate the search prematurely.
 
    Set PART->lo_minimal to true iff the minimal edit script for the
    left half of the partition is known; similarly for PART->hi_minimal.
 
    This function assumes that the first lines of the specified portions
    of the two files do not match, and likewise that the last lines do not
    match.  The caller must trim matching lines from the beginning and end
    of the portions it is going to specify.
 
    If we return the "wrong" partitions,
    the worst this can do is cause suboptimal diff output.
    It cannot cause incorrect diff output.  */
 
 GNULineRef GnuDiff::diag(GNULineRef xoff, GNULineRef xlim, GNULineRef yoff, GNULineRef ylim, bool find_minimal,
                          partition *part)
 {
     GNULineRef *const fd = fdiag;        /* Give the compiler a chance. */
     GNULineRef *const bd = bdiag;        /* Additional help for the compiler. */
     GNULineRef const *const xv = xvec;   /* Still more help for the compiler. */
     GNULineRef const *const yv = yvec;   /* And more and more . . . */
     GNULineRef const dmin = xoff - ylim; /* Minimum valid diagonal. */
     GNULineRef const dmax = xlim - yoff; /* Maximum valid diagonal. */
     GNULineRef const fmid = xoff - yoff; /* Center diagonal of top-down search. */
     GNULineRef const bmid = xlim - ylim; /* Center diagonal of bottom-up search. */
     GNULineRef fmin = fmid, fmax = fmid; /* Limits of top-down search. */
     GNULineRef bmin = bmid, bmax = bmid; /* Limits of bottom-up search. */
     GNULineRef c;                        /* Cost. */
     bool odd = (fmid - bmid) & 1;        /* True if southeast corner is on an odd
                    diagonal with respect to the northwest. */
 
     fd[fmid] = xoff;
     bd[bmid] = xlim;
 
     for(c = 1;; ++c)
     {
         GNULineRef d; /* Active diagonal. */
         bool big_snake = false;
 
         /* Extend the top-down search by an edit step in each diagonal. */
         fmin > dmin ? fd[--fmin - 1] = -1 : ++fmin;
         fmax < dmax ? fd[++fmax + 1] = -1 : --fmax;
         for(d = fmax; d >= fmin; d -= 2)
         {
             GNULineRef x, y, oldx, tlo = fd[d - 1], thi = fd[d + 1];
 
             if(tlo >= thi)
                 x = tlo + 1;
             else
                 x = thi;
             oldx = x;
             y = x - d;
             while(x < xlim && y < ylim && xv[x] == yv[y])
                 ++x, ++y;
             if(x - oldx > SNAKE_LIMIT)
                 big_snake = true;
             fd[d] = x;
             if(odd && bmin <= d && d <= bmax && bd[d] <= x)
             {
                 part->xmid = x;
                 part->ymid = y;
                 part->lo_minimal = part->hi_minimal = true;
                 return 2 * c - 1;
             }
         }
 
         /* Similarly extend the bottom-up search.  */
         bmin > dmin ? bd[--bmin - 1] = GNULINEREF_MAX : ++bmin;
         bmax < dmax ? bd[++bmax + 1] = GNULINEREF_MAX : --bmax;
         for(d = bmax; d >= bmin; d -= 2)
         {
             GNULineRef x, y, oldx, tlo = bd[d - 1], thi = bd[d + 1];
 
             if(tlo < thi)
                 x = tlo;
             else
                 x = thi - 1;
             oldx = x;
             y = x - d;
             while(x > xoff && y > yoff && xv[x - 1] == yv[y - 1])
                 --x, --y;
             if(oldx - x > SNAKE_LIMIT)
                 big_snake = true;
             bd[d] = x;
             if(!odd && fmin <= d && d <= fmax && x <= fd[d])
             {
                 part->xmid = x;
                 part->ymid = y;
                 part->lo_minimal = part->hi_minimal = true;
                 return 2 * c;
             }
         }
 
         if(find_minimal)
             continue;
 
         /* Heuristic: check occasionally for a diagonal that has made
      lots of progress compared with the edit distance.
      If we have any such, find the one that has made the most
      progress and return it as if it had succeeded.
 
      With this heuristic, for files with a constant small density
      of changes, the algorithm is linear in the file size.  */
 
         if(200 < c && big_snake && speed_large_files)
         {
             GNULineRef best;
 
             best = 0;
             for(d = fmax; d >= fmin; d -= 2)
             {
                 GNULineRef dd = d - fmid;
                 GNULineRef x = fd[d];
                 GNULineRef y = x - d;
                 GNULineRef v = (x - xoff) * 2 - dd;
                 if(v > 12 * (c + (dd < 0 ? -dd : dd)))
                 {
                     if(v > best && xoff + SNAKE_LIMIT <= x && x < xlim && yoff + SNAKE_LIMIT <= y && y < ylim)
                     {
                         /* We have a good enough best diagonal;
              now insist that it end with a significant snake.  */
                         int k;
 
                         for(k = 1; xv[x - k] == yv[y - k]; k++)
                             if(k == SNAKE_LIMIT)
                             {
                                 best = v;
                                 part->xmid = x;
                                 part->ymid = y;
                                 break;
                             }
                     }
                 }
             }
             if(best > 0)
             {
                 part->lo_minimal = true;
                 part->hi_minimal = false;
                 return 2 * c - 1;
             }
 
             best = 0;
             for(d = bmax; d >= bmin; d -= 2)
             {
                 GNULineRef dd = d - bmid;
                 GNULineRef x = bd[d];
                 GNULineRef y = x - d;
                 GNULineRef v = (xlim - x) * 2 + dd;
                 if(v > 12 * (c + (dd < 0 ? -dd : dd)))
                 {
                     if(v > best && xoff < x && x <= xlim - SNAKE_LIMIT && yoff < y && y <= ylim - SNAKE_LIMIT)
                     {
                         /* We have a good enough best diagonal;
              now insist that it end with a significant snake.  */
                         int k;
 
                         for(k = 0; xv[x + k] == yv[y + k]; k++)
                             if(k == SNAKE_LIMIT - 1)
                             {
                                 best = v;
                                 part->xmid = x;
                                 part->ymid = y;
                                 break;
                             }
                     }
                 }
             }
             if(best > 0)
             {
                 part->lo_minimal = false;
                 part->hi_minimal = true;
                 return 2 * c - 1;
             }
         }
 
         /* Heuristic: if we've gone well beyond the call of duty,
      give up and report halfway between our best results so far.  */
         if(c >= too_expensive)
         {
             GNULineRef fxybest, fxbest;
             GNULineRef bxybest, bxbest;
 
             fxbest = bxbest = 0; /* Pacify `gcc -Wall'.  */
 
             /* Find forward diagonal that maximizes X + Y.  */
             fxybest = -1;
             for(d = fmax; d >= fmin; d -= 2)
             {
                 GNULineRef x = std::min(fd[d], xlim);
                 GNULineRef y = x - d;
                 if(ylim < y)
                     x = ylim + d, y = ylim;
                 if(fxybest < x + y)
                 {
                     fxybest = x + y;
                     fxbest = x;
                 }
             }
 
             /* Find backward diagonal that minimizes X + Y.  */
             bxybest = GNULINEREF_MAX;
             for(d = bmax; d >= bmin; d -= 2)
             {
                 GNULineRef x = std::max(xoff, bd[d]);
                 GNULineRef y = x - d;
                 if(y < yoff)
                     x = yoff + d, y = yoff;
                 if(x + y < bxybest)
                 {
                     bxybest = x + y;
                     bxbest = x;
                 }
             }
 
             /* Use the better of the two diagonals.  */
             if((xlim + ylim) - bxybest < fxybest - (xoff + yoff))
             {
                 part->xmid = fxbest;
                 part->ymid = fxybest - fxbest;
                 part->lo_minimal = true;
                 part->hi_minimal = false;
             }
             else
             {
                 part->xmid = bxbest;
                 part->ymid = bxybest - bxbest;
                 part->lo_minimal = false;
                 part->hi_minimal = true;
             }
             return 2 * c - 1;
         }
     }
 }
 
 /* Compare in detail contiguous subsequences of the two files
    which are known, as a whole, to match each other.
 
    The results are recorded in the vectors files[N].changed, by
    storing 1 in the element for each line that is an insertion or deletion.
 
    The subsequence of file 0 is [XOFF, XLIM) and likewise for file 1.
 
    Note that XLIM, YLIM are exclusive bounds.
    All line numbers are origin-0 and discarded lines are not counted.
 
    If FIND_MINIMAL, find a minimal difference no matter how
    expensive it is.  */
 
 void GnuDiff::compareseq(GNULineRef xoff, GNULineRef xlim, GNULineRef yoff, GNULineRef ylim, bool find_minimal)
 {
     GNULineRef *const xv = xvec; /* Help the compiler.  */
     GNULineRef *const yv = yvec;
 
     /* Slide down the bottom initial diagonal. */
     while(xoff < xlim && yoff < ylim && xv[xoff] == yv[yoff])
         ++xoff, ++yoff;
     /* Slide up the top initial diagonal. */
     while(xlim > xoff && ylim > yoff && xv[xlim - 1] == yv[ylim - 1])
         --xlim, --ylim;
 
     /* Handle simple cases. */
     if(xoff == xlim)
         while(yoff < ylim)
             files[1].changed[files[1].realindexes[yoff++]] = true;
     else if(yoff == ylim)
         while(xoff < xlim)
             files[0].changed[files[0].realindexes[xoff++]] = true;
     else
     {
         GNULineRef c;
         partition part;
 
         /* Find a point of correspondence in the middle of the files.  */
 
         c = diag(xoff, xlim, yoff, ylim, find_minimal, &part);
 
         if(c == 1)
         {
             /* This should be impossible, because it implies that
          one of the two subsequences is empty,
          and that case was handled above without calling `diag'.
          Let's verify that this is true.  */
             abort();
 #if 0
       /* The two subsequences differ by a single insert or delete;
          record it and we are done.  */
       if (part.xmid - part.ymid < xoff - yoff)
         files[1].changed[files[1].realindexes[part.ymid - 1]] = 1;
       else
         files[0].changed[files[0].realindexes[part.xmid]] = 1;
 #endif
         }
         else
         {
             /* Use the partitions to split this problem into subproblems.  */
             compareseq(xoff, part.xmid, yoff, part.ymid, part.lo_minimal);
             compareseq(part.xmid, xlim, part.ymid, ylim, part.hi_minimal);
         }
     }
 }
 
 /* Discard lines from one file that have no matches in the other file.
 
    A line which is discarded will not be considered by the actual
    comparison algorithm; it will be as if that line were not in the file.
    The file's `realindexes' table maps virtual line numbers
    (which don't count the discarded lines) into real line numbers;
    this is how the actual comparison algorithm produces results
    that are comprehensible when the discarded lines are counted.
 
    When we discard a line, we also mark it as a deletion or insertion
    so that it will be printed in the output.  */
 
 void GnuDiff::discard_confusing_lines(file_data filevec[])
 {
     int f;
     GNULineRef i;
     char *discarded[2];
     GNULineRef *equiv_count[2];
     GNULineRef *p;
 
     /* Allocate our results.  */
     p = (GNULineRef *)xmalloc((filevec[0].buffered_lines + filevec[1].buffered_lines) * (2 * sizeof *p));
     for(f = 0; f < 2; ++f)
     {
         filevec[f].undiscarded = p;
         p += filevec[f].buffered_lines;
         filevec[f].realindexes = p;
         p += filevec[f].buffered_lines;
     }
 
     /* Set up equiv_count[F][I] as the number of lines in file F
      that fall in equivalence class I.  */
 
     p = (GNULineRef *)zalloc(filevec[0].equiv_max * (2 * sizeof *p));
     equiv_count[0] = p;
     equiv_count[1] = p + filevec[0].equiv_max;
 
     for(i = 0; i < filevec[0].buffered_lines; ++i)
         ++equiv_count[0][filevec[0].equivs[i]];
     for(i = 0; i < filevec[1].buffered_lines; ++i)
         ++equiv_count[1][filevec[1].equivs[i]];
 
     /* Set up tables of which lines are going to be discarded.  */
 
     discarded[0] = (char *)zalloc(filevec[0].buffered_lines + filevec[1].buffered_lines);
     discarded[1] = discarded[0] + filevec[0].buffered_lines;
 
     /* Mark to be discarded each line that matches no line of the other file.
      If a line matches many lines, mark it as provisionally discardable.  */
 
     for(f = 0; f < 2; ++f)
     {
         size_t end = filevec[f].buffered_lines;
         char *discards = discarded[f];
         GNULineRef *counts = equiv_count[1 - f];
         GNULineRef *equivs = filevec[f].equivs;
         size_t many = 5;
         size_t tem = end / 64;
 
         /* Multiply MANY by approximate square root of number of lines.
      That is the threshold for provisionally discardable lines.  */
         while((tem = tem >> 2) > 0)
             many *= 2;
 
         for(i = 0; i < (GNULineRef)end; ++i)
         {
             GNULineRef nmatch;
             if(equivs[i] == 0)
                 continue;
             nmatch = counts[equivs[i]];
             if(nmatch == 0)
                 discards[i] = 1;
             else if(nmatch > (GNULineRef)many)
                 discards[i] = 2;
         }
     }
 
     /* Don't really discard the provisional lines except when they occur
      in a run of discardables, with nonprovisionals at the beginning
      and end.  */
 
     for(f = 0; f < 2; ++f)
     {
         GNULineRef end = filevec[f].buffered_lines;
         char *discards = discarded[f];
 
         for(i = 0; i < end; ++i)
         {
             /* Cancel provisional discards not in middle of run of discards.  */
             if(discards[i] == 2)
                 discards[i] = 0;
             else if(discards[i] != 0)
             {
                 /* We have found a nonprovisional discard.  */
                 GNULineRef j;
                 GNULineRef length;
                 GNULineRef provisional = 0;
 
                 /* Find end of this run of discardable lines.
          Count how many are provisionally discardable.  */
                 for(j = i; j < end; ++j)
                 {
                     if(discards[j] == 0)
                         break;
                     if(discards[j] == 2)
                         ++provisional;
                 }
 
                 /* Cancel provisional discards at end, and shrink the run.  */
                 while(j > i && discards[j - 1] == 2)
                     discards[--j] = 0, --provisional;
 
                 /* Now we have the length of a run of discardable lines
          whose first and last are not provisional.  */
                 length = j - i;
 
                 /* If 1/4 of the lines in the run are provisional,
          cancel discarding of all provisional lines in the run.  */
                 if(provisional * 4 > length)
                 {
                     while(j > i)
                         if(discards[--j] == 2)
                             discards[j] = 0;
                 }
                 else
                 {
                     GNULineRef consec;
                     GNULineRef minimum = 1;
                     GNULineRef tem = length >> 2;
 
                     /* MINIMUM is approximate square root of LENGTH/4.
              A subrun of two or more provisionals can stand
              when LENGTH is at least 16.
              A subrun of 4 or more can stand when LENGTH >= 64.  */
                     while(0 < (tem >>= 2))
                         minimum <<= 1;
                     minimum++;
 
                     /* Cancel any subrun of MINIMUM or more provisionals
              within the larger run.  */
                     for(j = 0, consec = 0; j < length; ++j)
                         if(discards[i + j] != 2)
                             consec = 0;
                         else if(minimum == ++consec)
                             /* Back up to start of subrun, to cancel it all.  */
                             j -= consec;
                         else if(minimum < consec)
                             discards[i + j] = 0;
 
                     /* Scan from beginning of run
              until we find 3 or more nonprovisionals in a row
              or until the first nonprovisional at least 8 lines in.
              Until that point, cancel any provisionals.  */
                     for(j = 0, consec = 0; j < length; ++j)
                     {
                         if(j >= 8 && discards[i + j] == 1)
                             break;
                         if(discards[i + j] == 2)
                             consec = 0, discards[i + j] = 0;
                         else if(discards[i + j] == 0)
                             consec = 0;
                         else
                             consec++;
                         if(consec == 3)
                             break;
                     }
 
                     /* I advances to the last line of the run.  */
                     i += length - 1;
 
                     /* Same thing, from end.  */
                     for(j = 0, consec = 0; j < length; ++j)
                     {
                         if(j >= 8 && discards[i - j] == 1)
                             break;
                         if(discards[i - j] == 2)
                             consec = 0, discards[i - j] = 0;
                         else if(discards[i - j] == 0)
                             consec = 0;
                         else
                             consec++;
                         if(consec == 3)
                             break;
                     }
                 }
             }
         }
     }
 
     /* Actually discard the lines. */
     for(f = 0; f < 2; ++f)
     {
         char *discards = discarded[f];
         GNULineRef end = filevec[f].buffered_lines;
         GNULineRef j = 0;
         for(i = 0; i < end; ++i)
             if(minimal || discards[i] == 0)
             {
                 filevec[f].undiscarded[j] = filevec[f].equivs[i];
                 filevec[f].realindexes[j++] = i;
             }
             else
                 filevec[f].changed[i] = true;
         filevec[f].nondiscarded_lines = j;
     }
 
     free(discarded[0]);
     free(equiv_count[0]);
 }
 
 /* Adjust inserts/deletes of identical lines to join changes
    as much as possible.
 
    We do something when a run of changed lines include a
    line at one end and have an excluded, identical line at the other.
    We are free to choose which identical line is included.
    `compareseq' usually chooses the one at the beginning,
    but usually it is cleaner to consider the following identical line
    to be the "change".  */
 
 void GnuDiff::shift_boundaries(file_data filevec[])
 {
     int f;
 
     for(f = 0; f < 2; ++f)
     {
         bool *changed = filevec[f].changed;
         bool const *other_changed = filevec[1 - f].changed;
         GNULineRef const *equivs = filevec[f].equivs;
         GNULineRef i = 0;
         GNULineRef j = 0;
         GNULineRef i_end = filevec[f].buffered_lines;
 
         while(true)
         {
             GNULineRef runlength, start, corresponding;
 
             /* Scan forwards to find beginning of another run of changes.
          Also keep track of the corresponding point in the other file.  */
 
             while(i < i_end && !changed[i])
             {
                 while(other_changed[j++])
                     continue;
                 i++;
             }
 
             if(i == i_end)
                 break;
 
             start = i;
 
             /* Find the end of this run of changes.  */
 
             while(changed[++i])
                 continue;
             while(other_changed[j])
                 j++;
 
             do
             {
                 /* Record the length of this run of changes, so that
          we can later determine whether the run has grown.  */
                 runlength = i - start;
 
                 /* Move the changed region back, so long as the
          previous unchanged line matches the last changed one.
          This merges with previous changed regions.  */
 
                 while(start && equivs[start - 1] == equivs[i - 1])
                 {
                     changed[--start] = true;
                     changed[--i] = false;
                     while(changed[start - 1])
                         start--;
                     while(other_changed[--j])
                         continue;
                 }
 
                 /* Set CORRESPONDING to the end of the changed run, at the last
          point where it corresponds to a changed run in the other file.
          CORRESPONDING == I_END means no such point has been found.  */
                 corresponding = other_changed[j - 1] ? i : i_end;
 
                 /* Move the changed region forward, so long as the
          first changed line matches the following unchanged one.
          This merges with following changed regions.
          Do this second, so that if there are no merges,
          the changed region is moved forward as far as possible.  */
 
                 while(i != i_end && equivs[start] == equivs[i])
                 {
                     changed[start++] = false;
                     changed[i++] = true;
                     while(changed[i])
                         i++;
                     while(other_changed[++j])
                         corresponding = i;
                 }
             } while(runlength != i - start);
 
             /* If possible, move the fully-merged run of changes
          back to a corresponding run in the other file.  */
 
             while(corresponding < i)
             {
                 changed[--start] = true;
                 changed[--i] = false;
                 while(other_changed[--j])
                     continue;
             }
         }
     }
 }
 
 /* Cons an additional entry onto the front of an edit script OLD.
    LINE0 and LINE1 are the first affected lines in the two files (origin 0).
    DELETED is the number of lines deleted here from file 0.
    INSERTED is the number of lines inserted here in file 1.
 
    If DELETED is 0 then LINE0 is the number of the line before
    which the insertion was done; vice versa for INSERTED and LINE1.  */
 
 GnuDiff::change *GnuDiff::add_change(GNULineRef line0, GNULineRef line1, GNULineRef deleted, GNULineRef inserted, change *old)
 {
     change *newChange = (change *)xmalloc(sizeof *newChange);
 
     newChange->line0 = line0;
     newChange->line1 = line1;
     newChange->inserted = inserted;
     newChange->deleted = deleted;
     newChange->link = old;
     return newChange;
 }
 
 /* Scan the tables of which lines are inserted and deleted,
    producing an edit script in reverse order.  */
 
 GnuDiff::change *GnuDiff::build_reverse_script(file_data const filevec[])
 {
     change *script = nullptr;
     bool *changed0 = filevec[0].changed;
     bool *changed1 = filevec[1].changed;
     GNULineRef len0 = filevec[0].buffered_lines;
     GNULineRef len1 = filevec[1].buffered_lines;
 
     /* Note that changedN[len0] does exist, and is 0.  */
 
     GNULineRef i0 = 0, i1 = 0;
 
     while(i0 < len0 || i1 < len1)
     {
         if(changed0[i0] | changed1[i1])
         {
             GNULineRef line0 = i0, line1 = i1;
 
             /* Find # lines changed here in each file.  */
             while(changed0[i0]) ++i0;
             while(changed1[i1]) ++i1;
 
             /* Record this change.  */
             script = add_change(line0, line1, i0 - line0, i1 - line1, script);
         }
 
         /* We have reached lines in the two files that match each other.  */
         i0++, i1++;
     }
 
     return script;
 }
 
 /* Scan the tables of which lines are inserted and deleted,
    producing an edit script in forward order.  */
 
 GnuDiff::change *GnuDiff::build_script(file_data const filevec[])
 {
     change *script = nullptr;
     bool *changed0 = filevec[0].changed;
     bool *changed1 = filevec[1].changed;
     GNULineRef i0 = filevec[0].buffered_lines, i1 = filevec[1].buffered_lines;
 
     /* Note that changedN[-1] does exist, and is 0.  */
 
     while(i0 >= 0 || i1 >= 0)
     {
         if(changed0[i0 - 1] | changed1[i1 - 1])
         {
             GNULineRef line0 = i0, line1 = i1;
 
             /* Find # lines changed here in each file.  */
             while(changed0[i0 - 1]) --i0;
             while(changed1[i1 - 1]) --i1;
 
             /* Record this change.  */
             script = add_change(i0, i1, line0 - i0, line1 - i1, script);
         }
 
         /* We have reached lines in the two files that match each other.  */
         i0--, i1--;
     }
 
     return script;
 }
 
 /* Report the differences of two files.  */
 GnuDiff::change *GnuDiff::diff_2_files(comparison *cmp)
 {
     GNULineRef diags;
     int f;
     change *script;
 
     read_files(cmp->file, files_can_be_treated_as_binary);
 
     {
         /* Allocate vectors for the results of comparison:
      a flag for each line of each file, saying whether that line
      is an insertion or deletion.
      Allocate an extra element, always 0, at each end of each vector.  */
 
         size_t s = cmp->file[0].buffered_lines + cmp->file[1].buffered_lines + 4;
         bool *flag_space = (bool *)zalloc(s * sizeof(*flag_space));
         cmp->file[0].changed = flag_space + 1;
         cmp->file[1].changed = flag_space + cmp->file[0].buffered_lines + 3;
 
         /* Some lines are obviously insertions or deletions
      because they don't match anything.  Detect them now, and
      avoid even thinking about them in the main comparison algorithm.  */
 
         discard_confusing_lines(cmp->file);
 
         /* Now do the main comparison algorithm, considering just the
      undiscarded lines.  */
 
         xvec = cmp->file[0].undiscarded;
         yvec = cmp->file[1].undiscarded;
         diags = (cmp->file[0].nondiscarded_lines + cmp->file[1].nondiscarded_lines + 3);
         fdiag = (GNULineRef *)xmalloc(diags * (2 * sizeof *fdiag));
         bdiag = fdiag + diags;
         fdiag += cmp->file[1].nondiscarded_lines + 1;
         bdiag += cmp->file[1].nondiscarded_lines + 1;
 
         /* Set TOO_EXPENSIVE to be approximate square root of input size,
      bounded below by 256.  */
         too_expensive = 1;
         for(; diags != 0; diags >>= 2)
             too_expensive <<= 1;
         too_expensive = std::max((GNULineRef)256, too_expensive);
 
         files[0] = cmp->file[0];
         files[1] = cmp->file[1];
 
         compareseq(0, cmp->file[0].nondiscarded_lines,
                    0, cmp->file[1].nondiscarded_lines, minimal);
 
         free(fdiag - (cmp->file[1].nondiscarded_lines + 1));
 
         /* Modify the results slightly to make them prettier
      in cases where that can validly be done.  */
 
         shift_boundaries(cmp->file);
 
         /* Get the results of comparison in the form of a chain
          of `change's -- an edit script.  */
 
         script = build_script(cmp->file);
 
         free(cmp->file[0].undiscarded);
 
         free(flag_space);
 
         for(f = 0; f < 2; ++f)
         {
             free(cmp->file[f].equivs);
             free(cmp->file[f].linbuf + cmp->file[f].linbuf_base);
         }
     }
 
     return script;
 }
diff --git a/src/gnudiff_xmalloc.cpp b/src/gnudiff_xmalloc.cpp
index 1021363..cfc0a8e 100644
--- a/src/gnudiff_xmalloc.cpp
+++ b/src/gnudiff_xmalloc.cpp
@@ -1,79 +1,77 @@
 /* xmalloc.c -- malloc with out of memory checking
 
    Modified for KDiff3 by Joachim Eibl 2003.
    The original file was part of GNU DIFF.
 
    Copyright (C) 1990-1999, 2000, 2002 Free Software Foundation, Inc.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2, or (at your option)
    any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software Foundation,
    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
 
-#include <sys/types.h>
-
 #include <stdlib.h>
 #include <string.h>
 
 #ifndef EXIT_FAILURE
 #define EXIT_FAILURE 1
 #endif
 
 #include "gnudiff_diff.h"
 /* If non NULL, call this function when memory is exhausted. */
 void (*xalloc_fail_func)() = nullptr;
 
 void GnuDiff::xalloc_die()
 {
     if(xalloc_fail_func)
         (*xalloc_fail_func)();
     //error (exit_failure, 0, "%s", _(xalloc_msg_memory_exhausted));
     /* The `noreturn' cannot be given to error, since it may return if
      its first argument is 0.  To help compilers understand the
      xalloc_die does terminate, call exit. */
     exit(EXIT_FAILURE);
 }
 
 /* Allocate N bytes of memory dynamically, with error checking.  */
 
 void *
 GnuDiff::xmalloc(size_t n)
 {
     void *p;
 
     p = malloc(n == 0 ? 1 : n); // There are systems where malloc returns 0 for n==0.
     if(p == nullptr)
         xalloc_die();
     return p;
 }
 
 /* Change the size of an allocated block of memory P to N bytes,
    with error checking.  */
 
 void *
 GnuDiff::xrealloc(void *p, size_t n)
 {
     p = realloc(p, n == 0 ? 1 : n);
     if(p == nullptr)
         xalloc_die();
     return p;
 }
 
 /* Yield a new block of SIZE bytes, initialized to zero.  */
 
 void *
 GnuDiff::zalloc(size_t size)
 {
     void *p = xmalloc(size);
     memset(p, 0, size);
     return p;
 }
diff --git a/src/kdiff3.cpp b/src/kdiff3.cpp
index 9844f84..4f7f10b 100644
--- a/src/kdiff3.cpp
+++ b/src/kdiff3.cpp
@@ -1,1079 +1,1080 @@
 /***************************************************************************
  *   Copyright (C) 2003-2007 by Joachim Eibl <joachim.eibl at gmx.de>      *
  *   Copyright (C) 2018 Michael Reeves reeves.87@gmail.com                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 // 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>
 
 
 
 #define ID_STATUS_MSG 1
 #define MAIN_TOOLBAR_NAME QLatin1String("mainToolBar")
 
 void printDiffTextWindow(RLPainter& painter, const QRect& view, const QString& headerText, DiffTextWindow* pDiffTextWindow, int line, int linesPerPage, const QColor& fgColor);
 KActionCollection* KDiff3App::actionCollection()
 {
     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;
 }
 
 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");
 #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 = FileAccess(m_sd1.getFilename()).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());
     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->m_bWordWrap);
     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, this);
     m_pDirectoryMergeSplitter->addWidget(m_pDirectoryMergeWindow);
     m_pDirectoryMergeInfo = new DirectoryMergeInfo(m_pDirectoryMergeSplitter);
     m_pDirectoryMergeWindow->setDirectoryMergeInfo(m_pDirectoryMergeInfo);
     m_pDirectoryMergeSplitter->addWidget(m_pDirectoryMergeInfo);
 
     connect(m_pDirectoryMergeWindow, &DirectoryMergeWindow::startDiffMerge, this, &KDiff3App::slotFileOpen2);
     connect(m_pDirectoryMergeWindow->selectionModel(), &QItemSelectionModel::selectionChanged, this, &KDiff3App::slotUpdateAvailabilities);
     connect(m_pDirectoryMergeWindow->selectionModel(), &QItemSelectionModel::currentChanged, this, &KDiff3App::slotUpdateAvailabilities);
     connect(m_pDirectoryMergeWindow, &DirectoryMergeWindow::checkIfCanContinue, this, &KDiff3App::slotCheckIfCanContinue);
     connect(m_pDirectoryMergeWindow, static_cast<void (DirectoryMergeWindow::*) (void)>(&DirectoryMergeWindow::updateAvailabilities), this, &KDiff3App::slotUpdateAvailabilities);
     connect(m_pDirectoryMergeWindow, &DirectoryMergeWindow::statusBarMessage, this, &KDiff3App::slotStatusMsg);
     connect(QApplication::clipboard(), &QClipboard::dataChanged, this, &KDiff3App::slotClipboardChanged);
     m_pDirectoryMergeWindow->initDirectoryMergeActions(this, actionCollection());
 
     delete KDiff3Shell::getParser();
 
     if(m_pKDiff3Shell == nullptr) {
         completeInit(QString());
     }
 }
 
 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);
     }
     if(!fn2.isEmpty()) {
         m_sd2.setFilename(fn2);
     }
     if(!fn3.isEmpty()) {
         m_sd3.setFilename(fn3);
     }
 
     //should not happen now.
     Q_ASSERT(m_bDirCompare == FileAccess(m_sd1.getFilename()).isDir());
     bool bSuccess = improveFilenames(false);
 
     if(m_bAutoFlag && m_bAutoMode && m_bDirCompare)
     {
         QTextStream(stderr) << i18n("Option --auto ignored for directory comparison.") << "\n";
         m_bAutoMode = false;
     }
     if(!m_bDirCompare)
     {
         m_pDirectoryMergeSplitter->hide();
 
         mainInit();
         if(m_bAutoMode)
         {
             SourceData* pSD = nullptr;
             if(m_sd3.isEmpty()) {
                 if(m_totalDiffStatus.isBinaryEqualAB()) {
                     pSD = &m_sd1;
                 }
             }
             else
             {
                 if(m_totalDiffStatus.isBinaryEqualBC()) {
                     pSD = &m_sd3; // B==C (assume A is old)
                 }
                 else if(m_totalDiffStatus.isBinaryEqualAB())
                 {
                     pSD = &m_sd3; // assuming C has changed
                 }
                 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"));
     editCut->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"
 
     goCurrent = 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");
 
     goTop = GuiUtils::createAction<QAction>(i18n("Go to First Delta"), QIcon(QPixmap(upend)), i18n("First\nDelta"), this, &KDiff3App::slotGoTop, ac, "go_top");
 
     goBottom = 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.)");
     goPrevDelta = 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");
     goPrevDelta->setToolTip(goPrevDelta->text() + omitsWhitespace);
     goNextDelta = 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");
     goNextDelta->setToolTip(goNextDelta->text() + omitsWhitespace);
     goPrevConflict = 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");
     goPrevConflict->setToolTip(goPrevConflict->text() + omitsWhitespace);
     goNextConflict = 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");
     goNextConflict->setToolTip(goNextConflict->text() + omitsWhitespace);
     goPrevUnsolvedConflict = GuiUtils::createAction<QAction>(i18n("Go to Previous Unsolved Conflict"), QIcon(QPixmap(prevunsolved)), i18n("Prev\nUnsolved"), this, &KDiff3App::slotGoPrevUnsolvedConflict, ac, "go_prev_unsolved_conflict");
     goPrevUnsolvedConflict->setToolTip(goPrevUnsolvedConflict->text() + includeWhitespace);
     goNextUnsolvedConflict = GuiUtils::createAction<QAction>(i18n("Go to Next Unsolved Conflict"), QIcon(QPixmap(nextunsolved)), i18n("Next\nUnsolved"), this, &KDiff3App::slotGoNextUnsolvedConflict, ac, "go_next_unsolved_conflict");
     goNextUnsolvedConflict->setToolTip(goNextUnsolvedConflict->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");
 
     autoSolve = GuiUtils::createAction<QAction>(i18n("Automatically Solve Simple Conflicts"), this, &KDiff3App::slotAutoSolve, ac, "merge_autosolve");
     unsolve = 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");
     mergeHistory = 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("Dir && Text Split Screen View"), this, &KDiff3App::slotDirShowBoth, ac, "win_dir_show_both");
     dirShowBoth->setChecked(true);
     dirViewToggle = GuiUtils::createAction<QAction>(i18n("Toggle Between Dir && 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 directory 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 printDiffTextWindow(RLPainter& painter, const QRect& view, const QString& headerText, DiffTextWindow* pDiffTextWindow, 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;
                 }
             //QString s2 = s.left(i);
             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());
     pDiffTextWindow->print(painter, view, line, linesPerPage);
     painter.resetTransform();
 }
 
 void KDiff3App::slotFilePrint()
 {
     if(m_pDiffTextWindow1 == 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 < 0 && m_pDiffTextWindow2 != nullptr) {
         m_pDiffTextWindow2->getSelectionRange(&firstSelectionD3LIdx, &lastSelectionD3LIdx, eD3LLineCoords);
     }
     if(firstSelectionD3LIdx < 0 && m_pDiffTextWindow3 != nullptr) {
         m_pDiffTextWindow3->getSelectionRange(&firstSelectionD3LIdx, &lastSelectionD3LIdx, eD3LLineCoords);
     }
 
     if(firstSelectionD3LIdx >= 0) {
         printDialog->addEnabledOption(QPrintDialog::PrintSelection);
         //printer.setOptionEnabled(QPrinter::PrintSelection,true);
         printDialog->setPrintRange(QAbstractPrintDialog::Selection);
     }
 
     if(firstSelectionD3LIdx == -1)
         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();
         QEventLoop eventLoopForPrinting;
         m_pEventLoopForPrinting = &eventLoopForPrinting;
         if(m_pOptions->m_bWordWrap)
         {
             // 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();
             for(int i = printer.fromPage(); i <= printer.toPage(); ++i)
             {
                 pageList.push_back(i);
             }
         }
 
         if(printer.printRange() == QPrinter::Selection)
         {
             bPrintSelection = true;
             if(firstSelectionD3LIdx >= 0)
             {
                 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(page == 10000) { // This means "Print the current page"
                     bPrintCurrentPage = true;
                     // 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 >= 0 && 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);
                 printDiffTextWindow(painter, view1, headerText1, m_pDiffTextWindow1, 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);
                 printDiffTextWindow(painter, view2, headerText2, m_pDiffTextWindow2, 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);
                     printDiffTextWindow(painter, view3, headerText3, m_pDiffTextWindow3, 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(bPrintSelection)
             {
                 line += linesPerPage;
                 ++page;
             }
             else
             {
                 ++pageListIt;
             }
         }
 
         painter.end();
 
         if(m_pOptions->m_bWordWrap)
         {
             recalcWordWrap();
             m_pEventLoopForPrinting->exec();
             m_pDiffVScrollBar->setValue(m_pDiffTextWindow1->convertDiff3LineIdxToLine(currentFirstD3LIdx));
         }
 
         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/main.cpp b/src/main.cpp
index 705a52a..7db156b 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,184 +1,186 @@
 /***************************************************************************
  *   Copyright (C) 2003-2007 by Joachim Eibl <joachim.eibl at gmx.de>      *
  *   Copyright (C) 2018 Michael Reeves reeves.87@gmail.com                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 #include "kdiff3_shell.h"
 #include "version.h"
 
 #include "Logging.h"
 
+#include <stdio.h>// for fileno, stderr
+#include <stdlib.h>// for exit
+
 #ifndef Q_OS_WIN
 #include <unistd.h>
 #endif
 
 #include <KAboutData>
 #include <KCrash/KCrash>
 #include <KLocalizedString>
 #include <KMessageBox>
 
 #include <QApplication>
-#include <QByteArray>
 #include <QCommandLineOption>
 #include <QCommandLineParser>
 #include <QFile>
 #include <QStringList>
 #include <QStandardPaths>
 #include <QTextStream>
 
 void initialiseCmdLineArgs(QCommandLineParser* cmdLineParser)
 {
     QString configFileName = QStandardPaths::locate(QStandardPaths::GenericConfigLocation, "kdiff3rc");
     QFile configFile(configFileName);
     QString ignorableOptionsLine = "-u;-query;-html;-abort";
     if(configFile.open(QIODevice::ReadOnly))
     {
         QTextStream ts(&configFile);
         while(!ts.atEnd())
         {
             QString line = ts.readLine();
             if(line.startsWith(QLatin1String("IgnorableCmdLineOptions=")))
             {
                 int pos = line.indexOf('=');
                 if(pos >= 0)
                 {
                     ignorableOptionsLine = line.mid(pos + 1);
                 }
                 break;
             }
         }
     }
     //support our own old preferences this is obsolete
     QStringList sl = ignorableOptionsLine.split(',');
 
     if(!sl.isEmpty())
     {
         QStringList ignorableOptions = sl.front().split(';');
         for(QStringList::iterator i = ignorableOptions.begin(); i != ignorableOptions.end(); ++i)
         {
             i->remove('-');
             if(!i->isEmpty())
             {
                 if(i->length() == 1) {
                     cmdLineParser->addOption(QCommandLineOption(QStringList() << *i << QLatin1String("ignore"), i18n("Ignored. (User defined.)")));
                 }
                 else
                 {
                     cmdLineParser->addOption(QCommandLineOption(QStringList() << *i, i18n("Ignored. (User defined.)")));
                 }
             }
         }
     }
 }
 
 int main(int argc, char* argv[])
 {
     const QLatin1String appName("kdiff3");
 
     QApplication app(argc, argv); // KAboutData and QCommandLineParser depend on this being setup.
     KLocalizedString::setApplicationDomain(appName.data());
 
     KCrash::initialize();
 
     const QString i18nName = i18n("KDiff3");
     QString appVersion(KDIFF3_VERSION_STRING);
 
     if(sizeof(void*) == 8)
         appVersion += i18n(" (64 bit)");
     else if(sizeof(void*) == 4)
         appVersion += i18n(" (32 bit)");
     const QString description = i18n("Tool for Comparison and Merge of Files and Directories");
     const QString copyright = i18n("(c) 2002-2014 Joachim Eibl, (c) 2017 Michael Reeves KF5/Qt5 port");
     const QString homePage = QStringLiteral("https://kde.org/applications/development/kdiff3");
 
     KAboutData aboutData(appName, i18nName,
                          appVersion, description, KAboutLicense::GPL_V2, copyright, QString(),
                          homePage);
 
     KAboutData::setApplicationData(aboutData);
 
     QCommandLineParser* cmdLineParser = KDiff3Shell::getParser();
     cmdLineParser->setApplicationDescription(aboutData.shortDescription());
 
     aboutData.setupCommandLine(cmdLineParser);
 
     initialiseCmdLineArgs(cmdLineParser);
     // ignorable command options
     cmdLineParser->addOption(QCommandLineOption(QStringList() << QLatin1String("m") << QLatin1String("merge"), i18n("Merge the input.")));
     cmdLineParser->addOption(QCommandLineOption(QStringList() << QLatin1String("b") << QLatin1String("base"), i18n("Explicit base file. For compatibility with certain tools."), QLatin1String("file")));
     cmdLineParser->addOption(QCommandLineOption(QStringList() << QLatin1String("o") << QLatin1String("output"), i18n("Output file. Implies -m. E.g.: -o newfile.txt"), QLatin1String("file")));
     cmdLineParser->addOption(QCommandLineOption(QStringList() << QLatin1String("out"), i18n("Output file, again. (For compatibility with certain tools.)"), QLatin1String("file")));
 #ifdef ENABLE_AUTO
     cmdLineParser->addOption(QCommandLineOption(QStringList() << QLatin1String("auto"), i18n("No GUI if all conflicts are auto-solvable. (Needs -o file)")));
 #else
     cmdLineParser->addOption(QCommandLineOption(QStringList() << QLatin1String("auto"), i18n("Ignored.")));
 #endif
     cmdLineParser->addOption(QCommandLineOption(QStringList() << QLatin1String("qall"), i18n("Do not solve conflicts automatically.")));
     cmdLineParser->addOption(QCommandLineOption(QStringList() << QLatin1String("L1"), i18n("Visible name replacement for input file 1 (base)."), QLatin1String("alias1")));
     cmdLineParser->addOption(QCommandLineOption(QStringList() << QLatin1String("L2"), i18n("Visible name replacement for input file 2."), QLatin1String("alias2")));
     cmdLineParser->addOption(QCommandLineOption(QStringList() << QLatin1String("L3"), i18n("Visible name replacement for input file 3."), QLatin1String("alias3")));
     cmdLineParser->addOption(QCommandLineOption(QStringList() << QLatin1String("L") << QLatin1String("fname"), i18n("Alternative visible name replacement. Supply this once for every input."), QLatin1String("alias")));
     cmdLineParser->addOption(QCommandLineOption(QStringList() << QLatin1String("cs"), i18n("Override a config setting. Use once for every setting. E.g.: --cs \"AutoAdvance=1\""), QLatin1String("string")));
     cmdLineParser->addOption(QCommandLineOption(QStringList() << QLatin1String("confighelp"), i18n("Show list of config settings and current values.")));
     cmdLineParser->addOption(QCommandLineOption(QStringList() << QLatin1String("config"), i18n("Use a different config file."), QLatin1String("file")));
 
     // other command options
     cmdLineParser->addPositionalArgument(QLatin1String("[File1]"), i18n("file1 to open (base, if not specified via --base)"));
     cmdLineParser->addPositionalArgument(QLatin1String("[File2]"), i18n("file2 to open"));
     cmdLineParser->addPositionalArgument(QLatin1String("[File3]"), i18n("file3 to open"));
 
     bool isAtty = true;
 
 #ifndef Q_OS_WIN
     isAtty = isatty(fileno(stderr)) == 1;//will be true for redirected output as well
 #endif
     /*
         QCommandLineParser::process does what is expected on windows or when running from a commandline.
         However, it only accounts for a lackof terminal output on windows.
     */
     if(isAtty)
     {
         cmdLineParser->process(QCoreApplication::arguments());
     }
     else
     {
         /*
             There is no terminal connected so don't just exit mysteriously on error.
         */
         if(!cmdLineParser->parse(QCoreApplication::arguments()))
         {
             QString errorMessage = cmdLineParser->errorText();
 
             KMessageBox::error(nullptr, "<html><head/><body><h2>" + errorMessage + "</h2><pre>" + i18n("See kdiff3 --help for supported options.") + "</pre></body></html>", aboutData.displayName());
             exit(1);
         }
 
         if(cmdLineParser->isSet(QStringLiteral("version"))) {
             KMessageBox::information(nullptr,
                                     aboutData.displayName() + ' ' + aboutData.version(), aboutData.displayName());
             exit(0);
         }
         if(cmdLineParser->isSet(QStringLiteral("help"))) {
             KMessageBox::information(nullptr, "<html><head/><body><pre>" + cmdLineParser->helpText() + "</pre></body></html>", aboutData.displayName());
 
             exit(0);
         }
     }
 
     aboutData.processCommandLine(cmdLineParser);
 
     KDiff3Shell* p = new KDiff3Shell();
     p->show();
     //p->setWindowState( p->windowState() | Qt::WindowActive ); // Patch for ubuntu: window not active on startup
     //app.installEventFilter( new CFilter );
     int retVal = app.exec();
     /*  if (QApplication::clipboard()->text().size() == 0)
      QApplication::clipboard()->clear(); // Patch for Ubuntu: Fix issue with Qt clipboard*/
     return retVal;
 }
 
diff --git a/src/mergeresultwindow.cpp b/src/mergeresultwindow.cpp
index 3795086..f7476f1 100644
--- a/src/mergeresultwindow.cpp
+++ b/src/mergeresultwindow.cpp
@@ -1,3327 +1,3329 @@
 /***************************************************************************
  *   Copyright (C) 2002-2007 by Joachim Eibl <joachim.eibl at gmx.de>      *
  *   Copyright (C) 2018 Michael Reeves reeves.87@gmail.com                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #include "mergeresultwindow.h"
 #include "options.h"
 #include "RLPainter.h"
 #include "guiutils.h"
+#include "Utils.h"             // for Utils
+
 
 #include <QApplication>
 #include <QClipboard>
 #include <QComboBox>
 #include <QCursor>
 #include <QDir>
 #include <QFile>
 #include <QHBoxLayout>
 #include <QKeyEvent>
 #include <QLabel>
 #include <QLineEdit>
 #include <QtMath>
 #include <QMouseEvent>
 #include <QPainter>
 #include <QRegExp>
 #include <QStatusBar>
 #include <QTextCodec>
 #include <QTextLayout>
 #include <QTextStream>
 #include <QUrl>
 
 #include <QAction>
 #include <QDropEvent>
 #include <QEvent>
 #include <QFocusEvent>
 #include <QInputEvent>
 #include <QMimeData>
 #include <QPaintEvent>
 #include <QPixmap>
 #include <QResizeEvent>
 #include <QTimerEvent>
 #include <QWheelEvent>
 
 #include <KActionCollection>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KToggleAction>
 
 bool g_bAutoSolve = true;
 
 #undef leftInfoWidth
 
 QAction* MergeResultWindow::chooseAEverywhere = nullptr;
 QAction* MergeResultWindow::chooseBEverywhere = nullptr;
 QAction* MergeResultWindow::chooseCEverywhere = nullptr;
 QAction* MergeResultWindow::chooseAForUnsolvedConflicts = nullptr;
 QAction* MergeResultWindow::chooseBForUnsolvedConflicts = nullptr;
 QAction* MergeResultWindow::chooseCForUnsolvedConflicts = nullptr;
 QAction* MergeResultWindow::chooseAForUnsolvedWhiteSpaceConflicts = nullptr;
 QAction* MergeResultWindow::chooseBForUnsolvedWhiteSpaceConflicts = nullptr;
 QAction* MergeResultWindow::chooseCForUnsolvedWhiteSpaceConflicts = nullptr;
 
 MergeResultWindow::MergeResultWindow(
     QWidget* pParent,
     const QSharedPointer<Options> &pOptions,
     QStatusBar* pStatusBar)
     : QWidget(pParent)
 {
     setObjectName("MergeResultWindow");
     setFocusPolicy(Qt::ClickFocus);
 
     m_firstLine = 0;
     m_horizScrollOffset = 0;
     m_nofLines = 0;
     m_bMyUpdate = false;
     m_bInsertMode = true;
     m_scrollDeltaX = 0;
     m_scrollDeltaY = 0;
     m_bModified = false;
     m_eOverviewMode = Overview::eOMNormal;
 
     m_pldA = nullptr;
     m_pldB = nullptr;
     m_pldC = nullptr;
     m_sizeA = 0;
     m_sizeB = 0;
     m_sizeC = 0;
 
     m_pDiff3LineList = nullptr;
     m_pTotalDiffStatus = nullptr;
     m_pStatusBar = pStatusBar;
     if(m_pStatusBar != nullptr)
         connect(m_pStatusBar, &QStatusBar::messageChanged, this, &MergeResultWindow::slotStatusMessageChanged);
 
     m_pOptions = pOptions;
     setUpdatesEnabled(false);
     m_delayedDrawTimer = 0;
 
     m_cursorXPos = 0;
     m_cursorOldXPixelPos = 0;
     m_cursorYPos = 0;
     m_bCursorOn = true;
     m_bCursorUpdate = false;
     m_maxTextWidth = -1;
     connect(&m_cursorTimer, &QTimer::timeout, this, &MergeResultWindow::slotCursorUpdate);
     m_cursorTimer.setSingleShot(true);
     m_cursorTimer.start(500 /*ms*/);
     m_selection.reset();
 
     setMinimumSize(QSize(20, 20));
     setFont(m_pOptions->m_font);
 }
 
 void MergeResultWindow::init(
     const QVector<LineData>* pLineDataA, LineRef sizeA,
     const QVector<LineData>* pLineDataB, LineRef sizeB,
     const QVector<LineData>* pLineDataC, LineRef sizeC,
     const Diff3LineList* pDiff3LineList,
     TotalDiffStatus* pTotalDiffStatus)
 {
     m_firstLine = 0;
     m_horizScrollOffset = 0;
     m_nofLines = 0;
     m_bMyUpdate = false;
     m_bInsertMode = true;
     m_scrollDeltaX = 0;
     m_scrollDeltaY = 0;
     setModified(false);
 
     m_pldA = pLineDataA;
     m_pldB = pLineDataB;
     m_pldC = pLineDataC;
     m_sizeA = sizeA;
     m_sizeB = sizeB;
     m_sizeC = sizeC;
 
     m_pDiff3LineList = pDiff3LineList;
     m_pTotalDiffStatus = pTotalDiffStatus;
 
     m_selection.reset();
     m_cursorXPos = 0;
     m_cursorOldXPixelPos = 0;
     m_cursorYPos = 0;
 
     m_maxTextWidth = -1;
 
     merge(g_bAutoSolve, Invalid);
     g_bAutoSolve = true;
     update();
     updateSourceMask();
 
     showUnsolvedConflictsStatusMessage();
 }
 
 //This must be called before KXMLGui::SetXMLFile and friends or the actions will not be shown in the menu.
 //At that point in startup we don't have a MergeResultWindow object so we cannot connect the signals yet.
 void MergeResultWindow::initActions(KActionCollection* ac)
 {
     if(ac == nullptr){
         KMessageBox::error(nullptr, "actionCollection==0");
         exit(-1);//we cannot recover from this.
     }
 
     chooseAEverywhere = GuiUtils::createAction<QAction>(i18n("Choose A Everywhere"), QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_1), ac, "merge_choose_a_everywhere");
     chooseBEverywhere = GuiUtils::createAction<QAction>(i18n("Choose B Everywhere"), QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_2), ac, "merge_choose_b_everywhere");
     chooseCEverywhere = GuiUtils::createAction<QAction>(i18n("Choose C Everywhere"), QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_3), ac, "merge_choose_c_everywhere");
     chooseAForUnsolvedConflicts = GuiUtils::createAction<QAction>(i18n("Choose A for All Unsolved Conflicts"), ac, "merge_choose_a_for_unsolved_conflicts");
     chooseBForUnsolvedConflicts = GuiUtils::createAction<QAction>(i18n("Choose B for All Unsolved Conflicts"), ac, "merge_choose_b_for_unsolved_conflicts");
     chooseCForUnsolvedConflicts = GuiUtils::createAction<QAction>(i18n("Choose C for All Unsolved Conflicts"), ac, "merge_choose_c_for_unsolved_conflicts");
     chooseAForUnsolvedWhiteSpaceConflicts = GuiUtils::createAction<QAction>(i18n("Choose A for All Unsolved Whitespace Conflicts"), ac, "merge_choose_a_for_unsolved_whitespace_conflicts");
     chooseBForUnsolvedWhiteSpaceConflicts = GuiUtils::createAction<QAction>(i18n("Choose B for All Unsolved Whitespace Conflicts"), ac, "merge_choose_b_for_unsolved_whitespace_conflicts");
     chooseCForUnsolvedWhiteSpaceConflicts = GuiUtils::createAction<QAction>(i18n("Choose C for All Unsolved Whitespace Conflicts"), ac, "merge_choose_c_for_unsolved_whitespace_conflicts");
 }
 
 void MergeResultWindow::connectActions()
 {
     QObject::connect(chooseAEverywhere, &QAction::triggered, this, &MergeResultWindow::slotChooseAEverywhere);
     QObject::connect(chooseBEverywhere, &QAction::triggered, this, &MergeResultWindow::slotChooseBEverywhere);
     QObject::connect(chooseCEverywhere, &QAction::triggered, this, &MergeResultWindow::slotChooseCEverywhere);
 
     QObject::connect(chooseAForUnsolvedConflicts, &QAction::triggered, this, &MergeResultWindow::slotChooseAForUnsolvedConflicts);
     QObject::connect(chooseBForUnsolvedConflicts, &QAction::triggered, this, &MergeResultWindow::slotChooseBForUnsolvedConflicts);
     QObject::connect(chooseCForUnsolvedConflicts, &QAction::triggered, this, &MergeResultWindow::slotChooseCForUnsolvedConflicts);
 
     QObject::connect(chooseAForUnsolvedWhiteSpaceConflicts, &QAction::triggered, this, &MergeResultWindow::slotChooseAForUnsolvedWhiteSpaceConflicts);
     QObject::connect(chooseBForUnsolvedWhiteSpaceConflicts, &QAction::triggered, this, &MergeResultWindow::slotChooseBForUnsolvedWhiteSpaceConflicts);
     QObject::connect(chooseCForUnsolvedWhiteSpaceConflicts, &QAction::triggered, this, &MergeResultWindow::slotChooseCForUnsolvedWhiteSpaceConflicts);
 }
 
 void MergeResultWindow::showUnsolvedConflictsStatusMessage()
 {
     if(m_pStatusBar != nullptr)
     {
         int wsc;
         int nofUnsolved = getNrOfUnsolvedConflicts(&wsc);
 
         m_persistentStatusMessage = i18n("Number of remaining unsolved conflicts: %1 (of which %2 are whitespace)", nofUnsolved, wsc);
         m_pStatusBar->showMessage(m_persistentStatusMessage);
     }
 }
 
 void MergeResultWindow::slotUpdateAvailabilities(bool bMergeEditorVisible,const bool bTripleDiff)
 {
     chooseAEverywhere->setEnabled(bMergeEditorVisible);
     chooseBEverywhere->setEnabled(bMergeEditorVisible);
     chooseCEverywhere->setEnabled(bMergeEditorVisible && bTripleDiff);
     chooseAForUnsolvedConflicts->setEnabled(bMergeEditorVisible);
     chooseBForUnsolvedConflicts->setEnabled(bMergeEditorVisible);
     chooseCForUnsolvedConflicts->setEnabled(bMergeEditorVisible && bTripleDiff);
     chooseAForUnsolvedWhiteSpaceConflicts->setEnabled(bMergeEditorVisible);
     chooseBForUnsolvedWhiteSpaceConflicts->setEnabled(bMergeEditorVisible);
     chooseCForUnsolvedWhiteSpaceConflicts->setEnabled(bMergeEditorVisible && bTripleDiff);
 }
 
 void MergeResultWindow::slotStatusMessageChanged(const QString& s)
 {
     if(s.isEmpty() && !m_persistentStatusMessage.isEmpty())
     {
         m_pStatusBar->showMessage(m_persistentStatusMessage, 0);
     }
 }
 
 void MergeResultWindow::reset()
 {
     m_pDiff3LineList = nullptr;
     m_pTotalDiffStatus = nullptr;
     m_pldA = nullptr;
     m_pldB = nullptr;
     m_pldC = nullptr;
     if(!m_persistentStatusMessage.isEmpty())
     {
         m_persistentStatusMessage = QString();
     }
 }
 
 // Calculate the merge information for the given Diff3Line.
 // Results will be stored in mergeDetails, bConflict, bLineRemoved and src.
 void Diff3Line::mergeOneLine(
     e_MergeDetails& mergeDetails, bool& bConflict,
     bool& bLineRemoved, e_SrcSelector& src, bool bTwoInputs) const
 {
     mergeDetails = eDefault;
     bConflict = false;
     bLineRemoved = false;
     src = None;
 
     if(bTwoInputs) // Only two input files
     {
         if(getLineA() != -1 && getLineB().isValid())
         {
             if(pFineAB == nullptr)
             {
                 mergeDetails = eNoChange;
                 src = A;
             }
             else
             {
                 mergeDetails = eBChanged;
                 bConflict = true;
             }
         }
         else
         {
             if(getLineA().isValid() && !getLineB().isValid())
             {
                 mergeDetails = eBDeleted;
                 bConflict = true;
             }
             else if(!getLineA().isValid() && getLineB().isValid())
             {
                 mergeDetails = eBDeleted;
                 bConflict = true;
             }
         }
         return;
     }
 
     // A is base.
     if(getLineA().isValid() && getLineB().isValid() && getLineC() != -1)
     {
         if(pFineAB == nullptr && pFineBC == nullptr && pFineCA == nullptr)
         {
             mergeDetails = eNoChange;
             src = A;
         }
         else if(pFineAB == nullptr && pFineBC != nullptr && pFineCA != nullptr)
         {
             mergeDetails = eCChanged;
             src = C;
         }
         else if(pFineAB != nullptr && pFineBC != nullptr && pFineCA == nullptr)
         {
             mergeDetails = eBChanged;
             src = B;
         }
         else if(pFineAB != nullptr && pFineBC == nullptr && pFineCA != nullptr)
         {
             mergeDetails = eBCChangedAndEqual;
             src = C;
         }
         else if(pFineAB != nullptr && pFineBC != nullptr && pFineCA != nullptr)
         {
             mergeDetails = eBCChanged;
             bConflict = true;
         }
         else
             Q_ASSERT(true);
     }
     else if(getLineA().isValid() && getLineB().isValid() && !getLineC().isValid())
     {
         if(pFineAB != nullptr)
         {
             mergeDetails = eBChanged_CDeleted;
             bConflict = true;
         }
         else
         {
             mergeDetails = eCDeleted;
             bLineRemoved = true;
             src = C;
         }
     }
     else if(getLineA().isValid() && !getLineB().isValid() && getLineC() != -1)
     {
         if(pFineCA != nullptr)
         {
             mergeDetails = eCChanged_BDeleted;
             bConflict = true;
         }
         else
         {
             mergeDetails = eBDeleted;
             bLineRemoved = true;
             src = B;
         }
     }
     else if(!getLineA().isValid() && getLineB().isValid() && getLineC() != -1)
     {
         if(pFineBC != nullptr)
         {
             mergeDetails = eBCAdded;
             bConflict = true;
         }
         else // B==C
         {
             mergeDetails = eBCAddedAndEqual;
             src = C;
         }
     }
     else if(!getLineA().isValid() && !getLineB().isValid() && getLineC() != -1)
     {
         mergeDetails = eCAdded;
         src = C;
     }
     else if(!getLineA().isValid() && getLineB().isValid() && !getLineC().isValid())
     {
         mergeDetails = eBAdded;
         src = B;
     }
     else if(getLineA().isValid() && !getLineB().isValid() && !getLineC().isValid())
     {
         mergeDetails = eBCDeleted;
         bLineRemoved = true;
         src = C;
     }
     else
         Q_ASSERT(true);
 }
 
 bool MergeResultWindow::sameKindCheck(const MergeLine& ml1, const MergeLine& ml2)
 {
     if(ml1.bConflict && ml2.bConflict)
     {
         // Both lines have conflicts: If one is only a white space conflict and
         // the other one is a real conflict, then this line returns false.
         return ml1.id3l->isEqualAC() == ml2.id3l->isEqualAC() && ml1.id3l->isEqualAB() == ml2.id3l->isEqualAB();
     }
     else
         return (
             (!ml1.bConflict && !ml2.bConflict && ml1.bDelta && ml2.bDelta && ml1.srcSelect == ml2.srcSelect && (ml1.mergeDetails == ml2.mergeDetails || (ml1.mergeDetails != eBCAddedAndEqual && ml2.mergeDetails != eBCAddedAndEqual))) ||
             (!ml1.bDelta && !ml2.bDelta));
 }
 
 void MergeResultWindow::merge(bool bAutoSolve, e_SrcSelector defaultSelector, bool bConflictsOnly, bool bWhiteSpaceOnly)
 {
     if(!bConflictsOnly)
     {
         if(m_bModified)
         {
             int result = KMessageBox::warningYesNo(this,
                                                    i18n("The output has been modified.\n"
                                                         "If you continue your changes will be lost."),
                                                    i18n("Warning"),
                                                    KStandardGuiItem::cont(),
                                                    KStandardGuiItem::cancel());
             if(result == KMessageBox::No)
                 return;
         }
 
         m_mergeLineList.clear();
 
         int lineIdx = 0;
         Diff3LineList::const_iterator it;
         for(it = m_pDiff3LineList->begin(); it != m_pDiff3LineList->end(); ++it, ++lineIdx)
         {
             const Diff3Line& d = *it;
 
             MergeLine ml;
             bool bLineRemoved;
             d.mergeOneLine( ml.mergeDetails, ml.bConflict, bLineRemoved, ml.srcSelect, m_pldC == nullptr);
 
             // Automatic solving for only whitespace changes.
             if(ml.bConflict &&
                ((m_pldC == nullptr && (d.isEqualAB() || (d.bWhiteLineA && d.bWhiteLineB))) ||
                 (m_pldC != nullptr && ((d.isEqualAB() && d.isEqualAC()) || (d.bWhiteLineA && d.bWhiteLineB && d.bWhiteLineC)))))
             {
                 ml.bWhiteSpaceConflict = true;
             }
 
             ml.d3lLineIdx = lineIdx;
             ml.bDelta = ml.srcSelect != A;
             ml.id3l = it;
             ml.srcRangeLength = 1;
 
             MergeLine* back = m_mergeLineList.empty() ? nullptr : &m_mergeLineList.back();
 
             bool bSame = back != nullptr && sameKindCheck(ml, *back);
             if(bSame)
             {
                 ++back->srcRangeLength;
                 if(back->bWhiteSpaceConflict && !ml.bWhiteSpaceConflict)
                     back->bWhiteSpaceConflict = false;
             }
             else
             {
                 m_mergeLineList.push_back(ml);
             }
 
             if(!ml.bConflict)
             {
                 MergeLine& tmpBack = m_mergeLineList.back();
                 MergeEditLine mel(ml.id3l);
                 mel.setSource(ml.srcSelect, bLineRemoved);
                 tmpBack.mergeEditLineList.push_back(mel);
             }
             else if(back == nullptr || !back->bConflict || !bSame)
             {
                 MergeLine& tmpBack = m_mergeLineList.back();
                 MergeEditLine mel(ml.id3l);
                 mel.setConflict();
                 tmpBack.mergeEditLineList.push_back(mel);
             }
         }
     }
 
     bool bSolveWhiteSpaceConflicts = false;
     if(bAutoSolve) // when true, then the other params are not used and we can change them here. (see all invocations of merge())
     {
         if(m_pldC == nullptr && m_pOptions->m_whiteSpace2FileMergeDefault != None) // Only two inputs
         {
             Q_ASSERT(m_pOptions->m_whiteSpace2FileMergeDefault <= Max && m_pOptions->m_whiteSpace2FileMergeDefault >= Min);
             defaultSelector = (e_SrcSelector)m_pOptions->m_whiteSpace2FileMergeDefault;
             bWhiteSpaceOnly = true;
             bSolveWhiteSpaceConflicts = true;
         }
         else if(m_pldC != nullptr && m_pOptions->m_whiteSpace3FileMergeDefault != None)
         {
             Q_ASSERT(m_pOptions->m_whiteSpace3FileMergeDefault <= Max && m_pOptions->m_whiteSpace2FileMergeDefault >= Min);
             defaultSelector = (e_SrcSelector)m_pOptions->m_whiteSpace3FileMergeDefault;
             bWhiteSpaceOnly = true;
             bSolveWhiteSpaceConflicts = true;
         }
     }
 
     if(!bAutoSolve || bSolveWhiteSpaceConflicts)
     {
         // Change all auto selections
         MergeLineList::iterator mlIt;
         for(mlIt = m_mergeLineList.begin(); mlIt != m_mergeLineList.end(); ++mlIt)
         {
             MergeLine& ml = *mlIt;
             bool bConflict = ml.mergeEditLineList.empty() || ml.mergeEditLineList.begin()->isConflict();
             if(ml.bDelta && (!bConflictsOnly || bConflict) && (!bWhiteSpaceOnly || ml.bWhiteSpaceConflict))
             {
                 ml.mergeEditLineList.clear();
                 if(defaultSelector == Invalid && ml.bDelta)
                 {
                     MergeEditLine mel(ml.id3l);
                     ;
                     mel.setConflict();
                     ml.bConflict = true;
                     ml.mergeEditLineList.push_back(mel);
                 }
                 else
                 {
                     Diff3LineList::const_iterator d3llit = ml.id3l;
                     int j;
 
                     for(j = 0; j < ml.srcRangeLength; ++j)
                     {
                         MergeEditLine mel(d3llit);
                         mel.setSource(defaultSelector, false);
 
                         LineRef srcLine = defaultSelector == A ? d3llit->getLineA() : defaultSelector == B ? d3llit->getLineB() : defaultSelector == C ? d3llit->getLineC() : LineRef();
 
                         if(srcLine.isValid())
                         {
                             ml.mergeEditLineList.push_back(mel);
                         }
 
                         ++d3llit;
                     }
 
                     if(ml.mergeEditLineList.empty()) // Make a line nevertheless
                     {
                         MergeEditLine mel(ml.id3l);
                         mel.setRemoved(defaultSelector);
                         ml.mergeEditLineList.push_back(mel);
                     }
                 }
             }
         }
     }
 
     MergeLineList::iterator mlIt;
     for(mlIt = m_mergeLineList.begin(); mlIt != m_mergeLineList.end(); ++mlIt)
     {
         MergeLine& ml = *mlIt;
         // Remove all lines that are empty, because no src lines are there.
 
         LineRef oldSrcLine;
         e_SrcSelector oldSrc = Invalid;
         MergeEditLineList::iterator melIt;
         for(melIt = ml.mergeEditLineList.begin(); melIt != ml.mergeEditLineList.end();)
         {
             MergeEditLine& mel = *melIt;
             e_SrcSelector melsrc = mel.src();
 
             LineRef srcLine = mel.isRemoved() ? LineRef() : melsrc == A ? mel.id3l()->getLineA() : melsrc == B ? mel.id3l()->getLineB() : melsrc == C ? mel.id3l()->getLineC() : LineRef();
 
             // At least one line remains because oldSrc != melsrc for first line in list
             // Other empty lines will be removed
             if(!srcLine.isValid() && !oldSrcLine.isValid() && oldSrc == melsrc)
                 melIt = ml.mergeEditLineList.erase(melIt);
             else
                 ++melIt;
 
             oldSrcLine = srcLine;
             oldSrc = melsrc;
         }
     }
 
     if(bAutoSolve && !bConflictsOnly)
     {
         if(m_pOptions->m_bRunHistoryAutoMergeOnMergeStart)
             slotMergeHistory();
         if(m_pOptions->m_bRunRegExpAutoMergeOnMergeStart)
             slotRegExpAutoMerge();
         if(m_pldC != nullptr && !doRelevantChangesExist())
             emit noRelevantChangesDetected();
     }
 
     int nrOfSolvedConflicts = 0;
     int nrOfUnsolvedConflicts = 0;
     int nrOfWhiteSpaceConflicts = 0;
 
     MergeLineList::iterator i;
     for(i = m_mergeLineList.begin(); i != m_mergeLineList.end(); ++i)
     {
         if(i->bConflict)
             ++nrOfUnsolvedConflicts;
         else if(i->bDelta)
             ++nrOfSolvedConflicts;
 
         if(i->bWhiteSpaceConflict)
             ++nrOfWhiteSpaceConflicts;
     }
 
     m_pTotalDiffStatus->setUnsolvedConflicts(nrOfUnsolvedConflicts);
     m_pTotalDiffStatus->setSolvedConflicts(nrOfSolvedConflicts);
     m_pTotalDiffStatus->setWhitespaceConflicts(nrOfWhiteSpaceConflicts);
 
     m_cursorXPos = 0;
     m_cursorOldXPixelPos = 0;
     m_cursorYPos = 0;
     m_maxTextWidth = -1;
 
     //m_firstLine = 0; // Must not set line/column without scrolling there
     //m_horizScrollOffset = 0;
 
     setModified(false);
 
     m_currentMergeLineIt = m_mergeLineList.begin();
     slotGoTop();
 
     emit updateAvailabilities();
     update();
 }
 
 void MergeResultWindow::setFirstLine(QtNumberType firstLine)
 {
     m_firstLine = std::max(0, firstLine);
     update();
 }
 
 void MergeResultWindow::setHorizScrollOffset(int horizScrollOffset)
 {
     m_horizScrollOffset = std::max(0, horizScrollOffset);
     update();
 }
 
 int MergeResultWindow::getMaxTextWidth()
 {
     if(m_maxTextWidth < 0)
     {
         m_maxTextWidth = 0;
 
         MergeLineList::iterator mlIt = m_mergeLineList.begin();
         for(mlIt = m_mergeLineList.begin(); mlIt != m_mergeLineList.end(); ++mlIt)
         {
             MergeLine& ml = *mlIt;
             MergeEditLineList::iterator melIt;
             for(melIt = ml.mergeEditLineList.begin(); melIt != ml.mergeEditLineList.end(); ++melIt)
             {
                 MergeEditLine& mel = *melIt;
                 QString s = mel.getString(m_pldA, m_pldB, m_pldC);
 
                 QTextLayout textLayout(s, font(), this);
                 textLayout.beginLayout();
                 textLayout.createLine();
                 textLayout.endLayout();
                 if(m_maxTextWidth < textLayout.maximumWidth())
                 {
                     m_maxTextWidth =  qCeil(textLayout.maximumWidth());
                 }
             }
         }
         m_maxTextWidth += 5; // cursorwidth
     }
     return m_maxTextWidth;
 }
 
 int MergeResultWindow::getNofLines()
 {
     return m_nofLines;
 }
 
 int MergeResultWindow::getVisibleTextAreaWidth()
 {
     // QFontMetrics fm = fontMetrics(); // FIXME used?
     return width() - getTextXOffset();
 }
 
 int MergeResultWindow::getNofVisibleLines()
 {
     QFontMetrics fm = fontMetrics();
     return (height() - 3) / fm.lineSpacing() - 2;
 }
 
 int MergeResultWindow::getTextXOffset()
 {
     QFontMetrics fm = fontMetrics();
     return 3 * Utils::getHorizontalAdvance(fm, '0');
 }
 
 void MergeResultWindow::resizeEvent(QResizeEvent* e)
 {
     QWidget::resizeEvent(e);
     emit resizeSignal();
 }
 
 Overview::e_OverviewMode MergeResultWindow::getOverviewMode()
 {
     return m_eOverviewMode;
 }
 
 void MergeResultWindow::setOverviewMode(Overview::e_OverviewMode eOverviewMode)
 {
     m_eOverviewMode = eOverviewMode;
 }
 
 // Check whether we should ignore current delta when moving to next/previous delta
 bool MergeResultWindow::checkOverviewIgnore(MergeLineList::iterator& i)
 {
     if(m_eOverviewMode == Overview::eOMNormal) return false;
     if(m_eOverviewMode == Overview::eOMAvsB)
         return i->mergeDetails == eCAdded || i->mergeDetails == eCDeleted || i->mergeDetails == eCChanged;
     if(m_eOverviewMode == Overview::eOMAvsC)
         return i->mergeDetails == eBAdded || i->mergeDetails == eBDeleted || i->mergeDetails == eBChanged;
     if(m_eOverviewMode == Overview::eOMBvsC)
         return i->mergeDetails == eBCAddedAndEqual || i->mergeDetails == eBCDeleted || i->mergeDetails == eBCChangedAndEqual;
     return false;
 }
 
 // Go to prev/next delta/conflict or first/last delta.
 void MergeResultWindow::go(e_Direction eDir, e_EndPoint eEndPoint)
 {
     Q_ASSERT(eDir == eUp || eDir == eDown);
     MergeLineList::iterator i = m_currentMergeLineIt;
     bool bSkipWhiteConflicts = !m_pOptions->m_bShowWhiteSpace;
     if(eEndPoint == eEnd)
     {
         if(eDir == eUp)
             i = m_mergeLineList.begin(); // first mergeline
         else
             i = --m_mergeLineList.end(); // last mergeline
 
         while(isItAtEnd(eDir == eUp, i) && !i->bDelta)
         {
             if(eDir == eUp)
                 ++i; // search downwards
             else
                 --i; // search upwards
         }
     }
     else if(eEndPoint == eDelta && isItAtEnd(eDir != eUp, i))
     {
         do
         {
             if(eDir == eUp)
                 --i;
             else
                 ++i;
         } while(isItAtEnd(eDir != eUp, i) && (!i->bDelta || checkOverviewIgnore(i) || (bSkipWhiteConflicts && i->bWhiteSpaceConflict)));
     }
     else if(eEndPoint == eConflict && isItAtEnd(eDir != eUp, i))
     {
         do
         {
             if(eDir == eUp)
                 --i;
             else
                 ++i;
         } while(isItAtEnd(eDir != eUp, i) && (!i->bConflict || (bSkipWhiteConflicts && i->bWhiteSpaceConflict)));
     }
     else if(isItAtEnd(eDir != eUp, i) && eEndPoint == eUnsolvedConflict)
     {
         do
         {
             if(eDir == eUp)
                 --i;
             else
                 ++i;
         } while(isItAtEnd(eDir != eUp, i) && !i->mergeEditLineList.begin()->isConflict());
     }
 
     if(isVisible())
         setFocus();
 
     setFastSelector(i);
 }
 
 bool MergeResultWindow::isDeltaAboveCurrent()
 {
     bool bSkipWhiteConflicts = !m_pOptions->m_bShowWhiteSpace;
     if(m_mergeLineList.empty()) return false;
     MergeLineList::iterator i = m_currentMergeLineIt;
     if(i == m_mergeLineList.begin()) return false;
     do
     {
         --i;
         if(i->bDelta && !checkOverviewIgnore(i) && !(bSkipWhiteConflicts && i->bWhiteSpaceConflict)) return true;
     } while(i != m_mergeLineList.begin());
 
     return false;
 }
 
 bool MergeResultWindow::isDeltaBelowCurrent()
 {
     bool bSkipWhiteConflicts = !m_pOptions->m_bShowWhiteSpace;
     if(m_mergeLineList.empty()) return false;
 
     MergeLineList::iterator i = m_currentMergeLineIt;
     if(i != m_mergeLineList.end())
     {
         ++i;
         for(; i != m_mergeLineList.end(); ++i)
         {
             if(i->bDelta && !checkOverviewIgnore(i) && !(bSkipWhiteConflicts && i->bWhiteSpaceConflict)) return true;
         }
     }
     return false;
 }
 
 bool MergeResultWindow::isConflictAboveCurrent()
 {
     if(m_mergeLineList.empty()) return false;
     MergeLineList::iterator i = m_currentMergeLineIt;
     if(i == m_mergeLineList.begin()) return false;
 
     bool bSkipWhiteConflicts = !m_pOptions->m_bShowWhiteSpace;
 
     do
     {
         --i;
         if(i->bConflict && !(bSkipWhiteConflicts && i->bWhiteSpaceConflict)) return true;
     } while(i != m_mergeLineList.begin());
 
     return false;
 }
 
 bool MergeResultWindow::isConflictBelowCurrent()
 {
     MergeLineList::iterator i = m_currentMergeLineIt;
     if(m_mergeLineList.empty()) return false;
 
     bool bSkipWhiteConflicts = !m_pOptions->m_bShowWhiteSpace;
 
     if(i != m_mergeLineList.end())
     {
         ++i;
         for(; i != m_mergeLineList.end(); ++i)
         {
             if(i->bConflict && !(bSkipWhiteConflicts && i->bWhiteSpaceConflict)) return true;
         }
     }
     return false;
 }
 
 bool MergeResultWindow::isUnsolvedConflictAtCurrent()
 {
     if(m_mergeLineList.empty()) return false;
     MergeLineList::iterator i = m_currentMergeLineIt;
     return i->mergeEditLineList.begin()->isConflict();
 }
 
 bool MergeResultWindow::isUnsolvedConflictAboveCurrent()
 {
     if(m_mergeLineList.empty()) return false;
     MergeLineList::iterator i = m_currentMergeLineIt;
     if(i == m_mergeLineList.begin()) return false;
 
     do
     {
         --i;
         if(i->mergeEditLineList.begin()->isConflict()) return true;
     } while(i != m_mergeLineList.begin());
 
     return false;
 }
 
 bool MergeResultWindow::isUnsolvedConflictBelowCurrent()
 {
     MergeLineList::iterator i = m_currentMergeLineIt;
     if(m_mergeLineList.empty()) return false;
 
     if(i != m_mergeLineList.end())
     {
         ++i;
         for(; i != m_mergeLineList.end(); ++i)
         {
             if(i->mergeEditLineList.begin()->isConflict()) return true;
         }
     }
     return false;
 }
 
 void MergeResultWindow::slotGoTop()
 {
     go(eUp, eEnd);
 }
 
 void MergeResultWindow::slotGoCurrent()
 {
     setFastSelector(m_currentMergeLineIt);
 }
 
 void MergeResultWindow::slotGoBottom()
 {
     go(eDown, eEnd);
 }
 
 void MergeResultWindow::slotGoPrevDelta()
 {
     go(eUp, eDelta);
 }
 
 void MergeResultWindow::slotGoNextDelta()
 {
     go(eDown, eDelta);
 }
 
 void MergeResultWindow::slotGoPrevConflict()
 {
     go(eUp, eConflict);
 }
 
 void MergeResultWindow::slotGoNextConflict()
 {
     go(eDown, eConflict);
 }
 
 void MergeResultWindow::slotGoPrevUnsolvedConflict()
 {
     go(eUp, eUnsolvedConflict);
 }
 
 void MergeResultWindow::slotGoNextUnsolvedConflict()
 {
     go(eDown, eUnsolvedConflict);
 }
 
 /** The line is given as a index in the Diff3LineList.
     The function calculates the corresponding iterator. */
 void MergeResultWindow::slotSetFastSelectorLine(LineIndex line)
 {
     MergeLineList::iterator i;
     for(i = m_mergeLineList.begin(); i != m_mergeLineList.end(); ++i)
     {
         if(line >= i->d3lLineIdx && line < i->d3lLineIdx + i->srcRangeLength)
         {
             //if ( i->bDelta )
             {
                 setFastSelector(i);
             }
             break;
         }
     }
 }
 
 int MergeResultWindow::getNrOfUnsolvedConflicts(int* pNrOfWhiteSpaceConflicts)
 {
     int nrOfUnsolvedConflicts = 0;
     if(pNrOfWhiteSpaceConflicts != nullptr)
         *pNrOfWhiteSpaceConflicts = 0;
 
     MergeLineList::iterator mlIt = m_mergeLineList.begin();
     for(mlIt = m_mergeLineList.begin(); mlIt != m_mergeLineList.end(); ++mlIt)
     {
         MergeLine& ml = *mlIt;
         MergeEditLineList::iterator melIt = ml.mergeEditLineList.begin();
         if(melIt->isConflict())
         {
             ++nrOfUnsolvedConflicts;
             if(ml.bWhiteSpaceConflict && pNrOfWhiteSpaceConflicts != nullptr)
                 ++*pNrOfWhiteSpaceConflicts;
         }
     }
 
     return nrOfUnsolvedConflicts;
 }
 
 void MergeResultWindow::showNrOfConflicts()
 {
     if(!m_pOptions->m_bShowInfoDialogs)
         return;
     int nrOfConflicts = 0;
     MergeLineList::iterator i;
     for(i = m_mergeLineList.begin(); i != m_mergeLineList.end(); ++i)
     {
         if(i->bConflict || i->bDelta)
             ++nrOfConflicts;
     }
     QString totalInfo;
     if(m_pTotalDiffStatus->bBinaryAEqB && m_pTotalDiffStatus->bBinaryAEqC)
         totalInfo += i18n("All input files are binary equal.");
     else if(m_pTotalDiffStatus->bTextAEqB && m_pTotalDiffStatus->bTextAEqC)
         totalInfo += i18n("All input files contain the same text.");
     else
     {
         if(m_pTotalDiffStatus->bBinaryAEqB)
             totalInfo += i18n("Files %1 and %2 are binary equal.\n", i18n("A"), i18n("B"));
         else if(m_pTotalDiffStatus->bTextAEqB)
             totalInfo += i18n("Files %1 and %2 have equal text.\n", i18n("A"), i18n("B"));
         if(m_pTotalDiffStatus->bBinaryAEqC)
             totalInfo += i18n("Files %1 and %2 are binary equal.\n", i18n("A"), i18n("C"));
         else if(m_pTotalDiffStatus->bTextAEqC)
             totalInfo += i18n("Files %1 and %2 have equal text.\n", i18n("A"), i18n("C"));
         if(m_pTotalDiffStatus->bBinaryBEqC)
             totalInfo += i18n("Files %1 and %2 are binary equal.\n", i18n("B"), i18n("C"));
         else if(m_pTotalDiffStatus->bTextBEqC)
             totalInfo += i18n("Files %1 and %2 have equal text.\n", i18n("B"), i18n("C"));
     }
 
     int nrOfUnsolvedConflicts = getNrOfUnsolvedConflicts();
 
     KMessageBox::information(this,
                              i18n("Total number of conflicts: %1\n"
                                   "Nr of automatically solved conflicts: %2\n"
                                   "Nr of unsolved conflicts: %3\n"
                                   "%4",
                                   nrOfConflicts, nrOfConflicts - nrOfUnsolvedConflicts,
                                   nrOfUnsolvedConflicts, totalInfo),
                              i18n("Conflicts"));
 }
 
 void MergeResultWindow::setFastSelector(MergeLineList::iterator i)
 {
     if(i == m_mergeLineList.end())
         return;
     m_currentMergeLineIt = i;
     emit setFastSelectorRange(i->d3lLineIdx, i->srcRangeLength);
 
     int line1 = 0;
 
     MergeLineList::iterator mlIt = m_mergeLineList.begin();
     for(mlIt = m_mergeLineList.begin(); mlIt != m_mergeLineList.end(); ++mlIt)
     {
         if(mlIt == m_currentMergeLineIt)
             break;
         line1 += mlIt->mergeEditLineList.size();
     }
 
     int nofLines = m_currentMergeLineIt->mergeEditLineList.size();
     int newFirstLine = getBestFirstLine(line1, nofLines, m_firstLine, getNofVisibleLines());
     if(newFirstLine != m_firstLine)
     {
         emit scrollMergeResultWindow(0, newFirstLine - m_firstLine);
     }
 
     if(m_selection.isEmpty())
     {
         m_cursorXPos = 0;
         m_cursorOldXPixelPos = 0;
         m_cursorYPos = line1;
     }
 
     update();
     updateSourceMask();
     emit updateAvailabilities();
 }
 
 void MergeResultWindow::choose(e_SrcSelector selector)
 {
     if(m_currentMergeLineIt == m_mergeLineList.end())
         return;
 
     setModified();
 
     // First find range for which this change works.
     MergeLine& ml = *m_currentMergeLineIt;
 
     MergeEditLineList::iterator melIt;
 
     // Now check if selector is active for this range already.
     bool bActive = false;
 
     // Remove unneeded lines in the range.
     for(melIt = ml.mergeEditLineList.begin(); melIt != ml.mergeEditLineList.end();)
     {
         MergeEditLine& mel = *melIt;
         if(mel.src() == selector)
             bActive = true;
 
         if(mel.src() == selector || !mel.isEditableText() || mel.isModified())
             melIt = ml.mergeEditLineList.erase(melIt);
         else
             ++melIt;
     }
 
     if(!bActive) // Selected source wasn't active.
     {            // Append the lines from selected source here at rangeEnd.
         Diff3LineList::const_iterator d3llit = ml.id3l;
         int j;
 
         for(j = 0; j < ml.srcRangeLength; ++j)
         {
             MergeEditLine mel(d3llit);
             mel.setSource(selector, false);
             ml.mergeEditLineList.push_back(mel);
 
             ++d3llit;
         }
     }
 
     if(!ml.mergeEditLineList.empty())
     {
         // Remove all lines that are empty, because no src lines are there.
         for(melIt = ml.mergeEditLineList.begin(); melIt != ml.mergeEditLineList.end();)
         {
             MergeEditLine& mel = *melIt;
 
             LineRef srcLine = mel.src() == A ? mel.id3l()->getLineA() : mel.src() == B ? mel.id3l()->getLineB() : mel.src() == C ? mel.id3l()->getLineC() : LineRef();
 
             if(!srcLine.isValid())
                 melIt = ml.mergeEditLineList.erase(melIt);
             else
                 ++melIt;
         }
     }
 
     if(ml.mergeEditLineList.empty())
     {
         // Insert a dummy line:
         MergeEditLine mel(ml.id3l);
 
         if(bActive)
             mel.setConflict(); // All src entries deleted => conflict
         else
             mel.setRemoved(selector); // No lines in corresponding src found.
 
         ml.mergeEditLineList.push_back(mel);
     }
 
     if(m_cursorYPos >= m_nofLines)
     {
         m_cursorYPos = m_nofLines - 1;
         m_cursorXPos = 0;
     }
 
     m_maxTextWidth = -1;
     update();
     updateSourceMask();
     emit updateAvailabilities();
     showUnsolvedConflictsStatusMessage();
 }
 
 // bConflictsOnly: automatically choose for conflicts only (true) or for everywhere (false)
 void MergeResultWindow::chooseGlobal(e_SrcSelector selector, bool bConflictsOnly, bool bWhiteSpaceOnly)
 {
     resetSelection();
 
     merge(false, selector, bConflictsOnly, bWhiteSpaceOnly);
     setModified(true);
     update();
     showUnsolvedConflictsStatusMessage();
 }
 
 void MergeResultWindow::slotAutoSolve()
 {
     resetSelection();
     merge(true, Invalid);
     setModified(true);
     update();
     showUnsolvedConflictsStatusMessage();
 }
 
 void MergeResultWindow::slotUnsolve()
 {
     resetSelection();
     merge(false, Invalid);
     setModified(true);
     update();
     showUnsolvedConflictsStatusMessage();
 }
 
 static QString calcHistoryLead(const QString& s)
 {
     // Return the start of the line until the first white char after the first non white char.
     int i;
     for(i = 0; i < s.length(); ++i)
     {
         if(s[i] != ' ' && s[i] != '\t')
         {
             for(; i < s.length(); ++i)
             {
                 if(s[i] == ' ' || s[i] == '\t')
                 {
                     return s.left(i);
                 }
             }
             return s; // Very unlikely
         }
     }
     return QString(); // Must be an empty string, not a null string.
 }
 
 static void findHistoryRange(const QRegExp& historyStart, bool bThreeFiles, const Diff3LineList* pD3LList,
                              Diff3LineList::const_iterator& iBegin, Diff3LineList::const_iterator& iEnd, int& idxBegin, int& idxEnd)
 {
     QString historyLead;
     // Search for start of history
     for(iBegin = pD3LList->begin(), idxBegin = 0; iBegin != pD3LList->end(); ++iBegin, ++idxBegin)
     {
         if(historyStart.exactMatch(iBegin->getString(A)) &&
            historyStart.exactMatch(iBegin->getString(B)) &&
            (!bThreeFiles || historyStart.exactMatch(iBegin->getString(C))))
         {
             historyLead = calcHistoryLead(iBegin->getString(A));
             break;
         }
     }
     // Search for end of history
     for(iEnd = iBegin, idxEnd = idxBegin; iEnd != pD3LList->end(); ++iEnd, ++idxEnd)
     {
         QString sA = iEnd->getString(A);
         QString sB = iEnd->getString(B);
         QString sC = iEnd->getString(C);
         if(!((sA.isEmpty() || historyLead == calcHistoryLead(sA)) &&
              (sB.isEmpty() || historyLead == calcHistoryLead(sB)) &&
              (!bThreeFiles || sC.isEmpty() || historyLead == calcHistoryLead(sC))))
         {
             break; // End of the history
         }
     }
 }
 
 bool findParenthesesGroups(const QString& s, QStringList& sl)
 {
     sl.clear();
     int i = 0;
     std::list<int> startPosStack;
     int length = s.length();
     for(i = 0; i < length; ++i)
     {
         if(s[i] == '\\' && i + 1 < length && (s[i + 1] == '\\' || s[i + 1] == '(' || s[i + 1] == ')'))
         {
             ++i;
             continue;
         }
         if(s[i] == '(')
         {
             startPosStack.push_back(i);
         }
         else if(s[i] == ')')
         {
             if(startPosStack.empty())
                 return false; // Parentheses don't match
             int startPos = startPosStack.back();
             startPosStack.pop_back();
             sl.push_back(s.mid(startPos + 1, i - startPos - 1));
         }
     }
     return startPosStack.empty(); // false if parentheses don't match
 }
 
 QString calcHistorySortKey(const QString& keyOrder, QRegExp& matchedRegExpr, const QStringList& parenthesesGroupList)
 {
     QStringList keyOrderList = keyOrder.split(',');
     QString key;
     for(QStringList::iterator keyIt = keyOrderList.begin(); keyIt != keyOrderList.end(); ++keyIt)
     {
         if(keyIt->isEmpty())
             continue;
         bool bOk = false;
         int groupIdx = keyIt->toInt(&bOk);
         if(!bOk || groupIdx < 0 || groupIdx > parenthesesGroupList.size())
             continue;
         QString s = matchedRegExpr.cap(groupIdx);
         if(groupIdx == 0)
         {
             key += s + ' ';
             continue;
         }
 
         QString groupRegExp = parenthesesGroupList[groupIdx - 1];
         if(groupRegExp.indexOf('|') < 0 || groupRegExp.indexOf('(') >= 0)
         {
             bOk = false;
             int i = s.toInt(&bOk);
             if(bOk && i >= 0 && i < 10000)
                 s.sprintf("%04d", i); // This should help for correct sorting of numbers.
             key += s + ' ';
         }
         else
         {
             // Assume that the groupRegExp consists of something like "Jan|Feb|Mar|Apr"
             // s is the string that managed to match.
             // Now we want to know at which position it occurred. e.g. Jan=0, Feb=1, Mar=2, etc.
             QStringList sl = groupRegExp.split('|');
             int idx = sl.indexOf(s);
             if(idx < 0)
             {
                 // Didn't match
             }
             else
             {
                 QString sIdx;
                 sIdx.sprintf("%02d", idx + 1); // Up to 99 words in the groupRegExp (more than 12 aren't expected)
                 key += sIdx + ' ';
             }
         }
     }
     return key;
 }
 
 void MergeResultWindow::collectHistoryInformation(
     e_SrcSelector src, Diff3LineList::const_iterator &iHistoryBegin, Diff3LineList::const_iterator &iHistoryEnd,
     HistoryMap& historyMap,
     std::list<HistoryMap::iterator>& hitList // list of iterators
 )
 {
     std::list<HistoryMap::iterator>::iterator itHitListFront = hitList.begin();
     Diff3LineList::const_iterator id3l = iHistoryBegin;
     QString historyLead;
     {
         const LineData* pld = id3l->getLineData(src);
 
         historyLead = calcHistoryLead(pld->getLine());
     }
     QRegExp historyStart(m_pOptions->m_historyStartRegExp);
     if(id3l == iHistoryEnd)
         return;
     ++id3l; // Skip line with "$Log ... $"
     QRegExp newHistoryEntry(m_pOptions->m_historyEntryStartRegExp);
     QStringList parenthesesGroups;
     findParenthesesGroups(m_pOptions->m_historyEntryStartRegExp, parenthesesGroups);
     QString key;
     MergeEditLineList melList;
     bool bPrevLineIsEmpty = true;
     bool bUseRegExp = !m_pOptions->m_historyEntryStartRegExp.isEmpty();
     for(; id3l != iHistoryEnd; ++id3l)
     {
         const LineData* pld = id3l->getLineData(src);
         if(!pld) continue;
 
         const QString& oriLine = pld->getLine();
         if(historyLead.isEmpty()) historyLead = calcHistoryLead(oriLine);
         QString sLine = oriLine.mid(historyLead.length());
         if((!bUseRegExp && !sLine.trimmed().isEmpty() && bPrevLineIsEmpty) || (bUseRegExp && newHistoryEntry.exactMatch(sLine)))
         {
             if(!key.isEmpty() && !melList.empty())
             {
                 // Only insert new HistoryMapEntry if key not found; in either case p.first is a valid iterator to element key.
                 std::pair<HistoryMap::iterator, bool> p = historyMap.insert(HistoryMap::value_type(key, HistoryMapEntry()));
                 HistoryMapEntry& hme = p.first->second;
                 if(src == A) hme.mellA = melList;
                 if(src == B) hme.mellB = melList;
                 if(src == C) hme.mellC = melList;
                 if(p.second) // Not in list yet?
                 {
                     hitList.insert(itHitListFront, p.first);
                 }
             }
 
             if(!bUseRegExp)
                 key = sLine;
             else
                 key = calcHistorySortKey(m_pOptions->m_historyEntryStartSortKeyOrder, newHistoryEntry, parenthesesGroups);
 
             melList.clear();
             melList.push_back(MergeEditLine(id3l, src));
         }
         else if(!historyStart.exactMatch(oriLine))
         {
             melList.push_back(MergeEditLine(id3l, src));
         }
 
         bPrevLineIsEmpty = sLine.trimmed().isEmpty();
     }
     if(!key.isEmpty())
     {
         // Only insert new HistoryMapEntry if key not found; in either case p.first is a valid iterator to element key.
         std::pair<HistoryMap::iterator, bool> p = historyMap.insert(HistoryMap::value_type(key, HistoryMapEntry()));
         HistoryMapEntry& hme = p.first->second;
         if(src == A) hme.mellA = melList;
         if(src == B) hme.mellB = melList;
         if(src == C) hme.mellC = melList;
         if(p.second) // Not in list yet?
         {
             hitList.insert(itHitListFront, p.first);
         }
     }
     // End of the history
 }
 
 MergeEditLineList& MergeResultWindow::HistoryMapEntry::choice(bool bThreeInputs)
 {
     if(!bThreeInputs)
         return mellA.empty() ? mellB : mellA;
     else
     {
         if(mellA.empty())
             return mellC.empty() ? mellB : mellC; // A doesn't exist, return one that exists
         else if(!mellB.empty() && !mellC.empty())
         { // A, B and C exist
             return mellA;
         }
         else
             return mellB.empty() ? mellB : mellC; // A exists, return the one that doesn't exist
     }
 }
 
 bool MergeResultWindow::HistoryMapEntry::staysInPlace(bool bThreeInputs, Diff3LineList::const_iterator& iHistoryEnd)
 {
     // The entry should stay in place if the decision made by the automerger is correct.
     Diff3LineList::const_iterator& iHistoryLast = iHistoryEnd;
     --iHistoryLast;
     if(!bThreeInputs)
     {
         if(!mellA.empty() && !mellB.empty() && mellA.begin()->id3l() == mellB.begin()->id3l() &&
            mellA.back().id3l() == iHistoryLast && mellB.back().id3l() == iHistoryLast)
         {
             iHistoryEnd = mellA.begin()->id3l();
             return true;
         }
         else
         {
             return false;
         }
     }
     else
     {
         if(!mellA.empty() && !mellB.empty() && !mellC.empty() && mellA.begin()->id3l() == mellB.begin()->id3l() && mellA.begin()->id3l() == mellC.begin()->id3l() && mellA.back().id3l() == iHistoryLast && mellB.back().id3l() == iHistoryLast && mellC.back().id3l() == iHistoryLast)
         {
             iHistoryEnd = mellA.begin()->id3l();
             return true;
         }
         else
         {
             return false;
         }
     }
 }
 
 void MergeResultWindow::slotMergeHistory()
 {
     Diff3LineList::const_iterator iD3LHistoryBegin;
     Diff3LineList::const_iterator iD3LHistoryEnd;
     int d3lHistoryBeginLineIdx = -1;
     int d3lHistoryEndLineIdx = -1;
 
     // Search for history start, history end in the diff3LineList
     findHistoryRange(QRegExp(m_pOptions->m_historyStartRegExp), m_pldC != nullptr, m_pDiff3LineList, iD3LHistoryBegin, iD3LHistoryEnd, d3lHistoryBeginLineIdx, d3lHistoryEndLineIdx);
 
     if(iD3LHistoryBegin != m_pDiff3LineList->end())
     {
         // Now collect the historyMap information
         HistoryMap historyMap;
         std::list<HistoryMap::iterator> hitList;
         if(m_pldC == nullptr)
         {
             collectHistoryInformation(A, iD3LHistoryBegin, iD3LHistoryEnd, historyMap, hitList);
             collectHistoryInformation(B, iD3LHistoryBegin, iD3LHistoryEnd, historyMap, hitList);
         }
         else
         {
             collectHistoryInformation(A, iD3LHistoryBegin, iD3LHistoryEnd, historyMap, hitList);
             collectHistoryInformation(B, iD3LHistoryBegin, iD3LHistoryEnd, historyMap, hitList);
             collectHistoryInformation(C, iD3LHistoryBegin, iD3LHistoryEnd, historyMap, hitList);
         }
 
         Diff3LineList::const_iterator iD3LHistoryOrigEnd = iD3LHistoryEnd;
 
         bool bHistoryMergeSorting = m_pOptions->m_bHistoryMergeSorting && !m_pOptions->m_historyEntryStartSortKeyOrder.isEmpty() &&
                                     !m_pOptions->m_historyEntryStartRegExp.isEmpty();
 
         if(m_pOptions->m_maxNofHistoryEntries == -1)
         {
             // Remove parts from the historyMap and hitList that stay in place
             if(bHistoryMergeSorting)
             {
                 while(!historyMap.empty())
                 {
                     HistoryMap::iterator hMapIt = historyMap.begin();
                     if(hMapIt->second.staysInPlace(m_pldC != nullptr, iD3LHistoryEnd))
                         historyMap.erase(hMapIt);
                     else
                         break;
                 }
             }
             else
             {
                 while(!hitList.empty())
                 {
                     HistoryMap::iterator hMapIt = hitList.back();
                     if(hMapIt->second.staysInPlace(m_pldC != nullptr, iD3LHistoryEnd))
                         hitList.pop_back();
                     else
                         break;
                 }
             }
             while(iD3LHistoryOrigEnd != iD3LHistoryEnd)
             {
                 --iD3LHistoryOrigEnd;
                 --d3lHistoryEndLineIdx;
             }
         }
 
         MergeLineList::iterator iMLLStart = splitAtDiff3LineIdx(d3lHistoryBeginLineIdx);
         MergeLineList::iterator iMLLEnd = splitAtDiff3LineIdx(d3lHistoryEndLineIdx);
         // Now join all MergeLines in the history
         MergeLineList::iterator i = iMLLStart;
         if(i != iMLLEnd)
         {
             ++i;
             while(i != iMLLEnd)
             {
                 iMLLStart->join(*i);
                 i = m_mergeLineList.erase(i);
             }
         }
         iMLLStart->mergeEditLineList.clear();
         // Now insert the complete history into the first MergeLine of the history
         iMLLStart->mergeEditLineList.push_back(MergeEditLine(iD3LHistoryBegin, m_pldC == nullptr ? B : C));
         QString lead = calcHistoryLead(iD3LHistoryBegin->getString(A));
         MergeEditLine mel(m_pDiff3LineList->end());
         mel.setString(lead);
         iMLLStart->mergeEditLineList.push_back(mel);
 
         int historyCount = 0;
         if(bHistoryMergeSorting)
         {
             // Create a sorted history
             HistoryMap::reverse_iterator hmit;
             for(hmit = historyMap.rbegin(); hmit != historyMap.rend(); ++hmit)
             {
                 if(historyCount == m_pOptions->m_maxNofHistoryEntries)
                     break;
                 ++historyCount;
                 HistoryMapEntry& hme = hmit->second;
                 MergeEditLineList& mell = hme.choice(m_pldC != nullptr);
                 if(!mell.empty())
                     iMLLStart->mergeEditLineList.splice(iMLLStart->mergeEditLineList.end(), mell, mell.begin(), mell.end());
             }
         }
         else
         {
             // Create history in order of appearance
             std::list<HistoryMap::iterator>::iterator hlit;
             for(hlit = hitList.begin(); hlit != hitList.end(); ++hlit)
             {
                 if(historyCount == m_pOptions->m_maxNofHistoryEntries)
                     break;
                 ++historyCount;
                 HistoryMapEntry& hme = (*hlit)->second;
                 MergeEditLineList& mell = hme.choice(m_pldC != nullptr);
                 if(!mell.empty())
                     iMLLStart->mergeEditLineList.splice(iMLLStart->mergeEditLineList.end(), mell, mell.begin(), mell.end());
             }
             // If the end of start is empty and the first line at the end is empty remove the last line of start
             if(!iMLLStart->mergeEditLineList.empty() && !iMLLEnd->mergeEditLineList.empty())
             {
                 QString lastLineOfStart = iMLLStart->mergeEditLineList.back().getString(m_pldA, m_pldB, m_pldC);
                 QString firstLineOfEnd = iMLLEnd->mergeEditLineList.front().getString(m_pldA, m_pldB, m_pldC);
                 if(lastLineOfStart.mid(lead.length()).trimmed().isEmpty() && firstLineOfEnd.mid(lead.length()).trimmed().isEmpty())
                     iMLLStart->mergeEditLineList.pop_back();
             }
         }
         setFastSelector(iMLLStart);
         update();
     }
 }
 
 void MergeResultWindow::slotRegExpAutoMerge()
 {
     if(m_pOptions->m_autoMergeRegExp.isEmpty())
         return;
 
     QRegExp vcsKeywords(m_pOptions->m_autoMergeRegExp);
     MergeLineList::iterator i;
     for(i = m_mergeLineList.begin(); i != m_mergeLineList.end(); ++i)
     {
         if(i->bConflict)
         {
             Diff3LineList::const_iterator id3l = i->id3l;
             if(vcsKeywords.exactMatch(id3l->getString(A)) &&
                vcsKeywords.exactMatch(id3l->getString(B)) &&
                (m_pldC == nullptr || vcsKeywords.exactMatch(id3l->getString(C))))
             {
                 MergeEditLine& mel = *i->mergeEditLineList.begin();
                 mel.setSource(m_pldC == nullptr ? B : C, false);
                 splitAtDiff3LineIdx(i->d3lLineIdx + 1);
             }
         }
     }
     update();
 }
 
 // This doesn't detect user modifications and should only be called after automatic merge
 // This will only do something for three file merge.
 // Irrelevant changes are those where all contributions from B are already contained in C.
 // Also irrelevant are conflicts automatically solved (automerge regexp and history automerge)
 // Precondition: The VCS-keyword would also be C.
 bool MergeResultWindow::doRelevantChangesExist()
 {
     if(m_pldC == nullptr || m_mergeLineList.size() <= 1)
         return true;
 
     MergeLineList::iterator i;
     for(i = m_mergeLineList.begin(); i != m_mergeLineList.end(); ++i)
     {
         if((i->bConflict && i->mergeEditLineList.begin()->src() != C) || i->srcSelect == B)
         {
             return true;
         }
     }
 
     return false;
 }
 
 // Returns the iterator to the MergeLine after the split
 MergeLineList::iterator MergeResultWindow::splitAtDiff3LineIdx(int d3lLineIdx)
 {
     MergeLineList::iterator i;
     for(i = m_mergeLineList.begin(); i != m_mergeLineList.end(); ++i)
     {
         if(i->d3lLineIdx == d3lLineIdx)
         {
             // No split needed, this is the beginning of a MergeLine
             return i;
         }
         else if(i->d3lLineIdx > d3lLineIdx)
         {
             // The split must be in the previous MergeLine
             --i;
             MergeLine& ml = *i;
             MergeLine newML;
             ml.split(newML, d3lLineIdx);
             ++i;
             return m_mergeLineList.insert(i, newML);
         }
     }
     // The split must be in the previous MergeLine
     --i;
     MergeLine& ml = *i;
     MergeLine newML;
     ml.split(newML, d3lLineIdx);
     ++i;
     return m_mergeLineList.insert(i, newML);
 }
 
 void MergeResultWindow::slotSplitDiff(int firstD3lLineIdx, int lastD3lLineIdx)
 {
     if(lastD3lLineIdx >= 0)
         splitAtDiff3LineIdx(lastD3lLineIdx + 1);
     setFastSelector(splitAtDiff3LineIdx(firstD3lLineIdx));
 }
 
 void MergeResultWindow::slotJoinDiffs(int firstD3lLineIdx, int lastD3lLineIdx)
 {
     MergeLineList::iterator i;
     MergeLineList::iterator iMLLStart = m_mergeLineList.end();
     MergeLineList::iterator iMLLEnd = m_mergeLineList.end();
     for(i = m_mergeLineList.begin(); i != m_mergeLineList.end(); ++i)
     {
         MergeLine& ml = *i;
         if(firstD3lLineIdx >= ml.d3lLineIdx && firstD3lLineIdx < ml.d3lLineIdx + ml.srcRangeLength)
         {
             iMLLStart = i;
         }
         if(lastD3lLineIdx >= ml.d3lLineIdx && lastD3lLineIdx < ml.d3lLineIdx + ml.srcRangeLength)
         {
             iMLLEnd = i;
             ++iMLLEnd;
             break;
         }
     }
 
     bool bJoined = false;
     for(i = iMLLStart; i != iMLLEnd && i != m_mergeLineList.end();)
     {
         if(i == iMLLStart)
         {
             ++i;
         }
         else
         {
             iMLLStart->join(*i);
             i = m_mergeLineList.erase(i);
             bJoined = true;
         }
     }
     if(bJoined)
     {
         iMLLStart->mergeEditLineList.clear();
         // Insert a conflict line as placeholder
         iMLLStart->mergeEditLineList.push_back(MergeEditLine(iMLLStart->id3l));
     }
     setFastSelector(iMLLStart);
 }
 
 void MergeResultWindow::myUpdate(int afterMilliSecs)
 {
     if(m_delayedDrawTimer)
         killTimer(m_delayedDrawTimer);
     m_bMyUpdate = true;
     m_delayedDrawTimer = startTimer(afterMilliSecs);
 }
 
 void MergeResultWindow::timerEvent(QTimerEvent*)
 {
     killTimer(m_delayedDrawTimer);
     m_delayedDrawTimer = 0;
 
     if(m_bMyUpdate)
     {
         update();
         m_bMyUpdate = false;
     }
 
     if(m_scrollDeltaX != 0 || m_scrollDeltaY != 0)
     {
         m_selection.end(m_selection.getLastLine() + m_scrollDeltaY, m_selection.getLastPos() + m_scrollDeltaX);
         emit scrollMergeResultWindow(m_scrollDeltaX, m_scrollDeltaY);
         killTimer(m_delayedDrawTimer);
         m_delayedDrawTimer = startTimer(50);
     }
 }
 
 /// Converts the cursor-posOnScreen into a text index, considering tabulators.
 int convertToPosInText(const QString& /*s*/, int posOnScreen, int /*tabSize*/)
 {
     return posOnScreen;
 }
 
 //   int localPosOnScreen = 0;
 //   int size=s.length();
 //   for ( int i=0; i<size; ++i )
 //   {
 //      if ( localPosOnScreen>=posOnScreen )
 //         return i;
 
 //      // All letters except tabulator have width one.
 //      int letterWidth = s[i]!='\t' ? 1 : tabber( localPosOnScreen, tabSize );
 
 //      localPosOnScreen += letterWidth;
 
 //      if ( localPosOnScreen>posOnScreen )
 //         return i;
 //   }
 //   return size;
 //}
 
 /// Converts the index into the text to a cursor-posOnScreen considering tabulators.
 int convertToPosOnScreen(const QString& /*p*/, int posInText, int /*tabSize*/)
 {
     return posInText;
 }
 //   int posOnScreen = 0;
 //   for ( int i=0; i<posInText; ++i )
 //   {
 //      // All letters except tabulator have width one.
 //      int letterWidth = p[i]!='\t' ? 1 : tabber( posOnScreen, tabSize );
 
 //      posOnScreen += letterWidth;
 //   }
 //   return posOnScreen;
 //}
 
 QVector<QTextLayout::FormatRange> MergeResultWindow::getTextLayoutForLine(int line, const QString& str, QTextLayout& textLayout)
 {
     // tabs
     QTextOption textOption;
 #if QT_VERSION < QT_VERSION_CHECK(5, 10, 0)
     textOption.setTabStop(QFontMetricsF(font()).width(' ') * m_pOptions->m_tabSize);
 #else
     textOption.setTabStopDistance(QFontMetricsF(font()).width(' ') * m_pOptions->m_tabSize);
 #endif
     if(m_pOptions->m_bShowWhiteSpaceCharacters)
     {
         textOption.setFlags(QTextOption::ShowTabsAndSpaces);
     }
     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 = str.length();
         formatRange.format.setFont(font());
         formats.append(formatRange);
         textLayout.setFormats(formats);
     }
     QVector<QTextLayout::FormatRange> selectionFormat;
     textLayout.beginLayout();
     if(m_selection.lineWithin(line))
     {
         int firstPosInText = convertToPosInText(str, m_selection.firstPosInLine(line), m_pOptions->m_tabSize);
         int lastPosInText = convertToPosInText(str, m_selection.lastPosInLine(line), m_pOptions->m_tabSize);
         int lengthInText = std::max(0, lastPosInText - firstPosInText);
         if(lengthInText > 0)
             m_selection.bSelectionContainsData = true;
 
         QTextLayout::FormatRange selection;
         selection.start = firstPosInText;
         selection.length = lengthInText;
         selection.format.setBackground(palette().highlight());
         selection.format.setForeground(palette().highlightedText().color());
         selectionFormat.push_back(selection);
     }
     QTextLine textLine = textLayout.createLine();
     textLine.setPosition(QPointF(0, fontMetrics().leading()));
     textLayout.endLayout();
     int cursorWidth = 5;
     if(m_pOptions->m_bRightToLeftLanguage)
         textLayout.setPosition(QPointF(width() - textLayout.maximumWidth() - getTextXOffset() + m_horizScrollOffset - cursorWidth, 0));
     else
         textLayout.setPosition(QPointF(getTextXOffset() - m_horizScrollOffset, 0));
     return selectionFormat;
 }
 
 void MergeResultWindow::writeLine(
     RLPainter& p, int line, const QString& str,
     int srcSelect, e_MergeDetails mergeDetails, int rangeMark, bool bUserModified, bool bLineRemoved, bool bWhiteSpaceConflict)
 {
     const QFontMetrics& fm = fontMetrics();
     int fontHeight = fm.lineSpacing();
     int fontAscent = fm.ascent();
 
     int topLineYOffset = 0;
     int xOffset = getTextXOffset();
 
     int yOffset = (line - m_firstLine) * fontHeight;
     if(yOffset < 0 || yOffset > height())
         return;
 
     yOffset += topLineYOffset;
 
     QString srcName = QChar(' ');
     if(bUserModified)
         srcName = QChar('m');
     else if(srcSelect == A && mergeDetails != eNoChange)
         srcName = i18n("A");
     else if(srcSelect == B)
         srcName = i18n("B");
     else if(srcSelect == C)
         srcName = i18n("C");
 
     if(rangeMark & 4)
     {
         p.fillRect(xOffset, yOffset, width(), fontHeight, m_pOptions->m_currentRangeBgColor);
     }
 
     if((srcSelect > 0 || bUserModified) && !bLineRemoved)
     {
         if(!m_pOptions->m_bRightToLeftLanguage)
             p.setClipRect(QRectF(xOffset, 0, width() - xOffset, height()));
         else
             p.setClipRect(QRectF(0, 0, width() - xOffset, height()));
 
         int outPos = 0;
         QString s;
         int size = str.length();
         for(int i = 0; i < size; ++i)
         {
             int spaces = 1;
             if(str[i] == '\t')
             {
                 spaces = tabber(outPos, m_pOptions->m_tabSize);
                 for(int j = 0; j < spaces; ++j)
                     s += ' ';
             }
             else
             {
                 s += str[i];
             }
             outPos += spaces;
         }
 
         p.setPen(m_pOptions->m_fgColor);
 
         QTextLayout textLayout(str, font(), this);
         QVector<QTextLayout::FormatRange> selectionFormat = getTextLayoutForLine(line, str, textLayout);
         textLayout.draw(&p, QPointF(0, yOffset), selectionFormat);
 
         if(line == m_cursorYPos)
         {
             m_cursorXPixelPos =  qCeil(textLayout.lineAt(0).cursorToX(m_cursorXPos));
             if(m_pOptions->m_bRightToLeftLanguage)
                 m_cursorXPixelPos +=  qCeil(textLayout.position().x() - m_horizScrollOffset);
         }
 
         p.setClipping(false);
 
         p.setPen(m_pOptions->m_fgColor);
 
         p.drawText(1, yOffset + fontAscent, srcName, true);
     }
     else if(bLineRemoved)
     {
         p.setPen(m_pOptions->m_colorForConflict);
         p.drawText(xOffset, yOffset + fontAscent, i18n("<No src line>"));
         p.drawText(1, yOffset + fontAscent, srcName);
         if(m_cursorYPos == line) m_cursorXPos = 0;
     }
     else if(srcSelect == 0)
     {
         p.setPen(m_pOptions->m_colorForConflict);
         if(bWhiteSpaceConflict)
             p.drawText(xOffset, yOffset + fontAscent, i18n("<Merge Conflict (Whitespace only)>"));
         else
             p.drawText(xOffset, yOffset + fontAscent, i18n("<Merge Conflict>"));
         p.drawText(1, yOffset + fontAscent, "?");
         if(m_cursorYPos == line) m_cursorXPos = 0;
     }
     else
         Q_ASSERT(true);
 
     xOffset -= Utils::getHorizontalAdvance(fm, '0');
     p.setPen(m_pOptions->m_fgColor);
     if(rangeMark & 1) // begin mark
     {
         p.drawLine(xOffset, yOffset + 1, xOffset, yOffset + fontHeight / 2);
         p.drawLine(xOffset, yOffset + 1, xOffset - 2, yOffset + 1);
     }
     else
     {
         p.drawLine(xOffset, yOffset, xOffset, yOffset + fontHeight / 2);
     }
 
     if(rangeMark & 2) // end mark
     {
         p.drawLine(xOffset, yOffset + fontHeight / 2, xOffset, yOffset + fontHeight - 1);
         p.drawLine(xOffset, yOffset + fontHeight - 1, xOffset - 2, yOffset + fontHeight - 1);
     }
     else
     {
         p.drawLine(xOffset, yOffset + fontHeight / 2, xOffset, yOffset + fontHeight);
     }
 
     if(rangeMark & 4)
     {
         p.fillRect(xOffset + 3, yOffset, 3, fontHeight, m_pOptions->m_fgColor);
         /*      p.setPen( blue );
       p.drawLine( xOffset+2, yOffset, xOffset+2, yOffset+fontHeight-1 );
       p.drawLine( xOffset+3, yOffset, xOffset+3, yOffset+fontHeight-1 );*/
     }
 }
 
 void MergeResultWindow::setPaintingAllowed(bool bPaintingAllowed)
 {
     setUpdatesEnabled(bPaintingAllowed);
     if(!bPaintingAllowed)
     {
         m_currentMergeLineIt = m_mergeLineList.end();
         reset();
     }
     else
         update();
 }
 
 void MergeResultWindow::paintEvent(QPaintEvent*)
 {
     if(m_pDiff3LineList == nullptr)
         return;
 
     bool bOldSelectionContainsData = m_selection.selectionContainsData();
     const QFontMetrics& fm = fontMetrics();
     int fontWidth = Utils::getHorizontalAdvance(fm, '0');
 
     if(!m_bCursorUpdate) // Don't redraw everything for blinking cursor?
     {
         m_selection.bSelectionContainsData = false;
         if(size() != m_pixmap.size())
             m_pixmap = QPixmap(size());
 
         RLPainter p(&m_pixmap, m_pOptions->m_bRightToLeftLanguage, width(), fontWidth);
         p.setFont(font());
         p.QPainter::fillRect(rect(), m_pOptions->m_bgColor);
 
         //int visibleLines = height() / fontHeight;
 
         int lastVisibleLine = m_firstLine + getNofVisibleLines() + 5;
         LineRef line = 0;
         MergeLineList::iterator mlIt = m_mergeLineList.begin();
         for(mlIt = m_mergeLineList.begin(); mlIt != m_mergeLineList.end(); ++mlIt)
         {
             MergeLine& ml = *mlIt;
             if(line > lastVisibleLine || line + ml.mergeEditLineList.size() < m_firstLine)
             {
                 line += ml.mergeEditLineList.size();
             }
             else
             {
                 MergeEditLineList::iterator melIt;
                 for(melIt = ml.mergeEditLineList.begin(); melIt != ml.mergeEditLineList.end(); ++melIt)
                 {
                     if(line >= m_firstLine && line <= lastVisibleLine)
                     {
                         MergeEditLine& mel = *melIt;
                         MergeEditLineList::iterator melIt1 = melIt;
                         ++melIt1;
 
                         int rangeMark = 0;
                         if(melIt == ml.mergeEditLineList.begin()) rangeMark |= 1; // Begin range mark
                         if(melIt1 == ml.mergeEditLineList.end()) rangeMark |= 2;  // End range mark
 
                         if(mlIt == m_currentMergeLineIt) rangeMark |= 4; // Mark of the current line
 
                         QString s;
                         s = mel.getString(m_pldA, m_pldB, m_pldC);
 
                         writeLine(p, line, s, mel.src(), ml.mergeDetails, rangeMark,
                                   mel.isModified(), mel.isRemoved(), ml.bWhiteSpaceConflict);
                     }
                     ++line;
                 }
             }
         }
 
         if(line != m_nofLines)
         {
             m_nofLines = line;
 
             emit resizeSignal();
         }
 
         p.end();
     }
 
     QPainter painter(this);
 
     if(!m_bCursorUpdate)
         painter.drawPixmap(0, 0, m_pixmap);
     else
     {
         painter.drawPixmap(0, 0, m_pixmap); // Draw everything. (Internally cursor rect is clipped anyway.)
         m_bCursorUpdate = false;
     }
 
     if(m_bCursorOn && hasFocus() && m_cursorYPos >= m_firstLine)
     {
         painter.setPen(m_pOptions->m_fgColor);
 
         QString str = getString(m_cursorYPos);
         QTextLayout textLayout(str, font(), this);
         getTextLayoutForLine(m_cursorYPos, str, textLayout);
         textLayout.drawCursor(&painter, QPointF(0, (m_cursorYPos - m_firstLine) * fontMetrics().lineSpacing()), m_cursorXPos);
     }
 
     painter.end();
 
     if(!bOldSelectionContainsData && m_selection.selectionContainsData())
         emit newSelection();
 }
 
 void MergeResultWindow::updateSourceMask()
 {
     int srcMask = 0;
     int enabledMask = 0;
     if(!hasFocus() || m_pDiff3LineList == nullptr || !updatesEnabled() || m_currentMergeLineIt == m_mergeLineList.end())
     {
         srcMask = 0;
         enabledMask = 0;
     }
     else
     {
         enabledMask = m_pldC == nullptr ? 3 : 7;
         MergeLine& ml = *m_currentMergeLineIt;
 
         srcMask = 0;
         bool bModified = false;
         MergeEditLineList::iterator melIt;
         for(melIt = ml.mergeEditLineList.begin(); melIt != ml.mergeEditLineList.end(); ++melIt)
         {
             MergeEditLine& mel = *melIt;
             if(mel.src() == A) srcMask |= 1;
             if(mel.src() == B) srcMask |= 2;
             if(mel.src() == C) srcMask |= 4;
             if(mel.isModified() || !mel.isEditableText()) bModified = true;
         }
 
         if(ml.mergeDetails == eNoChange)
         {
             srcMask = 0;
             enabledMask = bModified ? 1 : 0;
         }
     }
 
     emit sourceMask(srcMask, enabledMask);
 }
 
 void MergeResultWindow::focusInEvent(QFocusEvent* e)
 {
     updateSourceMask();
     QWidget::focusInEvent(e);
 }
 
 LineRef MergeResultWindow::convertToLine(int y)
 {
     const QFontMetrics& fm = fontMetrics();
     int fontHeight = fm.lineSpacing();
     int topLineYOffset = 0;
 
     int yOffset = topLineYOffset - m_firstLine * fontHeight;
 
     LineRef line = std::min((y - yOffset) / fontHeight, m_nofLines - 1);
     return line;
 }
 
 void MergeResultWindow::mousePressEvent(QMouseEvent* e)
 {
     m_bCursorOn = true;
 
     int xOffset = getTextXOffset();
 
     LineRef line = convertToLine(e->y());
     QString s = getString(line);
     QTextLayout textLayout(s, font(), this);
     getTextLayoutForLine(line, s, textLayout);
     QtNumberType pos = textLayout.lineAt(0).xToCursor(e->x() - textLayout.position().x());
 
     bool bLMB = e->button() == Qt::LeftButton;
     bool bMMB = e->button() == Qt::MidButton;
     bool bRMB = e->button() == Qt::RightButton;
 
     if((bLMB && (e->x() < xOffset)) || bRMB) // Fast range selection
     {
         m_cursorXPos = 0;
         m_cursorOldXPixelPos = 0;
         m_cursorYPos = std::max((LineRef::LineType)line, 0);
         int l = 0;
         MergeLineList::iterator i = m_mergeLineList.begin();
         for(i = m_mergeLineList.begin(); i != m_mergeLineList.end(); ++i)
         {
             if(l == line)
                 break;
 
             l += i->mergeEditLineList.size();
             if(l > line)
                 break;
         }
         m_selection.reset(); // Disable current selection
 
         m_bCursorOn = true;
         setFastSelector(i);
 
         if(bRMB)
         {
             emit showPopupMenu(QCursor::pos());
         }
     }
     else if(bLMB) // Normal cursor placement
     {
         pos = std::max(pos, 0);
         line = std::max((LineRef::LineType)line, 0);
         if(e->QInputEvent::modifiers() & Qt::ShiftModifier)
         {
             if(!m_selection.isValidFirstLine())
                 m_selection.start(line, pos);
             m_selection.end(line, pos);
         }
         else
         {
             // Selection
             m_selection.reset();
             m_selection.start(line, pos);
             m_selection.end(line, pos);
         }
         m_cursorXPos = pos;
         m_cursorXPixelPos =  qCeil(textLayout.lineAt(0).cursorToX(pos));
         if(m_pOptions->m_bRightToLeftLanguage)
             m_cursorXPixelPos +=  qCeil(textLayout.position().x() - m_horizScrollOffset);
         m_cursorOldXPixelPos = m_cursorXPixelPos;
         m_cursorYPos = line;
 
         update();
         //showStatusLine( line, m_winIdx, m_pFilename, m_pDiff3LineList, m_pStatusBar );
     }
     else if(bMMB) // Paste clipboard
     {
         pos = std::max(pos, 0);
         line = std::max((LineRef::LineType)line, 0);
 
         m_selection.reset();
         m_cursorXPos = pos;
         m_cursorOldXPixelPos = m_cursorXPixelPos;
         m_cursorYPos = line;
 
         pasteClipboard(true);
     }
 }
 
 void MergeResultWindow::mouseDoubleClickEvent(QMouseEvent* e)
 {
     if(e->button() == Qt::LeftButton)
     {
         LineRef line = convertToLine(e->y());
         QString s = getString(line);
         QTextLayout textLayout(s, font(), this);
         getTextLayoutForLine(line, s, textLayout);
         int pos = textLayout.lineAt(0).xToCursor(e->x() - textLayout.position().x());
         m_cursorXPos = pos;
         m_cursorOldXPixelPos = m_cursorXPixelPos;
         m_cursorYPos = line;
 
         if(!s.isEmpty())
         {
             int pos1, pos2;
 
             calcTokenPos(s, pos, pos1, pos2, m_pOptions->m_tabSize);
 
             resetSelection();
             m_selection.start(line, convertToPosOnScreen(s, pos1, m_pOptions->m_tabSize));
             m_selection.end(line, convertToPosOnScreen(s, pos2, m_pOptions->m_tabSize));
 
             update();
             // emit selectionEnd() happens in the mouseReleaseEvent.
         }
     }
 }
 
 void MergeResultWindow::mouseReleaseEvent(QMouseEvent* e)
 {
     if(e->button() == Qt::LeftButton)
     {
         if(m_delayedDrawTimer)
         {
             killTimer(m_delayedDrawTimer);
             m_delayedDrawTimer = 0;
         }
 
         if(m_selection.isValidFirstLine())
         {
             emit selectionEnd();
         }
     }
 }
 
 void MergeResultWindow::mouseMoveEvent(QMouseEvent* e)
 {
     LineRef line = convertToLine(e->y());
     QString s = getString(line);
     QTextLayout textLayout(s, font(), this);
     getTextLayoutForLine(line, s, textLayout);
     int pos = textLayout.lineAt(0).xToCursor(e->x() - textLayout.position().x());
     m_cursorXPos = pos;
     m_cursorOldXPixelPos = m_cursorXPixelPos;
     m_cursorYPos = line;
     if(m_selection.isValidFirstLine())
     {
         m_selection.end(line, pos);
         myUpdate(0);
 
         //showStatusLine( line, m_winIdx, m_pFilename, m_pDiff3LineList, m_pStatusBar );
 
         // Scroll because mouse moved out of the window
         const QFontMetrics& fm = fontMetrics();
         int fontWidth = Utils::getHorizontalAdvance(fm, '0');
         int topLineYOffset = 0;
         int deltaX = 0;
         int deltaY = 0;
         if(!m_pOptions->m_bRightToLeftLanguage)
         {
             if(e->x() < getTextXOffset()) deltaX = -1;
             if(e->x() > width()) deltaX = +1;
         }
         else
         {
             if(e->x() > width() - 1 - getTextXOffset()) deltaX = -1;
             if(e->x() < fontWidth) deltaX = +1;
         }
         if(e->y() < topLineYOffset) deltaY = -1;
         if(e->y() > height()) deltaY = +1;
         m_scrollDeltaX = deltaX;
         m_scrollDeltaY = deltaY;
         if(deltaX != 0 || deltaY != 0)
         {
             emit scrollMergeResultWindow(deltaX, deltaY);
         }
     }
 }
 
 void MergeResultWindow::slotCursorUpdate()
 {
     m_cursorTimer.stop();
     m_bCursorOn = !m_bCursorOn;
 
     if(isVisible())
     {
         m_bCursorUpdate = true;
 
         const QFontMetrics& fm = fontMetrics();
         int topLineYOffset = 0;
         int yOffset = (m_cursorYPos - m_firstLine) * fm.lineSpacing() + topLineYOffset;
 
         repaint(0, yOffset, width(), fm.lineSpacing() + 2);
 
         m_bCursorUpdate = false;
     }
 
     m_cursorTimer.start(500);
 }
 
 void MergeResultWindow::wheelEvent(QWheelEvent* e)
 {
     int d = -e->delta() * QApplication::wheelScrollLines() / 120;
     e->accept();
     emit scrollMergeResultWindow(0, std::min(d, getNofVisibleLines()));
 }
 
 bool MergeResultWindow::event(QEvent* e)
 {
     if(e->type() == QEvent::KeyPress)
     {
         QKeyEvent* ke = static_cast<QKeyEvent*>(e);
         if(ke->key() == Qt::Key_Tab)
         {
             // special tab handling here to avoid moving focus
             keyPressEvent(ke);
             return true;
         }
     }
     return QWidget::event(e);
 }
 void MergeResultWindow::keyPressEvent(QKeyEvent* e)
 {
     int y = m_cursorYPos;
     MergeLineList::iterator mlIt;
     MergeEditLineList::iterator melIt;
     calcIteratorFromLineNr(y, mlIt, melIt);
 
     QString str = melIt->getString(m_pldA, m_pldB, m_pldC);
     int x = convertToPosInText(str, m_cursorXPos, m_pOptions->m_tabSize);
 
     QTextLayout textLayoutOrig(str, font(), this);
     getTextLayoutForLine(y, str, textLayoutOrig);
 
     bool bCtrl = (e->QInputEvent::modifiers() & Qt::ControlModifier) != 0;
     bool bShift = (e->QInputEvent::modifiers() & Qt::ShiftModifier) != 0;
 #ifdef Q_OS_WIN
     bool bAlt = (e->QInputEvent::modifiers() & Qt::AltModifier) != 0;
     if(bCtrl && bAlt)
     {
         bCtrl = false;
         bAlt = false;
     } // AltGr-Key pressed.
 #endif
 
     bool bYMoveKey = false;
     // Special keys
     switch(e->key())
     {
     case Qt::Key_Escape:
         break;
     //case  Key_Tab:          break;
     case Qt::Key_Backtab:
         break;
     case Qt::Key_Delete:
     {
         if(deleteSelection2(str, x, y, mlIt, melIt)) break;
         if(!melIt->isEditableText()) break;
         if(x >= str.length())
         {
             if(y < m_nofLines - 1)
             {
                 setModified();
                 MergeLineList::iterator mlIt1;
                 MergeEditLineList::iterator melIt1;
                 calcIteratorFromLineNr(y + 1, mlIt1, melIt1);
                 if(melIt1->isEditableText())
                 {
                     QString s2 = melIt1->getString(m_pldA, m_pldB, m_pldC);
                     melIt->setString(str + s2);
 
                     // Remove the line
                     if(mlIt1->mergeEditLineList.size() > 1)
                         mlIt1->mergeEditLineList.erase(melIt1);
                     else
                         melIt1->setRemoved();
                 }
             }
         }
         else
         {
             QString s = str.left(x);
             s += str.midRef(x + 1);
             melIt->setString(s);
             setModified();
         }
         break;
     }
     case Qt::Key_Backspace:
     {
         if(deleteSelection2(str, x, y, mlIt, melIt)) break;
         if(!melIt->isEditableText()) break;
         if(x == 0)
         {
             if(y > 0)
             {
                 setModified();
                 MergeLineList::iterator mlIt1;
                 MergeEditLineList::iterator melIt1;
                 calcIteratorFromLineNr(y - 1, mlIt1, melIt1);
                 if(melIt1->isEditableText())
                 {
                     QString s1 = melIt1->getString(m_pldA, m_pldB, m_pldC);
                     melIt1->setString(s1 + str);
 
                     // Remove the previous line
                     if(mlIt->mergeEditLineList.size() > 1)
                         mlIt->mergeEditLineList.erase(melIt);
                     else
                         melIt->setRemoved();
 
                     --y;
                     x = str.length();
                 }
             }
         }
         else
         {
             QString s = str.left(x - 1);
             s += str.midRef(x);
             --x;
             melIt->setString(s);
             setModified();
         }
         break;
     }
     case Qt::Key_Return:
     case Qt::Key_Enter:
     {
         if(!melIt->isEditableText()) break;
         deleteSelection2(str, x, y, mlIt, melIt);
         setModified();
         QString indentation;
         if(m_pOptions->m_bAutoIndentation)
         { // calc last indentation
             MergeLineList::iterator mlIt1 = mlIt;
             MergeEditLineList::iterator melIt1 = melIt;
             for(;;)
             {
                 const QString s = melIt1->getString(m_pldA, m_pldB, m_pldC);
                 if(!s.isEmpty())
                 {
                     int i;
                     for(i = 0; i < s.length(); ++i)
                     {
                         if(s[i] != ' ' && s[i] != '\t') break;
                     }
                     if(i < s.length())
                     {
                         indentation = s.left(i);
                         break;
                     }
                 }
                 // Go back one line
                 if(melIt1 != mlIt1->mergeEditLineList.begin())
                     --melIt1;
                 else
                 {
                     if(mlIt1 == m_mergeLineList.begin()) break;
                     --mlIt1;
                     melIt1 = mlIt1->mergeEditLineList.end();
                     --melIt1;
                 }
             }
         }
         MergeEditLine mel(mlIt->id3l); // Associate every mel with an id3l, even if not really valid.
         mel.setString(indentation + str.mid(x));
 
         if(x < str.length()) // Cut off the old line.
         {
             // Since ps possibly points into melIt->str, first copy it into a temporary.
             QString temp = str.left(x);
             melIt->setString(temp);
         }
 
         ++melIt;
         mlIt->mergeEditLineList.insert(melIt, mel);
         x = indentation.length();
         ++y;
         break;
     }
     case Qt::Key_Insert:
         m_bInsertMode = !m_bInsertMode;
         break;
     case Qt::Key_Pause:
         break;
     case Qt::Key_Print:
         break;
     case Qt::Key_SysReq:
         break;
     case Qt::Key_Home:
         x = 0;
         if(bCtrl)
         {
             y = 0;
         }
         break; // cursor movement
     case Qt::Key_End:
         x = INT_MAX;
         if(bCtrl)
         {
             y = INT_MAX;
         }
         break;
 
     case Qt::Key_Left:
     case Qt::Key_Right:
         if((e->key() == Qt::Key_Left) != m_pOptions->m_bRightToLeftLanguage)
         {
             if(!bCtrl)
             {
                 int newX = textLayoutOrig.previousCursorPosition(x);
                 if(newX == x && y > 0)
                 {
                     --y;
                     x = INT_MAX;
                 }
                 else
                 {
                     x = newX;
                 }
             }
             else
             {
                 while(x > 0 && (str[x - 1] == ' ' || str[x - 1] == '\t'))
                 {
                     int newX = textLayoutOrig.previousCursorPosition(x);
                     if(newX == x) break;
                     x = newX;
                 }
                 while(x > 0 && (str[x - 1] != ' ' && str[x - 1] != '\t'))
                 {
                     int newX = textLayoutOrig.previousCursorPosition(x);
                     if(newX == x) break;
                     x = newX;
                 }
             }
         }
         else
         {
             if(!bCtrl)
             {
                 int newX = textLayoutOrig.nextCursorPosition(x);
                 if(newX == x && y < m_nofLines - 1)
                 {
                     ++y;
                     x = 0;
                 }
                 else
                 {
                     x = newX;
                 }
             }
             else
             {
                 while(x < str.length() && (str[x] == ' ' || str[x] == '\t'))
                 {
                     int newX = textLayoutOrig.nextCursorPosition(x);
                     if(newX == x) break;
                     x = newX;
                 }
                 while(x < str.length() && (str[x] != ' ' && str[x] != '\t'))
                 {
                     int newX = textLayoutOrig.nextCursorPosition(x);
                     if(newX == x) break;
                     x = newX;
                 }
             }
         }
         break;
 
     case Qt::Key_Up:
         if(!bCtrl)
         {
             --y;
             bYMoveKey = true;
         }
         break;
     case Qt::Key_Down:
         if(!bCtrl)
         {
             ++y;
             bYMoveKey = true;
         }
         break;
     case Qt::Key_PageUp:
         if(!bCtrl)
         {
             y -= getNofVisibleLines();
             bYMoveKey = true;
         }
         break;
     case Qt::Key_PageDown:
         if(!bCtrl)
         {
             y += getNofVisibleLines();
             bYMoveKey = true;
         }
         break;
     default:
     {
         QString t = e->text();
         if(t.isEmpty() || bCtrl)
         {
             e->ignore();
             return;
         }
         else
         {
             if(bCtrl)
             {
                 e->ignore();
                 return;
             }
             else
             {
                 if(!melIt->isEditableText()) break;
                 deleteSelection2(str, x, y, mlIt, melIt);
 
                 setModified();
                 // Characters to insert
                 QString s = str;
                 if(t[0] == '\t' && m_pOptions->m_bReplaceTabs)
                 {
                     int spaces = (m_cursorXPos / m_pOptions->m_tabSize + 1) * m_pOptions->m_tabSize - m_cursorXPos;
                     t.fill(' ', spaces);
                 }
                 if(m_bInsertMode)
                     s.insert(x, t);
                 else
                     s.replace(x, t.length(), t);
 
                 melIt->setString(s);
                 x += t.length();
                 bShift = false;
             }
         }
     }
     }
 
     y = qBound(0, y, m_nofLines - 1);
 
     calcIteratorFromLineNr(y, mlIt, melIt);
     str = melIt->getString(m_pldA, m_pldB, m_pldC);
 
     x = qBound(0, x, (int)str.length());
 
     int newFirstLine = m_firstLine;
     int newHorizScrollOffset = m_horizScrollOffset;
 
     if(y < m_firstLine)
         newFirstLine = y;
     else if(y > m_firstLine + getNofVisibleLines())
         newFirstLine = y - getNofVisibleLines();
 
     QTextLayout textLayout(str, font(), this);
     getTextLayoutForLine(m_cursorYPos, str, textLayout);
 
     // try to preserve cursor x pixel position when moving to another line
     if(bYMoveKey)
     {
         if(m_pOptions->m_bRightToLeftLanguage)
             x = textLayout.lineAt(0).xToCursor(m_cursorOldXPixelPos - (textLayout.position().x() - m_horizScrollOffset));
         else
             x = textLayout.lineAt(0).xToCursor(m_cursorOldXPixelPos);
     }
 
     m_cursorXPixelPos =  qCeil(textLayout.lineAt(0).cursorToX(x));
     int hF = 1; // horizontal factor
     if(m_pOptions->m_bRightToLeftLanguage)
     {
         m_cursorXPixelPos +=  qCeil(textLayout.position().x() - m_horizScrollOffset);
         hF = -1;
     }
     int cursorWidth = 5;
     if(m_cursorXPixelPos < hF * m_horizScrollOffset)
         newHorizScrollOffset = hF * m_cursorXPixelPos;
     else if(m_cursorXPixelPos > hF * m_horizScrollOffset + getVisibleTextAreaWidth() - cursorWidth)
         newHorizScrollOffset = hF * (m_cursorXPixelPos - (getVisibleTextAreaWidth() - cursorWidth));
 
     int newCursorX = x;
     if(bShift)
     {
         if(!m_selection.isValidFirstLine())
             m_selection.start(m_cursorYPos, m_cursorXPos);
 
         m_selection.end(y, newCursorX);
     }
     else
         m_selection.reset();
 
     m_cursorYPos = y;
     m_cursorXPos = newCursorX;
 
     // TODO if width of current line exceeds the current maximum width then force recalculating the scrollbars
     if(textLayout.maximumWidth() > getMaxTextWidth())
     {
         m_maxTextWidth =  qCeil(textLayout.maximumWidth());
         emit resizeSignal();
     }
     if(!bYMoveKey)
         m_cursorOldXPixelPos = m_cursorXPixelPos;
 
     m_bCursorOn = true;
     m_cursorTimer.start(500);
 
     update();
     if(newFirstLine != m_firstLine || newHorizScrollOffset != m_horizScrollOffset)
     {
         emit scrollMergeResultWindow(newHorizScrollOffset - m_horizScrollOffset, newFirstLine - m_firstLine);
         return;
     }
 }
 
 void MergeResultWindow::calcIteratorFromLineNr(
     int line,
     MergeLineList::iterator& mlIt,
     MergeEditLineList::iterator& melIt)
 {
     for(mlIt = m_mergeLineList.begin(); mlIt != m_mergeLineList.end(); ++mlIt)
     {
         MergeLine& ml = *mlIt;
         if(line > ml.mergeEditLineList.size())
         {
             line -= ml.mergeEditLineList.size();
         }
         else
         {
             for(melIt = ml.mergeEditLineList.begin(); melIt != ml.mergeEditLineList.end(); ++melIt)
             {
                 --line;
                 if(line < 0) return;
             }
         }
     }
 }
 
 QString MergeResultWindow::getSelection()
 {
     QString selectionString;
 
     int line = 0;
     MergeLineList::iterator mlIt = m_mergeLineList.begin();
     for(mlIt = m_mergeLineList.begin(); mlIt != m_mergeLineList.end(); ++mlIt)
     {
         MergeLine& ml = *mlIt;
         MergeEditLineList::iterator melIt;
         for(melIt = ml.mergeEditLineList.begin(); melIt != ml.mergeEditLineList.end(); ++melIt)
         {
             MergeEditLine& mel = *melIt;
 
             if(m_selection.lineWithin(line))
             {
                 int outPos = 0;
                 if(mel.isEditableText())
                 {
                     const QString str = mel.getString(m_pldA, m_pldB, m_pldC);
 
                     // Consider tabs
 
                     for(int i = 0; i < str.length(); ++i)
                     {
                         int spaces = 1;
                         if(str[i] == '\t')
                         {
                             spaces = tabber(outPos, m_pOptions->m_tabSize);
                         }
 
                         if(m_selection.within(line, outPos))
                         {
                             selectionString += str[i];
                         }
 
                         outPos += spaces;
                     }
                 }
                 else if(mel.isConflict())
                 {
                     selectionString += i18n("<Merge Conflict>");
                 }
 
                 if(m_selection.within(line, outPos))
                 {
 #ifdef Q_OS_WIN
                     selectionString += '\r';
 #endif
                     selectionString += '\n';
                 }
             }
 
             ++line;
         }
     }
 
     return selectionString;
 }
 
 bool MergeResultWindow::deleteSelection2(QString& s, int& x, int& y,
                                          MergeLineList::iterator& mlIt, MergeEditLineList::iterator& melIt)
 {
     if(m_selection.selectionContainsData())
     {
         Q_ASSERT(m_selection.isValidFirstLine());
         deleteSelection();
         y = m_cursorYPos;
         calcIteratorFromLineNr(y, mlIt, melIt);
         s = melIt->getString(m_pldA, m_pldB, m_pldC);
         x = convertToPosInText(s, m_cursorXPos, m_pOptions->m_tabSize);
         return true;
     }
 
     return false;
 }
 
 void MergeResultWindow::deleteSelection()
 {
     if(!m_selection.selectionContainsData())
     {
         return;
     }
     Q_ASSERT(m_selection.isValidFirstLine());
 
     setModified();
 
     LineRef line = 0;
     MergeLineList::iterator mlItFirst;
     MergeEditLineList::iterator melItFirst;
     QString firstLineString;
 
     LineRef firstLine;
     LineRef lastLine;
 
     MergeLineList::iterator mlIt;
     for(mlIt = m_mergeLineList.begin(); mlIt != m_mergeLineList.end(); ++mlIt)
     {
         MergeLine& ml = *mlIt;
         MergeEditLineList::iterator melIt;
         for(melIt = ml.mergeEditLineList.begin(); melIt != ml.mergeEditLineList.end(); ++melIt)
         {
             MergeEditLine& mel = *melIt;
 
             if(mel.isEditableText() && m_selection.lineWithin(line))
             {
                 if(!firstLine.isValid())
                     firstLine = line;
                 lastLine = line;
             }
 
             ++line;
         }
     }
 
     if(!firstLine.isValid())
     {
         return; // Nothing to delete.
     }
 
     line = 0;
     for(mlIt = m_mergeLineList.begin(); mlIt != m_mergeLineList.end(); ++mlIt)
     {
         MergeLine& ml = *mlIt;
         MergeEditLineList::iterator melIt, melIt1;
         for(melIt = ml.mergeEditLineList.begin(); melIt != ml.mergeEditLineList.end();)
         {
             MergeEditLine& mel = *melIt;
             melIt1 = melIt;
             ++melIt1;
 
             if(mel.isEditableText() && m_selection.lineWithin(line))
             {
                 QString lineString = mel.getString(m_pldA, m_pldB, m_pldC);
 
                 int firstPosInLine = m_selection.firstPosInLine(line);
                 int lastPosInLine = m_selection.lastPosInLine(line);
 
                 if(line == firstLine)
                 {
                     mlItFirst = mlIt;
                     melItFirst = melIt;
                     int pos = convertToPosInText(lineString, firstPosInLine, m_pOptions->m_tabSize);
                     firstLineString = lineString.left(pos);
                 }
 
                 if(line == lastLine)
                 {
                     // This is the last line in the selection
                     int pos = convertToPosInText(lineString, lastPosInLine, m_pOptions->m_tabSize);
                     firstLineString += lineString.midRef(pos); // rest of line
                     melItFirst->setString(firstLineString);
                 }
 
                 if(line != firstLine || (m_selection.endPos() - m_selection.beginPos()) == lineString.length())
                 {
                     // Remove the line
                     if(mlIt->mergeEditLineList.size() > 1)
                         mlIt->mergeEditLineList.erase(melIt);
                     else
                         melIt->setRemoved();
                 }
             }
 
             ++line;
             melIt = melIt1;
         }
     }
 
     m_cursorYPos = m_selection.beginLine();
     m_cursorXPos = m_selection.beginPos();
     m_cursorOldXPixelPos = m_cursorXPixelPos;
 
     m_selection.reset();
 }
 
 void MergeResultWindow::pasteClipboard(bool bFromSelection)
 {
     //checking of m_selection if needed is done by deleteSelection no need for check here.
     deleteSelection();
 
     setModified();
 
     int y = m_cursorYPos;
     MergeLineList::iterator mlIt;
     MergeEditLineList::iterator melIt, melItAfter;
     calcIteratorFromLineNr(y, mlIt, melIt);
     melItAfter = melIt;
     ++melItAfter;
     QString str = melIt->getString(m_pldA, m_pldB, m_pldC);
     int x = convertToPosInText(str, m_cursorXPos, m_pOptions->m_tabSize);
 
     if(!QApplication::clipboard()->supportsSelection())
         bFromSelection = false;
 
     QString clipBoard = QApplication::clipboard()->text(bFromSelection ? QClipboard::Selection : QClipboard::Clipboard);
 
     QString currentLine = str.left(x);
     QString endOfLine = str.mid(x);
     int i;
     int len = clipBoard.length();
     for(i = 0; i < len; ++i)
     {
         QChar c = clipBoard[i];
         if(c == '\r') continue;
         if(c == '\n')
         {
             melIt->setString(currentLine);
             MergeEditLine mel(mlIt->id3l); // Associate every mel with an id3l, even if not really valid.
             melIt = mlIt->mergeEditLineList.insert(melItAfter, mel);
             currentLine = "";
             x = 0;
             ++y;
         }
         else
         {
             currentLine += c;
             ++x;
         }
     }
 
     currentLine += endOfLine;
     melIt->setString(currentLine);
 
     m_cursorYPos = y;
     m_cursorXPos = convertToPosOnScreen(currentLine, x, m_pOptions->m_tabSize);
     m_cursorOldXPixelPos = m_cursorXPixelPos;
 
     update();
 }
 
 void MergeResultWindow::resetSelection()
 {
     m_selection.reset();
     update();
 }
 
 void MergeResultWindow::setModified(bool bModified)
 {
     if(bModified != m_bModified)
     {
         m_bModified = bModified;
         emit modifiedChanged(m_bModified);
     }
 }
 
 /// Saves and returns true when successful.
 bool MergeResultWindow::saveDocument(const QString& fileName, QTextCodec* pEncoding, e_LineEndStyle eLineEndStyle)
 {
     // Are still conflicts somewhere?
     if(getNrOfUnsolvedConflicts() > 0)
     {
         KMessageBox::error(this,
                            i18n("Not all conflicts are solved yet.\n"
                                 "File not saved."),
                            i18n("Conflicts Left"));
         return false;
     }
 
     if(eLineEndStyle == eLineEndStyleConflict || eLineEndStyle == eLineEndStyleUndefined)
     {
         KMessageBox::error(this,
                            i18n("There is a line end style conflict. Please choose the line end style manually.\n"
                                 "File not saved."),
                            i18n("Conflicts Left"));
         return false;
     }
 
     update();
 
     FileAccess file(fileName, true /*bWantToWrite*/);
     if(m_pOptions->m_bDmCreateBakFiles && file.exists())
     {
         bool bSuccess = file.createBackup(".orig");
         if(!bSuccess)
         {
             KMessageBox::error(this, file.getStatusText() + i18n("\n\nCreating backup failed. File not saved."), i18n("File Save Error"));
             return false;
         }
     }
 
     QByteArray dataArray;
     QTextStream textOutStream(&dataArray, QIODevice::WriteOnly);
     if(pEncoding->name() == "UTF-8")
         textOutStream.setGenerateByteOrderMark(false); // Shouldn't be necessary. Bug in Qt or docs
     else
         textOutStream.setGenerateByteOrderMark(true); // Only for UTF-16
     textOutStream.setCodec(pEncoding);
 
     int line = 0;
     MergeLineList::iterator mlIt = m_mergeLineList.begin();
     for(mlIt = m_mergeLineList.begin(); mlIt != m_mergeLineList.end(); ++mlIt)
     {
         MergeLine& ml = *mlIt;
         MergeEditLineList::iterator melIt;
         for(melIt = ml.mergeEditLineList.begin(); melIt != ml.mergeEditLineList.end(); ++melIt)
         {
             MergeEditLine& mel = *melIt;
 
             if(mel.isEditableText())
             {
                 QString str = mel.getString(m_pldA, m_pldB, m_pldC);
 
                 if(line > 0) // Prepend line feed, but not for first line
                 {
                     if(eLineEndStyle == eLineEndStyleDos)
                     {
                         str.prepend("\r\n");
                     }
                     else
                     {
                         str.prepend("\n");
                     }
                 }
 
                 textOutStream << str;
                 ++line;
             }
         }
     }
     textOutStream.flush();
     bool bSuccess = file.writeFile(dataArray.data(), dataArray.size());
     if(!bSuccess)
     {
         KMessageBox::error(this, i18n("Error while writing."), i18n("File Save Error"));
         return false;
     }
 
     setModified(false);
     update();
 
     return true;
 }
 
 QString MergeResultWindow::getString(int lineIdx)
 {
     MergeLineList::iterator mlIt;
     MergeEditLineList::iterator melIt;
     if(m_mergeLineList.empty())
     {
         return QString();
     }
     calcIteratorFromLineNr(lineIdx, mlIt, melIt);
     QString s = melIt->getString(m_pldA, m_pldB, m_pldC);
     return s;
 }
 
 bool MergeResultWindow::findString(const QString& s, LineRef& d3vLine, int& posInLine, bool bDirDown, bool bCaseSensitive)
 {
     int it = d3vLine;
     int endIt = bDirDown ? getNofLines() : -1;
     int step = bDirDown ? 1 : -1;
     int startPos = posInLine;
 
     for(; it != endIt; it += step)
     {
         QString line = 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 MergeResultWindow::setSelection(int firstLine, int startPos, int lastLine, int endPos)
 {
     if(lastLine >= getNofLines())
     {
         lastLine = getNofLines() - 1;
         QString s = getString(lastLine);
         endPos = s.length();
     }
     m_selection.reset();
     m_selection.start(firstLine, convertToPosOnScreen(getString(firstLine), startPos, m_pOptions->m_tabSize));
     m_selection.end(lastLine, convertToPosOnScreen(getString(lastLine), endPos, m_pOptions->m_tabSize));
     update();
 }
 
 WindowTitleWidget::WindowTitleWidget(const QSharedPointer<Options> &pOptions)
 {
     m_pOptions = pOptions;
     setAutoFillBackground(true);
 
     QHBoxLayout* pHLayout = new QHBoxLayout(this);
     pHLayout->setMargin(2);
     pHLayout->setSpacing(2);
 
     m_pLabel = new QLabel(i18n("Output:"));
     pHLayout->addWidget(m_pLabel);
 
     m_pFileNameLineEdit = new FileNameLineEdit();
     pHLayout->addWidget(m_pFileNameLineEdit, 6);
     m_pFileNameLineEdit->installEventFilter(this);//for focus tracking
     m_pFileNameLineEdit->setAcceptDrops(true);
     m_pFileNameLineEdit->setReadOnly(true);
 
     //m_pBrowseButton = new QPushButton("...");
     //pHLayout->addWidget( m_pBrowseButton, 0 );
     //connect( m_pBrowseButton, &QPushButton::clicked), this, &MergeResultWindow::slotBrowseButtonClicked);
 
     m_pModifiedLabel = new QLabel(i18n("[Modified]"));
     pHLayout->addWidget(m_pModifiedLabel);
     m_pModifiedLabel->setMinimumSize(m_pModifiedLabel->sizeHint());
     m_pModifiedLabel->setText("");
 
     pHLayout->addStretch(1);
 
     m_pEncodingLabel = new QLabel(i18n("Encoding for saving:"));
     pHLayout->addWidget(m_pEncodingLabel);
 
     m_pEncodingSelector = new QComboBox();
     m_pEncodingSelector->setSizeAdjustPolicy(QComboBox::AdjustToContents);
     pHLayout->addWidget(m_pEncodingSelector, 2);
     setEncodings(nullptr, nullptr, nullptr);
 
     m_pLineEndStyleLabel = new QLabel(i18n("Line end style:"));
     pHLayout->addWidget(m_pLineEndStyleLabel);
     m_pLineEndStyleSelector = new QComboBox();
     m_pLineEndStyleSelector->setSizeAdjustPolicy(QComboBox::AdjustToContents);
     pHLayout->addWidget(m_pLineEndStyleSelector);
     setLineEndStyles(eLineEndStyleUndefined, eLineEndStyleUndefined, eLineEndStyleUndefined);
 }
 
 void WindowTitleWidget::setFileName(const QString& fileName)
 {
     m_pFileNameLineEdit->setText(QDir::toNativeSeparators(fileName));
 }
 
 QString WindowTitleWidget::getFileName()
 {
     return m_pFileNameLineEdit->text();
 }
 
 //static QString getLineEndStyleName( e_LineEndStyle eLineEndStyle )
 //{
 //   if ( eLineEndStyle == eLineEndStyleDos )
 //      return "DOS";
 //   else if ( eLineEndStyle == eLineEndStyleUnix )
 //      return "Unix";
 //   return QString();
 //}
 
 void WindowTitleWidget::setLineEndStyles(e_LineEndStyle eLineEndStyleA, e_LineEndStyle eLineEndStyleB, e_LineEndStyle eLineEndStyleC)
 {
     m_pLineEndStyleSelector->clear();
     QString dosUsers;
     if(eLineEndStyleA == eLineEndStyleDos)
         dosUsers += i18n("A");
     if(eLineEndStyleB == eLineEndStyleDos)
         dosUsers += QLatin1String(dosUsers.isEmpty() ? "" : ", ") + i18n("B");
     if(eLineEndStyleC == eLineEndStyleDos)
         dosUsers += QLatin1String(dosUsers.isEmpty() ? "" : ", ") + i18n("C");
     QString unxUsers;
     if(eLineEndStyleA == eLineEndStyleUnix)
         unxUsers += i18n("A");
     if(eLineEndStyleB == eLineEndStyleUnix)
         unxUsers += QLatin1String(unxUsers.isEmpty() ? "" : ", ") + i18n("B");
     if(eLineEndStyleC == eLineEndStyleUnix)
         unxUsers += QLatin1String(unxUsers.isEmpty() ? "" : ", ") + i18n("C");
 
     m_pLineEndStyleSelector->addItem(i18n("Unix") + (unxUsers.isEmpty() ? QString("") : QLatin1String(" (") + unxUsers + QLatin1String(")")));
     m_pLineEndStyleSelector->addItem(i18n("DOS") + (dosUsers.isEmpty() ? QString("") : QLatin1String(" (") + dosUsers + QLatin1String(")")));
 
     e_LineEndStyle autoChoice = (e_LineEndStyle)m_pOptions->m_lineEndStyle;
 
     if(m_pOptions->m_lineEndStyle == eLineEndStyleAutoDetect)
     {
         if(eLineEndStyleA != eLineEndStyleUndefined && eLineEndStyleB != eLineEndStyleUndefined && eLineEndStyleC != eLineEndStyleUndefined)
         {
             if(eLineEndStyleA == eLineEndStyleB)
                 autoChoice = eLineEndStyleC;
             else if(eLineEndStyleA == eLineEndStyleC)
                 autoChoice = eLineEndStyleB;
             else
                 autoChoice = eLineEndStyleConflict; //conflict (not likely while only two values exist)
         }
         else
         {
             e_LineEndStyle c1, c2;
             if(eLineEndStyleA == eLineEndStyleUndefined)
             {
                 c1 = eLineEndStyleB;
                 c2 = eLineEndStyleC;
             }
             else if(eLineEndStyleB == eLineEndStyleUndefined)
             {
                 c1 = eLineEndStyleA;
                 c2 = eLineEndStyleC;
             }
             else /*if( eLineEndStyleC == eLineEndStyleUndefined )*/
             {
                 c1 = eLineEndStyleA;
                 c2 = eLineEndStyleB;
             }
             if(c1 == c2 && c1 != eLineEndStyleUndefined)
                 autoChoice = c1;
             else
                 autoChoice = eLineEndStyleConflict;
         }
     }
 
     if(autoChoice == eLineEndStyleUnix)
         m_pLineEndStyleSelector->setCurrentIndex(0);
     else if(autoChoice == eLineEndStyleDos)
         m_pLineEndStyleSelector->setCurrentIndex(1);
     else if(autoChoice == eLineEndStyleConflict)
     {
         m_pLineEndStyleSelector->addItem(i18n("Conflict"));
         m_pLineEndStyleSelector->setCurrentIndex(2);
     }
 }
 
 e_LineEndStyle WindowTitleWidget::getLineEndStyle()
 {
 
     int current = m_pLineEndStyleSelector->currentIndex();
     if(current == 0)
         return eLineEndStyleUnix;
     else if(current == 1)
         return eLineEndStyleDos;
     else
         return eLineEndStyleConflict;
 }
 
 void WindowTitleWidget::setEncodings(QTextCodec* pCodecForA, QTextCodec* pCodecForB, QTextCodec* pCodecForC)
 {
     m_pEncodingSelector->clear();
 
     // First sort codec names:
     std::map<QString, QTextCodec*> names;
     QList<int> mibs = QTextCodec::availableMibs();
     foreach(int i, mibs)
     {
         QTextCodec* c = QTextCodec::codecForMib(i);
         if(c != nullptr)
             names[QLatin1String(c->name())] = c;
     }
 
     if(pCodecForA != nullptr)
         m_pEncodingSelector->addItem(i18n("Codec from A: %1", QLatin1String(pCodecForA->name())), QVariant::fromValue((void*)pCodecForA));
     if(pCodecForB != nullptr)
         m_pEncodingSelector->addItem(i18n("Codec from B: %1", QLatin1String(pCodecForB->name())), QVariant::fromValue((void*)pCodecForB));
     if(pCodecForC != nullptr)
         m_pEncodingSelector->addItem(i18n("Codec from C: %1", QLatin1String(pCodecForC->name())), QVariant::fromValue((void*)pCodecForC));
 
     std::map<QString, QTextCodec*>::iterator it;
     for(it = names.begin(); it != names.end(); ++it)
     {
         m_pEncodingSelector->addItem(it->first, QVariant::fromValue((void*)it->second));
     }
     m_pEncodingSelector->setMinimumSize(m_pEncodingSelector->sizeHint());
 
     if(pCodecForC != nullptr && pCodecForB != nullptr && pCodecForA != nullptr)
     {
         if(pCodecForA == pCodecForB)
             m_pEncodingSelector->setCurrentIndex(2); // C
         else if(pCodecForA == pCodecForC)
             m_pEncodingSelector->setCurrentIndex(1); // B
         else
             m_pEncodingSelector->setCurrentIndex(2); // C
     }
     else if(pCodecForA != nullptr && pCodecForB != nullptr)
         m_pEncodingSelector->setCurrentIndex(1); // B
     else
         m_pEncodingSelector->setCurrentIndex(0);
 }
 
 QTextCodec* WindowTitleWidget::getEncoding()
 {
     return (QTextCodec*)m_pEncodingSelector->itemData(m_pEncodingSelector->currentIndex()).value<void*>();
 }
 
 void WindowTitleWidget::setEncoding(QTextCodec* pEncoding)
 {
     int idx = m_pEncodingSelector->findText(QLatin1String(pEncoding->name()));
     if(idx >= 0)
         m_pEncodingSelector->setCurrentIndex(idx);
 }
 
 //void WindowTitleWidget::slotBrowseButtonClicked()
 //{
 //   QString current = m_pFileNameLineEdit->text();
 //
 //   QUrl newURL = KFileDialog::getSaveUrl( current, 0, this, i18n("Select file (not saving yet)"));
 //   if ( !newURL.isEmpty() )
 //   {
 //      m_pFileNameLineEdit->setText( newURL.url() );
 //   }
 //}
 
 void WindowTitleWidget::slotSetModified(bool bModified)
 {
     m_pModifiedLabel->setText(bModified ? i18n("[Modified]") : "");
 }
 
 bool WindowTitleWidget::eventFilter(QObject* o, QEvent* e)
 {
     Q_UNUSED(o);
     if(e->type() == QEvent::FocusIn || e->type() == QEvent::FocusOut)
     {
         QPalette p = m_pLabel->palette();
 
         QColor c1 = m_pOptions->m_fgColor;
         QColor c2 = Qt::lightGray;
         if(e->type() == QEvent::FocusOut)
             c2 = m_pOptions->m_bgColor;
 
         p.setColor(QPalette::Window, c2);
         setPalette(p);
 
         p.setColor(QPalette::WindowText, c1);
         m_pLabel->setPalette(p);
         m_pEncodingLabel->setPalette(p);
         m_pEncodingSelector->setPalette(p);
     }
     return false;
 }
 
 //#include "mergeresultwindow.moc"
diff --git a/src/optiondialog.cpp b/src/optiondialog.cpp
index 0651d41..58ecce3 100644
--- a/src/optiondialog.cpp
+++ b/src/optiondialog.cpp
@@ -1,1629 +1,1627 @@
 /*
  *   kdiff3 - Text Diff And Merge Tool
  *   Copyright (C) 2002-2009  Joachim Eibl, joachim.eibl at gmx.de
  *   Copyright (C) 2018 Michael Reeves reeves.87@gmail.com
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
  *   the Free Software Foundation; either version 2 of the License, or
  *   (at your option) any later version.
  *
  *   This program is distributed in the hope that it will be useful,
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *   GNU General Public License for more details.
  *
  *   You should have received a copy of the GNU General Public License
  *   along with this program; if not, write to the Free Software
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  *
  */
 #include "optiondialog.h"
 #include "OptionItems.h"
 
-#include "diff.h"
+#include "common.h"
 #include "smalldialogs.h"
 
 #include <map>
 
 #include <KColorButton>
 #include <KHelpClient>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KToolBar>
 
 #include <QApplication>
 #include <QCheckBox>
 #include <QComboBox>
 #include <QDialogButtonBox>
-#include <QDir>
 #include <QFontDatabase>
 #include <QFontDialog>
 #include <QFrame>
 #include <QGridLayout>
 #include <QGroupBox>
 #include <QLabel>
 #include <QLayout>
 #include <QLineEdit>
-#include <QLocale>
 #include <QPixmap>
 #include <QPlainTextEdit>
 #include <QPointer>
 #include <QPushButton>
 #include <QRadioButton>
 #include <QTextCodec>
-#include <QToolTip>
+//#include <QToolTip>
 
 QString s_historyEntryStartRegExpToolTip;
 QString s_historyEntryStartSortKeyOrderToolTip;
 QString s_autoMergeRegExpToolTip;
 QString s_historyStartRegExpToolTip;
 
 class OptionCheckBox : public QCheckBox, public OptionBool
 {
   public:
     OptionCheckBox(const QString& text, bool bDefaultVal, const QString& saveName, bool* pbVar,
                    QWidget* pParent)
         : QCheckBox(text, pParent), OptionBool(pbVar, bDefaultVal, saveName)
     {}
     void setToDefault() override { setChecked(getDefault()); }
     void setToCurrent() override { setChecked(getCurrent()); }
 
     using OptionBool::apply;
     void apply() override { apply(isChecked()); }
 
   private:
     Q_DISABLE_COPY(OptionCheckBox)
 };
 
 class OptionRadioButton : public QRadioButton, public OptionBool
 {
   public:
     OptionRadioButton(const QString& text, bool bDefaultVal, const QString& saveName, bool* pbVar,
                       QWidget* pParent)
         : QRadioButton(text, pParent), OptionBool(pbVar, bDefaultVal, saveName)
     {}
     void setToDefault() override { setChecked(getDefault()); }
     void setToCurrent() override { setChecked(getCurrent()); }
 
     using OptionBool::apply;
     void apply() override { apply(isChecked()); }
 
   private:
     Q_DISABLE_COPY(OptionRadioButton)
 };
 
 FontChooser::FontChooser(QWidget* pParent)
     : QGroupBox(pParent)
 {
     QVBoxLayout* pLayout = new QVBoxLayout(this);
     m_pLabel = new QLabel(QString());
     pLayout->addWidget(m_pLabel);
 
     QChar visualTab(0x2192);
     QChar visualSpace((ushort)0xb7);
     m_pExampleTextEdit = new QPlainTextEdit(QString("The quick brown fox jumps over the river\n"
                                                     "but the little red hen escapes with a shiver.\n"
                                                     ":-)") +
                                                 visualTab + visualSpace,
                                             this);
     m_pExampleTextEdit->setFont(m_font);
     m_pExampleTextEdit->setReadOnly(true);
     pLayout->addWidget(m_pExampleTextEdit);
 
     m_pSelectFont = new QPushButton(i18n("Change Font"));
     m_pSelectFont->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
     connect(m_pSelectFont, &QPushButton::clicked, this, &FontChooser::slotSelectFont);
     pLayout->addWidget(m_pSelectFont);
     pLayout->setAlignment(m_pSelectFont, Qt::AlignRight);
 }
 
 QFont FontChooser::font()
 {
     return m_font; //QFont("courier",10);
 }
 
 void FontChooser::setFont(const QFont& font, bool)
 {
     m_font = font;
     m_pExampleTextEdit->setFont(m_font);
     m_pLabel->setText(i18n("Font: %1, %2, %3\n\nExample:", m_font.family(), m_font.styleName(), m_font.pointSize()));
 
     //update();
 }
 
 void FontChooser::slotSelectFont()
 {
     bool bOk;
     m_font = QFontDialog::getFont(&bOk, m_font);
     m_pExampleTextEdit->setFont(m_font);
     m_pLabel->setText(i18n("Font: %1, %2, %3\n\nExample:", m_font.family(), m_font.styleName(), m_font.pointSize()));
 }
 
 class OptionFontChooser : public FontChooser, public OptionFont
 {
   public:
     OptionFontChooser(const QFont& defaultVal, const QString& saveName, QFont* pVar, QWidget* pParent) : FontChooser(pParent),
                                                                                                                             OptionFont(pVar, defaultVal, saveName)
     {}
 
     void setToDefault() override { setFont(getDefault(), false); }
     void setToCurrent() override { setFont(getCurrent(), false); }
     using OptionFont::apply;
     void apply() override { apply(font()); }
   private:
     Q_DISABLE_COPY(OptionFontChooser)
 };
 
 class OptionColorButton : public KColorButton, public OptionColor
 {
   public:
     OptionColorButton(const QColor &defaultVal, const QString& saveName, QColor* pVar, QWidget* pParent)
         : KColorButton(pParent), OptionColor(pVar, defaultVal, saveName)
     {}
 
     void setToDefault() override { setColor(getDefault()); }
     void setToCurrent() override { setColor(getCurrent()); }
     using OptionColor::apply;
     void apply() override { apply(color()); }
 
   private:
     Q_DISABLE_COPY(OptionColorButton)
 };
 
 class OptionLineEdit : public QComboBox, public OptionString
 {
   public:
     OptionLineEdit(const QString& defaultVal, const QString& saveName, QString* pVar,
                    QWidget* pParent)
         : QComboBox(pParent), OptionString(pVar, defaultVal, saveName)
     {
         setMinimumWidth(50);
         setEditable(true);
         m_list.push_back(defaultVal);
         insertText();
     }
     void setToDefault() override
     {
         setEditText(getDefault());
     }
     void setToCurrent() override
     {
         setEditText(getCurrent());
     }
 
     using OptionString::apply;
     void apply() override
     {
         apply(currentText());
         insertText();
     }
     void write(ValueMap* config) override
     {
         config->writeEntry(m_saveName, m_list);
     }
     void read(ValueMap* config) override
     {
         m_list = config->readEntry(m_saveName, QStringList(m_defaultVal));
         if(!m_list.empty()) setCurrent(m_list.front());
         clear();
         insertItems(0, m_list);
     }
 
   private:
     void insertText()
     { // Check if the text exists. If yes remove it and push it in as first element
         QString current = currentText();
         m_list.removeAll(current);
         m_list.push_front(current);
         clear();
         if(m_list.size() > 10)
             m_list.erase(m_list.begin() + 10, m_list.end());
         insertItems(0, m_list);
     }
 
     Q_DISABLE_COPY(OptionLineEdit)
     QStringList m_list;
 };
 
 class OptionIntEdit : public QLineEdit, public OptionNum<int>
 {
   public:
     OptionIntEdit(int defaultVal, const QString& saveName, int* pVar, int rangeMin, int rangeMax,
                   QWidget* pParent)
         : QLineEdit(pParent), OptionNum<int>(pVar, defaultVal, saveName)
     {
         QIntValidator* v = new QIntValidator(this);
         v->setRange(rangeMin, rangeMax);
         setValidator(v);
     }
     void setToDefault() override
     {
         //QString::setNum does not account for locale settings
         setText(OptionNum::toString(getDefault()));
     }
 
     void setToCurrent() override
     {
         setText(getString());
     }
 
     using OptionNum<int>::apply;
     void apply() override
     {
         const QIntValidator* v = static_cast<const QIntValidator*>(validator());
         setCurrent( qBound(v->bottom(), text().toInt(), v->top()) );
 
         setText(getString());
     }
 
   private:
     Q_DISABLE_COPY(OptionIntEdit)
 };
 
 class OptionComboBox : public QComboBox, public OptionItemBase
 {
   public:
     OptionComboBox(int defaultVal, const QString& saveName, int* pVarNum,
                    QWidget* pParent)
         : QComboBox(pParent), OptionItemBase(saveName)
     {
         setMinimumWidth(50);
         m_pVarNum = pVarNum;
         m_pVarStr = nullptr;
         m_defaultVal = defaultVal;
         setEditable(false);
     }
     OptionComboBox(int defaultVal, const QString& saveName, QString* pVarStr,
                    QWidget* pParent)
         : QComboBox(pParent), OptionItemBase(saveName)
     {
         m_pVarNum = nullptr;
         m_pVarStr = pVarStr;
         m_defaultVal = defaultVal;
         setEditable(false);
     }
     void setToDefault() override
     {
         setCurrentIndex(m_defaultVal);
         if(m_pVarStr != nullptr) {
             *m_pVarStr = currentText();
         }
     }
     void setToCurrent() override
     {
         if(m_pVarNum != nullptr)
             setCurrentIndex(*m_pVarNum);
         else
             setText(*m_pVarStr);
     }
     using OptionItemBase::apply;
     void apply() override
     {
         if(m_pVarNum != nullptr) {
             *m_pVarNum = currentIndex();
         }
         else
         {
             *m_pVarStr = currentText();
         }
     }
     void write(ValueMap* config) override
     {
         if(m_pVarStr != nullptr)
             config->writeEntry(m_saveName, *m_pVarStr);
         else
             config->writeEntry(m_saveName, *m_pVarNum);
     }
     void read(ValueMap* config) override
     {
         if(m_pVarStr != nullptr)
             setText(config->readEntry(m_saveName, currentText()));
         else
             *m_pVarNum = config->readEntry(m_saveName, *m_pVarNum);
     }
     void preserve() override
     {
         if(m_pVarStr != nullptr) {
             m_preservedStrVal = *m_pVarStr;
         }
         else
         {
             m_preservedNumVal = *m_pVarNum;
         }
     }
     void unpreserve() override
     {
         if(m_pVarStr != nullptr) {
             *m_pVarStr = m_preservedStrVal;
         }
         else
         {
             *m_pVarNum = m_preservedNumVal;
         }
     }
 
   private:
     Q_DISABLE_COPY(OptionComboBox)
     int* m_pVarNum;
     int m_preservedNumVal = 0;
     QString* m_pVarStr;
     QString m_preservedStrVal;
     int m_defaultVal;
 
     void setText(const QString& s)
     {
         // Find the string in the combobox-list, don't change the value if nothing fits.
         for(int i = 0; i < count(); ++i)
         {
             if(itemText(i) == s)
             {
                 if(m_pVarNum != nullptr) *m_pVarNum = i;
                 if(m_pVarStr != nullptr) *m_pVarStr = s;
                 setCurrentIndex(i);
                 return;
             }
         }
     }
 };
 
 class OptionEncodingComboBox : public QComboBox, public OptionCodec
 {
     Q_OBJECT
     QVector<QTextCodec*> m_codecVec;
     QTextCodec** m_ppVarCodec;
 
   public:
     OptionEncodingComboBox(const QString& saveName, QTextCodec** ppVarCodec,
                            QWidget* pParent)
         : QComboBox(pParent), OptionCodec(saveName)
     {
         m_ppVarCodec = ppVarCodec;
         insertCodec(i18n("Unicode, 8 bit"), QTextCodec::codecForName("UTF-8"));
         insertCodec(i18n("Unicode"), QTextCodec::codecForName("iso-10646-UCS-2"));
         insertCodec(i18n("Latin1"), QTextCodec::codecForName("iso 8859-1"));
 
         // First sort codec names:
         std::map<QString, QTextCodec*> names;
         QList<int> mibs = QTextCodec::availableMibs();
         foreach(int i, mibs)
         {
             QTextCodec* c = QTextCodec::codecForMib(i);
             if(c != nullptr)
                 names[QString(QLatin1String(c->name())).toUpper()] = c;
         }
 
         std::map<QString, QTextCodec*>::iterator it;
         for(it = names.begin(); it != names.end(); ++it)
         {
             insertCodec("", it->second);
         }
 
         this->setToolTip(i18n(
             "Change this if non-ASCII characters are not displayed correctly."));
     }
     void insertCodec(const QString& visibleCodecName, QTextCodec* c)
     {
         if(c != nullptr)
         {
             QString codecName = QLatin1String(c->name());
             for(int i = 0; i < m_codecVec.size(); ++i)
             {
                 if(c == m_codecVec[i])
                     return; // don't insert any codec twice
             }
 
             // The m_codecVec.size will at this point return the value we need for the index.
             if(codecName == defaultName())
                 saveDefaultIndex(m_codecVec.size());
             QString itemText = visibleCodecName.isEmpty() ? codecName : visibleCodecName + QStringLiteral(" (") + codecName + QStringLiteral(")");
             addItem(itemText, m_codecVec.size());
             m_codecVec.push_back(c);
         }
     }
     void setToDefault() override
     {
         int index = getDefaultIndex();
 
         setCurrentIndex(index);
         if(m_ppVarCodec != nullptr) {
             *m_ppVarCodec = m_codecVec[index];
         }
     }
     void setToCurrent() override
     {
         if(m_ppVarCodec != nullptr)
         {
             for(int i = 0; i < m_codecVec.size(); ++i)
             {
                 if(*m_ppVarCodec == m_codecVec[i])
                 {
                     setCurrentIndex(i);
                     break;
                 }
             }
         }
     }
     using OptionCodec::apply;
     void apply() override
     {
         if(m_ppVarCodec != nullptr) {
             *m_ppVarCodec = m_codecVec[currentIndex()];
         }
     }
     void write(ValueMap* config) override
     {
         if(m_ppVarCodec != nullptr) config->writeEntry(m_saveName, (const char*)(*m_ppVarCodec)->name());
     }
     void read(ValueMap* config) override
     {
         QString codecName = config->readEntry(m_saveName, (const char*)m_codecVec[currentIndex()]->name());
         for(int i = 0; i < m_codecVec.size(); ++i)
         {
             if(codecName == QLatin1String(m_codecVec[i]->name()))
             {
                 setCurrentIndex(i);
                 if(m_ppVarCodec != nullptr) *m_ppVarCodec = m_codecVec[i];
                 break;
             }
         }
     }
 
   protected:
     void preserve() override { m_preservedVal = currentIndex(); }
     void unpreserve() override { setCurrentIndex(m_preservedVal); }
     int m_preservedVal;
 };
 
 void OptionDialog::addOptionItem(OptionItemBase* p)
 {
     m_options->addOptionItem(p);
 }
 
 OptionDialog::OptionDialog(bool bShowDirMergeSettings, QWidget* parent) : KPageDialog(parent)
 {
     setFaceType(List);
     setWindowTitle(i18n("Configure"));
     setStandardButtons(QDialogButtonBox::Help | QDialogButtonBox::RestoreDefaults | QDialogButtonBox::Apply | QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
 
     setModal(true);
 
     //showButtonSeparator( true );
     //setHelp( "kdiff3/index.html", QString::null );
 
     m_options->init();
     setupFontPage();
     setupColorPage();
     setupEditPage();
     setupDiffPage();
     setupMergePage();
     setupOtherOptions();
     if(bShowDirMergeSettings)
         setupDirectoryMergePage();
 
     setupRegionalPage();
     setupIntegrationPage();
 
     //setupKeysPage();
 
     // Initialize all values in the dialog
     resetToDefaults();
     slotApply();
     connect(button(QDialogButtonBox::Apply), &QPushButton::clicked, this, &OptionDialog::slotApply);
     connect(button(QDialogButtonBox::Ok), &QPushButton::clicked, this, &OptionDialog::slotOk);
     connect(button(QDialogButtonBox::RestoreDefaults), &QPushButton::clicked, this, &OptionDialog::slotDefault);
     connect(button(QDialogButtonBox::Cancel), &QPushButton::clicked, this, &QDialog::reject);
     connect(button(QDialogButtonBox::Help), &QPushButton::clicked, this, &OptionDialog::helpRequested);
     //connect(this, &OptionDialog::applyClicked, this, &OptionDialog::slotApply);
     //helpClicked() is connected in KDiff3App::KDiff3App -- Really where?
     //connect(this, &OptionDialog::defaultClicked, this, &OptionDialog::slotDefault);
 }
 
 void OptionDialog::helpRequested()
 {
     KHelpClient::invokeHelp(QStringLiteral("kdiff3/index.html"));
 }
 
 OptionDialog::~OptionDialog()
 {
 }
 
 void OptionDialog::setupOtherOptions()
 {
     //TODO move to Options class
     addOptionItem(new OptionToggleAction(false, "AutoAdvance", &m_options->m_bAutoAdvance));
     addOptionItem(new OptionToggleAction(true, "ShowWhiteSpaceCharacters", &m_options->m_bShowWhiteSpaceCharacters));
     addOptionItem(new OptionToggleAction(true, "ShowWhiteSpace", &m_options->m_bShowWhiteSpace));
     addOptionItem(new OptionToggleAction(false, "ShowLineNumbers", &m_options->m_bShowLineNumbers));
     addOptionItem(new OptionToggleAction(true, "HorizDiffWindowSplitting", &m_options->m_bHorizDiffWindowSplitting));
     addOptionItem(new OptionToggleAction(false, "WordWrap", &m_options->m_bWordWrap));
 
     addOptionItem(new OptionToggleAction(true, "ShowIdenticalFiles", &m_options->m_bDmShowIdenticalFiles));
 
     addOptionItem(new OptionStringList(&m_options->m_recentAFiles, "RecentAFiles"));
     addOptionItem(new OptionStringList(&m_options->m_recentBFiles, "RecentBFiles"));
     addOptionItem(new OptionStringList(&m_options->m_recentCFiles, "RecentCFiles"));
     addOptionItem(new OptionStringList(&m_options->m_recentOutputFiles, "RecentOutputFiles"));
     addOptionItem(new OptionStringList(&m_options->m_recentEncodings, "RecentEncodings"));
 }
 
 void OptionDialog::setupFontPage()
 {
     QFrame* page = new QFrame();
     KPageWidgetItem* pageItem = new KPageWidgetItem(page, i18n("Font"));
 
     pageItem->setHeader(i18n("Editor & Diff Output Font"));
     //not all themes have this icon
     if(QIcon::hasThemeIcon(QStringLiteral("font-select-symbolic")))
         pageItem->setIcon(QIcon::fromTheme(QStringLiteral("font-select-symbolic")));
     else
         pageItem->setIcon(QIcon::fromTheme(QStringLiteral("preferences-desktop-font")));
     addPage(pageItem);
 
     QVBoxLayout* topLayout = new QVBoxLayout(page);
     topLayout->setMargin(5);
 
     //requires QT 5.2 or later.
     static const QFont defaultFont = QFontDatabase::systemFont(QFontDatabase::FixedFont);
     static QFont defaultAppFont = QApplication::font();
 
     OptionFontChooser* pAppFontChooser = new OptionFontChooser(defaultAppFont, "ApplicationFont", &m_options->m_appFont, page);
     addOptionItem(pAppFontChooser);
     topLayout->addWidget(pAppFontChooser);
     pAppFontChooser->setTitle(i18n("Application font"));
 
     OptionFontChooser* pFontChooser = new OptionFontChooser(defaultFont, "Font", &m_options->m_font, page);
     addOptionItem(pFontChooser);
     topLayout->addWidget(pFontChooser);
     pFontChooser->setTitle(i18n("File view font"));
 
     QGridLayout* gbox = new QGridLayout();
     topLayout->addLayout(gbox);
     //int line=0;
 
     // This currently does not work (see rendering in class DiffTextWindow)
     //OptionCheckBox* pItalicDeltas = new OptionCheckBox( i18n("Italic font for deltas"), false, "ItalicForDeltas", &m_options->m_bItalicForDeltas, page, this );
     //addOptionItem(pItalicDeltas);
     //gbox->addWidget( pItalicDeltas, line, 0, 1, 2 );
     //pItalicDeltas->setToolTip( i18n(
     //   "Selects the italic version of the font for differences.\n"
     //   "If the font doesn't support italic characters, then this does nothing.")
     //   );
 }
 
 void OptionDialog::setupColorPage()
 {
     QFrame* page = new QFrame();
     KPageWidgetItem* pageItem = new KPageWidgetItem(page, i18nc("Title for color settings page","Color"));
     pageItem->setHeader(i18n("Colors Settings"));
     pageItem->setIcon(QIcon::fromTheme(QStringLiteral("colormanagement")));
     addPage(pageItem);
 
     QVBoxLayout* topLayout = new QVBoxLayout(page);
     topLayout->setMargin(5);
 
     QGridLayout* gbox = new QGridLayout();
     gbox->setColumnStretch(1, 5);
     topLayout->addLayout(gbox);
 
     QLabel* label;
     int line = 0;
 
     int depth = QPixmap::defaultDepth();
     bool bLowColor = depth <= 8;
 
     label = new QLabel(i18n("Editor and Diff Views:"), page);
     gbox->addWidget(label, line, 0);
     QFont f(label->font());
     f.setBold(true);
     label->setFont(f);
     ++line;
 
     OptionColorButton* pFgColor = new OptionColorButton(Qt::black, "FgColor", &m_options->m_fgColor, page);
     label = new QLabel(i18n("Foreground color:"), page);
     label->setBuddy(pFgColor);
     addOptionItem(pFgColor);
     gbox->addWidget(label, line, 0);
     gbox->addWidget(pFgColor, line, 1);
     ++line;
 
     OptionColorButton* pBgColor = new OptionColorButton(Qt::white, "BgColor", &m_options->m_bgColor, page);
     label = new QLabel(i18n("Background color:"), page);
     label->setBuddy(pBgColor);
     addOptionItem(pBgColor);
     gbox->addWidget(label, line, 0);
     gbox->addWidget(pBgColor, line, 1);
 
     ++line;
 
     OptionColorButton* pDiffBgColor = new OptionColorButton(
         bLowColor ? QColor(Qt::lightGray) : qRgb(224, 224, 224), "DiffBgColor", &m_options->m_diffBgColor, page);
     label = new QLabel(i18n("Diff background color:"), page);
     label->setBuddy(pDiffBgColor);
     addOptionItem(pDiffBgColor);
     gbox->addWidget(label, line, 0);
     gbox->addWidget(pDiffBgColor, line, 1);
     ++line;
 
     OptionColorButton* pColorA = new OptionColorButton(
         bLowColor ? qRgb(0, 0, 255) : qRgb(0, 0, 200) /*blue*/, "ColorA", &m_options->m_colorA, page);
     label = new QLabel(i18n("Color A:"), page);
     label->setBuddy(pColorA);
     addOptionItem(pColorA);
     gbox->addWidget(label, line, 0);
     gbox->addWidget(pColorA, line, 1);
     ++line;
 
     OptionColorButton* pColorB = new OptionColorButton(
         bLowColor ? qRgb(0, 128, 0) : qRgb(0, 150, 0) /*green*/, "ColorB", &m_options->m_colorB, page);
     label = new QLabel(i18n("Color B:"), page);
     label->setBuddy(pColorB);
     addOptionItem(pColorB);
     gbox->addWidget(label, line, 0);
     gbox->addWidget(pColorB, line, 1);
     ++line;
 
     OptionColorButton* pColorC = new OptionColorButton(
         bLowColor ? qRgb(128, 0, 128) : qRgb(150, 0, 150) /*magenta*/, "ColorC", &m_options->m_colorC, page);
     label = new QLabel(i18n("Color C:"), page);
     label->setBuddy(pColorC);
     addOptionItem(pColorC);
     gbox->addWidget(label, line, 0);
     gbox->addWidget(pColorC, line, 1);
     ++line;
 
     OptionColorButton* pColorForConflict = new OptionColorButton(Qt::red, "ColorForConflict", &m_options->m_colorForConflict, page);
     label = new QLabel(i18n("Conflict color:"), page);
     label->setBuddy(pColorForConflict);
     addOptionItem(pColorForConflict);
     gbox->addWidget(label, line, 0);
     gbox->addWidget(pColorForConflict, line, 1);
     ++line;
 
     OptionColorButton* pColor = new OptionColorButton(
         bLowColor ? qRgb(192, 192, 192) : qRgb(220, 220, 100), "CurrentRangeBgColor", &m_options->m_currentRangeBgColor, page);
     label = new QLabel(i18n("Current range background color:"), page);
     label->setBuddy(pColor);
     addOptionItem(pColor);
     gbox->addWidget(label, line, 0);
     gbox->addWidget(pColor, line, 1);
     ++line;
 
     pColor = new OptionColorButton(
         bLowColor ? qRgb(255, 255, 0) : qRgb(255, 255, 150), "CurrentRangeDiffBgColor", &m_options->m_currentRangeDiffBgColor, page);
     label = new QLabel(i18n("Current range diff background color:"), page);
     label->setBuddy(pColor);
     addOptionItem(pColor);
     gbox->addWidget(label, line, 0);
     gbox->addWidget(pColor, line, 1);
     ++line;
 
     pColor = new OptionColorButton(qRgb(0xff, 0xd0, 0x80), "ManualAlignmentRangeColor", &m_options->m_manualHelpRangeColor, page);
     label = new QLabel(i18n("Color for manually aligned difference ranges:"), page);
     label->setBuddy(pColor);
     addOptionItem(pColor);
     gbox->addWidget(label, line, 0);
     gbox->addWidget(pColor, line, 1);
     ++line;
 
     label = new QLabel(i18n("Directory Comparison View:"), page);
     gbox->addWidget(label, line, 0);
     label->setFont(f);
     ++line;
 
     pColor = new OptionColorButton(qRgb(0, 0xd0, 0), "NewestFileColor", &m_options->m_newestFileColor, page);
     label = new QLabel(i18n("Newest file color:"), page);
     label->setBuddy(pColor);
     addOptionItem(pColor);
     gbox->addWidget(label, line, 0);
     gbox->addWidget(pColor, line, 1);
     QString dirColorTip = i18n("Changing this color will only be effective when starting the next directory comparison.");
     label->setToolTip(dirColorTip);
     ++line;
 
     pColor = new OptionColorButton(qRgb(0xf0, 0, 0), "OldestFileColor", &m_options->m_oldestFileColor, page);
     label = new QLabel(i18n("Oldest file color:"), page);
     label->setBuddy(pColor);
     addOptionItem(pColor);
     gbox->addWidget(label, line, 0);
     gbox->addWidget(pColor, line, 1);
     label->setToolTip(dirColorTip);
     ++line;
 
     pColor = new OptionColorButton(qRgb(0xc0, 0xc0, 0), "MidAgeFileColor", &m_options->m_midAgeFileColor, page);
     label = new QLabel(i18n("Middle age file color:"), page);
     label->setBuddy(pColor);
     addOptionItem(pColor);
     gbox->addWidget(label, line, 0);
     gbox->addWidget(pColor, line, 1);
     label->setToolTip(dirColorTip);
     ++line;
 
     pColor = new OptionColorButton(qRgb(0, 0, 0), "MissingFileColor", &m_options->m_missingFileColor, page);
     label = new QLabel(i18n("Color for missing files:"), page);
     label->setBuddy(pColor);
     addOptionItem(pColor);
     gbox->addWidget(label, line, 0);
     gbox->addWidget(pColor, line, 1);
     label->setToolTip(dirColorTip);
     ++line;
 
     topLayout->addStretch(10);
 }
 
 void OptionDialog::setupEditPage()
 {
     QFrame* page = new QFrame();
     KPageWidgetItem* pageItem = new KPageWidgetItem(page, i18n("Editor"));
     pageItem->setHeader(i18n("Editor Behavior"));
     pageItem->setIcon(QIcon::fromTheme(QStringLiteral("accessories-text-editor")));
     addPage(pageItem);
 
     QVBoxLayout* topLayout = new QVBoxLayout(page);
     topLayout->setMargin(5);
 
     QGridLayout* gbox = new QGridLayout();
     gbox->setColumnStretch(1, 5);
     topLayout->addLayout(gbox);
     QLabel* label;
     int line = 0;
 
     OptionCheckBox* pReplaceTabs = new OptionCheckBox(i18n("Tab inserts spaces"), false, "ReplaceTabs", &m_options->m_bReplaceTabs, page);
     addOptionItem(pReplaceTabs);
     gbox->addWidget(pReplaceTabs, line, 0, 1, 2);
     pReplaceTabs->setToolTip(i18n(
         "On: Pressing tab generates the appropriate number of spaces.\n"
         "Off: A tab character will be inserted."));
     ++line;
 
     OptionIntEdit* pTabSize = new OptionIntEdit(8, "TabSize", &m_options->m_tabSize, 1, 100, page);
     label = new QLabel(i18n("Tab size:"), page);
     label->setBuddy(pTabSize);
     addOptionItem(pTabSize);
     gbox->addWidget(label, line, 0);
     gbox->addWidget(pTabSize, line, 1);
     ++line;
 
     OptionCheckBox* pAutoIndentation = new OptionCheckBox(i18n("Auto indentation"), true, "AutoIndentation", &m_options->m_bAutoIndentation, page);
     gbox->addWidget(pAutoIndentation, line, 0, 1, 2);
     addOptionItem(pAutoIndentation);
     pAutoIndentation->setToolTip(i18n(
         "On: The indentation of the previous line is used for a new line.\n"));
     ++line;
 
     OptionCheckBox* pAutoCopySelection = new OptionCheckBox(i18n("Auto copy selection"), false, "AutoCopySelection", &m_options->m_bAutoCopySelection, page);
     gbox->addWidget(pAutoCopySelection, line, 0, 1, 2);
     addOptionItem(pAutoCopySelection);
     pAutoCopySelection->setToolTip(i18n(
         "On: Any selection is immediately written to the clipboard.\n"
         "Off: You must explicitly copy e.g. via Ctrl-C."));
     ++line;
 
     label = new QLabel(i18n("Line end style:"), page);
     gbox->addWidget(label, line, 0);
 
     OptionComboBox* pLineEndStyle = new OptionComboBox(eLineEndStyleAutoDetect, "LineEndStyle", (int*)&m_options->m_lineEndStyle, page);
     gbox->addWidget(pLineEndStyle, line, 1);
     addOptionItem(pLineEndStyle);
     pLineEndStyle->insertItem(eLineEndStyleUnix, "Unix");
     pLineEndStyle->insertItem(eLineEndStyleDos, "Dos/Windows");
     pLineEndStyle->insertItem(eLineEndStyleAutoDetect, "Autodetect");
 
     label->setToolTip(i18n(
         "Sets the line endings for when an edited file is saved.\n"
         "DOS/Windows: CR+LF; UNIX: LF; with CR=0D, LF=0A"));
     ++line;
 
     topLayout->addStretch(10);
 }
 
 void OptionDialog::setupDiffPage()
 {
     QFrame* page = new QFrame();
     KPageWidgetItem* pageItem = new KPageWidgetItem(page, i18n("Diff"));
     pageItem->setHeader(i18n("Diff Settings"));
     pageItem->setIcon(QIcon::fromTheme(QStringLiteral("text-x-patch")));
     addPage(pageItem);
 
     QVBoxLayout* topLayout = new QVBoxLayout(page);
     topLayout->setMargin(5);
 
     QGridLayout* gbox = new QGridLayout();
     gbox->setColumnStretch(1, 5);
     topLayout->addLayout(gbox);
     int line = 0;
 
     QLabel* label = nullptr;
 
     m_options->m_bPreserveCarriageReturn = false;
     /*
     OptionCheckBox* pPreserveCarriageReturn = new OptionCheckBox( i18n("Preserve carriage return"), false, "PreserveCarriageReturn", &m_options->m_bPreserveCarriageReturn, page, this );
     addOptionItem(pPreserveCarriageReturn);
     gbox->addWidget( pPreserveCarriageReturn, line, 0, 1, 2 );
     pPreserveCarriageReturn->setToolTip( i18n(
        "Show carriage return characters '\\r' if they exist.\n"
        "Helps to compare files that were modified under different operating systems.")
        );
     ++line;
 */
     OptionCheckBox* pIgnoreNumbers = new OptionCheckBox(i18n("Ignore numbers (treat as white space)"), false, "IgnoreNumbers", &m_options->m_bIgnoreNumbers, page);
     gbox->addWidget(pIgnoreNumbers, line, 0, 1, 2);
     addOptionItem(pIgnoreNumbers);
     pIgnoreNumbers->setToolTip(i18n(
         "Ignore number characters during line matching phase. (Similar to Ignore white space.)\n"
         "Might help to compare files with numeric data."));
     ++line;
 
     OptionCheckBox* pIgnoreComments = new OptionCheckBox(i18n("Ignore C/C++ comments (treat as white space)"), false, "IgnoreComments", &m_options->m_bIgnoreComments, page);
     gbox->addWidget(pIgnoreComments, line, 0, 1, 2);
     addOptionItem(pIgnoreComments);
     pIgnoreComments->setToolTip(i18n("Treat C/C++ comments like white space."));
     ++line;
 
     OptionCheckBox* pIgnoreCase = new OptionCheckBox(i18n("Ignore case (treat as white space)"), false, "IgnoreCase", &m_options->m_bIgnoreCase, page);
     gbox->addWidget(pIgnoreCase, line, 0, 1, 2);
     addOptionItem(pIgnoreCase);
     pIgnoreCase->setToolTip(i18n(
         "Treat case differences like white space changes. ('a'<=>'A')"));
     ++line;
 
     label = new QLabel(i18n("Preprocessor command:"), page);
     gbox->addWidget(label, line, 0);
     OptionLineEdit* pLE = new OptionLineEdit("", "PreProcessorCmd", &m_options->m_PreProcessorCmd, page);
     gbox->addWidget(pLE, line, 1);
     addOptionItem(pLE);
     label->setToolTip(i18n("User defined pre-processing. (See the docs for details.)"));
     ++line;
 
     label = new QLabel(i18n("Line-matching preprocessor command:"), page);
     gbox->addWidget(label, line, 0);
     pLE = new OptionLineEdit("", "LineMatchingPreProcessorCmd", &m_options->m_LineMatchingPreProcessorCmd, page);
     gbox->addWidget(pLE, line, 1);
     addOptionItem(pLE);
     label->setToolTip(i18n("This pre-processor is only used during line matching.\n(See the docs for details.)"));
     ++line;
 
     OptionCheckBox* pTryHard = new OptionCheckBox(i18n("Try hard (slower)"), true, "TryHard", &m_options->m_bTryHard, page);
     gbox->addWidget(pTryHard, line, 0, 1, 2);
     addOptionItem(pTryHard);
     pTryHard->setToolTip(i18n(
         "Enables the --minimal option for the external diff.\n"
         "The analysis of big files will be much slower."));
     ++line;
 
     OptionCheckBox* pDiff3AlignBC = new OptionCheckBox(i18n("Align B and C for 3 input files"), false, "Diff3AlignBC", &m_options->m_bDiff3AlignBC, page);
     gbox->addWidget(pDiff3AlignBC, line, 0, 1, 2);
     addOptionItem(pDiff3AlignBC);
     pDiff3AlignBC->setToolTip(i18n(
         "Try to align B and C when comparing or merging three input files.\n"
         "Not recommended for merging because merge might get more complicated.\n"
         "(Default is off.)"));
     ++line;
 
     topLayout->addStretch(10);
 }
 
 void OptionDialog::setupMergePage()
 {
     QFrame* page = new QFrame();
     KPageWidgetItem* pageItem = new KPageWidgetItem(page, i18n("Merge"));
     pageItem->setHeader(i18n("Merge Settings"));
     pageItem->setIcon(QIcon::fromTheme(QStringLiteral("merge")));
     addPage(pageItem);
 
     QVBoxLayout* topLayout = new QVBoxLayout(page);
     topLayout->setMargin(5);
 
     QGridLayout* gbox = new QGridLayout();
     gbox->setColumnStretch(1, 5);
     topLayout->addLayout(gbox);
     int line = 0;
 
     QLabel* label = nullptr;
 
     label = new QLabel(i18n("Auto advance delay (ms):"), page);
     gbox->addWidget(label, line, 0);
     OptionIntEdit* pAutoAdvanceDelay = new OptionIntEdit(500, "AutoAdvanceDelay", &m_options->m_autoAdvanceDelay, 0, 2000, page);
     gbox->addWidget(pAutoAdvanceDelay, line, 1);
     addOptionItem(pAutoAdvanceDelay);
     label->setToolTip(i18n(
         "When in Auto-Advance mode the result of the current selection is shown \n"
         "for the specified time, before jumping to the next conflict. Range: 0-2000 ms"));
     ++line;
 
     OptionCheckBox* pShowInfoDialogs = new OptionCheckBox(i18n("Show info dialogs"), true, "ShowInfoDialogs", &m_options->m_bShowInfoDialogs, page);
     gbox->addWidget(pShowInfoDialogs, line, 0, 1, 2);
     addOptionItem(pShowInfoDialogs);
     pShowInfoDialogs->setToolTip(i18n("Show a dialog with information about the number of conflicts."));
     ++line;
 
     label = new QLabel(i18n("White space 2-file merge default:"), page);
     gbox->addWidget(label, line, 0);
     OptionComboBox* pWhiteSpace2FileMergeDefault = new OptionComboBox(0, "WhiteSpace2FileMergeDefault", &m_options->m_whiteSpace2FileMergeDefault, page);
     gbox->addWidget(pWhiteSpace2FileMergeDefault, line, 1);
     addOptionItem(pWhiteSpace2FileMergeDefault);
     pWhiteSpace2FileMergeDefault->insertItem(0, i18n("Manual Choice"));
     pWhiteSpace2FileMergeDefault->insertItem(1, i18n("A"));
     pWhiteSpace2FileMergeDefault->insertItem(2, i18n("B"));
     label->setToolTip(i18n(
         "Allow the merge algorithm to automatically select an input for "
         "white-space-only changes."));
     ++line;
 
     label = new QLabel(i18n("White space 3-file merge default:"), page);
     gbox->addWidget(label, line, 0);
     OptionComboBox* pWhiteSpace3FileMergeDefault = new OptionComboBox(0, "WhiteSpace3FileMergeDefault", &m_options->m_whiteSpace3FileMergeDefault, page);
     gbox->addWidget(pWhiteSpace3FileMergeDefault, line, 1);
     addOptionItem(pWhiteSpace3FileMergeDefault);
     pWhiteSpace3FileMergeDefault->insertItem(0, i18n("Manual Choice"));
     pWhiteSpace3FileMergeDefault->insertItem(1, i18n("A"));
     pWhiteSpace3FileMergeDefault->insertItem(2, i18n("B"));
     pWhiteSpace3FileMergeDefault->insertItem(3, i18n("C"));
     label->setToolTip(i18n(
         "Allow the merge algorithm to automatically select an input for "
         "white-space-only changes."));
     ++line;
 
     QGroupBox* pGroupBox = new QGroupBox(i18n("Automatic Merge Regular Expression"));
     gbox->addWidget(pGroupBox, line, 0, 1, 2);
     ++line;
     {
         gbox = new QGridLayout(pGroupBox);
         gbox->setColumnStretch(1, 10);
         line = 0;
 
         label = new QLabel(i18n("Auto merge regular expression:"), page);
         gbox->addWidget(label, line, 0);
         m_pAutoMergeRegExpLineEdit = new OptionLineEdit(".*\\$(Version|Header|Date|Author).*\\$.*", "AutoMergeRegExp", &m_options->m_autoMergeRegExp, page);
         gbox->addWidget(m_pAutoMergeRegExpLineEdit, line, 1);
         addOptionItem(m_pAutoMergeRegExpLineEdit);
         s_autoMergeRegExpToolTip = i18n("Regular expression for lines where KDiff3 should automatically choose one source.\n"
                                         "When a line with a conflict matches the regular expression then\n"
                                         "- if available - C, otherwise B will be chosen.");
         label->setToolTip(s_autoMergeRegExpToolTip);
         ++line;
 
         OptionCheckBox* pAutoMergeRegExp = new OptionCheckBox(i18n("Run regular expression auto merge on merge start"), false, "RunRegExpAutoMergeOnMergeStart", &m_options->m_bRunRegExpAutoMergeOnMergeStart, page);
         addOptionItem(pAutoMergeRegExp);
         gbox->addWidget(pAutoMergeRegExp, line, 0, 1, 2);
         pAutoMergeRegExp->setToolTip(i18n("Run the merge for auto merge regular expressions\n"
                                           "immediately when a merge starts.\n"));
         ++line;
     }
 
     pGroupBox = new QGroupBox(i18n("Version Control History Merging"));
     gbox->addWidget(pGroupBox, line, 0, 1, 2);
     ++line;
     {
         gbox = new QGridLayout(pGroupBox);
         gbox->setColumnStretch(1, 10);
         line = 0;
 
         label = new QLabel(i18n("History start regular expression:"), page);
         gbox->addWidget(label, line, 0);
         m_pHistoryStartRegExpLineEdit = new OptionLineEdit(".*\\$Log.*\\$.*", "HistoryStartRegExp", &m_options->m_historyStartRegExp, page);
         gbox->addWidget(m_pHistoryStartRegExpLineEdit, line, 1);
         addOptionItem(m_pHistoryStartRegExpLineEdit);
         s_historyStartRegExpToolTip = i18n("Regular expression for the start of the version control history entry.\n"
                                            "Usually this line contains the \"$Log$\" keyword.\n"
                                            "Default value: \".*\\$Log.*\\$.*\"");
         label->setToolTip(s_historyStartRegExpToolTip);
         ++line;
 
         label = new QLabel(i18n("History entry start regular expression:"), page);
         gbox->addWidget(label, line, 0);
         // Example line:  "** \main\rolle_fsp_dev_008\1   17 Aug 2001 10:45:44   rolle"
         QString historyEntryStartDefault =
             "\\s*\\\\main\\\\(\\S+)\\s+"                         // Start with  "\main\"
             "([0-9]+) "                                          // day
             "(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) " //month
             "([0-9][0-9][0-9][0-9]) "                            // year
             "([0-9][0-9]:[0-9][0-9]:[0-9][0-9])\\s+(.*)";        // time, name
 
         m_pHistoryEntryStartRegExpLineEdit = new OptionLineEdit(historyEntryStartDefault, "HistoryEntryStartRegExp", &m_options->m_historyEntryStartRegExp, page);
         gbox->addWidget(m_pHistoryEntryStartRegExpLineEdit, line, 1);
         addOptionItem(m_pHistoryEntryStartRegExpLineEdit);
         s_historyEntryStartRegExpToolTip = i18n("A version control history entry consists of several lines.\n"
                                                 "Specify the regular expression to detect the first line (without the leading comment).\n"
                                                 "Use parentheses to group the keys you want to use for sorting.\n"
                                                 "If left empty, then KDiff3 assumes that empty lines separate history entries.\n"
                                                 "See the documentation for details.");
         label->setToolTip(s_historyEntryStartRegExpToolTip);
         ++line;
 
         m_pHistoryMergeSorting = new OptionCheckBox(i18n("History merge sorting"), false, "HistoryMergeSorting", &m_options->m_bHistoryMergeSorting, page);
         gbox->addWidget(m_pHistoryMergeSorting, line, 0, 1, 2);
         addOptionItem(m_pHistoryMergeSorting);
         m_pHistoryMergeSorting->setToolTip(i18n("Sort version control history by a key."));
         ++line;
         //QString branch = newHistoryEntry.cap(1);
         //int day    = newHistoryEntry.cap(2).toInt();
         //int month  = QString("Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec").find(newHistoryEntry.cap(3))/4 + 1;
         //int year   = newHistoryEntry.cap(4).toInt();
         //QString time = newHistoryEntry.cap(5);
         //QString name = newHistoryEntry.cap(6);
         QString defaultSortKeyOrder = "4,3,2,5,1,6"; //QDate(year,month,day).toString(Qt::ISODate) +" "+ time + " " + branch + " " + name;
 
         label = new QLabel(i18n("History entry start sort key order:"), page);
         gbox->addWidget(label, line, 0);
         m_pHistorySortKeyOrderLineEdit = new OptionLineEdit(defaultSortKeyOrder, "HistoryEntryStartSortKeyOrder", &m_options->m_historyEntryStartSortKeyOrder, page);
         gbox->addWidget(m_pHistorySortKeyOrderLineEdit, line, 1);
         addOptionItem(m_pHistorySortKeyOrderLineEdit);
         s_historyEntryStartSortKeyOrderToolTip = i18n("Each pair of parentheses used in the regular expression for the history start entry\n"
                                                       "groups a key that can be used for sorting.\n"
                                                       "Specify the list of keys (that are numbered in order of occurrence\n"
                                                       "starting with 1) using ',' as separator (e.g. \"4,5,6,1,2,3,7\").\n"
                                                       "If left empty, then no sorting will be done.\n"
                                                       "See the documentation for details.");
         label->setToolTip(s_historyEntryStartSortKeyOrderToolTip);
         m_pHistorySortKeyOrderLineEdit->setEnabled(false);
         connect(m_pHistoryMergeSorting, &OptionCheckBox::toggled, m_pHistorySortKeyOrderLineEdit, &OptionLineEdit::setEnabled);
         ++line;
 
         m_pHistoryAutoMerge = new OptionCheckBox(i18n("Merge version control history on merge start"), false, "RunHistoryAutoMergeOnMergeStart", &m_options->m_bRunHistoryAutoMergeOnMergeStart, page);
         addOptionItem(m_pHistoryAutoMerge);
         gbox->addWidget(m_pHistoryAutoMerge, line, 0, 1, 2);
         m_pHistoryAutoMerge->setToolTip(i18n("Run version control history automerge on merge start."));
         ++line;
 
         OptionIntEdit* pMaxNofHistoryEntries = new OptionIntEdit(-1, "MaxNofHistoryEntries", &m_options->m_maxNofHistoryEntries, -1, 1000, page);
         label = new QLabel(i18n("Max number of history entries:"), page);
         gbox->addWidget(label, line, 0);
         gbox->addWidget(pMaxNofHistoryEntries, line, 1);
         addOptionItem(pMaxNofHistoryEntries);
         pMaxNofHistoryEntries->setToolTip(i18n("Cut off after specified number. Use -1 for infinite number of entries."));
         ++line;
     }
 
     QPushButton* pButton = new QPushButton(i18n("Test your regular expressions"), page);
     gbox->addWidget(pButton, line, 0);
     connect(pButton, &QPushButton::clicked, this, &OptionDialog::slotHistoryMergeRegExpTester);
     ++line;
 
     label = new QLabel(i18n("Irrelevant merge command:"), page);
     gbox->addWidget(label, line, 0);
     OptionLineEdit* pLE = new OptionLineEdit("", "IrrelevantMergeCmd", &m_options->m_IrrelevantMergeCmd, page);
     gbox->addWidget(pLE, line, 1);
     addOptionItem(pLE);
     label->setToolTip(i18n("If specified this script is run after automerge\n"
                            "when no other relevant changes were detected.\n"
                            "Called with the parameters: filename1 filename2 filename3"));
     ++line;
 
     OptionCheckBox* pAutoSaveAndQuit = new OptionCheckBox(i18n("Auto save and quit on merge without conflicts"), false,
                                                           "AutoSaveAndQuitOnMergeWithoutConflicts", &m_options->m_bAutoSaveAndQuitOnMergeWithoutConflicts, page);
     gbox->addWidget(pAutoSaveAndQuit, line, 0, 1, 2);
     addOptionItem(pAutoSaveAndQuit);
     pAutoSaveAndQuit->setToolTip(i18n("If KDiff3 was started for a file-merge from the command line and all\n"
                                       "conflicts are solvable without user interaction then automatically save and quit.\n"
                                       "(Similar to command line option \"--auto\".)"));
     ++line;
 
     topLayout->addStretch(10);
 }
 
 void OptionDialog::setupDirectoryMergePage()
 {
     QFrame* page = new QFrame();
     KPageWidgetItem* pageItem = new KPageWidgetItem(page, i18n("Directory"));
     pageItem->setHeader(i18n("Directory"));
     pageItem->setIcon(QIcon::fromTheme(QStringLiteral("inode-directory")));
     addPage(pageItem);
 
     QVBoxLayout* topLayout = new QVBoxLayout(page);
     topLayout->setMargin(5);
 
     QGridLayout* gbox = new QGridLayout();
     gbox->setColumnStretch(1, 5);
     topLayout->addLayout(gbox);
     int line = 0;
 
     OptionCheckBox* pRecursiveDirs = new OptionCheckBox(i18n("Recursive directories"), true, "RecursiveDirs", &m_options->m_bDmRecursiveDirs, page);
     gbox->addWidget(pRecursiveDirs, line, 0, 1, 2);
     addOptionItem(pRecursiveDirs);
     pRecursiveDirs->setToolTip(i18n("Whether to analyze subdirectories or not."));
     ++line;
     QLabel* label = new QLabel(i18n("File pattern(s):"), page);
     gbox->addWidget(label, line, 0);
     OptionLineEdit* pFilePattern = new OptionLineEdit("*", "FilePattern", &m_options->m_DmFilePattern, page);
     gbox->addWidget(pFilePattern, line, 1);
     addOptionItem(pFilePattern);
     label->setToolTip(i18n(
         "Pattern(s) of files to be analyzed. \n"
         "Wildcards: '*' and '?'\n"
         "Several Patterns can be specified by using the separator: ';'"));
     ++line;
 
     label = new QLabel(i18n("File-anti-pattern(s):"), page);
     gbox->addWidget(label, line, 0);
     OptionLineEdit* pFileAntiPattern = new OptionLineEdit("*.orig;*.o;*.obj;*.rej;*.bak", "FileAntiPattern", &m_options->m_DmFileAntiPattern, page);
     gbox->addWidget(pFileAntiPattern, line, 1);
     addOptionItem(pFileAntiPattern);
     label->setToolTip(i18n(
         "Pattern(s) of files to be excluded from analysis. \n"
         "Wildcards: '*' and '?'\n"
         "Several Patterns can be specified by using the separator: ';'"));
     ++line;
 
     label = new QLabel(i18n("Dir-anti-pattern(s):"), page);
     gbox->addWidget(label, line, 0);
     OptionLineEdit* pDirAntiPattern = new OptionLineEdit("CVS;.deps;.svn;.hg;.git", "DirAntiPattern", &m_options->m_DmDirAntiPattern, page);
     gbox->addWidget(pDirAntiPattern, line, 1);
     addOptionItem(pDirAntiPattern);
     label->setToolTip(i18n(
         "Pattern(s) of directories to be excluded from analysis. \n"
         "Wildcards: '*' and '?'\n"
         "Several Patterns can be specified by using the separator: ';'"));
     ++line;
 
     OptionCheckBox* pUseCvsIgnore = new OptionCheckBox(i18n("Use .cvsignore"), false, "UseCvsIgnore", &m_options->m_bDmUseCvsIgnore, page);
     gbox->addWidget(pUseCvsIgnore, line, 0, 1, 2);
     addOptionItem(pUseCvsIgnore);
     pUseCvsIgnore->setToolTip(i18n(
         "Extends the antipattern to anything that would be ignored by CVS.\n"
         "Via local \".cvsignore\" files this can be directory specific."));
     ++line;
 
     OptionCheckBox* pFindHidden = new OptionCheckBox(i18n("Find hidden files and directories"), true, "FindHidden", &m_options->m_bDmFindHidden, page);
     gbox->addWidget(pFindHidden, line, 0, 1, 2);
     addOptionItem(pFindHidden);
     pFindHidden->setToolTip(i18n("Finds hidden files and directories."));
     ++line;
 
     OptionCheckBox* pFollowFileLinks = new OptionCheckBox(i18n("Follow file links"), false, "FollowFileLinks", &m_options->m_bDmFollowFileLinks, page);
     gbox->addWidget(pFollowFileLinks, line, 0, 1, 2);
     addOptionItem(pFollowFileLinks);
     pFollowFileLinks->setToolTip(i18n(
         "On: Compare the file the link points to.\n"
         "Off: Compare the links."));
     ++line;
 
     OptionCheckBox* pFollowDirLinks = new OptionCheckBox(i18n("Follow directory links"), false, "FollowDirLinks", &m_options->m_bDmFollowDirLinks, page);
     gbox->addWidget(pFollowDirLinks, line, 0, 1, 2);
     addOptionItem(pFollowDirLinks);
     pFollowDirLinks->setToolTip(i18n(
         "On: Compare the directory the link points to.\n"
         "Off: Compare the links."));
     ++line;
 
 #if defined(Q_OS_WIN)
     bool bCaseSensitiveFilenameComparison = false;
 #else
     bool bCaseSensitiveFilenameComparison = true;
 #endif
     OptionCheckBox* pCaseSensitiveFileNames = new OptionCheckBox(i18n("Case sensitive filename comparison"), bCaseSensitiveFilenameComparison, "CaseSensitiveFilenameComparison", &m_options->m_bDmCaseSensitiveFilenameComparison, page);
     gbox->addWidget(pCaseSensitiveFileNames, line, 0, 1, 2);
     addOptionItem(pCaseSensitiveFileNames);
     pCaseSensitiveFileNames->setToolTip(i18n(
         "The directory comparison will compare files or directories when their names match.\n"
         "Set this option if the case of the names must match. (Default for Windows is off, otherwise on.)"));
     ++line;
 
     OptionCheckBox* pUnfoldSubdirs = new OptionCheckBox(i18n("Unfold all subdirectories on load"), false, "UnfoldSubdirs", &m_options->m_bDmUnfoldSubdirs, page);
     gbox->addWidget(pUnfoldSubdirs, line, 0, 1, 2);
     addOptionItem(pUnfoldSubdirs);
     pUnfoldSubdirs->setToolTip(i18n(
         "On: Unfold all subdirectories when starting a directory diff.\n"
         "Off: Leave subdirectories folded."));
     ++line;
 
     OptionCheckBox* pSkipDirStatus = new OptionCheckBox(i18n("Skip directory status report"), false, "SkipDirStatus", &m_options->m_bDmSkipDirStatus, page);
     gbox->addWidget(pSkipDirStatus, line, 0, 1, 2);
     addOptionItem(pSkipDirStatus);
     pSkipDirStatus->setToolTip(i18n(
         "On: Do not show the Directory Comparison Status.\n"
         "Off: Show the status dialog on start."));
     ++line;
 
     QGroupBox* pBG = new QGroupBox(i18n("File Comparison Mode"));
     gbox->addWidget(pBG, line, 0, 1, 2);
 
     QVBoxLayout* pBGLayout = new QVBoxLayout(pBG);
 
     OptionRadioButton* pBinaryComparison = new OptionRadioButton(i18n("Binary comparison"), true, "BinaryComparison", &m_options->m_bDmBinaryComparison, pBG);
     addOptionItem(pBinaryComparison);
     pBinaryComparison->setToolTip(i18n("Binary comparison of each file. (Default)"));
     pBGLayout->addWidget(pBinaryComparison);
 
     OptionRadioButton* pFullAnalysis = new OptionRadioButton(i18n("Full analysis"), false, "FullAnalysis", &m_options->m_bDmFullAnalysis, pBG);
     addOptionItem(pFullAnalysis);
     pFullAnalysis->setToolTip(i18n("Do a full analysis and show statistics information in extra columns.\n"
                                    "(Slower than a binary comparison, much slower for binary files.)"));
     pBGLayout->addWidget(pFullAnalysis);
 
     OptionRadioButton* pTrustDate = new OptionRadioButton(i18n("Trust the size and modification date (unsafe)"), false, "TrustDate", &m_options->m_bDmTrustDate, pBG);
     addOptionItem(pTrustDate);
     pTrustDate->setToolTip(i18n("Assume that files are equal if the modification date and file length are equal.\n"
                                 "Files with equal contents but different modification dates will appear as different.\n"
                                 "Useful for big directories or slow networks."));
     pBGLayout->addWidget(pTrustDate);
 
     OptionRadioButton* pTrustDateFallbackToBinary = new OptionRadioButton(i18n("Trust the size and date, but use binary comparison if date does not match (unsafe)"), false, "TrustDateFallbackToBinary", &m_options->m_bDmTrustDateFallbackToBinary, pBG);
     addOptionItem(pTrustDateFallbackToBinary);
     pTrustDateFallbackToBinary->setToolTip(i18n("Assume that files are equal if the modification date and file length are equal.\n"
                                                 "If the dates are not equal but the sizes are, use binary comparison.\n"
                                                 "Useful for big directories or slow networks."));
     pBGLayout->addWidget(pTrustDateFallbackToBinary);
 
     OptionRadioButton* pTrustSize = new OptionRadioButton(i18n("Trust the size (unsafe)"), false, "TrustSize", &m_options->m_bDmTrustSize, pBG);
     addOptionItem(pTrustSize);
     pTrustSize->setToolTip(i18n("Assume that files are equal if their file lengths are equal.\n"
                                 "Useful for big directories or slow networks when the date is modified during download."));
     pBGLayout->addWidget(pTrustSize);
 
     ++line;
 
     // Some two Dir-options: Affects only the default actions.
     OptionCheckBox* pSyncMode = new OptionCheckBox(i18n("Synchronize directories"), false, "SyncMode", &m_options->m_bDmSyncMode, page);
     addOptionItem(pSyncMode);
     gbox->addWidget(pSyncMode, line, 0, 1, 2);
     pSyncMode->setToolTip(i18n(
         "Offers to store files in both directories so that\n"
         "both directories are the same afterwards.\n"
         "Works only when comparing two directories without specifying a destination."));
     ++line;
 
     // Allow white-space only differences to be considered equal
     OptionCheckBox* pWhiteSpaceDiffsEqual = new OptionCheckBox(i18n("White space differences considered equal"), true, "WhiteSpaceEqual", &m_options->m_bDmWhiteSpaceEqual, page);
     addOptionItem(pWhiteSpaceDiffsEqual);
     gbox->addWidget(pWhiteSpaceDiffsEqual, line, 0, 1, 2);
     pWhiteSpaceDiffsEqual->setToolTip(i18n(
         "If files differ only by white space consider them equal.\n"
         "This is only active when full analysis is chosen."));
     connect(pFullAnalysis, &OptionRadioButton::toggled, pWhiteSpaceDiffsEqual, &OptionCheckBox::setEnabled);
     pWhiteSpaceDiffsEqual->setEnabled(false);
     ++line;
 
     OptionCheckBox* pCopyNewer = new OptionCheckBox(i18n("Copy newer instead of merging (unsafe)"), false, "CopyNewer", &m_options->m_bDmCopyNewer, page);
     addOptionItem(pCopyNewer);
     gbox->addWidget(pCopyNewer, line, 0, 1, 2);
     pCopyNewer->setToolTip(i18n(
         "Do not look inside, just take the newer file.\n"
         "(Use this only if you know what you are doing!)\n"
         "Only effective when comparing two directories."));
     ++line;
 
     OptionCheckBox* pCreateBakFiles = new OptionCheckBox(i18n("Backup files (.orig)"), true, "CreateBakFiles", &m_options->m_bDmCreateBakFiles, page);
     gbox->addWidget(pCreateBakFiles, line, 0, 1, 2);
     addOptionItem(pCreateBakFiles);
     pCreateBakFiles->setToolTip(i18n(
         "If a file would be saved over an old file, then the old file\n"
         "will be renamed with a '.orig' extension instead of being deleted."));
     ++line;
 
     topLayout->addStretch(10);
 }
 /*
 static void insertCodecs(OptionComboBox* p)
 {
    std::multimap<QString,QString> m;  // Using the multimap for case-insensitive sorting.
    int i;
    for(i=0;;++i)
    {
       QTextCodec* pCodec = QTextCodec::codecForIndex ( i );
       if ( pCodec != 0 )  m.insert( std::make_pair( QString(pCodec->mimeName()).toUpper(), pCodec->mimeName()) );
       else                break;
    }
 
    p->insertItem( i18n("Auto"), 0 );
    std::multimap<QString,QString>::iterator mi;
    for(mi=m.begin(), i=0; mi!=m.end(); ++mi, ++i)
       p->insertItem(mi->second, i+1);
 }
 */
 /*
 // UTF8-Codec that saves a BOM
 // UTF8-Codec that saves a BOM
 class Utf8BOMCodec : public QTextCodec
 {
    QTextCodec* m_pUtf8Codec;
    class PublicTextCodec : public QTextCodec
    {
    public:
       QString publicConvertToUnicode ( const char * p, int len, ConverterState* pState ) const
       {
          return convertToUnicode( p, len, pState );
       }
       QByteArray publicConvertFromUnicode ( const QChar * input, int number, ConverterState * pState ) const
       {
          return convertFromUnicode( input, number, pState );
       }
    };
 public:
    Utf8BOMCodec()
    {
       m_pUtf8Codec = QTextCodec::codecForName("UTF-8");
    }
    QByteArray name () const { return "UTF-8-BOM"; }
    int mibEnum () const { return 2123; }
    QByteArray convertFromUnicode ( const QChar * input, int number, ConverterState * pState ) const
    {
       QByteArray r;
       if ( pState && pState->state_data[2]==0)  // state_data[2] not used by QUtf8::convertFromUnicode (see qutfcodec.cpp)
       {
         r += "\xEF\xBB\xBF";
         pState->state_data[2]=1;
         pState->flags |= QTextCodec::IgnoreHeader;
       }
 
       r += ((PublicTextCodec*)m_pUtf8Codec)->publicConvertFromUnicode( input, number, pState );
       return r;
    }
    QString convertToUnicode ( const char * p, int len, ConverterState* pState ) const
    {
       return ((PublicTextCodec*)m_pUtf8Codec)->publicConvertToUnicode( p, len, pState );
    }
 };
 */
 void OptionDialog::setupRegionalPage()
 {
     /*
      TODO: What is this line supposed to do besides leak memory? Introduced as is in .91 no explanation
         new Utf8BOMCodec();
    */
 
     QFrame* page = new QFrame();
     KPageWidgetItem* pageItem = new KPageWidgetItem(page, i18n("Regional Settings"));
     pageItem->setHeader(i18n("Regional Settings"));
     pageItem->setIcon(QIcon::fromTheme(QStringLiteral("preferences-desktop-locale")));
     addPage(pageItem);
 
     QVBoxLayout* topLayout = new QVBoxLayout(page);
     topLayout->setMargin(5);
 
     QGridLayout* gbox = new QGridLayout();
     gbox->setColumnStretch(1, 5);
     topLayout->addLayout(gbox);
     int line = 0;
 
     QLabel* label;
 
     m_pSameEncoding = new OptionCheckBox(i18n("Use the same encoding for everything:"), true, "SameEncoding", &m_options->m_bSameEncoding, page);
     addOptionItem(m_pSameEncoding);
     gbox->addWidget(m_pSameEncoding, line, 0, 1, 2);
     m_pSameEncoding->setToolTip(i18n(
         "Enable this allows to change all encodings by changing the first only.\n"
         "Disable this if different individual settings are needed."));
     ++line;
 
     label = new QLabel(i18n("Note: Local Encoding is \"%1\"", QLatin1String(QTextCodec::codecForLocale()->name())), page);
     gbox->addWidget(label, line, 0);
     ++line;
 
     label = new QLabel(i18n("File Encoding for A:"), page);
     gbox->addWidget(label, line, 0);
     m_pEncodingAComboBox = new OptionEncodingComboBox("EncodingForA", &m_options->m_pEncodingA, page);
     addOptionItem(m_pEncodingAComboBox);
     gbox->addWidget(m_pEncodingAComboBox, line, 1);
 
     QString autoDetectToolTip = i18n(
         "If enabled then Unicode (UTF-16 or UTF-8) encoding will be detected.\n"
         "If the file is not Unicode then the selected encoding will be used as fallback.\n"
         "(Unicode detection depends on the first bytes of a file.)");
     m_pAutoDetectUnicodeA = new OptionCheckBox(i18n("Auto Detect Unicode"), true, "AutoDetectUnicodeA", &m_options->m_bAutoDetectUnicodeA, page);
     gbox->addWidget(m_pAutoDetectUnicodeA, line, 2);
     addOptionItem(m_pAutoDetectUnicodeA);
     m_pAutoDetectUnicodeA->setToolTip(autoDetectToolTip);
     ++line;
 
     label = new QLabel(i18n("File Encoding for B:"), page);
     gbox->addWidget(label, line, 0);
     m_pEncodingBComboBox = new OptionEncodingComboBox("EncodingForB", &m_options->m_pEncodingB, page);
     addOptionItem(m_pEncodingBComboBox);
     gbox->addWidget(m_pEncodingBComboBox, line, 1);
     m_pAutoDetectUnicodeB = new OptionCheckBox(i18n("Auto Detect Unicode"), true, "AutoDetectUnicodeB", &m_options->m_bAutoDetectUnicodeB, page);
     addOptionItem(m_pAutoDetectUnicodeB);
     gbox->addWidget(m_pAutoDetectUnicodeB, line, 2);
     m_pAutoDetectUnicodeB->setToolTip(autoDetectToolTip);
     ++line;
 
     label = new QLabel(i18n("File Encoding for C:"), page);
     gbox->addWidget(label, line, 0);
     m_pEncodingCComboBox = new OptionEncodingComboBox("EncodingForC", &m_options->m_pEncodingC, page);
     addOptionItem(m_pEncodingCComboBox);
     gbox->addWidget(m_pEncodingCComboBox, line, 1);
     m_pAutoDetectUnicodeC = new OptionCheckBox(i18n("Auto Detect Unicode"), true, "AutoDetectUnicodeC", &m_options->m_bAutoDetectUnicodeC, page);
     addOptionItem(m_pAutoDetectUnicodeC);
     gbox->addWidget(m_pAutoDetectUnicodeC, line, 2);
     m_pAutoDetectUnicodeC->setToolTip(autoDetectToolTip);
     ++line;
 
     label = new QLabel(i18n("File Encoding for Merge Output and Saving:"), page);
     gbox->addWidget(label, line, 0);
     m_pEncodingOutComboBox = new OptionEncodingComboBox("EncodingForOutput", &m_options->m_pEncodingOut, page);
     addOptionItem(m_pEncodingOutComboBox);
     gbox->addWidget(m_pEncodingOutComboBox, line, 1);
     m_pAutoSelectOutEncoding = new OptionCheckBox(i18n("Auto Select"), true, "AutoSelectOutEncoding", &m_options->m_bAutoSelectOutEncoding, page);
     addOptionItem(m_pAutoSelectOutEncoding);
     gbox->addWidget(m_pAutoSelectOutEncoding, line, 2);
     m_pAutoSelectOutEncoding->setToolTip(i18n(
         "If enabled then the encoding from the input files is used.\n"
         "In ambiguous cases a dialog will ask the user to choose the encoding for saving."));
     ++line;
     label = new QLabel(i18n("File Encoding for Preprocessor Files:"), page);
     gbox->addWidget(label, line, 0);
     m_pEncodingPPComboBox = new OptionEncodingComboBox("EncodingForPP", &m_options->m_pEncodingPP, page);
     addOptionItem(m_pEncodingPPComboBox);
     gbox->addWidget(m_pEncodingPPComboBox, line, 1);
     ++line;
 
     connect(m_pSameEncoding, &OptionCheckBox::toggled, this, &OptionDialog::slotEncodingChanged);
     connect(m_pEncodingAComboBox, static_cast<void (OptionEncodingComboBox::*)(int)>(&OptionEncodingComboBox::activated), this, &OptionDialog::slotEncodingChanged);
     connect(m_pAutoDetectUnicodeA, &OptionCheckBox::toggled, this, &OptionDialog::slotEncodingChanged);
     connect(m_pAutoSelectOutEncoding, &OptionCheckBox::toggled, this, &OptionDialog::slotEncodingChanged);
 
     OptionCheckBox* pRightToLeftLanguage = new OptionCheckBox(i18n("Right To Left Language"), false, "RightToLeftLanguage", &m_options->m_bRightToLeftLanguage, page);
     addOptionItem(pRightToLeftLanguage);
     gbox->addWidget(pRightToLeftLanguage, line, 0, 1, 2);
     pRightToLeftLanguage->setToolTip(i18n(
         "Some languages are read from right to left.\n"
         "This setting will change the viewer and editor accordingly."));
     ++line;
 
     topLayout->addStretch(10);
 }
 
 void OptionDialog::setupIntegrationPage()
 {
     QFrame* page = new QFrame();
     KPageWidgetItem* pageItem = new KPageWidgetItem(page, i18n("Integration"));
     pageItem->setHeader(i18n("Integration Settings"));
     pageItem->setIcon(QIcon::fromTheme(QStringLiteral("utilities-terminal")));
     addPage(pageItem);
 
     QVBoxLayout* topLayout = new QVBoxLayout(page);
     topLayout->setMargin(5);
 
     QGridLayout* gbox = new QGridLayout();
     gbox->setColumnStretch(2, 5);
     topLayout->addLayout(gbox);
     int line = 0;
 
     QLabel* label;
     label = new QLabel(i18n("Command line options to ignore:"), page);
     gbox->addWidget(label, line, 0);
     OptionLineEdit* pIgnorableCmdLineOptions = new OptionLineEdit("-u;-query;-html;-abort", "IgnorableCmdLineOptions", &m_options->m_ignorableCmdLineOptions, page);
     gbox->addWidget(pIgnorableCmdLineOptions, line, 1, 1, 2);
     addOptionItem(pIgnorableCmdLineOptions);
     label->setToolTip(i18n(
         "List of command line options that should be ignored when KDiff3 is used by other tools.\n"
         "Several values can be specified if separated via ';'\n"
         "This will suppress the \"Unknown option\" error."));
     ++line;
 
     OptionCheckBox* pEscapeKeyQuits = new OptionCheckBox(i18n("Quit also via Escape key"), false, "EscapeKeyQuits", &m_options->m_bEscapeKeyQuits, page);
     gbox->addWidget(pEscapeKeyQuits, line, 0, 1, 2);
     addOptionItem(pEscapeKeyQuits);
     pEscapeKeyQuits->setToolTip(i18n(
         "Fast method to exit.\n"
         "For those who are used to using the Escape key."));
     ++line;
 
     topLayout->addStretch(10);
 }
 
 
 void OptionDialog::slotEncodingChanged()
 {
     if(m_pSameEncoding->isChecked())
     {
         m_pEncodingBComboBox->setEnabled(false);
         m_pEncodingBComboBox->setCurrentIndex(m_pEncodingAComboBox->currentIndex());
         m_pEncodingCComboBox->setEnabled(false);
         m_pEncodingCComboBox->setCurrentIndex(m_pEncodingAComboBox->currentIndex());
         m_pEncodingOutComboBox->setEnabled(false);
         m_pEncodingOutComboBox->setCurrentIndex(m_pEncodingAComboBox->currentIndex());
         m_pEncodingPPComboBox->setEnabled(false);
         m_pEncodingPPComboBox->setCurrentIndex(m_pEncodingAComboBox->currentIndex());
         m_pAutoDetectUnicodeB->setEnabled(false);
         m_pAutoDetectUnicodeB->setCheckState(m_pAutoDetectUnicodeA->checkState());
         m_pAutoDetectUnicodeC->setEnabled(false);
         m_pAutoDetectUnicodeC->setCheckState(m_pAutoDetectUnicodeA->checkState());
         m_pAutoSelectOutEncoding->setEnabled(false);
         m_pAutoSelectOutEncoding->setCheckState(m_pAutoDetectUnicodeA->checkState());
     }
     else
     {
         m_pEncodingBComboBox->setEnabled(true);
         m_pEncodingCComboBox->setEnabled(true);
         m_pEncodingOutComboBox->setEnabled(true);
         m_pEncodingPPComboBox->setEnabled(true);
         m_pAutoDetectUnicodeB->setEnabled(true);
         m_pAutoDetectUnicodeC->setEnabled(true);
         m_pAutoSelectOutEncoding->setEnabled(true);
         m_pEncodingOutComboBox->setEnabled(m_pAutoSelectOutEncoding->checkState() == Qt::Unchecked);
     }
 }
 
 void OptionDialog::setupKeysPage()
 {
     //QVBox *page = addVBoxPage( i18n("Keys"), i18n("KeyDialog" ),
     //                          BarIcon("fonts", KIconLoader::SizeMedium ) );
 
     //QVBoxLayout *topLayout = new QVBoxLayout( page, 0, spacingHint() );
     //           new KFontChooser( page,"font",false/*onlyFixed*/,QStringList(),false,6 );
     //m_pKeyDialog=new KKeyDialog( false, 0 );
     //topLayout->addWidget( m_pKeyDialog );
 }
 
 void OptionDialog::slotOk()
 {
     slotApply();
 
     accept();
 }
 
 /** Copy the values from the widgets to the public variables.*/
 void OptionDialog::slotApply()
 {
     m_options->apply();
 
     emit applyDone();
 }
 
 /** Set the default values in the widgets only, while the
     public variables remain unchanged. */
 void OptionDialog::slotDefault()
 {
     int result = KMessageBox::warningContinueCancel(this, i18n("This resets all options. Not only those of the current topic."));
     if(result == KMessageBox::Cancel)
         return;
     else
         resetToDefaults();
 }
 
 void OptionDialog::resetToDefaults()
 {
     m_options->resetToDefaults();
     slotEncodingChanged();
 }
 
 /** Initialise the widgets using the values in the public varibles. */
 void OptionDialog::setState()
 {
     m_options->setToCurrent();
 
     slotEncodingChanged();
 }
 
 void OptionDialog::saveOptions(KSharedConfigPtr config)
 {
     // No i18n()-Translations here!
     m_options->saveOptions(config);
 }
 
 void OptionDialog::readOptions(KSharedConfigPtr config)
 {
     // No i18n()-Translations here!
     m_options->readOptions(config);
 
     setState();
 }
 
 QString OptionDialog::parseOptions(const QStringList& optionList)
 {
 
     return m_options->parseOptions(optionList);
 }
 
 QString OptionDialog::calcOptionHelp()
 {
     return m_options->calcOptionHelp();
 }
 
 void OptionDialog::slotHistoryMergeRegExpTester()
 {
     QPointer<RegExpTester> dlg=QPointer<RegExpTester>(new RegExpTester(this, s_autoMergeRegExpToolTip, s_historyStartRegExpToolTip,
                      s_historyEntryStartRegExpToolTip, s_historyEntryStartSortKeyOrderToolTip));
     dlg->init(m_pAutoMergeRegExpLineEdit->currentText(), m_pHistoryStartRegExpLineEdit->currentText(),
              m_pHistoryEntryStartRegExpLineEdit->currentText(), m_pHistorySortKeyOrderLineEdit->currentText());
     if(dlg->exec())
     {
         m_pAutoMergeRegExpLineEdit->setEditText(dlg->autoMergeRegExp());
         m_pHistoryStartRegExpLineEdit->setEditText(dlg->historyStartRegExp());
         m_pHistoryEntryStartRegExpLineEdit->setEditText(dlg->historyEntryStartRegExp());
         m_pHistorySortKeyOrderLineEdit->setEditText(dlg->historySortKeyOrder());
     }
 }
 
 #include "optiondialog.moc"
diff --git a/src/optiondialog.h b/src/optiondialog.h
index af928dc..2b0dc98 100644
--- a/src/optiondialog.h
+++ b/src/optiondialog.h
@@ -1,133 +1,133 @@
 /*
  *   kdiff3 - Text Diff And Merge Tool
  *   Copyright (C) 2002-2007  Joachim Eibl, joachim.eibl at gmx.de
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
  *   the Free Software Foundation; either version 2 of the License, or
  *   (at your option) any later version.
  *
  *   This program is distributed in the hope that it will be useful,
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *   GNU General Public License for more details.
  *
  *   You should have received a copy of the GNU General Public License
  *   along with this program; if not, write to the Free Software
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  *
  */
 
 #ifndef OPTION_DIALOG_H
 #define OPTION_DIALOG_H
 
+#include "options.h"
+
+#include <QSharedPointer>   // for QSharedPointer
 #include <QStringList>
 #include <QGroupBox>
 
 #include <KPageDialog>
 #include <KSharedConfig>
 
-#include <list>
-
-#include "options.h"
 
 class QLabel;
 class QPlainTextEdit;
 
 class OptionItemBase;
 class OptionCheckBox;
 class OptionEncodingComboBox;
 class OptionLineEdit;
 class KKeyDialog;
 
 class OptionDialog : public KPageDialog
 {
    Q_OBJECT
 
 public:
 
     explicit OptionDialog( bool bShowDirMergeSettings, QWidget *parent = nullptr );
     ~OptionDialog() override;
     QString parseOptions( const QStringList& optionList );
     QString calcOptionHelp();
 
     void saveOptions(KSharedConfigPtr config);
     void readOptions(KSharedConfigPtr config);
 
     void setState(); // Must be called before calling exec();
 
     void addOptionItem(OptionItemBase*);
 
     QSharedPointer<Options> getOptions() { return m_options; }
 
     KKeyDialog* m_pKeyDialog;
 protected Q_SLOTS:
     virtual void slotDefault();
     virtual void slotOk();
     virtual void slotApply();
     //virtual void buttonClicked( QAbstractButton* );
     virtual void helpRequested();
 
     void slotEncodingChanged();
     void slotHistoryMergeRegExpTester();
 Q_SIGNALS:
     void applyDone();
 private:
     void setupFontPage();
     void setupColorPage();
     void setupEditPage();
     void setupDiffPage();
     void setupMergePage();
     void setupDirectoryMergePage();
     void setupKeysPage();
     void setupRegionalPage();
     void setupIntegrationPage();
     void setupOtherOptions();
 
     void resetToDefaults();
 
 
     QSharedPointer<Options> m_options=QSharedPointer<Options>::create(Options());
     //QDialogButtonBox *mButtonBox;
     OptionCheckBox* m_pSameEncoding;
     OptionEncodingComboBox* m_pEncodingAComboBox;
     OptionCheckBox* m_pAutoDetectUnicodeA;
     OptionEncodingComboBox* m_pEncodingBComboBox;
     OptionCheckBox* m_pAutoDetectUnicodeB;
     OptionEncodingComboBox* m_pEncodingCComboBox;
     OptionCheckBox* m_pAutoDetectUnicodeC;
     OptionEncodingComboBox* m_pEncodingOutComboBox;
     OptionCheckBox* m_pAutoSelectOutEncoding;
     OptionEncodingComboBox* m_pEncodingPPComboBox;
     OptionCheckBox* m_pHistoryAutoMerge;
     OptionLineEdit* m_pAutoMergeRegExpLineEdit;
     OptionLineEdit* m_pHistoryStartRegExpLineEdit;
     OptionLineEdit* m_pHistoryEntryStartRegExpLineEdit;
     OptionCheckBox* m_pHistoryMergeSorting;
     OptionLineEdit* m_pHistorySortKeyOrderLineEdit;
 };
 
 
 class FontChooser : public QGroupBox
 {
    Q_OBJECT
    QFont m_font;
    QPushButton* m_pSelectFont;
    QPlainTextEdit* m_pExampleTextEdit;
    QLabel* m_pLabel;
 public:
    explicit FontChooser( QWidget* pParent );
    QFont font();
    void setFont( const QFont&, bool );
 private slots:
    void slotSelectFont();
 };
 
 #endif
 
 
 
 
 
 
 
diff --git a/src/selection.cpp b/src/selection.cpp
index 7f0cbb0..febaf81 100644
--- a/src/selection.cpp
+++ b/src/selection.cpp
@@ -1,107 +1,109 @@
 /***************************************************************************
  *   Copyright (C) 2003-2011 by Joachim Eibl                               *
  *   joachim.eibl at gmx.de                                                *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  ***************************************************************************/
 
 #include "selection.h"
-#include "gnudiff_diff.h"
+
+#include <limits.h>  // for INT_MAX
+#include <utility>   // for swap
 
 #include <QtGlobal>
 
 int Selection::firstPosInLine(LineRef l)
 {
     Q_ASSERT(firstLine != invalidRef);
 
     LineRef l1 = firstLine;
     LineRef l2 = lastLine;
     int p1 = firstPos;
     int p2 = lastPos;
     if(l1 > l2)
     {
         std::swap(l1, l2);
         std::swap(p1, p2);
     }
     if(l1 == l2 && p1 > p2)
     {
         std::swap(p1, p2);
     }
 
     if(l == l1)
         return p1;
     return 0;
 }
 
 int Selection::lastPosInLine(LineRef l)
 {
     Q_ASSERT(firstLine != invalidRef);
 
     LineRef l1 = firstLine;
     LineRef l2 = lastLine;
     int p1 = firstPos;
     int p2 = lastPos;
 
     if(l1 > l2)
     {
         std::swap(l1, l2);
         std::swap(p1, p2);
     }
     if(l1 == l2 && p1 > p2)
     {
         std::swap(p1, p2);
     }
 
     if(l == l2)
         return p2;
     return INT_MAX;
 }
 
 bool Selection::within(LineRef l, LineRef p)
 {
     if(firstLine == invalidRef)
         return false;
-    
+
     LineRef l1 = firstLine;
     LineRef l2 = lastLine;
     int p1 = firstPos;
     int p2 = lastPos;
     if(l1 > l2)
     {
         std::swap(l1, l2);
         std::swap(p1, p2);
     }
     if(l1 == l2 && p1 > p2)
     {
         std::swap(p1, p2);
     }
     if(l1 <= l && l <= l2)
     {
         if(l1 == l2)
             return p >= p1 && p < p2;
         if(l == l1)
             return p >= p1;
         if(l == l2)
             return p < p2;
         return true;
     }
     return false;
 }
 
 bool Selection::lineWithin(LineRef l)
 {
     if(firstLine == invalidRef)
         return false;
     LineRef l1 = firstLine;
     LineRef l2 = lastLine;
 
     if(l1 > l2)
     {
         std::swap(l1, l2);
     }
 
     return (l1 <= l && l <= l2);
 }
diff --git a/src/selection.h b/src/selection.h
index f19ff15..bdd127b 100644
--- a/src/selection.h
+++ b/src/selection.h
@@ -1,82 +1,83 @@
 /***************************************************************************
  *   Copyright (C) 2003-2011 by Joachim Eibl                               *
  *   joachim.eibl at gmx.de                                                *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  ***************************************************************************/
 #ifndef SELECTION_H
 #define SELECTION_H
 
-#include "gnudiff_diff.h"
-#include "common.h"
+#include "LineRef.h"
+
+#include <algorithm>  // for max, min
 
 class Selection
 {
 public:
   Selection(){}
 private:
   const LineRef invalidRef = -1;
   LineRef firstLine = invalidRef;
   LineRef lastLine = invalidRef;
 
   int firstPos = -1;
   int lastPos = -1;
-  
+
   LineRef oldFirstLine = invalidRef;
   LineRef oldLastLine = invalidRef;
 public:
 //private:
   bool bSelectionContainsData = false;
 public:
   inline LineRef getFirstLine() { return firstLine; };
   inline LineRef getLastLine() { return lastLine; };
 
   inline int getFirstPos() { return firstPos; };
   inline int getLastPos() { return lastPos; };
 
   inline bool isValidFirstLine() { return firstLine != invalidRef; }
   inline void clearOldSelection() { oldLastLine = invalidRef, oldFirstLine = invalidRef; };
-  
+
   inline LineRef getOldLastLine() { return oldLastLine; };
   inline LineRef getOldFirstLine() { return oldFirstLine; };
   inline bool selectionContainsData() { return bSelectionContainsData; };
   bool isEmpty() { return firstLine == invalidRef || (firstLine == lastLine && firstPos == lastPos) || !bSelectionContainsData; }
   void reset()
   {
       oldLastLine = lastLine;
       oldFirstLine = firstLine;
       firstLine = invalidRef;
       lastLine = invalidRef;
       bSelectionContainsData = false;
    }
    void start( LineRef l, int p ) { firstLine = l; firstPos = p; }
    void end( LineRef l, int p )  {
       if ( oldLastLine == invalidRef )
          oldLastLine = lastLine;
       lastLine  = l;
       lastPos  = p;
       //bSelectionContainsData = (firstLine == lastLine && firstPos == lastPos);
    }
    bool within( LineRef l, LineRef p );
 
    bool lineWithin( LineRef l );
    int firstPosInLine(LineRef l);
    int lastPosInLine(LineRef l);
-   LineRef beginLine(){ 
+   LineRef beginLine(){
       if (firstLine<0 && lastLine<0) return invalidRef;
-      return std::max((LineRef)0,std::min(firstLine,lastLine)); 
+      return std::max((LineRef)0,std::min(firstLine,lastLine));
    }
-   LineRef endLine(){ 
+   LineRef endLine(){
       if (firstLine<0 && lastLine<0) return invalidRef;
-      return std::max(firstLine,lastLine); 
+      return std::max(firstLine,lastLine);
    }
    int beginPos() { return firstLine==lastLine ? std::min(firstPos,lastPos) :
                            firstLine<lastLine ? (firstLine<0?0:firstPos) : (lastLine<0?0:lastPos);  }
    int endPos()   { return firstLine==lastLine ? std::max(firstPos,lastPos) :
                            firstLine<lastLine ? lastPos : firstPos;      }
 };
 
 #endif