diff --git a/src/LineRef.h b/src/LineRef.h
new file mode 100644
index 0000000..38586b0
--- /dev/null
+++ b/src/LineRef.h
@@ -0,0 +1,59 @@
+/**
+ *
+ * Copyright (C) 2018 Michael Reeves
+ *
+ * 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 LINEREF_H
+#define LINEREF_H
+
+#include <stdlib.h>
+#include <type_traits>
+
+class LineRef
+{
+    public:
+      typedef int LineType;
+
+      static_assert(sizeof(LineType) <= sizeof(size_t), "Unsupport configuration.");
+
+      LineRef() = default;
+      LineRef(const LineType i) { mLineNumber = i; }
+      operator LineType() const { return mLineNumber; }
+      inline void operator= (const LineType lineIn) { mLineNumber = lineIn; }
+      inline LineRef& operator+=(const LineType& inLine)
+      {
+          mLineNumber += inLine;
+          return *this;
+      };
+
+    private:
+        LineType mLineNumber = -1;
+};
+
+static_assert(std::is_copy_constructible<LineRef>::value, "");
+static_assert(std::is_copy_assignable<LineRef>::value, "");
+static_assert(std::is_move_constructible<LineRef>::value, "");
+static_assert(std::is_move_assignable<LineRef>::value, "");
+static_assert(std::is_convertible<LineRef, int>::value, "");
+static_assert(std::is_convertible<int, LineRef>::value, "");
+
+typedef LineRef::LineType LineCount;
+typedef size_t PtrDiffRef;
+typedef LineRef::LineType LineIndex;
+
+#endif
diff --git a/src/SourceData.cpp b/src/SourceData.cpp
index 9f01e79..11bbb63 100644
--- a/src/SourceData.cpp
+++ b/src/SourceData.cpp
@@ -1,937 +1,937 @@
 /***************************************************************************
  *   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.                                   *
  ***************************************************************************/
 
 /* Features of class SourceData:
 - Read a file (from the given URL) or accept data via a string.
 - Allocate and free buffers as necessary.
 - Run a preprocessor, when specified.
 - Run the line-matching preprocessor, when specified.
 - Run other preprocessing steps: Uppercase, ignore comments,
                                  remove carriage return, ignore numbers.
 
 Order of operation:
  1. If data was given via a string then save it to a temp file. (see setData())
  2. If the specified file is nonlocal (URL) copy it to a temp file.
  3. If a preprocessor was specified, run the input file through it.
  4. Read the output of the preprocessor.
  5. If Uppercase was specified: Turn the read data to uppercase.
  6. Write the result to a temp file.
  7. If a line-matching preprocessor was specified, run the temp file through it.
  8. Read the output of the line-matching preprocessor.
  9. If ignore numbers was specified, strip the LMPP-output of all numbers.
 10. If ignore comments was specified, strip the LMPP-output of comments.
 
 Optimizations: Skip unneeded steps.
 */
 #include "SourceData.h"
 
 #include "Utils.h"
 #include "diff.h"
 
 #include <QProcess>
 #include <QString>
 #include <QTemporaryFile>
 #include <QTextCodec>
 #include <QTextStream>
 #include <QVector>
 
 #include <KLocalizedString>
 
 SourceData::SourceData()
 {
     m_pOptions = nullptr;
     reset();
 }
 
 SourceData::~SourceData()
 {
     reset();
 }
 
 void SourceData::reset()
 {
     m_pEncoding = nullptr;
     m_fileAccess = FileAccess();
     m_normalData.reset();
     m_lmppData.reset();
     if(!m_tempInputFileName.isEmpty())
     {
         m_tempFile.remove();
         m_tempInputFileName = "";
     }
 }
 
 void SourceData::setFilename(const QString& filename)
 {
     if(filename.isEmpty())
     {
         reset();
     }
     else
     {
         FileAccess fa(filename);
         setFileAccess(fa);
     }
 }
 
 bool SourceData::isEmpty()
 {
     return getFilename().isEmpty();
 }
 
 bool SourceData::hasData()
 {
     return m_normalData.m_pBuf != nullptr;
 }
 
 bool SourceData::isValid()
 {
     return isEmpty() || hasData();
 }
 
 void SourceData::setOptions(Options* pOptions)
 {
     m_pOptions = pOptions;
 }
 
 QString SourceData::getFilename()
 {
     return m_fileAccess.absoluteFilePath();
 }
 
 QString SourceData::getAliasName()
 {
     return m_aliasName.isEmpty() ? m_fileAccess.prettyAbsPath() : m_aliasName;
 }
 
 void SourceData::setAliasName(const QString& name)
 {
     m_aliasName = name;
 }
 
 void SourceData::setFileAccess(const FileAccess& fileAccess)
 {
     m_fileAccess = fileAccess;
     m_aliasName = QString();
     if(!m_tempInputFileName.isEmpty())
     {
         m_tempFile.remove();
         m_tempInputFileName = "";
     }
 }
 void SourceData::setEncoding(QTextCodec* pEncoding)
 {
     m_pEncoding = pEncoding;
 }
 
 QStringList SourceData::setData(const QString& data)
 {
     QStringList errors;
 
     // Create a temp file for preprocessing:
     if(m_tempInputFileName.isEmpty())
     {
         FileAccess::createTempFile(m_tempFile);
         m_tempInputFileName = m_tempFile.fileName();
     }
 
     FileAccess f(m_tempInputFileName);
     QByteArray ba = QTextCodec::codecForName("UTF-8")->fromUnicode(data);
     bool bSuccess = f.writeFile(ba.constData(), ba.length());
     if(!bSuccess)
     {
         errors.append(i18n("Writing clipboard data to temp file failed."));
     }
     else
     {
         m_aliasName = i18n("From Clipboard");
         m_fileAccess = FileAccess(""); // Effect: m_fileAccess.isValid() is false
     }
 
     return errors;
 }
 
 const LineData* SourceData::getLineDataForDiff() const
 {
     if(m_lmppData.m_pBuf == nullptr)
         return m_normalData.m_v.size() > 0 ? &m_normalData.m_v[0] : nullptr;
     else
         return m_lmppData.m_v.size() > 0 ? &m_lmppData.m_v[0] : nullptr;
 }
 
 const LineData* SourceData::getLineDataForDisplay() const
 {
     return m_normalData.m_v.size() > 0 ? &m_normalData.m_v[0] : nullptr;
 }
 
 LineRef SourceData::getSizeLines() const
 {
-    return (LineRef)m_normalData.m_vSize;
+    return (LineRef::LineType)(m_normalData.m_vSize);
 }
 
 qint64 SourceData::getSizeBytes() const
 {
     return m_normalData.m_size;
 }
 
 const char* SourceData::getBuf() const
 {
     return m_normalData.m_pBuf;
 }
 
 const QString& SourceData::getText() const
 {
     return m_normalData.m_unicodeBuf;
 }
 
 bool SourceData::isText()
 {
     return m_normalData.isText();
 }
 
 bool SourceData::isIncompleteConversion()
 {
     return m_normalData.m_bIncompleteConversion;
 }
 
 bool SourceData::isFromBuffer()
 {
     return !m_fileAccess.isValid();
 }
 
 bool SourceData::isBinaryEqualWith(const SourceData& other) const
 {
     return m_fileAccess.exists() && other.m_fileAccess.exists() &&
            getSizeBytes() == other.getSizeBytes() &&
            (getSizeBytes() == 0 || memcmp(getBuf(), other.getBuf(), getSizeBytes()) == 0);
 }
 
 void SourceData::FileData::reset()
 {
     delete[](char*) m_pBuf;
     m_pBuf = nullptr;
     m_v.clear();
     m_size = 0;
     m_vSize = 0;
     m_bIsText = true;
     m_bIncompleteConversion = false;
     m_eLineEndStyle = eLineEndStyleUndefined;
 }
 
 bool SourceData::FileData::readFile(FileAccess& file)
 {
     reset();
     if(file.fileName().isEmpty()) {
         return true;
     }
 
     //FileAccess fa(filename);
 
     if(!file.isNormal())
         return true;
 
     m_size = file.sizeForReading();
     char* pBuf;
     m_pBuf = pBuf = new char[m_size + 100]; // Alloc 100 byte extra: Safety hack, not nice but does no harm.
                                             // Some extra bytes at the end of the buffer are needed by
                                             // the diff algorithm. See also GnuDiff::diff_2_files().
     bool bSuccess = file.readFile(pBuf, m_size);
     if(!bSuccess)
     {
         delete[] pBuf;
         m_pBuf = nullptr;
         m_size = 0;
     }
     return bSuccess;
 }
 
 bool SourceData::FileData::readFile(const QString& filename)
 {
     reset();
     if(filename.isEmpty()) {
         return true;
     }
 
     FileAccess fa(filename);
 
     if(!fa.isNormal())
         return true;
 
     m_size = fa.sizeForReading();
     char* pBuf;
     m_pBuf = pBuf = new char[m_size + 100]; // Alloc 100 byte extra: Safety hack, not nice but does no harm.
                                             // Some extra bytes at the end of the buffer are needed by
                                             // the diff algorithm. See also GnuDiff::diff_2_files().
     bool bSuccess = fa.readFile(pBuf, m_size);
     if(!bSuccess)
     {
         delete[] pBuf;
         m_pBuf = nullptr;
         m_size = 0;
     }
     return bSuccess;
 }
 
 bool SourceData::saveNormalDataAs(const QString& fileName)
 {
     return m_normalData.writeFile(fileName);
 }
 
 bool SourceData::FileData::writeFile(const QString& filename)
 {
     if(filename.isEmpty()) {
         return true;
     }
 
     FileAccess fa(filename);
     bool bSuccess = fa.writeFile(m_pBuf, m_size);
     return bSuccess;
 }
 
 void SourceData::FileData::copyBufFrom(const FileData& src)
 {
     reset();
     char* pBuf;
     m_size = src.m_size;
     m_pBuf = pBuf = new char[m_size + 100];
     Q_ASSERT(src.m_pBuf != nullptr);
     memcpy(pBuf, src.m_pBuf, m_size);
 }
 
 QTextCodec* SourceData::detectEncoding(const QString& fileName, QTextCodec* pFallbackCodec)
 {
     QFile f(fileName);
     if(f.open(QIODevice::ReadOnly))
     {
         char buf[200];
         qint64 size = f.read(buf, sizeof(buf));
         qint64 skipBytes = 0;
         QTextCodec* pCodec = detectEncoding(buf, size, skipBytes);
         if(pCodec)
             return pCodec;
     }
     return pFallbackCodec;
 }
 
 QStringList SourceData::readAndPreprocess(QTextCodec* pEncoding, bool bAutoDetectUnicode)
 {
     m_pEncoding = pEncoding;
     QTemporaryFile fileIn1, fileOut1;
     QString fileNameIn1;
     QString fileNameOut1;
     QString fileNameIn2;
     QString fileNameOut2;
     QStringList errors;
 
     if(m_fileAccess.isValid() && !m_fileAccess.isNormal())
     {
         errors.append(i18n("%1 is not a normal file.", m_fileAccess.prettyAbsPath()));
         return errors;
     }
 
     bool bTempFileFromClipboard = !m_fileAccess.isValid();
 
     // Detect the input for the preprocessing operations
     if(!bTempFileFromClipboard)
     {
         if(m_fileAccess.isLocal())
         {
             fileNameIn1 = m_fileAccess.absoluteFilePath();
         }
         else // File is not local: create a temporary local copy:
         {
             if(m_tempInputFileName.isEmpty())
             {
                 m_fileAccess.createLocalCopy();
                 m_tempInputFileName = m_fileAccess.getTempName();
             }
 
             fileNameIn1 = m_tempInputFileName;
         }
         if(bAutoDetectUnicode)
         {
             m_pEncoding = detectEncoding(fileNameIn1, pEncoding);
         }
     }
     else // The input was set via setData(), probably from clipboard.
     {
         fileNameIn1 = m_tempInputFileName;
         m_pEncoding = QTextCodec::codecForName("UTF-8");
     }
     QTextCodec* pEncoding1 = m_pEncoding;
     QTextCodec* pEncoding2 = m_pEncoding;
 
     m_normalData.reset();
     m_lmppData.reset();
 
     FileAccess faIn(fileNameIn1);
     qint64 fileInSize = faIn.size();
 
     if(faIn.exists())
     {
         // Run the first preprocessor
         if(m_pOptions->m_PreProcessorCmd.isEmpty())
         {
             // No preprocessing: Read the file directly:
             if(!m_normalData.readFile(faIn))
             {
                 errors.append(faIn.getStatusText());
                 return errors;
             }
         }
         else
         {
             QTemporaryFile tmpInPPFile;
             QString fileNameInPP = fileNameIn1;
 
             if(pEncoding1 != m_pOptions->m_pEncodingPP)
             {
                 // Before running the preprocessor convert to the format that the preprocessor expects.
                 FileAccess::createTempFile(tmpInPPFile);
                 fileNameInPP = tmpInPPFile.fileName();
                 pEncoding1 = m_pOptions->m_pEncodingPP;
                 convertFileEncoding(fileNameIn1, pEncoding, fileNameInPP, pEncoding1);
             }
 
             QString ppCmd = m_pOptions->m_PreProcessorCmd;
             FileAccess::createTempFile(fileOut1);
             fileNameOut1 = fileOut1.fileName();
 
             QProcess ppProcess;
             ppProcess.setStandardInputFile(fileNameInPP);
             ppProcess.setStandardOutputFile(fileNameOut1);
             QString program;
             QStringList args;
             QString errorReason = Utils::getArguments(ppCmd, program, args);
             if(errorReason.isEmpty())
             {
                 ppProcess.start(program, args);
                 ppProcess.waitForFinished(-1);
             }
             else
                 errorReason = "\n(" + errorReason + ')';
 
             bool bSuccess = errorReason.isEmpty() && m_normalData.readFile(fileNameOut1);
             if(fileInSize > 0 && (!bSuccess || m_normalData.m_size == 0))
             {
                 if(!m_normalData.readFile(faIn))
                 {
                     errors.append(faIn.getStatusText());
                     errors.append(i18n("    Temp file is: %1", fileNameIn1));
                     return errors;
                 }
                 //Don't fail the preprocessor command if the file cann't be read.
                 errors.append(
                     i18n("Preprocessing possibly failed. Check this command:\n\n  %1"
                          "\n\nThe preprocessing command will be disabled now.", ppCmd) +
                     errorReason);
                 m_pOptions->m_PreProcessorCmd = "";
 
                 pEncoding1 = m_pEncoding;
             }
         }
 
         if(!m_normalData.preprocess(m_pOptions->m_bPreserveCarriageReturn, pEncoding1))
         {
             errors.append(i18n("File %1 too large to process. Skipping.", fileNameIn1));
             return errors;
         }
         //exit early for non text data further processing assumes a text file as input
         if(!m_normalData.isText())
             return errors;
 
         // LineMatching Preprocessor
         if(!m_pOptions->m_LineMatchingPreProcessorCmd.isEmpty())
         {
             QTemporaryFile tempOut2, fileInPP;
             fileNameIn2 = fileNameOut1.isEmpty() ? fileNameIn1 : fileNameOut1;
             QString fileNameInPP = fileNameIn2;
             pEncoding2 = pEncoding1;
             if(pEncoding2 != m_pOptions->m_pEncodingPP)
             {
                 // Before running the preprocessor convert to the format that the preprocessor expects.
                 FileAccess::createTempFile(fileInPP);
                 fileNameInPP = fileInPP.fileName();
                 pEncoding2 = m_pOptions->m_pEncodingPP;
                 convertFileEncoding(fileNameIn2, pEncoding1, fileNameInPP, pEncoding2);
             }
 
             QString ppCmd = m_pOptions->m_LineMatchingPreProcessorCmd;
             FileAccess::createTempFile(tempOut2);
             fileNameOut2 = tempOut2.fileName();
             QProcess ppProcess;
             ppProcess.setStandardInputFile(fileNameInPP);
             ppProcess.setStandardOutputFile(fileNameOut2);
             QString program;
             QStringList args;
             QString errorReason = Utils::getArguments(ppCmd, program, args);
             if(errorReason.isEmpty())
             {
                 ppProcess.start(program, args);
                 ppProcess.waitForFinished(-1);
             }
             else
                 errorReason = "\n(" + errorReason + ')';
 
             bool bSuccess = errorReason.isEmpty() && m_lmppData.readFile(fileNameOut2);
             if(FileAccess(fileNameIn2).size() > 0 && (!bSuccess || m_lmppData.m_size == 0))
             {
                 errors.append(
                     i18n("The line-matching-preprocessing possibly failed. Check this command:\n\n  %1"
                          "\n\nThe line-matching-preprocessing command will be disabled now.", ppCmd) +
                     errorReason);
                 m_pOptions->m_LineMatchingPreProcessorCmd = "";
                 if(!m_lmppData.readFile(fileNameIn2))
                 {
                     errors.append(i18n("Failed to read file: %1", fileNameIn2));
                     return errors;
                 }
             }
         }
         else if(m_pOptions->m_bIgnoreComments || m_pOptions->m_bIgnoreCase)
         {
             // We need a copy of the normal data.
             m_lmppData.copyBufFrom(m_normalData);
         }
     }
 
     if(!m_lmppData.preprocess(false, pEncoding2))
     {
         errors.append(i18n("File %1 too large to process. Skipping.", fileNameIn1));
         return errors;
     }
 
     Q_ASSERT(m_lmppData.isText());
     //TODO: Needed?
     if(m_lmppData.m_vSize < m_normalData.m_vSize)
     {
         // Preprocessing command may result in smaller data buffer so adjust size
         m_lmppData.m_v.resize((int)m_normalData.m_vSize);
         for(qint64 i = m_lmppData.m_vSize; i < m_normalData.m_vSize; ++i)
         { // Set all empty lines to point to the end of the buffer.
             m_lmppData.m_v[(int)i].setLine(m_lmppData.m_unicodeBuf.unicode() + m_lmppData.m_unicodeBuf.length());
         }
 
         m_lmppData.m_vSize = m_normalData.m_vSize;
     }
 
     // Ignore comments
     if(m_pOptions->m_bIgnoreComments)
     {
         m_lmppData.removeComments();
         qint64 vSize = std::min(m_normalData.m_vSize, m_lmppData.m_vSize);
         Q_ASSERT(vSize < std::numeric_limits<int>::max());
         for(int i = 0; i < vSize; ++i)
         {
             m_normalData.m_v[i].setPureComment(m_lmppData.m_v[i].isPureComment());
             //Don't crash if vSize is too large.
             if(i == std::numeric_limits<int>::max())
                 break;
         }
     }
 
     return errors;
 }
 
 /** Prepare the linedata vector for every input line.*/
 bool SourceData::FileData::preprocess(bool bPreserveCR, QTextCodec* pEncoding)
 {
     qint64 i;
     // detect line end style
     QVector<e_LineEndStyle> vOrigDataLineEndStyle;
     m_eLineEndStyle = eLineEndStyleUndefined;
     for(i = 0; i < m_size; ++i)
     {
         if(m_pBuf[i] == '\r')
         {
             if(i + 1 < m_size && m_pBuf[i + 1] == '\n') // not 16-bit unicode
             {
                 vOrigDataLineEndStyle.push_back(eLineEndStyleDos);
                 ++i;
             }
             else if(i > 0 && i + 2 < m_size && m_pBuf[i - 1] == '\0' && m_pBuf[i + 1] == '\0' && m_pBuf[i + 2] == '\n') // 16-bit unicode
             {
                 vOrigDataLineEndStyle.push_back(eLineEndStyleDos);
                 i += 2;
             }
             else // old mac line end style ?
             {
                 vOrigDataLineEndStyle.push_back(eLineEndStyleUndefined);
                 const_cast<char*>(m_pBuf)[i] = '\n'; // fix it in original data
             }
         }
         else if(m_pBuf[i] == '\n')
         {
             vOrigDataLineEndStyle.push_back(eLineEndStyleUnix);
         }
     }
 
     if(!vOrigDataLineEndStyle.isEmpty())
         m_eLineEndStyle = vOrigDataLineEndStyle[0];
 
     qint64 skipBytes = 0;
     QTextCodec* pCodec = detectEncoding(m_pBuf, m_size, skipBytes);
     if(pCodec != pEncoding)
         skipBytes = 0;
 
     if(m_size - skipBytes > INT_MAX)
         return false;
 
     QByteArray ba = QByteArray::fromRawData(m_pBuf + skipBytes, (int)(m_size - skipBytes));
     QTextStream ts(ba, QIODevice::ReadOnly | QIODevice::Text);
     ts.setCodec(pEncoding);
     ts.setAutoDetectUnicode(false);
     m_unicodeBuf = ts.readAll();
     ba.clear();
 
     int ucSize = m_unicodeBuf.length();
     const QChar* p = m_unicodeBuf.unicode();
 
     m_bIsText = true;
     int lines = 1;
     m_bIncompleteConversion = false;
     for(i = 0; i < ucSize; ++i)
     {
         if(i >= ucSize || p[i] == '\n')
         {
             ++lines;
         }
         if(p[i].isNull())
         {
             m_bIsText = false;
         }
         if(p[i] == QChar::ReplacementCharacter)
         {
             m_bIncompleteConversion = true;
         }
     }
 
     m_v.resize(lines + 5);
     int lineIdx = 0;
     int lineLength = 0;
     bool bNonWhiteFound = false;
     int whiteLength = 0;
     for(i = 0; i <= ucSize; ++i)
     {
         if(i >= ucSize || p[i] == '\n')
         {
             const QChar* pLine = &p[i - lineLength];
             m_v[lineIdx].setLine(&p[i - lineLength]);
             while(/*!bPreserveCR  &&*/ lineLength > 0 && m_v[lineIdx].getLine()[lineLength - 1] == '\r')
             {
                 --lineLength;
             }
             m_v[lineIdx].setFirstNonWhiteChar(m_v[lineIdx].getLine() + std::min(whiteLength, lineLength));
             if(lineIdx < vOrigDataLineEndStyle.count() && bPreserveCR && i < ucSize)
             {
                 ++lineLength;
                 const_cast<QChar*>(pLine)[lineLength] = '\r';
                 //switch ( vOrigDataLineEndStyle[lineIdx] )
                 //{
                 //case eLineEndStyleUnix: const_cast<QChar*>(pLine)[lineLength] = '\n'; break;
                 //case eLineEndStyleDos:  const_cast<QChar*>(pLine)[lineLength] = '\r'; break;
                 //case eLineEndStyleUndefined: const_cast<QChar*>(pLine)[lineLength] = '\x0b'; break;
                 //}
             }
             m_v[lineIdx].setSize(lineLength);
 
             lineLength = 0;
             bNonWhiteFound = false;
             whiteLength = 0;
             ++lineIdx;
         }
         else
         {
             ++lineLength;
 
             if(!bNonWhiteFound && isWhite(p[i]))
                 ++whiteLength;
             else
                 bNonWhiteFound = true;
         }
     }
     Q_ASSERT(lineIdx == lines);
 
     m_vSize = lines;
     return true;
 }
 
 // Must not be entered, when within a comment.
 // Returns either at a newline-character p[i]=='\n' or when i==size.
 // A line that contains only comments is still "white".
 // Comments in white lines must remain, while comments in
 // non-white lines are overwritten with spaces.
 void SourceData::FileData::checkLineForComments(
     const QChar* p,          // pointer to start of buffer
     int& i,                  // index of current position (in, out)
     int size,                // size of buffer
     bool& bWhite,            // false if this line contains nonwhite characters (in, out)
     bool& bCommentInLine,    // true if any comment is within this line (in, out)
     bool& bStartsOpenComment // true if the line ends within an comment (out)
     )
 {
     bStartsOpenComment = false;
     for(; i < size; ++i)
     {
         // A single apostroph ' has prio over a double apostroph " (e.g. '"')
         // (if not in a string)
         if(p[i] == '\'')
         {
             bWhite = false;
             ++i;
             for(; !isLineOrBufEnd(p, i, size) && p[i] != '\''; ++i)
                 ;
             if(p[i] == '\'') ++i;
         }
 
         // Strings have priority over comments: e.g. "/* Not a comment, but a string. */"
         else if(p[i] == '"')
         {
             bWhite = false;
             ++i;
             for(; !isLineOrBufEnd(p, i, size) && !(p[i] == '"' && p[i - 1] != '\\'); ++i)
                 ;
             if(p[i] == '"') ++i;
         }
 
         // C++-comment
         else if(p[i] == '/' && i + 1 < size && p[i + 1] == '/')
         {
             int commentStart = i;
             bCommentInLine = true;
             i += 2;
             for(; !isLineOrBufEnd(p, i, size); ++i)
                 ;
             if(!bWhite)
             {
                 size = i - commentStart;
                 m_unicodeBuf.replace(commentStart, size, QString(" ").repeated(size));
             }
             return;
         }
 
         // C-comment
         else if(p[i] == '/' && i + 1 < size && p[i + 1] == '*')
         {
             int commentStart = i;
             bCommentInLine = true;
             i += 2;
             for(; !isLineOrBufEnd(p, i, size); ++i)
             {
                 if(i + 1 < size && p[i] == '*' && p[i + 1] == '/') // end of the comment
                 {
                     i += 2;
 
                     // More comments in the line?
                     checkLineForComments(p, i, size, bWhite, bCommentInLine, bStartsOpenComment);
                     if(!bWhite)
                     {
                         size = i - commentStart;
                         m_unicodeBuf.replace(commentStart, size, QString(" ").repeated(size));                    }
                     return;
                 }
             }
             bStartsOpenComment = true;
             return;
         }
 
         if(isLineOrBufEnd(p, i, size))
         {
             return;
         }
         else if(!p[i].isSpace())
         {
             bWhite = false;
         }
     }
 }
 
 // Modifies the input data, and replaces C/C++ comments with whitespace
 // when the line contains other data too. If the line contains only
 // a comment or white data, remember this in the flag bContainsPureComment.
 void SourceData::FileData::removeComments()
 {
     int line = 0;
     const QChar* p = m_unicodeBuf.unicode();
     bool bWithinComment = false;
     int size = m_unicodeBuf.length();
     for(int i = 0; i < size; ++i)
     {
         //      std::cout << "2        " << std::string(&p[i], m_v[line].size) << std::endl;
         bool bWhite = true;
         bool bCommentInLine = false;
 
         if(bWithinComment)
         {
             int commentStart = i;
             bCommentInLine = true;
 
             for(; !isLineOrBufEnd(p, i, size); ++i)
             {
                 if(i + 1 < size && p[i] == '*' && p[i + 1] == '/') // end of the comment
                 {
                     i += 2;
 
                     // More comments in the line?
                     checkLineForComments(p, i, size, bWhite, bCommentInLine, bWithinComment);
                     if(!bWhite)
                     {
                         size = i - commentStart;
                         m_unicodeBuf.replace(commentStart, size, QString(" ").repeated(size));
                     }
                     break;
                 }
             }
         }
         else
         {
             checkLineForComments(p, i, size, bWhite, bCommentInLine, bWithinComment);
         }
 
         // end of line
         Q_ASSERT(isLineOrBufEnd(p, i, size));
         m_v[line].setPureComment(bCommentInLine && bWhite);
         /*      std::cout << line << " : " <<
        ( bCommentInLine ?  "c" : " " ) <<
        ( bWhite ? "w " : "  ") <<
        std::string(pLD[line].pLine, pLD[line].size) << std::endl;*/
 
         ++line;
     }
 }
 
 bool SourceData::isLineOrBufEnd(const QChar* p, int i, int size)
 {
     return i >= size            // End of file
            || isEndOfLine(p[i]) // Normal end of line
 
         // No support for Mac-end of line yet, because incompatible with GNU-diff-routines.
         // || ( p[i]=='\r' && (i>=size-1 || p[i+1]!='\n')
         //                 && (i==0        || p[i-1]!='\n') )  // Special case: '\r' without '\n'
         ;
 }
 
 // Convert the input file from input encoding to output encoding and write it to the output file.
 bool SourceData::convertFileEncoding(const QString& fileNameIn, QTextCodec* pCodecIn,
                                 const QString& fileNameOut, QTextCodec* pCodecOut)
 {
     QFile in(fileNameIn);
     if(!in.open(QIODevice::ReadOnly))
         return false;
     QTextStream inStream(&in);
     inStream.setCodec(pCodecIn);
     inStream.setAutoDetectUnicode(false);
 
     QFile out(fileNameOut);
     if(!out.open(QIODevice::WriteOnly))
         return false;
     QTextStream outStream(&out);
     outStream.setCodec(pCodecOut);
 
     QString data = inStream.readAll();
     outStream << data;
 
     return true;
 }
 
 QTextCodec* SourceData::getEncodingFromTag(const QByteArray& s, const QByteArray& encodingTag)
 {
     int encodingPos = s.indexOf(encodingTag);
     if(encodingPos >= 0)
     {
         int apostrophPos = s.indexOf('"', encodingPos + encodingTag.length());
         int apostroph2Pos = s.indexOf('\'', encodingPos + encodingTag.length());
         char apostroph = '"';
         if(apostroph2Pos >= 0 && (apostrophPos < 0 || apostroph2Pos < apostrophPos))
         {
             apostroph = '\'';
             apostrophPos = apostroph2Pos;
         }
 
         int encodingEnd = s.indexOf(apostroph, apostrophPos + 1);
         if(encodingEnd >= 0) // e.g.: <meta charset="utf-8"> or <?xml version="1.0" encoding="ISO-8859-1"?>
         {
             QByteArray encoding = s.mid(apostrophPos + 1, encodingEnd - (apostrophPos + 1));
             return QTextCodec::codecForName(encoding);
         }
         else // e.g.: <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
         {
             QByteArray encoding = s.mid(encodingPos + encodingTag.length(), apostrophPos - (encodingPos + encodingTag.length()));
             return QTextCodec::codecForName(encoding);
         }
     }
     return nullptr;
 }
 
 QTextCodec* SourceData::detectEncoding(const char* buf, qint64 size, qint64& skipBytes)
 {
     if(size >= 2)
     {
         if(buf[0] == '\xFF' && buf[1] == '\xFE')
         {
             skipBytes = 2;
             return QTextCodec::codecForName("UTF-16LE");
         }
 
         if(buf[0] == '\xFE' && buf[1] == '\xFF')
         {
             skipBytes = 2;
             return QTextCodec::codecForName("UTF-16BE");
         }
     }
     if(size >= 3)
     {
         if(buf[0] == '\xEF' && buf[1] == '\xBB' && buf[2] == '\xBF')
         {
             skipBytes = 3;
             return QTextCodec::codecForName("UTF-8-BOM");
         }
     }
     skipBytes = 0;
     QByteArray s;
     /*
         We don't need the whole file here just the header.
 ]    */
     if(size <= 5000)
         s=QByteArray(buf, (int)size);
     else
         s=QByteArray(buf, 5000);
 
     int xmlHeaderPos = s.indexOf("<?xml");
     if(xmlHeaderPos >= 0)
     {
         int xmlHeaderEnd = s.indexOf("?>", xmlHeaderPos);
         if(xmlHeaderEnd >= 0)
         {
             QTextCodec* pCodec = getEncodingFromTag(s.mid(xmlHeaderPos, xmlHeaderEnd - xmlHeaderPos), "encoding=");
             if(pCodec)
                 return pCodec;
         }
     }
     else // HTML
     {
         int metaHeaderPos = s.indexOf("<meta");
         while(metaHeaderPos >= 0)
         {
             int metaHeaderEnd = s.indexOf(">", metaHeaderPos);
             if(metaHeaderEnd >= 0)
             {
                 QTextCodec* pCodec = getEncodingFromTag(s.mid(metaHeaderPos, metaHeaderEnd - metaHeaderPos), "charset=");
                 if(pCodec)
                     return pCodec;
 
                 metaHeaderPos = s.indexOf("<meta", metaHeaderEnd);
             }
             else
                 break;
         }
     }
     return nullptr;
 }
