diff --git a/src/diff.cpp b/src/diff.cpp
index baa8ca2..0fe0e41 100644
--- a/src/diff.cpp
+++ b/src/diff.cpp
@@ -1,2481 +1,2471 @@
 /***************************************************************************
                           diff.cpp  -  description
                              -------------------
     begin                : Mon Mar 18 2002
     copyright            : (C) 2002-2007 by Joachim Eibl
     email                : joachim.eibl at gmx.de
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #include <qglobal.h>
 
 #ifdef Q_OS_WIN
 #include <qt_windows.h>
 
 #include <QCoreApplication>
 #endif
 
 #include <cstdlib>
 
 #include "diff.h"
 #include "fileaccess.h"
 #include "gnudiff_diff.h"
 #include "options.h"
 #include "progress.h"
 
 #include <KLocalizedString>
 #include <KMessageBox>
 
 #include <QDir>
 #include <QFileInfo>
 #include <QProcess>
 #include <QTextCodec>
 #include <QTextStream>
 
 #include <ctype.h>
 #include <map>
 //using namespace std;
 
 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 equal(const LineData& l1, const LineData& l2, bool bStrict)
 {
     if(l1.pLine == nullptr || l2.pLine == nullptr) return false;
 
     if(bStrict && g_bIgnoreTrivialMatches) //&& (l1.occurances>=5 || l2.occurances>=5) )
         return false;
 
     // Ignore white space diff
     const QChar* p1 = l1.pLine;
     const QChar* p1End = p1 + l1.size;
 
     const QChar* p2 = l2.pLine;
     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
     {
         if(l1.size == l2.size && memcmp(p1, p2, l1.size) == 0)
             return true;
         else
             return false;
     }
 }
 
 static bool 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'
         ;
 }
 
 /* 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.
 */
 
 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())
     {
         FileAccess::removeFile(m_tempInputFileName);
         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())
     {
         FileAccess::removeFile(m_tempInputFileName);
         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())
     {
         m_tempInputFileName = FileAccess::tempFileName();
     }
 
     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;
 }
 
 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.m_bIsText;
 }
 
 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(const QString& filename)
 {
     reset();
     if(filename.isEmpty()) {
         return true;
     }
 
     FileAccess fa(filename);
     m_size = fa.sizeForReading();
     char* pBuf;
     m_pBuf = pBuf = new char[m_size + 100]; // Alloc 100 byte extra: Savety 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];
     memcpy(pBuf, src.m_pBuf, m_size);
 }
 
 // Convert the input file from input encoding to output encoding and write it to the output file.
 static bool 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;
 }
 
 static QTextCodec* 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;
 }
 
 static QTextCodec* 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;
 }
 
 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;
 }
 
 /* Split the command line into arguments.
  * Normally split at white space separators except when quoting with " or '.
  * Backslash is treated as meta character within single quotes ' only.
  * Detect parsing errors like unclosed quotes.
  * The first item in the list will be the command itself.
  * Returns the error reasor as string or an empty string on success.
  * Eg. >"1" "2"<           => >1<, >2<
  * Eg. >'\'\\'<            => >'\<   backslash is a meta character between single quotes
  * Eg. > "\\" <            => >\\<   but not between double quotes
  * Eg. >"c:\sed" 's/a/\' /g'<  => >c:\sed<, >s/a/' /g<
  */
 static QString getArguments(QString cmd, QString& program, QStringList& args)
 {
     program = QString();
     args.clear();
     for(int i = 0; i < cmd.length(); ++i)
     {
         while(i < cmd.length() && cmd[i].isSpace())
         {
             ++i;
         }
         if(cmd[i] == '"' || cmd[i] == '\'') // argument beginning with a quote
         {
             QChar quoteChar = cmd[i];
             ++i;
             int argStart = i;
             bool bSkip = false;
             while(i < cmd.length() && (cmd[i] != quoteChar || bSkip))
             {
                 if(bSkip)
                 {
                     bSkip = false;
                     if(cmd[i] == '\\' || cmd[i] == quoteChar)
                     {
                         cmd.remove(i - 1, 1); // remove the backslash '\'
                         continue;
                     }
                 }
                 else if(cmd[i] == '\\' && quoteChar == '\'')
                     bSkip = true;
                 ++i;
             }
             if(i < cmd.length())
             {
                 args << cmd.mid(argStart, i - argStart);
                 if(i + 1 < cmd.length() && !cmd[i + 1].isSpace())
                     return i18n("Expecting space after closing apostroph.");
             }
             else
                 return i18n("Not matching apostrophs.");
             continue;
         }
         else
         {
             int argStart = i;
             //bool bSkip = false;
             while(i < cmd.length() && (!cmd[i].isSpace() /*|| bSkip*/))
             {
                 /*if ( bSkip )
             {
                bSkip = false;
                if ( cmd[i]=='\\' || cmd[i]=='"' || cmd[i]=='\'' || cmd[i].isSpace() )
                {
                   cmd.remove( i-1, 1 );  // remove the backslash '\'
                   continue;
                }
             }
             else if ( cmd[i]=='\\' )
                bSkip = true;
             else */
                 if(cmd[i] == '"' || cmd[i] == '\'')
                     return i18n("Unexpected apostroph within argument.");
                 ++i;
             }
             args << cmd.mid(argStart, i - argStart);
         }
     }
     if(args.isEmpty())
         return i18n("No program specified.");
     else
     {
         program = args[0];
         args.pop_front();
 #ifdef Q_OS_WIN
         if(program == "sed")
         {
             QString prg = QCoreApplication::applicationDirPath() + "/bin/sed.exe"; // in subdir bin
             if(QFile::exists(prg))
             {
                 program = prg;
             }
             else
             {
                 prg = QCoreApplication::applicationDirPath() + "/sed.exe"; // in same dir
                 if(QFile::exists(prg))
                 {
                     program = prg;
                 }
             }
         }
 #endif
     }
     return QString();
 }
 
 QStringList SourceData::readAndPreprocess(QTextCodec* pEncoding, bool bAutoDetectUnicode)
 {
     m_pEncoding = pEncoding;
     QString fileNameIn1;
     QString fileNameOut1;
     QString fileNameIn2;
     QString fileNameOut2;
     QStringList 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_tempInputFileName = FileAccess::tempFileName();
             }
 
             m_fileAccess.copyFile(m_tempInputFileName);
             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())
     {
-
-#if defined(Q_OS_WIN)
-        QString catCmd = "type";
-        fileNameIn1.replace('/', "\\");
-#else
-        QString catCmd = "cat";
-#endif
-
         // Run the first preprocessor
         if(m_pOptions->m_PreProcessorCmd.isEmpty())
         {
             // No preprocessing: Read the file directly:
             m_normalData.readFile(fileNameIn1);
         }
         else
         {
             QString fileNameInPP = fileNameIn1;
 
             if(pEncoding1 != m_pOptions->m_pEncodingPP)
             {
                 // Before running the preprocessor convert to the format that the preprocessor expects.
                 fileNameInPP = FileAccess::tempFileName();
                 pEncoding1 = m_pOptions->m_pEncodingPP;
                 convertFileEncoding(fileNameIn1, pEncoding, fileNameInPP, pEncoding1);
             }
 
             QString ppCmd = m_pOptions->m_PreProcessorCmd;
             fileNameOut1 = FileAccess::tempFileName();
 
             QProcess ppProcess;
             ppProcess.setStandardInputFile(fileNameInPP);
             ppProcess.setStandardOutputFile(fileNameOut1);
             QString program;
             QStringList args;
             QString errorReason = getArguments(ppCmd, program, args);
             if(errorReason.isEmpty())
             {
                 ppProcess.start(program, args);
                 ppProcess.waitForFinished(-1);
             }
             else
                 errorReason = "\n(" + errorReason + ")";
-            //QString cmd = catCmd + " \"" + fileNameInPP + "\" | " + ppCmd  + " >\"" + fileNameOut1+"\"";
-            //::system( encodeString(cmd) );
+            
             bool bSuccess = errorReason.isEmpty() && m_normalData.readFile(fileNameOut1);
             if(fileInSize > 0 && (!bSuccess || m_normalData.m_size == 0))
             {
 
                 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 = "";
                 m_normalData.readFile(fileNameIn1);
                 pEncoding1 = m_pEncoding;
             }
             if(fileNameInPP != fileNameIn1)
             {
                 FileAccess::removeTempFile(fileNameInPP);
             }
         }
 
         // LineMatching Preprocessor
         if(!m_pOptions->m_LineMatchingPreProcessorCmd.isEmpty())
         {
             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.
                 fileNameInPP = FileAccess::tempFileName();
                 pEncoding2 = m_pOptions->m_pEncodingPP;
                 convertFileEncoding(fileNameIn2, pEncoding1, fileNameInPP, pEncoding2);
             }
 
             QString ppCmd = m_pOptions->m_LineMatchingPreProcessorCmd;
             fileNameOut2 = FileAccess::tempFileName();
             QProcess ppProcess;
             ppProcess.setStandardInputFile(fileNameInPP);
             ppProcess.setStandardOutputFile(fileNameOut2);
             QString program;
             QStringList args;
             QString errorReason = getArguments(ppCmd, program, args);
             if(errorReason.isEmpty())
             {
                 ppProcess.start(program, args);
                 ppProcess.waitForFinished(-1);
             }
             else
                 errorReason = "\n(" + errorReason + ")";
-            //QString cmd = catCmd + " \"" + fileNameInPP + "\" | " + ppCmd  + " >\"" + fileNameOut2 + "\"";
-            //::system( encodeString(cmd) );
+            
             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 = "";
                 m_lmppData.readFile(fileNameIn2);
             }
             FileAccess::removeTempFile(fileNameOut2);
             if(fileNameInPP != fileNameIn2)
             {
                 FileAccess::removeTempFile(fileNameInPP);
             }
         }
         else if(m_pOptions->m_bIgnoreComments || m_pOptions->m_bIgnoreCase)
         {
             // We need a copy of the normal data.
             m_lmppData.copyBufFrom(m_normalData);
         }
         else
         { // We don't need any lmpp data at all.
             m_lmppData.reset();
         }
     }
 
     if(!m_normalData.preprocess(m_pOptions->m_bPreserveCarriageReturn, pEncoding1) ||
        !m_lmppData.preprocess(false, pEncoding2))
     {
 
         errors.append("File too large to processs. Skipping.");
     }
     else
     {
         //FIXME: Remove this hack after determining root cause.
         if(m_lmppData.m_vSize < m_normalData.m_vSize)
         {
             //This a bug that needs fixed elsewhere not hacked around
             Q_ASSERT(m_lmppData.m_vSize == m_normalData.m_vSize);
             // This probably is the fault of the LMPP-Command, but not worth reporting.
             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].pLine = m_lmppData.m_unicodeBuf.unicode() + m_lmppData.m_unicodeBuf.length();
             }
 
             m_lmppData.m_vSize = m_normalData.m_vSize;
         }
 
         // Internal Preprocessing: Uppercase-conversion
         if(m_pOptions->m_bIgnoreCase)
         {
             m_lmppData.m_unicodeBuf = QLocale::system().toUpper(m_lmppData.m_unicodeBuf);
         }
 
         // Ignore comments
         if(m_pOptions->m_bIgnoreComments)
         {
             m_lmppData.removeComments();
             LineRef vSize = (LineRef)min2(m_normalData.m_vSize, m_lmppData.m_vSize);
             for(int i = 0; i < (int)vSize; ++i)
             {
                 m_normalData.m_v[i].bContainsPureComment = m_lmppData.m_v[i].bContainsPureComment;
             }
         }
     }
     // Remove unneeded temporary files. (A temp file from clipboard must not be deleted.)
     if(!bTempFileFromClipboard && !m_tempInputFileName.isEmpty())
     {
         FileAccess::removeTempFile(m_tempInputFileName);
         m_tempInputFileName = "";
     }
 
     if(!fileNameOut1.isEmpty())
     {
         FileAccess::removeTempFile(fileNameOut1);
         fileNameOut1 = "";
     }
 
     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')
         {
             m_v[lineIdx].pLine = &p[i - lineLength];
             while(/*!bPreserveCR  &&*/ lineLength > 0 && m_v[lineIdx].pLine[lineLength - 1] == '\r')
             {
                 --lineLength;
             }
             m_v[lineIdx].pFirstNonWhiteChar = m_v[lineIdx].pLine + min2(whiteLength, lineLength);
             m_v[lineIdx].size = lineLength;
             if(lineIdx < vOrigDataLineEndStyle.count() && bPreserveCR && i < ucSize)
             {
                 ++m_v[lineIdx].size;
                 const_cast<QChar*>(m_v[lineIdx].pLine)[lineLength] = '\r';
                 //switch ( vOrigDataLineEndStyle[lineIdx] )
                 //{
                 //case eLineEndStyleUnix: const_cast<QChar*>(m_v[lineIdx].pLine)[lineLength] = '\n'; break;
                 //case eLineEndStyleDos:  const_cast<QChar*>(m_v[lineIdx].pLine)[lineLength] = '\r'; break;
                 //case eLineEndStyleUndefined: const_cast<QChar*>(m_v[lineIdx].pLine)[lineLength] = '\x0b'; break;
                 //}
             }
             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)
             {
                 int 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)
                     {
                         int 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)
                     {
                         int 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].bContainsPureComment = bCommentInLine && bWhite;
         /*      std::cout << line << " : " <<
        ( bCommentInLine ?  "c" : " " ) <<
        ( bWhite ? "w " : "  ") <<
        std::string(pLD[line].pLine, pLD[line].size) << std::endl;*/
 
         ++line;
     }
 }
 
 // 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.lineA = lineA;
             d3l.lineB = lineB;
             --d.nofEquals;
             ++lineA;
             ++lineB;
         }
         else if(d.diff1 > 0 && d.diff2 > 0)
         {
             d3l.lineA = lineA;
             d3l.lineB = lineB;
             --d.diff1;
             --d.diff2;
             ++lineA;
             ++lineB;
         }
         else if(d.diff1 > 0)
         {
             d3l.lineA = lineA;
             --d.diff1;
             ++lineA;
         }
         else if(d.diff2 > 0)
         {
             d3l.lineB = 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).lineA != lineA)
                 ++i3;
 
             (*i3).lineC = lineC;
             (*i3).bAEqC = true;
             (*i3).bBEqC = (*i3).bAEqB;
 
             --d.nofEquals;
             ++lineA;
             ++lineC;
             ++i3;
         }
         else if(d.diff1 > 0 && d.diff2 > 0)
         {
             d3l.lineC = 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.lineC = 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).lineB != lineB)
                 ++i3b;
 
             while(i3c != d3ll.end() && (*i3c).lineC != lineC)
                 ++i3c;
 
             Q_ASSERT(i3b != d3ll.end());
             Q_ASSERT(i3c != d3ll.end());
 
             if(i3b == i3c)
             {
                 Q_ASSERT((*i3b).lineC == 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).bAEqB) // i3c before i3b
                 {
                     Diff3LineList::iterator i3 = i3c;
                     int nofDisturbingLines = 0;
                     while(i3 != i3b && i3 != d3ll.end())
                     {
                         if((*i3).lineB != -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->bAEqB)
                             {
                                 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).lineB != -1 ||
                                (before_or_on_equal_line_in_A && i3->lineA != -1))
                             {
                                 Diff3Line d3l;
                                 d3l.lineB = (*i3).lineB;
                                 (*i3).lineB = -1;
 
                                 // Move A along if it matched B
                                 if(before_or_on_equal_line_in_A)
                                 {
                                     d3l.lineA = i3->lineA;
                                     d3l.bAEqB = i3->bAEqB;
                                     i3->lineA = -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).lineB = -1; // This might leave an empty line: removed later.
                         (*i3b).bAEqB = false;
                         (*i3b).bBEqC = false;
                         (*i3c).lineB = lineB;
                         (*i3c).bBEqC = true;
                         (*i3c).bAEqB = (*i3c).bAEqC;
                     }
                 }
                 else if(i3b1 == i3c && !(*i3c).bAEqC)
                 {
                     Diff3LineList::iterator i3 = i3b;
                     int nofDisturbingLines = 0;
                     while(i3 != i3c && i3 != d3ll.end())
                     {
                         if((*i3).lineC != -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->bAEqC)
                             {
                                 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).lineC != -1 ||
                                (before_or_on_equal_line_in_A && i3->lineA != -1))
                             {
                                 Diff3Line d3l;
                                 d3l.lineC = (*i3).lineC;
                                 (*i3).lineC = -1;
 
                                 // Move A along if it matched C
                                 if(before_or_on_equal_line_in_A)
                                 {
                                     d3l.lineA = i3->lineA;
                                     d3l.bAEqC = i3->bAEqC;
                                     i3->lineA = -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).lineC = -1; // This might leave an empty line: removed later.
                         (*i3c).bAEqC = false;
                         (*i3c).bBEqC = false;
                         (*i3b).lineC = lineC;
                         (*i3b).bBEqC = true;
                         (*i3b).bAEqC = (*i3b).bAEqB;
                     }
                 }
             }
 
             --d.nofEquals;
             ++lineB;
             ++lineC;
             ++i3b;
             ++i3c;
         }
         else if(d.diff1 > 0)
         {
             Diff3LineList::iterator i3 = i3b;
             while((*i3).lineB != lineB)
                 ++i3;
             if(i3 != i3b && (*i3).bAEqB == false)
             {
                 // Take B from this line and move it up as far as possible
                 d3l.lineB = lineB;
                 d3ll.insert(i3b, d3l);
                 (*i3).lineB = -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).lineA, (*it).lineB, (*it).lineC,
          (*it).bAEqB ? '=' : '!', (*it).bAEqC ? '=' : '!', (*it).bBEqC ? '=' : '!' );
    }
    printf("\n");*/
 }
 
 #ifdef Q_OS_WIN
 using ::equal;
 #endif
 
 // Test if the move would pass a barrier. Return true if not.
 static bool isValidMove(ManualDiffHelpList* pManualDiffHelpList, int line1, int line2, int winIdx1, int winIdx2)
 {
     if(line1 >= 0 && line2 >= 0)
     {
         ManualDiffHelpList::const_iterator i;
         for(i = pManualDiffHelpList->begin(); i != pManualDiffHelpList->end(); ++i)
         {
             const ManualDiffHelpEntry& mdhe = *i;
 
             // Barrier
             int l1 = winIdx1 == 1 ? mdhe.lineA1 : winIdx1 == 2 ? mdhe.lineB1 : mdhe.lineC1;
             int l2 = winIdx2 == 1 ? mdhe.lineA1 : winIdx2 == 2 ? mdhe.lineB1 : mdhe.lineC1;
 
             if(l1 >= 0 && l2 >= 0)
             {
                 if((line1 >= l1 && line2 < l2) || (line1 < l1 && line2 >= l2))
                     return false;
                 l1 = winIdx1 == 1 ? mdhe.lineA2 : winIdx1 == 2 ? mdhe.lineB2 : mdhe.lineC2;
                 l2 = winIdx2 == 1 ? mdhe.lineA2 : winIdx2 == 2 ? mdhe.lineB2 : mdhe.lineC2;
                 ++l1;
                 ++l2;
                 if((line1 >= l1 && line2 < l2) || (line1 < l1 && line2 >= l2))
                     return false;
             }
         }
     }
     return true; // no barrier passed.
 }
 
 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[0].pLine == nullptr || p2[0].pLine == nullptr || size1 == 0 || size2 == 0)
     {
         Diff d(0, 0, 0);
         if(p1[0].pLine == nullptr && p2[0].pLine == 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].pLine;                                                //ptr to buffer
         comparisonInput.file[0].buffered = (p1[size1 - 1].pLine - p1[0].pLine + p1[size1 - 1].size); // size of buffer
         comparisonInput.file[1].buffer = p2[0].pLine;                                                //ptr to buffer
         comparisonInput.file[1].buffered = (p2[size2 - 1].pLine - p2[0].pLine + 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 = 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 = 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;
             diffList.push_back(d);
 
             p = e->link;
             free(e);
         }
 
         if(diffList.empty())
         {
             Diff d(0, 0, 0);
             d.nofEquals = min2(size1, size2);
             d.diff1 = size1 - d.nofEquals;
             d.diff2 = size2 - d.nofEquals;
             diffList.push_back(d);
             /*         Diff d(0,0,0);
          d.nofEquals = equalLinesAtStart;
          if ( gnuDiff.files[0].missing_newline != gnuDiff.files[1].missing_newline )
          {
             d.diff1 = gnuDiff.files[0].missing_newline ? 0 : 1;
             d.diff2 = gnuDiff.files[1].missing_newline ? 0 : 1;
             ++d.nofEquals;
          }
          else if ( !gnuDiff.files[0].missing_newline )
          {
             ++d.nofEquals;
          }
          diffList.push_back(d);
 */
         }
         else
         {
             diffList.front().nofEquals += equalLinesAtStart;
             currentLine1 += equalLinesAtStart;
             currentLine2 += equalLinesAtStart;
 
             LineRef nofEquals = min2(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);
             }
 
             /*
          if ( gnuDiff.files[0].missing_newline != gnuDiff.files[1].missing_newline )
          {
             diffList.back().diff1 += gnuDiff.files[0].missing_newline ? 0 : 1;
             diffList.back().diff2 += gnuDiff.files[1].missing_newline ? 0 : 1;
          }
          else if ( !gnuDiff.files[0].missing_newline )
          {
             ++ diffList.back().nofEquals;
          }
          */
         }
     }
 
     // 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;
         }
 
         //if( l1!=p1-p1start || l2!=p2-p2start )
         Q_ASSERT(l1 == size1 && l2 == size2);
     }
 
     pp.setCurrent(1.0);
 
     return true;
 }
 
 bool runDiff(const LineData* p1, LineRef size1, const LineData* p2, LineRef size2, DiffList& diffList,
              int winIdx1, int winIdx2,
              ManualDiffHelpList* pManualDiffHelpList,
              Options* pOptions)
 {
     diffList.clear();
     DiffList diffList2;
 
     int l1begin = 0;
     int l2begin = 0;
     ManualDiffHelpList::const_iterator i;
     for(i = pManualDiffHelpList->begin(); i != pManualDiffHelpList->end(); ++i)
     {
         const ManualDiffHelpEntry& mdhe = *i;
 
         int l1end = winIdx1 == 1 ? mdhe.lineA1 : winIdx1 == 2 ? mdhe.lineB1 : mdhe.lineC1;
         int l2end = winIdx2 == 1 ? mdhe.lineA1 : winIdx2 == 2 ? mdhe.lineB1 : mdhe.lineC1;
 
         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 = winIdx1 == 1 ? mdhe.lineA2 : winIdx1 == 2 ? mdhe.lineB2 : mdhe.lineC2;
             l2end = winIdx2 == 1 ? mdhe.lineA2 : winIdx2 == 2 ? mdhe.lineB2 : mdhe.lineC2;
 
             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();
         int missingWinIdx = 0;
         int alignedSum = (iMDHL->lineA1 < 0 ? 0 : 1) + (iMDHL->lineB1 < 0 ? 0 : 1) + (iMDHL->lineC1 < 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->lineA1 < 0 ? 1 : (iMDHL->lineB1 < 0 ? 2 : 3);
         }
         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 = 0;
         for(; i3 != d3ll.end(); ++i3)
         {
             for(wi = 1; wi <= 3; ++wi)
             {
                 if(i3->getLineInFile(wi) >= 0 && iMDHL->firstLine(wi) == i3->getLineInFile(wi))
                     break;
             }
             if(wi <= 3)
                 break;
         }
 
         if(wi >= 1 && wi <= 3)
         {
             // 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 = 0;
             for(; i3 != d3ll.end(); ++i3)
             {
                 for(wi2 = 1; wi2 <= 3; ++wi2)
                 {
                     if(wi != wi2 && i3->getLineInFile(wi2) >= 0 && iMDHL->firstLine(wi2) == i3->getLineInFile(wi2))
                         break;
                 }
                 if(wi2 > 3)
                 { // Not yet found
                     // Move both others up
                     Diff3Line d3l;
                     // Move both up
                     if(wi == 1) // Move B and C up
                     {
                         d3l.bBEqC = i3->bBEqC;
                         d3l.lineB = i3->lineB;
                         d3l.lineC = i3->lineC;
                         i3->lineB = -1;
                         i3->lineC = -1;
                     }
                     if(wi == 2) // Move A and C up
                     {
                         d3l.bAEqC = i3->bAEqC;
                         d3l.lineA = i3->lineA;
                         d3l.lineC = i3->lineC;
                         i3->lineA = -1;
                         i3->lineC = -1;
                     }
                     if(wi == 3) // Move A and B up
                     {
                         d3l.bAEqB = i3->bAEqB;
                         d3l.lineA = i3->lineA;
                         d3l.lineB = i3->lineB;
                         i3->lineA = -1;
                         i3->lineB = -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 == 1)
                         {
                             iDest->lineA = i3->lineA;
                             i3->lineA = -1;
                             i3->bAEqB = false;
                             i3->bAEqC = false;
                         }
                         else if(wi2 == 2)
                         {
                             iDest->lineB = i3->lineB;
                             i3->lineB = -1;
                             i3->bAEqB = false;
                             i3->bBEqC = false;
                         }
                         else if(wi2 == 3)
                         {
                             iDest->lineC = i3->lineC;
                             i3->lineC = -1;
                             i3->bBEqC = false;
                             i3->bAEqC = false;
                         }
                     }
 
                     if(missingWinIdx != 0)
                     {
                         for(; i3 != d3ll.end(); ++i3)
                         {
                             int wi3 = missingWinIdx;
                             if(i3->getLineInFile(wi3) >= 0)
                             {
                                 // not found, move the line before iDest
                                 Diff3Line d3l;
                                 if(wi3 == 1)
                                 {
                                     if(i3->bAEqB) // Stop moving lines up if one equal is found.
                                         break;
                                     d3l.lineA = i3->lineA;
                                     i3->lineA = -1;
                                     i3->bAEqB = false;
                                     i3->bAEqC = false;
                                 }
                                 if(wi3 == 2)
                                 {
                                     if(i3->bAEqB)
                                         break;
                                     d3l.lineB = i3->lineB;
                                     i3->lineB = -1;
                                     i3->bAEqB = false;
                                     i3->bBEqC = false;
                                 }
                                 if(wi3 == 3)
                                 {
                                     if(i3->bAEqC)
                                         break;
                                     d3l.lineC = i3->lineC;
                                     i3->lineC = -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.removeAll(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->lineA >= 0 && i3->lineA == iMDHL->lineA1) ||
                (i3->lineB >= 0 && i3->lineB == iMDHL->lineB1) ||
                (i3->lineC >= 0 && i3->lineC == iMDHL->lineC1))
             {
                 i3A = i3;
                 i3B = i3;
                 i3C = i3;
                 lineA = line;
                 lineB = line;
                 lineC = line;
                 ++iMDHL;
             }
         }
 
         if(line > lineA && (*i3).lineA != -1 && (*i3A).lineB != -1 && (*i3A).bBEqC &&
            ::equal(pldA[(*i3).lineA], pldB[(*i3A).lineB], false) &&
            isValidMove(pManualDiffHelpList, (*i3).lineA, (*i3A).lineB, 1, 2) &&
            isValidMove(pManualDiffHelpList, (*i3).lineA, (*i3A).lineC, 1, 3))
         {
             // Empty space for A. A matches B and C in the empty line. Move it up.
             (*i3A).lineA = (*i3).lineA;
             (*i3A).bAEqB = true;
             (*i3A).bAEqC = true;
 
             (*i3).lineA = -1;
             (*i3).bAEqB = false;
             (*i3).bAEqC = false;
             ++i3A;
             ++lineA;
         }
 
         if(line > lineB && (*i3).lineB != -1 && (*i3B).lineA != -1 && (*i3B).bAEqC &&
            ::equal(pldB[(*i3).lineB], pldA[(*i3B).lineA], false) &&
            isValidMove(pManualDiffHelpList, (*i3).lineB, (*i3B).lineA, 2, 1) &&
            isValidMove(pManualDiffHelpList, (*i3).lineB, (*i3B).lineC, 2, 3))
         {
             // Empty space for B. B matches A and C in the empty line. Move it up.
             (*i3B).lineB = (*i3).lineB;
             (*i3B).bAEqB = true;
             (*i3B).bBEqC = true;
             (*i3).lineB = -1;
             (*i3).bAEqB = false;
             (*i3).bBEqC = false;
             ++i3B;
             ++lineB;
         }
 
         if(line > lineC && (*i3).lineC != -1 && (*i3C).lineA != -1 && (*i3C).bAEqB &&
            ::equal(pldC[(*i3).lineC], pldA[(*i3C).lineA], false) &&
            isValidMove(pManualDiffHelpList, (*i3).lineC, (*i3C).lineA, 3, 1) &&
            isValidMove(pManualDiffHelpList, (*i3).lineC, (*i3C).lineB, 3, 2))
         {
             // Empty space for C. C matches A and B in the empty line. Move it up.
             (*i3C).lineC = (*i3).lineC;
             (*i3C).bAEqC = true;
             (*i3C).bBEqC = true;
             (*i3).lineC = -1;
             (*i3).bAEqC = false;
             (*i3).bBEqC = false;
             ++i3C;
             ++lineC;
         }
 
         if(line > lineA && (*i3).lineA != -1 && !(*i3).bAEqB && !(*i3).bAEqC &&
            isValidMove(pManualDiffHelpList, (*i3).lineA, (*i3A).lineB, 1, 2) &&
            isValidMove(pManualDiffHelpList, (*i3).lineA, (*i3A).lineC, 1, 3)) {
             // Empty space for A. A doesn't match B or C. Move it up.
             (*i3A).lineA = (*i3).lineA;
             (*i3).lineA = -1;
 
             if(i3A->lineB != -1 && ::equal(pldA[i3A->lineA], pldB[i3A->lineB], false))
             {
                 i3A->bAEqB = true;
             }
             if((i3A->bAEqB && i3A->bBEqC) ||
                (i3A->lineC != -1 && ::equal(pldA[i3A->lineA], pldC[i3A->lineC], false)))
             {
                 i3A->bAEqC = true;
             }
 
             ++i3A;
             ++lineA;
         }
 
         if(line > lineB && (*i3).lineB != -1 && !(*i3).bAEqB && !(*i3).bBEqC &&
            isValidMove(pManualDiffHelpList, (*i3).lineB, (*i3B).lineA, 2, 1) &&
            isValidMove(pManualDiffHelpList, (*i3).lineB, (*i3B).lineC, 2, 3))
         {
             // Empty space for B. B matches neither A nor C. Move B up.
             (*i3B).lineB = (*i3).lineB;
             (*i3).lineB = -1;
 
             if(i3B->lineA != -1 && ::equal(pldA[i3B->lineA], pldB[i3B->lineB], false))
             {
                 i3B->bAEqB = true;
             }
             if((i3B->bAEqB && i3B->bAEqC) ||
                (i3B->lineC != -1 && ::equal(pldB[i3B->lineB], pldC[i3B->lineC], false)))
             {
                 i3B->bBEqC = true;
             }
 
             ++i3B;
             ++lineB;
         }
 
         if(line > lineC && (*i3).lineC != -1 && !(*i3).bAEqC && !(*i3).bBEqC &&
            isValidMove(pManualDiffHelpList, (*i3).lineC, (*i3C).lineA, 3, 1) &&
            isValidMove(pManualDiffHelpList, (*i3).lineC, (*i3C).lineB, 3, 2))
         {
             // Empty space for C. C matches neither A nor B. Move C up.
             (*i3C).lineC = (*i3).lineC;
             (*i3).lineC = -1;
 
             if(i3C->lineA != -1 && ::equal(pldA[i3C->lineA], pldC[i3C->lineC], false))
             {
                 i3C->bAEqC = true;
             }
             if((i3C->bAEqC && i3C->bAEqB) ||
                (i3C->lineB != -1 && ::equal(pldB[i3C->lineB], pldC[i3C->lineC], false)))
             {
                 i3C->bBEqC = true;
             }
 
             ++i3C;
             ++lineC;
         }
 
         if(line > lineA && line > lineB && (*i3).lineA != -1 && (*i3).bAEqB && !(*i3).bAEqC)
         {
             // 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(isValidMove(pManualDiffHelpList, i->lineC, (*i3).lineA, 3, 1) &&
                isValidMove(pManualDiffHelpList, i->lineC, (*i3).lineB, 3, 2))
             {
                 (*i).lineA = (*i3).lineA;
                 (*i).lineB = (*i3).lineB;
                 (*i).bAEqB = true;
 
                 if(i->lineC != -1 && ::equal(pldA[i->lineA], pldC[i->lineC], false))
                 {
                     (*i).bAEqC = true;
                     (*i).bBEqC = true;
                 }
 
                 (*i3).lineA = -1;
                 (*i3).lineB = -1;
                 (*i3).bAEqB = false;
                 i3A = i;
                 i3B = i;
                 ++i3A;
                 ++i3B;
                 lineA = l + 1;
                 lineB = l + 1;
             }
         }
         else if(line > lineA && line > lineC && (*i3).lineA != -1 && (*i3).bAEqC && !(*i3).bAEqB)
         {
             // 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(isValidMove(pManualDiffHelpList, i->lineB, (*i3).lineA, 2, 1) &&
                isValidMove(pManualDiffHelpList, i->lineB, (*i3).lineC, 2, 3))
             {
                 (*i).lineA = (*i3).lineA;
                 (*i).lineC = (*i3).lineC;
                 (*i).bAEqC = true;
 
                 if(i->lineB != -1 && ::equal(pldA[i->lineA], pldB[i->lineB], false))
                 {
                     (*i).bAEqB = true;
                     (*i).bBEqC = true;
                 }
 
                 (*i3).lineA = -1;
                 (*i3).lineC = -1;
                 (*i3).bAEqC = false;
                 i3A = i;
                 i3C = i;
                 ++i3A;
                 ++i3C;
                 lineA = l + 1;
                 lineC = l + 1;
             }
         }
         else if(line > lineB && line > lineC && (*i3).lineB != -1 && (*i3).bBEqC && !(*i3).bAEqC)
         {
             // 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(isValidMove(pManualDiffHelpList, i->lineA, (*i3).lineB, 1, 2) &&
                isValidMove(pManualDiffHelpList, i->lineA, (*i3).lineC, 1, 3))
             {
                 (*i).lineB = (*i3).lineB;
                 (*i).lineC = (*i3).lineC;
                 (*i).bBEqC = true;
 
                 if(i->lineA != -1 && ::equal(pldA[i->lineA], pldB[i->lineB], false))
                 {
                     (*i).bAEqB = true;
                     (*i).bAEqC = true;
                 }
 
                 (*i3).lineB = -1;
                 (*i3).lineC = -1;
                 (*i3).bBEqC = false;
                 i3B = i;
                 i3C = i;
                 ++i3B;
                 ++i3C;
                 lineB = l + 1;
                 lineC = l + 1;
             }
         }
 
         if((*i3).lineA != -1)
         {
             lineA = line + 1;
             i3A = i3;
             ++i3A;
         }
         if((*i3).lineB != -1)
         {
             lineB = line + 1;
             i3B = i3;
             ++i3B;
         }
         if((*i3).lineC != -1)
         {
             lineC = line + 1;
             i3C = i3;
             ++i3C;
         }
     }
 
     d3ll.removeAll(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).lineA, (*it).lineB, (*it).lineC,
          (*it).bAEqB ? '=' : '!', (*it).bAEqC ? '=' : '!', (*it).bBEqC ? '=' : '!' );
 
    }
 */
 }
 
 void DiffBufferInfo::init(Diff3LineList* pD3ll, const Diff3LineVector* pD3lv,
                           const LineData* pldA, LineRef sizeA, const LineData* pldB, LineRef sizeB, const LineData* pldC, LineRef 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 calcWhiteDiff3Lines(
     Diff3LineList& d3ll, const LineData* pldA, const LineData* pldB, const LineData* pldC)
 {
     Diff3LineList::iterator i3 = d3ll.begin();
 
     for(; i3 != d3ll.end(); ++i3)
     {
         i3->bWhiteLineA = ((*i3).lineA == -1 || pldA == nullptr || pldA[(*i3).lineA].whiteLine() || pldA[(*i3).lineA].bContainsPureComment);
         i3->bWhiteLineB = ((*i3).lineB == -1 || pldB == nullptr || pldB[(*i3).lineB].whiteLine() || pldB[(*i3).lineB].bContainsPureComment);
         i3->bWhiteLineC = ((*i3).lineC == -1 || pldC == nullptr || pldC[(*i3).lineC].whiteLine() || pldC[(*i3).lineC].bContainsPureComment);
     }
 }
 
 inline bool equal(QChar c1, QChar c2, bool /*bStrict*/)
 {
     // If bStrict then white space doesn't match
 
     //if ( bStrict &&  ( c1==' ' || c1=='\t' ) )
     //   return false;
 
     return c1 == c2;
 }
 
 // My own diff-invention:
 template <class T>
 void calcDiff(const T* p1, LineRef size1, const T* p2, LineRef size2, DiffList& diffList, int match, int maxSearchRange)
 {
     diffList.clear();
 
     const T* p1start = p1;
     const T* p2start = p2;
     const T* p1end = p1 + size1;
     const T* p2end = p2 + size2;
     for(;;)
     {
         int nofEquals = 0;
         while(p1 != p1end && p2 != p2end && equal(*p1, *p2, false))
         {
             ++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(equal(p2[i2], p1[i1], true) &&
                         (match == 1 || abs(i1 - i2) < 3 || (&p2[i2 + 1] == p2end && &p1[i1 + 1] == p1end) ||
                          (&p2[i2 + 1] != p2end && &p1[i1 + 1] != p1end && equal(p2[i2 + 1], p1[i1 + 1], false))))
                 {
                     if(i1 + i2 < bestI1 + bestI2 || bBestValid == false)
                     {
                         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 && equal(p1[bestI1 - 1], p2[bestI2 - 1], false))
         {
             --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 T* pu1 = p1 - 1;
         const T* pu2 = p2 - 1;
         while(pu1 >= p1start && pu2 >= p2start && equal(*pu1, *pu2, false))
         {
             ++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;
         }
 
         Q_ASSERT(l1 == size1 && l2 == size2);
     }
 }
 
 bool fineDiff(
     Diff3LineList& diff3LineList,
     int selector,
     const LineData* v1,
     const LineData* v2)
 {
     // Finetuning: Diff each line with deltas
     ProgressProxy pp;
     int maxSearchLength = 500;
     Diff3LineList::iterator i;
     LineRef k1 = 0;
     LineRef k2 = 0;
     bool bTextsTotalEqual = true;
     int listSize = diff3LineList.size();
     pp.setMaxNofSteps(listSize);
     int listIdx = 0;
     for(i = diff3LineList.begin(); i != diff3LineList.end(); ++i)
     {
         Q_ASSERT(selector == 1 || selector == 2 || selector == 3);
 
         if(selector == 1) {
             k1 = i->lineA;
             k2 = i->lineB;
         }
         else if(selector == 2)
         {
             k1 = i->lineB;
             k2 = i->lineC;
         }
         else if(selector == 3)
         {
             k1 = i->lineC;
             k2 = i->lineA;
         }
         
         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].pLine, v2[k2].pLine, v1[k1].size << 1) != 0)
             {
                 bTextsTotalEqual = false;
                 DiffList* pDiffList = new DiffList;
                 calcDiff(v1[k1].pLine, v1[k1].size, v2[k2].pLine, 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;
                     }
                 }
 
                 Q_ASSERT(selector == 1 || selector == 2 || selector == 3);
                 if(selector == 1) {
                     delete(*i).pFineAB;
                     (*i).pFineAB = pDiffList;
                 }
                 else if(selector == 2)
                 {
                     delete(*i).pFineBC;
                     (*i).pFineBC = pDiffList;
                 }
                 else if(selector == 3)
                 {
                     delete(*i).pFineCA;
                     (*i).pFineCA = pDiffList;
                 }
             }
 
             if((v1[k1].bContainsPureComment || v1[k1].whiteLine()) && (v2[k2].bContainsPureComment || v2[k2].whiteLine()))
             {
                 Q_ASSERT(selector == 1 || selector == 2 || selector == 3);
 
                 if(selector == 1) {
                     i->bAEqB = true;
                 }
                 else if(selector == 2)
                 {
                     i->bBEqC = true;
                 }
                 else if(selector == 3)
                 {
                     i->bAEqC = true;
                 }
             }
         }
         ++listIdx;
         pp.step();
     }
     return bTextsTotalEqual;
 }
 
 // Convert the list to a vector of pointers
 void calcDiff3LineVector(Diff3LineList& d3ll, Diff3LineVector& d3lv)
 {
     d3lv.resize(d3ll.size());
     Diff3LineList::iterator i;
     int j = 0;
     for(i = d3ll.begin(); i != d3ll.end(); ++i, ++j)
     {
         d3lv[j] = &(*i);
     }
     Q_ASSERT(j == (int)d3lv.size());
 }
