diff --git a/src/diff.cpp b/src/diff.cpp
index 30d9a25..09ed5a1 100644
--- a/src/diff.cpp
+++ b/src/diff.cpp
@@ -1,2464 +1,2469 @@
 /***************************************************************************
                           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;
 }
 
 int SourceData::getSizeLines() const
 {
     return m_normalData.m_vSize;
 }
 
 int 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(buf, size);
     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);
     int fileInSize = faIn.size();
 
     if(faIn.exists()) // fileInSize > 0 )
     {
 
 #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.")
                         .arg(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.")
                         .arg(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();
         }
     }
 
     m_normalData.preprocess(m_pOptions->m_bPreserveCarriageReturn, pEncoding1);
     m_lmppData.preprocess(false, pEncoding2);
 
     if(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(m_normalData.m_vSize);
         for(int 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[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)
     {
         int i;
         QChar* pBuf = const_cast<QChar*>(m_lmppData.m_unicodeBuf.unicode());
         int ucSize = m_lmppData.m_unicodeBuf.length();
         for(i = 0; i < ucSize; ++i)
         {
             pBuf[i] = pBuf[i].toUpper();
         }
     }
 
     // Ignore comments
     if(m_pOptions->m_bIgnoreComments)
     {
         m_lmppData.removeComments();
         int vSize = min2(m_normalData.m_vSize, m_lmppData.m_vSize);
         for(int i = 0; i < 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.*/
 void SourceData::FileData::preprocess(bool bPreserveCR, QTextCodec* pEncoding)
 {
     //m_unicodeBuf = decodeString( m_pBuf, m_size, eEncoding );
 
     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;
 
     QByteArray ba = QByteArray::fromRawData(m_pBuf + skipBytes, 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;
 }
 
 // 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.
 static void checkLineForComments(
     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)
             {
                 memset(&p[commentStart], ' ', i - commentStart);
             }
             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)
                     {
                         memset(&p[commentStart], ' ', i - commentStart);
                     }
                     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;
     QChar* p = const_cast<QChar*>(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)
                     {
                         memset(&p[commentStart], ' ', i - commentStart);
                     }
                     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, int size1, const LineData* p2, int 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);
 
         int equalLinesAtStart = comparisonInput.file[0].prefix_lines;
         int currentLine1 = 0;
         int 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;
 
             int 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
     {
         int l1 = 0;
         int 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, int size1, const LineData* p2, int 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, int sizeA, const LineData* pldB, int sizeB, const LineData* pldC, int 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, int size1, const T* p2, int 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
     {
         int l1 = 0;
         int 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;
     int k1 = 0;
     int 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/directorymergewindow.cpp b/src/directorymergewindow.cpp
index 61f4fa3..fef96f1 100644
--- a/src/directorymergewindow.cpp
+++ b/src/directorymergewindow.cpp
@@ -1,3736 +1,3737 @@
 /***************************************************************************
                           directorymergewindow.cpp
                              -----------------
     begin                : Sat Oct 19 2002
     copyright            : (C) 2002-2011 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.                                   *
  *                                                                         *
  ***************************************************************************/
 #ifdef Q_OS_WIN
 #include <qt_windows.h>
 #endif
 
 #include "directorymergewindow.h"
 #include "guiutils.h"
 #include "options.h"
 #include "progress.h"
 
 #include <algorithm>
 #include <map>
 #include <vector>
 
 #include <QAction>
 #include <QApplication>
 #include <QDir>
 #include <QFileDialog>
 #include <QImage>
 #include <QKeyEvent>
 #include <QLabel>
 #include <QLayout>
 #include <QMenu>
 #include <QMessageBox>
 #include <QPixmap>
 #include <QPushButton>
 #include <QRegExp>
 #include <QSplitter>
 #include <QStyledItemDelegate>
 #include <QTextEdit>
 #include <QTextStream>
 
 #include <KIconLoader>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KToggleAction>
 
 static bool conflictingFileTypes(MergeFileInfos& mfi);
 static QPixmap getOnePixmap(e_Age eAge, bool bLink, bool bDir);
 
 class StatusInfo : public QDialog
 {
     QTextEdit* m_pTextEdit;
 
   public:
     explicit StatusInfo(QWidget* pParent) : QDialog(pParent)
     {
         QVBoxLayout* pVLayout = new QVBoxLayout(this);
         m_pTextEdit = new QTextEdit(this);
         pVLayout->addWidget(m_pTextEdit);
         setObjectName("StatusInfo");
         setWindowFlags(Qt::Dialog);
         m_pTextEdit->setWordWrapMode(QTextOption::NoWrap);
         m_pTextEdit->setReadOnly(true);
         QPushButton* pClose = new QPushButton(tr("Close"));
         connect(pClose, &QPushButton::clicked, this, &QDialog::accept);
         pVLayout->addWidget(pClose);
     }
 
     bool isEmpty()
     {
         return m_pTextEdit->toPlainText().isEmpty();
     }
 
     void addText(const QString& s)
     {
         m_pTextEdit->append(s);
     }
 
     void clear()
     {
         m_pTextEdit->clear();
     }
 
     void setVisible(bool bVisible) override
     {
         if(bVisible)
         {
             m_pTextEdit->moveCursor(QTextCursor::End);
             m_pTextEdit->moveCursor(QTextCursor::StartOfLine);
             m_pTextEdit->ensureCursorVisible();
         }
 
         QDialog::setVisible(bVisible);
         if(bVisible)
             setWindowState(windowState() | Qt::WindowMaximized);
     }
 };
 
 class TempRemover
 {
   public:
     TempRemover(const QString& origName, FileAccess& fa);
     ~TempRemover();
     QString name() { return m_name; }
     bool success() { return m_bSuccess; }
 
   private:
     QString m_name;
     bool m_bTemp;
     bool m_bSuccess;
 };
 TempRemover::TempRemover(const QString& origName, FileAccess& fa)
 {
     if(fa.isLocal())
     {
         m_name = origName;
         m_bTemp = false;
         m_bSuccess = true;
     }
     else
     {
         m_name = FileAccess::tempFileName();
         m_bSuccess = fa.copyFile(m_name);
         m_bTemp = m_bSuccess;
     }
 }
 TempRemover::~TempRemover()
 {
     if(m_bTemp && !m_name.isEmpty())
         FileAccess::removeTempFile(m_name);
 }
 
 enum Columns
 {
     s_NameCol = 0,
     s_ACol = 1,
     s_BCol = 2,
     s_CCol = 3,
     s_OpCol = 4,
     s_OpStatusCol = 5,
     s_UnsolvedCol = 6, // Nr of unsolved conflicts (for 3 input files)
     s_SolvedCol = 7,   // Nr of auto-solvable conflicts (for 3 input files)
     s_NonWhiteCol = 8, // Nr of nonwhite deltas (for 2 input files)
     s_WhiteCol = 9     // Nr of white deltas (for 2 input files)
 };
 
 enum e_OperationStatus
 {
     eOpStatusNone,
     eOpStatusDone,
     eOpStatusError,
     eOpStatusSkipped,
     eOpStatusNotSaved,
     eOpStatusInProgress,
     eOpStatusToDo
 };
 
 class MergeFileInfos
 {
   public:
     MergeFileInfos()
     {
         m_bEqualAB = false;
         m_bEqualAC = false;
         m_bEqualBC = false;
         m_pParent = nullptr;
         m_bOperationComplete = false;
         m_bSimOpComplete = false;
         m_eMergeOperation = eNoOperation;
         m_eOpStatus = eOpStatusNone;
         m_ageA = eNotThere;
         m_ageB = eNotThere;
         m_ageC = eNotThere;
         m_bConflictingAges = false;
         m_pFileInfoA = nullptr;
         m_pFileInfoB = nullptr;
         m_pFileInfoC = nullptr;
     }
     ~MergeFileInfos()
     {
         //for( int i=0; i<m_children.count(); ++i )
         //   delete m_children[i];
         m_children.clear();
     }
     //bool operator>( const MergeFileInfos& );
     QString subPath() const
     {
         return m_pFileInfoA && m_pFileInfoA->exists() ? m_pFileInfoA->filePath() : m_pFileInfoB && m_pFileInfoB->exists() ? m_pFileInfoB->filePath() : m_pFileInfoC && m_pFileInfoC->exists() ? m_pFileInfoC->filePath() : QString("");
     }
     QString fileName() const
     {
         return m_pFileInfoA && m_pFileInfoA->exists() ? m_pFileInfoA->fileName() : m_pFileInfoB && m_pFileInfoB->exists() ? m_pFileInfoB->fileName() : m_pFileInfoC && m_pFileInfoC->exists() ? m_pFileInfoC->fileName() : QString("");
     }
     bool dirA() const { return m_pFileInfoA ? m_pFileInfoA->isDir() : false; }
     bool dirB() const { return m_pFileInfoB ? m_pFileInfoB->isDir() : false; }
     bool dirC() const { return m_pFileInfoC ? m_pFileInfoC->isDir() : false; }
     bool isLinkA() const { return m_pFileInfoA ? m_pFileInfoA->isSymLink() : false; }
     bool isLinkB() const { return m_pFileInfoB ? m_pFileInfoB->isSymLink() : false; }
     bool isLinkC() const { return m_pFileInfoC ? m_pFileInfoC->isSymLink() : false; }
     bool existsInA() const { return m_pFileInfoA != nullptr; }
     bool existsInB() const { return m_pFileInfoB != nullptr; }
     bool existsInC() const { return m_pFileInfoC != nullptr; }
     MergeFileInfos* m_pParent;
     FileAccess* m_pFileInfoA;
     FileAccess* m_pFileInfoB;
     FileAccess* m_pFileInfoC;
     TotalDiffStatus m_totalDiffStatus;
     QList<MergeFileInfos*> m_children;
 
     e_MergeOperation m_eMergeOperation : 5;
     e_OperationStatus m_eOpStatus : 4;
 
     e_Age m_ageA : 3;
     e_Age m_ageB : 3;
     e_Age m_ageC : 3;
 
     bool m_bOperationComplete : 1;
     bool m_bSimOpComplete : 1;
 
     bool m_bEqualAB : 1;
     bool m_bEqualAC : 1;
     bool m_bEqualBC : 1;
     bool m_bConflictingAges : 1; // Equal age but files are not!
 };
 
 static Qt::CaseSensitivity s_eCaseSensitivity = Qt::CaseSensitive;
 
 class DirectoryMergeWindow::Data : public QAbstractItemModel
 {
   public:
     DirectoryMergeWindow* q;
     explicit Data(DirectoryMergeWindow* pDMW)
     {
         q = pDMW;
         m_pOptions = nullptr;
         m_pIconLoader = nullptr;
         m_pDirectoryMergeInfo = nullptr;
         m_bSimulatedMergeStarted = false;
         m_bRealMergeStarted = false;
         m_bError = false;
         m_bSyncMode = false;
         m_pStatusInfo = new StatusInfo(q);
         m_pStatusInfo->hide();
         m_bScanning = false;
         m_bCaseSensitive = true;
         m_bUnfoldSubdirs = false;
         m_bSkipDirStatus = false;
         m_pRoot = new MergeFileInfos;
     }
     ~Data() override
     {
         delete m_pRoot;
     }
     // Implement QAbstractItemModel
     QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
     //Qt::ItemFlags flags ( const QModelIndex & index ) const
     QModelIndex parent(const QModelIndex& index) const override
     {
         MergeFileInfos* pMFI = getMFI(index);
         if(pMFI == nullptr || pMFI == m_pRoot || pMFI->m_pParent == m_pRoot)
             return QModelIndex();
         else
         {
             MergeFileInfos* pParentsParent = pMFI->m_pParent->m_pParent;
             return createIndex(pParentsParent->m_children.indexOf(pMFI->m_pParent), 0, pMFI->m_pParent);
         }
     }
     int rowCount(const QModelIndex& parent = QModelIndex()) const override
     {
         MergeFileInfos* pParentMFI = getMFI(parent);
         if(pParentMFI != nullptr)
             return pParentMFI->m_children.count();
         else
             return m_pRoot->m_children.count();
     }
     int columnCount(const QModelIndex& /*parent*/) const override
     {
         return 10;
     }
     QModelIndex index(int row, int column, const QModelIndex& parent) const override
     {
         MergeFileInfos* pParentMFI = getMFI(parent);
         if(pParentMFI == nullptr && row < m_pRoot->m_children.count())
             return createIndex(row, column, m_pRoot->m_children[row]);
         else if(pParentMFI != nullptr && row < pParentMFI->m_children.count())
             return createIndex(row, column, pParentMFI->m_children[row]);
         else
             return QModelIndex();
     }
     QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
     void sort(int column, Qt::SortOrder order) override;
     // private data and helper methods
     MergeFileInfos* getMFI(const QModelIndex& mi) const
     {
         if(mi.isValid())
             return (MergeFileInfos*)mi.internalPointer();
         else
             return nullptr;
     }
     MergeFileInfos* m_pRoot;
 
     QString fullNameA(const MergeFileInfos& mfi)
     {
         return mfi.existsInA() ? mfi.m_pFileInfoA->absoluteFilePath() : m_dirA.absoluteFilePath() + "/" + mfi.subPath();
     }
     QString fullNameB(const MergeFileInfos& mfi)
     {
         return mfi.existsInB() ? mfi.m_pFileInfoB->absoluteFilePath() : m_dirB.absoluteFilePath() + "/" + mfi.subPath();
     }
     QString fullNameC(const MergeFileInfos& mfi)
     {
         return mfi.existsInC() ? mfi.m_pFileInfoC->absoluteFilePath() : m_dirC.absoluteFilePath() + "/" + mfi.subPath();
     }
     QString fullNameDest(const MergeFileInfos& mfi)
     {
         if(m_dirDestInternal.prettyAbsPath() == m_dirC.prettyAbsPath())
             return fullNameC(mfi);
         else if(m_dirDestInternal.prettyAbsPath() == m_dirB.prettyAbsPath())
             return fullNameB(mfi);
         else
             return m_dirDestInternal.absoluteFilePath() + "/" + mfi.subPath();
     }
 
     FileAccess m_dirA;
     FileAccess m_dirB;
     FileAccess m_dirC;
     FileAccess m_dirDest;
     FileAccess m_dirDestInternal;
     Options* m_pOptions;
 
     void calcDirStatus(bool bThreeDirs, const QModelIndex& mi,
                        int& nofFiles, int& nofDirs, int& nofEqualFiles, int& nofManualMerges);
 
     void mergeContinue(bool bStart, bool bVerbose);
 
     void prepareListView(ProgressProxy& pp);
     void calcSuggestedOperation(const QModelIndex& mi, e_MergeOperation eDefaultOperation);
     void setAllMergeOperations(e_MergeOperation eDefaultOperation);
     friend class MergeFileInfos;
 
     bool canContinue();
     QModelIndex treeIterator(QModelIndex mi, bool bVisitChildren = true, bool bFindInvisible = false);
     void prepareMergeStart(const QModelIndex& miBegin, const QModelIndex& miEnd, bool bVerbose);
     bool executeMergeOperation(MergeFileInfos& mfi, bool& bSingleFileMerge);
 
     void scanDirectory(const QString& dirName, t_DirectoryList& dirList);
     void scanLocalDirectory(const QString& dirName, t_DirectoryList& dirList);
     bool fastFileComparison(FileAccess& fi1, FileAccess& fi2,
                             bool& bError, QString& status);
     void compareFilesAndCalcAges(MergeFileInfos& mfi);
 
     void setMergeOperation(const QModelIndex& mi, e_MergeOperation eMergeOp, bool bRecursive = true);
     bool isDir(const QModelIndex& mi);
     QString getFileName(const QModelIndex& mi);
 
     bool copyFLD(const QString& srcName, const QString& destName);
     bool deleteFLD(const QString& name, bool bCreateBackup);
     bool makeDir(const QString& name, bool bQuiet = false);
     bool renameFLD(const QString& srcName, const QString& destName);
     bool mergeFLD(const QString& nameA, const QString& nameB, const QString& nameC,
                   const QString& nameDest, bool& bSingleFileMerge);
 
     t_DirectoryList m_dirListA;
     t_DirectoryList m_dirListB;
     t_DirectoryList m_dirListC;
 
     QString m_dirMergeStateFilename;
 
     class FileKey
     {
       public:
         const FileAccess* m_pFA;
         explicit FileKey(const FileAccess& fa) : m_pFA(&fa) {}
 
         int getParents(const FileAccess* pFA, const FileAccess* v[]) const
         {
             int s = 0;
             for(s = 0; pFA->parent() != nullptr; pFA = pFA->parent(), ++s)
                 v[s] = pFA;
             return s;
         }
 
         // This is essentially the same as
         // int r = filePath().compare( fa.filePath() )
         // if ( r<0 ) return true;
         // if ( r==0 ) return m_col < fa.m_col;
         // return false;
         bool operator<(const FileKey& fk) const
         {
             const FileAccess* v1[100];
             const FileAccess* v2[100];
             int v1Size = getParents(m_pFA, v1);
             int v2Size = getParents(fk.m_pFA, v2);
 
             for(int i = 0; i < v1Size && i < v2Size; ++i)
             {
                 int r = v1[v1Size - i - 1]->fileName().compare(v2[v2Size - i - 1]->fileName(), s_eCaseSensitivity);
                 if(r < 0)
                     return true;
                 else if(r > 0)
                     return false;
             }
 
             if(v1Size < v2Size)
                 return true;
             return false;
         }
     };
     typedef QMap<FileKey, MergeFileInfos> t_fileMergeMap;
     t_fileMergeMap m_fileMergeMap;
 
     bool m_bFollowDirLinks;
     bool m_bFollowFileLinks;
     bool m_bSimulatedMergeStarted;
     bool m_bRealMergeStarted;
     bool m_bError;
     bool m_bSyncMode;
     bool m_bDirectoryMerge; // if true, then merge is the default operation, otherwise it's diff.
     bool m_bCaseSensitive;
     bool m_bUnfoldSubdirs;
     bool m_bSkipDirStatus;
     bool m_bScanning; // true while in init()
 
     KIconLoader* m_pIconLoader;
     DirectoryMergeInfo* m_pDirectoryMergeInfo;
     StatusInfo* m_pStatusInfo;
 
     typedef std::list<QModelIndex> MergeItemList; // linked list
     MergeItemList m_mergeItemList;
     MergeItemList::iterator m_currentIndexForOperation;
 
     QModelIndex m_selection1Index;
     QModelIndex m_selection2Index;
     QModelIndex m_selection3Index;
     void selectItemAndColumn(const QModelIndex& mi, bool bContextMenu);
     friend class DirMergeItem;
 
     QAction* m_pDirStartOperation;
     QAction* m_pDirRunOperationForCurrentItem;
     QAction* m_pDirCompareCurrent;
     QAction* m_pDirMergeCurrent;
     QAction* m_pDirRescan;
     QAction* m_pDirChooseAEverywhere;
     QAction* m_pDirChooseBEverywhere;
     QAction* m_pDirChooseCEverywhere;
     QAction* m_pDirAutoChoiceEverywhere;
     QAction* m_pDirDoNothingEverywhere;
     QAction* m_pDirFoldAll;
     QAction* m_pDirUnfoldAll;
 
     KToggleAction* m_pDirShowIdenticalFiles;
     KToggleAction* m_pDirShowDifferentFiles;
     KToggleAction* m_pDirShowFilesOnlyInA;
     KToggleAction* m_pDirShowFilesOnlyInB;
     KToggleAction* m_pDirShowFilesOnlyInC;
 
     KToggleAction* m_pDirSynchronizeDirectories;
     KToggleAction* m_pDirChooseNewerFiles;
 
     QAction* m_pDirCompareExplicit;
     QAction* m_pDirMergeExplicit;
 
     QAction* m_pDirCurrentDoNothing;
     QAction* m_pDirCurrentChooseA;
     QAction* m_pDirCurrentChooseB;
     QAction* m_pDirCurrentChooseC;
     QAction* m_pDirCurrentMerge;
     QAction* m_pDirCurrentDelete;
 
     QAction* m_pDirCurrentSyncDoNothing;
     QAction* m_pDirCurrentSyncCopyAToB;
     QAction* m_pDirCurrentSyncCopyBToA;
     QAction* m_pDirCurrentSyncDeleteA;
     QAction* m_pDirCurrentSyncDeleteB;
     QAction* m_pDirCurrentSyncDeleteAAndB;
     QAction* m_pDirCurrentSyncMergeToA;
     QAction* m_pDirCurrentSyncMergeToB;
     QAction* m_pDirCurrentSyncMergeToAAndB;
 
     QAction* m_pDirSaveMergeState;
     QAction* m_pDirLoadMergeState;
 
     bool init(FileAccess& dirA, FileAccess& dirB, FileAccess& dirC, FileAccess& dirDest, bool bDirectoryMerge, bool bReload);
     void setOpStatus(const QModelIndex& mi, e_OperationStatus eOpStatus)
     {
         if(MergeFileInfos* pMFI = getMFI(mi))
         {
             pMFI->m_eOpStatus = eOpStatus;
             emit dataChanged(mi, mi);
         }
     }
 };
 
 QVariant DirectoryMergeWindow::Data::data(const QModelIndex& index, int role) const
 {
     MergeFileInfos* pMFI = getMFI(index);
     if(pMFI)
     {
         if(role == Qt::DisplayRole)
         {
             switch(index.column())
             {
             case s_NameCol:
                 return QFileInfo(pMFI->subPath()).fileName();
             case s_ACol:
                 return "A";
             case s_BCol:
                 return "B";
             case s_CCol:
                 return "C";
             //case s_OpCol:       return i18n("Operation");
             //case s_OpStatusCol: return i18n("Status");
             case s_UnsolvedCol:
                 return i18n("Unsolved");
             case s_SolvedCol:
                 return i18n("Solved");
             case s_NonWhiteCol:
                 return i18n("Nonwhite");
             case s_WhiteCol:
                 return i18n("White");
                 //default :           return QVariant();
             }
 
             if(s_OpCol == index.column())
             {
                 bool bDir = pMFI->dirA() || pMFI->dirB() || pMFI->dirC();
                 switch(pMFI->m_eMergeOperation)
                 {
                 case eNoOperation:
                     return "";
                     break;
                 case eCopyAToB:
                     return i18n("Copy A to B");
                     break;
                 case eCopyBToA:
                     return i18n("Copy B to A");
                     break;
                 case eDeleteA:
                     return i18n("Delete A");
                     break;
                 case eDeleteB:
                     return i18n("Delete B");
                     break;
                 case eDeleteAB:
                     return i18n("Delete A & B");
                     break;
                 case eMergeToA:
                     return i18n("Merge to A");
                     break;
                 case eMergeToB:
                     return i18n("Merge to B");
                     break;
                 case eMergeToAB:
                     return i18n("Merge to A & B");
                     break;
                 case eCopyAToDest:
                     return "A";
                     break;
                 case eCopyBToDest:
                     return "B";
                     break;
                 case eCopyCToDest:
                     return "C";
                     break;
                 case eDeleteFromDest:
                     return i18n("Delete (if exists)");
                     break;
                 case eMergeABCToDest:
                     return bDir ? i18n("Merge") : i18n("Merge (manual)");
                     break;
                 case eMergeABToDest:
                     return bDir ? i18n("Merge") : i18n("Merge (manual)");
                     break;
                 case eConflictingFileTypes:
                     return i18n("Error: Conflicting File Types");
                     break;
                 case eChangedAndDeleted:
                     return i18n("Error: Changed and Deleted");
                     break;
                 case eConflictingAges:
                     return i18n("Error: Dates are equal but files are not.");
                     break;
                 default:
                     Q_ASSERT(true);
                     break;
                 }
             }
             if(s_OpStatusCol == index.column())
             {
                 switch(pMFI->m_eOpStatus)
                 {
                 case eOpStatusNone:
                     return "";
                 case eOpStatusDone:
                     return i18n("Done");
                 case eOpStatusError:
                     return i18n("Error");
                 case eOpStatusSkipped:
                     return i18n("Skipped.");
                 case eOpStatusNotSaved:
                     return i18n("Not saved.");
                 case eOpStatusInProgress:
                     return i18n("In progress...");
                 case eOpStatusToDo:
                     return i18n("To do.");
                 }
             }
         }
         else if(role == Qt::DecorationRole)
         {
             if(s_NameCol == index.column())
             {
                 return getOnePixmap(eAgeEnd, pMFI->isLinkA() || pMFI->isLinkB() || pMFI->isLinkC(),
                                     pMFI->dirA() || pMFI->dirB() || pMFI->dirC());
             }
 
             if(s_ACol == index.column())
             {
                 return getOnePixmap(pMFI->m_ageA, pMFI->isLinkA(), pMFI->dirA());
             }
             if(s_BCol == index.column())
             {
                 return getOnePixmap(pMFI->m_ageB, pMFI->isLinkB(), pMFI->dirB());
             }
             if(s_CCol == index.column())
             {
                 return getOnePixmap(pMFI->m_ageC, pMFI->isLinkC(), pMFI->dirC());
             }
         }
         else if(role == Qt::TextAlignmentRole)
         {
             if(s_UnsolvedCol == index.column() || s_SolvedCol == index.column() || s_NonWhiteCol == index.column() || s_WhiteCol == index.column())
                 return Qt::AlignRight;
         }
     }
     return QVariant();
 }
 
 QVariant DirectoryMergeWindow::Data::headerData(int section, Qt::Orientation orientation, int role) const
 {
     if(orientation == Qt::Horizontal && section >= 0 && section < columnCount(QModelIndex()) && role == Qt::DisplayRole)
     {
         switch(section)
         {
         case s_NameCol:
             return i18n("Name");
         case s_ACol:
             return "A";
         case s_BCol:
             return "B";
         case s_CCol:
             return "C";
         case s_OpCol:
             return i18n("Operation");
         case s_OpStatusCol:
             return i18n("Status");
         case s_UnsolvedCol:
             return i18n("Unsolved");
         case s_SolvedCol:
             return i18n("Solved");
         case s_NonWhiteCol:
             return i18n("Nonwhite");
         case s_WhiteCol:
             return i18n("White");
         default:
             return QVariant();
         }
     }
     return QVariant();
 }
 
 // Previously  Q3ListViewItem::paintCell(p,cg,column,width,align);
 class DirectoryMergeWindow::DirMergeItemDelegate : public QStyledItemDelegate
 {
     DirectoryMergeWindow* m_pDMW;
     DirectoryMergeWindow::Data* d;
 
   public:
     explicit DirMergeItemDelegate(DirectoryMergeWindow* pParent)
         : QStyledItemDelegate(pParent), m_pDMW(pParent), d(pParent->d)
     {
     }
     void paint(QPainter* p, const QStyleOptionViewItem& option, const QModelIndex& index) const override
     {
         int column = index.column();
         if(column == s_ACol || column == s_BCol || column == s_CCol)
         {
             QVariant value = index.data(Qt::DecorationRole);
             QPixmap icon;
             if(value.isValid())
             {
                 if(value.type() == QVariant::Icon)
                 {
                     icon = qvariant_cast<QIcon>(value).pixmap(16, 16);
                     //icon = qvariant_cast<QIcon>(value);
                     //decorationRect = QRect(QPoint(0, 0), icon.actualSize(option.decorationSize, iconMode, iconState));
                 }
                 else
                 {
                     icon = qvariant_cast<QPixmap>(value);
                     //decorationRect = QRect(QPoint(0, 0), option.decorationSize).intersected(pixmap.rect());
                 }
             }
 
             int x = option.rect.left();
             int y = option.rect.top();
             //QPixmap icon = value.value<QPixmap>(); //pixmap(column);
             if(!icon.isNull())
             {
                 int yOffset = (sizeHint(option, index).height() - icon.height()) / 2;
                 p->drawPixmap(x + 2, y + yOffset, icon);
 
                 int i = index == d->m_selection1Index ? 1 : index == d->m_selection2Index ? 2 : index == d->m_selection3Index ? 3 : 0;
                 if(i != 0)
                 {
                     Options* pOpts = d->m_pOptions;
                     QColor c(i == 1 ? pOpts->m_colorA : i == 2 ? pOpts->m_colorB : pOpts->m_colorC);
                     p->setPen(c); // highlight() );
                     p->drawRect(x + 2, y + yOffset, icon.width(), icon.height());
                     p->setPen(QPen(c, 0, Qt::DotLine));
                     p->drawRect(x + 1, y + yOffset - 1, icon.width() + 2, icon.height() + 2);
                     p->setPen(Qt::white);
                     QString s(QChar('A' + i - 1));
                     p->drawText(x + 2 + (icon.width() - p->fontMetrics().width(s)) / 2,
                                 y + yOffset + (icon.height() + p->fontMetrics().ascent()) / 2 - 1,
                                 s);
                 }
                 else
                 {
                     p->setPen(m_pDMW->palette().background().color());
                     p->drawRect(x + 1, y + yOffset - 1, icon.width() + 2, icon.height() + 2);
                 }
                 return;
             }
         }
         QStyleOptionViewItem option2 = option;
         if(column >= s_UnsolvedCol)
         {
             option2.displayAlignment = Qt::AlignRight;
         }
         QStyledItemDelegate::paint(p, option2, index);
     }
     QSize sizeHint(const QStyleOptionViewItem& option, const QModelIndex& index) const override
     {
         QSize sz = QStyledItemDelegate::sizeHint(option, index);
         return sz.expandedTo(QSize(0, 18));
     }
 };
 
 DirectoryMergeWindow::DirectoryMergeWindow(QWidget* pParent, Options* pOptions, KIconLoader* pIconLoader)
     : QTreeView(pParent)
 {
     d = new Data(this);
     setModel(d);
     setItemDelegate(new DirMergeItemDelegate(this));
     connect(this, &DirectoryMergeWindow::doubleClicked, this, &DirectoryMergeWindow::onDoubleClick);
     connect(this, &DirectoryMergeWindow::expanded, this, &DirectoryMergeWindow::onExpanded);
 
     d->m_pOptions = pOptions;
     d->m_pIconLoader = pIconLoader;
 
     setSortingEnabled(true);
 }
 
 DirectoryMergeWindow::~DirectoryMergeWindow()
 {
     delete d;
 }
 
 QString DirectoryMergeWindow::getDirNameA() { return d->m_dirA.prettyAbsPath(); }
 QString DirectoryMergeWindow::getDirNameB() { return d->m_dirB.prettyAbsPath(); }
 QString DirectoryMergeWindow::getDirNameC() { return d->m_dirC.prettyAbsPath(); }
 QString DirectoryMergeWindow::getDirNameDest() { return d->m_dirDest.prettyAbsPath(); }
 void DirectoryMergeWindow::setDirectoryMergeInfo(DirectoryMergeInfo* p) { d->m_pDirectoryMergeInfo = p; }
 bool DirectoryMergeWindow::isDirectoryMergeInProgress() { return d->m_bRealMergeStarted; }
 bool DirectoryMergeWindow::isSyncMode() { return d->m_bSyncMode; }
 bool DirectoryMergeWindow::isScanning() { return d->m_bScanning; }
 
 bool DirectoryMergeWindow::Data::fastFileComparison(
     FileAccess& fi1, FileAccess& fi2,
     bool& bError, QString& status)
 {
     ProgressProxy pp;
     status = "";
     bool bEqual = false;
     bError = true;
 
     if(!m_bFollowFileLinks)
     {
         if(fi1.isSymLink() != fi2.isSymLink())
         {
             status = i18n("Mix of links and normal files.");
             return bEqual;
         }
         else if(fi1.isSymLink() && fi2.isSymLink())
         {
             bError = false;
             bEqual = fi1.readLink() == fi2.readLink();
             status = i18n("Link: ");
             return bEqual;
         }
     }
 
     if(fi1.size() != fi2.size())
     {
         bEqual = false;
         status = i18n("Size. ");
         return bEqual;
     }
     else if(m_pOptions->m_bDmTrustSize)
     {
         bEqual = true;
         return bEqual;
     }
 
     if(m_pOptions->m_bDmTrustDate)
     {
         bEqual = (fi1.lastModified() == fi2.lastModified() && fi1.size() == fi2.size());
         bError = false;
         status = i18n("Date & Size: ");
         return bEqual;
     }
 
     if(m_pOptions->m_bDmTrustDateFallbackToBinary)
     {
         bEqual = (fi1.lastModified() == fi2.lastModified() && fi1.size() == fi2.size());
         if(bEqual)
         {
             bError = false;
             status = i18n("Date & Size: ");
             return bEqual;
         }
     }
 
     QString fileName1 = fi1.absoluteFilePath();
     QString fileName2 = fi2.absoluteFilePath();
     TempRemover tr1(fileName1, fi1);
     if(!tr1.success())
     {
         status = i18n("Creating temp copy of %1 failed.", fileName1);
         return bEqual;
     }
     TempRemover tr2(fileName2, fi2);
     if(!tr2.success())
     {
         status = i18n("Creating temp copy of %1 failed.", fileName2);
         return bEqual;
     }
 
     std::vector<char> buf1(100000);
     std::vector<char> buf2(buf1.size());
 
     QFile file1(tr1.name());
 
     if(!file1.open(QIODevice::ReadOnly))
     {
         status = i18n("Opening %1 failed.", fileName1);
         return bEqual;
     }
 
     QFile file2(tr2.name());
 
     if(!file2.open(QIODevice::ReadOnly))
     {
         status = i18n("Opening %1 failed.", fileName2);
         return bEqual;
     }
 
     pp.setInformation(i18n("Comparing file..."), 0, false);
     typedef qint64 t_FileSize;
     t_FileSize fullSize = file1.size();
     t_FileSize sizeLeft = fullSize;
 
     pp.setMaxNofSteps(fullSize / buf1.size());
 
     while(sizeLeft > 0 && !pp.wasCancelled())
     {
         int len = min2(sizeLeft, (t_FileSize)buf1.size());
         if(len != file1.read(&buf1[0], len))
         {
             status = i18n("Error reading from %1", fileName1);
             return bEqual;
         }
 
         if(len != file2.read(&buf2[0], len))
         {
             status = i18n("Error reading from %1", fileName2);
             return bEqual;
         }
 
         if(memcmp(&buf1[0], &buf2[0], len) != 0)
         {
             bError = false;
             return bEqual;
         }
         sizeLeft -= len;
         //pp.setCurrent(double(fullSize-sizeLeft)/fullSize, false );
         pp.step();
     }
 
     // If the program really arrives here, then the files are really equal.
     bError = false;
     bEqual = true;
     return bEqual;
 }
 
 int DirectoryMergeWindow::totalColumnWidth()
 {
     int w = 0;
     for(int i = 0; i < s_OpStatusCol; ++i)
     {
         w += columnWidth(i);
     }
     return w;
 }
 
 void DirectoryMergeWindow::reload()
 {
     if(isDirectoryMergeInProgress())
     {
         int result = KMessageBox::warningYesNo(this,
                                                i18n("You are currently doing a directory merge. Are you sure, you want to abort the merge and rescan the directory?"),
                                                i18n("Warning"),
                                                KGuiItem(i18n("Rescan")),
                                                KGuiItem(i18n("Continue Merging")));
         if(result != KMessageBox::Yes)
             return;
     }
 
     init(d->m_dirA, d->m_dirB, d->m_dirC, d->m_dirDest, d->m_bDirectoryMerge, true);
     //fix file visibilities after reload or menu will be out of sync with display if changed from defaults.
     updateFileVisibilities();
 }
 
 // Copy pm2 onto pm1, but preserve the alpha value from pm1 where pm2 is transparent.
 static QPixmap pixCombiner(const QPixmap* pm1, const QPixmap* pm2)
 {
     QImage img1 = pm1->toImage().convertToFormat(QImage::Format_ARGB32);
     QImage img2 = pm2->toImage().convertToFormat(QImage::Format_ARGB32);
 
     for(int y = 0; y < img1.height(); y++)
     {
         quint32* line1 = reinterpret_cast<quint32*>(img1.scanLine(y));
         quint32* line2 = reinterpret_cast<quint32*>(img2.scanLine(y));
         for(int x = 0; x < img1.width(); x++)
         {
             if(qAlpha(line2[x]) > 0)
                 line1[x] = (line2[x] | 0xff000000);
         }
     }
     return QPixmap::fromImage(img1);
 }
 
 // like pixCombiner but let the pm1 color shine through
 static QPixmap pixCombiner2(const QPixmap* pm1, const QPixmap* pm2)
 {
     QPixmap pix = *pm1;
     QPainter p(&pix);
     p.setOpacity(0.5);
     p.drawPixmap(0, 0, *pm2);
     p.end();
 
     return pix;
 }
 
 void DirectoryMergeWindow::Data::calcDirStatus(bool bThreeDirs, const QModelIndex& mi,
                                                int& nofFiles, int& nofDirs, int& nofEqualFiles, int& nofManualMerges)
 {
     MergeFileInfos* pMFI = getMFI(mi);
     if(pMFI->dirA() || pMFI->dirB() || pMFI->dirC())
     {
         ++nofDirs;
     }
     else
     {
         ++nofFiles;
         if(pMFI->m_bEqualAB && (!bThreeDirs || pMFI->m_bEqualAC))
         {
             ++nofEqualFiles;
         }
         else
         {
             if(pMFI->m_eMergeOperation == eMergeABCToDest || pMFI->m_eMergeOperation == eMergeABToDest)
                 ++nofManualMerges;
         }
     }
     for(int childIdx = 0; childIdx < rowCount(mi); ++childIdx)
         calcDirStatus(bThreeDirs, index(childIdx, 0, mi), nofFiles, nofDirs, nofEqualFiles, nofManualMerges);
 }
 
 struct t_ItemInfo {
     bool bExpanded;
     bool bOperationComplete;
     QString status;
     e_MergeOperation eMergeOperation;
 };
 
 bool DirectoryMergeWindow::init(
     FileAccess& dirA,
     FileAccess& dirB,
     FileAccess& dirC,
     FileAccess& dirDest,
     bool bDirectoryMerge,
     bool bReload)
 {
     return d->init(dirA, dirB, dirC, dirDest, bDirectoryMerge, bReload);
 }
 
 bool DirectoryMergeWindow::Data::init(
     FileAccess& dirA,
     FileAccess& dirB,
     FileAccess& dirC,
     FileAccess& dirDest,
     bool bDirectoryMerge,
     bool bReload)
 {
     if(m_pOptions->m_bDmFullAnalysis)
     {
         // A full analysis uses the same ressources that a normal text-diff/merge uses.
         // So make sure that the user saves his data first.
         bool bCanContinue = false;
         emit q->checkIfCanContinue(&bCanContinue);
         if(!bCanContinue)
             return false;
         emit q->startDiffMerge("", "", "", "", "", "", "", nullptr); // hide main window
     }
 
     q->show();
     q->setUpdatesEnabled(true);
 
     std::map<QString, t_ItemInfo> expandedDirsMap;
 
     if(bReload)
     {
         // Remember expanded items TODO
         //QTreeWidgetItemIterator it( this );
         //while ( *it )
         //{
         //   DirMergeItem* pDMI = static_cast<DirMergeItem*>( *it );
         //   t_ItemInfo& ii = expandedDirsMap[ pDMI->m_pMFI->subPath() ];
         //   ii.bExpanded = pDMI->isExpanded();
         //   ii.bOperationComplete = pDMI->m_pMFI->m_bOperationComplete;
         //   ii.status = pDMI->text( s_OpStatusCol );
         //   ii.eMergeOperation = pDMI->m_pMFI->m_eMergeOperation;
         //   ++it;
         //}
     }
 
     ProgressProxy pp;
     m_bFollowDirLinks = m_pOptions->m_bDmFollowDirLinks;
     m_bFollowFileLinks = m_pOptions->m_bDmFollowFileLinks;
     m_bSimulatedMergeStarted = false;
     m_bRealMergeStarted = false;
     m_bError = false;
     m_bDirectoryMerge = bDirectoryMerge;
     m_selection1Index = QModelIndex();
     m_selection2Index = QModelIndex();
     m_selection3Index = QModelIndex();
     m_bCaseSensitive = m_pOptions->m_bDmCaseSensitiveFilenameComparison;
     m_bUnfoldSubdirs = m_pOptions->m_bDmUnfoldSubdirs;
     m_bSkipDirStatus = m_pOptions->m_bDmSkipDirStatus;
 
     beginResetModel();
     m_pRoot->m_children.clear();
     m_mergeItemList.clear();
     endResetModel();
 
     m_currentIndexForOperation = m_mergeItemList.end();
 
     m_dirA = dirA;
     m_dirB = dirB;
     m_dirC = dirC;
     m_dirDest = dirDest;
 
     if(!bReload)
     {
         m_pDirShowIdenticalFiles->setChecked(true);
         m_pDirShowDifferentFiles->setChecked(true);
         m_pDirShowFilesOnlyInA->setChecked(true);
         m_pDirShowFilesOnlyInB->setChecked(true);
         m_pDirShowFilesOnlyInC->setChecked(true);
     }
 
     // Check if all input directories exist and are valid. The dest dir is not tested now.
     // The test will happen only when we are going to write to it.
     if(!m_dirA.isDir() || !m_dirB.isDir() ||
        (m_dirC.isValid() && !m_dirC.isDir()))
     {
         QString text(i18n("Opening of directories failed:"));
         text += "\n\n";
         if(!dirA.isDir())
         {
             text += i18n("Dir A \"%1\" does not exist or is not a directory.\n", m_dirA.prettyAbsPath());
         }
 
         if(!dirB.isDir())
         {
             text += i18n("Dir B \"%1\" does not exist or is not a directory.\n", m_dirB.prettyAbsPath());
         }
 
         if(m_dirC.isValid() && !m_dirC.isDir())
         {
             text += i18n("Dir C \"%1\" does not exist or is not a directory.\n", m_dirC.prettyAbsPath());
         }
 
         KMessageBox::sorry(q, text, i18n("Directory Open Error"));
         return false;
     }
 
     if(m_dirC.isValid() &&
        (m_dirDest.prettyAbsPath() == m_dirA.prettyAbsPath() || m_dirDest.prettyAbsPath() == m_dirB.prettyAbsPath()))
     {
         KMessageBox::error(q,
                            i18n("The destination directory must not be the same as A or B when "
                                 "three directories are merged.\nCheck again before continuing."),
                            i18n("Parameter Warning"));
         return false;
     }
 
     m_bScanning = true;
     emit q->statusBarMessage(i18n("Scanning directories..."));
 
     m_bSyncMode = m_pOptions->m_bDmSyncMode && !m_dirC.isValid() && !m_dirDest.isValid();
 
     if(m_dirDest.isValid())
         m_dirDestInternal = m_dirDest;
     else
         m_dirDestInternal = m_dirC.isValid() ? m_dirC : m_dirB;
 
     QString origCurrentDirectory = QDir::currentPath();
 
     m_fileMergeMap.clear();
     s_eCaseSensitivity = m_bCaseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive;
     t_DirectoryList::iterator i;
 
     // calc how many directories will be read:
     double nofScans = (m_dirA.isValid() ? 1 : 0) + (m_dirB.isValid() ? 1 : 0) + (m_dirC.isValid() ? 1 : 0);
     int currentScan = 0;
 
     //TODO   setColumnWidthMode(s_UnsolvedCol, Q3ListView::Manual);
     //   setColumnWidthMode(s_SolvedCol,   Q3ListView::Manual);
     //   setColumnWidthMode(s_WhiteCol,    Q3ListView::Manual);
     //   setColumnWidthMode(s_NonWhiteCol, Q3ListView::Manual);
     q->setColumnHidden(s_CCol, !m_dirC.isValid());
     q->setColumnHidden(s_WhiteCol, !m_pOptions->m_bDmFullAnalysis);
     q->setColumnHidden(s_NonWhiteCol, !m_pOptions->m_bDmFullAnalysis);
     q->setColumnHidden(s_UnsolvedCol, !m_pOptions->m_bDmFullAnalysis);
     q->setColumnHidden(s_SolvedCol, !(m_pOptions->m_bDmFullAnalysis && m_dirC.isValid()));
 
     bool bListDirSuccessA = true;
     bool bListDirSuccessB = true;
     bool bListDirSuccessC = true;
     m_dirListA.clear();
     m_dirListB.clear();
     m_dirListC.clear();
     if(m_dirA.isValid())
     {
         pp.setInformation(i18n("Reading Directory A"));
         pp.setSubRangeTransformation(currentScan / nofScans, (currentScan + 1) / nofScans);
         ++currentScan;
 
         bListDirSuccessA = m_dirA.listDir(&m_dirListA,
                                           m_pOptions->m_bDmRecursiveDirs, m_pOptions->m_bDmFindHidden,
                                           m_pOptions->m_DmFilePattern, m_pOptions->m_DmFileAntiPattern,
                                           m_pOptions->m_DmDirAntiPattern, m_pOptions->m_bDmFollowDirLinks,
                                           m_pOptions->m_bDmUseCvsIgnore);
 
         for(i = m_dirListA.begin(); i != m_dirListA.end(); ++i)
         {
             MergeFileInfos& mfi = m_fileMergeMap[FileKey(*i)];
             //std::cout <<i->filePath()<<std::endl;
             mfi.m_pFileInfoA = &(*i);
         }
     }
 
     if(m_dirB.isValid())
     {
         pp.setInformation(i18n("Reading Directory B"));
         pp.setSubRangeTransformation(currentScan / nofScans, (currentScan + 1) / nofScans);
         ++currentScan;
 
         bListDirSuccessB = m_dirB.listDir(&m_dirListB,
                                           m_pOptions->m_bDmRecursiveDirs, m_pOptions->m_bDmFindHidden,
                                           m_pOptions->m_DmFilePattern, m_pOptions->m_DmFileAntiPattern,
                                           m_pOptions->m_DmDirAntiPattern, m_pOptions->m_bDmFollowDirLinks,
                                           m_pOptions->m_bDmUseCvsIgnore);
 
         for(i = m_dirListB.begin(); i != m_dirListB.end(); ++i)
         {
             MergeFileInfos& mfi = m_fileMergeMap[FileKey(*i)];
             mfi.m_pFileInfoB = &(*i);
             if(mfi.m_pFileInfoA && mfi.m_pFileInfoA->fileName() == mfi.m_pFileInfoB->fileName())
                 mfi.m_pFileInfoB->setSharedName(mfi.m_pFileInfoA->fileName()); // Reduce memory by sharing the name.
         }
     }
 
     e_MergeOperation eDefaultMergeOp;
     if(m_dirC.isValid())
     {
         pp.setInformation(i18n("Reading Directory C"));
         pp.setSubRangeTransformation(currentScan / nofScans, (currentScan + 1) / nofScans);
         ++currentScan;
 
         bListDirSuccessC = m_dirC.listDir(&m_dirListC,
                                           m_pOptions->m_bDmRecursiveDirs, m_pOptions->m_bDmFindHidden,
                                           m_pOptions->m_DmFilePattern, m_pOptions->m_DmFileAntiPattern,
                                           m_pOptions->m_DmDirAntiPattern, m_pOptions->m_bDmFollowDirLinks,
                                           m_pOptions->m_bDmUseCvsIgnore);
 
         for(i = m_dirListC.begin(); i != m_dirListC.end(); ++i)
         {
             MergeFileInfos& mfi = m_fileMergeMap[FileKey(*i)];
             mfi.m_pFileInfoC = &(*i);
         }
 
         eDefaultMergeOp = eMergeABCToDest;
     }
     else
         eDefaultMergeOp = m_bSyncMode ? eMergeToAB : eMergeABToDest;
 
     bool bContinue = true;
     if(!bListDirSuccessA || !bListDirSuccessB || !bListDirSuccessC)
     {
         QString s = i18n("Some subdirectories were not readable in");
         if(!bListDirSuccessA) s += "\nA: " + m_dirA.prettyAbsPath();
         if(!bListDirSuccessB) s += "\nB: " + m_dirB.prettyAbsPath();
         if(!bListDirSuccessC) s += "\nC: " + m_dirC.prettyAbsPath();
         s += "\n";
         s += i18n("Check the permissions of the subdirectories.");
         bContinue = KMessageBox::Continue == KMessageBox::warningContinueCancel(q, s);
     }
 
     if(bContinue)
     {
         prepareListView(pp);
 
         q->updateFileVisibilities();
 
         for(int childIdx = 0; childIdx < rowCount(); ++childIdx)
         {
             QModelIndex mi = index(childIdx, 0, QModelIndex());
             calcSuggestedOperation(mi, eDefaultMergeOp);
         }
     }
 
     q->sortByColumn(0, Qt::AscendingOrder);
 
     for(int i = 0; i < columnCount(QModelIndex()); ++i)
         q->resizeColumnToContents(i);
 
     // Try to improve the view a little bit.
     QWidget* pParent = q->parentWidget();
     QSplitter* pSplitter = static_cast<QSplitter*>(pParent);
     if(pSplitter != nullptr)
     {
         QList<int> sizes = pSplitter->sizes();
         int total = sizes[0] + sizes[1];
         if(total < 10)
             total = 100;
         sizes[0] = total * 6 / 10;
         sizes[1] = total - sizes[0];
         pSplitter->setSizes(sizes);
     }
 
     QDir::setCurrent(origCurrentDirectory);
 
     m_bScanning = false;
     emit q->statusBarMessage(i18n("Ready."));
 
     if(bContinue && !m_bSkipDirStatus)
     {
         // Generate a status report
         int nofFiles = 0;
         int nofDirs = 0;
         int nofEqualFiles = 0;
         int nofManualMerges = 0;
         //TODO
         for(int childIdx = 0; childIdx < rowCount(); ++childIdx)
             calcDirStatus(m_dirC.isValid(), index(childIdx, 0, QModelIndex()),
                           nofFiles, nofDirs, nofEqualFiles, nofManualMerges);
 
         QString s;
         s = i18n("Directory Comparison Status") + "\n\n" +
             i18n("Number of subdirectories:") + " " + QString::number(nofDirs) + "\n" +
             i18n("Number of equal files:") + " " + QString::number(nofEqualFiles) + "\n" +
             i18n("Number of different files:") + " " + QString::number(nofFiles - nofEqualFiles);
 
         if(m_dirC.isValid())
             s += "\n" + i18n("Number of manual merges:") + " " + QString::number(nofManualMerges);
         KMessageBox::information(q, s);
         //
         //TODO
         //if ( topLevelItemCount()>0 )
         //{
         //   topLevelItem(0)->setSelected(true);
         //   setCurrentItem( topLevelItem(0) );
         //}
     }
 
     if(bReload)
     {
         // Remember expanded items
         //TODO
         //QTreeWidgetItemIterator it( this );
         //while ( *it )
         //{
         //   DirMergeItem* pDMI = static_cast<DirMergeItem*>( *it );
         //   std::map<QString,t_ItemInfo>::iterator i = expandedDirsMap.find( pDMI->m_pMFI->subPath() );
         //   if ( i!=expandedDirsMap.end() )
         //   {
         //      t_ItemInfo& ii = i->second;
         //      pDMI->setExpanded( ii.bExpanded );
         //      //pDMI->m_pMFI->setMergeOperation( ii.eMergeOperation, false ); unsafe, might have changed
         //      pDMI->m_pMFI->m_bOperationComplete = ii.bOperationComplete;
         //      pDMI->setText( s_OpStatusCol, ii.status );
         //   }
         //   ++it;
         //}
     }
     else if(m_bUnfoldSubdirs)
     {
         m_pDirUnfoldAll->trigger();
     }
 
     return true;
 }
 
 void DirectoryMergeWindow::onExpanded()
 {
     resizeColumnToContents(s_NameCol);
 }
 
 void DirectoryMergeWindow::slotChooseAEverywhere() { d->setAllMergeOperations(eCopyAToDest); }
 
 void DirectoryMergeWindow::slotChooseBEverywhere() { d->setAllMergeOperations(eCopyBToDest); }
 
 void DirectoryMergeWindow::slotChooseCEverywhere() { d->setAllMergeOperations(eCopyCToDest); }
 
 void DirectoryMergeWindow::slotAutoChooseEverywhere()
 {
     e_MergeOperation eDefaultMergeOp = d->m_dirC.isValid() ? eMergeABCToDest : d->m_bSyncMode ? eMergeToAB : eMergeABToDest;
     d->setAllMergeOperations(eDefaultMergeOp);
 }
 
 void DirectoryMergeWindow::slotNoOpEverywhere() { d->setAllMergeOperations(eNoOperation); }
 
 void DirectoryMergeWindow::slotFoldAllSubdirs()
 {
     collapseAll();
 }
 
 void DirectoryMergeWindow::slotUnfoldAllSubdirs()
 {
     expandAll();
 }
 
 // Merge current item (merge mode)
 void DirectoryMergeWindow::slotCurrentDoNothing() { d->setMergeOperation(currentIndex(), eNoOperation); }
 void DirectoryMergeWindow::slotCurrentChooseA() { d->setMergeOperation(currentIndex(), d->m_bSyncMode ? eCopyAToB : eCopyAToDest); }
 void DirectoryMergeWindow::slotCurrentChooseB() { d->setMergeOperation(currentIndex(), d->m_bSyncMode ? eCopyBToA : eCopyBToDest); }
 void DirectoryMergeWindow::slotCurrentChooseC() { d->setMergeOperation(currentIndex(), eCopyCToDest); }
 void DirectoryMergeWindow::slotCurrentMerge()
 {
     bool bThreeDirs = d->m_dirC.isValid();
     d->setMergeOperation(currentIndex(), bThreeDirs ? eMergeABCToDest : eMergeABToDest);
 }
 void DirectoryMergeWindow::slotCurrentDelete() { d->setMergeOperation(currentIndex(), eDeleteFromDest); }
 // Sync current item
 void DirectoryMergeWindow::slotCurrentCopyAToB() { d->setMergeOperation(currentIndex(), eCopyAToB); }
 void DirectoryMergeWindow::slotCurrentCopyBToA() { d->setMergeOperation(currentIndex(), eCopyBToA); }
 void DirectoryMergeWindow::slotCurrentDeleteA() { d->setMergeOperation(currentIndex(), eDeleteA); }
 void DirectoryMergeWindow::slotCurrentDeleteB() { d->setMergeOperation(currentIndex(), eDeleteB); }
 void DirectoryMergeWindow::slotCurrentDeleteAAndB() { d->setMergeOperation(currentIndex(), eDeleteAB); }
 void DirectoryMergeWindow::slotCurrentMergeToA() { d->setMergeOperation(currentIndex(), eMergeToA); }
 void DirectoryMergeWindow::slotCurrentMergeToB() { d->setMergeOperation(currentIndex(), eMergeToB); }
 void DirectoryMergeWindow::slotCurrentMergeToAAndB() { d->setMergeOperation(currentIndex(), eMergeToAB); }
 
 void DirectoryMergeWindow::keyPressEvent(QKeyEvent* e)
 {
     if((e->QInputEvent::modifiers() & Qt::ControlModifier) != 0)
     {
         bool bThreeDirs = d->m_dirC.isValid();
 
         MergeFileInfos* pMFI = d->getMFI(currentIndex());
 
         if(pMFI == nullptr)
             return;
         bool bMergeMode = bThreeDirs || !d->m_bSyncMode;
         bool bFTConflict = pMFI == nullptr ? false : conflictingFileTypes(*pMFI);
 
         if(bMergeMode)
         {
             switch(e->key())
             {
             case Qt::Key_1:
                 if(pMFI->existsInA()) {
                     slotCurrentChooseA();
                 }
                 return;
             case Qt::Key_2:
                 if(pMFI->existsInB()) {
                     slotCurrentChooseB();
                 }
                 return;
             case Qt::Key_3:
                 if(pMFI->existsInC()) {
                     slotCurrentChooseC();
                 }
                 return;
             case Qt::Key_Space:
                 slotCurrentDoNothing();
                 return;
             case Qt::Key_4:
                 if(!bFTConflict) {
                     slotCurrentMerge();
                 }
                 return;
             case Qt::Key_Delete:
                 slotCurrentDelete();
                 return;
             default:
                 break;
             }
         }
         else
         {
             switch(e->key())
             {
             case Qt::Key_1:
                 if(pMFI->existsInA()) {
                     slotCurrentCopyAToB();
                 }
                 return;
             case Qt::Key_2:
                 if(pMFI->existsInB()) {
                     slotCurrentCopyBToA();
                 }
                 return;
             case Qt::Key_Space:
                 slotCurrentDoNothing();
                 return;
             case Qt::Key_4:
                 if(!bFTConflict) {
                     slotCurrentMergeToAAndB();
                 }
                 return;
             case Qt::Key_Delete:
                 if(pMFI->existsInA() && pMFI->existsInB())
                     slotCurrentDeleteAAndB();
                 else if(pMFI->existsInA())
                     slotCurrentDeleteA();
                 else if(pMFI->existsInB())
                     slotCurrentDeleteB();
                 return;
             default:
                 break;
             }
         }
     }
     else if(e->key() == Qt::Key_Return || e->key() == Qt::Key_Enter)
     {
         onDoubleClick(currentIndex());
         return;
     }
 
     QTreeView::keyPressEvent(e);
 }
 
 void DirectoryMergeWindow::focusInEvent(QFocusEvent*)
 {
     updateAvailabilities();
 }
 void DirectoryMergeWindow::focusOutEvent(QFocusEvent*)
 {
     updateAvailabilities();
 }
 
 void DirectoryMergeWindow::Data::setAllMergeOperations(e_MergeOperation eDefaultOperation)
 {
     if(KMessageBox::Yes == KMessageBox::warningYesNo(q,
                                                      i18n("This affects all merge operations."),
                                                      i18n("Changing All Merge Operations"),
                                                      KStandardGuiItem::cont(),
                                                      KStandardGuiItem::cancel()))
     {
         for(int i = 0; i < rowCount(); ++i)
         {
             calcSuggestedOperation(index(i, 0, QModelIndex()), eDefaultOperation);
         }
     }
 }
 
 void DirectoryMergeWindow::Data::compareFilesAndCalcAges(MergeFileInfos& mfi)
 {
     std::map<QDateTime, int> dateMap;
 
     if(mfi.existsInA())
     {
         dateMap[mfi.m_pFileInfoA->lastModified()] = 0;
     }
     if(mfi.existsInB())
     {
         dateMap[mfi.m_pFileInfoB->lastModified()] = 1;
     }
     if(mfi.existsInC())
     {
         dateMap[mfi.m_pFileInfoC->lastModified()] = 2;
     }
 
     if(m_pOptions->m_bDmFullAnalysis)
     {
         if((mfi.existsInA() && mfi.dirA()) || (mfi.existsInB() && mfi.dirB()) || (mfi.existsInC() && mfi.dirC()))
         {
             // If any input is a directory, don't start any comparison.
             mfi.m_bEqualAB = mfi.existsInA() && mfi.existsInB();
             mfi.m_bEqualAC = mfi.existsInA() && mfi.existsInC();
             mfi.m_bEqualBC = mfi.existsInB() && mfi.existsInC();
         }
         else
         {
             emit q->startDiffMerge(
                 mfi.existsInA() ? mfi.m_pFileInfoA->absoluteFilePath() : QString(""),
                 mfi.existsInB() ? mfi.m_pFileInfoB->absoluteFilePath() : QString(""),
                 mfi.existsInC() ? mfi.m_pFileInfoC->absoluteFilePath() : QString(""),
                 "",
                 "", "", "", &mfi.m_totalDiffStatus);
             int nofNonwhiteConflicts = mfi.m_totalDiffStatus.nofUnsolvedConflicts +
                                        mfi.m_totalDiffStatus.nofSolvedConflicts - mfi.m_totalDiffStatus.nofWhitespaceConflicts;
 
             if(m_pOptions->m_bDmWhiteSpaceEqual && nofNonwhiteConflicts == 0)
             {
                 mfi.m_bEqualAB = mfi.existsInA() && mfi.existsInB();
                 mfi.m_bEqualAC = mfi.existsInA() && mfi.existsInC();
                 mfi.m_bEqualBC = mfi.existsInB() && mfi.existsInC();
             }
             else
             {
                 mfi.m_bEqualAB = mfi.m_totalDiffStatus.bBinaryAEqB;
                 mfi.m_bEqualBC = mfi.m_totalDiffStatus.bBinaryBEqC;
                 mfi.m_bEqualAC = mfi.m_totalDiffStatus.bBinaryAEqC;
             }
         }
     }
     else
     {
         bool bError;
         QString eqStatus;
         if(mfi.existsInA() && mfi.existsInB())
         {
             if(mfi.dirA())
                 mfi.m_bEqualAB = true;
             else
                 mfi.m_bEqualAB = fastFileComparison(*mfi.m_pFileInfoA, *mfi.m_pFileInfoB, bError, eqStatus);
         }
         if(mfi.existsInA() && mfi.existsInC())
         {
             if(mfi.dirA())
                 mfi.m_bEqualAC = true;
             else
                 mfi.m_bEqualAC = fastFileComparison(*mfi.m_pFileInfoA, *mfi.m_pFileInfoC, bError, eqStatus);
         }
         if(mfi.existsInB() && mfi.existsInC())
         {
             if(mfi.m_bEqualAB && mfi.m_bEqualAC)
                 mfi.m_bEqualBC = true;
             else
             {
                 if(mfi.dirB())
                     mfi.m_bEqualBC = true;
                 else
                     mfi.m_bEqualBC = fastFileComparison(*mfi.m_pFileInfoB, *mfi.m_pFileInfoC, bError, eqStatus);
             }
         }
     }
 
     if(mfi.isLinkA() != mfi.isLinkB()) mfi.m_bEqualAB = false;
     if(mfi.isLinkA() != mfi.isLinkC()) mfi.m_bEqualAC = false;
     if(mfi.isLinkB() != mfi.isLinkC()) mfi.m_bEqualBC = false;
 
     if(mfi.dirA() != mfi.dirB()) mfi.m_bEqualAB = false;
     if(mfi.dirA() != mfi.dirC()) mfi.m_bEqualAC = false;
     if(mfi.dirB() != mfi.dirC()) mfi.m_bEqualBC = false;
 
     Q_ASSERT(eNew == 0 && eMiddle == 1 && eOld == 2);
 
     // The map automatically sorts the keys.
     int age = eNew;
     std::map<QDateTime, int>::reverse_iterator i;
     for(i = dateMap.rbegin(); i != dateMap.rend(); ++i)
     {
         int n = i->second;
         if(n == 0 && mfi.m_ageA == eNotThere)
         {
             mfi.m_ageA = (e_Age)age;
             ++age;
             if(mfi.m_bEqualAB) {
                 mfi.m_ageB = mfi.m_ageA;
                 ++age;
             }
             if(mfi.m_bEqualAC) {
                 mfi.m_ageC = mfi.m_ageA;
                 ++age;
             }
         }
         else if(n == 1 && mfi.m_ageB == eNotThere)
         {
             mfi.m_ageB = (e_Age)age;
             ++age;
             if(mfi.m_bEqualAB) {
                 mfi.m_ageA = mfi.m_ageB;
                 ++age;
             }
             if(mfi.m_bEqualBC) {
                 mfi.m_ageC = mfi.m_ageB;
                 ++age;
             }
         }
         else if(n == 2 && mfi.m_ageC == eNotThere)
         {
             mfi.m_ageC = (e_Age)age;
             ++age;
             if(mfi.m_bEqualAC) {
                 mfi.m_ageA = mfi.m_ageC;
                 ++age;
             }
             if(mfi.m_bEqualBC) {
                 mfi.m_ageB = mfi.m_ageC;
                 ++age;
             }
         }
     }
 
     // The checks below are necessary when the dates of the file are equal but the
     // files are not. One wouldn't expect this to happen, yet it happens sometimes.
     if(mfi.existsInC() && mfi.m_ageC == eNotThere)
     {
         mfi.m_ageC = (e_Age)age;
         ++age;
         mfi.m_bConflictingAges = true;
     }
     if(mfi.existsInB() && mfi.m_ageB == eNotThere)
     {
         mfi.m_ageB = (e_Age)age;
         ++age;
         mfi.m_bConflictingAges = true;
     }
     if(mfi.existsInA() && mfi.m_ageA == eNotThere)
     {
         mfi.m_ageA = (e_Age)age;
         ++age;
         mfi.m_bConflictingAges = true;
     }
 
     if(mfi.m_ageA != eOld && mfi.m_ageB != eOld && mfi.m_ageC != eOld)
     {
         if(mfi.m_ageA == eMiddle) mfi.m_ageA = eOld;
         if(mfi.m_ageB == eMiddle) mfi.m_ageB = eOld;
         if(mfi.m_ageC == eMiddle) mfi.m_ageC = eOld;
     }
 }
 
 static QPixmap* s_pm_dir;
 static QPixmap* s_pm_file;
 
 static QPixmap* pmNotThere;
 static QPixmap* pmNew;
 static QPixmap* pmOld;
 static QPixmap* pmMiddle;
 
 static QPixmap* pmLink;
 
 static QPixmap* pmDirLink;
 static QPixmap* pmFileLink;
 
 static QPixmap* pmNewLink;
 static QPixmap* pmOldLink;
 static QPixmap* pmMiddleLink;
 
 static QPixmap* pmNewDir;
 static QPixmap* pmMiddleDir;
 static QPixmap* pmOldDir;
 
 static QPixmap* pmNewDirLink;
 static QPixmap* pmMiddleDirLink;
 static QPixmap* pmOldDirLink;
 
 static QPixmap colorToPixmap(QColor c)
 {
     QPixmap pm(16, 16);
     QPainter p(&pm);
     p.setPen(Qt::black);
     p.setBrush(c);
     p.drawRect(0, 0, pm.width(), pm.height());
     return pm;
 }
 
 static void initPixmaps(QColor newest, QColor oldest, QColor middle, QColor notThere)
 {
     if(pmNew == nullptr)
     {
         pmNotThere = new QPixmap;
         pmNew = new QPixmap;
         pmOld = new QPixmap;
         pmMiddle = new QPixmap;
 
 #include "xpm/link_arrow.xpm"
         pmLink = new QPixmap(link_arrow);
 
         pmDirLink = new QPixmap;
         pmFileLink = new QPixmap;
 
         pmNewLink = new QPixmap;
         pmOldLink = new QPixmap;
         pmMiddleLink = new QPixmap;
 
         pmNewDir = new QPixmap;
         pmMiddleDir = new QPixmap;
         pmOldDir = new QPixmap;
 
         pmNewDirLink = new QPixmap;
         pmMiddleDirLink = new QPixmap;
         pmOldDirLink = new QPixmap;
     }
 
     *pmNotThere = colorToPixmap(notThere);
     *pmNew = colorToPixmap(newest);
     *pmOld = colorToPixmap(oldest);
     *pmMiddle = colorToPixmap(middle);
 
     *pmDirLink = pixCombiner(s_pm_dir, pmLink);
     *pmFileLink = pixCombiner(s_pm_file, pmLink);
 
     *pmNewLink = pixCombiner(pmNew, pmLink);
     *pmOldLink = pixCombiner(pmOld, pmLink);
     *pmMiddleLink = pixCombiner(pmMiddle, pmLink);
 
     *pmNewDir = pixCombiner2(pmNew, s_pm_dir);
     *pmMiddleDir = pixCombiner2(pmMiddle, s_pm_dir);
     *pmOldDir = pixCombiner2(pmOld, s_pm_dir);
 
     *pmNewDirLink = pixCombiner(pmNewDir, pmLink);
     *pmMiddleDirLink = pixCombiner(pmMiddleDir, pmLink);
     *pmOldDirLink = pixCombiner(pmOldDir, pmLink);
 }
 
 static QPixmap getOnePixmap(e_Age eAge, bool bLink, bool bDir)
 {
     static QPixmap* ageToPm[] = {pmNew, pmMiddle, pmOld, pmNotThere, s_pm_file};
     static QPixmap* ageToPmLink[] = {pmNewLink, pmMiddleLink, pmOldLink, pmNotThere, pmFileLink};
     static QPixmap* ageToPmDir[] = {pmNewDir, pmMiddleDir, pmOldDir, pmNotThere, s_pm_dir};
     static QPixmap* ageToPmDirLink[] = {pmNewDirLink, pmMiddleDirLink, pmOldDirLink, pmNotThere, pmDirLink};
 
     QPixmap** ppPm = bDir ? (bLink ? ageToPmDirLink : ageToPmDir) : (bLink ? ageToPmLink : ageToPm);
 
     return *ppPm[eAge];
 }
 
 static void setPixmaps(MergeFileInfos& mfi, bool)
 {
     if(mfi.dirA() || mfi.dirB() || mfi.dirC())
     {
         mfi.m_ageA = eNotThere;
         mfi.m_ageB = eNotThere;
         mfi.m_ageC = eNotThere;
         int age = eNew;
         if(mfi.existsInC())
         {
             mfi.m_ageC = (e_Age)age;
             if(mfi.m_bEqualAC) mfi.m_ageA = (e_Age)age;
             if(mfi.m_bEqualBC) mfi.m_ageB = (e_Age)age;
             ++age;
         }
         if(mfi.existsInB() && mfi.m_ageB == eNotThere)
         {
             mfi.m_ageB = (e_Age)age;
             if(mfi.m_bEqualAB) mfi.m_ageA = (e_Age)age;
             ++age;
         }
         if(mfi.existsInA() && mfi.m_ageA == eNotThere)
         {
             mfi.m_ageA = (e_Age)age;
         }
         if(mfi.m_ageA != eOld && mfi.m_ageB != eOld && mfi.m_ageC != eOld)
         {
             if(mfi.m_ageA == eMiddle) mfi.m_ageA = eOld;
             if(mfi.m_ageB == eMiddle) mfi.m_ageB = eOld;
             if(mfi.m_ageC == eMiddle) mfi.m_ageC = eOld;
         }
     }
 }
 
 static QModelIndex nextSibling(const QModelIndex& mi)
 {
     QModelIndex miParent = mi.parent();
     int currentIdx = mi.row();
     if(currentIdx + 1 < mi.model()->rowCount(miParent))
         return mi.model()->index(mi.row() + 1, 0, miParent); // next child of parent
     return QModelIndex();
 }
 
 // Iterate through the complete tree. Start by specifying QListView::firstChild().
 QModelIndex DirectoryMergeWindow::Data::treeIterator(QModelIndex mi, bool bVisitChildren, bool bFindInvisible)
 {
     if(mi.isValid())
     {
         do
         {
             if(bVisitChildren && mi.model()->rowCount(mi) != 0)
                 mi = mi.model()->index(0, 0, mi);
             else
             {
                 QModelIndex miNextSibling = nextSibling(mi);
                 if(miNextSibling.isValid())
                     mi = miNextSibling;
                 else
                 {
                     mi = mi.parent();
                     while(mi.isValid())
                     {
                         QModelIndex miNextSibling = nextSibling(mi);
                         if(miNextSibling.isValid())
                         {
                             mi = miNextSibling;
                             break;
                         }
                         else
                         {
                             mi = mi.parent();
                         }
                     }
                 }
             }
         } while(mi.isValid() && q->isRowHidden(mi.row(), mi.parent()) && !bFindInvisible);
     }
     return mi;
 }
 
 void DirectoryMergeWindow::Data::prepareListView(ProgressProxy& pp)
 {
     static bool bFirstTime = true;
     if(bFirstTime)
     {
 #include "xpm/file.xpm"
 #include "xpm/folder.xpm"
         // FIXME specify correct icon loader group
         s_pm_dir = new QPixmap(m_pIconLoader->loadIcon("folder", KIconLoader::NoGroup, KIconLoader::Small));
         if(s_pm_dir->size() != QSize(16, 16))
         {
             delete s_pm_dir;
             s_pm_dir = new QPixmap(folder_pm);
         }
         s_pm_file = new QPixmap(file_pm);
         bFirstTime = false;
     }
 
     //TODO   clear();
     initPixmaps(m_pOptions->m_newestFileColor, m_pOptions->m_oldestFileColor,
                 m_pOptions->m_midAgeFileColor, m_pOptions->m_missingFileColor);
 
     q->setRootIsDecorated(true);
 
     bool bCheckC = m_dirC.isValid();
 
     t_fileMergeMap::iterator j;
     int nrOfFiles = m_fileMergeMap.size();
     int currentIdx = 1;
     QTime t;
     t.start();
     pp.setMaxNofSteps(nrOfFiles);
     for(j = m_fileMergeMap.begin(); j != m_fileMergeMap.end(); ++j)
     {
         MergeFileInfos& mfi = j.value();
 
         // const QString& fileName = j->first;
         const QString& fileName = mfi.subPath();
 
         pp.setInformation(
             i18n("Processing ") + QString::number(currentIdx) + " / " + QString::number(nrOfFiles) + "\n" + fileName, currentIdx, false);
         if(pp.wasCancelled()) break;
         ++currentIdx;
 
         // The comparisons and calculations for each file take place here.
         compareFilesAndCalcAges(mfi);
 
         // Get dirname from fileName: Search for "/" from end:
         int pos = fileName.lastIndexOf('/');
         QString dirPart;
         QString filePart;
         if(pos == -1)
         {
             // Top dir
             filePart = fileName;
         }
         else
         {
             dirPart = fileName.left(pos);
             filePart = fileName.mid(pos + 1);
         }
         if(dirPart.isEmpty()) // Top level
         {
             m_pRoot->m_children.push_back(&mfi); //new DirMergeItem( this, filePart, &mfi );
             mfi.m_pParent = m_pRoot;
         }
         else
         {
             FileAccess* pFA = mfi.m_pFileInfoA ? mfi.m_pFileInfoA : mfi.m_pFileInfoB ? mfi.m_pFileInfoB : mfi.m_pFileInfoC;
             MergeFileInfos& dirMfi = pFA->parent() ? m_fileMergeMap[FileKey(*pFA->parent())] : *m_pRoot; // parent
 
             dirMfi.m_children.push_back(&mfi); //new DirMergeItem( dirMfi.m_pDMI, filePart, &mfi );
             mfi.m_pParent = &dirMfi;
 
             //   // Equality for parent dirs is set in updateFileVisibilities()
         }
 
         setPixmaps(mfi, bCheckC);
     }
     beginResetModel();
     endResetModel();
 }
 
 static bool conflictingFileTypes(MergeFileInfos& mfi)
 {
     // Now check if file/dir-types fit.
     if(mfi.isLinkA() || mfi.isLinkB() || mfi.isLinkC())
     {
         if((mfi.existsInA() && !mfi.isLinkA()) ||
            (mfi.existsInB() && !mfi.isLinkB()) ||
            (mfi.existsInC() && !mfi.isLinkC()))
         {
             return true;
         }
     }
 
     if(mfi.dirA() || mfi.dirB() || mfi.dirC())
     {
         if((mfi.existsInA() && !mfi.dirA()) ||
            (mfi.existsInB() && !mfi.dirB()) ||
            (mfi.existsInC() && !mfi.dirC()))
         {
             return true;
         }
     }
     return false;
 }
 
 void DirectoryMergeWindow::Data::calcSuggestedOperation(const QModelIndex& mi, e_MergeOperation eDefaultMergeOp)
 {
     MergeFileInfos* pMFI = getMFI(mi);
     if(pMFI == nullptr)
         return;
     MergeFileInfos& mfi = *pMFI;
     bool bCheckC = m_dirC.isValid();
     bool bCopyNewer = m_pOptions->m_bDmCopyNewer;
     bool bOtherDest = !((m_dirDestInternal.absoluteFilePath() == m_dirA.absoluteFilePath()) ||
                         (m_dirDestInternal.absoluteFilePath() == m_dirB.absoluteFilePath()) ||
                         (bCheckC && m_dirDestInternal.absoluteFilePath() == m_dirC.absoluteFilePath()));
 
     if(eDefaultMergeOp == eMergeABCToDest && !bCheckC) {
         eDefaultMergeOp = eMergeABToDest;
     }
     if(eDefaultMergeOp == eMergeToAB && bCheckC) {
         Q_ASSERT(true);
     }
 
     if(eDefaultMergeOp == eMergeToA || eDefaultMergeOp == eMergeToB ||
        eDefaultMergeOp == eMergeABCToDest || eDefaultMergeOp == eMergeABToDest || eDefaultMergeOp == eMergeToAB)
     {
         if(!bCheckC)
         {
             if(mfi.m_bEqualAB)
             {
                 setMergeOperation(mi, bOtherDest ? eCopyBToDest : eNoOperation);
             }
             else if(mfi.existsInA() && mfi.existsInB())
             {
                 if(!bCopyNewer || mfi.dirA())
                     setMergeOperation(mi, eDefaultMergeOp);
                 else if(bCopyNewer && mfi.m_bConflictingAges)
                 {
                     setMergeOperation(mi, eConflictingAges);
                 }
                 else
                 {
                     if(mfi.m_ageA == eNew)
                         setMergeOperation(mi, eDefaultMergeOp == eMergeToAB ? eCopyAToB : eCopyAToDest);
                     else
                         setMergeOperation(mi, eDefaultMergeOp == eMergeToAB ? eCopyBToA : eCopyBToDest);
                 }
             }
             else if(!mfi.existsInA() && mfi.existsInB())
             {
                 if(eDefaultMergeOp == eMergeABToDest)
                     setMergeOperation(mi, eCopyBToDest);
                 else if(eDefaultMergeOp == eMergeToB)
                     setMergeOperation(mi, eNoOperation);
                 else
                     setMergeOperation(mi, eCopyBToA);
             }
             else if(mfi.existsInA() && !mfi.existsInB())
             {
                 if(eDefaultMergeOp == eMergeABToDest)
                     setMergeOperation(mi, eCopyAToDest);
                 else if(eDefaultMergeOp == eMergeToA)
                     setMergeOperation(mi, eNoOperation);
                 else
                     setMergeOperation(mi, eCopyAToB);
             }
             else //if ( !mfi.existsInA() && !mfi.existsInB() )
             {
                 setMergeOperation(mi, eNoOperation);
             }
         }
         else
         {
             if(mfi.m_bEqualAB && mfi.m_bEqualAC)
             {
                 setMergeOperation(mi, bOtherDest ? eCopyCToDest : eNoOperation);
             }
             else if(mfi.existsInA() && mfi.existsInB() && mfi.existsInC())
             {
                 if(mfi.m_bEqualAB)
                     setMergeOperation(mi, eCopyCToDest);
                 else if(mfi.m_bEqualAC)
                     setMergeOperation(mi, eCopyBToDest);
                 else if(mfi.m_bEqualBC)
                     setMergeOperation(mi, eCopyCToDest);
                 else
                     setMergeOperation(mi, eMergeABCToDest);
             }
             else if(mfi.existsInA() && mfi.existsInB() && !mfi.existsInC())
             {
                 if(mfi.m_bEqualAB)
                     setMergeOperation(mi, eDeleteFromDest);
                 else
                     setMergeOperation(mi, eChangedAndDeleted);
             }
             else if(mfi.existsInA() && !mfi.existsInB() && mfi.existsInC())
             {
                 if(mfi.m_bEqualAC)
                     setMergeOperation(mi, eDeleteFromDest);
                 else
                     setMergeOperation(mi, eChangedAndDeleted);
             }
             else if(!mfi.existsInA() && mfi.existsInB() && mfi.existsInC())
             {
                 if(mfi.m_bEqualBC)
                     setMergeOperation(mi, eCopyCToDest);
                 else
                     setMergeOperation(mi, eMergeABCToDest);
             }
             else if(!mfi.existsInA() && !mfi.existsInB() && mfi.existsInC())
             {
                 setMergeOperation(mi, eCopyCToDest);
             }
             else if(!mfi.existsInA() && mfi.existsInB() && !mfi.existsInC())
             {
                 setMergeOperation(mi, eCopyBToDest);
             }
             else if(mfi.existsInA() && !mfi.existsInB() && !mfi.existsInC())
             {
                 setMergeOperation(mi, eDeleteFromDest);
             }
             else //if ( !mfi.existsInA() && !mfi.existsInB() && !mfi.existsInC() )
             {
                 setMergeOperation(mi, eNoOperation);
             }
         }
 
         // Now check if file/dir-types fit.
         if(conflictingFileTypes(mfi))
         {
             setMergeOperation(mi, eConflictingFileTypes);
         }
     }
     else
     {
         e_MergeOperation eMO = eDefaultMergeOp;
         switch(eDefaultMergeOp)
         {
         case eConflictingFileTypes:
         case eChangedAndDeleted:
         case eConflictingAges:
         case eDeleteA:
         case eDeleteB:
         case eDeleteAB:
         case eDeleteFromDest:
         case eNoOperation:
             break;
         case eCopyAToB:
             if(!mfi.existsInA()) {
                 eMO = eDeleteB;
             }
             break;
         case eCopyBToA:
             if(!mfi.existsInB()) {
                 eMO = eDeleteA;
             }
             break;
         case eCopyAToDest:
             if(!mfi.existsInA()) {
                 eMO = eDeleteFromDest;
             }
             break;
         case eCopyBToDest:
             if(!mfi.existsInB()) {
                 eMO = eDeleteFromDest;
             }
             break;
         case eCopyCToDest:
             if(!mfi.existsInC()) {
                 eMO = eDeleteFromDest;
             }
             break;
 
         case eMergeToA:
         case eMergeToB:
         case eMergeToAB:
         case eMergeABCToDest:
         case eMergeABToDest:
             break;
         default:
             Q_ASSERT(true);
             break;
         }
         setMergeOperation(mi, eMO);
     }
 }
 
 void DirectoryMergeWindow::onDoubleClick(const QModelIndex& mi)
 {
     if(!mi.isValid())
         return;
 
     d->m_bSimulatedMergeStarted = false;
     if(d->m_bDirectoryMerge)
         mergeCurrentFile();
     else
         compareCurrentFile();
 }
 
 void DirectoryMergeWindow::currentChanged(const QModelIndex& current, const QModelIndex& previous)
 {
     QTreeView::currentChanged(current, previous);
     MergeFileInfos* pMFI = d->getMFI(current);
     if(pMFI == nullptr)
         return;
 
     d->m_pDirectoryMergeInfo->setInfo(d->m_dirA, d->m_dirB, d->m_dirC, d->m_dirDestInternal, *pMFI);
 }
 
 void DirectoryMergeWindow::mousePressEvent(QMouseEvent* e)
 {
     QTreeView::mousePressEvent(e);
     QModelIndex mi = indexAt(e->pos());
     int c = mi.column();
     QPoint p = e->globalPos();
     MergeFileInfos* pMFI = d->getMFI(mi);
     if(pMFI == nullptr)
         return;
     MergeFileInfos& mfi = *pMFI;
 
     if(c == s_OpCol)
     {
         bool bThreeDirs = d->m_dirC.isValid();
 
         QMenu m(this);
         if(bThreeDirs)
         {
             m.addAction(d->m_pDirCurrentDoNothing);
             int count = 0;
             if(mfi.existsInA()) {
                 m.addAction(d->m_pDirCurrentChooseA);
                 ++count;
             }
             if(mfi.existsInB()) {
                 m.addAction(d->m_pDirCurrentChooseB);
                 ++count;
             }
             if(mfi.existsInC()) {
                 m.addAction(d->m_pDirCurrentChooseC);
                 ++count;
             }
             if(!conflictingFileTypes(mfi) && count > 1) m.addAction(d->m_pDirCurrentMerge);
             m.addAction(d->m_pDirCurrentDelete);
         }
         else if(d->m_bSyncMode)
         {
             m.addAction(d->m_pDirCurrentSyncDoNothing);
             if(mfi.existsInA()) m.addAction(d->m_pDirCurrentSyncCopyAToB);
             if(mfi.existsInB()) m.addAction(d->m_pDirCurrentSyncCopyBToA);
             if(mfi.existsInA()) m.addAction(d->m_pDirCurrentSyncDeleteA);
             if(mfi.existsInB()) m.addAction(d->m_pDirCurrentSyncDeleteB);
             if(mfi.existsInA() && mfi.existsInB())
             {
                 m.addAction(d->m_pDirCurrentSyncDeleteAAndB);
                 if(!conflictingFileTypes(mfi))
                 {
                     m.addAction(d->m_pDirCurrentSyncMergeToA);
                     m.addAction(d->m_pDirCurrentSyncMergeToB);
                     m.addAction(d->m_pDirCurrentSyncMergeToAAndB);
                 }
             }
         }
         else
         {
             m.addAction(d->m_pDirCurrentDoNothing);
             if(mfi.existsInA()) {
                 m.addAction(d->m_pDirCurrentChooseA);
             }
             if(mfi.existsInB()) {
                 m.addAction(d->m_pDirCurrentChooseB);
             }
             if(!conflictingFileTypes(mfi) && mfi.existsInA() && mfi.existsInB()) m.addAction(d->m_pDirCurrentMerge);
             m.addAction(d->m_pDirCurrentDelete);
         }
 
         m.exec(p);
     }
     else if(c == s_ACol || c == s_BCol || c == s_CCol)
     {
         QString itemPath;
         if(c == s_ACol && mfi.existsInA()) {
             itemPath = d->fullNameA(mfi);
         }
         else if(c == s_BCol && mfi.existsInB())
         {
             itemPath = d->fullNameB(mfi);
         }
         else if(c == s_CCol && mfi.existsInC())
         {
             itemPath = d->fullNameC(mfi);
         }
 
         if(!itemPath.isEmpty())
         {
             d->selectItemAndColumn(mi, e->button() == Qt::RightButton);
         }
     }
 }
 
 void DirectoryMergeWindow::contextMenuEvent(QContextMenuEvent* e)
 {
     QModelIndex mi = indexAt(e->pos());
     int c = mi.column();
     QPoint p = e->globalPos();
 
     MergeFileInfos* pMFI = d->getMFI(mi);
     if(pMFI == nullptr)
         return;
     if(c == s_ACol || c == s_BCol || c == s_CCol)
     {
         QString itemPath;
         if(c == s_ACol && pMFI->existsInA()) {
             itemPath = d->fullNameA(*pMFI);
         }
         else if(c == s_BCol && pMFI->existsInB())
         {
             itemPath = d->fullNameB(*pMFI);
         }
         else if(c == s_CCol && pMFI->existsInC())
         {
             itemPath = d->fullNameC(*pMFI);
         }
 
         if(!itemPath.isEmpty())
         {
             d->selectItemAndColumn(mi, true);
             QMenu m(this);
             m.addAction(d->m_pDirCompareExplicit);
             m.addAction(d->m_pDirMergeExplicit);
 
-#ifndef Q_OS_WIN
+            // TODO: Do we need the special Windows implementation?! -- Disabled for now.
+//#ifndef Q_OS_WIN
             m.exec(p);
-#else
-            void showShellContextMenu(const QString&, QPoint, QWidget*, QMenu*);
-            showShellContextMenu(itemPath, p, this, &m);
-#endif
+// #else
+//             void showShellContextMenu(const QString&, QPoint, QWidget*, QMenu*);
+//             showShellContextMenu(itemPath, p, this, &m);
+// #endif
         }
     }
 }
 
 QString DirectoryMergeWindow::Data::getFileName(const QModelIndex& mi)
 {
     MergeFileInfos* pMFI = getMFI(mi);
     if(pMFI != nullptr)
     {
         return mi.column() == s_ACol ? pMFI->m_pFileInfoA->absoluteFilePath() : mi.column() == s_BCol ? pMFI->m_pFileInfoB->absoluteFilePath() : mi.column() == s_CCol ? pMFI->m_pFileInfoC->absoluteFilePath() : QString("");
     }
     return "";
 }
 
 bool DirectoryMergeWindow::Data::isDir(const QModelIndex& mi)
 {
     MergeFileInfos* pMFI = getMFI(mi);
     if(pMFI != nullptr)
     {
         return mi.column() == s_ACol ? pMFI->dirA() : mi.column() == s_BCol ? pMFI->dirB() : pMFI->dirC();
     }
     return false;
 }
 
 void DirectoryMergeWindow::Data::selectItemAndColumn(const QModelIndex& mi, bool bContextMenu)
 {
     if(bContextMenu && (mi == m_selection1Index || mi == m_selection2Index || mi == m_selection3Index))
         return;
 
     QModelIndex old1 = m_selection1Index;
     QModelIndex old2 = m_selection2Index;
     QModelIndex old3 = m_selection3Index;
 
     bool bReset = false;
 
     if(m_selection1Index.isValid())
     {
         if(isDir(m_selection1Index) != isDir(mi))
             bReset = true;
     }
 
     if(bReset || m_selection3Index.isValid() || mi == m_selection1Index || mi == m_selection2Index || mi == m_selection3Index)
     {
         // restart
         m_selection1Index = QModelIndex();
         m_selection2Index = QModelIndex();
         m_selection3Index = QModelIndex();
     }
     else if(!m_selection1Index.isValid())
     {
         m_selection1Index = mi;
         m_selection2Index = QModelIndex();
         m_selection3Index = QModelIndex();
     }
     else if(!m_selection2Index.isValid())
     {
         m_selection2Index = mi;
         m_selection3Index = QModelIndex();
     }
     else if(!m_selection3Index.isValid())
     {
         m_selection3Index = mi;
     }
     if(old1.isValid()) dataChanged(old1, old1);
     if(old2.isValid()) dataChanged(old2, old2);
     if(old3.isValid()) dataChanged(old3, old3);
     if(m_selection1Index.isValid()) dataChanged(m_selection1Index, m_selection1Index);
     if(m_selection2Index.isValid()) dataChanged(m_selection2Index, m_selection2Index);
     if(m_selection3Index.isValid()) dataChanged(m_selection3Index, m_selection3Index);
     emit q->updateAvailabilities();
 }
 
 //TODO
 //void DirMergeItem::init(MergeFileInfos* pMFI)
 //{
 //   pMFI->m_pDMI = this;
 //   m_pMFI = pMFI;
 //   TotalDiffStatus& tds = pMFI->m_totalDiffStatus;
 //   if ( m_pMFI->dirA() || m_pMFI->dirB() || m_pMFI->dirC() )
 //   {
 //   }
 //   else
 //   {
 //      setText( s_UnsolvedCol, QString::number( tds.nofUnsolvedConflicts ) );
 //      setText( s_SolvedCol,   QString::number( tds.nofSolvedConflicts ) );
 //      setText( s_NonWhiteCol, QString::number( tds.nofUnsolvedConflicts + tds.nofSolvedConflicts - tds.nofWhitespaceConflicts ) );
 //      setText( s_WhiteCol,    QString::number( tds.nofWhitespaceConflicts ) );
 //   }
 //   setSizeHint( s_ACol, QSize(17,17) ); // Iconsize
 //   setSizeHint( s_BCol, QSize(17,17) ); // Iconsize
 //   setSizeHint( s_CCol, QSize(17,17) ); // Iconsize
 //}
 
 class MfiCompare
 {
     Qt::SortOrder mOrder;
 
   public:
     explicit MfiCompare(Qt::SortOrder order)
     {
         mOrder = order;
     }
     bool operator()(MergeFileInfos* pMFI1, MergeFileInfos* pMFI2)
     {
         bool bDir1 = pMFI1->dirA() || pMFI1->dirB() || pMFI1->dirC();
         bool bDir2 = pMFI2->dirA() || pMFI2->dirB() || pMFI2->dirC();
         if(bDir1 == bDir2) {
             if(mOrder == Qt::AscendingOrder)
             {
                 return pMFI1->fileName().compare(pMFI2->fileName(), Qt::CaseInsensitive) < 0;
             }
             else
             {
                 return pMFI1->fileName().compare(pMFI2->fileName(), Qt::CaseInsensitive) > 0;
             }
         }
         else
             return bDir1;
     }
 };
 
 static void sortHelper(MergeFileInfos* pMFI, Qt::SortOrder order)
 {
     std::sort(pMFI->m_children.begin(), pMFI->m_children.end(), MfiCompare(order));
 
     for(int i = 0; i < pMFI->m_children.count(); ++i)
         sortHelper(pMFI->m_children[i], order);
 }
 
 void DirectoryMergeWindow::Data::sort(int column, Qt::SortOrder order)
 {
     Q_UNUSED(column);
     beginResetModel();
     sortHelper(m_pRoot, order);
     endResetModel();
 }
 
 //
 //DirMergeItem::~DirMergeItem()
 //{
 //   m_pMFI->m_pDMI = 0;
 //}
 
 void DirectoryMergeWindow::Data::setMergeOperation(const QModelIndex& mi, e_MergeOperation eMOp, bool bRecursive)
 {
     MergeFileInfos* pMFI = getMFI(mi);
     if(pMFI == nullptr)
         return;
 
     MergeFileInfos& mfi = *pMFI;
 
     if(eMOp != mfi.m_eMergeOperation)
     {
         mfi.m_bOperationComplete = false;
         setOpStatus(mi, eOpStatusNone);
     }
 
     mfi.m_eMergeOperation = eMOp;
     if(bRecursive)
     {
         e_MergeOperation eChildrenMergeOp = mfi.m_eMergeOperation;
         if(eChildrenMergeOp == eConflictingFileTypes) eChildrenMergeOp = eMergeABCToDest;
         for(int childIdx = 0; childIdx < mfi.m_children.count(); ++childIdx)
         {
             calcSuggestedOperation(index(childIdx, 0, mi), eChildrenMergeOp);
         }
     }
 }
 
 void DirectoryMergeWindow::compareCurrentFile()
 {
     if(!d->canContinue()) return;
 
     if(d->m_bRealMergeStarted)
     {
         KMessageBox::sorry(this, i18n("This operation is currently not possible."), i18n("Operation Not Possible"));
         return;
     }
 
     if(MergeFileInfos* pMFI = d->getMFI(currentIndex()))
     {
         if(!(pMFI->dirA() || pMFI->dirB() || pMFI->dirC()))
         {
             emit startDiffMerge(
                 pMFI->existsInA() ? pMFI->m_pFileInfoA->absoluteFilePath() : QString(""),
                 pMFI->existsInB() ? pMFI->m_pFileInfoB->absoluteFilePath() : QString(""),
                 pMFI->existsInC() ? pMFI->m_pFileInfoC->absoluteFilePath() : QString(""),
                 "",
                 "", "", "", nullptr);
         }
     }
     emit updateAvailabilities();
 }
 
 void DirectoryMergeWindow::slotCompareExplicitlySelectedFiles()
 {
     if(!d->isDir(d->m_selection1Index) && !d->canContinue()) return;
 
     if(d->m_bRealMergeStarted)
     {
         KMessageBox::sorry(this, i18n("This operation is currently not possible."), i18n("Operation Not Possible"));
         return;
     }
 
     emit startDiffMerge(
         d->getFileName(d->m_selection1Index),
         d->getFileName(d->m_selection2Index),
         d->getFileName(d->m_selection3Index),
         "",
         "", "", "", nullptr);
     d->m_selection1Index = QModelIndex();
     d->m_selection2Index = QModelIndex();
     d->m_selection3Index = QModelIndex();
 
     emit updateAvailabilities();
     update();
 }
 
 void DirectoryMergeWindow::slotMergeExplicitlySelectedFiles()
 {
     if(!d->isDir(d->m_selection1Index) && !d->canContinue()) return;
 
     if(d->m_bRealMergeStarted)
     {
         KMessageBox::sorry(this, i18n("This operation is currently not possible."), i18n("Operation Not Possible"));
         return;
     }
 
     QString fn1 = d->getFileName(d->m_selection1Index);
     QString fn2 = d->getFileName(d->m_selection2Index);
     QString fn3 = d->getFileName(d->m_selection3Index);
 
     emit startDiffMerge(fn1, fn2, fn3,
                         fn3.isEmpty() ? fn2 : fn3,
                         "", "", "", nullptr);
     d->m_selection1Index = QModelIndex();
     d->m_selection2Index = QModelIndex();
     d->m_selection3Index = QModelIndex();
 
     emit updateAvailabilities();
     update();
 }
 
 bool DirectoryMergeWindow::isFileSelected()
 {
     if(MergeFileInfos* pMFI = d->getMFI(currentIndex()))
     {
         return !(pMFI->dirA() || pMFI->dirB() || pMFI->dirC() || conflictingFileTypes(*pMFI));
     }
     return false;
 }
 
 void DirectoryMergeWindow::mergeResultSaved(const QString& fileName)
 {
     QModelIndex mi = (d->m_mergeItemList.empty() || d->m_currentIndexForOperation == d->m_mergeItemList.end())
                          ? QModelIndex()
                          : *d->m_currentIndexForOperation;
 
     MergeFileInfos* pMFI = d->getMFI(mi);
     if(pMFI == nullptr)
     {
         // This can happen if the same file is saved and modified and saved again. Nothing to do then.
         return;
     }
     if(fileName == d->fullNameDest(*pMFI))
     {
         MergeFileInfos& mfi = *pMFI;
         if(mfi.m_eMergeOperation == eMergeToAB)
         {
             bool bSuccess = d->copyFLD(d->fullNameB(mfi), d->fullNameA(mfi));
             if(!bSuccess)
             {
                 KMessageBox::error(this, i18n("An error occurred while copying.\n"), i18n("Error"));
                 d->m_pStatusInfo->setWindowTitle(i18n("Merge Error"));
                 d->m_pStatusInfo->exec();
                 //if ( m_pStatusInfo->firstChild()!=0 )
                 //   m_pStatusInfo->ensureItemVisible( m_pStatusInfo->last() );
                 d->m_bError = true;
                 d->setOpStatus(mi, eOpStatusError);
                 mfi.m_eMergeOperation = eCopyBToA;
                 return;
             }
         }
         d->setOpStatus(mi, eOpStatusDone);
         pMFI->m_bOperationComplete = true;
         if(d->m_mergeItemList.size() == 1)
         {
             d->m_mergeItemList.clear();
             d->m_bRealMergeStarted = false;
         }
     }
 
     emit updateAvailabilities();
 }
 
 bool DirectoryMergeWindow::Data::canContinue()
 {
     bool bCanContinue = false;
     q->checkIfCanContinue(&bCanContinue);
     if(bCanContinue && !m_bError)
     {
         QModelIndex mi = (m_mergeItemList.empty() || m_currentIndexForOperation == m_mergeItemList.end()) ? QModelIndex() : *m_currentIndexForOperation;
         MergeFileInfos* pMFI = getMFI(mi);
         if(pMFI && !pMFI->m_bOperationComplete)
         {
             setOpStatus(mi, eOpStatusNotSaved);
             pMFI->m_bOperationComplete = true;
             if(m_mergeItemList.size() == 1)
             {
                 m_mergeItemList.clear();
                 m_bRealMergeStarted = false;
             }
         }
     }
     return bCanContinue;
 }
 
 bool DirectoryMergeWindow::Data::executeMergeOperation(MergeFileInfos& mfi, bool& bSingleFileMerge)
 {
     bool bCreateBackups = m_pOptions->m_bDmCreateBakFiles;
     // First decide destname
     QString destName;
     switch(mfi.m_eMergeOperation)
     {
     case eNoOperation:
         break;
     case eDeleteAB:
         break;
     case eMergeToAB: // let the user save in B. In mergeResultSaved() the file will be copied to A.
     case eMergeToB:
     case eDeleteB:
     case eCopyAToB:
         destName = fullNameB(mfi);
         break;
     case eMergeToA:
     case eDeleteA:
     case eCopyBToA:
         destName = fullNameA(mfi);
         break;
     case eMergeABToDest:
     case eMergeABCToDest:
     case eCopyAToDest:
     case eCopyBToDest:
     case eCopyCToDest:
     case eDeleteFromDest:
         destName = fullNameDest(mfi);
         break;
     default:
         KMessageBox::error(q, i18n("Unknown merge operation. (This must never happen!)"), i18n("Error"));
     }
 
     bool bSuccess = false;
     bSingleFileMerge = false;
     switch(mfi.m_eMergeOperation)
     {
     case eNoOperation:
         bSuccess = true;
         break;
     case eCopyAToDest:
     case eCopyAToB:
         bSuccess = copyFLD(fullNameA(mfi), destName);
         break;
     case eCopyBToDest:
     case eCopyBToA:
         bSuccess = copyFLD(fullNameB(mfi), destName);
         break;
     case eCopyCToDest:
         bSuccess = copyFLD(fullNameC(mfi), destName);
         break;
     case eDeleteFromDest:
     case eDeleteA:
     case eDeleteB:
         bSuccess = deleteFLD(destName, bCreateBackups);
         break;
     case eDeleteAB:
         bSuccess = deleteFLD(fullNameA(mfi), bCreateBackups) &&
                    deleteFLD(fullNameB(mfi), bCreateBackups);
         break;
     case eMergeABToDest:
     case eMergeToA:
     case eMergeToAB:
     case eMergeToB:
         bSuccess = mergeFLD(fullNameA(mfi), fullNameB(mfi), "",
                             destName, bSingleFileMerge);
         break;
     case eMergeABCToDest:
         bSuccess = mergeFLD(
             mfi.existsInA() ? fullNameA(mfi) : QString(""),
             mfi.existsInB() ? fullNameB(mfi) : QString(""),
             mfi.existsInC() ? fullNameC(mfi) : QString(""),
             destName, bSingleFileMerge);
         break;
     default:
         KMessageBox::error(q, i18n("Unknown merge operation."), i18n("Error"));
     }
 
     return bSuccess;
 }
 
 // Check if the merge can start, and prepare the m_mergeItemList which then contains all
 // items that must be merged.
 void DirectoryMergeWindow::Data::prepareMergeStart(const QModelIndex& miBegin, const QModelIndex& miEnd, bool bVerbose)
 {
     if(bVerbose)
     {
         int status = KMessageBox::warningYesNoCancel(q,
                                                      i18n("The merge is about to begin.\n\n"
                                                           "Choose \"Do it\" if you have read the instructions and know what you are doing.\n"
                                                           "Choosing \"Simulate it\" will tell you what would happen.\n\n"
                                                           "Be aware that this program still has beta status "
                                                           "and there is NO WARRANTY whatsoever! Make backups of your vital data!"),
                                                      i18n("Starting Merge"),
                                                      KGuiItem(i18n("Do It")),
                                                      KGuiItem(i18n("Simulate It")));
         if(status == KMessageBox::Yes)
             m_bRealMergeStarted = true;
         else if(status == KMessageBox::No)
             m_bSimulatedMergeStarted = true;
         else
             return;
     }
     else
     {
         m_bRealMergeStarted = true;
     }
 
     m_mergeItemList.clear();
     if(!miBegin.isValid())
         return;
 
     for(QModelIndex mi = miBegin; mi != miEnd; mi = treeIterator(mi))
     {
         MergeFileInfos* pMFI = getMFI(mi);
         if(pMFI && !pMFI->m_bOperationComplete)
         {
             m_mergeItemList.push_back(mi);
             QString errorText;
             if(pMFI->m_eMergeOperation == eConflictingFileTypes)
             {
                 errorText = i18n("The highlighted item has a different type in the different directories. Select what to do.");
             }
             if(pMFI->m_eMergeOperation == eConflictingAges)
             {
                 errorText = i18n("The modification dates of the file are equal but the files are not. Select what to do.");
             }
             if(pMFI->m_eMergeOperation == eChangedAndDeleted)
             {
                 errorText = i18n("The highlighted item was changed in one directory and deleted in the other. Select what to do.");
             }
             if(!errorText.isEmpty())
             {
                 q->scrollTo(mi, QAbstractItemView::EnsureVisible);
                 q->setCurrentIndex(mi);
                 KMessageBox::error(q, errorText, i18n("Error"));
                 m_mergeItemList.clear();
                 m_bRealMergeStarted = false;
                 return;
             }
         }
     }
 
     m_currentIndexForOperation = m_mergeItemList.begin();
     return;
 }
 
 void DirectoryMergeWindow::slotRunOperationForCurrentItem()
 {
     if(!d->canContinue()) return;
 
     bool bVerbose = false;
     if(d->m_mergeItemList.empty())
     {
         QModelIndex miBegin = currentIndex();
         QModelIndex miEnd = d->treeIterator(miBegin, false, false); // find next visible sibling (no children)
 
         d->prepareMergeStart(miBegin, miEnd, bVerbose);
         d->mergeContinue(true, bVerbose);
     }
     else
         d->mergeContinue(false, bVerbose);
 }
 
 void DirectoryMergeWindow::slotRunOperationForAllItems()
 {
     if(!d->canContinue()) return;
 
     bool bVerbose = true;
     if(d->m_mergeItemList.empty())
     {
         QModelIndex miBegin = d->rowCount() > 0 ? d->index(0, 0, QModelIndex()) : QModelIndex();
 
         d->prepareMergeStart(miBegin, QModelIndex(), bVerbose);
         d->mergeContinue(true, bVerbose);
     }
     else
         d->mergeContinue(false, bVerbose);
 }
 
 void DirectoryMergeWindow::mergeCurrentFile()
 {
     if(!d->canContinue()) return;
 
     if(d->m_bRealMergeStarted)
     {
         KMessageBox::sorry(this, i18n("This operation is currently not possible because directory merge is currently running."), i18n("Operation Not Possible"));
         return;
     }
 
     if(isFileSelected())
     {
         MergeFileInfos* pMFI = d->getMFI(currentIndex());
         if(pMFI != nullptr)
         {
             MergeFileInfos& mfi = *pMFI;
             d->m_mergeItemList.clear();
             d->m_mergeItemList.push_back(currentIndex());
             d->m_currentIndexForOperation = d->m_mergeItemList.begin();
             bool bDummy = false;
             d->mergeFLD(
                 mfi.existsInA() ? mfi.m_pFileInfoA->absoluteFilePath() : QString(""),
                 mfi.existsInB() ? mfi.m_pFileInfoB->absoluteFilePath() : QString(""),
                 mfi.existsInC() ? mfi.m_pFileInfoC->absoluteFilePath() : QString(""),
                 d->fullNameDest(mfi),
                 bDummy);
         }
     }
     emit updateAvailabilities();
 }
 
 // When bStart is true then m_currentIndexForOperation must still be processed.
 // When bVerbose is true then a messagebox will tell when the merge is complete.
 void DirectoryMergeWindow::Data::mergeContinue(bool bStart, bool bVerbose)
 {
     ProgressProxy pp;
     if(m_mergeItemList.empty())
         return;
 
     int nrOfItems = 0;
     int nrOfCompletedItems = 0;
     int nrOfCompletedSimItems = 0;
 
     // Count the number of completed items (for the progress bar).
     for(MergeItemList::iterator i = m_mergeItemList.begin(); i != m_mergeItemList.end(); ++i)
     {
         MergeFileInfos* pMFI = getMFI(*i);
         ++nrOfItems;
         if(pMFI->m_bOperationComplete)
             ++nrOfCompletedItems;
         if(pMFI->m_bSimOpComplete)
             ++nrOfCompletedSimItems;
     }
 
     m_pStatusInfo->hide();
     m_pStatusInfo->clear();
 
     QModelIndex miCurrent = m_currentIndexForOperation == m_mergeItemList.end() ? QModelIndex() : *m_currentIndexForOperation;
 
     bool bContinueWithCurrentItem = bStart; // true for first item, else false
     bool bSkipItem = false;
     if(!bStart && m_bError && miCurrent.isValid())
     {
         int status = KMessageBox::warningYesNoCancel(q,
                                                      i18n("There was an error in the last step.\n"
                                                           "Do you want to continue with the item that caused the error or do you want to skip this item?"),
                                                      i18n("Continue merge after an error"),
                                                      KGuiItem(i18n("Continue With Last Item")),
                                                      KGuiItem(i18n("Skip Item")));
         if(status == KMessageBox::Yes)
             bContinueWithCurrentItem = true;
         else if(status == KMessageBox::No)
             bSkipItem = true;
         else
             return;
         m_bError = false;
     }
 
     pp.setMaxNofSteps(nrOfItems);
 
     bool bSuccess = true;
     bool bSingleFileMerge = false;
     bool bSim = m_bSimulatedMergeStarted;
     while(bSuccess)
     {
         MergeFileInfos* pMFI = getMFI(miCurrent);
         if(pMFI == nullptr)
         {
             m_mergeItemList.clear();
             m_bRealMergeStarted = false;
             break;
         }
 
         if(pMFI != nullptr && !bContinueWithCurrentItem)
         {
             if(bSim)
             {
                 if(rowCount(miCurrent) == 0)
                 {
                     pMFI->m_bSimOpComplete = true;
                 }
             }
             else
             {
                 if(rowCount(miCurrent) == 0)
                 {
                     if(!pMFI->m_bOperationComplete)
                     {
                         setOpStatus(miCurrent, bSkipItem ? eOpStatusSkipped : eOpStatusDone);
                         pMFI->m_bOperationComplete = true;
                         bSkipItem = false;
                     }
                 }
                 else
                 {
                     setOpStatus(miCurrent, eOpStatusInProgress);
                 }
             }
         }
 
         if(!bContinueWithCurrentItem)
         {
             // Depth first
             QModelIndex miPrev = miCurrent;
             ++m_currentIndexForOperation;
             miCurrent = m_currentIndexForOperation == m_mergeItemList.end() ? QModelIndex() : *m_currentIndexForOperation;
             if((!miCurrent.isValid() || miCurrent.parent() != miPrev.parent()) && miPrev.parent().isValid())
             {
                 // Check if the parent may be set to "Done"
                 QModelIndex miParent = miPrev.parent();
                 bool bDone = true;
                 while(bDone && miParent.isValid())
                 {
                     for(int childIdx = 0; childIdx < rowCount(miParent); ++childIdx)
                     {
                         MergeFileInfos* pMFI = getMFI(index(childIdx, 0, miParent));
                         if((!bSim && !pMFI->m_bOperationComplete) || (bSim && pMFI->m_bSimOpComplete))
                         {
                             bDone = false;
                             break;
                         }
                     }
                     if(bDone)
                     {
                         MergeFileInfos* pMFI = getMFI(miParent);
                         if(bSim)
                             pMFI->m_bSimOpComplete = bDone;
                         else
                         {
                             setOpStatus(miParent, eOpStatusDone);
                             pMFI->m_bOperationComplete = bDone;
                         }
                     }
                     miParent = miParent.parent();
                 }
             }
         }
 
         if(!miCurrent.isValid()) // end?
         {
             if(m_bRealMergeStarted)
             {
                 if(bVerbose)
                 {
                     KMessageBox::information(q, i18n("Merge operation complete."), i18n("Merge Complete"));
                 }
                 m_bRealMergeStarted = false;
                 m_pStatusInfo->setWindowTitle(i18n("Merge Complete"));
             }
             if(m_bSimulatedMergeStarted)
             {
                 m_bSimulatedMergeStarted = false;
                 QModelIndex mi = rowCount() > 0 ? index(0, 0, QModelIndex()) : QModelIndex();
                 for(; mi.isValid(); mi = treeIterator(mi))
                 {
                     getMFI(mi)->m_bSimOpComplete = false;
                 }
                 m_pStatusInfo->setWindowTitle(i18n("Simulated merge complete: Check if you agree with the proposed operations."));
                 m_pStatusInfo->exec();
             }
             m_mergeItemList.clear();
             m_bRealMergeStarted = false;
             return;
         }
 
         MergeFileInfos& mfi = *getMFI(miCurrent);
 
         pp.setInformation(mfi.subPath(),
                           bSim ? nrOfCompletedSimItems : nrOfCompletedItems,
                           false // bRedrawUpdate
                           );
 
         bSuccess = executeMergeOperation(mfi, bSingleFileMerge); // Here the real operation happens.
 
         if(bSuccess)
         {
             if(bSim)
                 ++nrOfCompletedSimItems;
             else
                 ++nrOfCompletedItems;
             bContinueWithCurrentItem = false;
         }
 
         if(pp.wasCancelled())
             break;
     } // end while
 
     //g_pProgressDialog->hide();
 
     q->setCurrentIndex(miCurrent);
     q->scrollTo(miCurrent, EnsureVisible);
     if(!bSuccess && !bSingleFileMerge)
     {
         KMessageBox::error(q, i18n("An error occurred. Press OK to see detailed information.\n"), i18n("Error"));
         m_pStatusInfo->setWindowTitle(i18n("Merge Error"));
         m_pStatusInfo->exec();
         //if ( m_pStatusInfo->firstChild()!=0 )
         //   m_pStatusInfo->ensureItemVisible( m_pStatusInfo->last() );
         m_bError = true;
 
         setOpStatus(miCurrent, eOpStatusError);
     }
     else
     {
         m_bError = false;
     }
     emit q->updateAvailabilities();
 
     if(m_currentIndexForOperation == m_mergeItemList.end())
     {
         m_mergeItemList.clear();
         m_bRealMergeStarted = false;
     }
 }
 
 bool DirectoryMergeWindow::Data::deleteFLD(const QString& name, bool bCreateBackup)
 {
     FileAccess fi(name, true);
     if(!fi.exists())
         return true;
 
     if(bCreateBackup)
     {
         bool bSuccess = renameFLD(name, name + ".orig");
         if(!bSuccess)
         {
             m_pStatusInfo->addText(i18n("Error: While deleting %1: Creating backup failed.", name));
             return false;
         }
     }
     else
     {
         if(fi.isDir() && !fi.isSymLink())
             m_pStatusInfo->addText(i18n("delete directory recursively( %1 )", name));
         else
             m_pStatusInfo->addText(i18n("delete( %1 )", name));
 
         if(m_bSimulatedMergeStarted)
         {
             return true;
         }
 
         if(fi.isDir() && !fi.isSymLink()) // recursive directory delete only for real dirs, not symlinks
         {
             t_DirectoryList dirList;
             bool bSuccess = fi.listDir(&dirList, false, true, "*", "", "", false, false); // not recursive, find hidden files
 
             if(!bSuccess)
             {
                 // No Permission to read directory or other error.
                 m_pStatusInfo->addText(i18n("Error: delete dir operation failed while trying to read the directory."));
                 return false;
             }
 
             t_DirectoryList::iterator it; // create list iterator
 
             for(it = dirList.begin(); it != dirList.end(); ++it) // for each file...
             {
                 FileAccess& fi2 = *it;
                 if(fi2.fileName() == "." || fi2.fileName() == "..")
                     continue;
                 bSuccess = deleteFLD(fi2.absoluteFilePath(), false);
                 if(!bSuccess) break;
             }
             if(bSuccess)
             {
                 bSuccess = FileAccess::removeDir(name);
                 if(!bSuccess)
                 {
                     m_pStatusInfo->addText(i18n("Error: rmdir( %1 ) operation failed.", name));
                     return false;
                 }
             }
         }
         else
         {
             bool bSuccess = FileAccess::removeFile(name);
             if(!bSuccess)
             {
                 m_pStatusInfo->addText(i18n("Error: delete operation failed."));
                 return false;
             }
         }
     }
     return true;
 }
 
 bool DirectoryMergeWindow::Data::mergeFLD(const QString& nameA, const QString& nameB, const QString& nameC, const QString& nameDest, bool& bSingleFileMerge)
 {
     FileAccess fi(nameA);
     if(fi.isDir())
     {
         return makeDir(nameDest);
     }
 
     // Make sure that the dir exists, into which we will save the file later.
     int pos = nameDest.lastIndexOf('/');
     if(pos > 0)
     {
         QString parentName = nameDest.left(pos);
         bool bSuccess = makeDir(parentName, true /*quiet*/);
         if(!bSuccess)
             return false;
     }
 
     m_pStatusInfo->addText(i18n("manual merge( %1, %2, %3 -> %4)", nameA, nameB, nameC, nameDest));
     if(m_bSimulatedMergeStarted)
     {
         m_pStatusInfo->addText(i18n("     Note: After a manual merge the user should continue by pressing F7."));
         return true;
     }
 
     bSingleFileMerge = true;
     setOpStatus(*m_currentIndexForOperation, eOpStatusInProgress);
     q->scrollTo(*m_currentIndexForOperation, EnsureVisible);
 
     emit q->startDiffMerge(nameA, nameB, nameC, nameDest, "", "", "", nullptr);
 
     return false;
 }
 
 bool DirectoryMergeWindow::Data::copyFLD(const QString& srcName, const QString& destName)
 {
     if(srcName == destName)
         return true;
 
     FileAccess fi(srcName);
     FileAccess faDest(destName, true);
     if(faDest.exists() && !(fi.isDir() && faDest.isDir() && (fi.isSymLink() == faDest.isSymLink())))
     {
         bool bSuccess = deleteFLD(destName, m_pOptions->m_bDmCreateBakFiles);
         if(!bSuccess)
         {
             m_pStatusInfo->addText(i18n("Error: copy( %1 -> %2 ) failed."
                                         "Deleting existing destination failed.",
                                         srcName, destName));
             return false;
         }
     }
 
     if(fi.isSymLink() && ((fi.isDir() && !m_bFollowDirLinks) || (!fi.isDir() && !m_bFollowFileLinks)))
     {
         m_pStatusInfo->addText(i18n("copyLink( %1 -> %2 )", srcName, destName));
 #if defined(Q_OS_WIN)
 // What are links?
 #else
         if(m_bSimulatedMergeStarted)
         {
             return true;
         }
         FileAccess destFi(destName);
         if(!destFi.isLocal() || !fi.isLocal())
         {
             m_pStatusInfo->addText(i18n("Error: copyLink failed: Remote links are not yet supported."));
             return false;
         }
         QString linkTarget = fi.readLink();
         bool bSuccess = FileAccess::symLink(linkTarget, destName);
         if(!bSuccess)
             m_pStatusInfo->addText(i18n("Error: copyLink failed."));
         return bSuccess;
 #endif
     }
 
     if(fi.isDir())
     {
         if(faDest.exists())
             return true;
         else
         {
             bool bSuccess = makeDir(destName);
             return bSuccess;
         }
     }
 
     int pos = destName.lastIndexOf('/');
     if(pos > 0)
     {
         QString parentName = destName.left(pos);
         bool bSuccess = makeDir(parentName, true /*quiet*/);
         if(!bSuccess)
             return false;
     }
 
     m_pStatusInfo->addText(i18n("copy( %1 -> %2 )", srcName, destName));
 
     if(m_bSimulatedMergeStarted)
     {
         return true;
     }
 
     FileAccess faSrc(srcName);
     bool bSuccess = faSrc.copyFile(destName);
     if(!bSuccess) m_pStatusInfo->addText(faSrc.getStatusText());
     return bSuccess;
 }
 
 // Rename is not an operation that can be selected by the user.
 // It will only be used to create backups.
 // Hence it will delete an existing destination without making a backup (of the old backup.)
 bool DirectoryMergeWindow::Data::renameFLD(const QString& srcName, const QString& destName)
 {
     if(srcName == destName)
         return true;
 
     if(FileAccess(destName, true).exists())
     {
         bool bSuccess = deleteFLD(destName, false /*no backup*/);
         if(!bSuccess)
         {
             m_pStatusInfo->addText(i18n("Error during rename( %1 -> %2 ): "
                                         "Cannot delete existing destination.",
                                         srcName, destName));
             return false;
         }
     }
 
     m_pStatusInfo->addText(i18n("rename( %1 -> %2 )", srcName, destName));
     if(m_bSimulatedMergeStarted)
     {
         return true;
     }
 
     bool bSuccess = FileAccess(srcName).rename(destName);
     if(!bSuccess)
     {
         m_pStatusInfo->addText(i18n("Error: Rename failed."));
         return false;
     }
 
     return true;
 }
 
 bool DirectoryMergeWindow::Data::makeDir(const QString& name, bool bQuiet)
 {
     FileAccess fi(name, true);
     if(fi.exists() && fi.isDir())
         return true;
 
     if(fi.exists() && !fi.isDir())
     {
         bool bSuccess = deleteFLD(name, true);
         if(!bSuccess)
         {
             m_pStatusInfo->addText(i18n("Error during makeDir of %1. "
                                         "Cannot delete existing file.",
                                         name));
             return false;
         }
     }
 
     int pos = name.lastIndexOf('/');
     if(pos > 0)
     {
         QString parentName = name.left(pos);
         bool bSuccess = makeDir(parentName, true);
         if(!bSuccess)
             return false;
     }
 
     if(!bQuiet)
         m_pStatusInfo->addText(i18n("makeDir( %1 )", name));
 
     if(m_bSimulatedMergeStarted)
     {
         return true;
     }
 
     bool bSuccess = FileAccess::makeDir(name);
     if(bSuccess == false)
     {
         m_pStatusInfo->addText(i18n("Error while creating directory."));
         return false;
     }
     return true;
 }
 
 DirectoryMergeInfo::DirectoryMergeInfo(QWidget* pParent)
     : QFrame(pParent)
 {
     QVBoxLayout* topLayout = new QVBoxLayout(this);
     topLayout->setMargin(0);
 
     QGridLayout* grid = new QGridLayout();
     topLayout->addLayout(grid);
     grid->setColumnStretch(1, 10);
 
     int line = 0;
 
     m_pA = new QLabel("A", this);
     grid->addWidget(m_pA, line, 0);
     m_pInfoA = new QLabel(this);
     grid->addWidget(m_pInfoA, line, 1);
     ++line;
     
     m_pB = new QLabel("B", this);
     grid->addWidget(m_pB, line, 0);
     m_pInfoB = new QLabel(this);
     grid->addWidget(m_pInfoB, line, 1);
     ++line;
     
     m_pC = new QLabel("C", this);
     grid->addWidget(m_pC, line, 0);
     m_pInfoC = new QLabel(this);
     grid->addWidget(m_pInfoC, line, 1);
     ++line;
     
     m_pDest = new QLabel(i18n("Dest"), this);
     grid->addWidget(m_pDest, line, 0);
     m_pInfoDest = new QLabel(this);
     grid->addWidget(m_pInfoDest, line, 1);
     ++line;
 
     m_pInfoList = new QTreeWidget(this);
     topLayout->addWidget(m_pInfoList);
     m_pInfoList->setHeaderLabels(QStringList() << i18n("Dir") << i18n("Type") << i18n("Size")
                                                << i18n("Attr") << i18n("Last Modification") << i18n("Link-Destination"));
     setMinimumSize(100, 100);
 
     m_pInfoList->installEventFilter(this);
     m_pInfoList->setRootIsDecorated(false);
 }
 
 bool DirectoryMergeInfo::eventFilter(QObject* o, QEvent* e)
 {
     if(e->type() == QEvent::FocusIn && o == m_pInfoList)
         emit gotFocus();
     return false;
 }
 
 static void addListViewItem(QTreeWidget* pListView, const QString& dir,
                             const QString& basePath, FileAccess* fi)
 {
     if(basePath.isEmpty())
     {
         return;
     }
     else
     {
         if(fi != nullptr && fi->exists())
         {
             QString dateString = fi->lastModified().toString("yyyy-MM-dd hh:mm:ss");
 
             new QTreeWidgetItem(
                 pListView,
                 QStringList() << dir << QString(fi->isDir() ? i18n("Dir") : i18n("File")) + (fi->isSymLink() ? "-Link" : "") << QString::number(fi->size()) << QString(fi->isReadable() ? "r" : " ") + (fi->isWritable() ? "w" : " ")
 #ifdef Q_OS_WIN
                               /*Future: Use GetFileAttributes()*/
                               <<
 #else
                                                                                                                                                                    + (fi->isExecutable() ? "x" : " ")
                               <<
 #endif
                     dateString << QString(fi->isSymLink() ? (" -> " + fi->readLink()) : QString("")));
         }
         else
         {
             new QTreeWidgetItem(
                 pListView,
                 QStringList() << dir << i18n("not available") << ""
                               << ""
                               << ""
                               << "");
         }
     }
 }
 
 void DirectoryMergeInfo::setInfo(
     const FileAccess& dirA,
     const FileAccess& dirB,
     const FileAccess& dirC,
     const FileAccess& dirDest,
     MergeFileInfos& mfi)
 {
     bool bHideDest = false;
     if(dirA.absoluteFilePath() == dirDest.absoluteFilePath())
     {
         m_pA->setText(i18n("A (Dest): "));
         bHideDest = true;
     }
     else
         m_pA->setText(!dirC.isValid() ? QString("A:    ") : i18n("A (Base): "));
 
     m_pInfoA->setText(dirA.prettyAbsPath());
 
     if(dirB.absoluteFilePath() == dirDest.absoluteFilePath())
     {
         m_pB->setText(i18n("B (Dest): "));
         bHideDest = true;
     }
     else
         m_pB->setText("B:    ");
     m_pInfoB->setText(dirB.prettyAbsPath());
 
     if(dirC.absoluteFilePath() == dirDest.absoluteFilePath())
     {
         m_pC->setText(i18n("C (Dest): "));
         bHideDest = true;
     }
     else
         m_pC->setText("C:    ");
     m_pInfoC->setText(dirC.prettyAbsPath());
 
     m_pDest->setText(i18n("Dest: "));
     m_pInfoDest->setText(dirDest.prettyAbsPath());
 
     if(!dirC.isValid()) {
         m_pC->hide();
         m_pInfoC->hide();
     }
     else
     {
         m_pC->show();
         m_pInfoC->show();
     }
 
     if(!dirDest.isValid() || bHideDest) {
         m_pDest->hide();
         m_pInfoDest->hide();
     }
     else
     {
         m_pDest->show();
         m_pInfoDest->show();
     }
 
     m_pInfoList->clear();
     addListViewItem(m_pInfoList, "A", dirA.prettyAbsPath(), mfi.m_pFileInfoA);
     addListViewItem(m_pInfoList, "B", dirB.prettyAbsPath(), mfi.m_pFileInfoB);
     addListViewItem(m_pInfoList, "C", dirC.prettyAbsPath(), mfi.m_pFileInfoC);
     if(!bHideDest)
     {
         FileAccess fiDest(dirDest.prettyAbsPath() + "/" + mfi.subPath(), true);
         addListViewItem(m_pInfoList, i18n("Dest"), dirDest.prettyAbsPath(), &fiDest);
     }
     for(int i = 0; i < m_pInfoList->columnCount(); ++i)
         m_pInfoList->resizeColumnToContents(i);
 }
 
 QTextStream& operator<<(QTextStream& ts, MergeFileInfos& mfi)
 {
     ts << "{\n";
     ValueMap vm;
     vm.writeEntry("SubPath", mfi.subPath());
     vm.writeEntry("ExistsInA", mfi.existsInA());
     vm.writeEntry("ExistsInB", mfi.existsInB());
     vm.writeEntry("ExistsInC", mfi.existsInC());
     vm.writeEntry("EqualAB", mfi.m_bEqualAB);
     vm.writeEntry("EqualAC", mfi.m_bEqualAC);
     vm.writeEntry("EqualBC", mfi.m_bEqualBC);
     //DirMergeItem* m_pDMI;
     //MergeFileInfos* m_pParent;
     vm.writeEntry("MergeOperation", (int)mfi.m_eMergeOperation);
     vm.writeEntry("DirA", mfi.dirA());
     vm.writeEntry("DirB", mfi.dirB());
     vm.writeEntry("DirC", mfi.dirC());
     vm.writeEntry("LinkA", mfi.isLinkA());
     vm.writeEntry("LinkB", mfi.isLinkB());
     vm.writeEntry("LinkC", mfi.isLinkC());
     vm.writeEntry("OperationComplete", mfi.m_bOperationComplete);
     //bool m_bSimOpComplete );
 
     vm.writeEntry("AgeA", (int)mfi.m_ageA);
     vm.writeEntry("AgeB", (int)mfi.m_ageB);
     vm.writeEntry("AgeC", (int)mfi.m_ageC);
     vm.writeEntry("ConflictingAges", mfi.m_bConflictingAges); // Equal age but files are not!
 
     //FileAccess m_fileInfoA;
     //FileAccess m_fileInfoB;
     //FileAccess m_fileInfoC;
 
     //TotalDiffStatus m_totalDiffStatus;
 
     vm.save(ts);
 
     ts << "}\n";
 
     return ts;
 }
 
 void DirectoryMergeWindow::slotSaveMergeState()
 {
     //slotStatusMsg(i18n("Saving Directory Merge State ..."));
 
     //QString s = KFileDialog::getSaveUrl( QDir::currentPath(), 0, this, i18n("Save As...") ).url();
     QString s = QFileDialog::getSaveFileName(this, i18n("Save Directory Merge State As..."), QDir::currentPath(), nullptr);
     if(!s.isEmpty())
     {
         d->m_dirMergeStateFilename = s;
 
         QFile file(d->m_dirMergeStateFilename);
         bool bSuccess = file.open(QIODevice::WriteOnly);
         if(bSuccess)
         {
             QTextStream ts(&file);
 
             QModelIndex mi(d->index(0, 0, QModelIndex()));
             while(mi.isValid()) {
                 MergeFileInfos* pMFI = d->getMFI(mi);
                 ts << *pMFI;
                 mi = d->treeIterator(mi, true, true);
             }
         }
     }
 
     //slotStatusMsg(i18n("Ready."));
 }
 
 void DirectoryMergeWindow::slotLoadMergeState()
 {
 }
 
 void DirectoryMergeWindow::updateFileVisibilities()
 {
     bool bShowIdentical = d->m_pDirShowIdenticalFiles->isChecked();
     bool bShowDifferent = d->m_pDirShowDifferentFiles->isChecked();
     bool bShowOnlyInA = d->m_pDirShowFilesOnlyInA->isChecked();
     bool bShowOnlyInB = d->m_pDirShowFilesOnlyInB->isChecked();
     bool bShowOnlyInC = d->m_pDirShowFilesOnlyInC->isChecked();
     bool bThreeDirs = d->m_dirC.isValid();
     d->m_selection1Index = QModelIndex();
     d->m_selection2Index = QModelIndex();
     d->m_selection3Index = QModelIndex();
 
     // in first run set all dirs to equal and determine if they are not equal.
     // on second run don't change the equal-status anymore; it is needed to
     // set the visibility (when bShowIdentical is false).
     for(int loop = 0; loop < 2; ++loop)
     {
         QModelIndex mi = d->rowCount() > 0 ? d->index(0, 0, QModelIndex()) : QModelIndex();
         while(mi.isValid())
         {
             MergeFileInfos* pMFI = d->getMFI(mi);
             bool bDir = pMFI->dirA() || pMFI->dirB() || pMFI->dirC();
             if(loop == 0 && bDir)
             {
                 bool bChange = false;
                 if(!pMFI->m_bEqualAB && pMFI->dirA() == pMFI->dirB() && pMFI->isLinkA() == pMFI->isLinkB())
                 {
                     pMFI->m_bEqualAB = true;
                     bChange = true;
                 }
                 if(!pMFI->m_bEqualBC && pMFI->dirC() == pMFI->dirB() && pMFI->isLinkC() == pMFI->isLinkB())
                 {
                     pMFI->m_bEqualBC = true;
                     bChange = true;
                 }
                 if(!pMFI->m_bEqualAC && pMFI->dirA() == pMFI->dirC() && pMFI->isLinkA() == pMFI->isLinkC())
                 {
                     pMFI->m_bEqualAC = true;
                     bChange = true;
                 }
 
                 if(bChange)
                     setPixmaps(*pMFI, bThreeDirs);
             }
             bool bExistsEverywhere = pMFI->existsInA() && pMFI->existsInB() && (pMFI->existsInC() || !bThreeDirs);
             int existCount = int(pMFI->existsInA()) + int(pMFI->existsInB()) + int(pMFI->existsInC());
             bool bVisible =
                 (bShowIdentical && bExistsEverywhere && pMFI->m_bEqualAB && (pMFI->m_bEqualAC || !bThreeDirs)) || ((bShowDifferent || bDir) && existCount >= 2 && (!pMFI->m_bEqualAB || !(pMFI->m_bEqualAC || !bThreeDirs))) || (bShowOnlyInA && pMFI->existsInA() && !pMFI->existsInB() && !pMFI->existsInC()) || (bShowOnlyInB && !pMFI->existsInA() && pMFI->existsInB() && !pMFI->existsInC()) || (bShowOnlyInC && !pMFI->existsInA() && !pMFI->existsInB() && pMFI->existsInC());
 
             QString fileName = pMFI->fileName();
             bVisible = bVisible && ((bDir && !wildcardMultiMatch(d->m_pOptions->m_DmDirAntiPattern, fileName, d->m_bCaseSensitive)) || (wildcardMultiMatch(d->m_pOptions->m_DmFilePattern, fileName, d->m_bCaseSensitive) && !wildcardMultiMatch(d->m_pOptions->m_DmFileAntiPattern, fileName, d->m_bCaseSensitive)));
 
             setRowHidden(mi.row(), mi.parent(), !bVisible);
 
             bool bEqual = bThreeDirs ? pMFI->m_bEqualAB && pMFI->m_bEqualAC : pMFI->m_bEqualAB;
             if(!bEqual && bVisible && loop == 0) // Set all parents to "not equal"
             {
                 MergeFileInfos* p2 = pMFI->m_pParent;
                 while(p2 != nullptr)
                 {
                     bool bChange = false;
                     if(!pMFI->m_bEqualAB && p2->m_bEqualAB) {
                         p2->m_bEqualAB = false;
                         bChange = true;
                     }
                     if(!pMFI->m_bEqualAC && p2->m_bEqualAC) {
                         p2->m_bEqualAC = false;
                         bChange = true;
                     }
                     if(!pMFI->m_bEqualBC && p2->m_bEqualBC) {
                         p2->m_bEqualBC = false;
                         bChange = true;
                     }
 
                     if(bChange)
                         setPixmaps(*p2, bThreeDirs);
                     else
                         break;
 
                     p2 = p2->m_pParent;
                 }
             }
             mi = d->treeIterator(mi, true, true);
         }
     }
 }
 
 void DirectoryMergeWindow::slotShowIdenticalFiles()
 {
     d->m_pOptions->m_bDmShowIdenticalFiles = d->m_pDirShowIdenticalFiles->isChecked();
     updateFileVisibilities();
 }
 void DirectoryMergeWindow::slotShowDifferentFiles() { updateFileVisibilities(); }
 void DirectoryMergeWindow::slotShowFilesOnlyInA() { updateFileVisibilities(); }
 void DirectoryMergeWindow::slotShowFilesOnlyInB() { updateFileVisibilities(); }
 void DirectoryMergeWindow::slotShowFilesOnlyInC() { updateFileVisibilities(); }
 
 void DirectoryMergeWindow::slotSynchronizeDirectories() {}
 void DirectoryMergeWindow::slotChooseNewerFiles() {}
 
 void DirectoryMergeWindow::initDirectoryMergeActions(QObject* pKDiff3App, KActionCollection* ac)
 {
 #include "xpm/showequalfiles.xpm"
 #include "xpm/showfilesonlyina.xpm"
 #include "xpm/showfilesonlyinb.xpm"
 #include "xpm/showfilesonlyinc.xpm"
 #include "xpm/startmerge.xpm"
     DirectoryMergeWindow* p = this;
 
     d->m_pDirStartOperation = KDiff3::createAction<QAction>(i18n("Start/Continue Directory Merge"), QKeySequence(Qt::Key_F7), p, SLOT(slotRunOperationForAllItems()), ac, "dir_start_operation");
     d->m_pDirRunOperationForCurrentItem = KDiff3::createAction<QAction>(i18n("Run Operation for Current Item"), QKeySequence(Qt::Key_F6), p, SLOT(slotRunOperationForCurrentItem()), ac, "dir_run_operation_for_current_item");
     d->m_pDirCompareCurrent = KDiff3::createAction<QAction>(i18n("Compare Selected File"), p, SLOT(compareCurrentFile()), ac, "dir_compare_current");
     d->m_pDirMergeCurrent = KDiff3::createAction<QAction>(i18n("Merge Current File"), QIcon(QPixmap(startmerge)), i18n("Merge\nFile"), pKDiff3App, SLOT(slotMergeCurrentFile()), ac, "merge_current");
     d->m_pDirFoldAll = KDiff3::createAction<QAction>(i18n("Fold All Subdirs"), p, SLOT(collapseAll()), ac, "dir_fold_all");
     d->m_pDirUnfoldAll = KDiff3::createAction<QAction>(i18n("Unfold All Subdirs"), p, SLOT(expandAll()), ac, "dir_unfold_all");
     d->m_pDirRescan = KDiff3::createAction<QAction>(i18n("Rescan"), QKeySequence(Qt::SHIFT + Qt::Key_F5), p, SLOT(reload()), ac, "dir_rescan");
     d->m_pDirSaveMergeState = nullptr; //KDiff3::createAction< QAction >(i18n("Save Directory Merge State ..."), 0, p, SLOT(slotSaveMergeState()), ac, "dir_save_merge_state");
     d->m_pDirLoadMergeState = nullptr; //KDiff3::createAction< QAction >(i18n("Load Directory Merge State ..."), 0, p, SLOT(slotLoadMergeState()), ac, "dir_load_merge_state");
     d->m_pDirChooseAEverywhere = KDiff3::createAction<QAction>(i18n("Choose A for All Items"), p, SLOT(slotChooseAEverywhere()), ac, "dir_choose_a_everywhere");
     d->m_pDirChooseBEverywhere = KDiff3::createAction<QAction>(i18n("Choose B for All Items"), p, SLOT(slotChooseBEverywhere()), ac, "dir_choose_b_everywhere");
     d->m_pDirChooseCEverywhere = KDiff3::createAction<QAction>(i18n("Choose C for All Items"), p, SLOT(slotChooseCEverywhere()), ac, "dir_choose_c_everywhere");
     d->m_pDirAutoChoiceEverywhere = KDiff3::createAction<QAction>(i18n("Auto-Choose Operation for All Items"), p, SLOT(slotAutoChooseEverywhere()), ac, "dir_autochoose_everywhere");
     d->m_pDirDoNothingEverywhere = KDiff3::createAction<QAction>(i18n("No Operation for All Items"), p, SLOT(slotNoOpEverywhere()), ac, "dir_nothing_everywhere");
 
     //   d->m_pDirSynchronizeDirectories = KDiff3::createAction< KToggleAction >(i18n("Synchronize Directories"), 0, this, SLOT(slotSynchronizeDirectories()), ac, "dir_synchronize_directories");
     //   d->m_pDirChooseNewerFiles = KDiff3::createAction< KToggleAction >(i18n("Copy Newer Files Instead of Merging"), 0, this, SLOT(slotChooseNewerFiles()), ac, "dir_choose_newer_files");
 
     d->m_pDirShowIdenticalFiles = KDiff3::createAction<KToggleAction>(i18n("Show Identical Files"), QIcon(QPixmap(showequalfiles)), i18n("Identical\nFiles"), this, SLOT(slotShowIdenticalFiles()), ac, "dir_show_identical_files");
     d->m_pDirShowDifferentFiles = KDiff3::createAction<KToggleAction>(i18n("Show Different Files"), this, SLOT(slotShowDifferentFiles()), ac, "dir_show_different_files");
     d->m_pDirShowFilesOnlyInA = KDiff3::createAction<KToggleAction>(i18n("Show Files only in A"), QIcon(QPixmap(showfilesonlyina)), i18n("Files\nonly in A"), this, SLOT(slotShowFilesOnlyInA()), ac, "dir_show_files_only_in_a");
     d->m_pDirShowFilesOnlyInB = KDiff3::createAction<KToggleAction>(i18n("Show Files only in B"), QIcon(QPixmap(showfilesonlyinb)), i18n("Files\nonly in B"), this, SLOT(slotShowFilesOnlyInB()), ac, "dir_show_files_only_in_b");
     d->m_pDirShowFilesOnlyInC = KDiff3::createAction<KToggleAction>(i18n("Show Files only in C"), QIcon(QPixmap(showfilesonlyinc)), i18n("Files\nonly in C"), this, SLOT(slotShowFilesOnlyInC()), ac, "dir_show_files_only_in_c");
 
     d->m_pDirShowIdenticalFiles->setChecked(d->m_pOptions->m_bDmShowIdenticalFiles);
 
     d->m_pDirCompareExplicit = KDiff3::createAction<QAction>(i18n("Compare Explicitly Selected Files"), p, SLOT(slotCompareExplicitlySelectedFiles()), ac, "dir_compare_explicitly_selected_files");
     d->m_pDirMergeExplicit = KDiff3::createAction<QAction>(i18n("Merge Explicitly Selected Files"), p, SLOT(slotMergeExplicitlySelectedFiles()), ac, "dir_merge_explicitly_selected_files");
 
     d->m_pDirCurrentDoNothing = KDiff3::createAction<QAction>(i18n("Do Nothing"), p, SLOT(slotCurrentDoNothing()), ac, "dir_current_do_nothing");
     d->m_pDirCurrentChooseA = KDiff3::createAction<QAction>(i18n("A"), p, SLOT(slotCurrentChooseA()), ac, "dir_current_choose_a");
     d->m_pDirCurrentChooseB = KDiff3::createAction<QAction>(i18n("B"), p, SLOT(slotCurrentChooseB()), ac, "dir_current_choose_b");
     d->m_pDirCurrentChooseC = KDiff3::createAction<QAction>(i18n("C"), p, SLOT(slotCurrentChooseC()), ac, "dir_current_choose_c");
     d->m_pDirCurrentMerge = KDiff3::createAction<QAction>(i18n("Merge"), p, SLOT(slotCurrentMerge()), ac, "dir_current_merge");
     d->m_pDirCurrentDelete = KDiff3::createAction<QAction>(i18n("Delete (if exists)"), p, SLOT(slotCurrentDelete()), ac, "dir_current_delete");
 
     d->m_pDirCurrentSyncDoNothing = KDiff3::createAction<QAction>(i18n("Do Nothing"), p, SLOT(slotCurrentDoNothing()), ac, "dir_current_sync_do_nothing");
     d->m_pDirCurrentSyncCopyAToB = KDiff3::createAction<QAction>(i18n("Copy A to B"), p, SLOT(slotCurrentCopyAToB()), ac, "dir_current_sync_copy_a_to_b");
     d->m_pDirCurrentSyncCopyBToA = KDiff3::createAction<QAction>(i18n("Copy B to A"), p, SLOT(slotCurrentCopyBToA()), ac, "dir_current_sync_copy_b_to_a");
     d->m_pDirCurrentSyncDeleteA = KDiff3::createAction<QAction>(i18n("Delete A"), p, SLOT(slotCurrentDeleteA()), ac, "dir_current_sync_delete_a");
     d->m_pDirCurrentSyncDeleteB = KDiff3::createAction<QAction>(i18n("Delete B"), p, SLOT(slotCurrentDeleteB()), ac, "dir_current_sync_delete_b");
     d->m_pDirCurrentSyncDeleteAAndB = KDiff3::createAction<QAction>(i18n("Delete A && B"), p, SLOT(slotCurrentDeleteAAndB()), ac, "dir_current_sync_delete_a_and_b");
     d->m_pDirCurrentSyncMergeToA = KDiff3::createAction<QAction>(i18n("Merge to A"), p, SLOT(slotCurrentMergeToA()), ac, "dir_current_sync_merge_to_a");
     d->m_pDirCurrentSyncMergeToB = KDiff3::createAction<QAction>(i18n("Merge to B"), p, SLOT(slotCurrentMergeToB()), ac, "dir_current_sync_merge_to_b");
     d->m_pDirCurrentSyncMergeToAAndB = KDiff3::createAction<QAction>(i18n("Merge to A && B"), p, SLOT(slotCurrentMergeToAAndB()), ac, "dir_current_sync_merge_to_a_and_b");
 }
 
 void DirectoryMergeWindow::updateAvailabilities(bool bDirCompare, bool bDiffWindowVisible,
                                                 KToggleAction* chooseA, KToggleAction* chooseB, KToggleAction* chooseC)
 {
     d->m_pDirStartOperation->setEnabled(bDirCompare);
     d->m_pDirRunOperationForCurrentItem->setEnabled(bDirCompare);
     d->m_pDirFoldAll->setEnabled(bDirCompare);
     d->m_pDirUnfoldAll->setEnabled(bDirCompare);
 
     d->m_pDirCompareCurrent->setEnabled(bDirCompare && isVisible() && isFileSelected());
 
     d->m_pDirMergeCurrent->setEnabled((bDirCompare && isVisible() && isFileSelected()) || bDiffWindowVisible);
 
     d->m_pDirRescan->setEnabled(bDirCompare);
 
     d->m_pDirAutoChoiceEverywhere->setEnabled(bDirCompare && isVisible());
     d->m_pDirDoNothingEverywhere->setEnabled(bDirCompare && isVisible());
     d->m_pDirChooseAEverywhere->setEnabled(bDirCompare && isVisible());
     d->m_pDirChooseBEverywhere->setEnabled(bDirCompare && isVisible());
     d->m_pDirChooseCEverywhere->setEnabled(bDirCompare && isVisible());
 
     bool bThreeDirs = d->m_dirC.isValid();
 
     MergeFileInfos* pMFI = d->getMFI(currentIndex());
 
     bool bItemActive = bDirCompare && isVisible() && pMFI != nullptr; //  &&  hasFocus();
     bool bMergeMode = bThreeDirs || !d->m_bSyncMode;
     bool bFTConflict = pMFI == nullptr ? false : conflictingFileTypes(*pMFI);
 
     bool bDirWindowHasFocus = isVisible() && hasFocus();
 
     d->m_pDirShowIdenticalFiles->setEnabled(bDirCompare && isVisible());
     d->m_pDirShowDifferentFiles->setEnabled(bDirCompare && isVisible());
     d->m_pDirShowFilesOnlyInA->setEnabled(bDirCompare && isVisible());
     d->m_pDirShowFilesOnlyInB->setEnabled(bDirCompare && isVisible());
     d->m_pDirShowFilesOnlyInC->setEnabled(bDirCompare && isVisible() && bThreeDirs);
 
     d->m_pDirCompareExplicit->setEnabled(bDirCompare && isVisible() && d->m_selection2Index.isValid());
     d->m_pDirMergeExplicit->setEnabled(bDirCompare && isVisible() && d->m_selection2Index.isValid());
 
     d->m_pDirCurrentDoNothing->setEnabled(bItemActive && bMergeMode);
     d->m_pDirCurrentChooseA->setEnabled(bItemActive && bMergeMode && pMFI->existsInA());
     d->m_pDirCurrentChooseB->setEnabled(bItemActive && bMergeMode && pMFI->existsInB());
     d->m_pDirCurrentChooseC->setEnabled(bItemActive && bMergeMode && pMFI->existsInC());
     d->m_pDirCurrentMerge->setEnabled(bItemActive && bMergeMode && !bFTConflict);
     d->m_pDirCurrentDelete->setEnabled(bItemActive && bMergeMode);
     if(bDirWindowHasFocus)
     {
         chooseA->setEnabled(bItemActive && pMFI->existsInA());
         chooseB->setEnabled(bItemActive && pMFI->existsInB());
         chooseC->setEnabled(bItemActive && pMFI->existsInC());
         chooseA->setChecked(false);
         chooseB->setChecked(false);
         chooseC->setChecked(false);
     }
 
     d->m_pDirCurrentSyncDoNothing->setEnabled(bItemActive && !bMergeMode);
     d->m_pDirCurrentSyncCopyAToB->setEnabled(bItemActive && !bMergeMode && pMFI->existsInA());
     d->m_pDirCurrentSyncCopyBToA->setEnabled(bItemActive && !bMergeMode && pMFI->existsInB());
     d->m_pDirCurrentSyncDeleteA->setEnabled(bItemActive && !bMergeMode && pMFI->existsInA());
     d->m_pDirCurrentSyncDeleteB->setEnabled(bItemActive && !bMergeMode && pMFI->existsInB());
     d->m_pDirCurrentSyncDeleteAAndB->setEnabled(bItemActive && !bMergeMode && pMFI->existsInA() && pMFI->existsInB());
     d->m_pDirCurrentSyncMergeToA->setEnabled(bItemActive && !bMergeMode && !bFTConflict);
     d->m_pDirCurrentSyncMergeToB->setEnabled(bItemActive && !bMergeMode && !bFTConflict);
     d->m_pDirCurrentSyncMergeToAAndB->setEnabled(bItemActive && !bMergeMode && !bFTConflict);
 }
 
 //#include "directorymergewindow.moc"
diff --git a/src/fileaccess.cpp b/src/fileaccess.cpp
index 05ffa49..6e18af2 100644
--- a/src/fileaccess.cpp
+++ b/src/fileaccess.cpp
@@ -1,1784 +1,1784 @@
 /***************************************************************************
  *   Copyright (C) 2003-2011 by Joachim Eibl                               *
  *   joachim.eibl at gmx.de                                                *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  ***************************************************************************/
 #include "fileaccess.h"
 #include "common.h"
 #include "progress.h"
 
 #include <QDir>
 #include <QProcess>
 #include <QRegExp>
 #include <QTemporaryFile>
 #include <QTextStream>
 
 #include <cstdlib>
 #include <vector>
 
 #include <KIO/CopyJob>
 #include <KIO/Job>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <kio/global.h>
 #include <kio/jobclasses.h>
 #include <kio/jobuidelegate.h>
 
 #include <sys/stat.h>
 #include <sys/types.h>
 
 #ifdef Q_OS_WIN
 #include <io.h>
 #include <process.h>
 #include <sys/utime.h>
 #include <windows.h>
 #else
 #include <unistd.h> // Needed for creating symbolic links via symlink().
 #include <utime.h>
 #endif
 
 class FileAccess::Data
 {
   public:
     Data()
     {
         reset();
     }
     void reset()
     {
         m_url = QUrl();
         m_bValidData = false;
         m_name = QString();
         //m_creationTime = QDateTime();
         //m_accessTime = QDateTime();
         m_bReadable = false;
         m_bExecutable = false;
         m_linkTarget = "";
         //m_fileType = -1;
         m_bLocal = true;
         m_pParent = nullptr;
     }
 
     QUrl m_url;
     bool m_bLocal;
     bool m_bValidData;
 
     //QDateTime m_accessTime;
     //QDateTime m_creationTime;
     bool m_bReadable;
     bool m_bExecutable;
     //long m_fileType; // for testing only
     FileAccess* m_pParent;
 
     QString m_linkTarget;
     //QString m_user;
     //QString m_group;
     QString m_name;
     QString m_localCopy;
     QString m_statusText; // Might contain an error string, when the last operation didn't succeed.
 };
 
 FileAccess::FileAccess(const QString& name, bool bWantToWrite)
 {
     m_pData = nullptr;
     m_bUseData = false;
     setFile(name, bWantToWrite);
 }
 
 FileAccess::FileAccess()
 {
     m_bUseData = false;
     m_bExists = false;
     m_bFile = false;
     m_bDir = false;
     m_bSymLink = false;
     m_bWritable = false;
     m_bHidden = false;
     m_pParent = nullptr;
     m_size = 0;
 }
 
 FileAccess::FileAccess(const FileAccess& other)
 {
     m_pData = nullptr;
     m_bUseData = false;
     *this = other;
 }
 
 void FileAccess::createData()
 {
     if(d() == nullptr)
     {
         FileAccess* pParent = m_pParent; // backup because in union with m_pData
         m_pData = new Data();
         m_bUseData = true;
         m_pData->m_pParent = pParent;
     }
 }
 
 FileAccess& FileAccess::operator=(const FileAccess& other)
 {
     m_size = other.m_size;
     m_filePath = other.m_filePath;
     m_modificationTime = other.m_modificationTime;
     m_bSymLink = other.m_bSymLink;
     m_bFile = other.m_bFile;
     m_bDir = other.m_bDir;
     m_bExists = other.m_bExists;
     m_bWritable = other.m_bWritable;
     m_bHidden = other.m_bHidden;
 
     if(other.m_bUseData)
     {
         createData();
         *m_pData = *other.m_pData;
     }
     else
     {
         if(m_bUseData)
         {
             delete m_pData;
         }
         m_bUseData = false;
         m_pParent = other.parent(); // should be 0 anyway
     }
     return *this;
 }
 
 FileAccess::~FileAccess()
 {
     if(m_bUseData)
     {
         if(!d()->m_localCopy.isEmpty())
         {
             removeTempFile(d()->m_localCopy);
         }
         delete m_pData;
     }
 }
 
 static QString nicePath(const QFileInfo& fi)
 {
     QString fp = fi.filePath();
     if(fp.length() > 2 && fp[0] == '.' && fp[1] == '/')
     {
         return fp.mid(2);
     }
     return fp;
 }
 
 // Two kinds of optimization are applied here:
 // 1. Speed: don't ask for data as long as it is not needed or cheap to get.
 //    When opening a file it is early enough to ask for details.
 // 2. Memory usage: Don't store data that is not needed, and avoid redundancy.
 //    For recursive directory trees don't store the full path if a parent is available.
 //    Store urls only if files are not local.
 
 void FileAccess::setFile(const QFileInfo& fi, FileAccess* pParent)
 {
     m_filePath = pParent == nullptr ? fi.absoluteFilePath() : nicePath(fi.filePath()); // remove "./" at start
 
     m_bSymLink = fi.isSymLink();
     if(m_bSymLink || (!m_bExists && m_filePath.contains("@@")))
     {
         createData();
     }
 
     if(m_bUseData)
         d()->m_pParent = pParent;
     else
         m_pParent = pParent;
 
     if(parent() || d()) // if a parent is specified then we arrive here because of listing a directory
     {
         m_bFile = fi.isFile();
         m_bDir = fi.isDir();
         m_bExists = fi.exists();
         m_size = fi.size();
         m_modificationTime = fi.lastModified();
         m_bHidden = fi.isHidden();
 
 #if defined(Q_OS_WIN)
         m_bWritable = pParent == 0 || fi.isWritable(); // in certain situations this might become a problem though
 #else
         m_bWritable = fi.isWritable();
 #endif
     }
 
     if(d() != nullptr)
     {
 #if defined(Q_OS_WIN)
         // On some windows machines in a network this takes very long.
         // and it's not so important anyway.
         d()->m_bReadable = true;
         d()->m_bExecutable = false;
 #else
         d()->m_bReadable = fi.isReadable();
         d()->m_bExecutable = fi.isExecutable();
 #endif
 
         //d()->m_creationTime = fi.created();
         //d()->m_modificationTime = fi.lastModified();
         //d()->m_accessTime = fi.lastRead();
         d()->m_name = fi.fileName();
         if(m_bSymLink)
         {
 #ifdef Q_OS_WIN
             d()->m_linkTarget = fi.readLink();
 #else
             // TODO: Update for Qt5.
             // Unfortunately Qt4 readLink always returns an absolute path, even if the link is relative
             char s[PATH_MAX + 1];
             int len = readlink(QFile::encodeName(fi.absoluteFilePath()).constData(), s, PATH_MAX);
             if(len > 0)
             {
                 s[len] = '\0';
                 d()->m_linkTarget = QFile::decodeName(s);
             }
             else
             {
                 d()->m_linkTarget = fi.readLink();
             }
 #endif
         }
         d()->m_bLocal = true;
         d()->m_bValidData = true;
         d()->m_url = QUrl::fromLocalFile(fi.filePath());
         if(d()->m_url.isRelative())
         {
             d()->m_url.setPath(absoluteFilePath());
         }
 
         if(!m_bExists && absoluteFilePath().contains("@@"))
         {
             // Try reading a clearcase file
             d()->m_localCopy = FileAccess::tempFileName();
             QString cmd = "cleartool get -to \"" + d()->m_localCopy + "\"  \"" + absoluteFilePath() + "\"";
             QProcess process;
             process.start(cmd);
             process.waitForFinished(-1);
             //::system( cmd.local8Bit() );
             QFile::setPermissions(d()->m_localCopy, QFile::ReadUser | QFile::WriteUser); // Clearcase creates a write protected file, allow delete.
 
             QFileInfo fi(d()->m_localCopy);
 #if defined(Q_OS_WIN)
             d()->m_bReadable = true;    //fi.isReadable();
             m_bWritable = true;         //fi.isWritable();
             d()->m_bExecutable = false; //fi.isExecutable();
 #else
             d()->m_bReadable = fi.isReadable();
             d()->m_bExecutable = fi.isExecutable();
 #endif
             //d()->m_creationTime = fi.created();
             //d()->m_accessTime = fi.lastRead();
             m_bExists = fi.exists();
             m_size = fi.size();
         }
     }
 }
 
 void FileAccess::setFile(const QString& name, bool bWantToWrite)
 {
     m_bExists = false;
     m_bFile = false;
     m_bDir = false;
     m_bSymLink = false;
     m_size = 0;
     m_modificationTime = QDateTime();
 
     if(d() != nullptr)
     {
         d()->reset();
         d()->m_pParent = nullptr;
     }
     else
         m_pParent = nullptr;
 
     // Note: Checking if the filename-string is empty is necessary for Win95/98/ME.
     //       The isFile() / isDir() queries would cause the program to crash.
     //       (This is a Win95-bug which has been corrected only in WinNT/2000/XP.)
     if(!name.isEmpty())
     {
         QUrl url = QUrl::fromUserInput(name, QString(), QUrl::AssumeLocalFile);
 
         // FileAccess tries to detect if the given name is an URL or a local file.
         // This is a problem if the filename looks like an URL (i.e. contains a colon ':').
         // e.g. "file:f.txt" is a valid filename.
         // Most of the time it is sufficient to check if the file exists locally.
         // 2 Problems remain:
         //   1. When the local file exists and the remote location is wanted nevertheless. (unlikely)
         //   2. When the local file doesn't exist and should be written to.
 
         bool bExistsLocal = QDir().exists(name);
         if(url.isLocalFile() || url.isRelative() || !url.isValid() || bExistsLocal) // assuming that invalid means relative
         {
             QString localName = name;
 
 #if defined(Q_OS_WIN)
             if(localName.startsWith("/tmp/"))
             {
                 // git on Cygwin will put files in /tmp
                 // A workaround for the a native kdiff3 binary to find them...
 
                 QString cygwinBin = getenv("CYGWIN_BIN");
                 if(!cygwinBin.isEmpty())
                 {
                     localName = QString("%1\\..%2").arg(cygwinBin).arg(name);
                 }
             }
 #endif
 
             if(!bExistsLocal && url.isLocalFile() && name.left(5).toLower() == "file:")
             {
                 localName = url.path(); // I want the path without preceding "file:"
             }
 
             QFileInfo fi(localName);
             setFile(fi, nullptr);
         }
         else
         {
             createData();
             d()->m_url = url;
             d()->m_name = d()->m_url.fileName();
             d()->m_bLocal = false;
 
             FileAccessJobHandler jh(this);            // A friend, which writes to the parameters of this class!
             jh.stat(2 /*all details*/, bWantToWrite); // returns bSuccess, ignored
 
             m_filePath = name;
             d()->m_bValidData = true; // After running stat() the variables are initialised
                                       // and valid even if the file doesn't exist and the stat
                                       // query failed.
         }
     }
 }
 
 void FileAccess::addPath(const QString& txt)
 {
     if(d() != nullptr && d()->m_url.isValid())
     {
         QUrl url = d()->m_url.adjusted(QUrl::StripTrailingSlash);
         d()->m_url.setPath(url.path() + '/' + txt);
         setFile(d()->m_url.url()); // reinitialise
     }
     else
     {
         QString slash = (txt.isEmpty() || txt[0] == '/') ? "" : "/";
         setFile(absoluteFilePath() + slash + txt);
     }
 }
 
 /*     Filetype:
        S_IFMT     0170000   bitmask for the file type bitfields
        S_IFSOCK   0140000   socket
        S_IFLNK    0120000   symbolic link
        S_IFREG    0100000   regular file
        S_IFBLK    0060000   block device
        S_IFDIR    0040000   directory
        S_IFCHR    0020000   character device
        S_IFIFO    0010000   fifo
        S_ISUID    0004000   set UID bit
        S_ISGID    0002000   set GID bit (see below)
        S_ISVTX    0001000   sticky bit (see below)
 
        Access:
        S_IRWXU    00700     mask for file owner permissions
        S_IRUSR    00400     owner has read permission
        S_IWUSR    00200     owner has write permission
        S_IXUSR    00100     owner has execute permission
        S_IRWXG    00070     mask for group permissions
        S_IRGRP    00040     group has read permission
        S_IWGRP    00020     group has write permission
        S_IXGRP    00010     group has execute permission
        S_IRWXO    00007     mask for permissions for others (not in group)
        S_IROTH    00004     others have read permission
        S_IWOTH    00002     others have write permisson
        S_IXOTH    00001     others have execute permission
 */
 //TODO: Change this to kf5/kde auto test
-#ifdef KREPLACEMENTS_H
+#ifdef Q_OS_WIN
 void FileAccess::setUdsEntry(const KIO::UDSEntry&)
 {
 } // not needed if KDE is not available
 #else
 void FileAccess::setUdsEntry(const KIO::UDSEntry& e)
 {
     long acc = 0;
     long fileType = 0;
     QVector<uint> fields = e.fields();
     for(QVector<uint>::ConstIterator ei = fields.constBegin(); ei != fields.constEnd(); ++ei)
     {
         uint f = *ei;
         switch(f)
         {
         case KIO::UDSEntry::UDS_SIZE:
             m_size = e.numberValue(f);
             break;
         //case KIO::UDSEntry::UDS_USER :               d()->m_user   = e.stringValue(f);    break;
         //case KIO::UDSEntry::UDS_GROUP :              d()->m_group  = e.stringValue(f);    break;
         case KIO::UDSEntry::UDS_NAME:
             m_filePath = e.stringValue(f);
             break; // During listDir the relative path is given here.
         case KIO::UDSEntry::UDS_MODIFICATION_TIME:
             m_modificationTime.setTime_t(e.numberValue(f));
             break;
         //case KIO::UDSEntry::UDS_ACCESS_TIME :       d()->m_accessTime.setTime_t( e.numberValue(f) ); break;
         //case KIO::UDSEntry::UDS_CREATION_TIME :     d()->m_creationTime.setTime_t( e.numberValue(f) ); break;
         case KIO::UDSEntry::UDS_LINK_DEST:
             d()->m_linkTarget = e.stringValue(f);
             break;
         case KIO::UDSEntry::UDS_ACCESS:
         {
             acc = e.numberValue(f);
             d()->m_bReadable = (acc & S_IRUSR) != 0;
             m_bWritable = (acc & S_IWUSR) != 0;
             d()->m_bExecutable = (acc & S_IXUSR) != 0;
             break;
         }
         case KIO::UDSEntry::UDS_FILE_TYPE:
         {
             fileType = e.numberValue(f);
             m_bDir = (fileType & S_IFMT) == S_IFDIR;
             m_bFile = (fileType & S_IFMT) == S_IFREG;
             m_bSymLink = (fileType & S_IFMT) == S_IFLNK;
             m_bExists = fileType != 0;
             //d()->m_fileType = fileType;
             break;
         }
 
         case KIO::UDSEntry::UDS_URL: // m_url = QUrlFix( e.stringValue(f) );
             break;
         case KIO::UDSEntry::UDS_MIME_TYPE:
             break;
         case KIO::UDSEntry::UDS_GUESSED_MIME_TYPE:
             break;
         case KIO::UDSEntry::UDS_XML_PROPERTIES:
             break;
         default:
             break;
         }
     }
 
     m_bExists = acc != 0 || fileType != 0;
 
     d()->m_bLocal = false;
     d()->m_bValidData = true;
     m_bSymLink = !d()->m_linkTarget.isEmpty();
     if(d()->m_name.isEmpty())
     {
         int pos = m_filePath.lastIndexOf('/') + 1;
         d()->m_name = m_filePath.mid(pos);
     }
     m_bHidden = d()->m_name[0] == '.';
 }
 #endif
 
 bool FileAccess::isValid() const
 {
     return d() == nullptr ? !m_filePath.isEmpty() : d()->m_bValidData;
 }
 
 bool FileAccess::isFile() const
 {
     if(parent() || d())
         return m_bFile;
     else
         return QFileInfo(absoluteFilePath()).isFile();
 }
 
 bool FileAccess::isDir() const
 {
     if(parent() || d())
         return m_bDir;
     else
         return QFileInfo(absoluteFilePath()).isDir();
 }
 
 bool FileAccess::isSymLink() const
 {
     return m_bSymLink;
 }
 
 bool FileAccess::exists() const
 {
     if(parent() || d())
         return m_bExists;
     else
         return QFileInfo::exists(absoluteFilePath());
 }
 
 qint64 FileAccess::size() const
 {
     if(parent() || d())
         return m_size;
     else
         return QFileInfo(absoluteFilePath()).size();
 }
 
 QUrl FileAccess::url() const
 {
     if(d() != nullptr)
         return d()->m_url;
     else
     {
         QUrl url = QUrl::fromLocalFile(m_filePath);
         if(url.isRelative())
         {
             url.setPath(absoluteFilePath());
         }
         return url;
     }
 }
 
 bool FileAccess::isLocal() const
 {
     return d() == nullptr || d()->m_bLocal;
 }
 
 bool FileAccess::isReadable() const
 {
 #if defined(Q_OS_WIN)
     // On some windows machines in a network this takes very long to find out and it's not so important anyway.
     return true;
 #else
     if(d() != nullptr)
         return d()->m_bReadable;
     else
         return QFileInfo(absoluteFilePath()).isReadable();
 #endif
 }
 
 bool FileAccess::isWritable() const
 {
     if(parent() || d())
         return m_bWritable;
     else
         return QFileInfo(absoluteFilePath()).isWritable();
 }
 
 bool FileAccess::isExecutable() const
 {
 #if defined(Q_OS_WIN)
     // On some windows machines in a network this takes very long to find out and it's not so important anyway.
     return true;
 #else
     if(d() != nullptr)
         return d()->m_bExecutable;
     else
         return QFileInfo(absoluteFilePath()).isExecutable();
 #endif
 }
 
 bool FileAccess::isHidden() const
 {
     if(parent() || d())
         return m_bHidden;
     else
         return QFileInfo(absoluteFilePath()).isHidden();
 }
 
 QString FileAccess::readLink() const
 {
     if(d() != nullptr)
         return d()->m_linkTarget;
     else
         return QString();
 }
 
 QString FileAccess::absoluteFilePath() const
 {
     if(parent() != nullptr)
         return parent()->absoluteFilePath() + "/" + m_filePath;
     else
     {
         if(m_filePath.isEmpty())
             return QString();
 
         if(!isLocal())
             return m_filePath; // return complete url
 
         QFileInfo fi(m_filePath);
         if(fi.isAbsolute())
             return m_filePath;
         else
             return fi.absoluteFilePath(); // Probably never reached
     }
 } // Full abs path
 
 // Just the name-part of the path, without parent directories
 QString FileAccess::fileName() const
 {
     if(d() != nullptr)
         return d()->m_name;
     else if(parent())
         return m_filePath;
     else
         return QFileInfo(m_filePath).fileName();
 }
 
 void FileAccess::setSharedName(const QString& name)
 {
     if(name == m_filePath)
         m_filePath = name; // reduce memory because string is only used once.
 }
 
 QString FileAccess::filePath() const
 {
     if(parent() && parent()->parent())
         return parent()->filePath() + "/" + m_filePath;
     else
         return m_filePath; // The path-string that was used during construction
 }
 
 FileAccess* FileAccess::parent() const
 {
     if(m_bUseData)
         return d()->m_pParent;
     else
         return m_pParent;
 }
 
 FileAccess::Data* FileAccess::d()
 {
     if(m_bUseData)
         return m_pData;
     else
         return nullptr;
 }
 
 const FileAccess::Data* FileAccess::d() const
 {
     if(m_bUseData)
         return m_pData;
     else
         return nullptr;
 }
 
 QString FileAccess::prettyAbsPath() const
 {
     return isLocal() ? absoluteFilePath() : d()->m_url.toDisplayString();
 }
 
 /*
 QDateTime FileAccess::created() const
 {
    if ( d()!=0 )
    {
       if ( isLocal() && d()->m_creationTime.isNull() )
          const_cast<FileAccess*>(this)->d()->m_creationTime = QFileInfo( absoluteFilePath() ).created();
       return ( d()->m_creationTime.isValid() ?  d()->m_creationTime : lastModified() );
    }
    else
    {
       QDateTime created = QFileInfo( absoluteFilePath() ).created();
       return created.isValid() ? created : lastModified();
    }
 }
 */
 
 QDateTime FileAccess::lastModified() const
 {
     if(isLocal() && m_modificationTime.isNull())
         const_cast<FileAccess*>(this)->m_modificationTime = QFileInfo(absoluteFilePath()).lastModified();
     return m_modificationTime;
 }
 
 /*
 QDateTime FileAccess::lastRead() const
 {
    QDateTime accessTime = d()!=0 ? d()->m_accessTime : QFileInfo( absoluteFilePath() ).lastRead();
    return ( accessTime.isValid() ?  accessTime : lastModified() );
 }
 */
 
 static bool interruptableReadFile(QFile& f, void* pDestBuffer, unsigned long maxLength)
 {
     ProgressProxy pp;
     const unsigned long maxChunkSize = 100000;
     unsigned long i = 0;
     pp.setMaxNofSteps(maxLength / maxChunkSize + 1);
     while(i < maxLength)
     {
         unsigned long nextLength = min2(maxLength - i, maxChunkSize);
         unsigned long reallyRead = f.read((char*)pDestBuffer + i, nextLength);
         if(reallyRead != nextLength)
         {
             return false;
         }
         i += reallyRead;
 
         pp.setCurrent(double(i) / maxLength);
         if(pp.wasCancelled())
             return false;
     }
     return true;
 }
 
 bool FileAccess::readFile(void* pDestBuffer, unsigned long maxLength)
 {
     if(d() != nullptr && !d()->m_localCopy.isEmpty())
     {
         QFile f(d()->m_localCopy);
         if(f.open(QIODevice::ReadOnly))
             return interruptableReadFile(f, pDestBuffer, maxLength); // maxLength == f.read( (char*)pDestBuffer, maxLength );
     }
     else if(isLocal())
     {
         QFile f(absoluteFilePath());
 
         if(f.open(QIODevice::ReadOnly))
             return interruptableReadFile(f, pDestBuffer, maxLength); //maxLength == f.read( (char*)pDestBuffer, maxLength );
     }
     else
     {
         FileAccessJobHandler jh(this);
         return jh.get(pDestBuffer, maxLength);
     }
     return false;
 }
 
 bool FileAccess::writeFile(const void* pSrcBuffer, unsigned long length)
 {
     ProgressProxy pp;
     if(isLocal())
     {
         QFile f(absoluteFilePath());
         if(f.open(QIODevice::WriteOnly))
         {
             const unsigned long maxChunkSize = 100000;
             pp.setMaxNofSteps(length / maxChunkSize + 1);
             unsigned long i = 0;
             while(i < length)
             {
                 unsigned long nextLength = min2(length - i, maxChunkSize);
                 unsigned long reallyWritten = f.write((char*)pSrcBuffer + i, nextLength);
                 if(reallyWritten != nextLength)
                 {
                     return false;
                 }
                 i += reallyWritten;
 
                 pp.step();
                 if(pp.wasCancelled())
                     return false;
             }
             f.close();
 #ifndef Q_OS_WIN
             if(isExecutable()) // value is true if the old file was executable
             {
                 // Preserve attributes
                 f.setPermissions(f.permissions() | QFile::ExeUser);
                 //struct stat srcFileStatus;
                 //int statResult = ::stat( filePath().toLocal8Bit().constData(), &srcFileStatus );
                 //if (statResult==0)
                 //{
                 //   ::chmod ( filePath().toLocal8Bit().constData(), srcFileStatus.st_mode | S_IXUSR );
                 //}
             }
 #endif
 
             return true;
         }
     }
     else
     {
         FileAccessJobHandler jh(this);
         return jh.put(pSrcBuffer, length, true /*overwrite*/);
     }
     return false;
 }
 
 bool FileAccess::copyFile(const QString& dest)
 {
     FileAccessJobHandler jh(this);
     return jh.copyFile(dest); // Handles local and remote copying.
 }
 
 bool FileAccess::rename(const QString& dest)
 {
     FileAccessJobHandler jh(this);
     return jh.rename(dest);
 }
 
 bool FileAccess::removeFile()
 {
     if(isLocal())
     {
         return QDir().remove(absoluteFilePath());
     }
     else
     {
         FileAccessJobHandler jh(this);
         return jh.removeFile(url());
     }
 }
 
 bool FileAccess::removeFile(const QString& name) // static
 {
     return FileAccess(name).removeFile();
 }
 
 bool FileAccess::listDir(t_DirectoryList* pDirList, bool bRecursive, bool bFindHidden,
                          const QString& filePattern, const QString& fileAntiPattern, const QString& dirAntiPattern,
                          bool bFollowDirLinks, bool bUseCvsIgnore)
 {
     FileAccessJobHandler jh(this);
     return jh.listDir(pDirList, bRecursive, bFindHidden, filePattern, fileAntiPattern,
                       dirAntiPattern, bFollowDirLinks, bUseCvsIgnore);
 }
 
 QString FileAccess::tempFileName()
 {
     QTemporaryFile tmpFile;
     tmpFile.open();
     //tmpFile.setAutoDelete( true );  // We only want the name. Delete the precreated file immediately.
     QString name = tmpFile.fileName() + ".2";
     tmpFile.close();
     return name;
 }
 
 bool FileAccess::removeTempFile(const QString& name) // static
 {
     if(name.endsWith(".2"))
         FileAccess(name.left(name.length() - 2)).removeFile();
     return FileAccess(name).removeFile();
 }
 
 bool FileAccess::makeDir(const QString& dirName)
 {
     FileAccessJobHandler fh(nullptr);
     return fh.mkDir(dirName);
 }
 
 bool FileAccess::removeDir(const QString& dirName)
 {
     FileAccessJobHandler fh(nullptr);
     return fh.rmDir(dirName);
 }
 
 #if defined(Q_OS_WIN)
 bool FileAccess::symLink(const QString& /*linkTarget*/, const QString& /*linkLocation*/)
 {
     return false;
 }
 #else
 bool FileAccess::symLink(const QString& linkTarget, const QString& linkLocation)
 {
     return 0 == ::symlink(linkTarget.toLocal8Bit().constData(), linkLocation.toLocal8Bit().constData());
     //FileAccessJobHandler fh(0);
     //return fh.symLink( linkTarget, linkLocation );
 }
 #endif
 
 bool FileAccess::exists(const QString& name)
 {
     FileAccess fa(name);
     return fa.exists();
 }
 
 // If the size couldn't be determined by stat() then the file is copied to a local temp file.
 qint64 FileAccess::sizeForReading()
 {
     if(!isLocal() && m_size == 0)
     {
         // Size couldn't be determined. Copy the file to a local temp place.
         QString localCopy = tempFileName();
         bool bSuccess = copyFile(localCopy);
         if(bSuccess)
         {
             QFileInfo fi(localCopy);
             m_size = fi.size();
             d()->m_localCopy = localCopy;
             return m_size;
         }
         else
         {
             return 0;
         }
     }
     else
         return size();
 }
 
 QString FileAccess::getStatusText()
 {
     return d() == nullptr ? QString() : d()->m_statusText;
 }
 
 void FileAccess::setStatusText(const QString& s)
 {
     if(!s.isEmpty() || d() != nullptr)
     {
         createData();
         d()->m_statusText = s;
     }
 }
 
 QString FileAccess::cleanPath(const QString& path) // static
 {
     QUrl url = QUrl::fromUserInput(path, QString(""), QUrl::AssumeLocalFile);
     if(url.isLocalFile() || !url.isValid())
     {
         return QDir().cleanPath(path);
     }
     else
     {
         return path;
     }
 }
 
 bool FileAccess::createBackup(const QString& bakExtension)
 {
     if(exists())
     {
         createData();
         setFile(absoluteFilePath()); // make sure Data is initialized
         // First rename the existing file to the bak-file. If a bak-file file exists, delete that.
         QString bakName = absoluteFilePath() + bakExtension;
         FileAccess bakFile(bakName, true /*bWantToWrite*/);
         if(bakFile.exists())
         {
             bool bSuccess = bakFile.removeFile();
             if(!bSuccess)
             {
                 setStatusText(i18n("While trying to make a backup, deleting an older backup failed. \nFilename: ") + bakName);
                 return false;
             }
         }
         bool bSuccess = rename(bakName);
         if(!bSuccess)
         {
             setStatusText(i18n("While trying to make a backup, renaming failed. \nFilenames: ") +
                           absoluteFilePath() + " -> " + bakName);
             return false;
         }
     }
     return true;
 }
 
 FileAccessJobHandler::FileAccessJobHandler(FileAccess* pFileAccess)
 {
     m_pFileAccess = pFileAccess;
     m_bSuccess = false;
 }
 
 bool FileAccessJobHandler::stat(int detail, bool bWantToWrite)
 {
     m_bSuccess = false;
     m_pFileAccess->setStatusText(QString());
     KIO::StatJob* pStatJob = KIO::stat(m_pFileAccess->url(),
                                        bWantToWrite ? KIO::StatJob::DestinationSide : KIO::StatJob::SourceSide,
                                        detail, KIO::HideProgressInfo);
 
     connect(pStatJob, &KIO::StatJob::result, this, &FileAccessJobHandler::slotStatResult);
 
     ProgressProxy::enterEventLoop(pStatJob, i18n("Getting file status: %1", m_pFileAccess->prettyAbsPath()));
 
     return m_bSuccess;
 }
 
 void FileAccessJobHandler::slotStatResult(KJob* pJob)
 {
     if(pJob->error())
     {
         //pJob->uiDelegate()->showErrorMessage();
         m_pFileAccess->m_bExists = false;
         m_bSuccess = true;
     }
     else
     {
         m_bSuccess = true;
 
         m_pFileAccess->d()->m_bValidData = true;
         const KIO::UDSEntry e = static_cast<KIO::StatJob*>(pJob)->statResult();
 
         m_pFileAccess->setUdsEntry(e);
     }
 
     ProgressProxy::exitEventLoop();
 }
 
 bool FileAccessJobHandler::get(void* pDestBuffer, long maxLength)
 {
     ProgressProxyExtender pp; // Implicitly used in slotPercent()
     if(maxLength > 0 && !pp.wasCancelled())
     {
         KIO::TransferJob* pJob = KIO::get(m_pFileAccess->url(), KIO::NoReload);
         m_transferredBytes = 0;
         m_pTransferBuffer = (char*)pDestBuffer;
         m_maxLength = maxLength;
         m_bSuccess = false;
         m_pFileAccess->setStatusText(QString());
 
         connect(pJob, &KIO::TransferJob::result, this, &FileAccessJobHandler::slotSimpleJobResult);
         connect(pJob, &KIO::TransferJob::data, this, &FileAccessJobHandler::slotGetData);
         connect(pJob, SIGNAL(percent(KJob*, unsigned long)), &pp, SLOT(slotPercent(KJob*, unsigned long)));
 
         ProgressProxy::enterEventLoop(pJob, i18n("Reading file: %1", m_pFileAccess->prettyAbsPath()));
         return m_bSuccess;
     }
     else
         return true;
 }
 
 void FileAccessJobHandler::slotGetData(KJob* pJob, const QByteArray& newData)
 {
     if(pJob->error())
     {
         pJob->uiDelegate()->showErrorMessage();
     }
     else
     {
         qint64 length = min2(qint64(newData.size()), m_maxLength - m_transferredBytes);
         ::memcpy(m_pTransferBuffer + m_transferredBytes, newData.data(), newData.size());
         m_transferredBytes += length;
     }
 }
 
 bool FileAccessJobHandler::put(const void* pSrcBuffer, long maxLength, bool bOverwrite, bool bResume, int permissions)
 {
     ProgressProxyExtender pp; // Implicitly used in slotPercent()
     if(maxLength > 0)
     {
         KIO::TransferJob* pJob = KIO::put(m_pFileAccess->url(), permissions,
                                           KIO::HideProgressInfo | (bOverwrite ? KIO::Overwrite : KIO::DefaultFlags) | (bResume ? KIO::Resume : KIO::DefaultFlags));
         m_transferredBytes = 0;
         m_pTransferBuffer = (char*)pSrcBuffer;
         m_maxLength = maxLength;
         m_bSuccess = false;
         m_pFileAccess->setStatusText(QString());
 
         connect(pJob, &KIO::TransferJob::result, this, &FileAccessJobHandler::slotPutJobResult);
         connect(pJob, &KIO::TransferJob::dataReq, this, &FileAccessJobHandler::slotPutData);
         connect(pJob, SIGNAL(percent(KJob*, unsigned long)), &pp, SLOT(slotPercent(KJob*, unsigned long)));
 
         ProgressProxy::enterEventLoop(pJob, i18n("Writing file: %1", m_pFileAccess->prettyAbsPath()));
         return m_bSuccess;
     }
     else
         return true;
 }
 
 void FileAccessJobHandler::slotPutData(KIO::Job* pJob, QByteArray& data)
 {
     if(pJob->error())
     {
         pJob->uiDelegate()->showErrorMessage();
     }
     else
     {
         qint64 maxChunkSize = 100000;
         qint64 length = min2(maxChunkSize, m_maxLength - m_transferredBytes);
         data.resize(length);
         if(data.size() == length)
         {
             if(length > 0)
             {
                 ::memcpy(data.data(), m_pTransferBuffer + m_transferredBytes, data.size());
                 m_transferredBytes += length;
             }
         }
         else
         {
             KMessageBox::error(ProgressProxy::getDialog(), i18n("Out of memory"));
             data.resize(0);
             m_bSuccess = false;
         }
     }
 }
 
 void FileAccessJobHandler::slotPutJobResult(KJob* pJob)
 {
     if(pJob->error())
     {
         pJob->uiDelegate()->showErrorMessage();
     }
     else
     {
         m_bSuccess = (m_transferredBytes == m_maxLength); // Special success condition
     }
     ProgressProxy::exitEventLoop(); // Close the dialog, return from exec()
 }
 
 bool FileAccessJobHandler::mkDir(const QString& dirName)
 {
     QUrl dirURL = QUrl::fromUserInput(dirName, QString(""), QUrl::AssumeLocalFile);
     if(dirName.isEmpty())
         return false;
     else if(dirURL.isLocalFile() || dirURL.isRelative())
     {
         return QDir().mkdir(dirURL.path());
     }
     else
     {
         m_bSuccess = false;
         KIO::SimpleJob* pJob = KIO::mkdir(dirURL);
         connect(pJob, &KIO::SimpleJob::result, this, &FileAccessJobHandler::slotSimpleJobResult);
 
         ProgressProxy::enterEventLoop(pJob, i18n("Making directory: %1", dirName));
         return m_bSuccess;
     }
 }
 
 bool FileAccessJobHandler::rmDir(const QString& dirName)
 {
     QUrl dirURL = QUrl::fromUserInput(dirName, QString(""), QUrl::AssumeLocalFile);
     if(dirName.isEmpty())
         return false;
     else if(dirURL.isLocalFile())
     {
         return QDir().rmdir(dirURL.path());
     }
     else
     {
         m_bSuccess = false;
         KIO::SimpleJob* pJob = KIO::rmdir(dirURL);
         connect(pJob, &KIO::SimpleJob::result, this, &FileAccessJobHandler::slotSimpleJobResult);
 
         ProgressProxy::enterEventLoop(pJob, i18n("Removing directory: %1", dirName));
         return m_bSuccess;
     }
 }
 
 bool FileAccessJobHandler::removeFile(const QUrl& fileName)
 {
     if(fileName.isEmpty())
         return false;
     else
     {
         m_bSuccess = false;
         KIO::SimpleJob* pJob = KIO::file_delete(fileName, KIO::HideProgressInfo);
         connect(pJob, &KIO::SimpleJob::result, this, &FileAccessJobHandler::slotSimpleJobResult);
 
         ProgressProxy::enterEventLoop(pJob, i18n("Removing file: %1", fileName.toDisplayString()));
         return m_bSuccess;
     }
 }
 
 bool FileAccessJobHandler::symLink(const QUrl& linkTarget, const QUrl& linkLocation)
 {
     if(linkTarget.isEmpty() || linkLocation.isEmpty())
         return false;
     else
     {
         m_bSuccess = false;
         KIO::CopyJob* pJob = KIO::link(linkTarget, linkLocation, KIO::HideProgressInfo);
         connect(pJob, &KIO::CopyJob::result, this, &FileAccessJobHandler::slotSimpleJobResult);
 
         ProgressProxy::enterEventLoop(pJob,
                                       i18n("Creating symbolic link: %1 -> %2", linkLocation.toDisplayString(), linkTarget.toDisplayString()));
         return m_bSuccess;
     }
 }
 
 bool FileAccessJobHandler::rename(const QString& dest)
 {
     if(dest.isEmpty())
         return false;
 
     QUrl kurl = QUrl::fromUserInput(dest, QString(""), QUrl::AssumeLocalFile);
     if(kurl.isRelative())
         kurl = QUrl::fromUserInput(QDir().absoluteFilePath(dest), QString(""), QUrl::AssumeLocalFile); // assuming that invalid means relative
 
     if(m_pFileAccess->isLocal() && kurl.isLocalFile())
     {
         return QDir().rename(m_pFileAccess->absoluteFilePath(), kurl.path());
     }
     else
     {
         ProgressProxyExtender pp;
         int permissions = -1;
         m_bSuccess = false;
         KIO::FileCopyJob* pJob = KIO::file_move(m_pFileAccess->url(), kurl, permissions, KIO::HideProgressInfo);
         connect(pJob, &KIO::FileCopyJob::result, this, &FileAccessJobHandler::slotSimpleJobResult);
         connect(pJob, SIGNAL(percent(KJob*, unsigned long)), &pp, SLOT(slotPercent(KJob*, unsigned long)));
 
         ProgressProxy::enterEventLoop(pJob,
                                       i18n("Renaming file: %1 -> %2", m_pFileAccess->prettyAbsPath(), dest));
         return m_bSuccess;
     }
 }
 
 void FileAccessJobHandler::slotSimpleJobResult(KJob* pJob)
 {
     if(pJob->error())
     {
         pJob->uiDelegate()->showErrorMessage();
     }
     else
     {
         m_bSuccess = true;
     }
     ProgressProxy::exitEventLoop(); // Close the dialog, return from exec()
 }
 
 // Copy local or remote files.
 bool FileAccessJobHandler::copyFile(const QString& dest)
 {
     ProgressProxyExtender pp;
     QUrl destUrl = QUrl::fromUserInput(dest, QString(""), QUrl::AssumeLocalFile);
     m_pFileAccess->setStatusText(QString());
     if(!m_pFileAccess->isLocal() || !destUrl.isLocalFile()) // if either url is nonlocal
     {
         int permissions = (m_pFileAccess->isExecutable() ? 0111 : 0) + (m_pFileAccess->isWritable() ? 0222 : 0) + (m_pFileAccess->isReadable() ? 0444 : 0);
         m_bSuccess = false;
         KIO::FileCopyJob* pJob = KIO::file_copy(m_pFileAccess->url(), destUrl, permissions, KIO::HideProgressInfo);
         connect(pJob, &KIO::FileCopyJob::result, this, &FileAccessJobHandler::slotSimpleJobResult);
         connect(pJob, SIGNAL(percent(KJob*, unsigned long)), &pp, SLOT(slotPercent(KJob*, unsigned long)));
         ProgressProxy::enterEventLoop(pJob,
                                       i18n("Copying file: %1 -> %2", m_pFileAccess->prettyAbsPath(), dest));
 
         return m_bSuccess;
         // Note that the KIO-slave preserves the original date, if this is supported.
     }
 
     // Both files are local:
     QString srcName = m_pFileAccess->absoluteFilePath();
     QString destName = dest;
     QFile srcFile(srcName);
     QFile destFile(destName);
     bool bReadSuccess = srcFile.open(QIODevice::ReadOnly);
     if(bReadSuccess == false)
     {
         m_pFileAccess->setStatusText(i18n("Error during file copy operation: Opening file for reading failed. Filename: %1", srcName));
         return false;
     }
     bool bWriteSuccess = destFile.open(QIODevice::WriteOnly);
     if(bWriteSuccess == false)
     {
         m_pFileAccess->setStatusText(i18n("Error during file copy operation: Opening file for writing failed. Filename: %1", destName));
         return false;
     }
 
     std::vector<char> buffer(100000);
     qint64 bufSize = buffer.size();
     qint64 srcSize = srcFile.size();
     while(srcSize > 0 && !pp.wasCancelled())
     {
         qint64 readSize = srcFile.read(&buffer[0], min2(srcSize, bufSize));
         if(readSize == -1 || readSize == 0)
         {
             m_pFileAccess->setStatusText(i18n("Error during file copy operation: Reading failed. Filename: %1", srcName));
             return false;
         }
         srcSize -= readSize;
         while(readSize > 0)
         {
             qint64 writeSize = destFile.write(&buffer[0], readSize);
             if(writeSize == -1 || writeSize == 0)
             {
                 m_pFileAccess->setStatusText(i18n("Error during file copy operation: Writing failed. Filename: %1", destName));
                 return false;
             }
             readSize -= writeSize;
         }
         destFile.flush();
         pp.setCurrent((double)(srcFile.size() - srcSize) / srcFile.size(), false);
     }
     srcFile.close();
     destFile.close();
 
 // Update the times of the destFile
 #ifdef Q_OS_WIN
     struct _stat srcFileStatus;
     int statResult = ::_stat(srcName.toLocal8Bit().constData(), &srcFileStatus);
     if(statResult == 0)
     {
         _utimbuf destTimes;
         destTimes.actime = srcFileStatus.st_atime;  /* time of last access */
         destTimes.modtime = srcFileStatus.st_mtime; /* time of last modification */
 
         _utime(destName.toLocal8Bit().constData(), &destTimes);
         _chmod(destName.toLocal8Bit().constData(), srcFileStatus.st_mode);
     }
 #else
     struct stat srcFileStatus;
     int statResult = ::stat(srcName.toLocal8Bit().constData(), &srcFileStatus);
     if(statResult == 0)
     {
         utimbuf destTimes;
         destTimes.actime = srcFileStatus.st_atime;  /* time of last access */
         destTimes.modtime = srcFileStatus.st_mtime; /* time of last modification */
 
         utime(destName.toLocal8Bit().constData(), &destTimes);
         chmod(destName.toLocal8Bit().constData(), srcFileStatus.st_mode);
     }
 #endif
     return true;
 }
 
 bool wildcardMultiMatch(const QString& wildcard, const QString& testString, bool bCaseSensitive)
 {
     static QHash<QString, QRegExp> s_patternMap;
 
     QStringList sl = wildcard.split(";");
 
     for(QStringList::Iterator it = sl.begin(); it != sl.end(); ++it)
     {
         QHash<QString, QRegExp>::iterator patIt = s_patternMap.find(*it);
         if(patIt == s_patternMap.end())
         {
             QRegExp pattern(*it, bCaseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive, QRegExp::Wildcard);
             patIt = s_patternMap.insert(*it, pattern);
         }
 
         if(patIt.value().exactMatch(testString))
             return true;
     }
 
     return false;
 }
 
 // class CvsIgnoreList from Cervisia cvsdir.cpp
 //    Copyright (C) 1999-2002 Bernd Gehrmann <bernd at mail.berlios.de>
 // with elements from class StringMatcher
 //    Copyright (c) 2003 Andre Woebbeking <Woebbeking at web.de>
 // Modifications for KDiff3 by Joachim Eibl
 class CvsIgnoreList
 {
   public:
     CvsIgnoreList() {}
     void init(FileAccess& dir, bool bUseLocalCvsIgnore);
     bool matches(const QString& fileName, bool bCaseSensitive) const;
 
   private:
     void addEntriesFromString(const QString& str);
     void addEntriesFromFile(const QString& name);
     void addEntry(const QString& entry);
 
     QStringList m_exactPatterns;
     QStringList m_startPatterns;
     QStringList m_endPatterns;
     QStringList m_generalPatterns;
 };
 
 void CvsIgnoreList::init(FileAccess& dir, bool bUseLocalCvsIgnore)
 {
     static const char* ignorestr = ". .. core RCSLOG tags TAGS RCS SCCS .make.state "
                                    ".nse_depinfo #* .#* cvslog.* ,* CVS CVS.adm .del-* *.a *.olb *.o *.obj "
                                    "*.so *.Z *~ *.old *.elc *.ln *.bak *.BAK *.orig *.rej *.exe _$* *$";
 
     addEntriesFromString(QString::fromLatin1(ignorestr));
     addEntriesFromFile(QDir::homePath() + "/.cvsignore");
     addEntriesFromString(QString::fromLocal8Bit(::getenv("CVSIGNORE")));
 
     if(bUseLocalCvsIgnore)
     {
         FileAccess file(dir);
         file.addPath(".cvsignore");
         int size = file.exists() ? file.sizeForReading() : 0;
         if(size > 0)
         {
             char* buf = new char[size];
             if(buf != nullptr)
             {
                 file.readFile(buf, size);
                 int pos1 = 0;
                 for(int pos = 0; pos <= size; ++pos)
                 {
                     if(pos == size || buf[pos] == ' ' || buf[pos] == '\t' || buf[pos] == '\n' || buf[pos] == '\r')
                     {
                         if(pos > pos1)
                         {
                             addEntry(QString::fromLatin1(&buf[pos1], pos - pos1));
                         }
                         ++pos1;
                     }
                 }
                 delete[] buf;
             }
         }
     }
 }
 
 void CvsIgnoreList::addEntriesFromString(const QString& str)
 {
     int posLast(0);
     int pos;
     while((pos = str.indexOf(' ', posLast)) >= 0)
     {
         if(pos > posLast)
             addEntry(str.mid(posLast, pos - posLast));
         posLast = pos + 1;
     }
 
     if(posLast < static_cast<int>(str.length()))
         addEntry(str.mid(posLast));
 }
 
 void CvsIgnoreList::addEntriesFromFile(const QString& name)
 {
     QFile file(name);
 
     if(file.open(QIODevice::ReadOnly))
     {
         QTextStream stream(&file);
         while(!stream.atEnd())
         {
             addEntriesFromString(stream.readLine());
         }
     }
 }
 
 void CvsIgnoreList::addEntry(const QString& pattern)
 {
     if(pattern != QString("!"))
     {
         if(pattern.isEmpty()) return;
 
         // The general match is general but slow.
         // Special tests for '*' and '?' at the beginning or end of a pattern
         // allow fast checks.
 
         // Count number of '*' and '?'
         unsigned int nofMetaCharacters = 0;
 
         const QChar* pos;
         pos = pattern.unicode();
         const QChar* posEnd;
         posEnd = pos + pattern.length();
         while(pos < posEnd)
         {
             if(*pos == QChar('*') || *pos == QChar('?')) ++nofMetaCharacters;
             ++pos;
         }
 
         if(nofMetaCharacters == 0)
         {
             m_exactPatterns.append(pattern);
         }
         else if(nofMetaCharacters == 1)
         {
             if(pattern.at(0) == QChar('*'))
             {
                 m_endPatterns.append(pattern.right(pattern.length() - 1));
             }
             else if(pattern.at(pattern.length() - 1) == QChar('*'))
             {
                 m_startPatterns.append(pattern.left(pattern.length() - 1));
             }
             else
             {
                 m_generalPatterns.append(pattern.toLocal8Bit());
             }
         }
         else
         {
             m_generalPatterns.append(pattern.toLocal8Bit());
         }
     }
     else
     {
         m_exactPatterns.clear();
         m_startPatterns.clear();
         m_endPatterns.clear();
         m_generalPatterns.clear();
     }
 }
 
 bool CvsIgnoreList::matches(const QString& text, bool bCaseSensitive) const
 {
     if(m_exactPatterns.indexOf(text) >= 0)
     {
         return true;
     }
 
     QStringList::ConstIterator it;
     QStringList::ConstIterator itEnd;
     for(it = m_startPatterns.begin(), itEnd = m_startPatterns.end(); it != itEnd; ++it)
     {
         if(text.startsWith(*it))
         {
             return true;
         }
     }
 
     for(it = m_endPatterns.begin(), itEnd = m_endPatterns.end(); it != itEnd; ++it)
     {
         if(text.mid(text.length() - (*it).length()) == *it) //(text.endsWith(*it))
         {
             return true;
         }
     }
 
     /*
     for (QValueList<QCString>::const_iterator it(m_generalPatterns.begin()),
                                               itEnd(m_generalPatterns.end());
          it != itEnd; ++it)
     {
         if (::fnmatch(*it, text.local8Bit(), FNM_PATHNAME) == 0)
         {
             return true;
         }
     }
     */
 
     for(it = m_generalPatterns.begin(); it != m_generalPatterns.end(); ++it)
     {
         QRegExp pattern(*it, bCaseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive, QRegExp::Wildcard);
         if(pattern.exactMatch(text))
             return true;
     }
 
     return false;
 }
 
 static bool cvsIgnoreExists(t_DirectoryList* pDirList)
 {
     t_DirectoryList::iterator i;
     for(i = pDirList->begin(); i != pDirList->end(); ++i)
     {
         if(i->fileName() == ".cvsignore")
             return true;
     }
     return false;
 }
 
 bool FileAccessJobHandler::listDir(t_DirectoryList* pDirList, bool bRecursive, bool bFindHidden, const QString& filePattern,
                                    const QString& fileAntiPattern, const QString& dirAntiPattern, bool bFollowDirLinks, bool bUseCvsIgnore)
 {
     ProgressProxyExtender pp;
     m_pDirList = pDirList;
     m_pDirList->clear();
     m_bFindHidden = bFindHidden;
     m_bRecursive = bRecursive;
     m_bFollowDirLinks = bFollowDirLinks; // Only relevant if bRecursive==true.
     m_fileAntiPattern = fileAntiPattern;
     m_filePattern = filePattern;
     m_dirAntiPattern = dirAntiPattern;
 
     if(pp.wasCancelled())
         return true; // Cancelled is not an error.
 
     pp.setInformation(i18n("Reading directory: ") + m_pFileAccess->absoluteFilePath(), 0, false);
 
     if(m_pFileAccess->isLocal())
     {
         QString currentPath = QDir::currentPath();
         m_bSuccess = QDir::setCurrent(m_pFileAccess->absoluteFilePath());
         if(m_bSuccess)
         {
 #ifndef Q_OS_WIN
             m_bSuccess = true;
             QDir dir(".");
 
             dir.setSorting(QDir::Name | QDir::DirsFirst);
             dir.setFilter(QDir::Files | QDir::Dirs | /* from KDE3 QDir::TypeMaskDirs | */ QDir::Hidden | QDir::System);
 
             QFileInfoList fiList = dir.entryInfoList();
             if(fiList.isEmpty())
             {
                 // No Permission to read directory or other error.
                 m_bSuccess = false;
             }
             else
             {
                 foreach(const QFileInfo& fi, fiList) // for each file...
                 {
                     if(fi.fileName() == "." || fi.fileName() == "..")
                         continue;
 
                     FileAccess fa;
                     fa.setFile(fi, m_pFileAccess);
                     pDirList->push_back(fa);
                 }
             }
 #else
             QString pattern = "*.*";
             WIN32_FIND_DATA findData;
 
             Qt::HANDLE searchHandle = FindFirstFileW((const wchar_t*)pattern.utf16(), &findData);
 
             if(searchHandle != INVALID_HANDLE_VALUE)
             {
                 QString absPath = m_pFileAccess->absoluteFilePath();
                 QString relPath = m_pFileAccess->filePath();
                 bool bFirst = true;
                 while(!pp.wasCancelled())
                 {
                     if(!bFirst)
                     {
                         if(!FindNextFileW(searchHandle, &findData))
                             break;
                     }
                     bFirst = false;
                     FileAccess fa;
 
                     fa.m_filePath = QString::fromUtf16((const ushort*)findData.cFileName);
                     if(fa.m_filePath != "." && fa.m_filePath != "..")
                     {
                         fa.m_size = (qint64(findData.nFileSizeHigh) << 32) + findData.nFileSizeLow;
 
                         FILETIME ft;
                         SYSTEMTIME t;
                         FileTimeToLocalFileTime(&findData.ftLastWriteTime, &ft);
                         FileTimeToSystemTime(&ft, &t);
                         fa.m_modificationTime = QDateTime(QDate(t.wYear, t.wMonth, t.wDay), QTime(t.wHour, t.wMinute, t.wSecond));
                         //FileTimeToLocalFileTime( &findData.ftLastAccessTime, &ft ); FileTimeToSystemTime(&ft,&t);
                         //fa.m_accessTime       = QDateTime( QDate(t.wYear, t.wMonth, t.wDay), QTime(t.wHour, t.wMinute, t.wSecond) );
                         //FileTimeToLocalFileTime( &findData.ftCreationTime, &ft ); FileTimeToSystemTime(&ft,&t);
                         //fa.m_creationTime     = QDateTime( QDate(t.wYear, t.wMonth, t.wDay), QTime(t.wHour, t.wMinute, t.wSecond) );
 
                         int a = findData.dwFileAttributes;
                         fa.m_bWritable = (a & FILE_ATTRIBUTE_READONLY) == 0;
                         fa.m_bDir = (a & FILE_ATTRIBUTE_DIRECTORY) != 0;
                         fa.m_bFile = !fa.m_bDir;
                         fa.m_bHidden = (a & FILE_ATTRIBUTE_HIDDEN) != 0;
 
                         //fa.m_bExecutable = false; // Useless on windows
                         fa.m_bExists = true;
                         //fa.m_bReadable   = true;
                         //fa.m_bLocal      = true;
                         //fa.m_bValidData  = true;
                         fa.m_bSymLink = false;
                         //fa.m_fileType    = 0;
 
                         //fa.m_filePath = fa.m_name;
                         //fa.m_absoluteFilePath = absPath + "/" + fa.m_name;
                         //fa.m_url.setPath( fa.m_absoluteFilePath );
                         if(fa.d())
                             fa.m_pData->m_pParent = m_pFileAccess;
                         else
                             fa.m_pParent = m_pFileAccess;
                         pDirList->push_back(fa);
                     }
                 }
                 FindClose(searchHandle);
             }
             else
             {
                 QDir::setCurrent(currentPath); // restore current path
                 return false;
             }
 #endif
         }
         QDir::setCurrent(currentPath); // restore current path
     }
     else
     {
         KIO::ListJob* pListJob = nullptr;
         pListJob = KIO::listDir(m_pFileAccess->url(), KIO::HideProgressInfo, true /*bFindHidden*/);
 
         m_bSuccess = false;
         if(pListJob != nullptr)
         {
             connect(pListJob, &KIO::ListJob::entries, this, &FileAccessJobHandler::slotListDirProcessNewEntries);
             connect(pListJob, &KIO::ListJob::result, this, &FileAccessJobHandler::slotSimpleJobResult);
 
             connect(pListJob, &KIO::ListJob::infoMessage, &pp, &ProgressProxyExtender::slotListDirInfoMessage);
 
             // This line makes the transfer via fish unreliable.:-(
             //connect( pListJob, SIGNAL(percent(KJob*,unsigned long)), &pp, SLOT(slotPercent(KJob*, unsigned long)));
 
             ProgressProxy::enterEventLoop(pListJob,
                                           i18n("Listing directory: %1", m_pFileAccess->prettyAbsPath()));
         }
     }
 
     CvsIgnoreList cvsIgnoreList;
     if(bUseCvsIgnore)
     {
         cvsIgnoreList.init(*m_pFileAccess, cvsIgnoreExists(pDirList));
     }
 #if defined(Q_OS_WIN)
     bool bCaseSensitive = false;
 #else
     bool bCaseSensitive = true;
 #endif
 
     // Now remove all entries that should be ignored:
     t_DirectoryList::iterator i;
     for(i = pDirList->begin(); i != pDirList->end();)
     {
         t_DirectoryList::iterator i2 = i;
         ++i2;
         QString fn = i->fileName();
         if((!bFindHidden && i->isHidden()) ||
            (i->isFile() &&
             (!wildcardMultiMatch(filePattern, fn, bCaseSensitive) ||
              wildcardMultiMatch(fileAntiPattern, fn, bCaseSensitive))) ||
            (i->isDir() && wildcardMultiMatch(dirAntiPattern, fn, bCaseSensitive)) ||
            cvsIgnoreList.matches(fn, bCaseSensitive))
         {
             // Remove it
             pDirList->erase(i);
             i = i2;
         }
         else
         {
             ++i;
         }
     }
 
     if(bRecursive)
     {
         t_DirectoryList subDirsList;
 
         t_DirectoryList::iterator i;
         for(i = m_pDirList->begin(); i != m_pDirList->end(); ++i)
         {
             if(i->isDir() && (!i->isSymLink() || m_bFollowDirLinks))
             {
                 t_DirectoryList dirList;
                 i->listDir(&dirList, bRecursive, bFindHidden,
                            filePattern, fileAntiPattern, dirAntiPattern, bFollowDirLinks, bUseCvsIgnore);
 
                 t_DirectoryList::iterator j;
                 for(j = dirList.begin(); j != dirList.end(); ++j)
                 {
                     if(j->parent() == nullptr)
                         j->m_filePath = i->fileName() + "/" + j->m_filePath;
                 }
 
                 // append data onto the main list
                 subDirsList.splice(subDirsList.end(), dirList);
             }
         }
 
         m_pDirList->splice(m_pDirList->end(), subDirsList);
     }
 
     return m_bSuccess;
 }
 
 void FileAccessJobHandler::slotListDirProcessNewEntries(KIO::Job*, const KIO::UDSEntryList& l)
 {
     //This function is called for non-local urls. Don't use QUrl::fromLocalFile here as it does not handle these.
     QUrl parentUrl = QUrl::fromUserInput(m_pFileAccess->absoluteFilePath(), QString(""), QUrl::AssumeLocalFile);
 
     KIO::UDSEntryList::ConstIterator i;
     for(i = l.begin(); i != l.end(); ++i)
     {
         const KIO::UDSEntry& e = *i;
         FileAccess fa;
         fa.createData();
         fa.m_pData->m_pParent = m_pFileAccess;
         fa.setUdsEntry(e);
 
         if(fa.fileName() != "." && fa.fileName() != "..")
         {
             fa.d()->m_url = parentUrl;
             QUrl url = fa.d()->m_url.adjusted(QUrl::StripTrailingSlash);
             fa.d()->m_url.setPath(url.path() + "/" + fa.fileName());
             //fa.d()->m_absoluteFilePath = fa.url().url();
             m_pDirList->push_back(fa);
         }
     }
 }
 
 void ProgressProxyExtender::slotListDirInfoMessage(KJob*, const QString& msg)
 {
     setInformation(msg, 0);
 }
 
 void ProgressProxyExtender::slotPercent(KJob*, unsigned long percent)
 {
     setCurrent(percent);
 }
 
 //#include "fileaccess.moc"
diff --git a/src/pdiff.cpp b/src/pdiff.cpp
index 9a074cc..88d98f2 100644
--- a/src/pdiff.cpp
+++ b/src/pdiff.cpp
@@ -1,2512 +1,2513 @@
 /***************************************************************************
                          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>
-#else //TODO:Why?
-#include <kshortcutsdialog.h>
+#else //TODO:Why
 #include <unistd.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, int size, int idx)
 {
     Diff3LineList::iterator it = d3ll.begin();
     int i = 0;
 
     for(it = d3ll.begin(); it != d3ll.end(); ++it)
     {
         int 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 inputfiles don't seem to be pure textfiles.\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"
                                                 "Don't save the result if unsure. Continue at your own risk.\n"
                                                 "Affected input files are in %1.")
                                                .arg(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()
 {
     int l = 0, 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()
 {
     int firstLine = -1;
     int 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()
 {
     int firstLine = -1;
     int 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 hasn't 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();
 
     int d3vLine = m_pFindDialog->currentLine;
     int posInLine = m_pFindDialog->currentPos;
     int 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 + " \"" + m_sd1.getAliasName() + "\" \"" + m_sd2.getAliasName() + "\" \"" + m_sd3.getAliasName();
             QProcess process;
             process.start(cmd);
             process.waitForFinished(-1);
             //::system( cmd.local8Bit() );
         }
     }
 }
 
 static void insertManualDiffHelp(ManualDiffHelpList* pManualDiffHelpList, int winIdx, int firstLine, int 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()
 {
     int firstLine = -1;
     int 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->isVisible() && m_pMainWidget != nullptr && m_pMainWidget->isVisible()) ||
          (m_pDirectoryMergeSplitter->isVisible() && m_pMainWidget != nullptr && !m_pMainWidget->isVisible() && bTextDataAvailable)));
 
     bool bDirWindowHasFocus = 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);
 }