diff --git a/src/diff.cpp b/src/diff.cpp
index b2f572d..0481a0a 100644
--- a/src/diff.cpp
+++ b/src/diff.cpp
@@ -1,1461 +1,1461 @@
 /***************************************************************************
  *   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 <qglobal.h>
 #include <KLocalizedString>
 #include <KMessageBox>
 
 int LineData::width(int tabSize) const
 {
     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
     const QChar* p1 = l1.getLine();
     const QChar* p1End = p1 + l1.size();
 
     const QChar* p2 = l2.getLine();
     const QChar* p2End = p2 + l2.size();
 
     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() && memcmp(p1, p2, l1.size()) == 0);
     }
 }
 
 // First step
 void calcDiff3LineListUsingAB(
     const DiffList* pDiffListAB,
     Diff3LineList& d3ll)
 {
     // First make d3ll for AB (from pDiffListAB)
 
     DiffList::const_iterator i = pDiffListAB->begin();
     int lineA = 0;
     int lineB = 0;
     Diff d(0, 0, 0);
 
     for(;;)
     {
         if(d.nofEquals == 0 && d.diff1 == 0 && d.diff2 == 0)
         {
             if(i != pDiffListAB->end())
             {
                 d = *i;
                 ++i;
             }
             else
                 break;
         }
 
         Diff3Line d3l;
         if(d.nofEquals > 0)
         {
             d3l.bAEqB = true;
             d3l.setLineA(lineA);
             d3l.setLineB(lineB);
             --d.nofEquals;
             ++lineA;
             ++lineB;
         }
         else if(d.diff1 > 0 && d.diff2 > 0)
         {
             d3l.setLineA(lineA);
             d3l.setLineB(lineB);
             --d.diff1;
             --d.diff2;
             ++lineA;
             ++lineB;
         }
         else if(d.diff1 > 0)
         {
             d3l.setLineA(lineA);
             --d.diff1;
             ++lineA;
         }
         else if(d.diff2 > 0)
         {
             d3l.setLineB(lineB);
             --d.diff2;
             ++lineB;
         }
 
         Q_ASSERT(d.nofEquals >= 0);
 
         d3ll.push_back(d3l);
     }
 }
 
 // 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();
     int lineA = 0;
     int lineC = 0;
     Diff d(0, 0, 0);
 
     for(;;)
     {
         if(d.nofEquals == 0 && d.diff1 == 0 && d.diff2 == 0)
         {
             if(i != pDiffListAC->end())
             {
                 d = *i;
                 ++i;
             }
             else
                 break;
         }
 
         Diff3Line d3l;
         if(d.nofEquals > 0)
         {
             // Find the corresponding lineA
             while((*i3).getLineA() != lineA)
                 ++i3;
 
             (*i3).setLineC(lineC);
             (*i3).bAEqC = true;
             (*i3).bBEqC = (*i3).isEqualAB();
 
             --d.nofEquals;
             ++lineA;
             ++lineC;
             ++i3;
         }
         else if(d.diff1 > 0 && d.diff2 > 0)
         {
             d3l.setLineC(lineC);
             d3ll.insert(i3, d3l);
             --d.diff1;
             --d.diff2;
             ++lineA;
             ++lineC;
         }
         else if(d.diff1 > 0)
         {
             --d.diff1;
             ++lineA;
         }
         else if(d.diff2 > 0)
         {
             d3l.setLineC(lineC);
             d3ll.insert(i3, d3l);
             --d.diff2;
             ++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();
     int lineB = 0;
     int lineC = 0;
     Diff d(0, 0, 0);
 
     for(;;)
     {
         if(d.nofEquals == 0 && d.diff1 == 0 && d.diff2 == 0)
         {
             if(i != pDiffListBC->end())
             {
                 d = *i;
                 ++i;
             }
             else
                 break;
         }
 
         Diff3Line d3l;
         if(d.nofEquals > 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() != -1)
                             ++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() != -1 ||
                                (before_or_on_equal_line_in_A && i3->getLineA() != -1))
                             {
                                 d3l.setLineB((*i3).getLineB());
                                 (*i3).setLineB(-1);
 
                                 // Move A along if it matched B
                                 if(before_or_on_equal_line_in_A)
                                 {
                                     d3l.setLineA(i3->getLineA());
                                     d3l.bAEqB = i3->isEqualAB();
                                     i3->setLineA(-1);
                                     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).setLineB(-1); // 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() != -1)
                             ++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() != -1 ||
                                (before_or_on_equal_line_in_A && i3->getLineA() != -1))
                             {
                                 d3l.setLineC((*i3).getLineC());
                                 (*i3).setLineC(-1);
 
                                 // Move A along if it matched C
                                 if(before_or_on_equal_line_in_A)
                                 {
                                     d3l.setLineA(i3->getLineA());
                                     d3l.bAEqC = i3->isEqualAC();
                                     i3->setLineA(-1);
                                     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).setLineC(-1); // 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.nofEquals;
             ++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).setLineB(-1);
             }
             else
             {
                 i3b = i3;
             }
             --d.diff1;
             ++lineB;
             ++i3b;
 
             if(d.diff2 > 0)
             {
                 --d.diff2;
                 ++lineC;
             }
         }
         else if(d.diff2 > 0)
         {
             --d.diff2;
             ++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 LineData* p1, LineRef size1, const LineData* p2, LineRef size2, DiffList& diffList,
                     Options* pOptions)
 {
     ProgressProxy pp;
     static GnuDiff gnuDiff; // All values are initialized with zeros.
 
     pp.setCurrent(0);
 
     diffList.clear();
     if(p1 == nullptr || p1[0].getLine() == nullptr || p2 == nullptr || p2[0].getLine() == nullptr || size1 == 0 || size2 == 0)
     {
         Diff d(0, 0, 0);
         if(p1 != nullptr && p2 != nullptr && p1[0].getLine() == nullptr && p2[0].getLine() == nullptr && size1 == size2)
             d.nofEquals = size1;
         else
         {
             d.diff1 = size1;
             d.diff2 = size2;
         }
 
         diffList.push_back(d);
     }
     else
     {
         GnuDiff::comparison comparisonInput;
         memset(&comparisonInput, 0, sizeof(comparisonInput));
         comparisonInput.parent = nullptr;
         comparisonInput.file[0].buffer = p1[0].getLine();                                                //ptr to buffer
         comparisonInput.file[0].buffered = (p1[size1 - 1].getLine() - p1[0].getLine() + p1[size1 - 1].size()); // size of buffer
         comparisonInput.file[1].buffer = p2[0].getLine();                                                //ptr to buffer
         comparisonInput.file[1].buffered = (p2[size2 - 1].getLine() - p2[0].getLine() + p2[size2 - 1].size()); // 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 equalLinesAtStart = (LineRef::LineType)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(0, 0, 0);
-            d.nofEquals = (LineRef)(e->line0 - currentLine1);
+            d.nofEquals = (LineRef::LineType)(e->line0 - currentLine1);
             Q_ASSERT(d.nofEquals == e->line1 - currentLine2);
             d.diff1 = e->deleted;
             d.diff2 = e->inserted;
-            currentLine1 += d.nofEquals + d.diff1;
-            currentLine2 += d.nofEquals + d.diff2;
+            currentLine1 += (LineRef::LineType)(d.nofEquals + d.diff1);
+            currentLine2 += (LineRef::LineType)(d.nofEquals + d.diff2);
             diffList.push_back(d);
 
             p = e->link;
             free(e);
         }
 
         if(diffList.empty())
         {
             Diff d(0, 0, 0);
             d.nofEquals = std::min(size1, size2);
             d.diff1 = size1 - d.nofEquals;
             d.diff2 = size2 - d.nofEquals;
             diffList.push_back(d);
         }
         else
         {
             diffList.front().nofEquals += equalLinesAtStart;
             currentLine1 += equalLinesAtStart;
             currentLine2 += equalLinesAtStart;
 
             LineRef nofEquals = std::min(size1 - currentLine1, size2 - currentLine2);
             if(nofEquals == 0)
             {
                 diffList.back().diff1 += size1 - currentLine1;
                 diffList.back().diff2 += size2 - currentLine2;
             }
             else
             {
                 Diff d(nofEquals, size1 - currentLine1 - nofEquals, size2 - currentLine2 - nofEquals);
                 diffList.push_back(d);
             }
         }
     }
 
     // Verify difflist
     {
-        LineRef l1 = 0;
-        LineRef l2 = 0;
+        LineRef::LineType l1 = 0;
+        LineRef::LineType l2 = 0;
         DiffList::iterator i;
         for(i = diffList.begin(); i != diffList.end(); ++i)
         {
             l1 += i->nofEquals + i->diff1;
             l2 += i->nofEquals + i->diff2;
         }
 
         Q_ASSERT(l1 == size1 && l2 == size2);
     }
 
     pp.setCurrent(1);
 
     return true;
 }
 
 bool ManualDiffHelpList::runDiff(const LineData* p1, LineRef size1, const LineData* p2, LineRef size2, DiffList& diffList,
              e_SrcSelector winIdx1, e_SrcSelector winIdx2,
              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->setLineB(-1);
                         i3->setLineC(-1);
                     }
                     if(wi == B) // Move A and C up
                     {
                         d3l.bAEqC = i3->isEqualAC();
                         d3l.setLineA(i3->getLineA());
                         d3l.setLineC(i3->getLineC());
                         i3->setLineA(-1);
                         i3->setLineC(-1);
                     }
                     if(wi == C) // Move A and B up
                     {
                         d3l.bAEqB = i3->isEqualAB();
                         d3l.setLineA(i3->getLineA());
                         d3l.setLineB(i3->getLineB());
                         i3->setLineA(-1);
                         i3->setLineB(-1);
                     }
                     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->setLineA(-1);
                             i3->bAEqB = false;
                             i3->bAEqC = false;
                         }
                         else if(wi2 == B)
                         {
                             iDest->setLineB(i3->getLineB());
                             i3->setLineB(-1);
                             i3->bAEqB = false;
                             i3->bBEqC = false;
                         }
                         else if(wi2 == C)
                         {
                             iDest->setLineC(i3->getLineC());
                             i3->setLineC(-1);
                             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->setLineA(-1);
                                     i3->bAEqB = false;
                                     i3->bAEqC = false;
                                 }
                                 if(wi3 == B)
                                 {
                                     if(i3->isEqualAB())
                                         break;
                                     d3l.setLineB(i3->getLineB());
                                     i3->setLineB(-1);
                                     i3->bAEqB = false;
                                     i3->bBEqC = false;
                                 }
                                 if(wi3 == C)
                                 {
                                     if(i3->isEqualAC())
                                         break;
                                     d3l.setLineC(i3->getLineC());
                                     i3->setLineC(-1);
                                     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 LineData* pldA, const LineData* pldB, const 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() >= 0 && i3->getLineA() == iMDHL->getLine1(A)) ||
                (i3->getLineB() >= 0 && i3->getLineB() == iMDHL->getLine1(B)) ||
                (i3->getLineC() >= 0 && i3->getLineC() == iMDHL->getLine1(C)))
             {
                 i3A = i3;
                 i3B = i3;
                 i3C = i3;
                 lineA = line;
                 lineB = line;
                 lineC = line;
                 ++iMDHL;
             }
         }
 
         if(line > lineA && (*i3).getLineA() != -1 && (*i3A).getLineB() != -1 && (*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).setLineA(-1);
             (*i3).bAEqB = false;
             (*i3).bAEqC = false;
             ++i3A;
             ++lineA;
         }
 
         if(line > lineB && (*i3).getLineB() != -1 && (*i3B).getLineA() != -1 && (*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).setLineB(-1);
             (*i3).bAEqB = false;
             (*i3).bBEqC = false;
             ++i3B;
             ++lineB;
         }
 
         if(line > lineC && (*i3).getLineC() != -1 && (*i3C).getLineA() != -1 && (*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).setLineC(-1);
             (*i3).bAEqC = false;
             (*i3).bBEqC = false;
             ++i3C;
             ++lineC;
         }
 
         if(line > lineA && (*i3).getLineA() != -1 && !(*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).setLineA(-1);
 
             if(i3A->getLineB() != -1 && LineData::equal(pldA[i3A->getLineA()], pldB[i3A->getLineB()], false))
             {
                 i3A->bAEqB = true;
             }
             if((i3A->isEqualAB() && i3A->isEqualBC()) ||
                (i3A->getLineC() != -1 && LineData::equal(pldA[i3A->getLineA()], pldC[i3A->getLineC()], false)))
             {
                 i3A->bAEqC = true;
             }
 
             ++i3A;
             ++lineA;
         }
 
         if(line > lineB && (*i3).getLineB() != -1 && !(*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).setLineB(-1);
 
             if(i3B->getLineA() != -1 && LineData::equal(pldA[i3B->getLineA()], pldB[i3B->getLineB()], false))
             {
                 i3B->bAEqB = true;
             }
             if((i3B->isEqualAB() && i3B->isEqualAC()) ||
                (i3B->getLineC() != -1 && LineData::equal(pldB[i3B->getLineB()], pldC[i3B->getLineC()], false)))
             {
                 i3B->bBEqC = true;
             }
 
             ++i3B;
             ++lineB;
         }
 
         if(line > lineC && (*i3).getLineC() != -1 && !(*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).setLineC(-1);
 
             if(i3C->getLineA() != -1 && LineData::equal(pldA[i3C->getLineA()], pldC[i3C->getLineC()], false))
             {
                 i3C->bAEqC = true;
             }
             if((i3C->isEqualAC() && i3C->isEqualAB()) ||
                (i3C->getLineB() != -1 && LineData::equal(pldB[i3C->getLineB()], pldC[i3C->getLineC()], false)))
             {
                 i3C->bBEqC = true;
             }
 
             ++i3C;
             ++lineC;
         }
 
         if(line > lineA && line > lineB && (*i3).getLineA() != -1 && (*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() != -1 && LineData::equal(pldA[i->getLineA()], pldC[i->getLineC()], false))
                 {
                     (*i).bAEqC = true;
                     (*i).bBEqC = true;
                 }
 
                 (*i3).setLineA(-1);
                 (*i3).setLineB(-1);
                 (*i3).bAEqB = false;
                 i3A = i;
                 i3B = i;
                 ++i3A;
                 ++i3B;
                 lineA = l + 1;
                 lineB = l + 1;
             }
         }
         else if(line > lineA && line > lineC && (*i3).getLineA() != -1 && (*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() != -1 && LineData::equal(pldA[i->getLineA()], pldB[i->getLineB()], false))
                 {
                     (*i).bAEqB = true;
                     (*i).bBEqC = true;
                 }
 
                 (*i3).setLineA(-1);
                 (*i3).setLineC(-1);
                 (*i3).bAEqC = false;
                 i3A = i;
                 i3C = i;
                 ++i3A;
                 ++i3C;
                 lineA = l + 1;
                 lineC = l + 1;
             }
         }
         else if(line > lineB && line > lineC && (*i3).getLineB() != -1 && (*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() != -1 && LineData::equal(pldA[i->getLineA()], pldB[i->getLineB()], false))
                 {
                     (*i).bAEqB = true;
                     (*i).bAEqC = true;
                 }
 
                 (*i3).setLineB(-1);
                 (*i3).setLineC(-1);
                 (*i3).bBEqC = false;
                 i3B = i;
                 i3C = i;
                 ++i3B;
                 ++i3C;
                 lineB = l + 1;
                 lineC = l + 1;
             }
         }
 
         if((*i3).getLineA() != -1)
         {
             lineA = line + 1;
             i3A = i3;
             ++i3A;
         }
         if((*i3).getLineB() != -1)
         {
             lineB = line + 1;
             i3B = i3;
             ++i3B;
         }
         if((*i3).getLineC() != -1)
         {
             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 LineData* pldA, LineCount sizeA, const LineData* pldB, LineCount sizeB, const 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 LineData* pldA, const LineData* pldB, const LineData* pldC)
 {
     Diff3LineList::iterator i3;
 
     for(i3=begin(); i3 != end(); ++i3)
     {
         i3->bWhiteLineA = ((*i3).getLineA() == -1 || pldA == nullptr || pldA[(*i3).getLineA()].whiteLine() || pldA[(*i3).getLineA()].isPureComment());
         i3->bWhiteLineB = ((*i3).getLineB() == -1 || pldB == nullptr || pldB[(*i3).getLineB()].whiteLine() || pldB[(*i3).getLineB()].isPureComment());
         i3->bWhiteLineC = ((*i3).getLineC() == -1 || pldC == nullptr || pldC[(*i3).getLineC()].whiteLine() || pldC[(*i3).getLineC()].isPureComment());
     }
 }
 
 // My own diff-invention:
 void calcDiff(const QChar* p1, LineRef size1, const QChar* p2, LineRef size2, DiffList& diffList, int match, int maxSearchRange)
 {
     diffList.clear();
 
     const QChar* p1start = p1;
     const QChar* p2start = p2;
     const QChar* p1end = p1 + size1;
     const QChar* p2end = p2 + size2;
     for(;;)
     {
         int nofEquals = 0;
         while(p1 != p1end && p2 != p2end && *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] == p1end || (bBestValid && i1 >= bestI1 + bestI2))
             {
                 break;
             }
             for(i2 = 0; i2 < maxSearchRange; ++i2)
             {
                 if(&p2[i2] == p2end || (bBestValid && i1 + i2 >= bestI1 + bestI2))
                 {
                     break;
                 }
                 else if(p2[i2] == p1[i1] &&
                         (match == 1 || abs(i1 - i2) < 3 || (&p2[i2 + 1] == p2end && &p1[i1 + 1] == p1end) ||
                          (&p2[i2 + 1] != p2end && &p1[i1 + 1] != p1end && 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);
             diffList.push_back(d);
 
             p1 += bestI1;
             p2 += bestI2;
         }
         else
         {
             // Nothing else to match.
             Diff d(nofEquals, p1end - p1, p2end - 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;
         const QChar* pu1 = p1 - 1;
         const QChar* pu2 = p2 - 1;
         while(pu1 >= p1start && pu2 >= p2start && *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.diff1;
                     --d.diff2;
                     --nofUnmatched;
                 }
                 else if(d.nofEquals > 0)
                 {
                     --d.nofEquals;
                     --nofUnmatched;
                 }
 
                 if(d.nofEquals == 0 && (d.diff1 == 0 || d.diff2 == 0) && nofUnmatched > 0)
                 {
                     if(diffList.empty())
                         break;
                     d.nofEquals += diffList.back().nofEquals;
                     d.diff1 += diffList.back().diff1;
                     d.diff2 += 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;
     }
 
     // Verify difflist
     {
         LineRef l1 = 0;
         LineRef l2 = 0;
         DiffList::iterator i;
         for(i = diffList.begin(); i != diffList.end(); ++i)
         {
-            l1 += i->nofEquals + i->diff1;
-            l2 += i->nofEquals + i->diff2;
+            l1 += (LineRef::LineType)(i->nofEquals + i->diff1);
+            l2 += (LineRef::LineType)(i->nofEquals + i->diff2);
         }
 
         Q_ASSERT(l1 == size1 && l2 == size2);
     }
 }
 
 bool Diff3Line::fineDiff(bool inBTextsTotalEqual, const e_SrcSelector selector, const LineData* v1, const 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();
     }
 
     if((k1 == -1 && k2 != -1) || (k1 != -1 && k2 == -1)) bTextsTotalEqual = false;
     if(k1 != -1 && k2 != -1)
     {
         if(v1[k1].size() != v2[k2].size() || memcmp(v1[k1].getLine(), v2[k2].getLine(), v1[k1].size() << 1) != 0)
         {
             bTextsTotalEqual = false;
             DiffList* pDiffList = new DiffList;
             calcDiff(v1[k1].getLine(), v1[k1].size(), v2[k2].getLine(), v2[k2].size(), *pDiffList, 2, maxSearchLength);
 
             // Optimize the diff list.
             DiffList::iterator dli;
             bool bUsefulFineDiff = false;
             for(dli = pDiffList->begin(); dli != pDiffList->end(); ++dli)
             {
                 if(dli->nofEquals >= 4)
                 {
                     bUsefulFineDiff = true;
                     break;
                 }
             }
 
             for(dli = pDiffList->begin(); dli != pDiffList->end(); ++dli)
             {
                 if(dli->nofEquals < 4 && (dli->diff1 > 0 || dli->diff2 > 0) && !(bUsefulFineDiff && dli == pDiffList->begin()))
                 {
                     dli->diff1 += dli->nofEquals;
                     dli->diff2 += dli->nofEquals;
                     dli->nofEquals = 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() == -1) != (lineIdx == -1) ? 1 : 0) +
                    ((getLineC() == -1) != (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() == -1) != (lineIdx == -1) && isTriple ? 1 : 0) +
                    ((getLineA() == -1) != (lineIdx == -1) ? 2 : 0);
         changed2 |= (bBEqualC || !isTriple ? 0 : 1) + (bAEqualB ? 0 : 2);
     }
     else if(winIdx == C)
     {
         lineIdx = getLineC();
         pFineDiff1 = pFineCA;
         pFineDiff2 = pFineBC;
         changed |= ((getLineA() == -1) != (lineIdx == -1) ? 1 : 0) +
                    ((getLineB() == -1) != (lineIdx == -1) ? 2 : 0);
         changed2 |= (bAEqualC ? 0 : 1) + (bBEqualC ? 0 : 2);
     }
 }
 
 bool Diff3LineList::fineDiff(const e_SrcSelector selector, const LineData* v1, const 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 == (int)d3lv.size());
 }
diff --git a/src/difftextwindow.cpp b/src/difftextwindow.cpp
index d212cb9..36afae1 100644
--- a/src/difftextwindow.cpp
+++ b/src/difftextwindow.cpp
@@ -1,2022 +1,2022 @@
 /***************************************************************************
  *   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 "selection.h"
 #include "kdiff3.h"
 #include "merger.h"
 #include "options.h"
 #include "FileNameLineEdit.h"
 #include "RLPainter.h"
 
 #include <algorithm>
 #include <cmath>
 #include <cstdlib>
 
 #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 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;
 
     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,
     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 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 = fontMetrics().width('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(line, d->m_diff3WrapLineVector.size() - 1)].diff3LineIndex;
+        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 = fontMetrics().width('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 = fm.width('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;
 
   public:
     QVector<QTextLayout::FormatRange> 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 = m_pDiffTextWindow->fontMetrics().width('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 = fm.width('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(), pld->size());
         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.m_formatRanges /*, 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(), fontMetrics().width('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 QString(ld->getLine(), ld->size());
     }
     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() / fm.width('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() * fm.width('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 == 1) {
             lineIdx = d3l->getLineA();
         }
         else if(d->m_winIdx == 2)
         {
             lineIdx = d3l->getLineB();
         }
         else if(d->m_winIdx == 3)
         {
             lineIdx = d3l->getLineC();
         }
 
         if(lineIdx != -1)
         {
             const QChar* pLine = d->m_pLineData[lineIdx].getLine();
             int size = d->m_pLineData[lineIdx].size();
             QString lineString = QString(pLine, size);
 
             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)];
         int line = -1;
         if(d->m_winIdx == 1) line = d3l->getLineA();
         if(d->m_winIdx == 2) line = d3l->getLineB();
         if(d->m_winIdx == 3) line = d3l->getLineC();
         if(line >= 0)
             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() * fontMetrics().width('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;
     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, 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 == 1 ? (pDTW->d->m_bTriple ? i18n("A (Base)") : i18n("A")) : (pDTW->d->m_winIdx == 2 ? 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 = d->m_pTopLine->fontMetrics().width(
             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, 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/gnudiff_diff.h b/src/gnudiff_diff.h
index 56ed655..3fd000e 100644
--- a/src/gnudiff_diff.h
+++ b/src/gnudiff_diff.h
@@ -1,383 +1,384 @@
 /* Shared definitions for GNU DIFF
 
    Modified for KDiff3 by Joachim Eibl <joachim.eibl at gmx.de> 2003, 2004, 2005.
    The original file was part of GNU DIFF.
 
    Copyright (C) 1988, 1989, 1991, 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.  */
 
 #ifndef GNUDIFF_DIFF_H
 #define GNUDIFF_DIFF_H
 
 
 #include <stdint.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 
 #include <stdlib.h>
 #include <limits.h>
 #include <string.h>
 #include <ctype.h>
 #include <type_traits>
 
 #include <stdio.h>
 
 #include <QtGlobal>
 #include <QString>
 