diff --git a/src/difftextwindow.cpp b/src/difftextwindow.cpp
index e22c522..fb43973 100644
--- a/src/difftextwindow.cpp
+++ b/src/difftextwindow.cpp
@@ -1,2090 +1,2084 @@
 /***************************************************************************
                           difftextwindow.cpp  -  description
                              -------------------
     begin                : Mon Apr 8 2002
     copyright            : (C) 2002-2007 by Joachim Eibl
     email                : joachim.eibl at gmx.de
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #include "selection.h"
 #include "difftextwindow.h"
 #include "kdiff3.h"
 #include "merger.h"
 #include "options.h"
 
 #include <QApplication>
 #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 <qnamespace.h>
 
 #include <KLocalizedString>
 
 #include <cmath>
 #include <cstdlib>
 
 QAtomicInt s_runnableCount = 0;
 
 class DiffTextWindowData
 {
   public:
     explicit DiffTextWindowData(DiffTextWindow* p)
     {
         m_pDiffTextWindow = p;
         m_bPaintingAllowed = false;
         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 = 0;
         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;
 
     bool m_bPaintingAllowed;
     const LineData* m_pLineData;
     int m_size;
     QString m_filename;
     bool m_bWordWrap;
     int m_delayedDrawTimer;
 
     const Diff3LineVector* m_pDiff3LineVector;
     Diff3WrapLineVector m_diff3WrapLineVector;
     const ManualDiffHelpList* m_pManualDiffHelpList;
 
     class WrapLineCacheData
     {
       public:
         WrapLineCacheData() : m_d3LineIdx(0), m_textStart(0), m_textLength(0) {}
         WrapLineCacheData(int d3LineIdx, int textStart, int textLength)
             : m_d3LineIdx(d3LineIdx), m_textStart(textStart), m_textLength(textLength) {}
         int m_d3LineIdx;
         int m_textStart;
         int m_textLength;
     };
     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;
     int 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(
         MyPainter& 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(MyPainter& 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,
     int winIdx)
     : QWidget(pParent)
 {
     setObjectName(QString("DiffTextWindow%1").arg(winIdx));
     setAttribute(Qt::WA_OpaquePaintEvent);
     //setAttribute( Qt::WA_PaintOnScreen );
 
     d = new DiffTextWindowData(this);
     d->m_pDiffTextWindowFrame = pParent;
     setFocusPolicy(Qt::ClickFocus);
     setAcceptDrops(true);
 
     d->m_pOptions = pOptions;
     init(nullptr, nullptr, d->m_eLineEndStyle, nullptr, 0, nullptr, nullptr, false);
 
     setMinimumSize(QSize(20, 20));
 
     d->m_pStatusBar = pStatusBar;
     d->m_bPaintingAllowed = 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(d->m_bPaintingAllowed != bAllowPainting)
     {
         d->m_bPaintingAllowed = bAllowPainting;
         if(d->m_bPaintingAllowed)
             update();
         else
             reset();
     }
 }
 
 void DiffTextWindow::dragEnterEvent(QDragEnterEvent* e)
 {
     e->setAccepted(e->mimeData()->hasUrls() || e->mimeData()->hasText());
     // Note that the corresponding drop is handled in KDiff3App::eventFilter().
 }
 
 void DiffTextWindow::setFirstLine(int firstLine)
 {
     int fontHeight = fontMetrics().lineSpacing();
 
     int newFirstLine = max2(0, firstLine);
 
     int deltaY = fontHeight * (d->m_firstLine - newFirstLine);
 
     d->m_firstLine = newFirstLine;
 
     if(d->m_bSelectionInProgress && d->m_selection.isValidFirstLine())
     {
         int line, 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 - qMax(0, horizScrollOffset);
 
     d->m_horizScrollOffset = qMax(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())
     {
         int line, 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 = textLayout.maximumWidth();
         }
     }
     return getAtomic(d->m_maxTextWidth);
 }
 
 int DiffTextWindow::getNofLines()
 {
     return d->m_bWordWrap ? d->m_diff3WrapLineVector.size() : d->m_pDiff3LineVector->size();
 }
 
 int DiffTextWindow::convertLineToDiff3LineIdx(int line)
 {
     if(line >= 0 && d->m_bWordWrap && d->m_diff3WrapLineVector.size() > 0)
         return d->m_diff3WrapLineVector[min2(line, (int)d->m_diff3WrapLineVector.size() - 1)].diff3LineIndex;
     else
         return line;
 }
 
 int DiffTextWindow::convertDiff3LineIdxToLine(int d3lIdx)
 {
     if(d->m_bWordWrap && d->m_pDiff3LineVector != nullptr && d->m_pDiff3LineVector->size() > 0)
         return (*d->m_pDiff3LineVector)[min2(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)
         {
             scroll(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)
     {
         int 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, max2(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)
     {
         int 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)
 {
     int 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;
             scroll(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 = min2(d->m_selection.getLastLine(), d->m_selection.getOldLastLine());
                 lastLine = max2(d->m_selection.getLastLine(), d->m_selection.getOldLastLine());
             }
             int y1 = (firstLine - d->m_firstLine) * fontHeight;
             int y2 = min2(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);
         scroll(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, int& 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 += 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(
     MyPainter& 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();
-    QFont diffFont = normalFont;
-    //never set
-    //diffFont.setItalic(m_pOptions->m_bItalicForDeltas);
+
     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(0, 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->pLine, 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<UINT8> 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)
         {
             QColor 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;
             }
 
-            //QRect outRect( xOffset + outPixelPos, yOffset, charWidth*spaces, fontHeight );
-            //if ( m_pOptions->m_bRightToLeftLanguage )
-            //   outRect = QRect( deviceWidth-1-(xOffset + outPixelPos), yOffset, -charWidth*spaces, fontHeight ).normalized();
-            //if ( invalidRect.intersects( outRect ) )
             {
                 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;
         if(m_winIdx == 1) {
             rangeLine1 = mdhe.lineA1;
             rangeLine2 = mdhe.lineA2;
         }
         if(m_winIdx == 2) {
             rangeLine1 = mdhe.lineB1;
             rangeLine2 = mdhe.lineB2;
         }
         if(m_winIdx == 3) {
             rangeLine1 = mdhe.lineC1;
             rangeLine2 = mdhe.lineC2;
         }
         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() || !d->m_bPaintingAllowed)
         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 = min2(d->m_firstLine + getNofVisibleLines() + 2, getNofLines());
 
     MyPainter 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(MyPainter& p, const QRect&, int firstLine, int nofLinesPerPage)
 {
     if(d->m_pDiff3LineVector == nullptr || !d->m_bPaintingAllowed ||
        (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, min2(firstLine + nofLinesPerPage, getNofLines()));
     d->m_pOptions->m_bgColor = bgColor;
     d->m_firstLine = oldFirstLine;
 }
 
 void DiffTextWindowData::draw(MyPainter& p, const QRect& invalidRect, int deviceWidth, int beginLine, int endLine)
 {
     m_lineNumberWidth = m_pOptions->m_bShowLineNumbers ? (int)log10((double)qMax(m_size, 1)) + 1 : 0;
 
     if(m_winIdx == 1)
     {
         m_cThis = m_pOptions->m_colorA;
         m_cDiff1 = m_pOptions->m_colorB;
         m_cDiff2 = m_pOptions->m_colorC;
     }
     if(m_winIdx == 2)
     {
         m_cThis = m_pOptions->m_colorB;
         m_cDiff1 = m_pOptions->m_colorC;
         m_cDiff2 = m_pOptions->m_colorA;
     }
     if(m_winIdx == 3)
     {
         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->pLine, 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)
 {
     changed = 0;
     changed2 = 0;
     bool bAEqB = d3l.bAEqB || (d3l.bWhiteLineA && d3l.bWhiteLineB);
     bool bAEqC = d3l.bAEqC || (d3l.bWhiteLineA && d3l.bWhiteLineC);
     bool bBEqC = d3l.bBEqC || (d3l.bWhiteLineB && d3l.bWhiteLineC);
 
     Q_ASSERT(m_winIdx >= 1 && m_winIdx <= 3);
     if(m_winIdx == 1) {
         lineIdx = d3l.lineA;
         pFineDiff1 = d3l.pFineAB;
         pFineDiff2 = d3l.pFineCA;
         changed |= ((d3l.lineB == -1) != (lineIdx == -1) ? 1 : 0) +
                    ((d3l.lineC == -1) != (lineIdx == -1) && m_bTriple ? 2 : 0);
         changed2 |= (bAEqB ? 0 : 1) + (bAEqC || !m_bTriple ? 0 : 2);
     }
     else if(m_winIdx == 2)
     {
         lineIdx = d3l.lineB;
         pFineDiff1 = d3l.pFineBC;
         pFineDiff2 = d3l.pFineAB;
         changed |= ((d3l.lineC == -1) != (lineIdx == -1) && m_bTriple ? 1 : 0) +
                    ((d3l.lineA == -1) != (lineIdx == -1) ? 2 : 0);
         changed2 |= (bBEqC || !m_bTriple ? 0 : 1) + (bAEqB ? 0 : 2);
     }
     else if(m_winIdx == 3)
     {
         lineIdx = d3l.lineC;
         pFineDiff1 = d3l.pFineCA;
         pFineDiff2 = d3l.pFineBC;
         changed |= ((d3l.lineA == -1) != (lineIdx == -1) ? 1 : 0) +
                    ((d3l.lineB == -1) != (lineIdx == -1) ? 2 : 0);
         changed2 |= (bAEqC ? 0 : 1) + (bBEqC ? 0 : 2);
     }
     
 }
 
 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->lineA;
         }
         else if(d->m_winIdx == 2)
         {
             lineIdx = d3l->lineB;
         }
         else if(d->m_winIdx == 3)
         {
             lineIdx = d3l->lineC;
         }
 
         if(lineIdx != -1)
         {
             const QChar* pLine = d->m_pLineData[lineIdx].pLine;
             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, int& d3vLine, int& posInLine, bool bDirDown, bool bCaseSensitive)
 {
     int it = d3vLine;
     int endIt = bDirDown ? (int)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(int firstLine, int startPos, int lastLine, int endPos, int& 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->lineA;
         if(d->m_winIdx == 2) line = d3l->lineB;
         if(d->m_winIdx == 3) line = d3l->lineC;
         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)
 {
     int line = -1;
     if(lineOnScreen >= 0)
     {
         if(coordType == eWrapCoords) return lineOnScreen;
         int d3lIdx = m_pDiffTextWindow->convertLineToDiff3LineIdx(lineOnScreen);
         if(!bFirstLine && d3lIdx >= (int)m_pDiff3LineVector->size())
             d3lIdx = m_pDiff3LineVector->size() - 1;
         if(coordType == eD3LLineCoords) return d3lIdx;
         while(line < 0 && d3lIdx < (int)m_pDiff3LineVector->size() && d3lIdx >= 0)
         {
             const Diff3Line* d3l = (*m_pDiff3LineVector)[d3lIdx];
             if(m_winIdx == 1) line = d3l->lineA;
             if(m_winIdx == 2) line = d3l->lineB;
             if(m_winIdx == 3) line = d3l->lineC;
             if(bFirstLine)
                 ++d3lIdx;
             else
                 --d3lIdx;
         }
         if(coordType == eFileCoords) return line;
     }
     return line;
 }
 
 void DiffTextWindow::getSelectionRange(int* pFirstLine, int* 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 || !d->m_bPaintingAllowed || !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; // in Qt>=5.3 only
         s_runnableCount.fetchAndAddOrdered(1);
     }
     void run() override
     {
         m_pDTW->recalcWordWrapHelper(0, m_visibleTextWidth, m_cacheIdx);
         // int newValue = --s_runnableCount; // in Qt>=5.3 only
         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);
                     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)qMax(d->m_size, 1)) + 1 : 0;
 
         d->m_diff3WrapLineVector.resize(wrapLineVectorSize);
 
         if(wrapLineVectorSize == 0)
             d->m_wrapLineCacheList.clear();
 
         if(wrapLineVectorSize == 0)
         {
             d->m_bPaintingAllowed = 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));
             }
             //recalcWordWrap( bWordWrap, wrapLineVectorSize, visibleTextWidth, 0 );
         }
         else
         {
             recalcWordWrapHelper(wrapLineVectorSize, visibleTextWidth, 0);
             d->m_bPaintingAllowed = true;
         }
     }
     else
     {
         if(wrapLineVectorSize == 0 && getAtomic(d->m_maxTextWidth) < 0)
         {
             d->m_diff3WrapLineVector.resize(0);
             d->m_wrapLineCacheList.clear();
             d->m_bPaintingAllowed = 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
         {
             d->m_bPaintingAllowed = 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 : qMin(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 = min2(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 = qMin(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 = 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;
     QLineEdit* m_pFileSelection;
     QPushButton* m_pBrowseButton;
     Options* m_pOptions;
     QLabel* m_pLabel;
     QLabel* m_pTopLine;
     QLabel* m_pEncoding;
     QLabel* m_pLineEndStyle;
     QWidget* m_pTopLineWidget;
     int m_winIdx;
 };
 
 DiffTextWindowFrame::DiffTextWindowFrame(QWidget* pParent, QStatusBar* pStatusBar, Options* pOptions, int 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 QLineEdit(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_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 ? "A (Base)" : "A") : (pDTW->d->m_winIdx == 2 ? "B" : "C");
         d->m_pLabel->setText(winId + ":");
         d->m_pEncoding->setText(i18n("Encoding: %1", pDTW->d->m_pTextCodec != nullptr ? 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)qMax(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)
 {
     DiffTextWindow* pDTW = d->m_pDiffTextWindow;
     if(e->type() == QEvent::FocusIn || e->type() == QEvent::FocusOut)
     {
         QColor c1 = d->m_pOptions->m_bgColor;
         QColor c2;
         if(d->m_winIdx == 1)
             c2 = d->m_pOptions->m_colorA;
         else if(d->m_winIdx == 2)
             c2 = d->m_pOptions->m_colorB;
         else if(d->m_winIdx == 3)
             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);
     }
     if(o == d->m_pFileSelection && e->type() == QEvent::Drop)
     {
         QDropEvent* d = static_cast<QDropEvent*>(e);
 
         if(d->mimeData()->hasUrls())
         {
             QList<QUrl> lst = d->mimeData()->urls();
 
             if(lst.count() > 0)
             {
                 static_cast<QLineEdit*>(o)->setText(lst[0].toString());
                 static_cast<QLineEdit*>(o)->setFocus();
                 emit fileNameChanged(lst[0].toString(), pDTW->d->m_winIdx);
                 return true;
             }
         }
     }
 
     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.
         pAction->setText(visibleCodecName.isEmpty() ? QString(pCodec->name()) : visibleCodecName + " (" + pCodec->name() + ")");
         pAction->setData(CodecMIBEnum);
         pAction->setCheckable(true);
         if(currentTextCodecEnum == CodecMIBEnum)
             pAction->setChecked(true);
         pMenu->addAction(pAction);
         connect(pAction, SIGNAL(triggered()), this, SLOT(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(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/pdiff.cpp b/src/pdiff.cpp
index a7198c9..7a896eb 100644
--- a/src/pdiff.cpp
+++ b/src/pdiff.cpp
@@ -1,2537 +1,2527 @@
 /***************************************************************************
                          pdiff.cpp  -  Implementation for class KDiff3App
                          ---------------
     begin                : Mon March 18 20:04:50 CET 2002
     copyright            : (C) 2002-2007 by Joachim Eibl
     email                : joachim.eibl at gmx.de
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 #include <QtCore>
 #include <QtGui>
 #include <QtWidgets/QtWidgets>
 
 #ifdef Q_OS_WIN
 #include <qt_windows.h>
 #endif
 
 #include "difftextwindow.h"
 #include "directorymergewindow.h"
 #include "mergeresultwindow.h"
 #include "smalldialogs.h"
 
 #include <algorithm>
 #include <cstdio>
 #include <ctype.h>
 
 #include <QCheckBox>
 #include <QClipboard>
 #include <QComboBox>
 #include <QDir>
 #include <QDropEvent>
 #include <QFile>
 #include <QLayout>
 #include <QLineEdit>
 #include <QProcess>
 #include <QScrollBar>
 #include <QSplitter>
 #include <QStatusBar>
 #include <QUrl>
 
 #include <KLocalizedString>
 #include <KShortcutsDialog>
 #include <KMessageBox>
 
 #include "fileaccess.h"
 #include "kdiff3.h"
 #include "optiondialog.h"
 #include "progress.h"
 
 #ifdef Q_OS_WIN
 #include <windows.h>
 #endif
 
 bool g_bIgnoreWhiteSpace = true;
 bool g_bIgnoreTrivialMatches = true;
 
 // Just make sure that all input lines are in the output too, exactly once.
 static void debugLineCheck(Diff3LineList& d3ll, LineRef size, LineRef idx)
 {
     Diff3LineList::iterator it = d3ll.begin();
     LineRef i = 0;
 
     for(it = d3ll.begin(); it != d3ll.end(); ++it)
     {
         LineRef l = 0;
 
         Q_ASSERT(idx >= 1 && idx <= 3);
         if(idx == 1)
             l = (*it).lineA;
         else if(idx == 2)
             l = (*it).lineB;
         else if(idx == 3)
             l = (*it).lineC;            
 
         if(l != -1)
         {
             if(l != i)
             {
                 KMessageBox::error(nullptr, i18n(
                                           "Data loss error:\n"
                                           "If it is reproducible please contact the author.\n"),
                                    i18n("Severe Internal Error"));
                 
                 fprintf(stderr, "Severe Internal Error.\n");
                 ::exit(-1);
             }
             ++i;
         }
     }
 
     if(size != i)
     {
         KMessageBox::error(nullptr, i18n(
                                   "Data loss error:\n"
                                   "If it is reproducible please contact the author.\n"),
                            i18n("Severe Internal Error"));
         
         fprintf(stderr, "Severe Internal Error.\n");
         ::exit(-1);
     }
 }
 
 void KDiff3App::mainInit(TotalDiffStatus* pTotalDiffStatus, bool bLoadFiles, bool bUseCurrentEncoding)
 {
     ProgressProxy pp;
 
     // When doing a full analysis in the directory-comparison, then the statistics-results
     // will be stored in the given TotalDiffStatus. Otherwise it will be 0.
     bool bGUI = pTotalDiffStatus == nullptr;
     if(pTotalDiffStatus == nullptr)
         pTotalDiffStatus = &m_totalDiffStatus;
 
     //bool bPreserveCarriageReturn = m_pOptions->m_bPreserveCarriageReturn;
 
     bool bVisibleMergeResultWindow = !m_outputFilename.isEmpty();
     if(bVisibleMergeResultWindow && bGUI)
     {
         //bPreserveCarriageReturn = false;
 
         QString msg;
 
         if(!m_pOptions->m_PreProcessorCmd.isEmpty())
         {
             msg += "- " + i18n("PreprocessorCmd: ") + m_pOptions->m_PreProcessorCmd + "\n";
         }
         if(!msg.isEmpty())
         {
             int result = KMessageBox::warningYesNo(this,
                                                    i18n("The following option(s) you selected might change data:\n") + msg +
                                                        i18n("\nMost likely this is not wanted during a merge.\n"
                                                             "Do you want to disable these settings or continue with these settings active?"),
                                                    i18n("Option Unsafe for Merging"),
                                                    KGuiItem(i18n("Use These Options During Merge")),
                                                    KGuiItem(i18n("Disable Unsafe Options")));
 
             if(result == KMessageBox::No)
             {
                 m_pOptions->m_PreProcessorCmd = "";
             }
         }
     }
 
     // Because of the progressdialog paintevents can occur, but data is invalid,
     // so painting must be suppressed.
     if(m_pDiffTextWindow1) m_pDiffTextWindow1->setPaintingAllowed(false);
     if(m_pDiffTextWindow2) m_pDiffTextWindow2->setPaintingAllowed(false);
     if(m_pDiffTextWindow3) m_pDiffTextWindow3->setPaintingAllowed(false);
     if(m_pOverview) m_pOverview->setPaintingAllowed(false);
     if(m_pMergeResultWindow) m_pMergeResultWindow->setPaintingAllowed(false);
 
     m_diff3LineList.clear();
 
     if(bLoadFiles)
     {
         QStringList errors;
         m_manualDiffHelpList.clear();
 
         if(m_sd3.isEmpty())
             pp.setMaxNofSteps(4); // Read 2 files, 1 comparison, 1 finediff
         else
             pp.setMaxNofSteps(9); // Read 3 files, 3 comparisons, 3 finediffs
 
         // First get all input data.
         pp.setInformation(i18n("Loading A"));
         if(bUseCurrentEncoding == true)
             errors = m_sd1.readAndPreprocess(m_sd1.getEncoding(), false);
         else
             errors = m_sd1.readAndPreprocess(m_pOptions->m_pEncodingA, m_pOptions->m_bAutoDetectUnicodeA);
         foreach(const QString& error, errors)
         {
             KMessageBox::error(m_pOptionDialog, error);
         }
         pp.step();
 
         pp.setInformation(i18n("Loading B"));
         if(bUseCurrentEncoding == true)
             errors = m_sd2.readAndPreprocess(m_sd2.getEncoding(), false);
         else
             errors = m_sd2.readAndPreprocess(m_pOptions->m_pEncodingB, m_pOptions->m_bAutoDetectUnicodeB);
         foreach(const QString& error, errors)
         {
             KMessageBox::error(m_pOptionDialog, error);
         }
         pp.step();
     }
     else
     {
         if(m_sd3.isEmpty())
             pp.setMaxNofSteps(2); // 1 comparison, 1 finediff
         else
             pp.setMaxNofSteps(6); // 3 comparisons, 3 finediffs
     }
 
     pTotalDiffStatus->reset();
     // Run the diff.
     if(m_sd3.isEmpty())
     {
         pTotalDiffStatus->bBinaryAEqB = m_sd1.isBinaryEqualWith(m_sd2);
         pp.setInformation(i18n("Diff: A <-> B"));
 
         runDiff(m_sd1.getLineDataForDiff(), m_sd1.getSizeLines(), m_sd2.getLineDataForDiff(), m_sd2.getSizeLines(), m_diffList12, 1, 2,
                 &m_manualDiffHelpList, &m_pOptionDialog->m_options);
 
         pp.step();
 
         pp.setInformation(i18n("Linediff: A <-> B"));
         calcDiff3LineListUsingAB(&m_diffList12, m_diff3LineList);
         pTotalDiffStatus->bTextAEqB = fineDiff(m_diff3LineList, 1, m_sd1.getLineDataForDisplay(), m_sd2.getLineDataForDisplay());
         if(m_sd1.getSizeBytes() == 0) pTotalDiffStatus->bTextAEqB = false;
 
         pp.step();
     }
     else
     {
         if(bLoadFiles)
         {
             pp.setInformation(i18n("Loading C"));
             if(bUseCurrentEncoding == true)
                 m_sd3.readAndPreprocess(m_sd3.getEncoding(), false);
             else
                 m_sd3.readAndPreprocess(m_pOptions->m_pEncodingC, m_pOptions->m_bAutoDetectUnicodeC);
             pp.step();
         }
 
         pTotalDiffStatus->bBinaryAEqB = m_sd1.isBinaryEqualWith(m_sd2);
         pTotalDiffStatus->bBinaryAEqC = m_sd1.isBinaryEqualWith(m_sd3);
         pTotalDiffStatus->bBinaryBEqC = m_sd3.isBinaryEqualWith(m_sd2);
 
         pp.setInformation(i18n("Diff: A <-> B"));
         runDiff(m_sd1.getLineDataForDiff(), m_sd1.getSizeLines(), m_sd2.getLineDataForDiff(), m_sd2.getSizeLines(), m_diffList12, 1, 2,
                 &m_manualDiffHelpList, &m_pOptionDialog->m_options);
         pp.step();
         pp.setInformation(i18n("Diff: B <-> C"));
         runDiff(m_sd2.getLineDataForDiff(), m_sd2.getSizeLines(), m_sd3.getLineDataForDiff(), m_sd3.getSizeLines(), m_diffList23, 2, 3,
                 &m_manualDiffHelpList, &m_pOptionDialog->m_options);
         pp.step();
         pp.setInformation(i18n("Diff: A <-> C"));
         runDiff(m_sd1.getLineDataForDiff(), m_sd1.getSizeLines(), m_sd3.getLineDataForDiff(), m_sd3.getSizeLines(), m_diffList13, 1, 3,
                 &m_manualDiffHelpList, &m_pOptionDialog->m_options);
         pp.step();
 
         calcDiff3LineListUsingAB(&m_diffList12, m_diff3LineList);
         calcDiff3LineListUsingAC(&m_diffList13, m_diff3LineList);
         correctManualDiffAlignment(m_diff3LineList, &m_manualDiffHelpList);
         calcDiff3LineListTrim(m_diff3LineList, m_sd1.getLineDataForDiff(), m_sd2.getLineDataForDiff(), m_sd3.getLineDataForDiff(), &m_manualDiffHelpList);
 
         if(m_pOptions->m_bDiff3AlignBC)
         {
             calcDiff3LineListUsingBC(&m_diffList23, m_diff3LineList);
             correctManualDiffAlignment(m_diff3LineList, &m_manualDiffHelpList);
             calcDiff3LineListTrim(m_diff3LineList, m_sd1.getLineDataForDiff(), m_sd2.getLineDataForDiff(), m_sd3.getLineDataForDiff(), &m_manualDiffHelpList);
         }
         debugLineCheck(m_diff3LineList, m_sd1.getSizeLines(), 1);
         debugLineCheck(m_diff3LineList, m_sd2.getSizeLines(), 2);
         debugLineCheck(m_diff3LineList, m_sd3.getSizeLines(), 3);
 
         pp.setInformation(i18n("Linediff: A <-> B"));
         pTotalDiffStatus->bTextAEqB = fineDiff(m_diff3LineList, 1, m_sd1.getLineDataForDisplay(), m_sd2.getLineDataForDisplay());
         pp.step();
         pp.setInformation(i18n("Linediff: B <-> C"));
         pTotalDiffStatus->bTextBEqC = fineDiff(m_diff3LineList, 2, m_sd2.getLineDataForDisplay(), m_sd3.getLineDataForDisplay());
         pp.step();
         pp.setInformation(i18n("Linediff: A <-> C"));
         pTotalDiffStatus->bTextAEqC = fineDiff(m_diff3LineList, 3, m_sd3.getLineDataForDisplay(), m_sd1.getLineDataForDisplay());
         pp.step();
         if(m_sd1.getSizeBytes() == 0) {
             pTotalDiffStatus->bTextAEqB = false;
             pTotalDiffStatus->bTextAEqC = false;
         }
         if(m_sd2.getSizeBytes() == 0) {
             pTotalDiffStatus->bTextAEqB = false;
             pTotalDiffStatus->bTextBEqC = false;
         }
     }
     m_diffBufferInfo.init(&m_diff3LineList, &m_diff3LineVector,
                           m_sd1.getLineDataForDiff(), m_sd1.getSizeLines(),
                           m_sd2.getLineDataForDiff(), m_sd2.getSizeLines(),
                           m_sd3.getLineDataForDiff(), m_sd3.getSizeLines());
     calcWhiteDiff3Lines(m_diff3LineList, m_sd1.getLineDataForDiff(), m_sd2.getLineDataForDiff(), m_sd3.getLineDataForDiff());
     calcDiff3LineVector(m_diff3LineList, m_diff3LineVector);
 
     // Calc needed lines for display
     m_neededLines = m_diff3LineList.size();
 
     QList<int> oldHeights;
     if(m_pDirectoryMergeSplitter->isVisible())
         oldHeights = m_pMainSplitter->sizes();
 
     initView();
 
     if(m_pDirectoryMergeSplitter->isVisible())
     {
         if(oldHeights.count() < 2)
             oldHeights.append(0);
         if(oldHeights[1] == 0) // Distribute the available space evenly between the two widgets.
         {
             oldHeights[1] = oldHeights[0] / 2;
             oldHeights[0] -= oldHeights[1];
         }
         if(oldHeights[0] == 0 && oldHeights[1] == 0)
         {
             oldHeights[1] = 100;
             oldHeights[0] = 100;
         }
         m_pMainSplitter->setSizes(oldHeights);
     }
 
     m_pMainWidget->setVisible(bGUI);
 
     m_bTripleDiff = !m_sd3.isEmpty();
 
     m_pMergeResultWindowTitle->setEncodings(m_sd1.getEncoding(), m_sd2.getEncoding(), m_sd3.getEncoding());
     if(!m_pOptions->m_bAutoSelectOutEncoding)
         m_pMergeResultWindowTitle->setEncoding(m_pOptions->m_pEncodingOut);
 
     m_pMergeResultWindowTitle->setLineEndStyles(m_sd1.getLineEndStyle(), m_sd2.getLineEndStyle(), m_sd3.getLineEndStyle());
 
     if(bGUI)
     {
         const ManualDiffHelpList* pMDHL = &m_manualDiffHelpList;
         m_pDiffTextWindow1->init(m_sd1.getAliasName(), m_sd1.getEncoding(), m_sd1.getLineEndStyle(),
                                  m_sd1.getLineDataForDisplay(), m_sd1.getSizeLines(), &m_diff3LineVector, pMDHL, m_bTripleDiff);
         m_pDiffTextWindow2->init(m_sd2.getAliasName(), m_sd2.getEncoding(), m_sd2.getLineEndStyle(),
                                  m_sd2.getLineDataForDisplay(), m_sd2.getSizeLines(), &m_diff3LineVector, pMDHL, m_bTripleDiff);
         m_pDiffTextWindow3->init(m_sd3.getAliasName(), m_sd3.getEncoding(), m_sd3.getLineEndStyle(),
                                  m_sd3.getLineDataForDisplay(), m_sd3.getSizeLines(), &m_diff3LineVector, pMDHL, m_bTripleDiff);
 
         m_pDiffTextWindowFrame3->setVisible(m_bTripleDiff);
     }
 
     m_bOutputModified = bVisibleMergeResultWindow;
 
     m_pMergeResultWindow->init(
         m_sd1.getLineDataForDisplay(), m_sd1.getSizeLines(),
         m_sd2.getLineDataForDisplay(), m_sd2.getSizeLines(),
         m_bTripleDiff ? m_sd3.getLineDataForDisplay() : nullptr, m_sd3.getSizeLines(),
         &m_diff3LineList,
         pTotalDiffStatus);
     m_pMergeResultWindowTitle->setFileName(m_outputFilename.isEmpty() ? QString("unnamed.txt") : m_outputFilename);
 
     if(!bGUI)
     {
         // We now have all needed information. The rest below is only for GUI-activation.
         m_sd1.reset();
         m_sd2.reset();
         m_sd3.reset();
         return;
     }
 
     m_pOverview->init(&m_diff3LineList, m_bTripleDiff);
     m_pDiffVScrollBar->setValue(0);
     m_pHScrollBar->setValue(0);
     m_pMergeVScrollBar->setValue(0);
 
     m_pDiffTextWindow1->setPaintingAllowed(true);
     m_pDiffTextWindow2->setPaintingAllowed(true);
     m_pDiffTextWindow3->setPaintingAllowed(true);
     m_pOverview->setPaintingAllowed(true);
     m_pMergeResultWindow->setPaintingAllowed(true);
 
     if(!bVisibleMergeResultWindow)
         m_pMergeWindowFrame->hide();
     else
         m_pMergeWindowFrame->show();
 
     // Try to create a meaningful but not too long caption
     if(!isPart())
     {
         // 1. If the filenames are equal then show only one filename
         QString caption;
         QString f1 = m_sd1.getAliasName();
         QString f2 = m_sd2.getAliasName();
         QString f3 = m_sd3.getAliasName();
         int p;
         if((p = f1.indexOf("@@")) >= 0)
             f1 = f1.left(p);
         if((p = f2.indexOf("@@")) >= 0)
             f2 = f2.left(p);
         if((p = f3.indexOf("@@")) >= 0)
             f3 = f3.left(p);
 
         if((p = f1.lastIndexOf('/')) >= 0 || (p = f1.lastIndexOf('\\')) >= 0)
             f1 = f1.mid(p + 1);
         if((p = f2.lastIndexOf('/')) >= 0 || (p = f2.lastIndexOf('\\')) >= 0)
             f2 = f2.mid(p + 1);
         if((p = f3.lastIndexOf('/')) >= 0 || (p = f3.lastIndexOf('\\')) >= 0)
             f3 = f3.mid(p + 1);
 
         if(!f1.isEmpty())
         {
             if((f2.isEmpty() && f3.isEmpty()) ||
                (f2.isEmpty() && f1 == f3) || (f3.isEmpty() && f1 == f2) || (f1 == f2 && f1 == f3))
                 caption = f1;
         }
         else if(!f2.isEmpty())
         {
             if(f3.isEmpty() || f2 == f3)
                 caption = f2;
         }
         else if(!f3.isEmpty())
             caption = f3;
 
         // 2. If the files don't have the same name then show all names
         if(caption.isEmpty() && (!f1.isEmpty() || !f2.isEmpty() || !f3.isEmpty()))
         {
             caption = (f1.isEmpty() ? QString("") : f1);
             caption += QString(caption.isEmpty() || f2.isEmpty() ? "" : " <-> ") + (f2.isEmpty() ? QString("") : f2);
             caption += QString(caption.isEmpty() || f3.isEmpty() ? "" : " <-> ") + (f3.isEmpty() ? QString("") : f3);
         }
 
         m_pKDiff3Shell->setWindowTitle(caption.isEmpty() ? QString("KDiff3") : caption + QString(" - KDiff3"));
     }
 
     //initialize wheel tracking to zero
     m_iCumulativeWheelDelta = 0;
 
     m_bFinishMainInit = true; // call slotFinishMainInit after finishing the word wrap
     m_bLoadFiles = bLoadFiles;
     postRecalcWordWrap();
 }
 
 void KDiff3App::setHScrollBarRange()
 {
     int w1 = m_pDiffTextWindow1 != nullptr && m_pDiffTextWindow1->isVisible() ? m_pDiffTextWindow1->getMaxTextWidth() : 0;
     int w2 = m_pDiffTextWindow2 != nullptr && m_pDiffTextWindow2->isVisible() ? m_pDiffTextWindow2->getMaxTextWidth() : 0;
     int w3 = m_pDiffTextWindow3 != nullptr && m_pDiffTextWindow3->isVisible() ? m_pDiffTextWindow3->getMaxTextWidth() : 0;
 
     int wm = m_pMergeResultWindow != nullptr && m_pMergeResultWindow->isVisible() ? m_pMergeResultWindow->getMaxTextWidth() : 0;
 
     int v1 = m_pDiffTextWindow1 != nullptr && m_pDiffTextWindow1->isVisible() ? m_pDiffTextWindow1->getVisibleTextAreaWidth() : 0;
     int v2 = m_pDiffTextWindow2 != nullptr && m_pDiffTextWindow2->isVisible() ? m_pDiffTextWindow2->getVisibleTextAreaWidth() : 0;
     int v3 = m_pDiffTextWindow3 != nullptr && m_pDiffTextWindow3->isVisible() ? m_pDiffTextWindow3->getVisibleTextAreaWidth() : 0;
     int vm = m_pMergeResultWindow != nullptr && m_pMergeResultWindow->isVisible() ? m_pMergeResultWindow->getVisibleTextAreaWidth() : 0;
 
     // Find the minimum, but don't consider 0.
     int pageStep = 0;
     if((pageStep == 0 || pageStep > v1) && v1 > 0)
         pageStep = v1;
     if((pageStep == 0 || pageStep > v2) && v2 > 0)
         pageStep = v2;
     if((pageStep == 0 || pageStep > v3) && v3 > 0)
         pageStep = v3;
     if((pageStep == 0 || pageStep > vm) && vm > 0)
         pageStep = vm;
 
     int rangeMax = 0;
     if(w1 > v1 && w1 - v1 > rangeMax && v1 > 0)
         rangeMax = w1 - v1;
     if(w2 > v2 && w2 - v2 > rangeMax && v2 > 0)
         rangeMax = w2 - v2;
     if(w3 > v3 && w3 - v3 > rangeMax && v3 > 0)
         rangeMax = w3 - v3;
     if(wm > vm && wm - vm > rangeMax && vm > 0)
         rangeMax = wm - vm;
 
     m_pHScrollBar->setRange(0, rangeMax);
     m_pHScrollBar->setPageStep(pageStep);
 }
 
 void KDiff3App::resizeDiffTextWindowHeight(int newHeight)
 {
     m_DTWHeight = newHeight;
 
     m_pDiffVScrollBar->setRange(0, max2(0, m_neededLines + 1 - newHeight));
     m_pDiffVScrollBar->setPageStep(newHeight);
     m_pOverview->setRange(m_pDiffVScrollBar->value(), m_pDiffVScrollBar->pageStep());
 
     setHScrollBarRange();
 }
 
 void KDiff3App::resizeMergeResultWindow()
 {
     MergeResultWindow* p = m_pMergeResultWindow;
     m_pMergeVScrollBar->setRange(0, max2(0, p->getNofLines() - p->getNofVisibleLines()));
     m_pMergeVScrollBar->setPageStep(p->getNofVisibleLines());
 
     setHScrollBarRange();
 }
 
 void KDiff3App::scrollDiffTextWindow(int deltaX, int deltaY)
 {
     if(deltaY != 0)
     {
         m_pDiffVScrollBar->setValue(m_pDiffVScrollBar->value() + deltaY);
         m_pOverview->setRange(m_pDiffVScrollBar->value(), m_pDiffVScrollBar->pageStep());
     }
     if(deltaX != 0)
         m_pHScrollBar->QScrollBar::setValue(m_pHScrollBar->value() + deltaX);
 }
 
 void KDiff3App::scrollMergeResultWindow(int deltaX, int deltaY)
 {
     if(deltaY != 0)
         m_pMergeVScrollBar->setValue(m_pMergeVScrollBar->value() + deltaY);
     if(deltaX != 0)
         m_pHScrollBar->setValue(m_pHScrollBar->value() + deltaX);
 }
 
 void KDiff3App::setDiff3Line(int line)
 {
     m_pDiffVScrollBar->setValue(line);
 }
 
 void KDiff3App::sourceMask(int srcMask, int enabledMask)
 {
     chooseA->blockSignals(true);
     chooseB->blockSignals(true);
     chooseC->blockSignals(true);
     chooseA->setChecked((srcMask & 1) != 0);
     chooseB->setChecked((srcMask & 2) != 0);
     chooseC->setChecked((srcMask & 4) != 0);
     chooseA->blockSignals(false);
     chooseB->blockSignals(false);
     chooseC->blockSignals(false);
     chooseA->setEnabled((enabledMask & 1) != 0);
     chooseB->setEnabled((enabledMask & 2) != 0);
     chooseC->setEnabled((enabledMask & 4) != 0);
 }
 
 // Function uses setMinSize( sizeHint ) before adding the widget.
 // void addWidget(QBoxLayout* layout, QWidget* widget);
 template <class W, class L>
 void addWidget(L* layout, W* widget)
 {
     QSize s = widget->sizeHint();
     widget->setMinimumSize(QSize(max2(s.width(), 0), max2(s.height(), 0)));
     layout->addWidget(widget);
 }
 
 void KDiff3App::initView()
 {
     // set the main widget here
     if(m_pMainWidget != nullptr)
     {
         return;
         //delete m_pMainWidget;
     }
     m_pMainWidget = new QWidget(); // Contains vertical splitter and horiz scrollbar
     m_pMainSplitter->addWidget(m_pMainWidget);
     m_pMainWidget->setObjectName("MainWidget");
     QVBoxLayout* pVLayout = new QVBoxLayout(m_pMainWidget);
     pVLayout->setMargin(0);
     pVLayout->setSpacing(0);
 
     QSplitter* pVSplitter = new QSplitter();
     pVSplitter->setObjectName("VSplitter");
     pVSplitter->setOpaqueResize(false);
     pVSplitter->setOrientation(Qt::Vertical);
     pVLayout->addWidget(pVSplitter);
 
     QWidget* pDiffWindowFrame = new QWidget(); // Contains diff windows, overview and vert scrollbar
     pDiffWindowFrame->setObjectName("DiffWindowFrame");
     QHBoxLayout* pDiffHLayout = new QHBoxLayout(pDiffWindowFrame);
     pDiffHLayout->setMargin(0);
     pDiffHLayout->setSpacing(0);
     pVSplitter->addWidget(pDiffWindowFrame);
 
     m_pDiffWindowSplitter = new QSplitter();
     m_pDiffWindowSplitter->setObjectName("DiffWindowSplitter");
     m_pDiffWindowSplitter->setOpaqueResize(false);
 
     m_pDiffWindowSplitter->setOrientation(m_pOptions->m_bHorizDiffWindowSplitting ? Qt::Horizontal : Qt::Vertical);
     pDiffHLayout->addWidget(m_pDiffWindowSplitter);
 
     m_pOverview = new Overview(&m_pOptionDialog->m_options);
     m_pOverview->setObjectName("Overview");
     pDiffHLayout->addWidget(m_pOverview);
     connect(m_pOverview, SIGNAL(setLine(int)), this, SLOT(setDiff3Line(int)));
 
     m_pDiffVScrollBar = new QScrollBar(Qt::Vertical, pDiffWindowFrame);
     pDiffHLayout->addWidget(m_pDiffVScrollBar);
 
     m_pDiffTextWindowFrame1 = new DiffTextWindowFrame(m_pDiffWindowSplitter, statusBar(), &m_pOptionDialog->m_options, 1, &m_sd1);
     m_pDiffWindowSplitter->addWidget(m_pDiffTextWindowFrame1);
     m_pDiffTextWindowFrame2 = new DiffTextWindowFrame(m_pDiffWindowSplitter, statusBar(), &m_pOptionDialog->m_options, 2, &m_sd2);
     m_pDiffWindowSplitter->addWidget(m_pDiffTextWindowFrame2);
     m_pDiffTextWindowFrame3 = new DiffTextWindowFrame(m_pDiffWindowSplitter, statusBar(), &m_pOptionDialog->m_options, 3, &m_sd3);
     m_pDiffWindowSplitter->addWidget(m_pDiffTextWindowFrame3);
     m_pDiffTextWindow1 = m_pDiffTextWindowFrame1->getDiffTextWindow();
     m_pDiffTextWindow2 = m_pDiffTextWindowFrame2->getDiffTextWindow();
     m_pDiffTextWindow3 = m_pDiffTextWindowFrame3->getDiffTextWindow();
     connect(m_pDiffTextWindowFrame1, SIGNAL(fileNameChanged(const QString&, int)), this, SLOT(slotFileNameChanged(const QString&, int)));
     connect(m_pDiffTextWindowFrame2, SIGNAL(fileNameChanged(const QString&, int)), this, SLOT(slotFileNameChanged(const QString&, int)));
     connect(m_pDiffTextWindowFrame3, SIGNAL(fileNameChanged(const QString&, int)), this, SLOT(slotFileNameChanged(const QString&, int)));
 
     connect(m_pDiffTextWindowFrame1, SIGNAL(encodingChanged(QTextCodec*)), this, SLOT(slotEncodingChangedA(QTextCodec*)));
     connect(m_pDiffTextWindowFrame2, SIGNAL(encodingChanged(QTextCodec*)), this, SLOT(slotEncodingChangedB(QTextCodec*)));
     connect(m_pDiffTextWindowFrame3, SIGNAL(encodingChanged(QTextCodec*)), this, SLOT(slotEncodingChangedC(QTextCodec*)));
 
     // Merge window
     m_pMergeWindowFrame = new QWidget(pVSplitter);
     m_pMergeWindowFrame->setObjectName("MergeWindowFrame");
     pVSplitter->addWidget(m_pMergeWindowFrame);
     QHBoxLayout* pMergeHLayout = new QHBoxLayout(m_pMergeWindowFrame);
     pMergeHLayout->setMargin(0);
     pMergeHLayout->setSpacing(0);
     QVBoxLayout* pMergeVLayout = new QVBoxLayout();
     pMergeHLayout->addLayout(pMergeVLayout, 1);
 
     m_pMergeResultWindowTitle = new WindowTitleWidget(&m_pOptionDialog->m_options);
     pMergeVLayout->addWidget(m_pMergeResultWindowTitle);
 
     m_pMergeResultWindow = new MergeResultWindow(m_pMergeWindowFrame, &m_pOptionDialog->m_options, statusBar());
     pMergeVLayout->addWidget(m_pMergeResultWindow, 1);
 
     m_pMergeVScrollBar = new QScrollBar(Qt::Vertical, m_pMergeWindowFrame);
     pMergeHLayout->addWidget(m_pMergeVScrollBar);
 
     m_pMainSplitter->addWidget(m_pMainWidget);
 
     autoAdvance->setEnabled(true);
 
     QList<int> sizes = pVSplitter->sizes();
     int total = sizes[0] + sizes[1];
     if(total < 10)
         total = 100;
     sizes[0] = total / 2;
     sizes[1] = total / 2;
     pVSplitter->setSizes(sizes);
 
     QList<int> hSizes;
     hSizes << 1 << 1 << 1;
     m_pDiffWindowSplitter->setSizes(hSizes);
 
     m_pMergeResultWindow->installEventFilter(this);                      // for Cut/Copy/Paste-shortcuts
     m_pMergeResultWindow->installEventFilter(m_pMergeResultWindowTitle); // for focus tracking
 
     QHBoxLayout* pHScrollBarLayout = new QHBoxLayout();
     pVLayout->addLayout(pHScrollBarLayout);
     m_pHScrollBar = new ReversibleScrollBar(Qt::Horizontal, &m_pOptions->m_bRightToLeftLanguage);
     pHScrollBarLayout->addWidget(m_pHScrollBar);
     m_pCornerWidget = new QWidget(m_pMainWidget);
     pHScrollBarLayout->addWidget(m_pCornerWidget);
 
     connect(m_pDiffVScrollBar, &QScrollBar::valueChanged, m_pOverview, &Overview::setFirstLine);
     connect(m_pDiffVScrollBar, SIGNAL(valueChanged(int)), m_pDiffTextWindow1, SLOT(setFirstLine(int)));
     connect(m_pHScrollBar, SIGNAL(valueChanged2(int)), m_pDiffTextWindow1, SLOT(setHorizScrollOffset(int)));
     connect(m_pDiffTextWindow1, SIGNAL(newSelection()), this, SLOT(slotSelectionStart()));
     connect(m_pDiffTextWindow1, SIGNAL(selectionEnd()), this, SLOT(slotSelectionEnd()));
     connect(m_pDiffTextWindow1, SIGNAL(scroll(int, int)), this, SLOT(scrollDiffTextWindow(int, int)));
     m_pDiffTextWindow1->installEventFilter(this);
 
     connect(m_pDiffVScrollBar, SIGNAL(valueChanged(int)), m_pDiffTextWindow2, SLOT(setFirstLine(int)));
     connect(m_pHScrollBar, SIGNAL(valueChanged2(int)), m_pDiffTextWindow2, SLOT(setHorizScrollOffset(int)));
     connect(m_pDiffTextWindow2, SIGNAL(newSelection()), this, SLOT(slotSelectionStart()));
     connect(m_pDiffTextWindow2, SIGNAL(selectionEnd()), this, SLOT(slotSelectionEnd()));
     connect(m_pDiffTextWindow2, SIGNAL(scroll(int, int)), this, SLOT(scrollDiffTextWindow(int, int)));
     m_pDiffTextWindow2->installEventFilter(this);
 
     connect(m_pDiffVScrollBar, SIGNAL(valueChanged(int)), m_pDiffTextWindow3, SLOT(setFirstLine(int)));
     connect(m_pHScrollBar, SIGNAL(valueChanged2(int)), m_pDiffTextWindow3, SLOT(setHorizScrollOffset(int)));
     connect(m_pDiffTextWindow3, SIGNAL(newSelection()), this, SLOT(slotSelectionStart()));
     connect(m_pDiffTextWindow3, SIGNAL(selectionEnd()), this, SLOT(slotSelectionEnd()));
     connect(m_pDiffTextWindow3, SIGNAL(scroll(int, int)), this, SLOT(scrollDiffTextWindow(int, int)));
     m_pDiffTextWindow3->installEventFilter(this);
 
     MergeResultWindow* p = m_pMergeResultWindow;
     connect(m_pMergeVScrollBar, &QScrollBar::valueChanged, p, &MergeResultWindow::setFirstLine);
 
     connect(m_pHScrollBar, &ReversibleScrollBar::valueChanged2, p, &MergeResultWindow::setHorizScrollOffset);
     connect(p, SIGNAL(scroll(int, int)), this, SLOT(scrollMergeResultWindow(int, int)));
     connect(p, SIGNAL(sourceMask(int, int)), this, SLOT(sourceMask(int, int)));
     connect(p, SIGNAL(resizeSignal()), this, SLOT(resizeMergeResultWindow()));
     connect(p, SIGNAL(selectionEnd()), this, SLOT(slotSelectionEnd()));
     connect(p, SIGNAL(newSelection()), this, SLOT(slotSelectionStart()));
     connect(p, SIGNAL(modifiedChanged(bool)), this, SLOT(slotOutputModified(bool)));
     connect(p, &MergeResultWindow::modifiedChanged, m_pMergeResultWindowTitle, &WindowTitleWidget::slotSetModified);
     connect(p, SIGNAL(updateAvailabilities()), this, SLOT(slotUpdateAvailabilities()));
     connect(p, SIGNAL(showPopupMenu(const QPoint&)), this, SLOT(showPopupMenu(const QPoint&)));
     connect(p, SIGNAL(noRelevantChangesDetected()), this, SLOT(slotNoRelevantChangesDetected()));
     sourceMask(0, 0);
 
     connect(p, SIGNAL(setFastSelectorRange(int, int)), m_pDiffTextWindow1, SLOT(setFastSelectorRange(int, int)));
     connect(p, SIGNAL(setFastSelectorRange(int, int)), m_pDiffTextWindow2, SLOT(setFastSelectorRange(int, int)));
     connect(p, SIGNAL(setFastSelectorRange(int, int)), m_pDiffTextWindow3, SLOT(setFastSelectorRange(int, int)));
     connect(m_pDiffTextWindow1, SIGNAL(setFastSelectorLine(int)), p, SLOT(slotSetFastSelectorLine(int)));
     connect(m_pDiffTextWindow2, SIGNAL(setFastSelectorLine(int)), p, SLOT(slotSetFastSelectorLine(int)));
     connect(m_pDiffTextWindow3, SIGNAL(setFastSelectorLine(int)), p, SLOT(slotSetFastSelectorLine(int)));
     connect(m_pDiffTextWindow1, SIGNAL(gotFocus()), p, SLOT(updateSourceMask()));
     connect(m_pDiffTextWindow2, SIGNAL(gotFocus()), p, SLOT(updateSourceMask()));
     connect(m_pDiffTextWindow3, SIGNAL(gotFocus()), p, SLOT(updateSourceMask()));
     connect(m_pDirectoryMergeInfo, SIGNAL(gotFocus()), p, SLOT(updateSourceMask()));
 
     connect(m_pDiffTextWindow1, SIGNAL(resizeHeightChangedSignal(int)), this, SLOT(resizeDiffTextWindowHeight(int)));
     // The following two connects cause the wordwrap to be recalced thrice, just to make sure. Better than forgetting one.
     connect(m_pDiffTextWindow1, SIGNAL(resizeWidthChangedSignal(int)), this, SLOT(postRecalcWordWrap()));
     connect(m_pDiffTextWindow2, SIGNAL(resizeWidthChangedSignal(int)), this, SLOT(postRecalcWordWrap()));
     connect(m_pDiffTextWindow3, SIGNAL(resizeWidthChangedSignal(int)), this, SLOT(postRecalcWordWrap()));
 
     m_pDiffTextWindow1->setFocus();
     m_pMainWidget->setMinimumSize(50, 50);
     m_pCornerWidget->setFixedSize(m_pDiffVScrollBar->width(), m_pHScrollBar->height());
     showWindowA->setChecked(true);
     showWindowB->setChecked(true);
     showWindowC->setChecked(true);
 }
 
 static int calcManualDiffFirstDiff3LineIdx(const Diff3LineVector& d3lv, const ManualDiffHelpEntry& mdhe)
 {
     int i;
     for(i = 0; i < d3lv.size(); ++i)
     {
         const Diff3Line& d3l = *d3lv[i];
         if((mdhe.lineA1 >= 0 && mdhe.lineA1 == d3l.lineA) ||
            (mdhe.lineB1 >= 0 && mdhe.lineB1 == d3l.lineB) ||
            (mdhe.lineC1 >= 0 && mdhe.lineC1 == d3l.lineC))
             return i;
     }
     return -1;
 }
 
 // called after word wrap is complete
 void KDiff3App::slotFinishMainInit()
 {
     setHScrollBarRange();
 
     int newHeight = m_pDiffTextWindow1->getNofVisibleLines();
     /*int newWidth  = m_pDiffTextWindow1->getNofVisibleColumns();*/
     m_DTWHeight = newHeight;
 
     m_pDiffVScrollBar->setRange(0, max2(0, m_neededLines + 1 - newHeight));
     m_pDiffVScrollBar->setPageStep(newHeight);
     m_pOverview->setRange(m_pDiffVScrollBar->value(), m_pDiffVScrollBar->pageStep());
 
     int d3l = -1;
     if(!m_manualDiffHelpList.empty())
         d3l = calcManualDiffFirstDiff3LineIdx(m_diff3LineVector, m_manualDiffHelpList.front());
     if(d3l >= 0 && m_pDiffTextWindow1)
     {
         int line = m_pDiffTextWindow1->convertDiff3LineIdxToLine(d3l);
         m_pDiffVScrollBar->setValue(max2(0, line - 1));
     }
     else
     {
         m_pMergeResultWindow->slotGoTop();
         if(!m_outputFilename.isEmpty() && !m_pMergeResultWindow->isUnsolvedConflictAtCurrent())
             m_pMergeResultWindow->slotGoNextUnsolvedConflict();
     }
 
     if(m_pCornerWidget)
         m_pCornerWidget->setFixedSize(m_pDiffVScrollBar->width(), m_pHScrollBar->height());
 
     slotUpdateAvailabilities();
     setUpdatesEnabled(true);
     // Workaround for a Qt-bug
     QList<QTreeView*> treeViews = findChildren<QTreeView*>();
     foreach(QTreeView* pTreeView, treeViews)
     {
         pTreeView->setUpdatesEnabled(true);
     }
 
     bool bVisibleMergeResultWindow = !m_outputFilename.isEmpty();
     TotalDiffStatus* pTotalDiffStatus = &m_totalDiffStatus;
 
     if(m_bLoadFiles)
     {
 
         if(bVisibleMergeResultWindow)
             m_pMergeResultWindow->showNrOfConflicts();
         else if(
             // Avoid showing this message during startup without parameters.
             !(m_sd1.getAliasName().isEmpty() && m_sd2.getAliasName().isEmpty() && m_sd3.getAliasName().isEmpty()) &&
             (m_sd1.isValid() && m_sd2.isValid() && m_sd3.isValid()))
         {
             QString totalInfo;
             if(pTotalDiffStatus->bBinaryAEqB && pTotalDiffStatus->bBinaryAEqC)
                 totalInfo += i18n("All input files are binary equal.");
             else if(pTotalDiffStatus->bTextAEqB && pTotalDiffStatus->bTextAEqC)
                 totalInfo += i18n("All input files contain the same text, but are not binary equal.");
             else
             {
                 if(pTotalDiffStatus->bBinaryAEqB)
                     totalInfo += i18n("Files %1 and %2 are binary equal.\n", QString("A"), QString("B"));
                 else if(pTotalDiffStatus->bTextAEqB)
                     totalInfo += i18n("Files %1 and %2 have equal text, but are not binary equal. \n", QString("A"), QString("B"));
                 if(pTotalDiffStatus->bBinaryAEqC)
                     totalInfo += i18n("Files %1 and %2 are binary equal.\n", QString("A"), QString("C"));
                 else if(pTotalDiffStatus->bTextAEqC)
                     totalInfo += i18n("Files %1 and %2 have equal text, but are not binary equal. \n", QString("A"), QString("C"));
                 if(pTotalDiffStatus->bBinaryBEqC)
                     totalInfo += i18n("Files %1 and %2 are binary equal.\n", QString("B"), QString("C"));
                 else if(pTotalDiffStatus->bTextBEqC)
                     totalInfo += i18n("Files %1 and %2 have equal text, but are not binary equal. \n", QString("B"), QString("C"));
             }
 
             if(!totalInfo.isEmpty())
                 KMessageBox::information(this, totalInfo);
         }
 
         if(bVisibleMergeResultWindow && (!m_sd1.isText() || !m_sd2.isText() || !m_sd3.isText()))
         {
             KMessageBox::information(this, i18n(
                                                "Some input files do not seem to be pure text files.\n"
                                                "Note that the KDiff3 merge was not meant for binary data.\n"
                                                "Continue at your own risk."));
         }
         if(m_sd1.isIncompleteConversion() || m_sd2.isIncompleteConversion() || m_sd3.isIncompleteConversion())
         {
             QString files;
             if(m_sd1.isIncompleteConversion())
                 files += "A";
             if(m_sd2.isIncompleteConversion())
                 files += files.isEmpty() ? "B" : ", B";
             if(m_sd3.isIncompleteConversion())
                 files += files.isEmpty() ? "C" : ", C";
 
             KMessageBox::information(this, i18n("Some input characters could not be converted to valid unicode.\n"
                                                 "You might be using the wrong codec. (e.g. UTF-8 for non UTF-8 files).\n"
                                                 "Do not save the result if unsure. Continue at your own risk.\n"
                                                 "Affected input files are in %1.", files));
         }
     }
 
     if(bVisibleMergeResultWindow && m_pMergeResultWindow)
     {
         m_pMergeResultWindow->setFocus();
     }
     else if(m_pDiffTextWindow1)
     {
         m_pDiffTextWindow1->setFocus();
     }
 }
 
 void KDiff3App::resizeEvent(QResizeEvent* e)
 {
     QSplitter::resizeEvent(e);
     if(m_pCornerWidget)
         m_pCornerWidget->setFixedSize(m_pDiffVScrollBar->width(), m_pHScrollBar->height());
 }
 
 void KDiff3App::childEvent(QChildEvent* c)
 {
     // Workaround for a bug in several Qt versions. When a child is added to QSplitter, don't
     // add it to the splitter if it is a window.
     if(c->child()->isWidgetType())
     {
         QWidget* w = static_cast<QWidget*>(c->child());
         if(w->isWindow())
             return;
     }
     QSplitter::childEvent(c);
 }
 
 bool KDiff3App::eventFilter(QObject* o, QEvent* e)
 {
     if(o == m_pMergeResultWindow)
     {
         if(e->type() == QEvent::KeyPress)
         { // key press
             QKeyEvent* k = (QKeyEvent*)e;
             if(k->key() == Qt::Key_Insert && (k->QInputEvent::modifiers() & Qt::ControlModifier) != 0)
             {
                 slotEditCopy();
                 return true;
             }
             if(k->key() == Qt::Key_Insert && (k->QInputEvent::modifiers() & Qt::ShiftModifier) != 0)
             {
                 slotEditPaste();
                 return true;
             }
             if(k->key() == Qt::Key_Delete && (k->QInputEvent::modifiers() & Qt::ShiftModifier) != 0)
             {
                 slotEditCut();
                 return true;
             }
             if(k->key() == Qt::Key_Escape && m_pKDiff3Shell && m_pOptions->m_bEscapeKeyQuits)
             {
                 m_pKDiff3Shell->close();
                 return true;
             }
         }
         return QSplitter::eventFilter(o, e); // standard event processing
     }
 
     if(e->type() == QEvent::KeyPress) // key press
     {
         QKeyEvent* k = (QKeyEvent*)e;
         if(k->key() == Qt::Key_Escape && m_pKDiff3Shell && m_pOptions->m_bEscapeKeyQuits)
         {
             m_pKDiff3Shell->close();
             return true;
         }
 
         bool bCtrl = (k->QInputEvent::modifiers() & Qt::ControlModifier) != 0;
         if(k->key() == Qt::Key_Insert && bCtrl)
         {
             slotEditCopy();
             return true;
         }
         if(k->key() == Qt::Key_Insert && (k->QInputEvent::modifiers() & Qt::ShiftModifier) != 0)
         {
             slotEditPaste();
             return true;
         }
         int deltaX = 0;
         int deltaY = 0;
         int pageSize = m_DTWHeight;
         switch(k->key())
         {
         case Qt::Key_Down:
             if(!bCtrl) ++deltaY;
             break;
         case Qt::Key_Up:
             if(!bCtrl) --deltaY;
             break;
         case Qt::Key_PageDown:
             if(!bCtrl) deltaY += pageSize;
             break;
         case Qt::Key_PageUp:
             if(!bCtrl) deltaY -= pageSize;
             break;
         case Qt::Key_Left:
             if(!bCtrl) --deltaX;
             break;
         case Qt::Key_Right:
             if(!bCtrl) ++deltaX;
             break;
         case Qt::Key_Home:
             if(bCtrl)
                 m_pDiffVScrollBar->setValue(0);
             else
                 m_pHScrollBar->setValue(0);
             break;
         case Qt::Key_End:
             if(bCtrl)
                 m_pDiffVScrollBar->setValue(m_pDiffVScrollBar->maximum());
             else
                 m_pHScrollBar->setValue(m_pHScrollBar->maximum());
             break;
         default:
             break;
         }
 
         scrollDiffTextWindow(deltaX, deltaY);
 
         return true; // eat event
     }
     else if(e->type() == QEvent::Wheel) // wheel event
     {
         QWheelEvent* w = (QWheelEvent*)e;
         w->accept();
 
         int deltaX = 0;
 
         int d = w->delta();
 
         //As per QT documentation, some mice/OS combos send delta values
         //less than 120 units(15 degrees)
         d = d + m_iCumulativeWheelDelta;
         if(d > -120 && d < 120)
         {
             //not enough for a full step in either direction, add it up
             //to use on a successive call
             m_iCumulativeWheelDelta = d;
         }
         else
         {
             //reset cumulative tracking of the wheel since we have enough
             //for a 15 degree movement
             m_iCumulativeWheelDelta = 0;
         }
 
         int deltaY = -d / 120 * QApplication::wheelScrollLines();
 
         scrollDiffTextWindow(deltaX, deltaY);
         return true;
     }
     else if(e->type() == QEvent::Drop)
     {
         QDropEvent* pDropEvent = static_cast<QDropEvent*>(e);
         pDropEvent->accept();
 
         if(pDropEvent->mimeData()->hasUrls())
         {
             QList<QUrl> urlList = pDropEvent->mimeData()->urls();
             if(canContinue() && !urlList.isEmpty())
             {
                 raise();
                 QString filename = urlList.first().toLocalFile();
                 if(o == m_pDiffTextWindow1)
                     m_sd1.setFilename(filename);
                 else if(o == m_pDiffTextWindow2)
                     m_sd2.setFilename(filename);
                 else if(o == m_pDiffTextWindow3)
                     m_sd3.setFilename(filename);
                 mainInit();
             }
         }
         else if(pDropEvent->mimeData()->hasText())
         {
             QString text = pDropEvent->mimeData()->text();
             if(canContinue())
             {
                 QStringList errors;
 
                 raise();
                 if(o == m_pDiffTextWindow1)
                     errors = m_sd1.setData(text);
                 else if(o == m_pDiffTextWindow2)
                     errors = m_sd2.setData(text);
                 else if(o == m_pDiffTextWindow3)
                     errors = m_sd3.setData(text);
                 foreach(const QString& error, errors)
                 {
                     KMessageBox::error(m_pOptionDialog, error);
                 }
                 mainInit();
             }
         }
 
         return true;
     }
     return QSplitter::eventFilter(o, e); // standard event processing
 }
 
 void KDiff3App::slotFileOpen()
 {
     if(!canContinue()) return;
 
     if(m_pDirectoryMergeWindow->isDirectoryMergeInProgress())
     {
         int result = KMessageBox::warningYesNo(this,
                                                i18n("You are currently doing a directory merge. Are you sure, you want to abort?"),
                                                i18n("Warning"),
                                                KGuiItem(i18n("Abort")),
                                                KGuiItem(i18n("Continue Merging")));
         if(result != KMessageBox::Yes)
             return;
     }
 
     slotStatusMsg(i18n("Opening files..."));
 
     for(;;)
     {
         OpenDialog d(this,
                      QDir::toNativeSeparators(m_bDirCompare ? m_pDirectoryMergeWindow->getDirNameA() : m_sd1.isFromBuffer() ? QString("") : m_sd1.getAliasName()),
                      QDir::toNativeSeparators(m_bDirCompare ? m_pDirectoryMergeWindow->getDirNameB() : m_sd2.isFromBuffer() ? QString("") : m_sd2.getAliasName()),
                      QDir::toNativeSeparators(m_bDirCompare ? m_pDirectoryMergeWindow->getDirNameC() : m_sd3.isFromBuffer() ? QString("") : m_sd3.getAliasName()),
                      m_bDirCompare ? !m_pDirectoryMergeWindow->getDirNameDest().isEmpty() : !m_outputFilename.isEmpty(),
                      QDir::toNativeSeparators(m_bDirCompare ? m_pDirectoryMergeWindow->getDirNameDest() : m_bDefaultFilename ? QString("") : m_outputFilename),
                      SLOT(slotConfigure()), &m_pOptionDialog->m_options);
         int status = d.exec();
         if(status == QDialog::Accepted)
         {
             m_sd1.setFilename(d.m_pLineA->currentText());
             m_sd2.setFilename(d.m_pLineB->currentText());
             m_sd3.setFilename(d.m_pLineC->currentText());
 
             if(d.m_pMerge->isChecked())
             {
                 if(d.m_pLineOut->currentText().isEmpty())
                 {
                     m_outputFilename = "unnamed.txt";
                     m_bDefaultFilename = true;
                 }
                 else
                 {
                     m_outputFilename = d.m_pLineOut->currentText();
                     m_bDefaultFilename = false;
                 }
             }
             else
                 m_outputFilename = "";
 
             bool bSuccess = improveFilenames(false);
             if(!bSuccess)
                 continue;
 
             if(m_bDirCompare)
             {
                 m_pDirectoryMergeSplitter->show();
                 if(m_pMainWidget != nullptr)
                 {
                     m_pMainWidget->hide();
                 }
                 break;
             }
             else
             {
                 m_pDirectoryMergeSplitter->hide();
                 mainInit();
 
                 if((!m_sd1.isEmpty() && !m_sd1.hasData()) ||
                    (!m_sd2.isEmpty() && !m_sd2.hasData()) ||
                    (!m_sd3.isEmpty() && !m_sd3.hasData()))
                 {
                     QString text(i18n("Opening of these files failed:"));
                     text += "\n\n";
                     if(!m_sd1.isEmpty() && !m_sd1.hasData())
                         text += " - " + m_sd1.getAliasName() + "\n";
                     if(!m_sd2.isEmpty() && !m_sd2.hasData())
                         text += " - " + m_sd2.getAliasName() + "\n";
                     if(!m_sd3.isEmpty() && !m_sd3.hasData())
                         text += " - " + m_sd3.getAliasName() + "\n";
 
                     KMessageBox::sorry(this, text, i18n("File open error"));
                     continue;
                 }
             }
         }
         break;
     }
 
     slotUpdateAvailabilities();
     slotStatusMsg(i18n("Ready."));
 }
 
 void KDiff3App::slotFileOpen2(QString fn1, QString fn2, QString fn3, QString ofn,
                               QString an1, QString an2, QString an3, TotalDiffStatus* pTotalDiffStatus)
 {
     if(!canContinue()) return;
 
     if(fn1 == "" && fn2 == "" && fn3 == "" && ofn == "" && m_pMainWidget != nullptr)
     {
         m_pMainWidget->hide();
         return;
     }
 
     slotStatusMsg(i18n("Opening files..."));
 
     m_sd1.setFilename(fn1);
     m_sd2.setFilename(fn2);
     m_sd3.setFilename(fn3);
 
     m_sd1.setAliasName(an1);
     m_sd2.setAliasName(an2);
     m_sd3.setAliasName(an3);
 
     if(!ofn.isEmpty())
     {
         m_outputFilename = ofn;
         m_bDefaultFilename = false;
     }
     else
     {
         m_outputFilename = "";
         m_bDefaultFilename = true;
     }
 
     bool bDirCompare = m_bDirCompare;
     improveFilenames(true); // Create new window for KDiff3 for directory comparison.
 
     if(m_bDirCompare)
     {
     }
     else
     {
         m_bDirCompare = bDirCompare; // Don't allow this to change here.
         mainInit(pTotalDiffStatus);
 
         if(pTotalDiffStatus != nullptr)
             return;
 
         if((!m_sd1.isEmpty() && !m_sd1.hasData()) ||
            (!m_sd2.isEmpty() && !m_sd2.hasData()) ||
            (!m_sd3.isEmpty() && !m_sd3.hasData()))
         {
             QString text(i18n("Opening of these files failed:"));
             text += "\n\n";
             if(!m_sd1.isEmpty() && !m_sd1.hasData())
                 text += " - " + m_sd1.getAliasName() + "\n";
             if(!m_sd2.isEmpty() && !m_sd2.hasData())
                 text += " - " + m_sd2.getAliasName() + "\n";
             if(!m_sd3.isEmpty() && !m_sd3.hasData())
                 text += " - " + m_sd3.getAliasName() + "\n";
 
             KMessageBox::sorry(this, text, i18n("File open error"));
         }
         else
         {
             if(m_pDirectoryMergeWindow != nullptr && m_pDirectoryMergeWindow->isVisible() && !dirShowBoth->isChecked())
             {
                 slotDirViewToggle();
             }
         }
     }
     slotStatusMsg(i18n("Ready."));
 }
 
 void KDiff3App::slotFileNameChanged(const QString& fileName, int winIdx)
 {
     QString fn1 = m_sd1.getFilename();
     QString an1 = m_sd1.getAliasName();
     QString fn2 = m_sd2.getFilename();
     QString an2 = m_sd2.getAliasName();
     QString fn3 = m_sd3.getFilename();
     QString an3 = m_sd3.getAliasName();
     if(winIdx == 1) {
         fn1 = fileName;
         an1 = "";
     }
     if(winIdx == 2) {
         fn2 = fileName;
         an2 = "";
     }
     if(winIdx == 3) {
         fn3 = fileName;
         an3 = "";
     }
 
     slotFileOpen2(fn1, fn2, fn3, m_outputFilename, an1, an2, an3, nullptr);
 }
 
 void KDiff3App::slotEditCut()
 {
     slotStatusMsg(i18n("Cutting selection..."));
 
     QString s;
     if(m_pMergeResultWindow != nullptr)
     {
         s = m_pMergeResultWindow->getSelection();
         m_pMergeResultWindow->deleteSelection();
 
         m_pMergeResultWindow->update();
     }
 
     if(!s.isEmpty())
     {
         QApplication::clipboard()->setText(s, QClipboard::Clipboard);
     }
 
     slotStatusMsg(i18n("Ready."));
 }
 
 void KDiff3App::slotEditCopy()
 {
     slotStatusMsg(i18n("Copying selection to clipboard..."));
     QString s;
     if(m_pDiffTextWindow1 != nullptr) s = m_pDiffTextWindow1->getSelection();
     if(s.isEmpty() && m_pDiffTextWindow2 != nullptr) s = m_pDiffTextWindow2->getSelection();
     if(s.isEmpty() && m_pDiffTextWindow3 != nullptr) s = m_pDiffTextWindow3->getSelection();
     if(s.isEmpty() && m_pMergeResultWindow != nullptr) s = m_pMergeResultWindow->getSelection();
     if(!s.isEmpty())
     {
         QApplication::clipboard()->setText(s, QClipboard::Clipboard);
     }
 
     slotStatusMsg(i18n("Ready."));
 }
 
 void KDiff3App::slotEditPaste()
 {
     slotStatusMsg(i18n("Inserting clipboard contents..."));
 
     if(m_pMergeResultWindow != nullptr && m_pMergeResultWindow->isVisible())
     {
         m_pMergeResultWindow->pasteClipboard(false);
     }
     else if(canContinue())
     {
         QStringList errors;
         bool do_init = false;
 
         if(m_pDiffTextWindow1->hasFocus())
         {
             errors = m_sd1.setData(QApplication::clipboard()->text(QClipboard::Clipboard));
             do_init = true;
         }
         else if(m_pDiffTextWindow2->hasFocus())
         {
             errors = m_sd2.setData(QApplication::clipboard()->text(QClipboard::Clipboard));
             do_init = true;
         }
         else if(m_pDiffTextWindow3->hasFocus())
         {
             errors = m_sd3.setData(QApplication::clipboard()->text(QClipboard::Clipboard));
             do_init = true;
         }
 
         foreach(const QString& error, errors)
         {
             KMessageBox::error(m_pOptionDialog, error);
         }
 
         if(do_init)
         {
             mainInit();
         }
     }
 
     slotStatusMsg(i18n("Ready."));
 }
 
 void KDiff3App::slotEditSelectAll()
 {
     LineRef l = 0;
     int p = 0; // needed as dummy return values
     if(m_pMergeResultWindow && m_pMergeResultWindow->hasFocus()) {
         m_pMergeResultWindow->setSelection(0, 0, m_pMergeResultWindow->getNofLines(), 0);
     }
     else if(m_pDiffTextWindow1 && m_pDiffTextWindow1->hasFocus())
     {
         m_pDiffTextWindow1->setSelection(0, 0, m_pDiffTextWindow1->getNofLines(), 0, l, p);
     }
     else if(m_pDiffTextWindow2 && m_pDiffTextWindow2->hasFocus())
     {
         m_pDiffTextWindow2->setSelection(0, 0, m_pDiffTextWindow2->getNofLines(), 0, l, p);
     }
     else if(m_pDiffTextWindow3 && m_pDiffTextWindow3->hasFocus())
     {
         m_pDiffTextWindow3->setSelection(0, 0, m_pDiffTextWindow3->getNofLines(), 0, l, p);
     }
 
     slotStatusMsg(i18n("Ready."));
 }
 
 void KDiff3App::slotGoCurrent()
 {
     if(m_pMergeResultWindow) m_pMergeResultWindow->slotGoCurrent();
 }
 void KDiff3App::slotGoTop()
 {
     if(m_pMergeResultWindow) m_pMergeResultWindow->slotGoTop();
 }
 void KDiff3App::slotGoBottom()
 {
     if(m_pMergeResultWindow) m_pMergeResultWindow->slotGoBottom();
 }
 void KDiff3App::slotGoPrevUnsolvedConflict()
 {
     if(m_pMergeResultWindow) m_pMergeResultWindow->slotGoPrevUnsolvedConflict();
 }
 void KDiff3App::slotGoNextUnsolvedConflict()
 {
     m_bTimerBlock = false;
     if(m_pMergeResultWindow) m_pMergeResultWindow->slotGoNextUnsolvedConflict();
 }
 void KDiff3App::slotGoPrevConflict()
 {
     if(m_pMergeResultWindow) m_pMergeResultWindow->slotGoPrevConflict();
 }
 void KDiff3App::slotGoNextConflict()
 {
     m_bTimerBlock = false;
     if(m_pMergeResultWindow) m_pMergeResultWindow->slotGoNextConflict();
 }
 void KDiff3App::slotGoPrevDelta()
 {
     if(m_pMergeResultWindow) m_pMergeResultWindow->slotGoPrevDelta();
 }
 void KDiff3App::slotGoNextDelta()
 {
     if(m_pMergeResultWindow) m_pMergeResultWindow->slotGoNextDelta();
 }
 
 void KDiff3App::choose(int choice)
 {
     if(!m_bTimerBlock)
     {
         if(m_pDirectoryMergeWindow && m_pDirectoryMergeWindow->hasFocus())
         {
             if(choice == A) m_pDirectoryMergeWindow->slotCurrentChooseA();
             if(choice == B) m_pDirectoryMergeWindow->slotCurrentChooseB();
             if(choice == C) m_pDirectoryMergeWindow->slotCurrentChooseC();
 
             chooseA->setChecked(false);
             chooseB->setChecked(false);
             chooseC->setChecked(false);
         }
         else if(m_pMergeResultWindow)
         {
             m_pMergeResultWindow->choose(choice);
             if(autoAdvance->isChecked())
             {
                 m_bTimerBlock = true;
                 QTimer::singleShot(m_pOptions->m_autoAdvanceDelay, this, SLOT(slotGoNextUnsolvedConflict()));
             }
         }
     }
 }
 
 void KDiff3App::slotChooseA() { choose(A); }
 void KDiff3App::slotChooseB() { choose(B); }
 void KDiff3App::slotChooseC() { choose(C); }
 
 // bConflictsOnly automatically choose for conflicts only (true) or for everywhere
 static void mergeChooseGlobal(MergeResultWindow* pMRW, int selector, bool bConflictsOnly, bool bWhiteSpaceOnly)
 {
     if(pMRW)
     {
         pMRW->chooseGlobal(selector, bConflictsOnly, bWhiteSpaceOnly);
     }
 }
 
 void KDiff3App::slotChooseAEverywhere() { mergeChooseGlobal(m_pMergeResultWindow, A, false, false); }
 void KDiff3App::slotChooseBEverywhere() { mergeChooseGlobal(m_pMergeResultWindow, B, false, false); }
 void KDiff3App::slotChooseCEverywhere() { mergeChooseGlobal(m_pMergeResultWindow, C, false, false); }
 void KDiff3App::slotChooseAForUnsolvedConflicts() { mergeChooseGlobal(m_pMergeResultWindow, A, true, false); }
 void KDiff3App::slotChooseBForUnsolvedConflicts() { mergeChooseGlobal(m_pMergeResultWindow, B, true, false); }
 void KDiff3App::slotChooseCForUnsolvedConflicts() { mergeChooseGlobal(m_pMergeResultWindow, C, true, false); }
 void KDiff3App::slotChooseAForUnsolvedWhiteSpaceConflicts() { mergeChooseGlobal(m_pMergeResultWindow, A, true, true); }
 void KDiff3App::slotChooseBForUnsolvedWhiteSpaceConflicts() { mergeChooseGlobal(m_pMergeResultWindow, B, true, true); }
 void KDiff3App::slotChooseCForUnsolvedWhiteSpaceConflicts() { mergeChooseGlobal(m_pMergeResultWindow, C, true, true); }
 
 void KDiff3App::slotAutoSolve()
 {
     if(m_pMergeResultWindow)
     {
         m_pMergeResultWindow->slotAutoSolve();
         // m_pMergeWindowFrame->show(); incompatible with bPreserveCarriageReturn
         m_pMergeResultWindow->showNrOfConflicts();
         slotUpdateAvailabilities();
     }
 }
 
 void KDiff3App::slotUnsolve()
 {
     if(m_pMergeResultWindow)
     {
         m_pMergeResultWindow->slotUnsolve();
     }
 }
 
 void KDiff3App::slotMergeHistory()
 {
     if(m_pMergeResultWindow)
     {
         m_pMergeResultWindow->slotMergeHistory();
     }
 }
 
 void KDiff3App::slotRegExpAutoMerge()
 {
     if(m_pMergeResultWindow)
     {
         m_pMergeResultWindow->slotRegExpAutoMerge();
     }
 }
 
 void KDiff3App::slotSplitDiff()
 {
     LineRef firstLine = -1;
     LineRef lastLine = -1;
     DiffTextWindow* pDTW = nullptr;
     if(m_pDiffTextWindow1) {
         pDTW = m_pDiffTextWindow1;
         pDTW->getSelectionRange(&firstLine, &lastLine, eD3LLineCoords);
     }
     if(firstLine < 0 && m_pDiffTextWindow2) {
         pDTW = m_pDiffTextWindow2;
         pDTW->getSelectionRange(&firstLine, &lastLine, eD3LLineCoords);
     }
     if(firstLine < 0 && m_pDiffTextWindow3) {
         pDTW = m_pDiffTextWindow3;
         pDTW->getSelectionRange(&firstLine, &lastLine, eD3LLineCoords);
     }
     if(pDTW && firstLine >= 0 && m_pMergeResultWindow)
     {
         pDTW->resetSelection();
 
         m_pMergeResultWindow->slotSplitDiff(firstLine, lastLine);
     }
 }
 
 void KDiff3App::slotJoinDiffs()
 {
     LineRef firstLine = -1;
     LineRef lastLine = -1;
     DiffTextWindow* pDTW = nullptr;
     if(m_pDiffTextWindow1) {
         pDTW = m_pDiffTextWindow1;
         pDTW->getSelectionRange(&firstLine, &lastLine, eD3LLineCoords);
     }
     if(firstLine < 0 && m_pDiffTextWindow2) {
         pDTW = m_pDiffTextWindow2;
         pDTW->getSelectionRange(&firstLine, &lastLine, eD3LLineCoords);
     }
     if(firstLine < 0 && m_pDiffTextWindow3) {
         pDTW = m_pDiffTextWindow3;
         pDTW->getSelectionRange(&firstLine, &lastLine, eD3LLineCoords);
     }
     if(pDTW && firstLine >= 0 && m_pMergeResultWindow)
     {
         pDTW->resetSelection();
 
         m_pMergeResultWindow->slotJoinDiffs(firstLine, lastLine);
     }
 }
 
 void KDiff3App::slotConfigure()
 {
     m_pOptionDialog->setState();
     m_pOptionDialog->setMinimumHeight(m_pOptionDialog->minimumHeight() + 40);
     m_pOptionDialog->exec();
     slotRefresh();
 }
 
 void KDiff3App::slotConfigureKeys()
 {
     KShortcutsDialog::configure(actionCollection(), KShortcutsEditor::LetterShortcutsAllowed, this);
 }
 
 void KDiff3App::slotRefresh()
 {
     QApplication::setFont(m_pOptions->m_appFont);
     if(m_pDiffTextWindow1 != nullptr)
     {
         m_pDiffTextWindow1->setFont(m_pOptions->m_font);
         m_pDiffTextWindow1->update();
     }
     if(m_pDiffTextWindow2 != nullptr)
     {
         m_pDiffTextWindow2->setFont(m_pOptions->m_font);
         m_pDiffTextWindow2->update();
     }
     if(m_pDiffTextWindow3 != nullptr)
     {
         m_pDiffTextWindow3->setFont(m_pOptions->m_font);
         m_pDiffTextWindow3->update();
     }
     if(m_pMergeResultWindow != nullptr)
     {
         m_pMergeResultWindow->setFont(m_pOptions->m_font);
         m_pMergeResultWindow->update();
     }
     if(m_pHScrollBar != nullptr)
     {
         m_pHScrollBar->setAgain();
     }
     if(m_pDiffWindowSplitter != nullptr)
     {
         m_pDiffWindowSplitter->setOrientation(m_pOptions->m_bHorizDiffWindowSplitting ? Qt::Horizontal : Qt::Vertical);
     }
     if(m_pDirectoryMergeWindow)
     {
         m_pDirectoryMergeWindow->updateFileVisibilities();
     }
 }
 
 void KDiff3App::slotSelectionStart()
 {
     //editCopy->setEnabled( false );
     //editCut->setEnabled( false );
 
     const QObject* s = sender();
     if(m_pDiffTextWindow1 && s != m_pDiffTextWindow1) m_pDiffTextWindow1->resetSelection();
     if(m_pDiffTextWindow2 && s != m_pDiffTextWindow2) m_pDiffTextWindow2->resetSelection();
     if(m_pDiffTextWindow3 && s != m_pDiffTextWindow3) m_pDiffTextWindow3->resetSelection();
     if(m_pMergeResultWindow && s != m_pMergeResultWindow) m_pMergeResultWindow->resetSelection();
 }
 
 void KDiff3App::slotSelectionEnd()
 {
     //const QObject* s = sender();
     //editCopy->setEnabled(true);
     //editCut->setEnabled( s==m_pMergeResultWindow );
     if(m_pOptions->m_bAutoCopySelection)
     {
         slotEditCopy();
     }
     else
     {
         QClipboard* clipBoard = QApplication::clipboard();
 
         if(clipBoard->supportsSelection())
         {
             QString s;
             if(m_pDiffTextWindow1 != nullptr) s = m_pDiffTextWindow1->getSelection();
             if(s.isEmpty() && m_pDiffTextWindow2 != nullptr) s = m_pDiffTextWindow2->getSelection();
             if(s.isEmpty() && m_pDiffTextWindow3 != nullptr) s = m_pDiffTextWindow3->getSelection();
             if(s.isEmpty() && m_pMergeResultWindow != nullptr) s = m_pMergeResultWindow->getSelection();
             if(!s.isEmpty())
             {
                 clipBoard->setText(s, QClipboard::Selection);
             }
         }
     }
 }
 
 void KDiff3App::slotClipboardChanged()
 {
     QString s = QApplication::clipboard()->text();
     //editPaste->setEnabled(!s.isEmpty());
 }
 
 void KDiff3App::slotOutputModified(bool bModified)
 {
     if(bModified && !m_bOutputModified)
     {
         m_bOutputModified = true;
         slotUpdateAvailabilities();
     }
 }
 
 void KDiff3App::slotAutoAdvanceToggled()
 {
     m_pOptions->m_bAutoAdvance = autoAdvance->isChecked();
 }
 
 void KDiff3App::slotWordWrapToggled()
 {
     m_pOptions->m_bWordWrap = wordWrap->isChecked();
     postRecalcWordWrap();
 }
 
 // Enable or disable all widgets except the status bar widget.
 static void mainWindowEnable(QWidget* pWidget, bool bEnable)
 {
     if(QMainWindow* pWindow = dynamic_cast<QMainWindow*>(pWidget->window()))
     {
         QWidget* pStatusBarWidget = pWindow->statusBar();
         QList<QObject*> children = pWindow->children();
         for(int i = 0; i < children.count(); ++i)
         {
             if(children[i]->isWidgetType())
             {
                 QWidget* pChildWidget = (QWidget*)children[i];
                 if(pChildWidget != pStatusBarWidget)
                 {
                     pChildWidget->setEnabled(bEnable);
                 }
             }
         }
     }
 }
 
 void KDiff3App::postRecalcWordWrap()
 {
     if(!m_bRecalcWordWrapPosted)
     {
         m_bRecalcWordWrapPosted = true;
         mainWindowEnable(window(), false);
         m_firstD3LIdx = -1;
         QTimer::singleShot(1 /* ms */, this, SLOT(slotRecalcWordWrap()));
     }
     else
     {
         g_pProgressDialog->cancel(ProgressDialog::eResize);
     }
 }
 
 void KDiff3App::slotRecalcWordWrap()
 {
     recalcWordWrap();
 }
 
 // visibleTextWidthForPrinting is >=0 only for printing, otherwise the really visible width is used
 void KDiff3App::recalcWordWrap(int visibleTextWidthForPrinting)
 {
     m_bRecalcWordWrapPosted = true;
     mainWindowEnable(window(), false);
 
     m_visibleTextWidthForPrinting = visibleTextWidthForPrinting;
     if(m_firstD3LIdx < 0)
     {
         m_firstD3LIdx = 0;
         if(m_pDiffTextWindow1)
             m_firstD3LIdx = m_pDiffTextWindow1->convertLineToDiff3LineIdx(m_pDiffTextWindow1->getFirstLine());
     }
 
     // Convert selection to D3L-coords (converting back happens in DiffTextWindow::recalcWordWrap()
     if(m_pDiffTextWindow1)
         m_pDiffTextWindow1->convertSelectionToD3LCoords();
     if(m_pDiffTextWindow2)
         m_pDiffTextWindow2->convertSelectionToD3LCoords();
     if(m_pDiffTextWindow3)
         m_pDiffTextWindow3->convertSelectionToD3LCoords();
 
     g_pProgressDialog->clearCancelState(); // clear cancelled state if previously set
 
     if(!m_diff3LineList.empty())
     {
         if(m_pOptions->m_bWordWrap)
         {
             Diff3LineList::iterator i;
             int sumOfLines = 0;
             for(i = m_diff3LineList.begin(); i != m_diff3LineList.end(); ++i)
             {
                 Diff3Line& d3l = *i;
                 d3l.linesNeededForDisplay = 1;
                 d3l.sumLinesNeededForDisplay = sumOfLines;
                 sumOfLines += d3l.linesNeededForDisplay;
             }
 
             // Let every window calc how many lines will be needed.
             if(m_pDiffTextWindow1)
             {
                 m_pDiffTextWindow1->recalcWordWrap(true, 0, m_visibleTextWidthForPrinting);
             }
             if(m_pDiffTextWindow2)
             {
                 m_pDiffTextWindow2->recalcWordWrap(true, 0, m_visibleTextWidthForPrinting);
             }
             if(m_pDiffTextWindow3)
             {
                 m_pDiffTextWindow3->recalcWordWrap(true, 0, m_visibleTextWidthForPrinting);
             }
         }
         else
         {
             m_neededLines = m_diff3LineVector.size();
             if(m_pDiffTextWindow1)
                 m_pDiffTextWindow1->recalcWordWrap(false, 0, 0);
             if(m_pDiffTextWindow2)
                 m_pDiffTextWindow2->recalcWordWrap(false, 0, 0);
             if(m_pDiffTextWindow3)
                 m_pDiffTextWindow3->recalcWordWrap(false, 0, 0);
         }
         bool bRunnablesStarted = startRunnables();
         if(!bRunnablesStarted)
             slotFinishRecalcWordWrap();
         else
         {
             g_pProgressDialog->setInformation(m_pOptions->m_bWordWrap
                                                   ? i18n("Word wrap (Cancel disables word wrap)")
                                                   : i18n("Calculating max width for horizontal scrollbar"),
                                               false);
         }
     }
 }
 
 void KDiff3App::slotFinishRecalcWordWrap()
 {
     g_pProgressDialog->pop();
 
     if(m_pOptions->m_bWordWrap && g_pProgressDialog->wasCancelled())
     {
         if(g_pProgressDialog->cancelReason() == ProgressDialog::eUserAbort)
         {
             wordWrap->setChecked(false);
             m_pOptions->m_bWordWrap = wordWrap->isChecked();
             QTimer::singleShot(1 /* ms */, this, SLOT(slotRecalcWordWrap())); // do it again
         }
         else // eResize
         {
             QTimer::singleShot(1 /* ms */, this, SLOT(slotRecalcWordWrap())); // do it again
         }
         return;
     }
     else
     {
         m_bRecalcWordWrapPosted = false;
     }
 
     g_pProgressDialog->setStayHidden(false);
 
     bool bPrinting = m_visibleTextWidthForPrinting >= 0;
 
     if(!m_diff3LineList.empty())
     {
         if(m_pOptions->m_bWordWrap)
         {
             Diff3LineList::iterator i;
             int sumOfLines = 0;
             for(i = m_diff3LineList.begin(); i != m_diff3LineList.end(); ++i)
             {
                 Diff3Line& d3l = *i;
                 d3l.sumLinesNeededForDisplay = sumOfLines;
                 sumOfLines += d3l.linesNeededForDisplay;
             }
 
             // Finish the word wrap
             if(m_pDiffTextWindow1)
                 m_pDiffTextWindow1->recalcWordWrap(true, sumOfLines, m_visibleTextWidthForPrinting);
             if(m_pDiffTextWindow2)
                 m_pDiffTextWindow2->recalcWordWrap(true, sumOfLines, m_visibleTextWidthForPrinting);
             if(m_pDiffTextWindow3)
                 m_pDiffTextWindow3->recalcWordWrap(true, sumOfLines, m_visibleTextWidthForPrinting);
 
             m_neededLines = sumOfLines;
         }
         else
         {
             if(m_pDiffTextWindow1)
                 m_pDiffTextWindow1->recalcWordWrap(false, 1, 0);
             if(m_pDiffTextWindow2)
                 m_pDiffTextWindow2->recalcWordWrap(false, 1, 0);
             if(m_pDiffTextWindow3)
                 m_pDiffTextWindow3->recalcWordWrap(false, 1, 0);
         }
         slotStatusMsg(QString());
     }
 
     if(!bPrinting)
     {
         if(m_pOverview)
             m_pOverview->slotRedraw();
         if(m_pDiffVScrollBar)
             m_pDiffVScrollBar->setRange(0, max2(0, m_neededLines + 1 - m_DTWHeight));
         if(m_pDiffTextWindow1)
         {
             if(m_pDiffVScrollBar)
                 m_pDiffVScrollBar->setValue(m_pDiffTextWindow1->convertDiff3LineIdxToLine(m_firstD3LIdx));
             
             setHScrollBarRange();
             m_pHScrollBar->setValue(0);
         }
     }
     mainWindowEnable(window(), true);
 
     if(m_bFinishMainInit)
     {
         m_bFinishMainInit = false;
         slotFinishMainInit();
     }
     if(m_pEventLoopForPrinting)
         m_pEventLoopForPrinting->quit();
 }
 
 void KDiff3App::slotShowWhiteSpaceToggled()
 {
     m_pOptions->m_bShowWhiteSpaceCharacters = showWhiteSpaceCharacters->isChecked();
     m_pOptions->m_bShowWhiteSpace = showWhiteSpace->isChecked();
 
     if(m_pDiffTextWindow1 != nullptr)
         m_pDiffTextWindow1->update();
     if(m_pDiffTextWindow2 != nullptr)
         m_pDiffTextWindow2->update();
     if(m_pDiffTextWindow3 != nullptr)
         m_pDiffTextWindow3->update();
     if(m_pMergeResultWindow != nullptr)
         m_pMergeResultWindow->update();
     if(m_pOverview != nullptr)
         m_pOverview->slotRedraw();
 }
 
 void KDiff3App::slotShowLineNumbersToggled()
 {
     m_pOptions->m_bShowLineNumbers = showLineNumbers->isChecked();
 
     if(wordWrap->isChecked())
         recalcWordWrap();
 
     if(m_pDiffTextWindow1 != nullptr)
         m_pDiffTextWindow1->update();
     if(m_pDiffTextWindow2 != nullptr)
         m_pDiffTextWindow2->update();
 
     if(m_pDiffTextWindow3 != nullptr)
         m_pDiffTextWindow3->update();
 }
 
 /// Return true for success, else false
 bool KDiff3App::improveFilenames(bool bCreateNewInstance)
 {
     m_bDirCompare = false;
 
     FileAccess f1(m_sd1.getFilename());
     FileAccess f2(m_sd2.getFilename());
     FileAccess f3(m_sd3.getFilename());
     FileAccess f4(m_outputFilename);
 
     if(f1.isFile() && f1.exists())
     {
         if(f2.isDir())
         {
             f2.addPath(f1.fileName());
             if(f2.isFile() && f2.exists())
                 m_sd2.setFileAccess(f2);
         }
         if(f3.isDir())
         {
             f3.addPath(f1.fileName());
             if(f3.isFile() && f3.exists())
                 m_sd3.setFileAccess(f3);
         }
         if(f4.isDir())
         {
             f4.addPath(f1.fileName());
             if(f4.isFile() && f4.exists())
                 m_outputFilename = f4.absoluteFilePath();
         }
     }
     else if(f1.isDir())
     {
         m_bDirCompare = true;
         if(bCreateNewInstance)
         {
             emit createNewInstance(f1.absoluteFilePath(), f2.absoluteFilePath(), f3.absoluteFilePath());
         }
         else
         {
             FileAccess destDir;
             if(!m_bDefaultFilename) destDir = f4;
             m_pDirectoryMergeSplitter->show();
             if(m_pMainWidget != nullptr) m_pMainWidget->hide();
             setUpdatesEnabled(true);
 
             bool bSuccess = m_pDirectoryMergeWindow->init(
                 f1, f2, f3,
                 destDir, // Destdirname
                 !m_outputFilename.isEmpty());
 
             m_bDirCompare = true; // This seems redundant but it might have been reset during full analysis.
 
             if(bSuccess)
             {
                 m_sd1.reset();
                 if(m_pDiffTextWindow1 != nullptr) m_pDiffTextWindow1->init(nullptr, nullptr, eLineEndStyleDos, nullptr, 0, nullptr, nullptr, false);
                 m_sd2.reset();
                 if(m_pDiffTextWindow2 != nullptr) m_pDiffTextWindow2->init(nullptr, nullptr, eLineEndStyleDos, nullptr, 0, nullptr, nullptr, false);
                 m_sd3.reset();
                 if(m_pDiffTextWindow3 != nullptr) m_pDiffTextWindow3->init(nullptr, nullptr, eLineEndStyleDos, nullptr, 0, nullptr, nullptr, false);
             }
             slotUpdateAvailabilities();
             return bSuccess;
         }
     }
     return true;
 }
 
 void KDiff3App::slotReload()
 {
     if(!canContinue()) return;
 
     mainInit();
 }
 
 bool KDiff3App::canContinue()
 {
     // First test if anything must be saved.
     if(m_bOutputModified)
     {
         int result = KMessageBox::warningYesNoCancel(this,
                                                      i18n("The merge result has not been saved."),
                                                      i18n("Warning"),
                                                      KGuiItem(i18n("Save && Continue")),
                                                      KGuiItem(i18n("Continue Without Saving")));
         if(result == KMessageBox::Cancel)
             return false;
         else if(result == KMessageBox::Yes)
         {
             slotFileSave();
             if(m_bOutputModified)
             {
                 KMessageBox::sorry(this, i18n("Saving the merge result failed."), i18n("Warning"));
                 return false;
             }
         }
     }
 
     m_bOutputModified = false;
     return true;
 }
 
 void KDiff3App::slotCheckIfCanContinue(bool* pbContinue)
 {
     if(pbContinue != nullptr) *pbContinue = canContinue();
 }
 
 void KDiff3App::slotDirShowBoth()
 {
     if(dirShowBoth->isChecked())
     {
         if(m_pDirectoryMergeSplitter)
             m_pDirectoryMergeSplitter->setVisible(m_bDirCompare);
 
         if(m_pMainWidget != nullptr)
             m_pMainWidget->show();
     }
     else
     {
         bool bTextDataAvailable = (m_sd1.hasData() || m_sd2.hasData() || m_sd3.hasData());
         if(m_pMainWidget != nullptr && bTextDataAvailable)
         {
             m_pMainWidget->show();
             m_pDirectoryMergeSplitter->hide();
         }
         else if(m_bDirCompare)
         {
             m_pDirectoryMergeSplitter->show();
         }
     }
 
     slotUpdateAvailabilities();
 }
 
 void KDiff3App::slotDirViewToggle()
 {
     if(m_bDirCompare)
     {
         if(!m_pDirectoryMergeSplitter->isVisible())
         {
             m_pDirectoryMergeSplitter->show();
             if(m_pMainWidget != nullptr)
                 m_pMainWidget->hide();
         }
         else
         {
             if(m_pMainWidget != nullptr)
             {
                 m_pDirectoryMergeSplitter->hide();
                 m_pMainWidget->show();
             }
         }
     }
     slotUpdateAvailabilities();
 }
 
 void KDiff3App::slotShowWindowAToggled()
 {
     if(m_pDiffTextWindow1 != nullptr)
     {
         m_pDiffTextWindowFrame1->setVisible(showWindowA->isChecked());
         slotUpdateAvailabilities();
     }
 }
 
 void KDiff3App::slotShowWindowBToggled()
 {
     if(m_pDiffTextWindow2 != nullptr)
     {
         m_pDiffTextWindowFrame2->setVisible(showWindowB->isChecked());
         slotUpdateAvailabilities();
     }
 }
 
 void KDiff3App::slotShowWindowCToggled()
 {
     if(m_pDiffTextWindow3 != nullptr)
     {
         m_pDiffTextWindowFrame3->setVisible(showWindowC->isChecked());
         slotUpdateAvailabilities();
     }
 }
 
 void KDiff3App::slotEditFind()
 {
     m_pFindDialog->currentLine = 0;
     m_pFindDialog->currentPos = 0;
     m_pFindDialog->currentWindow = 1;
 
     // Use currently selected text:
     QString s;
     if(m_pDiffTextWindow1 != nullptr) s = m_pDiffTextWindow1->getSelection();
     if(s.isEmpty() && m_pDiffTextWindow2 != nullptr) s = m_pDiffTextWindow2->getSelection();
     if(s.isEmpty() && m_pDiffTextWindow3 != nullptr) s = m_pDiffTextWindow3->getSelection();
     if(s.isEmpty() && m_pMergeResultWindow != nullptr) s = m_pMergeResultWindow->getSelection();
     if(!s.isEmpty() && !s.contains('\n'))
     {
         m_pFindDialog->m_pSearchString->setText(s);
     }
 
     if(QDialog::Accepted == m_pFindDialog->exec())
     {
         slotEditFindNext();
     }
 }
 
 void KDiff3App::slotEditFindNext()
 {
     QString s = m_pFindDialog->m_pSearchString->text();
     if(s.isEmpty())
     {
         slotEditFind();
         return;
     }
 
     bool bDirDown = true;
     bool bCaseSensitive = m_pFindDialog->m_pCaseSensitive->isChecked();
 
     LineRef d3vLine = m_pFindDialog->currentLine;
     int posInLine = m_pFindDialog->currentPos;
     LineRef l = 0;
     int p = 0;
     if(m_pFindDialog->currentWindow == 1)
     {
         if(m_pFindDialog->m_pSearchInA->isChecked() && m_pDiffTextWindow1 != nullptr &&
            m_pDiffTextWindow1->findString(s, d3vLine, posInLine, bDirDown, bCaseSensitive))
         {
             m_pDiffTextWindow1->setSelection(d3vLine, posInLine, d3vLine, posInLine + s.length(), l, p);
             m_pDiffVScrollBar->setValue(l - m_pDiffVScrollBar->pageStep() / 2);
             m_pHScrollBar->setValue(max2(0, p + (int)s.length() - m_pHScrollBar->pageStep()));
             m_pFindDialog->currentLine = d3vLine;
             m_pFindDialog->currentPos = posInLine + 1;
             return;
         }
         m_pFindDialog->currentWindow = 2;
         m_pFindDialog->currentLine = 0;
         m_pFindDialog->currentPos = 0;
     }
 
     d3vLine = m_pFindDialog->currentLine;
     posInLine = m_pFindDialog->currentPos;
     if(m_pFindDialog->currentWindow == 2)
     {
         if(m_pFindDialog->m_pSearchInB->isChecked() && m_pDiffTextWindow2 != nullptr &&
            m_pDiffTextWindow2->findString(s, d3vLine, posInLine, bDirDown, bCaseSensitive))
         {
             m_pDiffTextWindow2->setSelection(d3vLine, posInLine, d3vLine, posInLine + s.length(), l, p);
             m_pDiffVScrollBar->setValue(l - m_pDiffVScrollBar->pageStep() / 2);
             m_pHScrollBar->setValue(max2(0, p + (int)s.length() - m_pHScrollBar->pageStep()));
             m_pFindDialog->currentLine = d3vLine;
             m_pFindDialog->currentPos = posInLine + 1;
             return;
         }
         m_pFindDialog->currentWindow = 3;
         m_pFindDialog->currentLine = 0;
         m_pFindDialog->currentPos = 0;
     }
 
     d3vLine = m_pFindDialog->currentLine;
     posInLine = m_pFindDialog->currentPos;
     if(m_pFindDialog->currentWindow == 3)
     {
         if(m_pFindDialog->m_pSearchInC->isChecked() && m_pDiffTextWindow3 != nullptr &&
            m_pDiffTextWindow3->findString(s, d3vLine, posInLine, bDirDown, bCaseSensitive))
         {
             m_pDiffTextWindow3->setSelection(d3vLine, posInLine, d3vLine, posInLine + s.length(), l, p);
             m_pDiffVScrollBar->setValue(l - m_pDiffVScrollBar->pageStep() / 2);
             m_pHScrollBar->setValue(max2(0, p + (int)s.length() - m_pHScrollBar->pageStep()));
             m_pFindDialog->currentLine = d3vLine;
             m_pFindDialog->currentPos = posInLine + 1;
             return;
         }
         m_pFindDialog->currentWindow = 4;
         m_pFindDialog->currentLine = 0;
         m_pFindDialog->currentPos = 0;
     }
 
     d3vLine = m_pFindDialog->currentLine;
     posInLine = m_pFindDialog->currentPos;
     if(m_pFindDialog->currentWindow == 4)
     {
         if(m_pFindDialog->m_pSearchInOutput->isChecked() && m_pMergeResultWindow != nullptr && m_pMergeResultWindow->isVisible() &&
            m_pMergeResultWindow->findString(s, d3vLine, posInLine, bDirDown, bCaseSensitive))
         {
             m_pMergeResultWindow->setSelection(d3vLine, posInLine, d3vLine, posInLine + s.length());
             m_pMergeVScrollBar->setValue(d3vLine - m_pMergeVScrollBar->pageStep() / 2);
             m_pHScrollBar->setValue(max2(0, posInLine + (int)s.length() - m_pHScrollBar->pageStep()));
             m_pFindDialog->currentLine = d3vLine;
             m_pFindDialog->currentPos = posInLine + 1;
             return;
         }
         m_pFindDialog->currentWindow = 5;
         m_pFindDialog->currentLine = 0;
         m_pFindDialog->currentPos = 0;
     }
 
     KMessageBox::information(this, i18n("Search complete."), i18n("Search Complete"));
     m_pFindDialog->currentWindow = 1;
     m_pFindDialog->currentLine = 0;
     m_pFindDialog->currentPos = 0;
 }
 
 void KDiff3App::slotMergeCurrentFile()
 {
     if(m_bDirCompare && m_pDirectoryMergeWindow->isVisible() && m_pDirectoryMergeWindow->isFileSelected())
     {
         m_pDirectoryMergeWindow->mergeCurrentFile();
     }
     else if(m_pMainWidget != nullptr && m_pMainWidget->isVisible())
     {
         if(!canContinue()) return;
         if(m_outputFilename.isEmpty())
         {
             if(!m_sd3.isEmpty() && !m_sd3.isFromBuffer())
             {
                 m_outputFilename = m_sd3.getFilename();
             }
             else if(!m_sd2.isEmpty() && !m_sd2.isFromBuffer())
             {
                 m_outputFilename = m_sd2.getFilename();
             }
             else if(!m_sd1.isEmpty() && !m_sd1.isFromBuffer())
             {
                 m_outputFilename = m_sd1.getFilename();
             }
             else
             {
                 m_outputFilename = "unnamed.txt";
                 m_bDefaultFilename = true;
             }
         }
         mainInit();
     }
 }
 
 void KDiff3App::slotWinFocusNext()
 {
     QWidget* focus = qApp->focusWidget();
     if(focus == m_pDirectoryMergeWindow && m_pDirectoryMergeWindow->isVisible() && !dirShowBoth->isChecked())
     {
         slotDirViewToggle();
     }
 
     std::list<QWidget*> visibleWidgetList;
     if(m_pDiffTextWindow1 && m_pDiffTextWindow1->isVisible()) visibleWidgetList.push_back(m_pDiffTextWindow1);
     if(m_pDiffTextWindow2 && m_pDiffTextWindow2->isVisible()) visibleWidgetList.push_back(m_pDiffTextWindow2);
     if(m_pDiffTextWindow3 && m_pDiffTextWindow3->isVisible()) visibleWidgetList.push_back(m_pDiffTextWindow3);
     if(m_pMergeResultWindow && m_pMergeResultWindow->isVisible()) visibleWidgetList.push_back(m_pMergeResultWindow);
     if(m_bDirCompare /*m_pDirectoryMergeWindow->isVisible()*/) visibleWidgetList.push_back(m_pDirectoryMergeWindow);
     //if ( m_pDirectoryMergeInfo->isVisible() ) visibleWidgetList.push_back(m_pDirectoryMergeInfo->getInfoList());
 
     std::list<QWidget*>::iterator i = std::find(visibleWidgetList.begin(), visibleWidgetList.end(), focus);
     ++i;
     if(i == visibleWidgetList.end())
         i = visibleWidgetList.begin();
     if(i != visibleWidgetList.end())
     {
         if(*i == m_pDirectoryMergeWindow && !dirShowBoth->isChecked())
         {
             slotDirViewToggle();
         }
         (*i)->setFocus();
     }
 }
 
 void KDiff3App::slotWinFocusPrev()
 {
     QWidget* focus = qApp->focusWidget();
     if(focus == m_pDirectoryMergeWindow && m_pDirectoryMergeWindow->isVisible() && !dirShowBoth->isChecked())
     {
         slotDirViewToggle();
     }
 
     std::list<QWidget*> visibleWidgetList;
     if(m_pDiffTextWindow1 && m_pDiffTextWindow1->isVisible()) visibleWidgetList.push_back(m_pDiffTextWindow1);
     if(m_pDiffTextWindow2 && m_pDiffTextWindow2->isVisible()) visibleWidgetList.push_back(m_pDiffTextWindow2);
     if(m_pDiffTextWindow3 && m_pDiffTextWindow3->isVisible()) visibleWidgetList.push_back(m_pDiffTextWindow3);
     if(m_pMergeResultWindow && m_pMergeResultWindow->isVisible()) visibleWidgetList.push_back(m_pMergeResultWindow);
     if(m_bDirCompare /* m_pDirectoryMergeWindow->isVisible() */) visibleWidgetList.push_back(m_pDirectoryMergeWindow);
     //if ( m_pDirectoryMergeInfo->isVisible() ) visibleWidgetList.push_back(m_pDirectoryMergeInfo->getInfoList());
 
     std::list<QWidget*>::iterator i = std::find(visibleWidgetList.begin(), visibleWidgetList.end(), focus);
     if(i == visibleWidgetList.begin())
         i = visibleWidgetList.end();
     --i;
     if(i != visibleWidgetList.end())
     {
         if(*i == m_pDirectoryMergeWindow && !dirShowBoth->isChecked())
         {
             slotDirViewToggle();
         }
         (*i)->setFocus();
     }
 }
 
 void KDiff3App::slotWinToggleSplitterOrientation()
 {
     if(m_pDiffWindowSplitter != nullptr)
     {
         m_pDiffWindowSplitter->setOrientation(
             m_pDiffWindowSplitter->orientation() == Qt::Vertical ? Qt::Horizontal : Qt::Vertical);
 
         m_pOptions->m_bHorizDiffWindowSplitting = m_pDiffWindowSplitter->orientation() == Qt::Horizontal;
     }
 }
 
 void KDiff3App::slotOverviewNormal()
 {
     if(m_pOverview != nullptr)
         m_pOverview->setOverviewMode(Overview::eOMNormal);
     if(m_pMergeResultWindow != nullptr)
         m_pMergeResultWindow->setOverviewMode(Overview::eOMNormal);
     slotUpdateAvailabilities();
 }
 
 void KDiff3App::slotOverviewAB()
 {
     if(m_pOverview != nullptr)
         m_pOverview->setOverviewMode(Overview::eOMAvsB);
     m_pMergeResultWindow->setOverviewMode(Overview::eOMAvsB);
     slotUpdateAvailabilities();
 }
 
 void KDiff3App::slotOverviewAC()
 {
     if(m_pOverview != nullptr)
         m_pOverview->setOverviewMode(Overview::eOMAvsC);
     if(m_pMergeResultWindow != nullptr)
         m_pMergeResultWindow->setOverviewMode(Overview::eOMAvsC);
     slotUpdateAvailabilities();
 }
 
 void KDiff3App::slotOverviewBC()
 {
     if(m_pOverview != nullptr)
         m_pOverview->setOverviewMode(Overview::eOMBvsC);
     if(m_pMergeResultWindow != nullptr)
         m_pMergeResultWindow->setOverviewMode(Overview::eOMBvsC);
     slotUpdateAvailabilities();
 }
 
 void KDiff3App::slotNoRelevantChangesDetected()
 {
     if(m_bTripleDiff && !m_outputFilename.isEmpty())
     {
         //KMessageBox::information( this, "No relevant changes detected", "KDiff3" );
         if(!m_pOptions->m_IrrelevantMergeCmd.isEmpty())
         {
             QString cmd = m_pOptions->m_IrrelevantMergeCmd;
             /*
                 QProcess doesn't check for single quotes and uses non-standard escaping syntax for double quotes.
                     The distinction between single and double quotes is purly a command shell issue. So
                     Silently convert quotes to what QProcess understands. Also convert '\"' to '"""'
             */
             //arg and arg1 can never both match but qt's pcre2 engine insists on unique naming anyway
             const QRegularExpression argRe("(?<!\\\\)\"(?<arg>(?:[^\"]|(?<=\\\\)\")*)(?<!\\\\)\"|'(?<arg1>[^']*)'|(?<!\\\\)\\s*(?<arg2>[\\S]+)");
             QRegularExpressionMatchIterator i = argRe.globalMatch(cmd);
             QRegularExpressionMatch match;
             QStringList args;
 
             while(i.hasNext())
             {
                 match = i.next();
                 args += match.captured("arg").replace("\\\"", "\"\"\"").replace("\\\\", "\\")
                     + match.captured("arg1") + match.captured("arg2");
             }
             args += m_sd1.getAliasName();
             args += m_sd2.getAliasName();
             args += m_sd3.getAliasName();
             //The command ends at the first non-escaped space.
             cmd = cmd.left(
                 cmd.indexOf( QRegularExpression("(?<!\\\\)[\\s]*") )
             ).trimmed();
             cmd.replace(QRegularExpression("(?<!\\\\)([\\s])"), "\1");
             
             QProcess process;
             process.start(cmd);
             process.waitForFinished(-1);
         }
     }
 }
 
 static void insertManualDiffHelp(ManualDiffHelpList* pManualDiffHelpList, int winIdx, LineRef firstLine, LineRef lastLine)
 {
     // The manual diff help list must be sorted and compact.
     // "Compact" means that upper items can't be empty if lower items contain data.
 
     // First insert the new item without regarding compactness.
     // If the new item overlaps with previous items then the previous items will be removed.
 
     ManualDiffHelpEntry mdhe;
     mdhe.firstLine(winIdx) = firstLine;
     mdhe.lastLine(winIdx) = lastLine;
 
     ManualDiffHelpList::iterator i;
     for(i = pManualDiffHelpList->begin(); i != pManualDiffHelpList->end(); ++i)
     {
         int& l1 = i->firstLine(winIdx);
         int& l2 = i->lastLine(winIdx);
         if(l1 >= 0 && l2 >= 0)
         {
             if((firstLine <= l1 && lastLine >= l1) || (firstLine <= l2 && lastLine >= l2))
             {
                 // overlap
                 l1 = -1;
                 l2 = -1;
             }
             if(firstLine < l1 && lastLine < l1)
             {
                 // insert before this position
                 pManualDiffHelpList->insert(i, mdhe);
                 break;
             }
         }
     }
     if(i == pManualDiffHelpList->end())
     {
         pManualDiffHelpList->insert(i, mdhe);
     }
 
     // Now make the list compact
     for(int wIdx = 1; wIdx <= 3; ++wIdx)
     {
         ManualDiffHelpList::iterator iEmpty = pManualDiffHelpList->begin();
         for(i = pManualDiffHelpList->begin(); i != pManualDiffHelpList->end(); ++i)
         {
             if(iEmpty->firstLine(wIdx) >= 0)
             {
                 ++iEmpty;
                 continue;
             }
             if(i->firstLine(wIdx) >= 0) // Current item is not empty -> move it to the empty place
             {
                 iEmpty->firstLine(wIdx) = i->firstLine(wIdx);
                 iEmpty->lastLine(wIdx) = i->lastLine(wIdx);
                 i->firstLine(wIdx) = -1;
                 i->lastLine(wIdx) = -1;
                 ++iEmpty;
             }
         }
     }
     pManualDiffHelpList->remove(ManualDiffHelpEntry()); // Remove all completely empty items.
 }
 
 void KDiff3App::slotAddManualDiffHelp()
 {
     LineRef firstLine = -1;
     LineRef lastLine = -1;
     int winIdx = -1;
     if(m_pDiffTextWindow1) {
         m_pDiffTextWindow1->getSelectionRange(&firstLine, &lastLine, eFileCoords);
         winIdx = 1;
     }
     if(firstLine < 0 && m_pDiffTextWindow2) {
         m_pDiffTextWindow2->getSelectionRange(&firstLine, &lastLine, eFileCoords);
         winIdx = 2;
     }
     if(firstLine < 0 && m_pDiffTextWindow3) {
         m_pDiffTextWindow3->getSelectionRange(&firstLine, &lastLine, eFileCoords);
         winIdx = 3;
     }
 
     if(firstLine < 0 || lastLine < 0 || lastLine < firstLine)
         KMessageBox::information(this, i18n("Nothing is selected in either diff input window."), i18n("Error while adding manual diff range"));
     else
     {
-        /*
-      ManualDiffHelpEntry mdhe;
-      if (!m_manualDiffHelpList.empty()) mdhe = m_manualDiffHelpList.front();
-      if ( winIdx==1 ) { mdhe.lineA1 = firstLine; mdhe.lineA2 = lastLine; }
-      if ( winIdx==2 ) { mdhe.lineB1 = firstLine; mdhe.lineB2 = lastLine; }
-      if ( winIdx==3 ) { mdhe.lineC1 = firstLine; mdhe.lineC2 = lastLine; }
-      m_manualDiffHelpList.clear();
-      m_manualDiffHelpList.push_back( mdhe );
-      */
-
         insertManualDiffHelp(&m_manualDiffHelpList, winIdx, firstLine, lastLine);
 
         mainInit(nullptr, false); // Init without reload
         slotRefresh();
     }
 }
 
 void KDiff3App::slotClearManualDiffHelpList()
 {
     m_manualDiffHelpList.clear();
     mainInit(nullptr, false); // Init without reload
     slotRefresh();
 }
 
 void KDiff3App::slotEncodingChangedA(QTextCodec* c)
 {
     m_sd1.setEncoding(c);
     mainInit(nullptr, true, true); // Init with reload
     slotRefresh();
 }
 
 void KDiff3App::slotEncodingChangedB(QTextCodec* c)
 {
     m_sd2.setEncoding(c);
     mainInit(nullptr, true, true); // Init with reload
     slotRefresh();
 }
 
 void KDiff3App::slotEncodingChangedC(QTextCodec* c)
 {
     m_sd3.setEncoding(c);
     mainInit(nullptr, true, true); // Init with reload
     slotRefresh();
 }
 
 void KDiff3App::slotUpdateAvailabilities()
 {
     if(m_pMainSplitter == nullptr)
         return;
 
     bool bTextDataAvailable = (m_sd1.hasData() || m_sd2.hasData() || m_sd3.hasData());
 
     if(dirShowBoth->isChecked())
     {
         if(m_pDirectoryMergeSplitter != nullptr)
             m_pDirectoryMergeSplitter->setVisible(m_bDirCompare);
 
         if(m_pMainWidget != nullptr && !m_pMainWidget->isVisible() &&
            bTextDataAvailable && !m_pDirectoryMergeWindow->isScanning())
             m_pMainWidget->show();
     }
 
     bool bDiffWindowVisible = m_pMainWidget != nullptr && m_pMainWidget->isVisible();
     bool bMergeEditorVisible = m_pMergeWindowFrame != nullptr && m_pMergeWindowFrame->isVisible();
 
     m_pDirectoryMergeWindow->updateAvailabilities(m_bDirCompare, bDiffWindowVisible, chooseA, chooseB, chooseC);
 
     dirShowBoth->setEnabled(m_bDirCompare);
     dirViewToggle->setEnabled(
         m_bDirCompare &&
         ((m_pDirectoryMergeSplitter != nullptr && m_pMainWidget != nullptr) &&
          ((!m_pDirectoryMergeSplitter->isVisible() && m_pMainWidget->isVisible()) ||
           (m_pDirectoryMergeSplitter->isVisible() && !m_pMainWidget->isVisible() && bTextDataAvailable))));
 
     bool bDirWindowHasFocus = m_pDirectoryMergeSplitter != nullptr && m_pDirectoryMergeSplitter->isVisible() && m_pDirectoryMergeWindow->hasFocus();
 
     showWhiteSpaceCharacters->setEnabled(bDiffWindowVisible);
     autoAdvance->setEnabled(bMergeEditorVisible);
     autoSolve->setEnabled(bMergeEditorVisible && m_bTripleDiff);
     unsolve->setEnabled(bMergeEditorVisible);
     if(!bDirWindowHasFocus)
     {
         chooseA->setEnabled(bMergeEditorVisible);
         chooseB->setEnabled(bMergeEditorVisible);
         chooseC->setEnabled(bMergeEditorVisible && m_bTripleDiff);
     }
     chooseAEverywhere->setEnabled(bMergeEditorVisible);
     chooseBEverywhere->setEnabled(bMergeEditorVisible);
     chooseCEverywhere->setEnabled(bMergeEditorVisible && m_bTripleDiff);
     chooseAForUnsolvedConflicts->setEnabled(bMergeEditorVisible);
     chooseBForUnsolvedConflicts->setEnabled(bMergeEditorVisible);
     chooseCForUnsolvedConflicts->setEnabled(bMergeEditorVisible && m_bTripleDiff);
     chooseAForUnsolvedWhiteSpaceConflicts->setEnabled(bMergeEditorVisible);
     chooseBForUnsolvedWhiteSpaceConflicts->setEnabled(bMergeEditorVisible);
     chooseCForUnsolvedWhiteSpaceConflicts->setEnabled(bMergeEditorVisible && m_bTripleDiff);
     mergeHistory->setEnabled(bMergeEditorVisible);
     mergeRegExp->setEnabled(bMergeEditorVisible);
     showWindowA->setEnabled(bDiffWindowVisible && (m_pDiffTextWindow2->isVisible() || m_pDiffTextWindow3->isVisible()));
     showWindowB->setEnabled(bDiffWindowVisible && (m_pDiffTextWindow1->isVisible() || m_pDiffTextWindow3->isVisible()));
     showWindowC->setEnabled(bDiffWindowVisible && m_bTripleDiff && (m_pDiffTextWindow1->isVisible() || m_pDiffTextWindow2->isVisible()));
     editFind->setEnabled(bDiffWindowVisible);
     editFindNext->setEnabled(bDiffWindowVisible);
     m_pFindDialog->m_pSearchInC->setEnabled(m_bTripleDiff);
     m_pFindDialog->m_pSearchInOutput->setEnabled(bMergeEditorVisible);
 
     bool bSavable = bMergeEditorVisible && m_pMergeResultWindow->getNrOfUnsolvedConflicts() == 0;
     fileSave->setEnabled(m_bOutputModified && bSavable);
     fileSaveAs->setEnabled(bSavable);
 
     goTop->setEnabled(bDiffWindowVisible && m_pMergeResultWindow->isDeltaAboveCurrent());
     goBottom->setEnabled(bDiffWindowVisible && m_pMergeResultWindow->isDeltaBelowCurrent());
     goCurrent->setEnabled(bDiffWindowVisible);
     goPrevUnsolvedConflict->setEnabled(bMergeEditorVisible && m_pMergeResultWindow->isUnsolvedConflictAboveCurrent());
     goNextUnsolvedConflict->setEnabled(bMergeEditorVisible && m_pMergeResultWindow->isUnsolvedConflictBelowCurrent());
     goPrevConflict->setEnabled(bDiffWindowVisible && m_pMergeResultWindow->isConflictAboveCurrent());
     goNextConflict->setEnabled(bDiffWindowVisible && m_pMergeResultWindow->isConflictBelowCurrent());
     goPrevDelta->setEnabled(bDiffWindowVisible && m_pMergeResultWindow->isDeltaAboveCurrent());
     goNextDelta->setEnabled(bDiffWindowVisible && m_pMergeResultWindow->isDeltaBelowCurrent());
 
     overviewModeNormal->setEnabled(m_bTripleDiff && bDiffWindowVisible);
     overviewModeAB->setEnabled(m_bTripleDiff && bDiffWindowVisible);
     overviewModeAC->setEnabled(m_bTripleDiff && bDiffWindowVisible);
     overviewModeBC->setEnabled(m_bTripleDiff && bDiffWindowVisible);
     Overview::e_OverviewMode overviewMode = m_pOverview == nullptr ? Overview::eOMNormal : m_pOverview->getOverviewMode();
     overviewModeNormal->setChecked(overviewMode == Overview::eOMNormal);
     overviewModeAB->setChecked(overviewMode == Overview::eOMAvsB);
     overviewModeAC->setChecked(overviewMode == Overview::eOMAvsC);
     overviewModeBC->setChecked(overviewMode == Overview::eOMBvsC);
 
     winToggleSplitOrientation->setEnabled(bDiffWindowVisible && m_pDiffWindowSplitter != nullptr);
 }