+#include "LineRef.h"
 /* The integer type of a line number. */
-typedef qint32 LineRef;
-typedef qint32 LineCount;
+//typedef qint32 LineRef;
+//typedef qint32 LineCount;
 typedef qint64 GNULineRef;
 typedef qint32 LineIndex;
 
 #define LINEREF_MAX std::numeric_limits<LineRef>::max()
 #define GNULINEREF_MAX std::numeric_limits<GNULineRef>::max()
 static_assert(sizeof(int) >= sizeof(qint32), "Legacy LP32 systems/compilers not supported");// e.g. Windows 16-bit
 static_assert(std::is_signed<GNULineRef>::value, "GNULineRef must be signed.");
 static_assert(sizeof(GNULineRef) >= sizeof(size_t),"GNULineRef must be able to recieve size_t values.");
 
 inline bool isEndOfLine( QChar c )
 {
    return c=='\n' || c=='\r' || c=='\x0b';
 }
 
 #define TAB_WIDTH 8
 
 class GnuDiff
 {
 public:
 /* What kind of changes a hunk contains.  */
 enum changes
 {
   /* No changes: lines common to both files.  */
   UNCHANGED,
 
   /* Deletes only: lines taken from just the first file.  */
   OLD,
 
   /* Inserts only: lines taken from just the second file.  */
   NEW,
 
   /* Both deletes and inserts: a hunk containing both old and new lines.  */
   CHANGED
 };
 
 /* Variables for command line options */
 
 /* Nonzero if output cannot be generated for identical files.  */
 bool no_diff_means_no_output;
 
 /* Number of lines of context to show in each set of diffs.
    This is zero when context is not to be shown.  */
 GNULineRef context;
 
 /* Consider all files as text files (-a).
    Don't interpret codes over 0177 as implying a "binary file".  */
 bool text;
 
 /* The significance of white space during comparisons.  */
 enum
 {
   /* All white space is significant (the default).  */
   IGNORE_NO_WHITE_SPACE,
 
   /* Ignore changes due to tab expansion (-E).  */
   IGNORE_TAB_EXPANSION,
 
   /* Ignore changes in horizontal white space (-b).  */
   IGNORE_SPACE_CHANGE,
 
   /* Ignore all horizontal white space (-w).  */
   IGNORE_ALL_SPACE
 } ignore_white_space;
 
 /* Ignore changes that affect only blank lines (-B).  */
 bool ignore_blank_lines;
 
 /* Ignore changes that affect only numbers. (J. Eibl)  */
 bool bIgnoreNumbers;
 bool bIgnoreWhiteSpace;
 
 /* Files can be compared byte-by-byte, as if they were binary.
    This depends on various options.  */
 bool files_can_be_treated_as_binary;
 
 /* Ignore differences in case of letters (-i).  */
 bool ignore_case;
 
 /* Ignore differences in case of letters in file names.  */
 bool ignore_file_name_case;
 
 /* Regexp to identify function-header lines (-F).  */
 //struct re_pattern_buffer function_regexp;
 
 /* Ignore changes that affect only lines matching this regexp (-I).  */
 //struct re_pattern_buffer ignore_regexp;
 
 /* Say only whether files differ, not how (-q).  */
 bool brief;
 
 /* Expand tabs in the output so the text lines up properly
    despite the characters added to the front of each line (-t).  */
 bool expand_tabs;
 
 /* Use a tab in the output, rather than a space, before the text of an
    input line, so as to keep the proper alignment in the input line
    without changing the characters in it (-T).  */
 bool initial_tab;
 
 /* In directory comparison, specify file to start with (-S).
    This is used for resuming an aborted comparison.
    All file names less than this name are ignored.  */
 const QChar *starting_file;
 
 /* Pipe each file's output through pr (-l).  */
 bool paginate;
 
 /* Line group formats for unchanged, old, new, and changed groups.  */
 const QChar *group_format[CHANGED + 1];
 
 /* Line formats for unchanged, old, and new lines.  */
 const QChar *line_format[NEW + 1];
 
 /* If using OUTPUT_SDIFF print extra information to help the sdiff filter.  */
 bool sdiff_merge_assist;
 
 /* Tell OUTPUT_SDIFF to show only the left version of common lines.  */
 bool left_column;
 
 /* Tell OUTPUT_SDIFF to not show common lines.  */
 bool suppress_common_lines;
 
 /* The half line width and column 2 offset for OUTPUT_SDIFF.  */
 unsigned int sdiff_half_width;
 unsigned int sdiff_column2_offset;
 
 /* Use heuristics for better speed with large files with a small
    density of changes.  */
 bool speed_large_files;
 
 /* Patterns that match file names to be excluded.  */
 struct exclude *excluded;
 
 /* Don't discard lines.  This makes things slower (sometimes much
    slower) but will find a guaranteed minimal set of changes.  */
 bool minimal;
 
 
 /* The result of comparison is an "edit script": a chain of `struct change'.
    Each `struct change' represents one place where some lines are deleted
    and some are inserted.
 
    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.  */
 
 struct change
 {
   struct change *link;		/* Previous or next edit command  */
   GNULineRef inserted;			/* # lines of file 1 changed here.  */
   GNULineRef deleted;			/* # lines of file 0 changed here.  */
   GNULineRef line0;			/* Line number of 1st deleted line.  */
   GNULineRef line1;			/* Line number of 1st inserted line.  */
   bool ignore;			/* Flag used in context.c.  */
 };
 
 /* Structures that describe the input files.  */
 
 /* Data on one input file being compared.  */
 
 struct file_data {
     /* Buffer in which text of file is read.  */
     const QChar* buffer;
 
     /* Allocated size of buffer, in QChars.  Always a multiple of
        sizeof *buffer.  */
     size_t bufsize;
 
     /* Number of valid bytes now in the buffer.  */
     size_t buffered;
 
     /* Array of pointers to lines in the file.  */
     const QChar **linbuf;
 
     /* linbuf_base <= buffered_lines <= valid_lines <= alloc_lines.
        linebuf[linbuf_base ... buffered_lines - 1] are possibly differing.
        linebuf[linbuf_base ... valid_lines - 1] contain valid data.
        linebuf[linbuf_base ... alloc_lines - 1] are allocated.  */
     GNULineRef linbuf_base, buffered_lines, valid_lines, alloc_lines;
 
     /* Pointer to end of prefix of this file to ignore when hashing.  */
     const QChar *prefix_end;
 
     /* Count of lines in the prefix.
        There are this many lines in the file before linbuf[0].  */
     GNULineRef prefix_lines;
 
     /* Pointer to start of suffix of this file to ignore when hashing.  */
     const QChar *suffix_begin;
 
     /* Vector, indexed by line number, containing an equivalence code for
        each line.  It is this vector that is actually compared with that
        of another file to generate differences.  */
     GNULineRef *equivs;
 
     /* Vector, like the previous one except that
        the elements for discarded lines have been squeezed out.  */
     GNULineRef *undiscarded;
 
     /* Vector mapping virtual line numbers (not counting discarded lines)
        to real ones (counting those lines).  Both are origin-0.  */
     GNULineRef *realindexes;
 
     /* Total number of nondiscarded lines.  */
     GNULineRef nondiscarded_lines;
 
     /* Vector, indexed by real origin-0 line number,
        containing TRUE for a line that is an insertion or a deletion.
        The results of comparison are stored here.  */
     bool *changed;
 
     /* 1 if at end of file.  */
     bool eof;
 
     /* 1 more than the maximum equivalence value used for this or its
        sibling file.  */
     GNULineRef equiv_max;
 };
 
 /* Data on two input files being compared.  */
 
 struct comparison
   {
     struct file_data file[2];
     struct comparison const *parent;  /* parent, if a recursive comparison */
   };
 
 /* Describe the two files currently being compared.  */
 
 struct file_data files[2];
 
 /* Stdio stream to output diffs to.  */
 
 FILE *outfile;
 
 /* Declare various functions.  */
 
 /* analyze.c */
 struct change* diff_2_files (struct comparison *);
 
 /* context.c */
 void print_context_header (struct file_data[], bool);
 void print_context_script (struct change *, bool);
 
 /* dir.c */
 int diff_dirs (struct comparison const *, int (*) (struct comparison const *, const QChar *, const QChar *));
 
 /* ed.c */
 void print_ed_script (struct change *);
 void pr_forward_ed_script (struct change *);
 
 /* ifdef.c */
 void print_ifdef_script (struct change *);
 
 /* io.c */
 void file_block_read (struct file_data *, size_t);
 bool read_files (struct file_data[], bool);
 
 /* normal.c */
 void print_normal_script (struct change *);
 
 /* rcs.c */
 void print_rcs_script (struct change *);
 
 /* side.c */
 void print_sdiff_script (struct change *);
 
 /* util.c */
 QChar *concat (const QChar *, const QChar *, const QChar *);
 bool lines_differ ( const QChar *, size_t, const QChar *, size_t );
 GNULineRef translate_line_number (struct file_data const *, GNULineRef);
 struct change *find_change (struct change *);
 struct change *find_reverse_change (struct change *);
 void *zalloc (size_t);
 enum changes analyze_hunk (struct change *, GNULineRef *, GNULineRef *, GNULineRef *, GNULineRef *);
 void begin_output (void);
 void debug_script (struct change *);
 void finish_output (void);
 void message (const QChar *, const QChar *, const QChar *);
 void message5 (const QChar *, const QChar *, const QChar *, const QChar *, const QChar *);
 void output_1_line (const QChar *, const QChar *, const QChar *, const QChar *);
 void perror_with_name (const QChar *);
 void setup_output (const QChar *, const QChar *, bool);
 void translate_range (struct file_data const *, GNULineRef, GNULineRef, long *, long *);
 
 /* version.c */
 //extern const QChar version_string[];
 
 private:
    // gnudiff_analyze.cpp
    GNULineRef diag (GNULineRef xoff, GNULineRef xlim, GNULineRef yoff, GNULineRef ylim, bool find_minimal, struct partition *part);
    void compareseq (GNULineRef xoff, GNULineRef xlim, GNULineRef yoff, GNULineRef ylim, bool find_minimal);
    void discard_confusing_lines (struct file_data filevec[]);
    void shift_boundaries (struct file_data filevec[]);
    struct change * add_change (GNULineRef line0, GNULineRef line1, GNULineRef deleted, GNULineRef inserted, struct change *old);
    struct change * build_reverse_script (struct file_data const filevec[]);
    struct change* build_script (struct file_data const filevec[]);
 
    // gnudiff_io.cpp
    void find_and_hash_each_line (struct file_data *current);
    void find_identical_ends (struct file_data filevec[]);
 
    // gnudiff_xmalloc.cpp
    void *xmalloc (size_t n);
    void *xrealloc(void *p, size_t n);
    void xalloc_die (void);
 
    inline bool isWhite( QChar c )
    {
       return c==' ' || c=='\t' ||  c=='\r';
    }
 }; // class GnuDiff
 
 # define XMALLOC(Type, N_items) ((Type *) xmalloc (sizeof (Type) * (N_items)))
 # define XREALLOC(Ptr, Type, N_items) \
   ((Type *) xrealloc ((void *) (Ptr), sizeof (Type) * (N_items)))
 
 /* Declare and alloc memory for VAR of type TYPE. */
 # define NEW(Type, Var)  Type *(Var) = XMALLOC (Type, 1)
 
 /* Free VAR only if non NULL. */
 # define XFREE(Var)	\
    do {                 \
       if (Var)          \
         free (Var);     \
    } while (0)
 
 /* Return a pointer to a malloc'ed copy of the array SRC of NUM elements. */
 # define CCLONE(Src, Num) \
   (memcpy (xmalloc (sizeof (*Src) * (Num)), (Src), sizeof (*Src) * (Num)))
 
 /* Return a malloc'ed copy of SRC. */
 # define CLONE(Src) CCLONE (Src, 1)
 
 #endif
diff --git a/src/mergeresultwindow.cpp b/src/mergeresultwindow.cpp
index a024fb6..465dcbb 100644
--- a/src/mergeresultwindow.cpp
+++ b/src/mergeresultwindow.cpp
@@ -1,3341 +1,3341 @@
 /***************************************************************************
  *   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 <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>
 
 int g_bAutoSolve = true;
 
 #undef leftInfoWidth
 
 MergeResultWindow::MergeResultWindow(
     QWidget* pParent,
     Options* pOptions,
     QStatusBar* pStatusBar)
     : QWidget(pParent)
 {
     setObjectName("MergeResultWindow");
     setFocusPolicy(Qt::ClickFocus);
 
     m_firstLine = 0;
     m_horizScrollOffset = 0;
     m_nofLines = 0;
     m_totalSize = 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)
         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 LineData* pLineDataA, LineRef sizeA,
     const LineData* pLineDataB, LineRef sizeB,
     const 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();
 }
 
 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), this, &MergeResultWindow::slotChooseAEverywhere, ac, "merge_choose_a_everywhere");
     chooseBEverywhere = GuiUtils::createAction<QAction>(i18n("Choose B Everywhere"), QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_2), this, &MergeResultWindow::slotChooseBEverywhere, ac, "merge_choose_b_everywhere");
     chooseCEverywhere = GuiUtils::createAction<QAction>(i18n("Choose C Everywhere"), QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_3), this, &MergeResultWindow::slotChooseCEverywhere, ac, "merge_choose_c_everywhere");
     chooseAForUnsolvedConflicts = GuiUtils::createAction<QAction>(i18n("Choose A for All Unsolved Conflicts"), this, &MergeResultWindow::slotChooseAForUnsolvedConflicts, ac, "merge_choose_a_for_unsolved_conflicts");
     chooseBForUnsolvedConflicts = GuiUtils::createAction<QAction>(i18n("Choose B for All Unsolved Conflicts"), this, &MergeResultWindow::slotChooseBForUnsolvedConflicts, ac, "merge_choose_b_for_unsolved_conflicts");
     chooseCForUnsolvedConflicts = GuiUtils::createAction<QAction>(i18n("Choose C for All Unsolved Conflicts"), this, &MergeResultWindow::slotChooseCForUnsolvedConflicts, ac, "merge_choose_c_for_unsolved_conflicts");
     chooseAForUnsolvedWhiteSpaceConflicts = GuiUtils::createAction<QAction>(i18n("Choose A for All Unsolved Whitespace Conflicts"), this, &MergeResultWindow::slotChooseAForUnsolvedWhiteSpaceConflicts, ac, "merge_choose_a_for_unsolved_whitespace_conflicts");
     chooseBForUnsolvedWhiteSpaceConflicts = GuiUtils::createAction<QAction>(i18n("Choose B for All Unsolved Whitespace Conflicts"), this, &MergeResultWindow::slotChooseBForUnsolvedWhiteSpaceConflicts, ac, "merge_choose_b_for_unsolved_whitespace_conflicts");
     chooseCForUnsolvedWhiteSpaceConflicts = GuiUtils::createAction<QAction>(i18n("Choose C for All Unsolved Whitespace Conflicts"), this, &MergeResultWindow::slotChooseCForUnsolvedWhiteSpaceConflicts, ac, "merge_choose_c_for_unsolved_whitespace_conflicts");
 }
 
 void MergeResultWindow::showUnsolvedConflictsStatusMessage()
 {
     if(m_pStatusBar)
     {
         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() != -1)
         {
             if(pFineAB == nullptr)
             {
                 mergeDetails = eNoChange;
                 src = A;
             }
             else
             {
                 mergeDetails = eBChanged;
                 bConflict = true;
             }
         }
         else
         {
             if(getLineA() != -1 && getLineB() == -1)
             {
                 mergeDetails = eBDeleted;
                 bConflict = true;
             }
             else if(getLineA() == -1 && getLineB() != -1)
             {
                 mergeDetails = eBDeleted;
                 bConflict = true;
             }
         }
         return;
     }
 
     // A is base.
     if(getLineA() != -1 && getLineB() != -1 && 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() != -1 && getLineB() != -1 && getLineC() == -1)
     {
         if(pFineAB != nullptr)
         {
             mergeDetails = eBChanged_CDeleted;
             bConflict = true;
         }
         else
         {
             mergeDetails = eCDeleted;
             bLineRemoved = true;
             src = C;
         }
     }
     else if(getLineA() != -1 && getLineB() == -1 && getLineC() != -1)
     {
         if(pFineCA != nullptr)
         {
             mergeDetails = eCChanged_BDeleted;
             bConflict = true;
         }
         else
         {
             mergeDetails = eBDeleted;
             bLineRemoved = true;
             src = B;
         }
     }
     else if(getLineA() == -1 && getLineB() != -1 && getLineC() != -1)
     {
         if(pFineBC != nullptr)
         {
             mergeDetails = eBCAdded;
             bConflict = true;
         }
         else // B==C
         {
             mergeDetails = eBCAddedAndEqual;
             src = C;
         }
     }
     else if(getLineA() == -1 && getLineB() == -1 && getLineC() != -1)
     {
         mergeDetails = eCAdded;
         src = C;
     }
     else if(getLineA() == -1 && getLineB() != -1 && getLineC() == -1)
     {
         mergeDetails = eBAdded;
         src = B;
     }
     else if(getLineA() != -1 && getLineB() == -1 && getLineC() == -1)
     {
         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();
         m_totalSize = 0;
         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
             {
                 ml.mergeEditLineList.setTotalSizePtr(&m_totalSize);
                 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 == -1 && 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 == 1 ? d3llit->getLineA() : defaultSelector == 2 ? d3llit->getLineB() : defaultSelector == 3 ? d3llit->getLineC() : -1;
+                        LineRef srcLine = defaultSelector == 1 ? d3llit->getLineA() : defaultSelector == 2 ? d3llit->getLineB() : defaultSelector == 3 ? d3llit->getLineC() : LineRef();
 
                         if(srcLine != -1)
                         {
                             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 = -1;
         int oldSrc = -1;
         MergeEditLineList::iterator melIt;
         for(melIt = ml.mergeEditLineList.begin(); melIt != ml.mergeEditLineList.end();)
         {
             MergeEditLine& mel = *melIt;
             int melsrc = mel.src();
 
-            LineRef srcLine = mel.isRemoved() ? -1 : melsrc == 1 ? mel.id3l()->getLineA() : melsrc == 2 ? mel.id3l()->getLineB() : melsrc == 3 ? mel.id3l()->getLineC() : -1;
+            LineRef srcLine = mel.isRemoved() ? LineRef() : melsrc == 1 ? mel.id3l()->getLineA() : melsrc == 2 ? mel.id3l()->getLineB() : melsrc == 3 ? 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 == -1 && oldSrcLine == -1 && 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(int 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(this);
 
                 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_totalSize;
 }
 
 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 * fm.width('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() == 1 ? mel.id3l()->getLineA() : mel.src() == 2 ? mel.id3l()->getLineB() : mel.src() == 3 ? mel.id3l()->getLineC() : -1;
+            LineRef srcLine = mel.src() == 1 ? mel.id3l()->getLineA() : mel.src() == 2 ? mel.id3l()->getLineB() : mel.src() == 3 ? mel.id3l()->getLineC() : LineRef();
 
             if(srcLine == -1)
                 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_totalSize)
     {
         m_cursorYPos = m_totalSize - 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 > (int)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);
         QString s(pld->getLine(), pld->size());
         historyLead = calcHistoryLead(s);
     }
     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;
         QString s(pld->getLine(), pld->size());
         if(historyLead.isEmpty()) historyLead = calcHistoryLead(s);
         QString sLine = s.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(s))
         {
             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
 }
 
 MergeResultWindow::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(this);
                 QString firstLineOfEnd = iMLLEnd->mergeEditLineList.front().getString(this);
                 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
 MergeResultWindow::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);
     }
 }
 
 QString MergeResultWindow::MergeEditLine::getString(const MergeResultWindow* mrw)
 {
     if(isRemoved())
     {
         return QString();
     }
 
     if(!isModified())
     {
         int src = m_src;
         if(src == 0)
         {
             return QString();
         }
         const Diff3Line& d3l = *m_id3l;
         const LineData* pld = nullptr;
         Q_ASSERT(src == A || src == B || src == C);
         if(src == A && d3l.getLineA() != -1)
             pld = &mrw->m_pldA[d3l.getLineA()];
         else if(src == B && d3l.getLineB() != -1)
             pld = &mrw->m_pldB[d3l.getLineB()];
         else if(src == C && d3l.getLineC() != -1)
             pld = &mrw->m_pldC[d3l.getLineC()];
 
         //Not an error.
         if(pld == nullptr)
         {
             return QString();
         }
 
         return QString(pld->getLine(), pld->size());
     }
     else
     {
         return m_str;
     }
     return QString();
 }
 
 /// 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 -= fm.width('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 = fm.width('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;
         int 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(this);
 
                         writeLine(p, line, s, mel.src(), ml.mergeDetails, rangeMark,
                                   mel.isModified(), mel.isRemoved(), ml.bWhiteSpaceConflict);
                     }
                     ++line;
                 }
             }
         }
 
         if(line != m_nofLines)
         {
             m_nofLines = line;
             Q_ASSERT(m_nofLines == m_totalSize);
 
             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() == 1) srcMask |= 1;
             if(mel.src() == 2) srcMask |= 2;
             if(mel.src() == 3) 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);
 }
 
 int MergeResultWindow::convertToLine(int y)
 {
     const QFontMetrics& fm = fontMetrics();
     int fontHeight = fm.lineSpacing();
     int topLineYOffset = 0;
 
     int yOffset = topLineYOffset - m_firstLine * fontHeight;
 
     int line = std::min((y - yOffset) / fontHeight, m_totalSize - 1);
     return line;
 }
 
 void MergeResultWindow::mousePressEvent(QMouseEvent* e)
 {
     m_bCursorOn = true;
 
     int xOffset = getTextXOffset();
 
     int 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());
 
     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(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(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(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)
     {
         int 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)
 {
     int 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 = fm.width('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(this);
     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 >= (int)str.length())
         {
             if(y < m_totalSize - 1)
             {
                 setModified();
                 MergeLineList::iterator mlIt1;
                 MergeEditLineList::iterator melIt1;
                 calcIteratorFromLineNr(y + 1, mlIt1, melIt1);
                 if(melIt1->isEditableText())
                 {
                     QString s2 = melIt1->getString(this);
                     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(this);
                     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(this);
                 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 < (int)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_totalSize - 1)
                 {
                     ++y;
                     x = 0;
                 }
                 else
                 {
                     x = newX;
                 }
             }
             else
             {
                 while(x < (int)str.length() && (str[x] == ' ' || str[x] == '\t'))
                 {
                     int newX = textLayoutOrig.nextCursorPosition(x);
                     if(newX == x) break;
                     x = newX;
                 }
                 while(x < (int)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_totalSize - 1);
 
     calcIteratorFromLineNr(y, mlIt, melIt);
     str = melIt->getString(this);
 
     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,
     MergeResultWindow::MergeLineList::iterator& mlIt,
     MergeResultWindow::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(this);
 
                     // 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(this);
         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();
 
     int line = 0;
     MergeLineList::iterator mlItFirst;
     MergeEditLineList::iterator melItFirst;
     QString firstLineString;
 
     int firstLine = -1;
     int lastLine = -1;
 
     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 == -1)
                     firstLine = line;
                 lastLine = line;
             }
 
             ++line;
         }
     }
 
     if(firstLine == -1)
     {
         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(this);
 
                 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(this);
     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(this);
 
                 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)
 {
     MergeResultWindow::MergeLineList::iterator mlIt;
     MergeResultWindow::MergeEditLineList::iterator melIt;
     if(m_mergeLineList.empty())
     {
         return QString();
     }
     calcIteratorFromLineNr(lineIdx, mlIt, melIt);
     QString s = melIt->getString(this);
     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(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)
         m_pEncodingSelector->addItem(i18n("Codec from A: %1", QLatin1String(pCodecForA->name())), QVariant::fromValue((void*)pCodecForA));
     if(pCodecForB)
         m_pEncodingSelector->addItem(i18n("Codec from B: %1", QLatin1String(pCodecForB->name())), QVariant::fromValue((void*)pCodecForB));
     if(pCodecForC)
         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 && pCodecForB && pCodecForA)
     {
         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 && pCodecForB)
         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"