diff --git a/src/directorymergewindow.cpp b/src/directorymergewindow.cpp
index 345e9cf..cda76fc 100644
--- a/src/directorymergewindow.cpp
+++ b/src/directorymergewindow.cpp
@@ -1,3105 +1,3105 @@
 /***************************************************************************
  *   Copyright (C) 2003-2007 by Joachim Eibl <joachim.eibl at gmx.de>      *
  *   Copyright (C) 2018 Michael Reeves reeves.87@gmail.com                 *
  *                                                                         *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 #include "directorymergewindow.h"
 
 #include "DirectoryInfo.h"
 #include "MergeFileInfos.h"
 #include "PixMapUtils.h"
 #include "Utils.h"
 #include "guiutils.h"
 #include "kdiff3.h"
 #include "options.h"
 #include "progress.h"
 
 #include <algorithm>
 #include <map>
 #include <vector>
 
 #include <QAction>
 #include <QApplication>
 #include <QDialogButtonBox>
 #include <QDir>
 #include <QFileDialog>
 #include <QImage>
 #include <QKeyEvent>
 #include <QLabel>
 #include <QLayout>
 #include <QMenu>
 #include <QPushButton>
 #include <QRegExp>
 #include <QSplitter>
 #include <QStyledItemDelegate>
 #include <QTextStream>
 #include <QPainter>
 
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KTextEdit>
 #include <KToggleAction>
 
 class StatusInfo : public QDialog
 {
     KTextEdit* m_pTextEdit;
 
   public:
     explicit StatusInfo(QWidget* pParent)
         : QDialog(pParent)
     {
         QVBoxLayout* pVLayout = new QVBoxLayout(this);
         m_pTextEdit = new KTextEdit(this);
         pVLayout->addWidget(m_pTextEdit);
         setObjectName("StatusInfo");
         setWindowFlags(Qt::Dialog);
         m_pTextEdit->setWordWrapMode(QTextOption::NoWrap);
         m_pTextEdit->setReadOnly(true);
         QDialogButtonBox* box = new QDialogButtonBox(QDialogButtonBox::Close, this);
         connect(box, &QDialogButtonBox::rejected, this, &QDialog::accept);
         pVLayout->addWidget(box);
     }
 
     bool isEmpty()
     {
         return m_pTextEdit->toPlainText().isEmpty();
     }
 
     void addText(const QString& s)
     {
         m_pTextEdit->append(s);
     }
 
     void clear()
     {
         m_pTextEdit->clear();
     }
 
     void setVisible(bool bVisible) override
     {
         if(bVisible)
         {
             m_pTextEdit->moveCursor(QTextCursor::End);
             m_pTextEdit->moveCursor(QTextCursor::StartOfLine);
             m_pTextEdit->ensureCursorVisible();
         }
 
         QDialog::setVisible(bVisible);
         if(bVisible)
             setWindowState(windowState() | Qt::WindowMaximized);
     }
 };
 
 enum Columns
 {
     s_NameCol = 0,
     s_ACol = 1,
     s_BCol = 2,
     s_CCol = 3,
     s_OpCol = 4,
     s_OpStatusCol = 5,
     s_UnsolvedCol = 6, // Nr of unsolved conflicts (for 3 input files)
     s_SolvedCol = 7,   // Nr of auto-solvable conflicts (for 3 input files)
     s_NonWhiteCol = 8, // Nr of nonwhite deltas (for 2 input files)
     s_WhiteCol = 9     // Nr of white deltas (for 2 input files)
 };
 
 static Qt::CaseSensitivity s_eCaseSensitivity = Qt::CaseSensitive;
 
 //TODO: clean up this mess.
 class DirectoryMergeWindow::DirectoryMergeWindowPrivate : public QAbstractItemModel
 {
     friend class DirMergeItem;
 
   public:
     DirectoryMergeWindow* mWindow;
     explicit DirectoryMergeWindowPrivate(DirectoryMergeWindow* pDMW)
     {
         mWindow = pDMW;
         m_pStatusInfo = new StatusInfo(mWindow);
         m_pStatusInfo->hide();
     }
     ~DirectoryMergeWindowPrivate() override
     {
         delete m_pRoot;
     }
     // Implement QAbstractItemModel
     QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
     //Qt::ItemFlags flags ( const QModelIndex & index ) const
     QModelIndex parent(const QModelIndex& index) const override
     {
         MergeFileInfos* pMFI = getMFI(index);
         if(pMFI == nullptr || pMFI == m_pRoot || pMFI->parent() == m_pRoot)
             return QModelIndex();
         else
         {
             MergeFileInfos* pParentsParent = pMFI->parent()->parent();
             return createIndex(pParentsParent->children().indexOf(pMFI->parent()), 0, pMFI->parent());
         }
     }
     int rowCount(const QModelIndex& parent = QModelIndex()) const override
     {
         MergeFileInfos* pParentMFI = getMFI(parent);
         if(pParentMFI != nullptr)
             return pParentMFI->children().count();
         else
             return m_pRoot->children().count();
     }
     int columnCount(const QModelIndex& /*parent*/) const override
     {
         return 10;
     }
     QModelIndex index(int row, int column, const QModelIndex& parent) const override
     {
         MergeFileInfos* pParentMFI = getMFI(parent);
         if(pParentMFI == nullptr && row < m_pRoot->children().count())
             return createIndex(row, column, m_pRoot->children()[row]);
         else if(pParentMFI != nullptr && row < pParentMFI->children().count())
             return createIndex(row, column, pParentMFI->children()[row]);
         else
             return QModelIndex();
     }
     QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
     void sort(int column, Qt::SortOrder order) override;
     // private data and helper methods
     MergeFileInfos* getMFI(const QModelIndex& mi) const
     {
         if(mi.isValid())
             return (MergeFileInfos*)mi.internalPointer();
         else
             return nullptr;
     }
 
     bool isThreeWay() const
     {
         if(rootMFI() == nullptr || rootMFI()->getDirectoryInfo() == nullptr) return false;
         return rootMFI()->getDirectoryInfo()->dirC().isValid();
     }
     MergeFileInfos* rootMFI() const { return m_pRoot; }
 
     QSharedPointer<Options> m_pOptions = nullptr;
 
     void calcDirStatus(bool bThreeDirs, const QModelIndex& mi,
                        int& nofFiles, int& nofDirs, int& nofEqualFiles, int& nofManualMerges);
 
     void mergeContinue(bool bStart, bool bVerbose);
 
     void prepareListView(ProgressProxy& pp);
     void calcSuggestedOperation(const QModelIndex& mi, e_MergeOperation eDefaultMergeOp);
     void setAllMergeOperations(e_MergeOperation eDefaultOperation);
 
     bool canContinue();
     QModelIndex treeIterator(QModelIndex mi, bool bVisitChildren = true, bool bFindInvisible = false);
     void prepareMergeStart(const QModelIndex& miBegin, const QModelIndex& miEnd, bool bVerbose);
     bool executeMergeOperation(MergeFileInfos& mfi, bool& bSingleFileMerge);
 
     void scanDirectory(const QString& dirName, t_DirectoryList& dirList);
     void scanLocalDirectory(const QString& dirName, t_DirectoryList& dirList);
 
     void setMergeOperation(const QModelIndex& mi, e_MergeOperation eMergeOp, bool bRecursive = true);
     bool isDir(const QModelIndex& mi);
     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);
 
 
     void buildMergeMap(const QSharedPointer<DirectoryInfo>& dirInfo);
 
   private:
     class FileKey
     {
       private:
         const FileAccess* m_pFA;
       public:
         explicit FileKey(const FileAccess& fa)
             : m_pFA(&fa) {}
 
         quint32 getParents(const FileAccess* pFA, const FileAccess* v[], quint32 maxSize) const
         {
             quint32 s = 0;
             for(s = 0; pFA->parent() != nullptr; pFA = pFA->parent(), ++s)
             {
                 if(s == maxSize)
                     break;
                 v[s] = pFA;
             }
             return s;
         }
 
         // This is essentially the same as
         // int r = filePath().compare( fa.filePath() )
         // if ( r<0 ) return true;
         // if ( r==0 ) return m_col < fa.m_col;
         // return false;
         bool operator<(const FileKey& fk) const
         {
             const FileAccess* v1[100];
             const FileAccess* v2[100];
             quint32 v1Size = getParents(m_pFA, v1, 100);
             quint32 v2Size = getParents(fk.m_pFA, v2, 100);
 
             for(quint32 i = 0; i < v1Size && i < v2Size; ++i)
             {
                 int r = v1[v1Size - i - 1]->fileName().compare(v2[v2Size - i - 1]->fileName(), s_eCaseSensitivity);
                 if(r < 0)
                     return true;
                 else if(r > 0)
                     return false;
             }
 
             return v1Size < v2Size;
         }
     };
 
     typedef QMap<FileKey, MergeFileInfos> t_fileMergeMap;
 
     MergeFileInfos* m_pRoot = new MergeFileInfos();
 
     t_fileMergeMap m_fileMergeMap;
   public:
 
     bool m_bFollowDirLinks = false;
     bool m_bFollowFileLinks = false;
     bool m_bSimulatedMergeStarted = false;
     bool m_bRealMergeStarted = false;
     bool m_bError = false;
     bool m_bSyncMode = false;
     bool m_bDirectoryMerge = false; // if true, then merge is the default operation, otherwise it's diff.
     bool m_bCaseSensitive = true;
     bool m_bUnfoldSubdirs = false;
     bool m_bSkipDirStatus = false;
     bool m_bScanning = false; // true while in init()
 
     DirectoryMergeInfo* m_pDirectoryMergeInfo = nullptr;
     StatusInfo* m_pStatusInfo = nullptr;
 
     typedef std::list<QModelIndex> MergeItemList; // linked list
     MergeItemList m_mergeItemList;
     MergeItemList::iterator m_currentIndexForOperation;
 
     QModelIndex m_selection1Index;
     QModelIndex m_selection2Index;
     QModelIndex m_selection3Index;
     void selectItemAndColumn(const QModelIndex& mi, bool bContextMenu);
 
     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(const QSharedPointer<DirectoryInfo> &dirInfo, bool bDirectoryMerge, bool bReload);
     void setOpStatus(const QModelIndex& mi, e_OperationStatus eOpStatus)
     {
         if(MergeFileInfos* pMFI = getMFI(mi))
         {
             pMFI->setOpStatus(eOpStatus);
             emit dataChanged(mi, mi);
         }
     }
 
     QModelIndex nextSibling(const QModelIndex& mi);
 };
 
 QVariant DirectoryMergeWindow::DirectoryMergeWindowPrivate::data(const QModelIndex& index, int role) const
 {
     MergeFileInfos* pMFI = getMFI(index);
     if(pMFI)
     {
         if(role == Qt::DisplayRole)
         {
             switch(index.column())
             {
                 case s_NameCol:
                     return QFileInfo(pMFI->subPath()).fileName();
                 case s_ACol:
                     return i18n("A");
                 case s_BCol:
                     return i18n("B");
                 case s_CCol:
                     return i18n("C");
                 //case s_OpCol:       return i18n("Operation");
                 //case s_OpStatusCol: return i18n("Status");
                 case s_UnsolvedCol:
                     return pMFI->diffStatus().getUnsolvedConflicts();
                 case s_SolvedCol:
                     return pMFI->diffStatus().getSolvedConflicts();
                 case s_NonWhiteCol:
                     return pMFI->diffStatus().getNonWhitespaceConflicts();
                 case s_WhiteCol:
                     return pMFI->diffStatus().getWhitespaceConflicts();
                     //default :           return QVariant();
             }
 
             if(s_OpCol == index.column())
             {
                 bool bDir = pMFI->hasDir();
                 switch(pMFI->getOperation())
                 {
                     case eNoOperation:
                         return "";
                         break;
                     case eCopyAToB:
                         return i18n("Copy A to B");
                         break;
                     case eCopyBToA:
                         return i18n("Copy B to A");
                         break;
                     case eDeleteA:
                         return i18n("Delete A");
                         break;
                     case eDeleteB:
                         return i18n("Delete B");
                         break;
                     case eDeleteAB:
                         return i18n("Delete A & B");
                         break;
                     case eMergeToA:
                         return i18n("Merge to A");
                         break;
                     case eMergeToB:
                         return i18n("Merge to B");
                         break;
                     case eMergeToAB:
                         return i18n("Merge to A & B");
                         break;
                     case eCopyAToDest:
                         return i18n("A");
                         break;
                     case eCopyBToDest:
                         return i18n("B");
                         break;
                     case eCopyCToDest:
                         return i18n("C");
                         break;
                     case eDeleteFromDest:
                         return i18n("Delete (if exists)");
                         break;
                     case eMergeABCToDest:
                     case eMergeABToDest:
                         return bDir ? i18n("Merge") : i18n("Merge (manual)");
                         break;
                     case eConflictingFileTypes:
                         return i18n("Error: Conflicting File Types");
                         break;
                     case eChangedAndDeleted:
                         return i18n("Error: Changed and Deleted");
                         break;
                     case eConflictingAges:
                         return i18n("Error: Dates are equal but files are not.");
                         break;
                     default:
                         Q_ASSERT(true);
                         break;
                 }
             }
             if(s_OpStatusCol == index.column())
             {
                 switch(pMFI->getOpStatus())
                 {
                     case eOpStatusNone:
                         return "";
                     case eOpStatusDone:
                         return i18n("Done");
                     case eOpStatusError:
                         return i18n("Error");
                     case eOpStatusSkipped:
                         return i18n("Skipped.");
                     case eOpStatusNotSaved:
                         return i18n("Not saved.");
                     case eOpStatusInProgress:
                         return i18n("In progress...");
                     case eOpStatusToDo:
                         return i18n("To do.");
                 }
             }
         }
         else if(role == Qt::DecorationRole)
         {
             if(s_NameCol == index.column())
             {
                 return PixMapUtils::getOnePixmap(eAgeEnd, pMFI->hasLink(), pMFI->hasDir());
             }
 
             if(s_ACol == index.column())
             {
                 return PixMapUtils::getOnePixmap(pMFI->getAgeA(), pMFI->isLinkA(), pMFI->isDirA());
             }
             if(s_BCol == index.column())
             {
                 return PixMapUtils::getOnePixmap(pMFI->getAgeB(), pMFI->isLinkB(), pMFI->isDirB());
             }
             if(s_CCol == index.column())
             {
                 return PixMapUtils::getOnePixmap(pMFI->getAgeC(), pMFI->isLinkC(), pMFI->isDirC());
             }
         }
         else if(role == Qt::TextAlignmentRole)
         {
             if(s_UnsolvedCol == index.column() || s_SolvedCol == index.column() || s_NonWhiteCol == index.column() || s_WhiteCol == index.column())
                 return Qt::AlignRight;
         }
     }
     return QVariant();
 }
 
 QVariant DirectoryMergeWindow::DirectoryMergeWindowPrivate::headerData(int section, Qt::Orientation orientation, int role) const
 {
     if(orientation == Qt::Horizontal && section >= 0 && section < columnCount(QModelIndex()) && role == Qt::DisplayRole)
     {
         switch(section)
         {
             case s_NameCol:
                 return i18n("Name");
             case s_ACol:
                 return i18n("A");
             case s_BCol:
                 return i18n("B");
             case s_CCol:
                 return i18n("C");
             case s_OpCol:
                 return i18n("Operation");
             case s_OpStatusCol:
                 return i18n("Status");
             case s_UnsolvedCol:
                 return i18n("Unsolved");
             case s_SolvedCol:
                 return i18n("Solved");
             case s_NonWhiteCol:
                 return i18n("Nonwhite");
             case s_WhiteCol:
                 return i18n("White");
             default:
                 return QVariant();
         }
     }
     return QVariant();
 }
 
 // Previously  Q3ListViewItem::paintCell(p,cg,column,width,align);
 class DirectoryMergeWindow::DirMergeItemDelegate : public QStyledItemDelegate
 {
     DirectoryMergeWindow* m_pDMW;
     DirectoryMergeWindow::DirectoryMergeWindowPrivate* d;
 
   public:
     explicit DirMergeItemDelegate(DirectoryMergeWindow* pParent)
         : QStyledItemDelegate(pParent), m_pDMW(pParent), d(pParent->d)
     {
     }
     void paint(QPainter* thePainter, const QStyleOptionViewItem& option, const QModelIndex& index) const override
     {
         QtNumberType column = index.column();
         if(column == s_ACol || column == s_BCol || column == s_CCol)
         {
             QVariant value = index.data(Qt::DecorationRole);
             QPixmap icon;
             if(value.isValid())
             {
                 if(value.type() == QVariant::Icon)
                 {
                     icon = qvariant_cast<QIcon>(value).pixmap(16, 16);
                     //icon = qvariant_cast<QIcon>(value);
                     //decorationRect = QRect(QPoint(0, 0), icon.actualSize(option.decorationSize, iconMode, iconState));
                 }
                 else
                 {
                     icon = qvariant_cast<QPixmap>(value);
                     //decorationRect = QRect(QPoint(0, 0), option.decorationSize).intersected(pixmap.rect());
                 }
             }
 
             int x = option.rect.left();
             int y = option.rect.top();
             //QPixmap icon = value.value<QPixmap>(); //pixmap(column);
             if(!icon.isNull())
             {
                 int yOffset = (sizeHint(option, index).height() - icon.height()) / 2;
                 thePainter->drawPixmap(x + 2, y + yOffset, icon);
 
                 int i = index == d->m_selection1Index ? 1 : index == d->m_selection2Index ? 2 : index == d->m_selection3Index ? 3 : 0;
                 if(i != 0)
                 {
                     QSharedPointer<Options> pOpts = d->m_pOptions;
                     QColor c(i == 1 ? pOpts->m_colorA : i == 2 ? pOpts->m_colorB : pOpts->m_colorC);
                     thePainter->setPen(c); // highlight() );
                     thePainter->drawRect(x + 2, y + yOffset, icon.width(), icon.height());
                     thePainter->setPen(QPen(c, 0, Qt::DotLine));
                     thePainter->drawRect(x + 1, y + yOffset - 1, icon.width() + 2, icon.height() + 2);
                     thePainter->setPen(Qt::white);
                     QString s(QChar('A' + i - 1));
 
                     thePainter->drawText(x + 2 + (icon.width() - Utils::getHorizontalAdvance(thePainter->fontMetrics(), s)) / 2,
                                 y + yOffset + (icon.height() + thePainter->fontMetrics().ascent()) / 2 - 1,
                                 s);
                 }
                 else
                 {
                     thePainter->setPen(m_pDMW->palette().window().color());
                     thePainter->drawRect(x + 1, y + yOffset - 1, icon.width() + 2, icon.height() + 2);
                 }
                 return;
             }
         }
         QStyleOptionViewItem option2 = option;
         if(column >= s_UnsolvedCol)
         {
             option2.displayAlignment = Qt::AlignRight;
         }
         QStyledItemDelegate::paint(thePainter, option2, index);
     }
     QSize sizeHint(const QStyleOptionViewItem& option, const QModelIndex& index) const override
     {
         QSize sz = QStyledItemDelegate::sizeHint(option, index);
         return sz.expandedTo(QSize(0, 18));
     }
 };
 
 DirectoryMergeWindow::DirectoryMergeWindow(QWidget* pParent, const QSharedPointer<Options> &pOptions, KDiff3App* const app)
     : QTreeView(pParent)
 {
     d = new DirectoryMergeWindowPrivate(this);
     setModel(d);
     setItemDelegate(new DirMergeItemDelegate(this));
     connect(this, &DirectoryMergeWindow::doubleClicked, this, &DirectoryMergeWindow::onDoubleClick);
     connect(this, &DirectoryMergeWindow::expanded, this, &DirectoryMergeWindow::onExpanded);
 
     d->m_pOptions = pOptions;
     mApp = app;
 
     setSortingEnabled(true);
 }
 
 DirectoryMergeWindow::~DirectoryMergeWindow()
 {
     delete d;
 }
 
 void DirectoryMergeWindow::setDirectoryMergeInfo(DirectoryMergeInfo* p)
 {
     d->m_pDirectoryMergeInfo = p;
 }
 bool DirectoryMergeWindow::isDirectoryMergeInProgress()
 {
     return d->m_bRealMergeStarted;
 }
 bool DirectoryMergeWindow::isSyncMode()
 {
     return d->m_bSyncMode;
 }
 bool DirectoryMergeWindow::isScanning()
 {
     return d->m_bScanning;
 }
 
 int DirectoryMergeWindow::totalColumnWidth()
 {
     int w = 0;
     for(int i = 0; i < s_OpStatusCol; ++i)
     {
         w += columnWidth(i);
     }
     return w;
 }
 
 void DirectoryMergeWindow::reload()
 {
     if(isDirectoryMergeInProgress())
     {
         int result = KMessageBox::warningYesNo(this,
                                                i18n("You are currently doing a 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->rootMFI()->getDirectoryInfo(), true);
     //fix file visibilities after reload or menu will be out of sync with display if changed from defaults.
     updateFileVisibilities();
 }
 
 void DirectoryMergeWindow::DirectoryMergeWindowPrivate::calcDirStatus(bool bThreeDirs, const QModelIndex& mi,
                                                                       int& nofFiles, int& nofDirs, int& nofEqualFiles, int& nofManualMerges)
 {
     MergeFileInfos* pMFI = getMFI(mi);
     if(pMFI->hasDir())
     {
         ++nofDirs;
     }
     else
     {
         ++nofFiles;
         if(pMFI->isEqualAB() && (!bThreeDirs || pMFI->isEqualAC()))
         {
             ++nofEqualFiles;
         }
         else
         {
             if(pMFI->getOperation() == eMergeABCToDest || pMFI->getOperation() == eMergeABToDest)
                 ++nofManualMerges;
         }
     }
     for(int childIdx = 0; childIdx < rowCount(mi); ++childIdx)
         calcDirStatus(bThreeDirs, index(childIdx, 0, mi), nofFiles, nofDirs, nofEqualFiles, nofManualMerges);
 }
 
 struct t_ItemInfo {
     bool bExpanded;
     bool bOperationComplete;
     QString status;
     e_MergeOperation eMergeOperation;
 };
 
 bool DirectoryMergeWindow::init(
     const QSharedPointer<DirectoryInfo> &dirInfo,
     bool bDirectoryMerge,
     bool bReload)
 {
     return d->init(dirInfo, bDirectoryMerge, bReload);
 }
 
 void DirectoryMergeWindow::DirectoryMergeWindowPrivate::buildMergeMap(const QSharedPointer<DirectoryInfo>& dirInfo)
 {
     t_DirectoryList::iterator dirIterator;
 
     if(dirInfo->dirA().isValid())
     {
         for(dirIterator = dirInfo->getDirListA().begin(); dirIterator != dirInfo->getDirListA().end(); ++dirIterator)
         {
             MergeFileInfos& mfi = m_fileMergeMap[FileKey(*dirIterator)];
 
             mfi.setFileInfoA(&(*dirIterator));
             mfi.setDirectoryInfo(dirInfo);
         }
     }
 
     if(dirInfo->dirB().isValid())
     {
         for(dirIterator = dirInfo->getDirListB().begin(); dirIterator != dirInfo->getDirListB().end(); ++dirIterator)
         {
             MergeFileInfos& mfi = m_fileMergeMap[FileKey(*dirIterator)];
 
             mfi.setFileInfoB(&(*dirIterator));
             mfi.setDirectoryInfo(dirInfo);
         }
     }
 
     if(dirInfo->dirC().isValid())
     {
         for(dirIterator = dirInfo->getDirListC().begin(); dirIterator != dirInfo->getDirListC().end(); ++dirIterator)
         {
             MergeFileInfos& mfi = m_fileMergeMap[FileKey(*dirIterator)];
 
             mfi.setFileInfoC(&(*dirIterator));
             mfi.setDirectoryInfo(dirInfo);
         }
     }
 }
 
 bool DirectoryMergeWindow::DirectoryMergeWindowPrivate::init(
     const QSharedPointer<DirectoryInfo> &dirInfo,
     bool bDirectoryMerge,
     bool bReload)
 {
     //set root data now that we have the directory info.
     rootMFI()->setDirectoryInfo(dirInfo);
 
     if(m_pOptions->m_bDmFullAnalysis)
     {
         // A full analysis uses the same resources that a normal text-diff/merge uses.
         // So make sure that the user saves his data first.
         bool bCanContinue = false;
         emit mWindow->checkIfCanContinue(&bCanContinue);
         if(!bCanContinue)
             return false;
         emit mWindow->startDiffMerge("", "", "", "", "", "", "", nullptr); // hide main window
     }
 
     mWindow->show();
     mWindow->setUpdatesEnabled(true);
 
     std::map<QString, t_ItemInfo> expandedDirsMap;
 
     if(bReload)
     {
         // Remember expanded items TODO
         //QTreeWidgetItemIterator it( this );
         //while ( *it )
         //{
         //   DirMergeItem* pDMI = static_cast<DirMergeItem*>( *it );
         //   t_ItemInfo& ii = expandedDirsMap[ pDMI->m_pMFI->subPath() ];
         //   ii.bExpanded = pDMI->isExpanded();
         //   ii.bOperationComplete = pDMI->m_pMFI->m_bOperationComplete;
         //   ii.status = pDMI->text( s_OpStatusCol );
         //   ii.eMergeOperation = pDMI->m_pMFI->getOperation();
         //   ++it;
         //}
     }
 
     ProgressProxy pp;
     m_bFollowDirLinks = m_pOptions->m_bDmFollowDirLinks;
     m_bFollowFileLinks = m_pOptions->m_bDmFollowFileLinks;
     m_bSimulatedMergeStarted = false;
     m_bRealMergeStarted = false;
     m_bError = false;
     m_bDirectoryMerge = bDirectoryMerge;
     m_selection1Index = QModelIndex();
     m_selection2Index = QModelIndex();
     m_selection3Index = QModelIndex();
     m_bCaseSensitive = m_pOptions->m_bDmCaseSensitiveFilenameComparison;
     m_bUnfoldSubdirs = m_pOptions->m_bDmUnfoldSubdirs;
     m_bSkipDirStatus = m_pOptions->m_bDmSkipDirStatus;
 
     beginResetModel();
     m_pRoot->clear();
     m_mergeItemList.clear();
     endResetModel();
 
     m_currentIndexForOperation = m_mergeItemList.end();
 
     if(!bReload)
     {
         m_pDirShowIdenticalFiles->setChecked(true);
         m_pDirShowDifferentFiles->setChecked(true);
         m_pDirShowFilesOnlyInA->setChecked(true);
         m_pDirShowFilesOnlyInB->setChecked(true);
         m_pDirShowFilesOnlyInC->setChecked(true);
     }
     Q_ASSERT(dirInfo != nullptr);
     FileAccess dirA = dirInfo->dirA();
     FileAccess dirB = dirInfo->dirB();
     FileAccess dirC = dirInfo->dirC();
     const FileAccess dirDest = dirInfo->destDir();
     // Check if all input directories exist and are valid. The dest dir is not tested now.
     // The test will happen only when we are going to write to it.
     if(!dirA.isDir() || !dirB.isDir() ||
        (dirC.isValid() && !dirC.isDir()))
     {
         QString text(i18n("Opening of directories failed:"));
         text += "\n\n";
         if(!dirA.isDir())
         {
             text += i18n("Dir A \"%1\" does not exist or is not a directory.\n", dirA.prettyAbsPath());
         }
 
         if(!dirB.isDir())
         {
             text += i18n("Dir B \"%1\" does not exist or is not a directory.\n", dirB.prettyAbsPath());
         }
 
         if(dirC.isValid() && !dirC.isDir())
         {
             text += i18n("Dir C \"%1\" does not exist or is not a directory.\n", dirC.prettyAbsPath());
         }
 
         KMessageBox::sorry(mWindow, text, i18n("Directory Open Error"));
         return false;
     }
 
     if(dirC.isValid() &&
        (dirDest.prettyAbsPath() == dirA.prettyAbsPath() || dirDest.prettyAbsPath() == dirB.prettyAbsPath()))
     {
         KMessageBox::error(mWindow,
                            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 mWindow->statusBarMessage(i18n("Scanning directories..."));
 
     m_bSyncMode = m_pOptions->m_bDmSyncMode && !dirC.isValid() && !dirDest.isValid();
 
     m_fileMergeMap.clear();
     s_eCaseSensitivity = m_bCaseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive;
     // calc how many directories will be read:
     double nofScans = (dirA.isValid() ? 1 : 0) + (dirB.isValid() ? 1 : 0) + (dirC.isValid() ? 1 : 0);
     int currentScan = 0;
 
     //TODO   setColumnWidthMode(s_UnsolvedCol, Q3ListView::Manual);
     //   setColumnWidthMode(s_SolvedCol,   Q3ListView::Manual);
     //   setColumnWidthMode(s_WhiteCol,    Q3ListView::Manual);
     //   setColumnWidthMode(s_NonWhiteCol, Q3ListView::Manual);
     mWindow->setColumnHidden(s_CCol, !dirC.isValid());
     mWindow->setColumnHidden(s_WhiteCol, !m_pOptions->m_bDmFullAnalysis);
     mWindow->setColumnHidden(s_NonWhiteCol, !m_pOptions->m_bDmFullAnalysis);
     mWindow->setColumnHidden(s_UnsolvedCol, !m_pOptions->m_bDmFullAnalysis);
     mWindow->setColumnHidden(s_SolvedCol, !(m_pOptions->m_bDmFullAnalysis && dirC.isValid()));
 
     bool bListDirSuccessA = true;
     bool bListDirSuccessB = true;
     bool bListDirSuccessC = true;
 
     if(dirA.isValid())
     {
         pp.setInformation(i18n("Reading Directory A"));
         pp.setSubRangeTransformation(currentScan / nofScans, (currentScan + 1) / nofScans);
         ++currentScan;
 
         bListDirSuccessA = dirInfo->listDirA(*m_pOptions);
     }
 
     if(dirB.isValid())
     {
         pp.setInformation(i18n("Reading Directory B"));
         pp.setSubRangeTransformation(currentScan / nofScans, (currentScan + 1) / nofScans);
         ++currentScan;
 
         bListDirSuccessB = dirInfo->listDirB(*m_pOptions);
     }
 
     e_MergeOperation eDefaultMergeOp;
     if(dirC.isValid())
     {
         pp.setInformation(i18n("Reading Directory C"));
         pp.setSubRangeTransformation(currentScan / nofScans, (currentScan + 1) / nofScans);
         ++currentScan;
 
         bListDirSuccessC = dirInfo->listDirC(*m_pOptions);
 
         eDefaultMergeOp = eMergeABCToDest;
     }
     else
         eDefaultMergeOp = m_bSyncMode ? eMergeToAB : eMergeABToDest;
 
     buildMergeMap(dirInfo);
 
     bool bContinue = true;
     if(!bListDirSuccessA || !bListDirSuccessB || !bListDirSuccessC)
     {
         QString s = i18n("Some subdirectories were not readable in");
         if(!bListDirSuccessA) s += "\nA: " + dirA.prettyAbsPath();
         if(!bListDirSuccessB) s += "\nB: " + dirB.prettyAbsPath();
         if(!bListDirSuccessC) s += "\nC: " + dirC.prettyAbsPath();
         s += '\n';
         s += i18n("Check the permissions of the subdirectories.");
         bContinue = KMessageBox::Continue == KMessageBox::warningContinueCancel(mWindow, s);
     }
 
     if(bContinue)
     {
         prepareListView(pp);
 
         mWindow->updateFileVisibilities();
 
         for(int childIdx = 0; childIdx < rowCount(); ++childIdx)
         {
             QModelIndex mi = index(childIdx, 0, QModelIndex());
             calcSuggestedOperation(mi, eDefaultMergeOp);
         }
     }
 
     mWindow->sortByColumn(0, Qt::AscendingOrder);
 
     for(int column = 0; column < columnCount(QModelIndex()); ++column)
         mWindow->resizeColumnToContents(column);
 
     // Try to improve the view a little bit.
     QWidget* pParent = mWindow->parentWidget();
     QSplitter* pSplitter = static_cast<QSplitter*>(pParent);
     if(pSplitter != nullptr)
     {
         QList<int> sizes = pSplitter->sizes();
         int total = sizes[0] + sizes[1];
         if(total < 10)
             total = 100;
         sizes[0] = total * 6 / 10;
         sizes[1] = total - sizes[0];
         pSplitter->setSizes(sizes);
     }
 
     m_bScanning = false;
     emit mWindow->statusBarMessage(i18n("Ready."));
 
     if(bContinue && !m_bSkipDirStatus)
     {
         // Generate a status report
         int nofFiles = 0;
         int nofDirs = 0;
         int nofEqualFiles = 0;
         int nofManualMerges = 0;
         //TODO
         for(int childIdx = 0; childIdx < rowCount(); ++childIdx)
             calcDirStatus(dirC.isValid(), index(childIdx, 0, QModelIndex()),
                           nofFiles, nofDirs, nofEqualFiles, nofManualMerges);
 
         QString s;
         s = i18n("Directory Comparison Status\n\n"
                  "Number of subdirectories: %1\n"
                  "Number of equal files: %2\n"
                  "Number of different files: %3",
                  nofDirs, nofEqualFiles, nofFiles - nofEqualFiles);
 
         if(dirC.isValid())
             s += '\n' + i18n("Number of manual merges: %1", nofManualMerges);
         KMessageBox::information(mWindow, s);
         //
         //TODO
         //if ( topLevelItemCount()>0 )
         //{
         //   topLevelItem(0)->setSelected(true);
         //   setCurrentItem( topLevelItem(0) );
         //}
     }
 
     if(bReload)
     {
         // Remember expanded items
         //TODO
         //QTreeWidgetItemIterator it( this );
         //while ( *it )
         //{
         //   DirMergeItem* pDMI = static_cast<DirMergeItem*>( *it );
         //   std::map<QString,t_ItemInfo>::iterator i = expandedDirsMap.find( pDMI->m_pMFI->subPath() );
         //   if ( i!=expandedDirsMap.end() )
         //   {
         //      t_ItemInfo& ii = i->second;
         //      pDMI->setExpanded( ii.bExpanded );
         //      //pDMI->m_pMFI->setMergeOperation( ii.eMergeOperation, false ); unsafe, might have changed
         //      pDMI->m_pMFI->m_bOperationComplete = ii.bOperationComplete;
         //      pDMI->setText( s_OpStatusCol, ii.status );
         //   }
         //   ++it;
         //}
     }
     else if(m_bUnfoldSubdirs)
     {
         m_pDirUnfoldAll->trigger();
     }
 
     return true;
 }
 
 inline QString DirectoryMergeWindow::getDirNameA() const
 {
     return d->rootMFI()->getDirectoryInfo()->dirA().prettyAbsPath();
 }
 inline QString DirectoryMergeWindow::getDirNameB() const
 {
     return d->rootMFI()->getDirectoryInfo()->dirB().prettyAbsPath();
 }
 inline QString DirectoryMergeWindow::getDirNameC() const
 {
     return d->rootMFI()->getDirectoryInfo()->dirC().prettyAbsPath();
 }
 inline QString DirectoryMergeWindow::getDirNameDest() const
 {
     return d->rootMFI()->getDirectoryInfo()->destDir().prettyAbsPath();
 }
 
 void DirectoryMergeWindow::onExpanded()
 {
     resizeColumnToContents(s_NameCol);
 }
 
 void DirectoryMergeWindow::slotChooseAEverywhere()
 {
     d->setAllMergeOperations(eCopyAToDest);
 }
 
 void DirectoryMergeWindow::slotChooseBEverywhere()
 {
     d->setAllMergeOperations(eCopyBToDest);
 }
 
 void DirectoryMergeWindow::slotChooseCEverywhere()
 {
     d->setAllMergeOperations(eCopyCToDest);
 }
 
 void DirectoryMergeWindow::slotAutoChooseEverywhere()
 {
     e_MergeOperation eDefaultMergeOp = d->isThreeWay() ? eMergeABCToDest : d->m_bSyncMode ? eMergeToAB : eMergeABToDest;
     d->setAllMergeOperations(eDefaultMergeOp);
 }
 
 void DirectoryMergeWindow::slotNoOpEverywhere()
 {
     d->setAllMergeOperations(eNoOperation);
 }
 
 void DirectoryMergeWindow::slotFoldAllSubdirs()
 {
     collapseAll();
 }
 
 void DirectoryMergeWindow::slotUnfoldAllSubdirs()
 {
     expandAll();
 }
 
 // Merge current item (merge mode)
 void DirectoryMergeWindow::slotCurrentDoNothing()
 {
     d->setMergeOperation(currentIndex(), eNoOperation);
 }
 void DirectoryMergeWindow::slotCurrentChooseA()
 {
     d->setMergeOperation(currentIndex(), d->m_bSyncMode ? eCopyAToB : eCopyAToDest);
 }
 void DirectoryMergeWindow::slotCurrentChooseB()
 {
     d->setMergeOperation(currentIndex(), d->m_bSyncMode ? eCopyBToA : eCopyBToDest);
 }
 void DirectoryMergeWindow::slotCurrentChooseC()
 {
     d->setMergeOperation(currentIndex(), eCopyCToDest);
 }
 void DirectoryMergeWindow::slotCurrentMerge()
 {
     bool bThreeDirs = d->isThreeWay();
     d->setMergeOperation(currentIndex(), bThreeDirs ? eMergeABCToDest : eMergeABToDest);
 }
 void DirectoryMergeWindow::slotCurrentDelete()
 {
     d->setMergeOperation(currentIndex(), eDeleteFromDest);
 }
 // Sync current item
 void DirectoryMergeWindow::slotCurrentCopyAToB()
 {
     d->setMergeOperation(currentIndex(), eCopyAToB);
 }
 void DirectoryMergeWindow::slotCurrentCopyBToA()
 {
     d->setMergeOperation(currentIndex(), eCopyBToA);
 }
 void DirectoryMergeWindow::slotCurrentDeleteA()
 {
     d->setMergeOperation(currentIndex(), eDeleteA);
 }
 void DirectoryMergeWindow::slotCurrentDeleteB()
 {
     d->setMergeOperation(currentIndex(), eDeleteB);
 }
 void DirectoryMergeWindow::slotCurrentDeleteAAndB()
 {
     d->setMergeOperation(currentIndex(), eDeleteAB);
 }
 void DirectoryMergeWindow::slotCurrentMergeToA()
 {
     d->setMergeOperation(currentIndex(), eMergeToA);
 }
 void DirectoryMergeWindow::slotCurrentMergeToB()
 {
     d->setMergeOperation(currentIndex(), eMergeToB);
 }
 void DirectoryMergeWindow::slotCurrentMergeToAAndB()
 {
     d->setMergeOperation(currentIndex(), eMergeToAB);
 }
 
 void DirectoryMergeWindow::keyPressEvent(QKeyEvent* e)
 {
     if((e->QInputEvent::modifiers() & Qt::ControlModifier) != 0)
     {
         MergeFileInfos* pMFI = d->getMFI(currentIndex());
         if(pMFI == nullptr)
             return;
 
         bool bThreeDirs = pMFI->getDirectoryInfo()->dirC().isValid();
         bool bMergeMode = bThreeDirs || !d->m_bSyncMode;
         bool bFTConflict = pMFI == nullptr ? false : pMFI->conflictingFileTypes();
 
         if(bMergeMode)
         {
             switch(e->key())
             {
                 case Qt::Key_1:
                     if(pMFI->existsInA())
                     {
                         slotCurrentChooseA();
                     }
                     return;
                 case Qt::Key_2:
                     if(pMFI->existsInB())
                     {
                         slotCurrentChooseB();
                     }
                     return;
                 case Qt::Key_3:
                     if(pMFI->existsInC())
                     {
                         slotCurrentChooseC();
                     }
                     return;
                 case Qt::Key_Space:
                     slotCurrentDoNothing();
                     return;
                 case Qt::Key_4:
                     if(!bFTConflict)
                     {
                         slotCurrentMerge();
                     }
                     return;
                 case Qt::Key_Delete:
                     slotCurrentDelete();
                     return;
                 default:
                     break;
             }
         }
         else
         {
             switch(e->key())
             {
                 case Qt::Key_1:
                     if(pMFI->existsInA())
                     {
                         slotCurrentCopyAToB();
                     }
                     return;
                 case Qt::Key_2:
                     if(pMFI->existsInB())
                     {
                         slotCurrentCopyBToA();
                     }
                     return;
                 case Qt::Key_Space:
                     slotCurrentDoNothing();
                     return;
                 case Qt::Key_4:
                     if(!bFTConflict)
                     {
                         slotCurrentMergeToAAndB();
                     }
                     return;
                 case Qt::Key_Delete:
                     if(pMFI->existsInA() && pMFI->existsInB())
                         slotCurrentDeleteAAndB();
                     else if(pMFI->existsInA())
                         slotCurrentDeleteA();
                     else if(pMFI->existsInB())
                         slotCurrentDeleteB();
                     return;
                 default:
                     break;
             }
         }
     }
     else if(e->key() == Qt::Key_Return || e->key() == Qt::Key_Enter)
     {
         onDoubleClick(currentIndex());
         return;
     }
 
     QTreeView::keyPressEvent(e);
 }
 
 void DirectoryMergeWindow::focusInEvent(QFocusEvent*)
 {
     emit updateAvailabilities();
 }
 void DirectoryMergeWindow::focusOutEvent(QFocusEvent*)
 {
     emit updateAvailabilities();
 }
 
 void DirectoryMergeWindow::DirectoryMergeWindowPrivate::setAllMergeOperations(e_MergeOperation eDefaultOperation)
 {
     if(KMessageBox::Yes == KMessageBox::warningYesNo(mWindow,
                                                      i18n("This affects all merge operations."),
                                                      i18n("Changing All Merge Operations"),
                                                      KStandardGuiItem::cont(),
                                                      KStandardGuiItem::cancel()))
     {
         for(int i = 0; i < rowCount(); ++i)
         {
             calcSuggestedOperation(index(i, 0, QModelIndex()), eDefaultOperation);
         }
     }
 }
 
 QModelIndex DirectoryMergeWindow::DirectoryMergeWindowPrivate::nextSibling(const QModelIndex& mi)
 {
     QModelIndex miParent = mi.parent();
     int currentIdx = mi.row();
     if(currentIdx + 1 < mi.model()->rowCount(miParent))
         return mi.model()->index(mi.row() + 1, 0, miParent); // next child of parent
     return QModelIndex();
 }
 
 // Iterate through the complete tree. Start by specifying QListView::firstChild().
 QModelIndex DirectoryMergeWindow::DirectoryMergeWindowPrivate::treeIterator(QModelIndex mi, bool bVisitChildren, bool bFindInvisible)
 {
     if(mi.isValid())
     {
         do
         {
             if(bVisitChildren && mi.model()->rowCount(mi) != 0)
                 mi = mi.model()->index(0, 0, mi);
             else
             {
                 QModelIndex miNextSibling = nextSibling(mi);
                 if(miNextSibling.isValid())
                     mi = miNextSibling;
                 else
                 {
                     mi = mi.parent();
                     while(mi.isValid())
                     {
                         miNextSibling = nextSibling(mi);
                         if(miNextSibling.isValid())
                         {
                             mi = miNextSibling;
                             break;
                         }
                         else
                         {
                             mi = mi.parent();
                         }
                     }
                 }
             }
         } while(mi.isValid() && mWindow->isRowHidden(mi.row(), mi.parent()) && !bFindInvisible);
     }
     return mi;
 }
 
 void DirectoryMergeWindow::DirectoryMergeWindowPrivate::prepareListView(ProgressProxy& pp)
 {
     QStringList errors;
     //TODO   clear();
     PixMapUtils::initPixmaps(m_pOptions->m_newestFileColor, m_pOptions->m_oldestFileColor,
                              m_pOptions->m_midAgeFileColor, m_pOptions->m_missingFileColor);
 
     mWindow->setRootIsDecorated(true);
 
     t_fileMergeMap::iterator j;
     int nrOfFiles = m_fileMergeMap.size();
     int currentIdx = 1;
     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 %1 / %2\n%3", currentIdx, nrOfFiles, fileName), currentIdx, false);
         if(pp.wasCancelled()) break;
         ++currentIdx;
 
         // The comparisons and calculations for each file take place here.
         mfi.compareFilesAndCalcAges(errors, m_pOptions, mWindow);
         // Get dirname from fileName: Search for "/" from end:
         int pos = fileName.lastIndexOf('/');
         QString dirPart;
         QString filePart;
         if(pos == -1)
         {
             // Top dir
             filePart = fileName;
         }
         else
         {
             dirPart = fileName.left(pos);
             filePart = fileName.mid(pos + 1);
         }
         if(dirPart.isEmpty()) // Top level
         {
             m_pRoot->addChild(&mfi); //new DirMergeItem( this, filePart, &mfi );
             mfi.setParent(m_pRoot);
         }
         else
         {
             FileAccess* pFA = mfi.getFileInfoA() ? mfi.getFileInfoA() : mfi.getFileInfoB() ? mfi.getFileInfoB() : mfi.getFileInfoC();
             MergeFileInfos& dirMfi = pFA->parent() ? m_fileMergeMap[FileKey(*pFA->parent())] : *m_pRoot; // parent
 
             dirMfi.addChild(&mfi); //new DirMergeItem( dirMfi.m_pDMI, filePart, &mfi );
             mfi.setParent(&dirMfi);
 
             //   // Equality for parent dirs is set in updateFileVisibilities()
         }
 
         mfi.updateAge();
     }
 
     if(errors.size() > 0)
     {
         if(errors.size() < 15)
         {
             KMessageBox::errorList(mWindow, i18n("Some files could not be processed."), errors);
         }
         else
         {
             KMessageBox::error(mWindow, i18n("Some files could not be processed."));
         }
     }
 
     beginResetModel();
     endResetModel();
 }
 
 void DirectoryMergeWindow::DirectoryMergeWindowPrivate::calcSuggestedOperation(const QModelIndex& mi, e_MergeOperation eDefaultMergeOp)
 {
     MergeFileInfos* pMFI = getMFI(mi);
     if(pMFI == nullptr)
         return;
 
     bool bCheckC = pMFI->getDirectoryInfo()->dirC().isValid();
     bool bCopyNewer = m_pOptions->m_bDmCopyNewer;
     bool bOtherDest = !((pMFI->getDirectoryInfo()->destDir().absoluteFilePath() == pMFI->getDirectoryInfo()->dirA().absoluteFilePath()) ||
                         (pMFI->getDirectoryInfo()->destDir().absoluteFilePath() == pMFI->getDirectoryInfo()->dirB().absoluteFilePath()) ||
                         (bCheckC && pMFI->getDirectoryInfo()->destDir().absoluteFilePath() == pMFI->getDirectoryInfo()->dirC().absoluteFilePath()));
 
     if(eDefaultMergeOp == eMergeABCToDest && !bCheckC)
     {
         eDefaultMergeOp = eMergeABToDest;
     }
     if(eDefaultMergeOp == eMergeToAB && bCheckC)
     {
         Q_ASSERT(true);
     }
 
     if(eDefaultMergeOp == eMergeToA || eDefaultMergeOp == eMergeToB ||
        eDefaultMergeOp == eMergeABCToDest || eDefaultMergeOp == eMergeABToDest || eDefaultMergeOp == eMergeToAB)
     {
         if(!bCheckC)
         {
             if(pMFI->isEqualAB())
             {
                 setMergeOperation(mi, bOtherDest ? eCopyBToDest : eNoOperation);
             }
             else if(pMFI->existsInA() && pMFI->existsInB())
             {
                 if(!bCopyNewer || pMFI->isDirA())
                     setMergeOperation(mi, eDefaultMergeOp);
                 else if(bCopyNewer && pMFI->m_bConflictingAges)
                 {
                     setMergeOperation(mi, eConflictingAges);
                 }
                 else
                 {
                     if(pMFI->getAgeA() == eNew)
                         setMergeOperation(mi, eDefaultMergeOp == eMergeToAB ? eCopyAToB : eCopyAToDest);
                     else
                         setMergeOperation(mi, eDefaultMergeOp == eMergeToAB ? eCopyBToA : eCopyBToDest);
                 }
             }
             else if(!pMFI->existsInA() && pMFI->existsInB())
             {
                 if(eDefaultMergeOp == eMergeABToDest)
                     setMergeOperation(mi, eCopyBToDest);
                 else if(eDefaultMergeOp == eMergeToB)
                     setMergeOperation(mi, eNoOperation);
                 else
                     setMergeOperation(mi, eCopyBToA);
             }
             else if(pMFI->existsInA() && !pMFI->existsInB())
             {
                 if(eDefaultMergeOp == eMergeABToDest)
                     setMergeOperation(mi, eCopyAToDest);
                 else if(eDefaultMergeOp == eMergeToA)
                     setMergeOperation(mi, eNoOperation);
                 else
                     setMergeOperation(mi, eCopyAToB);
             }
             else //if ( !pMFI->existsInA() && !pMFI->existsInB() )
             {
                 setMergeOperation(mi, eNoOperation);
             }
         }
         else
         {
             if(pMFI->isEqualAB() && pMFI->isEqualAC())
             {
                 setMergeOperation(mi, bOtherDest ? eCopyCToDest : eNoOperation);
             }
             else if(pMFI->existsInA() && pMFI->existsInB() && pMFI->existsInC())
             {
                 if(pMFI->isEqualAB() || pMFI->isEqualBC())
                     setMergeOperation(mi, eCopyCToDest);
                 else if(pMFI->isEqualAC())
                     setMergeOperation(mi, eCopyBToDest);
                 else
                     setMergeOperation(mi, eMergeABCToDest);
             }
             else if(pMFI->existsInA() && pMFI->existsInB() && !pMFI->existsInC())
             {
                 if(pMFI->isEqualAB())
                     setMergeOperation(mi, eDeleteFromDest);
                 else
                     setMergeOperation(mi, eChangedAndDeleted);
             }
             else if(pMFI->existsInA() && !pMFI->existsInB() && pMFI->existsInC())
             {
                 if(pMFI->isEqualAC())
                     setMergeOperation(mi, eDeleteFromDest);
                 else
                     setMergeOperation(mi, eChangedAndDeleted);
             }
             else if(!pMFI->existsInA() && pMFI->existsInB() && pMFI->existsInC())
             {
                 if(pMFI->isEqualBC())
                     setMergeOperation(mi, eCopyCToDest);
                 else
                     setMergeOperation(mi, eMergeABCToDest);
             }
             else if(!pMFI->existsInA() && !pMFI->existsInB() && pMFI->existsInC())
             {
                 setMergeOperation(mi, eCopyCToDest);
             }
             else if(!pMFI->existsInA() && pMFI->existsInB() && !pMFI->existsInC())
             {
                 setMergeOperation(mi, eCopyBToDest);
             }
             else if(pMFI->existsInA() && !pMFI->existsInB() && !pMFI->existsInC())
             {
                 setMergeOperation(mi, eDeleteFromDest);
             }
             else //if ( !pMFI->existsInA() && !pMFI->existsInB() && !pMFI->existsInC() )
             {
                 setMergeOperation(mi, eNoOperation);
             }
         }
 
         // Now check if file/dir-types fit.
         if(pMFI->conflictingFileTypes())
         {
             setMergeOperation(mi, eConflictingFileTypes);
         }
     }
     else
     {
         e_MergeOperation eMO = eDefaultMergeOp;
         switch(eDefaultMergeOp)
         {
             case eConflictingFileTypes:
             case eChangedAndDeleted:
             case eConflictingAges:
             case eDeleteA:
             case eDeleteB:
             case eDeleteAB:
             case eDeleteFromDest:
             case eNoOperation:
                 break;
             case eCopyAToB:
                 if(!pMFI->existsInA())
                 {
                     eMO = eDeleteB;
                 }
                 break;
             case eCopyBToA:
                 if(!pMFI->existsInB())
                 {
                     eMO = eDeleteA;
                 }
                 break;
             case eCopyAToDest:
                 if(!pMFI->existsInA())
                 {
                     eMO = eDeleteFromDest;
                 }
                 break;
             case eCopyBToDest:
                 if(!pMFI->existsInB())
                 {
                     eMO = eDeleteFromDest;
                 }
                 break;
             case eCopyCToDest:
                 if(!pMFI->existsInC())
                 {
                     eMO = eDeleteFromDest;
                 }
                 break;
 
             case eMergeToA:
             case eMergeToB:
             case eMergeToAB:
             case eMergeABCToDest:
             case eMergeABToDest:
                 break;
             default:
                 Q_ASSERT(true);
                 break;
         }
         setMergeOperation(mi, eMO);
     }
 }
 
 void DirectoryMergeWindow::onDoubleClick(const QModelIndex& mi)
 {
     if(!mi.isValid())
         return;
 
     d->m_bSimulatedMergeStarted = false;
     if(d->m_bDirectoryMerge)
         mergeCurrentFile();
     else
         compareCurrentFile();
 }
 
 void DirectoryMergeWindow::currentChanged(const QModelIndex& current, const QModelIndex& previous)
 {
     QTreeView::currentChanged(current, previous);
     MergeFileInfos* pMFI = d->getMFI(current);
     if(pMFI == nullptr)
         return;
 
     d->m_pDirectoryMergeInfo->setInfo(pMFI->getDirectoryInfo()->dirA(), pMFI->getDirectoryInfo()->dirB(), pMFI->getDirectoryInfo()->dirC(), pMFI->getDirectoryInfo()->destDir(), *pMFI);
 }
 
 void DirectoryMergeWindow::mousePressEvent(QMouseEvent* e)
 {
     QTreeView::mousePressEvent(e);
     QModelIndex mi = indexAt(e->pos());
     int c = mi.column();
     QPoint p = e->globalPos();
     MergeFileInfos* pMFI = d->getMFI(mi);
     if(pMFI == nullptr)
         return;
 
     if(c == s_OpCol)
     {
         bool bThreeDirs = d->isThreeWay();
 
         QMenu m(this);
         if(bThreeDirs)
         {
             m.addAction(d->m_pDirCurrentDoNothing);
             int count = 0;
             if(pMFI->existsInA())
             {
                 m.addAction(d->m_pDirCurrentChooseA);
                 ++count;
             }
             if(pMFI->existsInB())
             {
                 m.addAction(d->m_pDirCurrentChooseB);
                 ++count;
             }
             if(pMFI->existsInC())
             {
                 m.addAction(d->m_pDirCurrentChooseC);
                 ++count;
             }
             if(!pMFI->conflictingFileTypes() && count > 1) m.addAction(d->m_pDirCurrentMerge);
             m.addAction(d->m_pDirCurrentDelete);
         }
         else if(d->m_bSyncMode)
         {
             m.addAction(d->m_pDirCurrentSyncDoNothing);
             if(pMFI->existsInA()) m.addAction(d->m_pDirCurrentSyncCopyAToB);
             if(pMFI->existsInB()) m.addAction(d->m_pDirCurrentSyncCopyBToA);
             if(pMFI->existsInA()) m.addAction(d->m_pDirCurrentSyncDeleteA);
             if(pMFI->existsInB()) m.addAction(d->m_pDirCurrentSyncDeleteB);
             if(pMFI->existsInA() && pMFI->existsInB())
             {
                 m.addAction(d->m_pDirCurrentSyncDeleteAAndB);
                 if(!pMFI->conflictingFileTypes())
                 {
                     m.addAction(d->m_pDirCurrentSyncMergeToA);
                     m.addAction(d->m_pDirCurrentSyncMergeToB);
                     m.addAction(d->m_pDirCurrentSyncMergeToAAndB);
                 }
             }
         }
         else
         {
             m.addAction(d->m_pDirCurrentDoNothing);
             if(pMFI->existsInA())
             {
                 m.addAction(d->m_pDirCurrentChooseA);
             }
             if(pMFI->existsInB())
             {
                 m.addAction(d->m_pDirCurrentChooseB);
             }
             if(!pMFI->conflictingFileTypes() && pMFI->existsInA() && pMFI->existsInB()) m.addAction(d->m_pDirCurrentMerge);
             m.addAction(d->m_pDirCurrentDelete);
         }
 
         m.exec(p);
     }
     else if(c == s_ACol || c == s_BCol || c == s_CCol)
     {
         QString itemPath;
         if(c == s_ACol && pMFI->existsInA())
         {
             itemPath = pMFI->fullNameA();
         }
         else if(c == s_BCol && pMFI->existsInB())
         {
             itemPath = pMFI->fullNameB();
         }
         else if(c == s_CCol && pMFI->existsInC())
         {
             itemPath = pMFI->fullNameC();
         }
 
         if(!itemPath.isEmpty())
         {
             d->selectItemAndColumn(mi, e->button() == Qt::RightButton);
         }
     }
 }
 
 #ifndef QT_NO_CONTEXTMENU
 void DirectoryMergeWindow::contextMenuEvent(QContextMenuEvent* e)
 {
     QModelIndex mi = indexAt(e->pos());
     int c = mi.column();
 
     MergeFileInfos* pMFI = d->getMFI(mi);
     if(pMFI == nullptr)
         return;
     if(c == s_ACol || c == s_BCol || c == s_CCol)
     {
         QString itemPath;
         if(c == s_ACol && pMFI->existsInA())
         {
             itemPath = pMFI->fullNameA();
         }
         else if(c == s_BCol && pMFI->existsInB())
         {
             itemPath = pMFI->fullNameB();
         }
         else if(c == s_CCol && pMFI->existsInC())
         {
             itemPath = pMFI->fullNameC();
         }
 
         if(!itemPath.isEmpty())
         {
             d->selectItemAndColumn(mi, true);
             QMenu m(this);
             m.addAction(d->m_pDirCompareExplicit);
             m.addAction(d->m_pDirMergeExplicit);
 
             m.popup(e->globalPos());
         }
     }
 }
 #endif
 
 QString DirectoryMergeWindow::DirectoryMergeWindowPrivate::getFileName(const QModelIndex& mi)
 {
     MergeFileInfos* pMFI = getMFI(mi);
     if(pMFI != nullptr)
     {
         return mi.column() == s_ACol ? pMFI->getFileInfoA()->absoluteFilePath() : mi.column() == s_BCol ? pMFI->getFileInfoB()->absoluteFilePath() : mi.column() == s_CCol ? pMFI->getFileInfoC()->absoluteFilePath() : QString("");
     }
     return QString();
 }
 
 bool DirectoryMergeWindow::DirectoryMergeWindowPrivate::isDir(const QModelIndex& mi)
 {
     MergeFileInfos* pMFI = getMFI(mi);
     if(pMFI != nullptr)
     {
         return mi.column() == s_ACol ? pMFI->isDirA() : mi.column() == s_BCol ? pMFI->isDirB() : pMFI->isDirC();
     }
     return false;
 }
 
 void DirectoryMergeWindow::DirectoryMergeWindowPrivate::selectItemAndColumn(const QModelIndex& mi, bool bContextMenu)
 {
     if(bContextMenu && (mi == m_selection1Index || mi == m_selection2Index || mi == m_selection3Index))
         return;
 
     QModelIndex old1 = m_selection1Index;
     QModelIndex old2 = m_selection2Index;
     QModelIndex old3 = m_selection3Index;
 
     bool bReset = false;
 
     if(m_selection1Index.isValid())
     {
         if(isDir(m_selection1Index) != isDir(mi))
             bReset = true;
     }
 
     if(bReset || m_selection3Index.isValid() || mi == m_selection1Index || mi == m_selection2Index || mi == m_selection3Index)
     {
         // restart
         m_selection1Index = QModelIndex();
         m_selection2Index = QModelIndex();
         m_selection3Index = QModelIndex();
     }
     else if(!m_selection1Index.isValid())
     {
         m_selection1Index = mi;
         m_selection2Index = QModelIndex();
         m_selection3Index = QModelIndex();
     }
     else if(!m_selection2Index.isValid())
     {
         m_selection2Index = mi;
         m_selection3Index = QModelIndex();
     }
     else if(!m_selection3Index.isValid())
     {
         m_selection3Index = mi;
     }
     if(old1.isValid()) emit dataChanged(old1, old1);
     if(old2.isValid()) emit dataChanged(old2, old2);
     if(old3.isValid()) emit dataChanged(old3, old3);
     if(m_selection1Index.isValid()) emit dataChanged(m_selection1Index, m_selection1Index);
     if(m_selection2Index.isValid()) emit dataChanged(m_selection2Index, m_selection2Index);
     if(m_selection3Index.isValid()) emit dataChanged(m_selection3Index, m_selection3Index);
     emit mWindow->updateAvailabilities();
 }
 
 //TODO
 //void DirMergeItem::init(MergeFileInfos* pMFI)
 //{
 //   pMFI->m_pDMI = this; //no not here
 //   m_pMFI = pMFI;
 //   TotalDiffStatus& tds = pMFI->m_totalDiffStatus;
 //   if ( m_pMFI->dirA() || m_pMFI->dirB() || m_pMFI->isDirC() )
 //   {
 //   }
 //   else
 //   {
 //      setText( s_UnsolvedCol, QString::number( tds.getUnsolvedConflicts() ) );
 //      setText( s_SolvedCol,   QString::number( tds.getSolvedConflicts() ) );
 //      setText( s_NonWhiteCol, QString::number( tds.getUnsolvedConflicts() + tds.getSolvedConflicts() - tds.getWhitespaceConflicts() ) );
 //      setText( s_WhiteCol,    QString::number( tds.getWhitespaceConflicts() ) );
 //   }
 //   setSizeHint( s_ACol, QSize(17,17) ); // Iconsize
 //   setSizeHint( s_BCol, QSize(17,17) ); // Iconsize
 //   setSizeHint( s_CCol, QSize(17,17) ); // Iconsize
 //}
 
 void DirectoryMergeWindow::DirectoryMergeWindowPrivate::sort(int column, Qt::SortOrder order)
 {
     Q_UNUSED(column);
     beginResetModel();
     m_pRoot->sort(order);
     endResetModel();
 }
 
 void DirectoryMergeWindow::DirectoryMergeWindowPrivate::setMergeOperation(const QModelIndex& mi, e_MergeOperation eMergeOp, bool bRecursive)
 {
     MergeFileInfos* pMFI = getMFI(mi);
     if(pMFI == nullptr)
         return;
 
     if(eMergeOp != pMFI->getOperation())
     {
         pMFI->startOperation();
         setOpStatus(mi, eOpStatusNone);
     }
 
     pMFI->setOperation(eMergeOp);
     if(bRecursive)
     {
         e_MergeOperation eChildrenMergeOp = pMFI->getOperation();
         if(eChildrenMergeOp == eConflictingFileTypes) eChildrenMergeOp = eMergeABCToDest;
         for(int childIdx = 0; childIdx < pMFI->children().count(); ++childIdx)
         {
             calcSuggestedOperation(index(childIdx, 0, mi), eChildrenMergeOp);
         }
     }
 }
 
 void DirectoryMergeWindow::compareCurrentFile()
 {
     if(!d->canContinue()) return;
 
     if(d->m_bRealMergeStarted)
     {
         KMessageBox::sorry(this, i18n("This operation is currently not possible."), i18n("Operation Not Possible"));
         return;
     }
 
     if(MergeFileInfos* pMFI = d->getMFI(currentIndex()))
     {
         if(!(pMFI->hasDir()))
         {
             emit startDiffMerge(
                 pMFI->existsInA() ? pMFI->getFileInfoA()->absoluteFilePath() : QString(""),
                 pMFI->existsInB() ? pMFI->getFileInfoB()->absoluteFilePath() : QString(""),
                 pMFI->existsInC() ? pMFI->getFileInfoC()->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->hasDir() || pMFI->conflictingFileTypes());
     }
     return false;
 }
 
 void DirectoryMergeWindow::mergeResultSaved(const QString& fileName)
 {
     QModelIndex mi = (d->m_mergeItemList.empty() || d->m_currentIndexForOperation == d->m_mergeItemList.end())
                          ? QModelIndex()
                          : *d->m_currentIndexForOperation;
 
     MergeFileInfos* pMFI = d->getMFI(mi);
     if(pMFI == nullptr)
     {
         // This can happen if the same file is saved and modified and saved again. Nothing to do then.
         return;
     }
     if(fileName == pMFI->fullNameDest())
     {
         if(pMFI->getOperation() == eMergeToAB)
         {
             bool bSuccess = d->copyFLD(pMFI->fullNameB(), pMFI->fullNameA());
             if(!bSuccess)
             {
                 KMessageBox::error(this, i18n("An error occurred while copying."));
                 d->m_pStatusInfo->setWindowTitle(i18n("Merge Error"));
                 d->m_pStatusInfo->exec();
                 //if ( m_pStatusInfo->firstChild()!=0 )
                 //   m_pStatusInfo->ensureItemVisible( m_pStatusInfo->last() );
                 d->m_bError = true;
                 d->setOpStatus(mi, eOpStatusError);
                 pMFI->setOperation(eCopyBToA);
                 return;
             }
         }
         d->setOpStatus(mi, eOpStatusDone);
         pMFI->endOperation();
         if(d->m_mergeItemList.size() == 1)
         {
             d->m_mergeItemList.clear();
             d->m_bRealMergeStarted = false;
         }
     }
 
     emit updateAvailabilities();
 }
 
 bool DirectoryMergeWindow::DirectoryMergeWindowPrivate::canContinue()
 {
     bool bCanContinue = false;
 
     emit mWindow->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->isOperationRunning())
         {
             setOpStatus(mi, eOpStatusNotSaved);
             pMFI->endOperation();
             if(m_mergeItemList.size() == 1)
             {
                 m_mergeItemList.clear();
                 m_bRealMergeStarted = false;
             }
         }
     }
     return bCanContinue;
 }
 
 bool DirectoryMergeWindow::DirectoryMergeWindowPrivate::executeMergeOperation(MergeFileInfos& mfi, bool& bSingleFileMerge)
 {
     bool bCreateBackups = m_pOptions->m_bDmCreateBakFiles;
     // First decide destname
     QString destName;
     switch(mfi.getOperation())
     {
         case eNoOperation:
         case eDeleteAB:
             break;
         case eMergeToAB: // let the user save in B. In mergeResultSaved() the file will be copied to A.
         case eMergeToB:
         case eDeleteB:
         case eCopyAToB:
             destName = mfi.fullNameB();
             break;
         case eMergeToA:
         case eDeleteA:
         case eCopyBToA:
             destName = mfi.fullNameA();
             break;
         case eMergeABToDest:
         case eMergeABCToDest:
         case eCopyAToDest:
         case eCopyBToDest:
         case eCopyCToDest:
         case eDeleteFromDest:
             destName = mfi.fullNameDest();
             break;
         default:
             KMessageBox::error(mWindow, i18n("Unknown merge operation. (This must never happen!)"));
     }
 
     bool bSuccess = false;
     bSingleFileMerge = false;
     switch(mfi.getOperation())
     {
         case eNoOperation:
             bSuccess = true;
             break;
         case eCopyAToDest:
         case eCopyAToB:
             bSuccess = copyFLD(mfi.fullNameA(), destName);
             break;
         case eCopyBToDest:
         case eCopyBToA:
             bSuccess = copyFLD(mfi.fullNameB(), destName);
             break;
         case eCopyCToDest:
             bSuccess = copyFLD(mfi.fullNameC(), destName);
             break;
         case eDeleteFromDest:
         case eDeleteA:
         case eDeleteB:
             bSuccess = deleteFLD(destName, bCreateBackups);
             break;
         case eDeleteAB:
             bSuccess = deleteFLD(mfi.fullNameA(), bCreateBackups) &&
                        deleteFLD(mfi.fullNameB(), bCreateBackups);
             break;
         case eMergeABToDest:
         case eMergeToA:
         case eMergeToAB:
         case eMergeToB:
             bSuccess = mergeFLD(mfi.fullNameA(), mfi.fullNameB(), "",
                                 destName, bSingleFileMerge);
             break;
         case eMergeABCToDest:
             bSuccess = mergeFLD(
                 mfi.existsInA() ? mfi.fullNameA() : QString(""),
                 mfi.existsInB() ? mfi.fullNameB() : QString(""),
                 mfi.existsInC() ? mfi.fullNameC() : QString(""),
                 destName, bSingleFileMerge);
             break;
         default:
             KMessageBox::error(mWindow, i18n("Unknown merge operation."));
     }
 
     return bSuccess;
 }
 
 // Check if the merge can start, and prepare the m_mergeItemList which then contains all
 // items that must be merged.
 void DirectoryMergeWindow::DirectoryMergeWindowPrivate::prepareMergeStart(const QModelIndex& miBegin, const QModelIndex& miEnd, bool bVerbose)
 {
     if(bVerbose)
     {
         int status = KMessageBox::warningYesNoCancel(mWindow,
                                                      i18n("The merge is about to begin.\n\n"
                                                           "Choose \"Do it\" if you have read the instructions and know what you are doing.\n"
                                                           "Choosing \"Simulate it\" will tell you what would happen.\n\n"
                                                           "Be aware that this program still has beta status "
                                                           "and there is NO WARRANTY whatsoever! Make backups of your vital data!"),
                                                      i18n("Starting Merge"),
                                                      KGuiItem(i18n("Do It")),
                                                      KGuiItem(i18n("Simulate It")));
         if(status == KMessageBox::Yes)
             m_bRealMergeStarted = true;
         else if(status == KMessageBox::No)
             m_bSimulatedMergeStarted = true;
         else
             return;
     }
     else
     {
         m_bRealMergeStarted = true;
     }
 
     m_mergeItemList.clear();
     if(!miBegin.isValid())
         return;
 
     for(QModelIndex mi = miBegin; mi != miEnd; mi = treeIterator(mi))
     {
         MergeFileInfos* pMFI = getMFI(mi);
         if(pMFI && pMFI->isOperationRunning())
         {
             m_mergeItemList.push_back(mi);
             QString errorText;
             if(pMFI->getOperation() == eConflictingFileTypes)
             {
                 errorText = i18n("The highlighted item has a different type in the different directories. Select what to do.");
             }
             if(pMFI->getOperation() == eConflictingAges)
             {
                 errorText = i18n("The modification dates of the file are equal but the files are not. Select what to do.");
             }
             if(pMFI->getOperation() == eChangedAndDeleted)
             {
                 errorText = i18n("The highlighted item was changed in one directory and deleted in the other. Select what to do.");
             }
             if(!errorText.isEmpty())
             {
                 mWindow->scrollTo(mi, QAbstractItemView::EnsureVisible);
                 mWindow->setCurrentIndex(mi);
                 KMessageBox::error(mWindow, errorText);
                 m_mergeItemList.clear();
                 m_bRealMergeStarted = false;
                 return;
             }
         }
     }
 
     m_currentIndexForOperation = m_mergeItemList.begin();
 }
 
 void DirectoryMergeWindow::slotRunOperationForCurrentItem()
 {
     if(!d->canContinue()) return;
 
     bool bVerbose = false;
     if(d->m_mergeItemList.empty())
     {
         QModelIndex miBegin = currentIndex();
         QModelIndex miEnd = d->treeIterator(miBegin, false, false); // find next visible sibling (no children)
 
         d->prepareMergeStart(miBegin, miEnd, bVerbose);
         d->mergeContinue(true, bVerbose);
     }
     else
         d->mergeContinue(false, bVerbose);
 }
 
 void DirectoryMergeWindow::slotRunOperationForAllItems()
 {
     if(!d->canContinue()) return;
 
     bool bVerbose = true;
     if(d->m_mergeItemList.empty())
     {
         QModelIndex miBegin = d->rowCount() > 0 ? d->index(0, 0, QModelIndex()) : QModelIndex();
 
         d->prepareMergeStart(miBegin, QModelIndex(), bVerbose);
         d->mergeContinue(true, bVerbose);
     }
     else
         d->mergeContinue(false, bVerbose);
 }
 
 void DirectoryMergeWindow::mergeCurrentFile()
 {
     if(!d->canContinue()) return;
 
     if(d->m_bRealMergeStarted)
     {
         KMessageBox::sorry(this, i18n("This operation is currently not possible because directory merge is currently running."), i18n("Operation Not Possible"));
         return;
     }
 
     if(isFileSelected())
     {
         MergeFileInfos* pMFI = d->getMFI(currentIndex());
         if(pMFI != nullptr)
         {
             d->m_mergeItemList.clear();
             d->m_mergeItemList.push_back(currentIndex());
             d->m_currentIndexForOperation = d->m_mergeItemList.begin();
             bool bDummy = false;
             d->mergeFLD(
                 pMFI->existsInA() ? pMFI->getFileInfoA()->absoluteFilePath() : QString(""),
                 pMFI->existsInB() ? pMFI->getFileInfoB()->absoluteFilePath() : QString(""),
                 pMFI->existsInC() ? pMFI->getFileInfoC()->absoluteFilePath() : QString(""),
                 pMFI->fullNameDest(),
                 bDummy);
         }
     }
     emit updateAvailabilities();
 }
 
 // When bStart is true then m_currentIndexForOperation must still be processed.
 // When bVerbose is true then a messagebox will tell when the merge is complete.
 void DirectoryMergeWindow::DirectoryMergeWindowPrivate::mergeContinue(bool bStart, bool bVerbose)
 {
     ProgressProxy pp;
     if(m_mergeItemList.empty())
         return;
 
     int nrOfItems = 0;
     int nrOfCompletedItems = 0;
     int nrOfCompletedSimItems = 0;
 
     // Count the number of completed items (for the progress bar).
     for(MergeItemList::iterator i = m_mergeItemList.begin(); i != m_mergeItemList.end(); ++i)
     {
         MergeFileInfos* pMFI = getMFI(*i);
         ++nrOfItems;
         if(!pMFI->isOperationRunning())
             ++nrOfCompletedItems;
         if(!pMFI->isSimOpRunning())
             ++nrOfCompletedSimItems;
     }
 
     m_pStatusInfo->hide();
     m_pStatusInfo->clear();
 
     QModelIndex miCurrent = m_currentIndexForOperation == m_mergeItemList.end() ? QModelIndex() : *m_currentIndexForOperation;
 
     bool bContinueWithCurrentItem = bStart; // true for first item, else false
     bool bSkipItem = false;
     if(!bStart && m_bError && miCurrent.isValid())
     {
         int status = KMessageBox::warningYesNoCancel(mWindow,
                                                      i18n("There was an error in the last step.\n"
                                                           "Do you want to continue with the item that caused the error or do you want to skip this item?"),
                                                      i18n("Continue merge after an error"),
                                                      KGuiItem(i18n("Continue With Last Item")),
                                                      KGuiItem(i18n("Skip Item")));
         if(status == KMessageBox::Yes)
             bContinueWithCurrentItem = true;
         else if(status == KMessageBox::No)
             bSkipItem = true;
         else
             return;
         m_bError = false;
     }
 
     pp.setMaxNofSteps(nrOfItems);
 
     bool bSuccess = true;
     bool bSingleFileMerge = false;
     bool bSim = m_bSimulatedMergeStarted;
     while(bSuccess)
     {
         MergeFileInfos* pMFI = getMFI(miCurrent);
         if(pMFI == nullptr)
         {
             m_mergeItemList.clear();
             m_bRealMergeStarted = false;
             break;
         }
 
         if(pMFI != nullptr && !bContinueWithCurrentItem)
         {
             if(bSim)
             {
                 if(rowCount(miCurrent) == 0)
                 {
                     pMFI->endSimOp();
                 }
             }
             else
             {
                 if(rowCount(miCurrent) == 0)
                 {
                     if(pMFI->isOperationRunning())
                     {
                         setOpStatus(miCurrent, bSkipItem ? eOpStatusSkipped : eOpStatusDone);
                         pMFI->endOperation();
                         bSkipItem = false;
                     }
                 }
                 else
                 {
                     setOpStatus(miCurrent, eOpStatusInProgress);
                 }
             }
         }
 
         if(!bContinueWithCurrentItem)
         {
             // Depth first
             QModelIndex miPrev = miCurrent;
             ++m_currentIndexForOperation;
             miCurrent = m_currentIndexForOperation == m_mergeItemList.end() ? QModelIndex() : *m_currentIndexForOperation;
             if((!miCurrent.isValid() || miCurrent.parent() != miPrev.parent()) && miPrev.parent().isValid())
             {
                 // Check if the parent may be set to "Done"
                 QModelIndex miParent = miPrev.parent();
                 bool bDone = true;
                 while(bDone && miParent.isValid())
                 {
                     for(int childIdx = 0; childIdx < rowCount(miParent); ++childIdx)
                     {
                         pMFI = getMFI(index(childIdx, 0, miParent));
                         if((!bSim && pMFI->isOperationRunning()) || (bSim && !pMFI->isSimOpRunning()))
                         {
                             bDone = false;
                             break;
                         }
                     }
                     if(bDone)
                     {
                         pMFI = getMFI(miParent);
                         if(bSim)
                             pMFI->endSimOp();
                         else
                         {
                             setOpStatus(miParent, eOpStatusDone);
                             pMFI->endOperation();
                         }
                     }
                     miParent = miParent.parent();
                 }
             }
         }
 
         if(!miCurrent.isValid()) // end?
         {
             if(m_bRealMergeStarted)
             {
                 if(bVerbose)
                 {
                     KMessageBox::information(mWindow, i18n("Merge operation complete."), i18n("Merge Complete"));
                 }
                 m_bRealMergeStarted = false;
                 m_pStatusInfo->setWindowTitle(i18n("Merge Complete"));
             }
             if(m_bSimulatedMergeStarted)
             {
                 m_bSimulatedMergeStarted = false;
                 QModelIndex mi = rowCount() > 0 ? index(0, 0, QModelIndex()) : QModelIndex();
                 for(; mi.isValid(); mi = treeIterator(mi))
                 {
                     getMFI(mi)->startSimOp();
                 }
                 m_pStatusInfo->setWindowTitle(i18n("Simulated merge complete: Check if you agree with the proposed operations."));
                 m_pStatusInfo->exec();
             }
             m_mergeItemList.clear();
             m_bRealMergeStarted = false;
             return;
         }
 
         pMFI = getMFI(miCurrent);
 
         pp.setInformation(pMFI->subPath(),
                           bSim ? nrOfCompletedSimItems : nrOfCompletedItems,
                           false // bRedrawUpdate
         );
 
         bSuccess = executeMergeOperation(*pMFI, bSingleFileMerge); // Here the real operation happens.
 
         if(bSuccess)
         {
             if(bSim)
                 ++nrOfCompletedSimItems;
             else
                 ++nrOfCompletedItems;
             bContinueWithCurrentItem = false;
         }
 
         if(pp.wasCancelled())
             break;
     } // end while
 
     //g_pProgressDialog->hide();
 
     mWindow->setCurrentIndex(miCurrent);
     mWindow->scrollTo(miCurrent, EnsureVisible);
     if(!bSuccess && !bSingleFileMerge)
     {
         KMessageBox::error(mWindow, i18n("An error occurred. Press OK to see detailed information."));
         m_pStatusInfo->setWindowTitle(i18n("Merge Error"));
         m_pStatusInfo->exec();
         //if ( m_pStatusInfo->firstChild()!=0 )
         //   m_pStatusInfo->ensureItemVisible( m_pStatusInfo->last() );
         m_bError = true;
 
         setOpStatus(miCurrent, eOpStatusError);
     }
     else
     {
         m_bError = false;
     }
     emit mWindow->updateAvailabilities();
 
     if(m_currentIndexForOperation == m_mergeItemList.end())
     {
         m_mergeItemList.clear();
         m_bRealMergeStarted = false;
     }
 }
 
 bool DirectoryMergeWindow::DirectoryMergeWindowPrivate::deleteFLD(const QString& name, bool bCreateBackup)
 {
     FileAccess fi(name, true);
     if(!fi.exists())
         return true;
 
     if(bCreateBackup)
     {
         bool bSuccess = renameFLD(name, name + ".orig");
         if(!bSuccess)
         {
             m_pStatusInfo->addText(i18n("Error: While deleting %1: Creating backup failed.", name));
             return false;
         }
     }
     else
     {
         if(fi.isDir() && !fi.isSymLink())
             m_pStatusInfo->addText(i18n("delete 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;
                 Q_ASSERT(fi2.fileName() != "." && fi2.fileName() != "..");
 
                 bSuccess = deleteFLD(fi2.absoluteFilePath(), false);
                 if(!bSuccess) break;
             }
             if(bSuccess)
             {
                 bSuccess = FileAccess::removeDir(name);
                 if(!bSuccess)
                 {
                     m_pStatusInfo->addText(i18n("Error: rmdir( %1 ) operation failed.", name)); // krazy:exclude=syscalls
                     return false;
                 }
             }
         }
         else
         {
             bool bSuccess = fi.removeFile();
             if(!bSuccess)
             {
                 m_pStatusInfo->addText(i18n("Error: delete operation failed."));
                 return false;
             }
         }
     }
     return true;
 }
 
 bool DirectoryMergeWindow::DirectoryMergeWindowPrivate::mergeFLD(const QString& nameA, const QString& nameB, const QString& nameC, const QString& nameDest, bool& bSingleFileMerge)
 {
     FileAccess fi(nameA);
     if(fi.isDir())
     {
         return makeDir(nameDest);
     }
 
     // Make sure that the dir exists, into which we will save the file later.
     int pos = nameDest.lastIndexOf('/');
     if(pos > 0)
     {
         QString parentName = nameDest.left(pos);
         bool bSuccess = makeDir(parentName, true /*quiet*/);
         if(!bSuccess)
             return false;
     }
 
     m_pStatusInfo->addText(i18n("manual merge( %1, %2, %3 -> %4)", nameA, nameB, nameC, nameDest));
     if(m_bSimulatedMergeStarted)
     {
         m_pStatusInfo->addText(i18n("     Note: After a manual merge the user should continue by pressing F7."));
         return true;
     }
 
     bSingleFileMerge = true;
     setOpStatus(*m_currentIndexForOperation, eOpStatusInProgress);
     mWindow->scrollTo(*m_currentIndexForOperation, EnsureVisible);
 
     emit mWindow->startDiffMerge(nameA, nameB, nameC, nameDest, "", "", "", nullptr);
 
     return false;
 }
 
 bool DirectoryMergeWindow::DirectoryMergeWindowPrivate::copyFLD(const QString& srcName, const QString& destName)
 {
     bool bSuccess = false;
 
     if(srcName == destName)
         return true;
 
     FileAccess fi(srcName);
     FileAccess faDest(destName, true);
     if(faDest.exists() && !(fi.isDir() && faDest.isDir() && (fi.isSymLink() == faDest.isSymLink())))
     {
         bSuccess = deleteFLD(destName, m_pOptions->m_bDmCreateBakFiles);
         if(!bSuccess)
         {
             m_pStatusInfo->addText(i18n("Error: copy( %1 -> %2 ) failed."
                                         "Deleting existing destination failed.",
                                         srcName, destName));
             return bSuccess;
         }
     }
 
     if(fi.isSymLink() && ((fi.isDir() && !m_bFollowDirLinks) || (!fi.isDir() && !m_bFollowFileLinks)))
     {
         m_pStatusInfo->addText(i18n("copyLink( %1 -> %2 )", srcName, destName));
 
         if(m_bSimulatedMergeStarted)
         {
             return true;
         }
         FileAccess destFi(destName);
         if(!destFi.isLocal() || !fi.isLocal())
         {
             m_pStatusInfo->addText(i18n("Error: copyLink failed: Remote links are not yet supported."));
             return false;
         }
 
         bSuccess = false;
         QString linkTarget = fi.readLink();
         if(!linkTarget.isEmpty())
         {
             bSuccess = FileAccess::symLink(linkTarget, destName);
             if(!bSuccess)
                 m_pStatusInfo->addText(i18n("Error: copyLink failed."));
         }
         return bSuccess;
     }
 
     if(fi.isDir())
     {
         if(faDest.exists())
             return true;
         else
         {
             bSuccess = makeDir(destName);
             return bSuccess;
         }
     }
 
     int pos = destName.lastIndexOf('/');
     if(pos > 0)
     {
         QString parentName = destName.left(pos);
         bSuccess = makeDir(parentName, true /*quiet*/);
         if(!bSuccess)
             return false;
     }
 
     m_pStatusInfo->addText(i18n("copy( %1 -> %2 )", srcName, destName));
 
     if(m_bSimulatedMergeStarted)
     {
         return true;
     }
 
     FileAccess faSrc(srcName);
     bSuccess = faSrc.copyFile(destName);
     if(!bSuccess) m_pStatusInfo->addText(faSrc.getStatusText());
     return bSuccess;
 }
 
 // Rename is not an operation that can be selected by the user.
 // It will only be used to create backups.
 // Hence it will delete an existing destination without making a backup (of the old backup.)
 bool DirectoryMergeWindow::DirectoryMergeWindowPrivate::renameFLD(const QString& srcName, const QString& destName)
 {
     if(srcName == destName)
         return true;
     FileAccess destFile = FileAccess(destName, true);
     if(destFile.exists())
     {
         bool bSuccess = deleteFLD(destName, false /*no backup*/);
         if(!bSuccess)
         {
             m_pStatusInfo->addText(i18n("Error during rename( %1 -> %2 ): "
                                         "Cannot delete existing destination.",
                                         srcName, destName));
             return false;
         }
     }
 
     m_pStatusInfo->addText(i18n("rename( %1 -> %2 )", srcName, destName));
     if(m_bSimulatedMergeStarted)
     {
         return true;
     }
 
     bool bSuccess = FileAccess(srcName).rename(destFile);
     if(!bSuccess)
     {
         m_pStatusInfo->addText(i18n("Error: Rename failed."));
         return false;
     }
 
     return true;
 }
 
 bool DirectoryMergeWindow::DirectoryMergeWindowPrivate::makeDir(const QString& name, bool bQuiet)
 {
     FileAccess fi(name, true);
     if(fi.exists() && fi.isDir())
         return true;
 
     if(fi.exists() && !fi.isDir())
     {
         bool bSuccess = deleteFLD(name, true);
         if(!bSuccess)
         {
             m_pStatusInfo->addText(i18n("Error during makeDir of %1. "
                                         "Cannot delete existing file.",
                                         name));
             return false;
         }
     }
 
     int pos = name.lastIndexOf('/');
     if(pos > 0)
     {
         QString parentName = name.left(pos);
         bool bSuccess = makeDir(parentName, true);
         if(!bSuccess)
             return false;
     }
 
     if(!bQuiet)
         m_pStatusInfo->addText(i18n("makeDir( %1 )", name));
 
     if(m_bSimulatedMergeStarted)
     {
         return true;
     }
 
     bool bSuccess = FileAccess::makeDir(name);
     if(!bSuccess)
     {
         m_pStatusInfo->addText(i18n("Error while creating 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(i18n("A"), this);
     grid->addWidget(m_pA, line, 0);
     m_pInfoA = new QLabel(this);
     grid->addWidget(m_pInfoA, line, 1);
     ++line;
 
     m_pB = new QLabel(i18n("B"), this);
     grid->addWidget(m_pB, line, 0);
     m_pInfoB = new QLabel(this);
     grid->addWidget(m_pInfoB, line, 1);
     ++line;
 
     m_pC = new QLabel(i18n("C"), this);
     grid->addWidget(m_pC, line, 0);
     m_pInfoC = new QLabel(this);
     grid->addWidget(m_pInfoC, line, 1);
     ++line;
 
     m_pDest = new QLabel(i18n("Dest"), this);
     grid->addWidget(m_pDest, line, 0);
     m_pInfoDest = new QLabel(this);
     grid->addWidget(m_pInfoDest, line, 1);
     ++line;
 
     m_pInfoList = new QTreeWidget(this);
     topLayout->addWidget(m_pInfoList);
     m_pInfoList->setHeaderLabels(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;
 }
 
 void DirectoryMergeInfo::addListViewItem(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");
-            //TODO: Move logic to FileAccess
+            
             m_pInfoList->addTopLevelItem(new QTreeWidgetItem(
                 m_pInfoList,
                 QStringList() << dir << QString(fi->isDir() ? i18n("Dir") : i18n("File")) + (fi->isSymLink() ? i18n("-Link") : "") << QString::number(fi->size()) << QLatin1String(fi->isReadable() ? "r" : " ") + QLatin1String(fi->isWritable() ? "w" : " ") + QLatin1String((fi->isExecutable() ? "x" : " ")) << dateString << QString(fi->isSymLink() ? (" -> " + fi->readLink()) : QString(""))));
         }
         else
         {
             m_pInfoList->addTopLevelItem(new QTreeWidgetItem(
                 m_pInfoList,
                 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() ? i18n("A:    ") : i18n("A (Base): "));
 
     m_pInfoA->setText(dirA.prettyAbsPath());
 
     if(dirB.absoluteFilePath() == dirDest.absoluteFilePath())
     {
         m_pB->setText(i18n("B (Dest): "));
         bHideDest = true;
     }
     else
         m_pB->setText(i18n("B:    "));
     m_pInfoB->setText(dirB.prettyAbsPath());
 
     if(dirC.absoluteFilePath() == dirDest.absoluteFilePath())
     {
         m_pC->setText(i18n("C (Dest): "));
         bHideDest = true;
     }
     else
         m_pC->setText(i18n("C:    "));
     m_pInfoC->setText(dirC.prettyAbsPath());
 
     m_pDest->setText(i18n("Dest: "));
     m_pInfoDest->setText(dirDest.prettyAbsPath());
 
     if(!dirC.isValid())
     {
         m_pC->hide();
         m_pInfoC->hide();
     }
     else
     {
         m_pC->show();
         m_pInfoC->show();
     }
 
     if(!dirDest.isValid() || bHideDest)
     {
         m_pDest->hide();
         m_pInfoDest->hide();
     }
     else
     {
         m_pDest->show();
         m_pInfoDest->show();
     }
 
     m_pInfoList->clear();
     addListViewItem(i18n("A"), dirA.prettyAbsPath(), mfi.getFileInfoA());
     addListViewItem(i18n("B"), dirB.prettyAbsPath(), mfi.getFileInfoB());
     addListViewItem(i18n("C"), dirC.prettyAbsPath(), mfi.getFileInfoC());
     if(!bHideDest)
     {
         FileAccess fiDest(dirDest.prettyAbsPath() + '/' + mfi.subPath(), true);
         addListViewItem(i18n("Dest"), dirDest.prettyAbsPath(), &fiDest);
     }
     for(int i = 0; i < m_pInfoList->columnCount(); ++i)
         m_pInfoList->resizeColumnToContents(i);
 }
 
 
 
 void DirectoryMergeWindow::slotSaveMergeState()
 {
     //slotStatusMsg(i18n("Saving Directory Merge State ..."));
 
     QString dirMergeStateFilename = QFileDialog::getSaveFileName(this, i18n("Save Directory Merge State As..."), QDir::currentPath());
     if(!dirMergeStateFilename.isEmpty())
     {
         QFile file(dirMergeStateFilename);
         bool bSuccess = file.open(QIODevice::WriteOnly);
         if(bSuccess)
         {
             QTextStream ts(&file);
 
             QModelIndex mi(d->index(0, 0, QModelIndex()));
             while(mi.isValid())
             {
                 MergeFileInfos* pMFI = d->getMFI(mi);
                 ts << *pMFI;
                 mi = d->treeIterator(mi, true, true);
             }
         }
     }
 
     //slotStatusMsg(i18n("Ready."));
 }
 
 void DirectoryMergeWindow::slotLoadMergeState()
 {
 }
 
 void DirectoryMergeWindow::updateFileVisibilities()
 {
     bool bShowIdentical = d->m_pDirShowIdenticalFiles->isChecked();
     bool bShowDifferent = d->m_pDirShowDifferentFiles->isChecked();
     bool bShowOnlyInA = d->m_pDirShowFilesOnlyInA->isChecked();
     bool bShowOnlyInB = d->m_pDirShowFilesOnlyInB->isChecked();
     bool bShowOnlyInC = d->m_pDirShowFilesOnlyInC->isChecked();
     bool bThreeDirs = d->isThreeWay();
     d->m_selection1Index = QModelIndex();
     d->m_selection2Index = QModelIndex();
     d->m_selection3Index = QModelIndex();
 
     // in first run set all dirs to equal and determine if they are not equal.
     // on second run don't change the equal-status anymore; it is needed to
     // set the visibility (when bShowIdentical is false).
     for(int loop = 0; loop < 2; ++loop)
     {
         QModelIndex mi = d->rowCount() > 0 ? d->index(0, 0, QModelIndex()) : QModelIndex();
         while(mi.isValid())
         {
             MergeFileInfos* pMFI = d->getMFI(mi);
             bool bDir = pMFI->hasDir();
             if(loop == 0 && bDir)
             {
                 bool bChange = false;
                 if(!pMFI->isEqualAB() && pMFI->isDirA() == pMFI->isDirB() && pMFI->isLinkA() == pMFI->isLinkB())
                 {
                     pMFI->m_bEqualAB = true;
                     bChange = true;
                 }
                 if(!pMFI->isEqualBC() && pMFI->isDirC() == pMFI->isDirB() && pMFI->isLinkC() == pMFI->isLinkB())
                 {
                     pMFI->m_bEqualBC = true;
                     bChange = true;
                 }
                 if(!pMFI->isEqualAC() && pMFI->isDirA() == pMFI->isDirC() && pMFI->isLinkA() == pMFI->isLinkC())
                 {
                     pMFI->m_bEqualAC = true;
                     bChange = true;
                 }
 
                 if(bChange)
                     pMFI->updateAge();
             }
             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->isEqualAB() && (pMFI->isEqualAC() || !bThreeDirs)) || ((bShowDifferent || bDir) && existCount >= 2 && (!pMFI->isEqualAB() || !(pMFI->isEqualAC() || !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 && !Utils::wildcardMultiMatch(d->m_pOptions->m_DmDirAntiPattern, fileName, d->m_bCaseSensitive)) || (Utils::wildcardMultiMatch(d->m_pOptions->m_DmFilePattern, fileName, d->m_bCaseSensitive) && !Utils::wildcardMultiMatch(d->m_pOptions->m_DmFileAntiPattern, fileName, d->m_bCaseSensitive)));
 
             setRowHidden(mi.row(), mi.parent(), !bVisible);
 
             bool bEqual = bThreeDirs ? pMFI->isEqualAB() && pMFI->isEqualAC() : pMFI->isEqualAB();
             if(!bEqual && bVisible && loop == 0) // Set all parents to "not equal"
             {
                 MergeFileInfos* p2 = pMFI->parent();
                 while(p2 != nullptr)
                 {
                     bool bChange = false;
                     if(!pMFI->isEqualAB() && p2->isEqualAB())
                     {
                         p2->m_bEqualAB = false;
                         bChange = true;
                     }
                     if(!pMFI->isEqualAC() && p2->isEqualAC())
                     {
                         p2->m_bEqualAC = false;
                         bChange = true;
                     }
                     if(!pMFI->isEqualBC() && p2->isEqualBC())
                     {
                         p2->m_bEqualBC = false;
                         bChange = true;
                     }
 
                     if(bChange)
                         p2->updateAge();
                     else
                         break;
 
                     p2 = p2->parent();
                 }
             }
             mi = d->treeIterator(mi, true, true);
         }
     }
 }
 
 void DirectoryMergeWindow::slotShowIdenticalFiles()
 {
     d->m_pOptions->m_bDmShowIdenticalFiles = d->m_pDirShowIdenticalFiles->isChecked();
     updateFileVisibilities();
 }
 void DirectoryMergeWindow::slotShowDifferentFiles()
 {
     updateFileVisibilities();
 }
 void DirectoryMergeWindow::slotShowFilesOnlyInA()
 {
     updateFileVisibilities();
 }
 void DirectoryMergeWindow::slotShowFilesOnlyInB()
 {
     updateFileVisibilities();
 }
 void DirectoryMergeWindow::slotShowFilesOnlyInC()
 {
     updateFileVisibilities();
 }
 
 void DirectoryMergeWindow::slotSynchronizeDirectories() {}
 void DirectoryMergeWindow::slotChooseNewerFiles() {}
 
 void DirectoryMergeWindow::initDirectoryMergeActions(KDiff3App* pKDiff3App, KActionCollection* ac)
 {
 #include "xpm/showequalfiles.xpm"
 #include "xpm/showfilesonlyina.xpm"
 #include "xpm/showfilesonlyinb.xpm"
 #include "xpm/showfilesonlyinc.xpm"
 #include "xpm/startmerge.xpm"
 
     d->m_pDirStartOperation = GuiUtils::createAction<QAction>(i18n("Start/Continue Directory Merge"), QKeySequence(Qt::Key_F7), this, &DirectoryMergeWindow::slotRunOperationForAllItems, ac, "dir_start_operation");
     d->m_pDirRunOperationForCurrentItem = GuiUtils::createAction<QAction>(i18n("Run Operation for Current Item"), QKeySequence(Qt::Key_F6), this, &DirectoryMergeWindow::slotRunOperationForCurrentItem, ac, "dir_run_operation_for_current_item");
     d->m_pDirCompareCurrent = GuiUtils::createAction<QAction>(i18n("Compare Selected File"), this, &DirectoryMergeWindow::compareCurrentFile, ac, "dir_compare_current");
     d->m_pDirMergeCurrent = GuiUtils::createAction<QAction>(i18n("Merge Current File"), QIcon(QPixmap(startmerge)), i18n("Merge\nFile"), pKDiff3App, &KDiff3App::slotMergeCurrentFile, ac, "merge_current");
     d->m_pDirFoldAll = GuiUtils::createAction<QAction>(i18n("Fold All Subdirs"), this, &DirectoryMergeWindow::collapseAll, ac, "dir_fold_all");
     d->m_pDirUnfoldAll = GuiUtils::createAction<QAction>(i18n("Unfold All Subdirs"), this, &DirectoryMergeWindow::expandAll, ac, "dir_unfold_all");
     d->m_pDirRescan = GuiUtils::createAction<QAction>(i18n("Rescan"), QKeySequence(Qt::SHIFT + Qt::Key_F5), this, &DirectoryMergeWindow::reload, ac, "dir_rescan");
     d->m_pDirSaveMergeState = nullptr; //GuiUtils::createAction< QAction >(i18n("Save Directory Merge State ..."), 0, this, &DirectoryMergeWindow::slotSaveMergeState, ac, "dir_save_merge_state");
     d->m_pDirLoadMergeState = nullptr; //GuiUtils::createAction< QAction >(i18n("Load Directory Merge State ..."), 0, this, &DirectoryMergeWindow::slotLoadMergeState, ac, "dir_load_merge_state");
     d->m_pDirChooseAEverywhere = GuiUtils::createAction<QAction>(i18n("Choose A for All Items"), this, &DirectoryMergeWindow::slotChooseAEverywhere, ac, "dir_choose_a_everywhere");
     d->m_pDirChooseBEverywhere = GuiUtils::createAction<QAction>(i18n("Choose B for All Items"), this, &DirectoryMergeWindow::slotChooseBEverywhere, ac, "dir_choose_b_everywhere");
     d->m_pDirChooseCEverywhere = GuiUtils::createAction<QAction>(i18n("Choose C for All Items"), this, &DirectoryMergeWindow::slotChooseCEverywhere, ac, "dir_choose_c_everywhere");
     d->m_pDirAutoChoiceEverywhere = GuiUtils::createAction<QAction>(i18n("Auto-Choose Operation for All Items"), this, &DirectoryMergeWindow::slotAutoChooseEverywhere, ac, "dir_autochoose_everywhere");
     d->m_pDirDoNothingEverywhere = GuiUtils::createAction<QAction>(i18n("No Operation for All Items"), this, &DirectoryMergeWindow::slotNoOpEverywhere, ac, "dir_nothing_everywhere");
 
     //   d->m_pDirSynchronizeDirectories = GuiUtils::createAction< KToggleAction >(i18n("Synchronize Directories"), 0, this, &DirectoryMergeWindow::slotSynchronizeDirectories, ac, "dir_synchronize_directories");
     //   d->m_pDirChooseNewerFiles = GuiUtils::createAction< KToggleAction >(i18n("Copy Newer Files Instead of Merging"), 0, this, &DirectoryMergeWindow::slotChooseNewerFiles, ac, "dir_choose_newer_files");
 
     d->m_pDirShowIdenticalFiles = GuiUtils::createAction<KToggleAction>(i18n("Show Identical Files"), QIcon(QPixmap(showequalfiles)), i18n("Identical\nFiles"), this, &DirectoryMergeWindow::slotShowIdenticalFiles, ac, "dir_show_identical_files");
     d->m_pDirShowDifferentFiles = GuiUtils::createAction<KToggleAction>(i18n("Show Different Files"), this, &DirectoryMergeWindow::slotShowDifferentFiles, ac, "dir_show_different_files");
     d->m_pDirShowFilesOnlyInA = GuiUtils::createAction<KToggleAction>(i18n("Show Files only in A"), QIcon(QPixmap(showfilesonlyina)), i18n("Files\nonly in A"), this, &DirectoryMergeWindow::slotShowFilesOnlyInA, ac, "dir_show_files_only_in_a");
     d->m_pDirShowFilesOnlyInB = GuiUtils::createAction<KToggleAction>(i18n("Show Files only in B"), QIcon(QPixmap(showfilesonlyinb)), i18n("Files\nonly in B"), this, &DirectoryMergeWindow::slotShowFilesOnlyInB, ac, "dir_show_files_only_in_b");
     d->m_pDirShowFilesOnlyInC = GuiUtils::createAction<KToggleAction>(i18n("Show Files only in C"), QIcon(QPixmap(showfilesonlyinc)), i18n("Files\nonly in C"), this, &DirectoryMergeWindow::slotShowFilesOnlyInC, ac, "dir_show_files_only_in_c");
 
     d->m_pDirShowIdenticalFiles->setChecked(d->m_pOptions->m_bDmShowIdenticalFiles);
 
     d->m_pDirCompareExplicit = GuiUtils::createAction<QAction>(i18n("Compare Explicitly Selected Files"), this, &DirectoryMergeWindow::slotCompareExplicitlySelectedFiles, ac, "dir_compare_explicitly_selected_files");
     d->m_pDirMergeExplicit = GuiUtils::createAction<QAction>(i18n("Merge Explicitly Selected Files"), this, &DirectoryMergeWindow::slotMergeExplicitlySelectedFiles, ac, "dir_merge_explicitly_selected_files");
 
     d->m_pDirCurrentDoNothing = GuiUtils::createAction<QAction>(i18n("Do Nothing"), this, &DirectoryMergeWindow::slotCurrentDoNothing, ac, "dir_current_do_nothing");
     d->m_pDirCurrentChooseA = GuiUtils::createAction<QAction>(i18n("A"), this, &DirectoryMergeWindow::slotCurrentChooseA, ac, "dir_current_choose_a");
     d->m_pDirCurrentChooseB = GuiUtils::createAction<QAction>(i18n("B"), this, &DirectoryMergeWindow::slotCurrentChooseB, ac, "dir_current_choose_b");
     d->m_pDirCurrentChooseC = GuiUtils::createAction<QAction>(i18n("C"), this, &DirectoryMergeWindow::slotCurrentChooseC, ac, "dir_current_choose_c");
     d->m_pDirCurrentMerge = GuiUtils::createAction<QAction>(i18n("Merge"), this, &DirectoryMergeWindow::slotCurrentMerge, ac, "dir_current_merge");
     d->m_pDirCurrentDelete = GuiUtils::createAction<QAction>(i18n("Delete (if exists)"), this, &DirectoryMergeWindow::slotCurrentDelete, ac, "dir_current_delete");
 
     d->m_pDirCurrentSyncDoNothing = GuiUtils::createAction<QAction>(i18n("Do Nothing"), this, &DirectoryMergeWindow::slotCurrentDoNothing, ac, "dir_current_sync_do_nothing");
     d->m_pDirCurrentSyncCopyAToB = GuiUtils::createAction<QAction>(i18n("Copy A to B"), this, &DirectoryMergeWindow::slotCurrentCopyAToB, ac, "dir_current_sync_copy_a_to_b");
     d->m_pDirCurrentSyncCopyBToA = GuiUtils::createAction<QAction>(i18n("Copy B to A"), this, &DirectoryMergeWindow::slotCurrentCopyBToA, ac, "dir_current_sync_copy_b_to_a");
     d->m_pDirCurrentSyncDeleteA = GuiUtils::createAction<QAction>(i18n("Delete A"), this, &DirectoryMergeWindow::slotCurrentDeleteA, ac, "dir_current_sync_delete_a");
     d->m_pDirCurrentSyncDeleteB = GuiUtils::createAction<QAction>(i18n("Delete B"), this, &DirectoryMergeWindow::slotCurrentDeleteB, ac, "dir_current_sync_delete_b");
     d->m_pDirCurrentSyncDeleteAAndB = GuiUtils::createAction<QAction>(i18n("Delete A && B"), this, &DirectoryMergeWindow::slotCurrentDeleteAAndB, ac, "dir_current_sync_delete_a_and_b");
     d->m_pDirCurrentSyncMergeToA = GuiUtils::createAction<QAction>(i18n("Merge to A"), this, &DirectoryMergeWindow::slotCurrentMergeToA, ac, "dir_current_sync_merge_to_a");
     d->m_pDirCurrentSyncMergeToB = GuiUtils::createAction<QAction>(i18n("Merge to B"), this, &DirectoryMergeWindow::slotCurrentMergeToB, ac, "dir_current_sync_merge_to_b");
     d->m_pDirCurrentSyncMergeToAAndB = GuiUtils::createAction<QAction>(i18n("Merge to A && B"), this, &DirectoryMergeWindow::slotCurrentMergeToAAndB, ac, "dir_current_sync_merge_to_a_and_b");
 }
 
 void DirectoryMergeWindow::updateAvailabilities(bool bDirCompare, bool bDiffWindowVisible,
                                                 KToggleAction* chooseA, KToggleAction* chooseB, KToggleAction* chooseC)
 {
     d->m_pDirStartOperation->setEnabled(bDirCompare);
     d->m_pDirRunOperationForCurrentItem->setEnabled(bDirCompare);
     d->m_pDirFoldAll->setEnabled(bDirCompare);
     d->m_pDirUnfoldAll->setEnabled(bDirCompare);
 
     d->m_pDirCompareCurrent->setEnabled(bDirCompare && isVisible() && isFileSelected());
 
     d->m_pDirMergeCurrent->setEnabled((bDirCompare && isVisible() && isFileSelected()) || bDiffWindowVisible);
 
     d->m_pDirRescan->setEnabled(bDirCompare);
 
     bool bThreeDirs = d->isThreeWay();
     d->m_pDirAutoChoiceEverywhere->setEnabled(bDirCompare && isVisible());
     d->m_pDirDoNothingEverywhere->setEnabled(bDirCompare && isVisible());
     d->m_pDirChooseAEverywhere->setEnabled(bDirCompare && isVisible());
     d->m_pDirChooseBEverywhere->setEnabled(bDirCompare && isVisible());
     d->m_pDirChooseCEverywhere->setEnabled(bDirCompare && isVisible() && bThreeDirs);
 
 
     MergeFileInfos* pMFI = d->getMFI(currentIndex());
 
     bool bItemActive = bDirCompare && isVisible() && pMFI != nullptr; //  &&  hasFocus();
     bool bMergeMode = bThreeDirs || !d->m_bSyncMode;
     bool bFTConflict = pMFI == nullptr ? false : pMFI->conflictingFileTypes();
 
     bool bDirWindowHasFocus = isVisible() && hasFocus();
 
     d->m_pDirShowIdenticalFiles->setEnabled(bDirCompare && isVisible());
     d->m_pDirShowDifferentFiles->setEnabled(bDirCompare && isVisible());
     d->m_pDirShowFilesOnlyInA->setEnabled(bDirCompare && isVisible());
     d->m_pDirShowFilesOnlyInB->setEnabled(bDirCompare && isVisible());
     d->m_pDirShowFilesOnlyInC->setEnabled(bDirCompare && isVisible() && bThreeDirs);
 
     d->m_pDirCompareExplicit->setEnabled(bDirCompare && isVisible() && d->m_selection2Index.isValid());
     d->m_pDirMergeExplicit->setEnabled(bDirCompare && isVisible() && d->m_selection2Index.isValid());
 
     d->m_pDirCurrentDoNothing->setEnabled(bItemActive && bMergeMode);
     d->m_pDirCurrentChooseA->setEnabled(bItemActive && bMergeMode && pMFI->existsInA());
     d->m_pDirCurrentChooseB->setEnabled(bItemActive && bMergeMode && pMFI->existsInB());
     d->m_pDirCurrentChooseC->setEnabled(bItemActive && bMergeMode && pMFI->existsInC());
     d->m_pDirCurrentMerge->setEnabled(bItemActive && bMergeMode && !bFTConflict);
     d->m_pDirCurrentDelete->setEnabled(bItemActive && bMergeMode);
     if(bDirWindowHasFocus)
     {
         chooseA->setEnabled(bItemActive && pMFI->existsInA());
         chooseB->setEnabled(bItemActive && pMFI->existsInB());
         chooseC->setEnabled(bItemActive && pMFI->existsInC());
         chooseA->setChecked(false);
         chooseB->setChecked(false);
         chooseC->setChecked(false);
     }
 
     d->m_pDirCurrentSyncDoNothing->setEnabled(bItemActive && !bMergeMode);
     d->m_pDirCurrentSyncCopyAToB->setEnabled(bItemActive && !bMergeMode && pMFI->existsInA());
     d->m_pDirCurrentSyncCopyBToA->setEnabled(bItemActive && !bMergeMode && pMFI->existsInB());
     d->m_pDirCurrentSyncDeleteA->setEnabled(bItemActive && !bMergeMode && pMFI->existsInA());
     d->m_pDirCurrentSyncDeleteB->setEnabled(bItemActive && !bMergeMode && pMFI->existsInB());
     d->m_pDirCurrentSyncDeleteAAndB->setEnabled(bItemActive && !bMergeMode && pMFI->existsInA() && pMFI->existsInB());
     d->m_pDirCurrentSyncMergeToA->setEnabled(bItemActive && !bMergeMode && !bFTConflict);
     d->m_pDirCurrentSyncMergeToB->setEnabled(bItemActive && !bMergeMode && !bFTConflict);
     d->m_pDirCurrentSyncMergeToAAndB->setEnabled(bItemActive && !bMergeMode && !bFTConflict);
 }
 
 //#include "directorymergewindow.moc"
diff --git a/src/optiondialog.cpp b/src/optiondialog.cpp
index ff3e93f..6bfce9a 100644
--- a/src/optiondialog.cpp
+++ b/src/optiondialog.cpp
@@ -1,1629 +1,1562 @@
 /*
  *   kdiff3 - Text Diff And Merge Tool
  *   Copyright (C) 2002-2009  Joachim Eibl, joachim.eibl at gmx.de
  *   Copyright (C) 2018 Michael Reeves reeves.87@gmail.com
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
  *   the Free Software Foundation; either version 2 of the License, or
  *   (at your option) any later version.
  *
  *   This program is distributed in the hope that it will be useful,
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *   GNU General Public License for more details.
  *
  *   You should have received a copy of the GNU General Public License
  *   along with this program; if not, write to the Free Software
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  *
  */
 #include "optiondialog.h"
 #include "OptionItems.h"
 
 #include "common.h"
 #include "smalldialogs.h"
 
 #include <map>
 
 #include <KColorButton>
 #include <KHelpClient>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KToolBar>
 
 #include <QApplication>
 #include <QCheckBox>
 #include <QComboBox>
 #include <QDialogButtonBox>
 #include <QFontDatabase>
 #include <QFontDialog>
 #include <QFrame>
 #include <QGridLayout>
 #include <QGroupBox>
 #include <QLabel>
 #include <QLayout>
 #include <QLineEdit>
 #include <QPixmap>
 #include <QPlainTextEdit>
 #include <QPointer>
 #include <QPushButton>
 #include <QRadioButton>
 #include <QTextCodec>
 //#include <QToolTip>
 
 QString s_historyEntryStartRegExpToolTip;
 QString s_historyEntryStartSortKeyOrderToolTip;
 QString s_autoMergeRegExpToolTip;
 QString s_historyStartRegExpToolTip;
 
 class OptionCheckBox : public QCheckBox, public OptionBool
 {
   public:
     OptionCheckBox(const QString& text, bool bDefaultVal, const QString& saveName, bool* pbVar,
                    QWidget* pParent)
         : QCheckBox(text, pParent), OptionBool(pbVar, bDefaultVal, saveName)
     {}
     void setToDefault() override { setChecked(getDefault()); }
     void setToCurrent() override { setChecked(getCurrent()); }
 
     using OptionBool::apply;
     void apply() override { apply(isChecked()); }
 
   private:
     Q_DISABLE_COPY(OptionCheckBox)
 };
 
 class OptionRadioButton : public QRadioButton, public OptionBool
 {
   public:
     OptionRadioButton(const QString& text, bool bDefaultVal, const QString& saveName, bool* pbVar,
                       QWidget* pParent)
         : QRadioButton(text, pParent), OptionBool(pbVar, bDefaultVal, saveName)
     {}
     void setToDefault() override { setChecked(getDefault()); }
     void setToCurrent() override { setChecked(getCurrent()); }
 
     using OptionBool::apply;
     void apply() override { apply(isChecked()); }
 
   private:
     Q_DISABLE_COPY(OptionRadioButton)
 };
 
 FontChooser::FontChooser(QWidget* pParent)
     : QGroupBox(pParent)
 {
     QVBoxLayout* pLayout = new QVBoxLayout(this);
     m_pLabel = new QLabel(QString());
     pLayout->addWidget(m_pLabel);
 
     QChar visualTab(0x2192);
     QChar visualSpace((ushort)0xb7);
     m_pExampleTextEdit = new QPlainTextEdit(QString("The quick brown fox jumps over the river\n"
                                                     "but the little red hen escapes with a shiver.\n"
                                                     ":-)") +
                                                 visualTab + visualSpace,
                                             this);
     m_pExampleTextEdit->setFont(m_font);
     m_pExampleTextEdit->setReadOnly(true);
     pLayout->addWidget(m_pExampleTextEdit);
 
     m_pSelectFont = new QPushButton(i18n("Change Font"));
     m_pSelectFont->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
     connect(m_pSelectFont, &QPushButton::clicked, this, &FontChooser::slotSelectFont);
     pLayout->addWidget(m_pSelectFont);
     pLayout->setAlignment(m_pSelectFont, Qt::AlignRight);
 }
 
 QFont FontChooser::font()
 {
     return m_font; //QFont("courier",10);
 }
 
 void FontChooser::setFont(const QFont& font, bool)
 {
     m_font = font;
     m_pExampleTextEdit->setFont(m_font);
     m_pLabel->setText(i18n("Font: %1, %2, %3\n\nExample:", m_font.family(), m_font.styleName(), m_font.pointSize()));
 
     //update();
 }
 
 void FontChooser::slotSelectFont()
 {
     bool bOk;
     m_font = QFontDialog::getFont(&bOk, m_font);
     m_pExampleTextEdit->setFont(m_font);
     m_pLabel->setText(i18n("Font: %1, %2, %3\n\nExample:", m_font.family(), m_font.styleName(), m_font.pointSize()));
 }
 
 class OptionFontChooser : public FontChooser, public OptionFont
 {
   public:
     OptionFontChooser(const QFont& defaultVal, const QString& saveName, QFont* pVar, QWidget* pParent) : FontChooser(pParent),
                                                                                                                             OptionFont(pVar, defaultVal, saveName)
     {}
 
     void setToDefault() override { setFont(getDefault(), false); }
     void setToCurrent() override { setFont(getCurrent(), false); }
     using OptionFont::apply;
     void apply() override { apply(font()); }
   private:
     Q_DISABLE_COPY(OptionFontChooser)
 };
 
 class OptionColorButton : public KColorButton, public OptionColor
 {
   public:
     OptionColorButton(const QColor &defaultVal, const QString& saveName, QColor* pVar, QWidget* pParent)
         : KColorButton(pParent), OptionColor(pVar, defaultVal, saveName)
     {}
 
     void setToDefault() override { setColor(getDefault()); }
     void setToCurrent() override { setColor(getCurrent()); }
     using OptionColor::apply;
     void apply() override { apply(color()); }
 
   private:
     Q_DISABLE_COPY(OptionColorButton)
 };
 
 class OptionLineEdit : public QComboBox, public OptionString
 {
   public:
     OptionLineEdit(const QString& defaultVal, const QString& saveName, QString* pVar,
                    QWidget* pParent)
         : QComboBox(pParent), OptionString(pVar, defaultVal, saveName)
     {
         setMinimumWidth(50);
         setEditable(true);
         m_list.push_back(defaultVal);
         insertText();
     }
     void setToDefault() override
     {
         setEditText(getDefault());
     }
     void setToCurrent() override
     {
         setEditText(getCurrent());
     }
 
     using OptionString::apply;
     void apply() override
     {
         apply(currentText());
         insertText();
     }
     void write(ValueMap* config) override
     {
         config->writeEntry(m_saveName, m_list);
     }
     void read(ValueMap* config) override
     {
         m_list = config->readEntry(m_saveName, QStringList(m_defaultVal));
         if(!m_list.empty()) setCurrent(m_list.front());
         clear();
         insertItems(0, m_list);
     }
 
   private:
     void insertText()
     { // Check if the text exists. If yes remove it and push it in as first element
         QString current = currentText();
         m_list.removeAll(current);
         m_list.push_front(current);
         clear();
         if(m_list.size() > 10)
             m_list.erase(m_list.begin() + 10, m_list.end());
         insertItems(0, m_list);
     }
 
     Q_DISABLE_COPY(OptionLineEdit)
     QStringList m_list;
 };
 
 class OptionIntEdit : public QLineEdit, public OptionNum<int>
 {
   public:
     OptionIntEdit(int defaultVal, const QString& saveName, int* pVar, int rangeMin, int rangeMax,
                   QWidget* pParent)
         : QLineEdit(pParent), OptionNum<int>(pVar, defaultVal, saveName)
     {
         QIntValidator* v = new QIntValidator(this);
         v->setRange(rangeMin, rangeMax);
         setValidator(v);
     }
     void setToDefault() override
     {
         //QString::setNum does not account for locale settings
         setText(OptionNum::toString(getDefault()));
     }
 
     void setToCurrent() override
     {
         setText(getString());
     }
 
     using OptionNum<int>::apply;
     void apply() override
     {
         const QIntValidator* v = static_cast<const QIntValidator*>(validator());
         setCurrent( qBound(v->bottom(), text().toInt(), v->top()) );
 
         setText(getString());
     }
 
   private:
     Q_DISABLE_COPY(OptionIntEdit)
 };
 
 class OptionComboBox : public QComboBox, public OptionItemBase
 {
   public:
     OptionComboBox(int defaultVal, const QString& saveName, int* pVarNum,
                    QWidget* pParent)
         : QComboBox(pParent), OptionItemBase(saveName)
     {
         setMinimumWidth(50);
         m_pVarNum = pVarNum;
         m_pVarStr = nullptr;
         m_defaultVal = defaultVal;
         setEditable(false);
     }
     OptionComboBox(int defaultVal, const QString& saveName, QString* pVarStr,
                    QWidget* pParent)
         : QComboBox(pParent), OptionItemBase(saveName)
     {
         m_pVarNum = nullptr;
         m_pVarStr = pVarStr;
         m_defaultVal = defaultVal;
         setEditable(false);
     }
     void setToDefault() override
     {
         setCurrentIndex(m_defaultVal);
         if(m_pVarStr != nullptr) {
             *m_pVarStr = currentText();
         }
     }
     void setToCurrent() override
     {
         if(m_pVarNum != nullptr)
             setCurrentIndex(*m_pVarNum);
         else
             setText(*m_pVarStr);
     }
     using OptionItemBase::apply;
     void apply() override
     {
         if(m_pVarNum != nullptr) {
             *m_pVarNum = currentIndex();
         }
         else
         {
             *m_pVarStr = currentText();
         }
     }
     void write(ValueMap* config) override
     {
         if(m_pVarStr != nullptr)
             config->writeEntry(m_saveName, *m_pVarStr);
         else
             config->writeEntry(m_saveName, *m_pVarNum);
     }
     void read(ValueMap* config) override
     {
         if(m_pVarStr != nullptr)
             setText(config->readEntry(m_saveName, currentText()));
         else
             *m_pVarNum = config->readEntry(m_saveName, *m_pVarNum);
     }
     void preserve() override
     {
         if(m_pVarStr != nullptr) {
             m_preservedStrVal = *m_pVarStr;
         }
         else
         {
             m_preservedNumVal = *m_pVarNum;
         }
     }
     void unpreserve() override
     {
         if(m_pVarStr != nullptr) {
             *m_pVarStr = m_preservedStrVal;
         }
         else
         {
             *m_pVarNum = m_preservedNumVal;
         }
     }
 
   private:
     Q_DISABLE_COPY(OptionComboBox)
     int* m_pVarNum;
     int m_preservedNumVal = 0;
     QString* m_pVarStr;
     QString m_preservedStrVal;
     int m_defaultVal;
 
     void setText(const QString& s)
     {
         // Find the string in the combobox-list, don't change the value if nothing fits.
         for(int i = 0; i < count(); ++i)
         {
             if(itemText(i) == s)
             {
                 if(m_pVarNum != nullptr) *m_pVarNum = i;
                 if(m_pVarStr != nullptr) *m_pVarStr = s;
                 setCurrentIndex(i);
                 return;
             }
         }
     }
 };
 
 class OptionEncodingComboBox : public QComboBox, public OptionCodec
 {
     Q_OBJECT
     QVector<QTextCodec*> m_codecVec;
     QTextCodec** m_ppVarCodec;
 
   public:
     OptionEncodingComboBox(const QString& saveName, QTextCodec** ppVarCodec,
                            QWidget* pParent)
         : QComboBox(pParent), OptionCodec(saveName)
     {
         m_ppVarCodec = ppVarCodec;
         insertCodec(i18n("Unicode, 8 bit"), QTextCodec::codecForName("UTF-8"));
         insertCodec(i18n("Unicode"), QTextCodec::codecForName("iso-10646-UCS-2"));
         insertCodec(i18n("Latin1"), QTextCodec::codecForName("iso 8859-1"));
 
         // First sort codec names:
         std::map<QString, QTextCodec*> names;
         QList<int> mibs = QTextCodec::availableMibs();
         for(int i: mibs)
         {
             QTextCodec* c = QTextCodec::codecForMib(i);
             if(c != nullptr)
                 names[QString(QLatin1String(c->name())).toUpper()] = c;
         }
 
         std::map<QString, QTextCodec*>::iterator it;
         for(it = names.begin(); it != names.end(); ++it)
         {
             insertCodec("", it->second);
         }
 
         this->setToolTip(i18n(
             "Change this if non-ASCII characters are not displayed correctly."));
     }
     void insertCodec(const QString& visibleCodecName, QTextCodec* c)
     {
         if(c != nullptr)
         {
             QByteArray nameArray = c->name();
             QLatin1String codecName = QLatin1String(nameArray);
 
             for(int i = 0; i < m_codecVec.size(); ++i)
             {
                 if(c == m_codecVec[i])
                     return; // don't insert any codec twice
             }
 
             // The m_codecVec.size will at this point return the value we need for the index.
             if(codecName == defaultName())
                 saveDefaultIndex(m_codecVec.size());
             QString itemText = visibleCodecName.isEmpty() ? codecName : visibleCodecName + QLatin1String(" (") + codecName + QLatin1String(")");
             addItem(itemText, m_codecVec.size());
             m_codecVec.push_back(c);
         }
     }
     void setToDefault() override
     {
         int index = getDefaultIndex();
 
         setCurrentIndex(index);
         if(m_ppVarCodec != nullptr) {
             *m_ppVarCodec = m_codecVec[index];
         }
     }
     void setToCurrent() override
     {
         if(m_ppVarCodec != nullptr)
         {
             for(int i = 0; i < m_codecVec.size(); ++i)
             {
                 if(*m_ppVarCodec == m_codecVec[i])
                 {
                     setCurrentIndex(i);
                     break;
                 }
             }
         }
     }
     using OptionCodec::apply;
     void apply() override
     {
         if(m_ppVarCodec != nullptr) {
             *m_ppVarCodec = m_codecVec[currentIndex()];
         }
     }
     void write(ValueMap* config) override
     {
         if(m_ppVarCodec != nullptr) config->writeEntry(m_saveName, (const char*)(*m_ppVarCodec)->name());
     }
     void read(ValueMap* config) override
     {
         QString codecName = config->readEntry(m_saveName, (const char*)m_codecVec[currentIndex()]->name());
         for(int i = 0; i < m_codecVec.size(); ++i)
         {
             if(codecName == QLatin1String(m_codecVec[i]->name()))
             {
                 setCurrentIndex(i);
                 if(m_ppVarCodec != nullptr) *m_ppVarCodec = m_codecVec[i];
                 break;
             }
         }
     }
 
   protected:
     void preserve() override { m_preservedVal = currentIndex(); }
     void unpreserve() override { setCurrentIndex(m_preservedVal); }
     int m_preservedVal;
 };
 
 void OptionDialog::addOptionItem(OptionItemBase* p)
 {
     m_options->addOptionItem(p);
 }
 
 OptionDialog::OptionDialog(bool bShowDirMergeSettings, QWidget* parent) : KPageDialog(parent)
 {
     setFaceType(List);
     setWindowTitle(i18n("Configure"));
     setStandardButtons(QDialogButtonBox::Help | QDialogButtonBox::RestoreDefaults | QDialogButtonBox::Apply | QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
 
     setModal(true);
 
     //showButtonSeparator( true );
     //setHelp( "kdiff3/index.html", QString::null );
 
     m_options->init();
     setupFontPage();
     setupColorPage();
     setupEditPage();
     setupDiffPage();
     setupMergePage();
     setupOtherOptions();
     if(bShowDirMergeSettings)
         setupDirectoryMergePage();
 
     setupRegionalPage();
     setupIntegrationPage();
 
     //setupKeysPage();
 
     // Initialize all values in the dialog
     resetToDefaults();
     slotApply();
     connect(button(QDialogButtonBox::Apply), &QPushButton::clicked, this, &OptionDialog::slotApply);
     connect(button(QDialogButtonBox::Ok), &QPushButton::clicked, this, &OptionDialog::slotOk);
     connect(button(QDialogButtonBox::RestoreDefaults), &QPushButton::clicked, this, &OptionDialog::slotDefault);
     connect(button(QDialogButtonBox::Cancel), &QPushButton::clicked, this, &QDialog::reject);
     connect(button(QDialogButtonBox::Help), &QPushButton::clicked, this, &OptionDialog::helpRequested);
     //connect(this, &OptionDialog::applyClicked, this, &OptionDialog::slotApply);
     //helpClicked() is connected in KDiff3App::KDiff3App -- Really where?
     //connect(this, &OptionDialog::defaultClicked, this, &OptionDialog::slotDefault);
 }
 
 void OptionDialog::helpRequested()
 {
     KHelpClient::invokeHelp(QStringLiteral("kdiff3/index.html"));
 }
 
 OptionDialog::~OptionDialog()
 {
 }
 
 void OptionDialog::setupOtherOptions()
 {
     //TODO move to Options class
     addOptionItem(new OptionToggleAction(false, "AutoAdvance", &m_options->m_bAutoAdvance));
     addOptionItem(new OptionToggleAction(true, "ShowWhiteSpaceCharacters", &m_options->m_bShowWhiteSpaceCharacters));
     addOptionItem(new OptionToggleAction(true, "ShowWhiteSpace", &m_options->m_bShowWhiteSpace));
     addOptionItem(new OptionToggleAction(false, "ShowLineNumbers", &m_options->m_bShowLineNumbers));
     addOptionItem(new OptionToggleAction(true, "HorizDiffWindowSplitting", &m_options->m_bHorizDiffWindowSplitting));
     addOptionItem(new OptionToggleAction(false, "WordWrap", &m_options->m_bWordWrap));
 
     addOptionItem(new OptionToggleAction(true, "ShowIdenticalFiles", &m_options->m_bDmShowIdenticalFiles));
 
     addOptionItem(new OptionStringList(&m_options->m_recentAFiles, "RecentAFiles"));
     addOptionItem(new OptionStringList(&m_options->m_recentBFiles, "RecentBFiles"));
     addOptionItem(new OptionStringList(&m_options->m_recentCFiles, "RecentCFiles"));
     addOptionItem(new OptionStringList(&m_options->m_recentOutputFiles, "RecentOutputFiles"));
     addOptionItem(new OptionStringList(&m_options->m_recentEncodings, "RecentEncodings"));
 }
 
 void OptionDialog::setupFontPage()
 {
     QFrame* page = new QFrame();
     KPageWidgetItem* pageItem = new KPageWidgetItem(page, i18n("Font"));
 
     pageItem->setHeader(i18n("Editor & Diff Output Font"));
     //not all themes have this icon
     if(QIcon::hasThemeIcon(QStringLiteral("font-select-symbolic")))
         pageItem->setIcon(QIcon::fromTheme(QStringLiteral("font-select-symbolic")));
     else
         pageItem->setIcon(QIcon::fromTheme(QStringLiteral("preferences-desktop-font")));
     addPage(pageItem);
 
     QVBoxLayout* topLayout = new QVBoxLayout(page);
     topLayout->setMargin(5);
 
     //requires QT 5.2 or later.
     static const QFont defaultFont = QFontDatabase::systemFont(QFontDatabase::FixedFont);
     static QFont defaultAppFont = QApplication::font();
 
     OptionFontChooser* pAppFontChooser = new OptionFontChooser(defaultAppFont, "ApplicationFont", &m_options->m_appFont, page);
     addOptionItem(pAppFontChooser);
     topLayout->addWidget(pAppFontChooser);
     pAppFontChooser->setTitle(i18n("Application font"));
 
     OptionFontChooser* pFontChooser = new OptionFontChooser(defaultFont, "Font", &m_options->m_font, page);
     addOptionItem(pFontChooser);
     topLayout->addWidget(pFontChooser);
     pFontChooser->setTitle(i18n("File view font"));
 
     QGridLayout* gbox = new QGridLayout();
     topLayout->addLayout(gbox);
     //int line=0;
 
     // This currently does not work (see rendering in class DiffTextWindow)
     //OptionCheckBox* pItalicDeltas = new OptionCheckBox( i18n("Italic font for deltas"), false, "ItalicForDeltas", &m_options->m_bItalicForDeltas, page, this );
     //addOptionItem(pItalicDeltas);
     //gbox->addWidget( pItalicDeltas, line, 0, 1, 2 );
     //pItalicDeltas->setToolTip( i18n(
     //   "Selects the italic version of the font for differences.\n"
     //   "If the font doesn't support italic characters, then this does nothing.")
     //   );
 }
 
 void OptionDialog::setupColorPage()
 {
     QFrame* page = new QFrame();
     KPageWidgetItem* pageItem = new KPageWidgetItem(page, i18nc("Title for color settings page","Color"));
     pageItem->setHeader(i18n("Colors Settings"));
     pageItem->setIcon(QIcon::fromTheme(QStringLiteral("colormanagement")));
     addPage(pageItem);
 
     QVBoxLayout* topLayout = new QVBoxLayout(page);
     topLayout->setMargin(5);
 
     QGridLayout* gbox = new QGridLayout();
     gbox->setColumnStretch(1, 5);
     topLayout->addLayout(gbox);
 
     QLabel* label;
     int line = 0;
 
     int depth = QPixmap::defaultDepth();
     bool bLowColor = depth <= 8;
 
     label = new QLabel(i18n("Editor and Diff Views:"), page);
     gbox->addWidget(label, line, 0);
     QFont f(label->font());
     f.setBold(true);
     label->setFont(f);
     ++line;
 
     OptionColorButton* pFgColor = new OptionColorButton(Qt::black, "FgColor", &m_options->m_fgColor, page);
     label = new QLabel(i18n("Foreground color:"), page);
     label->setBuddy(pFgColor);
     addOptionItem(pFgColor);
     gbox->addWidget(label, line, 0);
     gbox->addWidget(pFgColor, line, 1);
     ++line;
 
     OptionColorButton* pBgColor = new OptionColorButton(Qt::white, "BgColor", &m_options->m_bgColor, page);
     label = new QLabel(i18n("Background color:"), page);
     label->setBuddy(pBgColor);
     addOptionItem(pBgColor);
     gbox->addWidget(label, line, 0);
     gbox->addWidget(pBgColor, line, 1);
 
     ++line;
 
     OptionColorButton* pDiffBgColor = new OptionColorButton(
         bLowColor ? QColor(Qt::lightGray) : qRgb(224, 224, 224), "DiffBgColor", &m_options->m_diffBgColor, page);
     label = new QLabel(i18n("Diff background color:"), page);
     label->setBuddy(pDiffBgColor);
     addOptionItem(pDiffBgColor);
     gbox->addWidget(label, line, 0);
     gbox->addWidget(pDiffBgColor, line, 1);
     ++line;
 
     OptionColorButton* pColorA = new OptionColorButton(
         bLowColor ? qRgb(0, 0, 255) : qRgb(0, 0, 200) /*blue*/, "ColorA", &m_options->m_colorA, page);
     label = new QLabel(i18n("Color A:"), page);
     label->setBuddy(pColorA);
     addOptionItem(pColorA);
     gbox->addWidget(label, line, 0);
     gbox->addWidget(pColorA, line, 1);
     ++line;
 
     OptionColorButton* pColorB = new OptionColorButton(
         bLowColor ? qRgb(0, 128, 0) : qRgb(0, 150, 0) /*green*/, "ColorB", &m_options->m_colorB, page);
     label = new QLabel(i18n("Color B:"), page);
     label->setBuddy(pColorB);
     addOptionItem(pColorB);
     gbox->addWidget(label, line, 0);
     gbox->addWidget(pColorB, line, 1);
     ++line;
 
     OptionColorButton* pColorC = new OptionColorButton(
         bLowColor ? qRgb(128, 0, 128) : qRgb(150, 0, 150) /*magenta*/, "ColorC", &m_options->m_colorC, page);
     label = new QLabel(i18n("Color C:"), page);
     label->setBuddy(pColorC);
     addOptionItem(pColorC);
     gbox->addWidget(label, line, 0);
     gbox->addWidget(pColorC, line, 1);
     ++line;
 
     OptionColorButton* pColorForConflict = new OptionColorButton(Qt::red, "ColorForConflict", &m_options->m_colorForConflict, page);
     label = new QLabel(i18n("Conflict color:"), page);
     label->setBuddy(pColorForConflict);
     addOptionItem(pColorForConflict);
     gbox->addWidget(label, line, 0);
     gbox->addWidget(pColorForConflict, line, 1);
     ++line;
 
     OptionColorButton* pColor = new OptionColorButton(
         bLowColor ? qRgb(192, 192, 192) : qRgb(220, 220, 100), "CurrentRangeBgColor", &m_options->m_currentRangeBgColor, page);
     label = new QLabel(i18n("Current range background color:"), page);
     label->setBuddy(pColor);
     addOptionItem(pColor);
     gbox->addWidget(label, line, 0);
     gbox->addWidget(pColor, line, 1);
     ++line;
 
     pColor = new OptionColorButton(
         bLowColor ? qRgb(255, 255, 0) : qRgb(255, 255, 150), "CurrentRangeDiffBgColor", &m_options->m_currentRangeDiffBgColor, page);
     label = new QLabel(i18n("Current range diff background color:"), page);
     label->setBuddy(pColor);
     addOptionItem(pColor);
     gbox->addWidget(label, line, 0);
     gbox->addWidget(pColor, line, 1);
     ++line;
 
     pColor = new OptionColorButton(qRgb(0xff, 0xd0, 0x80), "ManualAlignmentRangeColor", &m_options->m_manualHelpRangeColor, page);
     label = new QLabel(i18n("Color for manually aligned difference ranges:"), page);
     label->setBuddy(pColor);
     addOptionItem(pColor);
     gbox->addWidget(label, line, 0);
     gbox->addWidget(pColor, line, 1);
     ++line;
 
     label = new QLabel(i18n("Directory Comparison View:"), page);
     gbox->addWidget(label, line, 0);
     label->setFont(f);
     ++line;
 
     pColor = new OptionColorButton(qRgb(0, 0xd0, 0), "NewestFileColor", &m_options->m_newestFileColor, page);
     label = new QLabel(i18n("Newest file color:"), page);
     label->setBuddy(pColor);
     addOptionItem(pColor);
     gbox->addWidget(label, line, 0);
     gbox->addWidget(pColor, line, 1);
     QString dirColorTip = i18n("Changing this color will only be effective when starting the next directory comparison.");
     label->setToolTip(dirColorTip);
     ++line;
 
     pColor = new OptionColorButton(qRgb(0xf0, 0, 0), "OldestFileColor", &m_options->m_oldestFileColor, page);
     label = new QLabel(i18n("Oldest file color:"), page);
     label->setBuddy(pColor);
     addOptionItem(pColor);
     gbox->addWidget(label, line, 0);
     gbox->addWidget(pColor, line, 1);
     label->setToolTip(dirColorTip);
     ++line;
 
     pColor = new OptionColorButton(qRgb(0xc0, 0xc0, 0), "MidAgeFileColor", &m_options->m_midAgeFileColor, page);
     label = new QLabel(i18n("Middle age file color:"), page);
     label->setBuddy(pColor);
     addOptionItem(pColor);
     gbox->addWidget(label, line, 0);
     gbox->addWidget(pColor, line, 1);
     label->setToolTip(dirColorTip);
     ++line;
 
     pColor = new OptionColorButton(qRgb(0, 0, 0), "MissingFileColor", &m_options->m_missingFileColor, page);
     label = new QLabel(i18n("Color for missing files:"), page);
     label->setBuddy(pColor);
     addOptionItem(pColor);
     gbox->addWidget(label, line, 0);
     gbox->addWidget(pColor, line, 1);
     label->setToolTip(dirColorTip);
     ++line;
 
     topLayout->addStretch(10);
 }
 
 void OptionDialog::setupEditPage()
 {
     QFrame* page = new QFrame();
     KPageWidgetItem* pageItem = new KPageWidgetItem(page, i18n("Editor"));
     pageItem->setHeader(i18n("Editor Behavior"));
     pageItem->setIcon(QIcon::fromTheme(QStringLiteral("accessories-text-editor")));
     addPage(pageItem);
 
     QVBoxLayout* topLayout = new QVBoxLayout(page);
     topLayout->setMargin(5);
 
     QGridLayout* gbox = new QGridLayout();
     gbox->setColumnStretch(1, 5);
     topLayout->addLayout(gbox);
     QLabel* label;
     int line = 0;
 
     OptionCheckBox* pReplaceTabs = new OptionCheckBox(i18n("Tab inserts spaces"), false, "ReplaceTabs", &m_options->m_bReplaceTabs, page);
     addOptionItem(pReplaceTabs);
     gbox->addWidget(pReplaceTabs, line, 0, 1, 2);
     pReplaceTabs->setToolTip(i18n(
         "On: Pressing tab generates the appropriate number of spaces.\n"
         "Off: A tab character will be inserted."));
     ++line;
 
     OptionIntEdit* pTabSize = new OptionIntEdit(8, "TabSize", &m_options->m_tabSize, 1, 100, page);
     label = new QLabel(i18n("Tab size:"), page);
     label->setBuddy(pTabSize);
     addOptionItem(pTabSize);
     gbox->addWidget(label, line, 0);
     gbox->addWidget(pTabSize, line, 1);
     ++line;
 
     OptionCheckBox* pAutoIndentation = new OptionCheckBox(i18n("Auto indentation"), true, "AutoIndentation", &m_options->m_bAutoIndentation, page);
     gbox->addWidget(pAutoIndentation, line, 0, 1, 2);
     addOptionItem(pAutoIndentation);
     pAutoIndentation->setToolTip(i18n(
         "On: The indentation of the previous line is used for a new line.\n"));
     ++line;
 
     OptionCheckBox* pAutoCopySelection = new OptionCheckBox(i18n("Auto copy selection"), false, "AutoCopySelection", &m_options->m_bAutoCopySelection, page);
     gbox->addWidget(pAutoCopySelection, line, 0, 1, 2);
     addOptionItem(pAutoCopySelection);
     pAutoCopySelection->setToolTip(i18n(
         "On: Any selection is immediately written to the clipboard.\n"
         "Off: You must explicitly copy e.g. via Ctrl-C."));
     ++line;
 
     label = new QLabel(i18n("Line end style:"), page);
     gbox->addWidget(label, line, 0);
 
     OptionComboBox* pLineEndStyle = new OptionComboBox(eLineEndStyleAutoDetect, "LineEndStyle", (int*)&m_options->m_lineEndStyle, page);
     gbox->addWidget(pLineEndStyle, line, 1);
     addOptionItem(pLineEndStyle);
     pLineEndStyle->insertItem(eLineEndStyleUnix, "Unix");
     pLineEndStyle->insertItem(eLineEndStyleDos, "Dos/Windows");
     pLineEndStyle->insertItem(eLineEndStyleAutoDetect, "Autodetect");
 
     label->setToolTip(i18n(
         "Sets the line endings for when an edited file is saved.\n"
         "DOS/Windows: CR+LF; UNIX: LF; with CR=0D, LF=0A"));
     ++line;
 
     topLayout->addStretch(10);
 }
 
 void OptionDialog::setupDiffPage()
 {
     QFrame* page = new QFrame();
     KPageWidgetItem* pageItem = new KPageWidgetItem(page, i18n("Diff"));
     pageItem->setHeader(i18n("Diff Settings"));
     pageItem->setIcon(QIcon::fromTheme(QStringLiteral("text-x-patch")));
     addPage(pageItem);
 
     QVBoxLayout* topLayout = new QVBoxLayout(page);
     topLayout->setMargin(5);
 
     QGridLayout* gbox = new QGridLayout();
     gbox->setColumnStretch(1, 5);
     topLayout->addLayout(gbox);
     int line = 0;
 
     QLabel* label = nullptr;
 
     m_options->m_bPreserveCarriageReturn = false;
     /*
     OptionCheckBox* pPreserveCarriageReturn = new OptionCheckBox( i18n("Preserve carriage return"), false, "PreserveCarriageReturn", &m_options->m_bPreserveCarriageReturn, page, this );
     addOptionItem(pPreserveCarriageReturn);
     gbox->addWidget( pPreserveCarriageReturn, line, 0, 1, 2 );
     pPreserveCarriageReturn->setToolTip( i18n(
        "Show carriage return characters '\\r' if they exist.\n"
        "Helps to compare files that were modified under different operating systems.")
        );
     ++line;
 */
     OptionCheckBox* pIgnoreNumbers = new OptionCheckBox(i18n("Ignore numbers (treat as white space)"), false, "IgnoreNumbers", &m_options->m_bIgnoreNumbers, page);
     gbox->addWidget(pIgnoreNumbers, line, 0, 1, 2);
     addOptionItem(pIgnoreNumbers);
     pIgnoreNumbers->setToolTip(i18n(
         "Ignore number characters during line matching phase. (Similar to Ignore white space.)\n"
         "Might help to compare files with numeric data."));
     ++line;
 
     OptionCheckBox* pIgnoreComments = new OptionCheckBox(i18n("Ignore C/C++ comments (treat as white space)"), false, "IgnoreComments", &m_options->m_bIgnoreComments, page);
     gbox->addWidget(pIgnoreComments, line, 0, 1, 2);
     addOptionItem(pIgnoreComments);
     pIgnoreComments->setToolTip(i18n("Treat C/C++ comments like white space."));
     ++line;
 
     OptionCheckBox* pIgnoreCase = new OptionCheckBox(i18n("Ignore case (treat as white space)"), false, "IgnoreCase", &m_options->m_bIgnoreCase, page);
     gbox->addWidget(pIgnoreCase, line, 0, 1, 2);
     addOptionItem(pIgnoreCase);
     pIgnoreCase->setToolTip(i18n(
         "Treat case differences like white space changes. ('a'<=>'A')"));
     ++line;
 
     label = new QLabel(i18n("Preprocessor command:"), page);
     gbox->addWidget(label, line, 0);
     OptionLineEdit* pLE = new OptionLineEdit("", "PreProcessorCmd", &m_options->m_PreProcessorCmd, page);
     gbox->addWidget(pLE, line, 1);
     addOptionItem(pLE);
     label->setToolTip(i18n("User defined pre-processing. (See the docs for details.)"));
     ++line;
 
     label = new QLabel(i18n("Line-matching preprocessor command:"), page);
     gbox->addWidget(label, line, 0);
     pLE = new OptionLineEdit("", "LineMatchingPreProcessorCmd", &m_options->m_LineMatchingPreProcessorCmd, page);
     gbox->addWidget(pLE, line, 1);
     addOptionItem(pLE);
     label->setToolTip(i18n("This pre-processor is only used during line matching.\n(See the docs for details.)"));
     ++line;
 
     OptionCheckBox* pTryHard = new OptionCheckBox(i18n("Try hard (slower)"), true, "TryHard", &m_options->m_bTryHard, page);
     gbox->addWidget(pTryHard, line, 0, 1, 2);
     addOptionItem(pTryHard);
     pTryHard->setToolTip(i18n(
         "Enables the --minimal option for the external diff.\n"
         "The analysis of big files will be much slower."));
     ++line;
 
     OptionCheckBox* pDiff3AlignBC = new OptionCheckBox(i18n("Align B and C for 3 input files"), false, "Diff3AlignBC", &m_options->m_bDiff3AlignBC, page);
     gbox->addWidget(pDiff3AlignBC, line, 0, 1, 2);
     addOptionItem(pDiff3AlignBC);
     pDiff3AlignBC->setToolTip(i18n(
         "Try to align B and C when comparing or merging three input files.\n"
         "Not recommended for merging because merge might get more complicated.\n"
         "(Default is off.)"));
     ++line;
 
     topLayout->addStretch(10);
 }
 
 void OptionDialog::setupMergePage()
 {
     QFrame* page = new QFrame();
     KPageWidgetItem* pageItem = new KPageWidgetItem(page, i18n("Merge"));
     pageItem->setHeader(i18n("Merge Settings"));
     pageItem->setIcon(QIcon::fromTheme(QStringLiteral("merge")));
     addPage(pageItem);
 
     QVBoxLayout* topLayout = new QVBoxLayout(page);
     topLayout->setMargin(5);
 
     QGridLayout* gbox = new QGridLayout();
     gbox->setColumnStretch(1, 5);
     topLayout->addLayout(gbox);
     int line = 0;
 
     QLabel* label = nullptr;
 
     label = new QLabel(i18n("Auto advance delay (ms):"), page);
     gbox->addWidget(label, line, 0);
     OptionIntEdit* pAutoAdvanceDelay = new OptionIntEdit(500, "AutoAdvanceDelay", &m_options->m_autoAdvanceDelay, 0, 2000, page);
     gbox->addWidget(pAutoAdvanceDelay, line, 1);
     addOptionItem(pAutoAdvanceDelay);
     label->setToolTip(i18n(
         "When in Auto-Advance mode the result of the current selection is shown \n"
         "for the specified time, before jumping to the next conflict. Range: 0-2000 ms"));
     ++line;
 
     OptionCheckBox* pShowInfoDialogs = new OptionCheckBox(i18n("Show info dialogs"), true, "ShowInfoDialogs", &m_options->m_bShowInfoDialogs, page);
     gbox->addWidget(pShowInfoDialogs, line, 0, 1, 2);
     addOptionItem(pShowInfoDialogs);
     pShowInfoDialogs->setToolTip(i18n("Show a dialog with information about the number of conflicts."));
     ++line;
 
     label = new QLabel(i18n("White space 2-file merge default:"), page);
     gbox->addWidget(label, line, 0);
     OptionComboBox* pWhiteSpace2FileMergeDefault = new OptionComboBox(0, "WhiteSpace2FileMergeDefault", &m_options->m_whiteSpace2FileMergeDefault, page);
     gbox->addWidget(pWhiteSpace2FileMergeDefault, line, 1);
     addOptionItem(pWhiteSpace2FileMergeDefault);
     pWhiteSpace2FileMergeDefault->insertItem(0, i18n("Manual Choice"));
     pWhiteSpace2FileMergeDefault->insertItem(1, i18n("A"));
     pWhiteSpace2FileMergeDefault->insertItem(2, i18n("B"));
     label->setToolTip(i18n(
         "Allow the merge algorithm to automatically select an input for "
         "white-space-only changes."));
     ++line;
 
     label = new QLabel(i18n("White space 3-file merge default:"), page);
     gbox->addWidget(label, line, 0);
     OptionComboBox* pWhiteSpace3FileMergeDefault = new OptionComboBox(0, "WhiteSpace3FileMergeDefault", &m_options->m_whiteSpace3FileMergeDefault, page);
     gbox->addWidget(pWhiteSpace3FileMergeDefault, line, 1);
     addOptionItem(pWhiteSpace3FileMergeDefault);
     pWhiteSpace3FileMergeDefault->insertItem(0, i18n("Manual Choice"));
     pWhiteSpace3FileMergeDefault->insertItem(1, i18n("A"));
     pWhiteSpace3FileMergeDefault->insertItem(2, i18n("B"));
     pWhiteSpace3FileMergeDefault->insertItem(3, i18n("C"));
     label->setToolTip(i18n(
         "Allow the merge algorithm to automatically select an input for "
         "white-space-only changes."));
     ++line;
 
     QGroupBox* pGroupBox = new QGroupBox(i18n("Automatic Merge Regular Expression"));
     gbox->addWidget(pGroupBox, line, 0, 1, 2);
     ++line;
     {
         gbox = new QGridLayout(pGroupBox);
         gbox->setColumnStretch(1, 10);
         line = 0;
 
         label = new QLabel(i18n("Auto merge regular expression:"), page);
         gbox->addWidget(label, line, 0);
         m_pAutoMergeRegExpLineEdit = new OptionLineEdit(".*\\$(Version|Header|Date|Author).*\\$.*", "AutoMergeRegExp", &m_options->m_autoMergeRegExp, page);
         gbox->addWidget(m_pAutoMergeRegExpLineEdit, line, 1);
         addOptionItem(m_pAutoMergeRegExpLineEdit);
         s_autoMergeRegExpToolTip = i18n("Regular expression for lines where KDiff3 should automatically choose one source.\n"
                                         "When a line with a conflict matches the regular expression then\n"
                                         "- if available - C, otherwise B will be chosen.");
         label->setToolTip(s_autoMergeRegExpToolTip);
         ++line;
 
         OptionCheckBox* pAutoMergeRegExp = new OptionCheckBox(i18n("Run regular expression auto merge on merge start"), false, "RunRegExpAutoMergeOnMergeStart", &m_options->m_bRunRegExpAutoMergeOnMergeStart, page);
         addOptionItem(pAutoMergeRegExp);
         gbox->addWidget(pAutoMergeRegExp, line, 0, 1, 2);
         pAutoMergeRegExp->setToolTip(i18n("Run the merge for auto merge regular expressions\n"
                                           "immediately when a merge starts.\n"));
         ++line;
     }
 
     pGroupBox = new QGroupBox(i18n("Version Control History Merging"));
     gbox->addWidget(pGroupBox, line, 0, 1, 2);
     ++line;
     {
         gbox = new QGridLayout(pGroupBox);
         gbox->setColumnStretch(1, 10);
         line = 0;
 
         label = new QLabel(i18n("History start regular expression:"), page);
         gbox->addWidget(label, line, 0);
         m_pHistoryStartRegExpLineEdit = new OptionLineEdit(".*\\$Log.*\\$.*", "HistoryStartRegExp", &m_options->m_historyStartRegExp, page);
         gbox->addWidget(m_pHistoryStartRegExpLineEdit, line, 1);
         addOptionItem(m_pHistoryStartRegExpLineEdit);
         s_historyStartRegExpToolTip = i18n("Regular expression for the start of the version control history entry.\n"
                                            "Usually this line contains the \"$Log$\" keyword.\n"
                                            "Default value: \".*\\$Log.*\\$.*\"");
         label->setToolTip(s_historyStartRegExpToolTip);
         ++line;
 
         label = new QLabel(i18n("History entry start regular expression:"), page);
         gbox->addWidget(label, line, 0);
         // Example line:  "** \main\rolle_fsp_dev_008\1   17 Aug 2001 10:45:44   rolle"
         QString historyEntryStartDefault =
             "\\s*\\\\main\\\\(\\S+)\\s+"                         // Start with  "\main\"
             "([0-9]+) "                                          // day
             "(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) " //month
             "([0-9][0-9][0-9][0-9]) "                            // year
             "([0-9][0-9]:[0-9][0-9]:[0-9][0-9])\\s+(.*)";        // time, name
 
         m_pHistoryEntryStartRegExpLineEdit = new OptionLineEdit(historyEntryStartDefault, "HistoryEntryStartRegExp", &m_options->m_historyEntryStartRegExp, page);
         gbox->addWidget(m_pHistoryEntryStartRegExpLineEdit, line, 1);
         addOptionItem(m_pHistoryEntryStartRegExpLineEdit);
         s_historyEntryStartRegExpToolTip = i18n("A version control history entry consists of several lines.\n"
                                                 "Specify the regular expression to detect the first line (without the leading comment).\n"
                                                 "Use parentheses to group the keys you want to use for sorting.\n"
                                                 "If left empty, then KDiff3 assumes that empty lines separate history entries.\n"
                                                 "See the documentation for details.");
         label->setToolTip(s_historyEntryStartRegExpToolTip);
         ++line;
 
         m_pHistoryMergeSorting = new OptionCheckBox(i18n("History merge sorting"), false, "HistoryMergeSorting", &m_options->m_bHistoryMergeSorting, page);
         gbox->addWidget(m_pHistoryMergeSorting, line, 0, 1, 2);
         addOptionItem(m_pHistoryMergeSorting);
         m_pHistoryMergeSorting->setToolTip(i18n("Sort version control history by a key."));
         ++line;
         //QString branch = newHistoryEntry.cap(1);
         //int day    = newHistoryEntry.cap(2).toInt();
         //int month  = QString("Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec").find(newHistoryEntry.cap(3))/4 + 1;
         //int year   = newHistoryEntry.cap(4).toInt();
         //QString time = newHistoryEntry.cap(5);
         //QString name = newHistoryEntry.cap(6);
         QString defaultSortKeyOrder = "4,3,2,5,1,6"; //QDate(year,month,day).toString(Qt::ISODate) +" "+ time + " " + branch + " " + name;
 
         label = new QLabel(i18n("History entry start sort key order:"), page);
         gbox->addWidget(label, line, 0);
         m_pHistorySortKeyOrderLineEdit = new OptionLineEdit(defaultSortKeyOrder, "HistoryEntryStartSortKeyOrder", &m_options->m_historyEntryStartSortKeyOrder, page);
         gbox->addWidget(m_pHistorySortKeyOrderLineEdit, line, 1);
         addOptionItem(m_pHistorySortKeyOrderLineEdit);
         s_historyEntryStartSortKeyOrderToolTip = i18n("Each pair of parentheses used in the regular expression for the history start entry\n"
                                                       "groups a key that can be used for sorting.\n"
                                                       "Specify the list of keys (that are numbered in order of occurrence\n"
                                                       "starting with 1) using ',' as separator (e.g. \"4,5,6,1,2,3,7\").\n"
                                                       "If left empty, then no sorting will be done.\n"
                                                       "See the documentation for details.");
         label->setToolTip(s_historyEntryStartSortKeyOrderToolTip);
         m_pHistorySortKeyOrderLineEdit->setEnabled(false);
         connect(m_pHistoryMergeSorting, &OptionCheckBox::toggled, m_pHistorySortKeyOrderLineEdit, &OptionLineEdit::setEnabled);
         ++line;
 
         m_pHistoryAutoMerge = new OptionCheckBox(i18n("Merge version control history on merge start"), false, "RunHistoryAutoMergeOnMergeStart", &m_options->m_bRunHistoryAutoMergeOnMergeStart, page);
         addOptionItem(m_pHistoryAutoMerge);
         gbox->addWidget(m_pHistoryAutoMerge, line, 0, 1, 2);
         m_pHistoryAutoMerge->setToolTip(i18n("Run version control history automerge on merge start."));
         ++line;
 
         OptionIntEdit* pMaxNofHistoryEntries = new OptionIntEdit(-1, "MaxNofHistoryEntries", &m_options->m_maxNofHistoryEntries, -1, 1000, page);
         label = new QLabel(i18n("Max number of history entries:"), page);
         gbox->addWidget(label, line, 0);
         gbox->addWidget(pMaxNofHistoryEntries, line, 1);
         addOptionItem(pMaxNofHistoryEntries);
         pMaxNofHistoryEntries->setToolTip(i18n("Cut off after specified number. Use -1 for infinite number of entries."));
         ++line;
     }
 
     QPushButton* pButton = new QPushButton(i18n("Test your regular expressions"), page);
     gbox->addWidget(pButton, line, 0);
     connect(pButton, &QPushButton::clicked, this, &OptionDialog::slotHistoryMergeRegExpTester);
     ++line;
 
     label = new QLabel(i18n("Irrelevant merge command:"), page);
     gbox->addWidget(label, line, 0);
     OptionLineEdit* pLE = new OptionLineEdit("", "IrrelevantMergeCmd", &m_options->m_IrrelevantMergeCmd, page);
     gbox->addWidget(pLE, line, 1);
     addOptionItem(pLE);
     label->setToolTip(i18n("If specified this script is run after automerge\n"
                            "when no other relevant changes were detected.\n"
                            "Called with the parameters: filename1 filename2 filename3"));
     ++line;
 
     OptionCheckBox* pAutoSaveAndQuit = new OptionCheckBox(i18n("Auto save and quit on merge without conflicts"), false,
                                                           "AutoSaveAndQuitOnMergeWithoutConflicts", &m_options->m_bAutoSaveAndQuitOnMergeWithoutConflicts, page);
     gbox->addWidget(pAutoSaveAndQuit, line, 0, 1, 2);
     addOptionItem(pAutoSaveAndQuit);
     pAutoSaveAndQuit->setToolTip(i18n("If KDiff3 was started for a file-merge from the command line and all\n"
                                       "conflicts are solvable without user interaction then automatically save and quit.\n"
                                       "(Similar to command line option \"--auto\".)"));
     ++line;
 
     topLayout->addStretch(10);
 }
 
 void OptionDialog::setupDirectoryMergePage()
 {
     QFrame* page = new QFrame();
     KPageWidgetItem* pageItem = new KPageWidgetItem(page, i18n("Directory"));
     pageItem->setHeader(i18n("Directory"));
     pageItem->setIcon(QIcon::fromTheme(QStringLiteral("inode-directory")));
     addPage(pageItem);
 
     QVBoxLayout* topLayout = new QVBoxLayout(page);
     topLayout->setMargin(5);
 
     QGridLayout* gbox = new QGridLayout();
     gbox->setColumnStretch(1, 5);
     topLayout->addLayout(gbox);
     int line = 0;
 
     OptionCheckBox* pRecursiveDirs = new OptionCheckBox(i18n("Recursive directories"), true, "RecursiveDirs", &m_options->m_bDmRecursiveDirs, page);
     gbox->addWidget(pRecursiveDirs, line, 0, 1, 2);
     addOptionItem(pRecursiveDirs);
     pRecursiveDirs->setToolTip(i18n("Whether to analyze subdirectories or not."));
     ++line;
     QLabel* label = new QLabel(i18n("File pattern(s):"), page);
     gbox->addWidget(label, line, 0);
     OptionLineEdit* pFilePattern = new OptionLineEdit("*", "FilePattern", &m_options->m_DmFilePattern, page);
     gbox->addWidget(pFilePattern, line, 1);
     addOptionItem(pFilePattern);
     label->setToolTip(i18n(
         "Pattern(s) of files to be analyzed. \n"
         "Wildcards: '*' and '?'\n"
         "Several Patterns can be specified by using the separator: ';'"));
     ++line;
 
     label = new QLabel(i18n("File-anti-pattern(s):"), page);
     gbox->addWidget(label, line, 0);
     OptionLineEdit* pFileAntiPattern = new OptionLineEdit("*.orig;*.o;*.obj;*.rej;*.bak", "FileAntiPattern", &m_options->m_DmFileAntiPattern, page);
     gbox->addWidget(pFileAntiPattern, line, 1);
     addOptionItem(pFileAntiPattern);
     label->setToolTip(i18n(
         "Pattern(s) of files to be excluded from analysis. \n"
         "Wildcards: '*' and '?'\n"
         "Several Patterns can be specified by using the separator: ';'"));
     ++line;
 
     label = new QLabel(i18n("Dir-anti-pattern(s):"), page);
     gbox->addWidget(label, line, 0);
     OptionLineEdit* pDirAntiPattern = new OptionLineEdit("CVS;.deps;.svn;.hg;.git", "DirAntiPattern", &m_options->m_DmDirAntiPattern, page);
     gbox->addWidget(pDirAntiPattern, line, 1);
     addOptionItem(pDirAntiPattern);
     label->setToolTip(i18n(
         "Pattern(s) of directories to be excluded from analysis. \n"
         "Wildcards: '*' and '?'\n"
         "Several Patterns can be specified by using the separator: ';'"));
     ++line;
 
     OptionCheckBox* pUseCvsIgnore = new OptionCheckBox(i18n("Use .cvsignore"), false, "UseCvsIgnore", &m_options->m_bDmUseCvsIgnore, page);
     gbox->addWidget(pUseCvsIgnore, line, 0, 1, 2);
     addOptionItem(pUseCvsIgnore);
     pUseCvsIgnore->setToolTip(i18n(
         "Extends the antipattern to anything that would be ignored by CVS.\n"
         "Via local \".cvsignore\" files this can be directory specific."));
     ++line;
 
     OptionCheckBox* pFindHidden = new OptionCheckBox(i18n("Find hidden files and directories"), true, "FindHidden", &m_options->m_bDmFindHidden, page);
     gbox->addWidget(pFindHidden, line, 0, 1, 2);
     addOptionItem(pFindHidden);
     pFindHidden->setToolTip(i18n("Finds hidden files and directories."));
     ++line;
 
     OptionCheckBox* pFollowFileLinks = new OptionCheckBox(i18n("Follow file links"), false, "FollowFileLinks", &m_options->m_bDmFollowFileLinks, page);
     gbox->addWidget(pFollowFileLinks, line, 0, 1, 2);
     addOptionItem(pFollowFileLinks);
     pFollowFileLinks->setToolTip(i18n(
         "On: Compare the file the link points to.\n"
         "Off: Compare the links."));
     ++line;
 
     OptionCheckBox* pFollowDirLinks = new OptionCheckBox(i18n("Follow directory links"), false, "FollowDirLinks", &m_options->m_bDmFollowDirLinks, page);
     gbox->addWidget(pFollowDirLinks, line, 0, 1, 2);
     addOptionItem(pFollowDirLinks);
     pFollowDirLinks->setToolTip(i18n(
         "On: Compare the directory the link points to.\n"
         "Off: Compare the links."));
     ++line;
 
 #if defined(Q_OS_WIN)
     bool bCaseSensitiveFilenameComparison = false;
 #else
     bool bCaseSensitiveFilenameComparison = true;
 #endif
     OptionCheckBox* pCaseSensitiveFileNames = new OptionCheckBox(i18n("Case sensitive filename comparison"), bCaseSensitiveFilenameComparison, "CaseSensitiveFilenameComparison", &m_options->m_bDmCaseSensitiveFilenameComparison, page);
     gbox->addWidget(pCaseSensitiveFileNames, line, 0, 1, 2);
     addOptionItem(pCaseSensitiveFileNames);
     pCaseSensitiveFileNames->setToolTip(i18n(
         "The directory comparison will compare files or directories when their names match.\n"
         "Set this option if the case of the names must match. (Default for Windows is off, otherwise on.)"));
     ++line;
 
     OptionCheckBox* pUnfoldSubdirs = new OptionCheckBox(i18n("Unfold all subdirectories on load"), false, "UnfoldSubdirs", &m_options->m_bDmUnfoldSubdirs, page);
     gbox->addWidget(pUnfoldSubdirs, line, 0, 1, 2);
     addOptionItem(pUnfoldSubdirs);
     pUnfoldSubdirs->setToolTip(i18n(
         "On: Unfold all subdirectories when starting a directory diff.\n"
         "Off: Leave subdirectories folded."));
     ++line;
 
     OptionCheckBox* pSkipDirStatus = new OptionCheckBox(i18n("Skip directory status report"), false, "SkipDirStatus", &m_options->m_bDmSkipDirStatus, page);
     gbox->addWidget(pSkipDirStatus, line, 0, 1, 2);
     addOptionItem(pSkipDirStatus);
     pSkipDirStatus->setToolTip(i18n(
         "On: Do not show the Directory Comparison Status.\n"
         "Off: Show the status dialog on start."));
     ++line;
 
     QGroupBox* pBG = new QGroupBox(i18n("File Comparison Mode"));
     gbox->addWidget(pBG, line, 0, 1, 2);
 
     QVBoxLayout* pBGLayout = new QVBoxLayout(pBG);
 
     OptionRadioButton* pBinaryComparison = new OptionRadioButton(i18n("Binary comparison"), true, "BinaryComparison", &m_options->m_bDmBinaryComparison, pBG);
     addOptionItem(pBinaryComparison);
     pBinaryComparison->setToolTip(i18n("Binary comparison of each file. (Default)"));
     pBGLayout->addWidget(pBinaryComparison);
 
     OptionRadioButton* pFullAnalysis = new OptionRadioButton(i18n("Full analysis"), false, "FullAnalysis", &m_options->m_bDmFullAnalysis, pBG);
     addOptionItem(pFullAnalysis);
     pFullAnalysis->setToolTip(i18n("Do a full analysis and show statistics information in extra columns.\n"
                                    "(Slower than a binary comparison, much slower for binary files.)"));
     pBGLayout->addWidget(pFullAnalysis);
 
     OptionRadioButton* pTrustDate = new OptionRadioButton(i18n("Trust the size and modification date (unsafe)"), false, "TrustDate", &m_options->m_bDmTrustDate, pBG);
     addOptionItem(pTrustDate);
     pTrustDate->setToolTip(i18n("Assume that files are equal if the modification date and file length are equal.\n"
                                 "Files with equal contents but different modification dates will appear as different.\n"
                                 "Useful for big directories or slow networks."));
     pBGLayout->addWidget(pTrustDate);
 
     OptionRadioButton* pTrustDateFallbackToBinary = new OptionRadioButton(i18n("Trust the size and date, but use binary comparison if date does not match (unsafe)"), false, "TrustDateFallbackToBinary", &m_options->m_bDmTrustDateFallbackToBinary, pBG);
     addOptionItem(pTrustDateFallbackToBinary);
     pTrustDateFallbackToBinary->setToolTip(i18n("Assume that files are equal if the modification date and file length are equal.\n"
                                                 "If the dates are not equal but the sizes are, use binary comparison.\n"
                                                 "Useful for big directories or slow networks."));
     pBGLayout->addWidget(pTrustDateFallbackToBinary);
 
     OptionRadioButton* pTrustSize = new OptionRadioButton(i18n("Trust the size (unsafe)"), false, "TrustSize", &m_options->m_bDmTrustSize, pBG);
     addOptionItem(pTrustSize);
     pTrustSize->setToolTip(i18n("Assume that files are equal if their file lengths are equal.\n"
                                 "Useful for big directories or slow networks when the date is modified during download."));
     pBGLayout->addWidget(pTrustSize);
 
     ++line;
 
     // Some two Dir-options: Affects only the default actions.
     OptionCheckBox* pSyncMode = new OptionCheckBox(i18n("Synchronize directories"), false, "SyncMode", &m_options->m_bDmSyncMode, page);
     addOptionItem(pSyncMode);
     gbox->addWidget(pSyncMode, line, 0, 1, 2);
     pSyncMode->setToolTip(i18n(
         "Offers to store files in both directories so that\n"
         "both directories are the same afterwards.\n"
         "Works only when comparing two directories without specifying a destination."));
     ++line;
 
     // Allow white-space only differences to be considered equal
     OptionCheckBox* pWhiteSpaceDiffsEqual = new OptionCheckBox(i18n("White space differences considered equal"), true, "WhiteSpaceEqual", &m_options->m_bDmWhiteSpaceEqual, page);
     addOptionItem(pWhiteSpaceDiffsEqual);
     gbox->addWidget(pWhiteSpaceDiffsEqual, line, 0, 1, 2);
     pWhiteSpaceDiffsEqual->setToolTip(i18n(
         "If files differ only by white space consider them equal.\n"
         "This is only active when full analysis is chosen."));
     connect(pFullAnalysis, &OptionRadioButton::toggled, pWhiteSpaceDiffsEqual, &OptionCheckBox::setEnabled);
     pWhiteSpaceDiffsEqual->setEnabled(false);
     ++line;
 
     OptionCheckBox* pCopyNewer = new OptionCheckBox(i18n("Copy newer instead of merging (unsafe)"), false, "CopyNewer", &m_options->m_bDmCopyNewer, page);
     addOptionItem(pCopyNewer);
     gbox->addWidget(pCopyNewer, line, 0, 1, 2);
     pCopyNewer->setToolTip(i18n(
         "Do not look inside, just take the newer file.\n"
         "(Use this only if you know what you are doing!)\n"
         "Only effective when comparing two directories."));
     ++line;
 
     OptionCheckBox* pCreateBakFiles = new OptionCheckBox(i18n("Backup files (.orig)"), true, "CreateBakFiles", &m_options->m_bDmCreateBakFiles, page);
     gbox->addWidget(pCreateBakFiles, line, 0, 1, 2);
     addOptionItem(pCreateBakFiles);
     pCreateBakFiles->setToolTip(i18n(
         "If a file would be saved over an old file, then the old file\n"
         "will be renamed with a '.orig' extension instead of being deleted."));
     ++line;
 
     topLayout->addStretch(10);
 }
-/*
-static void insertCodecs(OptionComboBox* p)
-{
-   std::multimap<QString,QString> m;  // Using the multimap for case-insensitive sorting.
-   int i;
-   for(i=0;;++i)
-   {
-      QTextCodec* pCodec = QTextCodec::codecForIndex ( i );
-      if ( pCodec != 0 )  m.insert( std::make_pair( QString(pCodec->mimeName()).toUpper(), pCodec->mimeName()) );
-      else                break;
-   }
-
-   p->insertItem( i18n("Auto"), 0 );
-   std::multimap<QString,QString>::iterator mi;
-   for(mi=m.begin(), i=0; mi!=m.end(); ++mi, ++i)
-      p->insertItem(mi->second, i+1);
-}
-*/
-/*
-// UTF8-Codec that saves a BOM
-// UTF8-Codec that saves a BOM
-class Utf8BOMCodec : public QTextCodec
-{
-   QTextCodec* m_pUtf8Codec;
-   class PublicTextCodec : public QTextCodec
-   {
-   public:
-      QString publicConvertToUnicode ( const char * p, int len, ConverterState* pState ) const
-      {
-         return convertToUnicode( p, len, pState );
-      }
-      QByteArray publicConvertFromUnicode ( const QChar * input, int number, ConverterState * pState ) const
-      {
-         return convertFromUnicode( input, number, pState );
-      }
-   };
-public:
-   Utf8BOMCodec()
-   {
-      m_pUtf8Codec = QTextCodec::codecForName("UTF-8");
-   }
-   QByteArray name () const { return "UTF-8-BOM"; }
-   int mibEnum () const { return 2123; }
-   QByteArray convertFromUnicode ( const QChar * input, int number, ConverterState * pState ) const
-   {
-      QByteArray r;
-      if ( pState && pState->state_data[2]==0)  // state_data[2] not used by QUtf8::convertFromUnicode (see qutfcodec.cpp)
-      {
-        r += "\xEF\xBB\xBF";
-        pState->state_data[2]=1;
-        pState->flags |= QTextCodec::IgnoreHeader;
-      }
-
-      r += ((PublicTextCodec*)m_pUtf8Codec)->publicConvertFromUnicode( input, number, pState );
-      return r;
-   }
-   QString convertToUnicode ( const char * p, int len, ConverterState* pState ) const
-   {
-      return ((PublicTextCodec*)m_pUtf8Codec)->publicConvertToUnicode( p, len, pState );
-   }
-};
-*/
 void OptionDialog::setupRegionalPage()
 {
-    /*
-     TODO: What is this line supposed to do besides leak memory? Introduced as is in .91 no explanation
-        new Utf8BOMCodec();
-   */
-
     QFrame* page = new QFrame();
     KPageWidgetItem* pageItem = new KPageWidgetItem(page, i18n("Regional Settings"));
     pageItem->setHeader(i18n("Regional Settings"));
     pageItem->setIcon(QIcon::fromTheme(QStringLiteral("preferences-desktop-locale")));
     addPage(pageItem);
 
     QVBoxLayout* topLayout = new QVBoxLayout(page);
     topLayout->setMargin(5);
 
     QGridLayout* gbox = new QGridLayout();
     gbox->setColumnStretch(1, 5);
     topLayout->addLayout(gbox);
     int line = 0;
 
     QLabel* label;
 
     m_pSameEncoding = new OptionCheckBox(i18n("Use the same encoding for everything:"), true, "SameEncoding", &m_options->m_bSameEncoding, page);
     addOptionItem(m_pSameEncoding);
     gbox->addWidget(m_pSameEncoding, line, 0, 1, 2);
     m_pSameEncoding->setToolTip(i18n(
         "Enable this allows to change all encodings by changing the first only.\n"
         "Disable this if different individual settings are needed."));
     ++line;
 
     label = new QLabel(i18n("Note: Local Encoding is \"%1\"", QLatin1String(QTextCodec::codecForLocale()->name())), page);
     gbox->addWidget(label, line, 0);
     ++line;
 
     label = new QLabel(i18n("File Encoding for A:"), page);
     gbox->addWidget(label, line, 0);
     m_pEncodingAComboBox = new OptionEncodingComboBox("EncodingForA", &m_options->m_pEncodingA, page);
     addOptionItem(m_pEncodingAComboBox);
     gbox->addWidget(m_pEncodingAComboBox, line, 1);
 
     QString autoDetectToolTip = i18n(
         "If enabled then Unicode (UTF-16 or UTF-8) encoding will be detected.\n"
         "If the file is not Unicode then the selected encoding will be used as fallback.\n"
         "(Unicode detection depends on the first bytes of a file.)");
     m_pAutoDetectUnicodeA = new OptionCheckBox(i18n("Auto Detect Unicode"), true, "AutoDetectUnicodeA", &m_options->m_bAutoDetectUnicodeA, page);
     gbox->addWidget(m_pAutoDetectUnicodeA, line, 2);
     addOptionItem(m_pAutoDetectUnicodeA);
     m_pAutoDetectUnicodeA->setToolTip(autoDetectToolTip);
     ++line;
 
     label = new QLabel(i18n("File Encoding for B:"), page);
     gbox->addWidget(label, line, 0);
     m_pEncodingBComboBox = new OptionEncodingComboBox("EncodingForB", &m_options->m_pEncodingB, page);
     addOptionItem(m_pEncodingBComboBox);
     gbox->addWidget(m_pEncodingBComboBox, line, 1);
     m_pAutoDetectUnicodeB = new OptionCheckBox(i18n("Auto Detect Unicode"), true, "AutoDetectUnicodeB", &m_options->m_bAutoDetectUnicodeB, page);
     addOptionItem(m_pAutoDetectUnicodeB);
     gbox->addWidget(m_pAutoDetectUnicodeB, line, 2);
     m_pAutoDetectUnicodeB->setToolTip(autoDetectToolTip);
     ++line;
 
     label = new QLabel(i18n("File Encoding for C:"), page);
     gbox->addWidget(label, line, 0);
     m_pEncodingCComboBox = new OptionEncodingComboBox("EncodingForC", &m_options->m_pEncodingC, page);
     addOptionItem(m_pEncodingCComboBox);
     gbox->addWidget(m_pEncodingCComboBox, line, 1);
     m_pAutoDetectUnicodeC = new OptionCheckBox(i18n("Auto Detect Unicode"), true, "AutoDetectUnicodeC", &m_options->m_bAutoDetectUnicodeC, page);
     addOptionItem(m_pAutoDetectUnicodeC);
     gbox->addWidget(m_pAutoDetectUnicodeC, line, 2);
     m_pAutoDetectUnicodeC->setToolTip(autoDetectToolTip);
     ++line;
 
     label = new QLabel(i18n("File Encoding for Merge Output and Saving:"), page);
     gbox->addWidget(label, line, 0);
     m_pEncodingOutComboBox = new OptionEncodingComboBox("EncodingForOutput", &m_options->m_pEncodingOut, page);
     addOptionItem(m_pEncodingOutComboBox);
     gbox->addWidget(m_pEncodingOutComboBox, line, 1);
     m_pAutoSelectOutEncoding = new OptionCheckBox(i18n("Auto Select"), true, "AutoSelectOutEncoding", &m_options->m_bAutoSelectOutEncoding, page);
     addOptionItem(m_pAutoSelectOutEncoding);
     gbox->addWidget(m_pAutoSelectOutEncoding, line, 2);
     m_pAutoSelectOutEncoding->setToolTip(i18n(
         "If enabled then the encoding from the input files is used.\n"
         "In ambiguous cases a dialog will ask the user to choose the encoding for saving."));
     ++line;
     label = new QLabel(i18n("File Encoding for Preprocessor Files:"), page);
     gbox->addWidget(label, line, 0);
     m_pEncodingPPComboBox = new OptionEncodingComboBox("EncodingForPP", &m_options->m_pEncodingPP, page);
     addOptionItem(m_pEncodingPPComboBox);
     gbox->addWidget(m_pEncodingPPComboBox, line, 1);
     ++line;
 
     connect(m_pSameEncoding, &OptionCheckBox::toggled, this, &OptionDialog::slotEncodingChanged);
     connect(m_pEncodingAComboBox, static_cast<void (OptionEncodingComboBox::*)(int)>(&OptionEncodingComboBox::activated), this, &OptionDialog::slotEncodingChanged);
     connect(m_pAutoDetectUnicodeA, &OptionCheckBox::toggled, this, &OptionDialog::slotEncodingChanged);
     connect(m_pAutoSelectOutEncoding, &OptionCheckBox::toggled, this, &OptionDialog::slotEncodingChanged);
 
     OptionCheckBox* pRightToLeftLanguage = new OptionCheckBox(i18n("Right To Left Language"), false, "RightToLeftLanguage", &m_options->m_bRightToLeftLanguage, page);
     addOptionItem(pRightToLeftLanguage);
     gbox->addWidget(pRightToLeftLanguage, line, 0, 1, 2);
     pRightToLeftLanguage->setToolTip(i18n(
         "Some languages are read from right to left.\n"
         "This setting will change the viewer and editor accordingly."));
     ++line;
 
     topLayout->addStretch(10);
 }
 
 void OptionDialog::setupIntegrationPage()
 {
     QFrame* page = new QFrame();
     KPageWidgetItem* pageItem = new KPageWidgetItem(page, i18n("Integration"));
     pageItem->setHeader(i18n("Integration Settings"));
     pageItem->setIcon(QIcon::fromTheme(QStringLiteral("utilities-terminal")));
     addPage(pageItem);
 
     QVBoxLayout* topLayout = new QVBoxLayout(page);
     topLayout->setMargin(5);
 
     QGridLayout* gbox = new QGridLayout();
     gbox->setColumnStretch(2, 5);
     topLayout->addLayout(gbox);
     int line = 0;
 
     QLabel* label;
     label = new QLabel(i18n("Command line options to ignore:"), page);
     gbox->addWidget(label, line, 0);
     OptionLineEdit* pIgnorableCmdLineOptions = new OptionLineEdit("-u;-query;-html;-abort", "IgnorableCmdLineOptions", &m_options->m_ignorableCmdLineOptions, page);
     gbox->addWidget(pIgnorableCmdLineOptions, line, 1, 1, 2);
     addOptionItem(pIgnorableCmdLineOptions);
     label->setToolTip(i18n(
         "List of command line options that should be ignored when KDiff3 is used by other tools.\n"
         "Several values can be specified if separated via ';'\n"
         "This will suppress the \"Unknown option\" error."));
     ++line;
 
     OptionCheckBox* pEscapeKeyQuits = new OptionCheckBox(i18n("Quit also via Escape key"), false, "EscapeKeyQuits", &m_options->m_bEscapeKeyQuits, page);
     gbox->addWidget(pEscapeKeyQuits, line, 0, 1, 2);
     addOptionItem(pEscapeKeyQuits);
     pEscapeKeyQuits->setToolTip(i18n(
         "Fast method to exit.\n"
         "For those who are used to using the Escape key."));
     ++line;
 
     topLayout->addStretch(10);
 }
 
 
 void OptionDialog::slotEncodingChanged()
 {
     if(m_pSameEncoding->isChecked())
     {
         m_pEncodingBComboBox->setEnabled(false);
         m_pEncodingBComboBox->setCurrentIndex(m_pEncodingAComboBox->currentIndex());
         m_pEncodingCComboBox->setEnabled(false);
         m_pEncodingCComboBox->setCurrentIndex(m_pEncodingAComboBox->currentIndex());
         m_pEncodingOutComboBox->setEnabled(false);
         m_pEncodingOutComboBox->setCurrentIndex(m_pEncodingAComboBox->currentIndex());
         m_pEncodingPPComboBox->setEnabled(false);
         m_pEncodingPPComboBox->setCurrentIndex(m_pEncodingAComboBox->currentIndex());
         m_pAutoDetectUnicodeB->setEnabled(false);
         m_pAutoDetectUnicodeB->setCheckState(m_pAutoDetectUnicodeA->checkState());
         m_pAutoDetectUnicodeC->setEnabled(false);
         m_pAutoDetectUnicodeC->setCheckState(m_pAutoDetectUnicodeA->checkState());
         m_pAutoSelectOutEncoding->setEnabled(false);
         m_pAutoSelectOutEncoding->setCheckState(m_pAutoDetectUnicodeA->checkState());
     }
     else
     {
         m_pEncodingBComboBox->setEnabled(true);
         m_pEncodingCComboBox->setEnabled(true);
         m_pEncodingOutComboBox->setEnabled(true);
         m_pEncodingPPComboBox->setEnabled(true);
         m_pAutoDetectUnicodeB->setEnabled(true);
         m_pAutoDetectUnicodeC->setEnabled(true);
         m_pAutoSelectOutEncoding->setEnabled(true);
         m_pEncodingOutComboBox->setEnabled(m_pAutoSelectOutEncoding->checkState() == Qt::Unchecked);
     }
 }
 
 void OptionDialog::setupKeysPage()
 {
     //QVBox *page = addVBoxPage( i18n("Keys"), i18n("KeyDialog" ),
     //                          BarIcon("fonts", KIconLoader::SizeMedium ) );
 
     //QVBoxLayout *topLayout = new QVBoxLayout( page, 0, spacingHint() );
     //           new KFontChooser( page,"font",false/*onlyFixed*/,QStringList(),false,6 );
     //m_pKeyDialog=new KKeyDialog( false, 0 );
     //topLayout->addWidget( m_pKeyDialog );
 }
 
 void OptionDialog::slotOk()
 {
     slotApply();
 
     accept();
 }
 
 /** Copy the values from the widgets to the public variables.*/
 void OptionDialog::slotApply()
 {
     m_options->apply();
 
     emit applyDone();
 }
 
 /** Set the default values in the widgets only, while the
     public variables remain unchanged. */
 void OptionDialog::slotDefault()
 {
     int result = KMessageBox::warningContinueCancel(this, i18n("This resets all options. Not only those of the current topic."));
     if(result == KMessageBox::Cancel)
         return;
     else
         resetToDefaults();
 }
 
 void OptionDialog::resetToDefaults()
 {
     m_options->resetToDefaults();
     slotEncodingChanged();
 }
 
 /** Initialise the widgets using the values in the public varibles. */
 void OptionDialog::setState()
 {
     m_options->setToCurrent();
 
     slotEncodingChanged();
 }
 
 void OptionDialog::saveOptions(KSharedConfigPtr config)
 {
     // No i18n()-Translations here!
     m_options->saveOptions(config);
 }
 
 void OptionDialog::readOptions(KSharedConfigPtr config)
 {
     // No i18n()-Translations here!
     m_options->readOptions(config);
 
     setState();
 }
 
 QString OptionDialog::parseOptions(const QStringList& optionList)
 {
 
     return m_options->parseOptions(optionList);
 }
 
 QString OptionDialog::calcOptionHelp()
 {
     return m_options->calcOptionHelp();
 }
 
 void OptionDialog::slotHistoryMergeRegExpTester()
 {
     QPointer<RegExpTester> dlg=QPointer<RegExpTester>(new RegExpTester(this, s_autoMergeRegExpToolTip, s_historyStartRegExpToolTip,
                      s_historyEntryStartRegExpToolTip, s_historyEntryStartSortKeyOrderToolTip));
     dlg->init(m_pAutoMergeRegExpLineEdit->currentText(), m_pHistoryStartRegExpLineEdit->currentText(),
              m_pHistoryEntryStartRegExpLineEdit->currentText(), m_pHistorySortKeyOrderLineEdit->currentText());
     if(dlg->exec())
     {
         m_pAutoMergeRegExpLineEdit->setEditText(dlg->autoMergeRegExp());
         m_pHistoryStartRegExpLineEdit->setEditText(dlg->historyStartRegExp());
         m_pHistoryEntryStartRegExpLineEdit->setEditText(dlg->historyEntryStartRegExp());
         m_pHistorySortKeyOrderLineEdit->setEditText(dlg->historySortKeyOrder());
     }
 }
 
 #include "optiondialog.moc"
diff --git a/src/pdiff.cpp b/src/pdiff.cpp
index 84075cf..eea45e2 100644
--- a/src/pdiff.cpp
+++ b/src/pdiff.cpp
@@ -1,2485 +1,2478 @@
 /***************************************************************************
  *   Copyright (C) 2003-2007 by Joachim Eibl <joachim.eibl at gmx.de>      *
  *   Copyright (C) 2018 Michael Reeves reeves.87@gmail.com                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #include "difftextwindow.h"
 #include "directorymergewindow.h"
 #include "fileaccess.h"
 #include "Logging.h"
 #include "kdiff3.h"
 #include "optiondialog.h"
 #include "progress.h"
 #include "Utils.h"
 #include "DirectoryInfo.h"
 
 #include "mergeresultwindow.h"
 #include "smalldialogs.h"
 
 #include <algorithm>
 #include <cstdio>
 #include <list>
 
 #include <QCheckBox>
 #include <QClipboard>
 #include <QComboBox>
 #include <QDir>
 #include <QDialog>
 #include <QEvent> // QKeyEvent, QDropEvent, QInputEvent
 #include <QFile>
 #include <QLayout>
 #include <QLineEdit>
 #include <QMimeData>
 #include <QPointer>
 #include <QProcess>
 #include <QScrollBar>
 #include <QSplitter>
 #include <QStatusBar>
 #include <QStringList>
 #include <QTextCodec>
 #include <QUrl>
 
 #include <KLocalizedString>
 #include <KShortcutsDialog>
 #include <KMessageBox>
 
 bool g_bIgnoreWhiteSpace = true;
 bool g_bIgnoreTrivialMatches = true;
 
 // Just make sure that all input lines are in the output too, exactly once.
 void Diff3LineList::debugLineCheck(const LineCount size, const e_SrcSelector srcSelector) const
 {
     Diff3LineList::const_iterator it = begin();
     int i = 0;
 
     for(it = begin(); it != end(); ++it)
     {
         LineRef line;
 
         Q_ASSERT(srcSelector == A || srcSelector == B || srcSelector == C);
         if(srcSelector == A)
             line = it->getLineA();
         else if(srcSelector == B)
             line = it->getLineB();
         else if(srcSelector == C)
             line = it->getLineC();
 
         if(line.isValid())
         {
             if(line != i)
             {
                 KMessageBox::error(nullptr, i18n(
                                           "Data loss error:\n"
                                           "If it is reproducible please contact the author.\n"),
                                    i18n("Severe Internal Error"));
 
                 qCCritical(kdiffMain) << i18n("Severe Internal Error.") << " line != i for srcSelector=" << srcSelector << "\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"));
 
         qCCritical(kdiffMain) << i18n("Severe Internal Error.: ") << size << " != " << i << "\n";
         ::exit(-1);
     }
 }
 
 void KDiff3App::mainInit(TotalDiffStatus* pTotalDiffStatus, bool bLoadFiles, bool bUseCurrentEncoding)
 {
     ProgressProxy pp;
     QStringList errors;
     // When doing a full analysis in the directory-comparison, then the statistics-results
     // will be stored in the given TotalDiffStatus. Otherwise it will be 0.
     bool bGUI = pTotalDiffStatus == nullptr;
     if(pTotalDiffStatus == nullptr)
         pTotalDiffStatus = &m_totalDiffStatus;
 
     //bool bPreserveCarriageReturn = m_pOptions->m_bPreserveCarriageReturn;
 
     bool bVisibleMergeResultWindow = !m_outputFilename.isEmpty();
     if(bVisibleMergeResultWindow && bGUI)
     {
         //bPreserveCarriageReturn = false;
 
         QString msg;
 
         if(!m_pOptions->m_PreProcessorCmd.isEmpty())
         {
             msg += "- " + i18n("PreprocessorCmd: ") + m_pOptions->m_PreProcessorCmd + '\n';
         }
         if(!msg.isEmpty())
         {
             int result = KMessageBox::warningYesNo(this,
                                                    i18n("The following option(s) you selected might change data:\n") + msg +
                                                        i18n("\nMost likely this is not wanted during a merge.\n"
                                                             "Do you want to disable these settings or continue with these settings active?"),
                                                    i18n("Option Unsafe for Merging"),
                                                    KGuiItem(i18n("Use These Options During Merge")),
                                                    KGuiItem(i18n("Disable Unsafe Options")));
 
             if(result == KMessageBox::No)
             {
                 m_pOptions->m_PreProcessorCmd = "";
             }
         }
     }
 
     // Because of the progressdialog paintevents can occur, but data is invalid,
     // so painting must be suppressed
     if(bGUI) setLockPainting(true);
 
     //insure merge result window never has stale iterators.
     if(m_pMergeResultWindow) m_pMergeResultWindow->clearMergeList();
     m_diff3LineList.clear();
     m_diff3LineVector.clear();
 
     if(bLoadFiles)
     {
         m_manualDiffHelpList.clear();
 
         if(m_sd3.isEmpty())
             pp.setMaxNofSteps(4); // Read 2 files, 1 comparison, 1 finediff
         else
             pp.setMaxNofSteps(9); // Read 3 files, 3 comparisons, 3 finediffs
 
         // First get all input data.
         pp.setInformation(i18n("Loading A"));
         qCInfo(kdiffMain) << i18n("Loading A: %1", m_sd1.getFilename());
 
         if(bUseCurrentEncoding)
             errors = m_sd1.readAndPreprocess(m_sd1.getEncoding(), false);
         else
             errors = m_sd1.readAndPreprocess(m_pOptions->m_pEncodingA, m_pOptions->m_bAutoDetectUnicodeA);
 
         if(!errors.isEmpty())
         {
             KMessageBox::errorList(m_pOptionDialog, i18n("Errors occurred during pre-processing of file A."), errors);
         }
 
         pp.step();
 
         pp.setInformation(i18n("Loading B"));
         qCInfo(kdiffMain) << i18n("Loading B: %1", m_sd2.getFilename());
 
         if(bUseCurrentEncoding)
             errors = m_sd2.readAndPreprocess(m_sd2.getEncoding(), false);
         else
             errors = m_sd2.readAndPreprocess(m_pOptions->m_pEncodingB, m_pOptions->m_bAutoDetectUnicodeB);
 
         if(!errors.isEmpty())
             KMessageBox::errorList(m_pOptionDialog, i18n("Errors occurred during pre-processing of file B."), errors);
 
         pp.step();
     }
     else
     {
         if(m_sd3.isEmpty())
             pp.setMaxNofSteps(2); // 1 comparison, 1 finediff
         else
             pp.setMaxNofSteps(6); // 3 comparisons, 3 finediffs
     }
 
     if(pTotalDiffStatus)
         pTotalDiffStatus->reset();
     if(errors.isEmpty())
     {
         // Run the diff.
         if(m_sd3.isEmpty())
         {
             pTotalDiffStatus->bBinaryAEqB = m_sd1.isBinaryEqualWith(m_sd2);
 
             if(m_sd1.isText() && m_sd2.isText())
             {
                pp.setInformation(i18n("Diff: A <-> B"));
                qCInfo(kdiffMain) << i18n("Diff: A <-> B") ;
                m_manualDiffHelpList.runDiff(m_sd1.getLineDataForDiff(), m_sd1.getSizeLines(), m_sd2.getLineDataForDiff(), m_sd2.getSizeLines(), m_diffList12, A, B,
                         m_pOptionDialog->getOptions());
 
                 pp.step();
 
                 pp.setInformation(i18n("Linediff: A <-> B"));
                 qCInfo(kdiffMain) << i18n("Linediff: A <-> B") ;
                 m_diff3LineList.calcDiff3LineListUsingAB(&m_diffList12);
                 pTotalDiffStatus->bTextAEqB = m_diff3LineList.fineDiff(A, m_sd1.getLineDataForDisplay(), m_sd2.getLineDataForDisplay());
                 if(m_sd1.getSizeBytes() == 0) pTotalDiffStatus->bTextAEqB = false;
 
                 pp.step();
             }
             else
             {
                 pp.step();
                 pp.step();
             }
         }
         else
         {
             if(bLoadFiles)
             {
                 pp.setInformation(i18n("Loading C"));
                 if(bUseCurrentEncoding)
                     errors = m_sd3.readAndPreprocess(m_sd3.getEncoding(), false);
                 else
                     errors = m_sd3.readAndPreprocess(m_pOptions->m_pEncodingC, m_pOptions->m_bAutoDetectUnicodeC);
 
                 if(!errors.isEmpty())
                     KMessageBox::errorList(m_pOptionDialog, i18n("Errors occurred during pre-processing of file C."), errors);
 
                 pp.step();
             }
 
             pTotalDiffStatus->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"));
             if(m_sd1.isText() && m_sd2.isText())
             {
                 m_manualDiffHelpList.runDiff(m_sd1.getLineDataForDiff(), m_sd1.getSizeLines(), m_sd2.getLineDataForDiff(), m_sd2.getSizeLines(), m_diffList12, A, B,
                         m_pOptionDialog->getOptions());
 
                 m_diff3LineList.calcDiff3LineListUsingAB(&m_diffList12);
             }
             pp.step();
             pp.setInformation(i18n("Diff: A <-> C"));
             if(m_sd1.isText() && m_sd3.isText())
             {
                 m_manualDiffHelpList.runDiff(m_sd1.getLineDataForDiff(), m_sd1.getSizeLines(), m_sd3.getLineDataForDiff(), m_sd3.getSizeLines(), m_diffList13, A, C,
                         m_pOptionDialog->getOptions());
 
                 m_diff3LineList.calcDiff3LineListUsingAC(&m_diffList13);
                 m_diff3LineList.correctManualDiffAlignment(&m_manualDiffHelpList);
                 m_diff3LineList.calcDiff3LineListTrim(m_sd1.getLineDataForDiff(), m_sd2.getLineDataForDiff(), m_sd3.getLineDataForDiff(), &m_manualDiffHelpList);
             }
             pp.step();
             pp.setInformation(i18n("Diff: B <-> C"));
             if(m_sd2.isText() && m_sd3.isText())
             {
                 m_manualDiffHelpList.runDiff(m_sd2.getLineDataForDiff(), m_sd2.getSizeLines(), m_sd3.getLineDataForDiff(), m_sd3.getSizeLines(), m_diffList23, B, C,
                         m_pOptionDialog->getOptions());
                 if(m_pOptions->m_bDiff3AlignBC)
                 {
                     m_diff3LineList.calcDiff3LineListUsingBC(&m_diffList23);
                     m_diff3LineList.correctManualDiffAlignment(&m_manualDiffHelpList);
                     m_diff3LineList.calcDiff3LineListTrim(m_sd1.getLineDataForDiff(), m_sd2.getLineDataForDiff(), m_sd3.getLineDataForDiff(), &m_manualDiffHelpList);
                 }
             }
             pp.step();
 
             m_diff3LineList.debugLineCheck(m_sd1.getSizeLines(), A);
             m_diff3LineList.debugLineCheck(m_sd2.getSizeLines(), B);
             m_diff3LineList.debugLineCheck(m_sd3.getSizeLines(), C);
 
             pp.setInformation(i18n("Linediff: A <-> B"));
             if(m_sd1.hasData() && m_sd2.hasData() && m_sd1.isText() && m_sd2.isText())
               pTotalDiffStatus->bTextAEqB = m_diff3LineList.fineDiff(A, m_sd1.getLineDataForDisplay(), m_sd2.getLineDataForDisplay());
             pp.step();
             pp.setInformation(i18n("Linediff: B <-> C"));
             if(m_sd2.hasData() && m_sd3.hasData() && m_sd2.isText() && m_sd3.isText())
             pTotalDiffStatus->bTextBEqC = m_diff3LineList.fineDiff(B, m_sd2.getLineDataForDisplay(), m_sd3.getLineDataForDisplay());
             pp.step();
             pp.setInformation(i18n("Linediff: A <-> C"));
             if(m_sd1.hasData() && m_sd3.hasData() && m_sd1.isText() && m_sd3.isText())
               pTotalDiffStatus->bTextAEqC = m_diff3LineList.fineDiff(C, m_sd3.getLineDataForDisplay(), m_sd1.getLineDataForDisplay());
             m_diff3LineList.debugLineCheck(m_sd2.getSizeLines(), B);
             m_diff3LineList.debugLineCheck(m_sd3.getSizeLines(), C);
 
             pp.setInformation(i18n("Linediff: A <-> B"));
             if(m_sd1.hasData() && m_sd2.hasData() && m_sd1.isText() && m_sd2.isText())
                 pTotalDiffStatus->bTextAEqB = m_diff3LineList.fineDiff(A, m_sd1.getLineDataForDisplay(), m_sd2.getLineDataForDisplay());
             pp.step();
             pp.setInformation(i18n("Linediff: B <-> C"));
             if(m_sd3.hasData() && m_sd2.hasData() && m_sd3.isText() && m_sd2.isText())
                 pTotalDiffStatus->bTextBEqC = m_diff3LineList.fineDiff(B, m_sd2.getLineDataForDisplay(), m_sd3.getLineDataForDisplay());
             pp.step();
             pp.setInformation(i18n("Linediff: A <-> C"));
             if(m_sd1.hasData() && m_sd3.hasData() && m_sd1.isText() && m_sd3.isText())
               pTotalDiffStatus->bTextAEqC = m_diff3LineList.fineDiff(C, 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;
             }
         }
     }
     else
     {
         pp.clear();
     }
 
     if(errors.isEmpty() && m_sd1.isText() && m_sd2.isText())
     {
         m_diffBufferInfo.init(&m_diff3LineList, &m_diff3LineVector,
                           m_sd1.getLineDataForDiff(), m_sd1.getSizeLines(),
                           m_sd2.getLineDataForDiff(), m_sd2.getSizeLines(),
                           m_sd3.getLineDataForDiff(), m_sd3.getSizeLines());
 
         m_diff3LineList.calcWhiteDiff3Lines(m_sd1.getLineDataForDiff(), m_sd2.getLineDataForDiff(), m_sd3.getLineDataForDiff());
         m_diff3LineList.calcDiff3LineVector(m_diff3LineVector);
     }
 
     // Calc needed lines for display
     m_neededLines = m_diff3LineList.size();
 
     QList<int> oldHeights;
     if(m_pDirectoryMergeSplitter->isVisible())
         oldHeights = m_pMainSplitter->sizes();
 
     initView();
     m_pMergeResultWindow->connectActions();
 
     if(m_pDirectoryMergeSplitter->isVisible())
     {
         if(oldHeights.count() < 2)
             oldHeights.append(0);
         if(oldHeights[1] == 0) // Distribute the available space evenly between the two widgets.
         {
             oldHeights[1] = oldHeights[0] / 2;
             oldHeights[0] -= oldHeights[1];
         }
         if(oldHeights[0] == 0 && oldHeights[1] == 0)
         {
             oldHeights[1] = 100;
             oldHeights[0] = 100;
         }
         m_pMainSplitter->setSizes(oldHeights);
     }
 
     m_pMainWidget->setVisible(bGUI);
 
     m_bTripleDiff = !m_sd3.isEmpty();
 
     m_pMergeResultWindowTitle->setEncodings(m_sd1.getEncoding(), m_sd2.getEncoding(), m_sd3.getEncoding());
     if(!m_pOptions->m_bAutoSelectOutEncoding)
         m_pMergeResultWindowTitle->setEncoding(m_pOptions->m_pEncodingOut);
 
     m_pMergeResultWindowTitle->setLineEndStyles(m_sd1.getLineEndStyle(), m_sd2.getLineEndStyle(), m_sd3.getLineEndStyle());
 
     if(bGUI)
     {
         const ManualDiffHelpList* pMDHL = &m_manualDiffHelpList;
         m_pDiffTextWindow1->init(m_sd1.getAliasName(), m_sd1.getEncoding(), m_sd1.getLineEndStyle(),
                                  m_sd1.getLineDataForDisplay(), m_sd1.getSizeLines(), &m_diff3LineVector, pMDHL, m_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();
     }
     else
     {
         m_pOverview->init(&m_diff3LineList, m_bTripleDiff);
         m_pDiffVScrollBar->setValue(0);
         m_pHScrollBar->setValue(0);
         m_pMergeVScrollBar->setValue(0);
         setLockPainting(false);
 
         if(!bVisibleMergeResultWindow)
             m_pMergeWindowFrame->hide();
         else
             m_pMergeWindowFrame->show();
 
         // Try to create a meaningful but not too long caption
         if(!isPart() && errors.isEmpty())
         {
             createCaption();
         }
 
         //initialize wheel tracking to zero
         m_iCumulativeWheelDelta = 0;
 
         m_bFinishMainInit = true; // call slotFinishMainInit after finishing the word wrap
         m_bLoadFiles = bLoadFiles;
         postRecalcWordWrap();
     }
 }
 
 void KDiff3App::setLockPainting(bool bLock)
 {
     if(m_pDiffTextWindow1) m_pDiffTextWindow1->setPaintingAllowed(!bLock);
     if(m_pDiffTextWindow2) m_pDiffTextWindow2->setPaintingAllowed(!bLock);
     if(m_pDiffTextWindow3) m_pDiffTextWindow3->setPaintingAllowed(!bLock);
     if(m_pOverview) m_pOverview->setPaintingAllowed(!bLock);
     if(m_pMergeResultWindow) m_pMergeResultWindow->setPaintingAllowed(!bLock);
 }
 
 void KDiff3App::createCaption()
 {
     // Try to create a meaningful but not too long caption
     // 1. If the filenames are equal then show only one filename
     QString caption;
     QString f1 = m_sd1.getAliasName();
     QString f2 = m_sd2.getAliasName();
     QString f3 = m_sd3.getAliasName();
     int p;
 
     if((p = f1.lastIndexOf('/')) >= 0 || (p = f1.lastIndexOf('\\')) >= 0)
         f1 = f1.mid(p + 1);
     if((p = f2.lastIndexOf('/')) >= 0 || (p = f2.lastIndexOf('\\')) >= 0)
         f2 = f2.mid(p + 1);
     if((p = f3.lastIndexOf('/')) >= 0 || (p = f3.lastIndexOf('\\')) >= 0)
         f3 = f3.mid(p + 1);
 
     if(!f1.isEmpty())
     {
         if((f2.isEmpty() && f3.isEmpty()) ||
            (f2.isEmpty() && f1 == f3) || (f3.isEmpty() && f1 == f2) || (f1 == f2 && f1 == f3))
             caption = f1;
     }
     else if(!f2.isEmpty())
     {
         if(f3.isEmpty() || f2 == f3)
             caption = f2;
     }
     else if(!f3.isEmpty())
         caption = f3;
 
     // 2. If the files don't have the same name then show all names
     if(caption.isEmpty() && (!f1.isEmpty() || !f2.isEmpty() || !f3.isEmpty()))
     {
         caption = (f1.isEmpty() ? QString("") : f1);
         caption += QLatin1String(caption.isEmpty() || f2.isEmpty() ? "" : " <-> ") + (f2.isEmpty() ? QString("") : f2);
         caption += QLatin1String(caption.isEmpty() || f3.isEmpty() ? "" : " <-> ") + (f3.isEmpty() ? QString("") : f3);
     }
 
     m_pKDiff3Shell->setWindowTitle(caption.isEmpty() ? QString("KDiff3") : caption + QString(" - KDiff3"));
 }
 
 void KDiff3App::setHScrollBarRange()
 {
     int w1 = m_pDiffTextWindow1 != nullptr && m_pDiffTextWindow1->isVisible() ? m_pDiffTextWindow1->getMaxTextWidth() : 0;
     int w2 = m_pDiffTextWindow2 != nullptr && m_pDiffTextWindow2->isVisible() ? m_pDiffTextWindow2->getMaxTextWidth() : 0;
     int w3 = m_pDiffTextWindow3 != nullptr && m_pDiffTextWindow3->isVisible() ? m_pDiffTextWindow3->getMaxTextWidth() : 0;
 
     int wm = m_pMergeResultWindow != nullptr && m_pMergeResultWindow->isVisible() ? m_pMergeResultWindow->getMaxTextWidth() : 0;
 
     int v1 = m_pDiffTextWindow1 != nullptr && m_pDiffTextWindow1->isVisible() ? m_pDiffTextWindow1->getVisibleTextAreaWidth() : 0;
     int v2 = m_pDiffTextWindow2 != nullptr && m_pDiffTextWindow2->isVisible() ? m_pDiffTextWindow2->getVisibleTextAreaWidth() : 0;
     int v3 = m_pDiffTextWindow3 != nullptr && m_pDiffTextWindow3->isVisible() ? m_pDiffTextWindow3->getVisibleTextAreaWidth() : 0;
     int vm = m_pMergeResultWindow != nullptr && m_pMergeResultWindow->isVisible() ? m_pMergeResultWindow->getVisibleTextAreaWidth() : 0;
 
     // Find the minimum, but don't consider 0.
     int pageStep = 0;
     if((pageStep == 0 || pageStep > v1) && v1 > 0)
         pageStep = v1;
     if((pageStep == 0 || pageStep > v2) && v2 > 0)
         pageStep = v2;
     if((pageStep == 0 || pageStep > v3) && v3 > 0)
         pageStep = v3;
     if((pageStep == 0 || pageStep > vm) && vm > 0)
         pageStep = vm;
 
     int rangeMax = 0;
     if(w1 > v1 && w1 - v1 > rangeMax && v1 > 0)
         rangeMax = w1 - v1;
     if(w2 > v2 && w2 - v2 > rangeMax && v2 > 0)
         rangeMax = w2 - v2;
     if(w3 > v3 && w3 - v3 > rangeMax && v3 > 0)
         rangeMax = w3 - v3;
     if(wm > vm && wm - vm > rangeMax && vm > 0)
         rangeMax = wm - vm;
 
     m_pHScrollBar->setRange(0, rangeMax);
     m_pHScrollBar->setPageStep(pageStep);
 }
 
 void KDiff3App::resizeDiffTextWindowHeight(int newHeight)
 {
     m_DTWHeight = newHeight;
 
     m_pDiffVScrollBar->setRange(0, std::max(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, std::max(0, p->getNofLines() - p->getNofVisibleLines()));
     m_pMergeVScrollBar->setPageStep(p->getNofVisibleLines());
 
     setHScrollBarRange();
 }
 
 void KDiff3App::scrollDiffTextWindow(int deltaX, int deltaY)
 {
     if(deltaY != 0 && m_pDiffVScrollBar != nullptr)
     {
         m_pDiffVScrollBar->setValue(m_pDiffVScrollBar->value() + deltaY);
         m_pOverview->setRange(m_pDiffVScrollBar->value(), m_pDiffVScrollBar->pageStep());
     }
     if(deltaX != 0 && m_pHScrollBar != nullptr)
         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(std::max(s.width(), 0), std::max(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->getOptions());
     m_pOverview->setObjectName("Overview");
     pDiffHLayout->addWidget(m_pOverview);
     connect(m_pOverview, &Overview::setLine, this, &KDiff3App::setDiff3Line);
 
     m_pDiffVScrollBar = new QScrollBar(Qt::Vertical, pDiffWindowFrame);
     pDiffHLayout->addWidget(m_pDiffVScrollBar);
 
     m_pDiffTextWindowFrame1 = new DiffTextWindowFrame(m_pDiffWindowSplitter, statusBar(), m_pOptionDialog->getOptions(), A, &m_sd1);
     m_pDiffWindowSplitter->addWidget(m_pDiffTextWindowFrame1);
     m_pDiffTextWindowFrame2 = new DiffTextWindowFrame(m_pDiffWindowSplitter, statusBar(), m_pOptionDialog->getOptions(), B, &m_sd2);
     m_pDiffWindowSplitter->addWidget(m_pDiffTextWindowFrame2);
     m_pDiffTextWindowFrame3 = new DiffTextWindowFrame(m_pDiffWindowSplitter, statusBar(), m_pOptionDialog->getOptions(), C, &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, &DiffTextWindowFrame::fileNameChanged, this, &KDiff3App::slotFileNameChanged);
     connect(m_pDiffTextWindowFrame2, &DiffTextWindowFrame::fileNameChanged, this, &KDiff3App::slotFileNameChanged);
     connect(m_pDiffTextWindowFrame3, &DiffTextWindowFrame::fileNameChanged, this, &KDiff3App::slotFileNameChanged);
 
     connect(m_pDiffTextWindowFrame1, &DiffTextWindowFrame::encodingChanged, this, &KDiff3App::slotEncodingChanged);
     connect(m_pDiffTextWindowFrame2, &DiffTextWindowFrame::encodingChanged, this, &KDiff3App::slotEncodingChanged);
     connect(m_pDiffTextWindowFrame3, &DiffTextWindowFrame::encodingChanged, this, &KDiff3App::slotEncodingChanged);
 
     connect(m_pDiffTextWindowFrame1, &DiffTextWindowFrame::encodingChanged, &m_sd1, &SourceData::setEncoding);
     connect(m_pDiffTextWindowFrame2, &DiffTextWindowFrame::encodingChanged, &m_sd2, &SourceData::setEncoding);
     connect(m_pDiffTextWindowFrame3, &DiffTextWindowFrame::encodingChanged, &m_sd3, &SourceData::setEncoding);
 
     // Merge window
     m_pMergeWindowFrame = new QWidget(pVSplitter);
     m_pMergeWindowFrame->setObjectName("MergeWindowFrame");
     pVSplitter->addWidget(m_pMergeWindowFrame);
     QHBoxLayout* pMergeHLayout = new QHBoxLayout(m_pMergeWindowFrame);
     pMergeHLayout->setMargin(0);
     pMergeHLayout->setSpacing(0);
     QVBoxLayout* pMergeVLayout = new QVBoxLayout();
     pMergeHLayout->addLayout(pMergeVLayout, 1);
 
     m_pMergeResultWindowTitle = new WindowTitleWidget(m_pOptionDialog->getOptions());
     pMergeVLayout->addWidget(m_pMergeResultWindowTitle);
 
     m_pMergeResultWindow = new MergeResultWindow(m_pMergeWindowFrame, m_pOptionDialog->getOptions(), statusBar());
     pMergeVLayout->addWidget(m_pMergeResultWindow, 1);
 
     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 drop and focus events
     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, &QScrollBar::valueChanged, m_pDiffTextWindow1, &DiffTextWindow::setFirstLine);
     connect(m_pHScrollBar, &ReversibleScrollBar::valueChanged2, m_pDiffTextWindow1, &DiffTextWindow::setHorizScrollOffset);
     connect(m_pDiffTextWindow1, &DiffTextWindow::newSelection, this, &KDiff3App::slotSelectionStart);
     connect(m_pDiffTextWindow1, &DiffTextWindow::selectionEnd, this, &KDiff3App::slotSelectionEnd);
     connect(m_pDiffTextWindow1, &DiffTextWindow::scrollDiffTextWindow, this, &KDiff3App::scrollDiffTextWindow);
     connect(m_pDiffTextWindow1, &DiffTextWindow::finishRecalcWordWrap, this, &KDiff3App::slotFinishRecalcWordWrap, Qt::QueuedConnection);
     m_pDiffTextWindow1->installEventFilter(this);
 
     connect(m_pDiffVScrollBar, &QScrollBar::valueChanged, m_pDiffTextWindow2, &DiffTextWindow::setFirstLine);
     connect(m_pHScrollBar, &ReversibleScrollBar::valueChanged2, m_pDiffTextWindow2, &DiffTextWindow::setHorizScrollOffset);
     connect(m_pDiffTextWindow2, &DiffTextWindow::newSelection, this, &KDiff3App::slotSelectionStart);
     connect(m_pDiffTextWindow2, &DiffTextWindow::selectionEnd, this, &KDiff3App::slotSelectionEnd);
     connect(m_pDiffTextWindow2, &DiffTextWindow::scrollDiffTextWindow, this, &KDiff3App::scrollDiffTextWindow);
     connect(m_pDiffTextWindow2, &DiffTextWindow::finishRecalcWordWrap, this, &KDiff3App::slotFinishRecalcWordWrap, Qt::QueuedConnection);
 
     m_pDiffTextWindow2->installEventFilter(this);
 
     connect(m_pDiffVScrollBar, &QScrollBar::valueChanged, m_pDiffTextWindow3, &DiffTextWindow::setFirstLine);
     connect(m_pHScrollBar, &ReversibleScrollBar::valueChanged2, m_pDiffTextWindow3, &DiffTextWindow::setHorizScrollOffset);
     connect(m_pDiffTextWindow3, &DiffTextWindow::newSelection, this, &KDiff3App::slotSelectionStart);
     connect(m_pDiffTextWindow3, &DiffTextWindow::selectionEnd, this, &KDiff3App::slotSelectionEnd);
     connect(m_pDiffTextWindow3, &DiffTextWindow::scrollDiffTextWindow, this, &KDiff3App::scrollDiffTextWindow);
     connect(m_pDiffTextWindow3, &DiffTextWindow::finishRecalcWordWrap, this, &KDiff3App::slotFinishRecalcWordWrap, Qt::QueuedConnection);
 
     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, &MergeResultWindow::scrollMergeResultWindow, this, &KDiff3App::scrollMergeResultWindow);
     connect(p, &MergeResultWindow::sourceMask, this, &KDiff3App::sourceMask);
     connect(p, &MergeResultWindow::resizeSignal, this, &KDiff3App::resizeMergeResultWindow);
     connect(p, &MergeResultWindow::selectionEnd, this, &KDiff3App::slotSelectionEnd);
     connect(p, &MergeResultWindow::newSelection, this, &KDiff3App::slotSelectionStart);
     connect(p, &MergeResultWindow::modifiedChanged, this, &KDiff3App::slotOutputModified);
     connect(p, &MergeResultWindow::modifiedChanged, m_pMergeResultWindowTitle, &WindowTitleWidget::slotSetModified);
     connect(p, &MergeResultWindow::updateAvailabilities, this, &KDiff3App::slotUpdateAvailabilities);
     connect(p, &MergeResultWindow::showPopupMenu, this, &KDiff3App::showPopupMenu);
     connect(p, &MergeResultWindow::noRelevantChangesDetected, this, &KDiff3App::slotNoRelevantChangesDetected);
     sourceMask(0, 0);
 
     connect(p, &MergeResultWindow::setFastSelectorRange, m_pDiffTextWindow1, &DiffTextWindow::setFastSelectorRange);
     connect(p, &MergeResultWindow::setFastSelectorRange, m_pDiffTextWindow2, &DiffTextWindow::setFastSelectorRange);
     connect(p, &MergeResultWindow::setFastSelectorRange, m_pDiffTextWindow3, &DiffTextWindow::setFastSelectorRange);
     connect(m_pDiffTextWindow1, &DiffTextWindow::setFastSelectorLine, p, &MergeResultWindow::slotSetFastSelectorLine);
     connect(m_pDiffTextWindow2, &DiffTextWindow::setFastSelectorLine, p, &MergeResultWindow::slotSetFastSelectorLine);
     connect(m_pDiffTextWindow3, &DiffTextWindow::setFastSelectorLine, p, &MergeResultWindow::slotSetFastSelectorLine);
     connect(m_pDiffTextWindow1, &DiffTextWindow::gotFocus, p, &MergeResultWindow::updateSourceMask);
     connect(m_pDiffTextWindow2, &DiffTextWindow::gotFocus, p, &MergeResultWindow::updateSourceMask);
     connect(m_pDiffTextWindow3, &DiffTextWindow::gotFocus, p, &MergeResultWindow::updateSourceMask);
     connect(m_pDirectoryMergeInfo, &DirectoryMergeInfo::gotFocus, p, &MergeResultWindow::updateSourceMask);
 
     connect(m_pDiffTextWindow1, &DiffTextWindow::resizeHeightChangedSignal, this, &KDiff3App::resizeDiffTextWindowHeight);
     // The following two connects cause the wordwrap to be recalced thrice, just to make sure. Better than forgetting one.
     connect(m_pDiffTextWindow1, &DiffTextWindow::resizeWidthChangedSignal, this, &KDiff3App::postRecalcWordWrap);
     connect(m_pDiffTextWindow2, &DiffTextWindow::resizeWidthChangedSignal, this, &KDiff3App::postRecalcWordWrap);
     connect(m_pDiffTextWindow3, &DiffTextWindow::resizeWidthChangedSignal, this, &KDiff3App::postRecalcWordWrap);
 
     m_pDiffTextWindow1->setFocus();
     m_pMainWidget->setMinimumSize(50, 50);
     m_pCornerWidget->setFixedSize(m_pDiffVScrollBar->width(), m_pHScrollBar->height());
     showWindowA->setChecked(true);
     showWindowB->setChecked(true);
     showWindowC->setChecked(true);
 }
 
 int ManualDiffHelpEntry::calcManualDiffFirstDiff3LineIdx(const Diff3LineVector& d3lv)
 {
     int i;
     for(i = 0; i < d3lv.size(); ++i)
     {
         const Diff3Line& d3l = *d3lv[i];
         if((lineA1 >= 0 && lineA1 == d3l.getLineA()) ||
            (lineB1 >= 0 && lineB1 == d3l.getLineB()) ||
            (lineC1 >= 0 && lineC1 == d3l.getLineC()))
             return i;
     }
     return -1;
 }
 
 // called after word wrap is complete
 void KDiff3App::slotFinishMainInit()
 {
     Q_ASSERT(m_pDiffTextWindow1 != nullptr && m_pDiffVScrollBar != nullptr);
 
     setHScrollBarRange();
 
     int newHeight = m_pDiffTextWindow1->getNofVisibleLines();
     /*int newWidth  = m_pDiffTextWindow1->getNofVisibleColumns();*/
     m_DTWHeight = newHeight;
 
     m_pDiffVScrollBar->setRange(0, std::max(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 = m_manualDiffHelpList.front().calcManualDiffFirstDiff3LineIdx(m_diff3LineVector);
     if(d3l >= 0 && m_pDiffTextWindow1)
     {
         int line = m_pDiffTextWindow1->convertDiff3LineIdxToLine(d3l);
         m_pDiffVScrollBar->setValue(std::max(0, line - 1));
     }
     else
     {
         m_pMergeResultWindow->slotGoTop();
         if(!m_outputFilename.isEmpty() && !m_pMergeResultWindow->isUnsolvedConflictAtCurrent())
             m_pMergeResultWindow->slotGoNextUnsolvedConflict();
     }
 
     if(m_pCornerWidget)
         m_pCornerWidget->setFixedSize(m_pDiffVScrollBar->width(), m_pHScrollBar->height());
 
     slotUpdateAvailabilities();
     setUpdatesEnabled(true);
-    // TODO What bug? Seems fixed.
-    // Workaround for a Qt-bug
-    /*QList<QTreeView*> treeViews = findChildren<QTreeView*>();
-    for(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", i18n("A"), i18n("B"));
                 else if(pTotalDiffStatus->bTextAEqB)
                     totalInfo += i18n("Files %1 and %2 have equal text, but are not binary equal. \n", i18n("A"), i18n("B"));
                 if(pTotalDiffStatus->bBinaryAEqC)
                     totalInfo += i18n("Files %1 and %2 are binary equal.\n", i18n("A"), i18n("C"));
                 else if(pTotalDiffStatus->bTextAEqC)
                     totalInfo += i18n("Files %1 and %2 have equal text, but are not binary equal. \n", i18n("A"), i18n("C"));
                 if(pTotalDiffStatus->bBinaryBEqC)
                     totalInfo += i18n("Files %1 and %2 are binary equal.\n", i18n("B"), i18n("C"));
                 else if(pTotalDiffStatus->bTextBEqC)
                     totalInfo += i18n("Files %1 and %2 have equal text, but are not binary equal. \n", i18n("B"), i18n("C"));
             }
 
             if(!totalInfo.isEmpty())
                 KMessageBox::information(this, totalInfo);
         }
 
         if(bVisibleMergeResultWindow && (!m_sd1.isText() || !m_sd2.isText() || !m_sd3.isText()))
         {
             KMessageBox::information(this, i18n(
                                                "Some input files do not seem to be pure text files.\n"
                                                "Note that the KDiff3 merge was not meant for binary data.\n"
                                                "Continue at your own risk."));
         }
         if(m_sd1.isIncompleteConversion() || m_sd2.isIncompleteConversion() || m_sd3.isIncompleteConversion())
         {
             QString files;
             if(m_sd1.isIncompleteConversion())
                 files += i18n("A");
             if(m_sd2.isIncompleteConversion())
                 files += files.isEmpty() ? i18n("B") : i18n(", B");
             if(m_sd3.isIncompleteConversion())
                 files += files.isEmpty() ? i18n("C") : i18n(", C");
 
             KMessageBox::information(this, i18n("Some input characters could not be converted to valid unicode.\n"
                                                 "You might be using the wrong codec. (e.g. UTF-8 for non UTF-8 files).\n"
                                                 "Do not save the result if unsure. Continue at your own risk.\n"
                                                 "Affected input files are in %1.", files));
         }
     }
 
     if(bVisibleMergeResultWindow && m_pMergeResultWindow)
     {
         m_pMergeResultWindow->setFocus();
     }
     else if(m_pDiffTextWindow1)
     {
         m_pDiffTextWindow1->setFocus();
     }
 }
 
 void KDiff3App::resizeEvent(QResizeEvent* e)
 {
     QSplitter::resizeEvent(e);
     if(m_pCornerWidget)
         m_pCornerWidget->setFixedSize(m_pDiffVScrollBar->width(), m_pHScrollBar->height());
 }
 
 void KDiff3App::wheelEvent(QWheelEvent* pWheelEvent)
 {
     pWheelEvent->accept();
 
     int deltaX = 0;
 
     int d = pWheelEvent->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);
 }
 
 void KDiff3App::keyPressEvent(QKeyEvent* keyEvent)
 {
     if(keyEvent->key() == Qt::Key_Escape && m_pKDiff3Shell && m_pOptions->m_bEscapeKeyQuits)
     {
         m_pKDiff3Shell->close();
         return;
     }
 
     //FIXME: Move use QAction
     int deltaX = 0;
     int deltaY = 0;
     int pageSize = m_DTWHeight;
     bool bCtrl = (keyEvent->QInputEvent::modifiers() & Qt::ControlModifier) != 0;
 
     switch(keyEvent->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)
             {
                 if(m_pDiffVScrollBar != nullptr) m_pDiffVScrollBar->setValue(0);
             }
             else
             {
                 if(m_pHScrollBar != nullptr)  m_pHScrollBar->setValue(0);
             }
             break;
         case Qt::Key_End:
             if(bCtrl)
             {
                 if(m_pDiffVScrollBar != nullptr) m_pDiffVScrollBar->setValue(m_pDiffVScrollBar->maximum());
             }
             else
             {
                 if(m_pHScrollBar != nullptr) m_pHScrollBar->setValue(m_pHScrollBar->maximum());
             }
             break;
         default:
             break;
     }
 
     scrollDiffTextWindow(deltaX, deltaY);
 }
 
 bool KDiff3App::eventFilter(QObject* o, QEvent* e)
 { //TODO: Move this into DiffTextWindow::DropEvent
     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);
                 for(const QString& error: qAsConst(errors))
                 {
                     KMessageBox::error(m_pOptionDialog, error);
                 }
                 mainInit();
             }
         }
     }
 
     return QSplitter::eventFilter(o, e); // standard event processing
 }
 
 void KDiff3App::slotFileOpen()
 {
     if(!canContinue()) return;
     //create dummy DirectoryInfo record for first run so we don't crash.
     if(m_dirinfo == nullptr)
         m_dirinfo = QSharedPointer<DirectoryInfo>::create();
 
     if(m_pDirectoryMergeWindow->isDirectoryMergeInProgress())
     {
         int result = KMessageBox::warningYesNo(this,
                                                i18n("You are currently doing a 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(;;)
     {
          QPointer<OpenDialog> d = QPointer<OpenDialog>(new OpenDialog(this,
                      QDir::toNativeSeparators(m_bDirCompare ? m_dirinfo->dirA().prettyAbsPath() : m_sd1.isFromBuffer() ? QString("") : m_sd1.getAliasName()),
                      QDir::toNativeSeparators(m_bDirCompare ? m_dirinfo->dirB().prettyAbsPath() : m_sd2.isFromBuffer() ? QString("") : m_sd2.getAliasName()),
                      QDir::toNativeSeparators(m_bDirCompare ? m_dirinfo->dirC().prettyAbsPath() : m_sd3.isFromBuffer() ? QString("") : m_sd3.getAliasName()),
                      m_bDirCompare ? !m_dirinfo->destDir().prettyAbsPath().isEmpty() : !m_outputFilename.isEmpty(),
                      QDir::toNativeSeparators(m_bDefaultFilename ? QString("") : m_outputFilename), m_pOptionDialog->getOptions()));
 
         int status = d->exec();
         if(status == QDialog::Accepted)
         {
             m_sd1.setFilename(d->m_pLineA->currentText());
             m_sd2.setFilename(d->m_pLineB->currentText());
             m_sd3.setFilename(d->m_pLineC->currentText());
 
             if(d->m_pMerge->isChecked())
             {
                 if(d->m_pLineOut->currentText().isEmpty())
                 {
                     m_outputFilename = "unnamed.txt";
                     m_bDefaultFilename = true;
                 }
                 else
                 {
                     m_outputFilename = d->m_pLineOut->currentText();
                     m_bDefaultFilename = false;
                 }
             }
             else
                 m_outputFilename = "";
 
             m_bDirCompare = FileAccess(m_sd1.getFilename()).isDir();
             bool bSuccess = improveFilenames(false);
 
             if(!bSuccess)
                 continue;
 
             if(m_bDirCompare)
             {
                 m_pDirectoryMergeSplitter->show();
                 if(m_pMainWidget != nullptr)
                 {
                     m_pMainWidget->hide();
                 }
                 break;
             }
             else
             {
                 m_pDirectoryMergeSplitter->hide();
                 mainInit();
 
                 if((!m_sd1.isEmpty() && !m_sd1.hasData()) ||
                    (!m_sd2.isEmpty() && !m_sd2.hasData()) ||
                    (!m_sd3.isEmpty() && !m_sd3.hasData()))
                 {
                     QString text(i18n("Opening of these files failed:"));
                     text += "\n\n";
                     if(!m_sd1.isEmpty() && !m_sd1.hasData())
                         text += " - " + m_sd1.getAliasName() + '\n';
                     if(!m_sd2.isEmpty() && !m_sd2.hasData())
                         text += " - " + m_sd2.getAliasName() + '\n';
                     if(!m_sd3.isEmpty() && !m_sd3.hasData())
                         text += " - " + m_sd3.getAliasName() + '\n';
 
                     KMessageBox::sorry(this, text, i18n("File open error"));
                     continue;
                 }
             }
         }
         break;
     }
 
     slotUpdateAvailabilities();
     slotStatusMsg(i18n("Ready."));
 }
 
 void KDiff3App::slotFileOpen2(const QString& fn1, const QString& fn2, const QString& fn3, const QString& ofn,
                               const QString& an1, const QString& an2, const QString& an3, TotalDiffStatus* pTotalDiffStatus)
 {
     if(!canContinue()) return;
 
     if(fn1.isEmpty() && fn2.isEmpty() && fn3.isEmpty() && ofn.isEmpty() && m_pMainWidget != nullptr)
     {
         m_pMainWidget->hide();
         return;
     }
 
     slotStatusMsg(i18n("Opening files..."));
 
     m_sd1.setFilename(fn1);
     m_sd2.setFilename(fn2);
     m_sd3.setFilename(fn3);
 
     m_sd1.setAliasName(an1);
     m_sd2.setAliasName(an2);
     m_sd3.setAliasName(an3);
 
     if(!ofn.isEmpty())
     {
         m_outputFilename = ofn;
         m_bDefaultFilename = false;
     }
     else
     {
         m_outputFilename = "";
         m_bDefaultFilename = true;
     }
 
     improveFilenames(true); // Create new window for KDiff3 for directory comparison.
 
     if(!FileAccess(m_sd1.getFilename()).isDir())
     {
         mainInit(pTotalDiffStatus);
 
         if(pTotalDiffStatus != nullptr)
             return;
 
         if(!((!m_sd1.isEmpty() && !m_sd1.hasData()) ||
            (!m_sd2.isEmpty() && !m_sd2.hasData()) ||
            (!m_sd3.isEmpty() && !m_sd3.hasData())))
         {
             if(m_pDirectoryMergeWindow != nullptr && m_pDirectoryMergeWindow->isVisible() && !dirShowBoth->isChecked())
             {
                 slotDirViewToggle();
             }
         }
     }
     slotStatusMsg(i18n("Ready."));
 }
 
 void KDiff3App::slotFileNameChanged(const QString& fileName, e_SrcSelector winIdx)
 {
     QString fn1 = m_sd1.getFilename();
     QString an1 = m_sd1.getAliasName();
     QString fn2 = m_sd2.getFilename();
     QString an2 = m_sd2.getAliasName();
     QString fn3 = m_sd3.getFilename();
     QString an3 = m_sd3.getAliasName();
     if(winIdx == A)
     {
         fn1 = fileName;
         an1 = "";
     }
     if(winIdx == B)
     {
         fn2 = fileName;
         an2 = "";
     }
     if(winIdx == C)
     {
         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;
         }
 
         for(const QString& error: qAsConst(errors))
         {
             KMessageBox::error(m_pOptionDialog, error);
         }
 
         if(do_init)
         {
             mainInit();
         }
     }
 
     slotStatusMsg(i18n("Ready."));
 }
 
 void KDiff3App::slotEditSelectAll()
 {
     LineRef l = 0;
     int p = 0; // needed as dummy return values
     if(m_pMergeResultWindow && m_pMergeResultWindow->hasFocus())
     {
         m_pMergeResultWindow->setSelection(0, 0, m_pMergeResultWindow->getNofLines(), 0);
     }
     else if(m_pDiffTextWindow1 && m_pDiffTextWindow1->hasFocus())
     {
         m_pDiffTextWindow1->setSelection(0, 0, m_pDiffTextWindow1->getNofLines(), 0, l, p);
     }
     else if(m_pDiffTextWindow2 && m_pDiffTextWindow2->hasFocus())
     {
         m_pDiffTextWindow2->setSelection(0, 0, m_pDiffTextWindow2->getNofLines(), 0, l, p);
     }
     else if(m_pDiffTextWindow3 && m_pDiffTextWindow3->hasFocus())
     {
         m_pDiffTextWindow3->setSelection(0, 0, m_pDiffTextWindow3->getNofLines(), 0, l, p);
     }
 
     slotStatusMsg(i18n("Ready."));
 }
 
 void KDiff3App::slotGoCurrent()
 {
     if(m_pMergeResultWindow) m_pMergeResultWindow->slotGoCurrent();
 }
 void KDiff3App::slotGoTop()
 {
     if(m_pMergeResultWindow) m_pMergeResultWindow->slotGoTop();
 }
 void KDiff3App::slotGoBottom()
 {
     if(m_pMergeResultWindow) m_pMergeResultWindow->slotGoBottom();
 }
 void KDiff3App::slotGoPrevUnsolvedConflict()
 {
     if(m_pMergeResultWindow) m_pMergeResultWindow->slotGoPrevUnsolvedConflict();
 }
 void KDiff3App::slotGoNextUnsolvedConflict()
 {
     m_bTimerBlock = false;
     if(m_pMergeResultWindow) m_pMergeResultWindow->slotGoNextUnsolvedConflict();
 }
 void KDiff3App::slotGoPrevConflict()
 {
     if(m_pMergeResultWindow) m_pMergeResultWindow->slotGoPrevConflict();
 }
 void KDiff3App::slotGoNextConflict()
 {
     m_bTimerBlock = false;
     if(m_pMergeResultWindow) m_pMergeResultWindow->slotGoNextConflict();
 }
 void KDiff3App::slotGoPrevDelta()
 {
     if(m_pMergeResultWindow) m_pMergeResultWindow->slotGoPrevDelta();
 }
 void KDiff3App::slotGoNextDelta()
 {
     if(m_pMergeResultWindow) m_pMergeResultWindow->slotGoNextDelta();
 }
 
 void KDiff3App::choose(e_SrcSelector 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, &KDiff3App::slotGoNextUnsolvedConflict);
             }
         }
     }
 }
 
 void KDiff3App::slotChooseA()
 {
     choose(A);
 }
 void KDiff3App::slotChooseB()
 {
     choose(B);
 }
 void KDiff3App::slotChooseC()
 {
     choose(C);
 }
 
 void KDiff3App::slotAutoSolve()
 {
     if(m_pMergeResultWindow)
     {
         m_pMergeResultWindow->slotAutoSolve();
         // m_pMergeWindowFrame->show(); incompatible with bPreserveCarriageReturn
         m_pMergeResultWindow->showNrOfConflicts();
         slotUpdateAvailabilities();
     }
 }
 
 void KDiff3App::slotUnsolve()
 {
     if(m_pMergeResultWindow)
     {
         m_pMergeResultWindow->slotUnsolve();
     }
 }
 
 void KDiff3App::slotMergeHistory()
 {
     if(m_pMergeResultWindow)
     {
         m_pMergeResultWindow->slotMergeHistory();
     }
 }
 
 void KDiff3App::slotRegExpAutoMerge()
 {
     if(m_pMergeResultWindow)
     {
         m_pMergeResultWindow->slotRegExpAutoMerge();
     }
 }
 
 void KDiff3App::slotSplitDiff()
 {
     LineRef firstLine;
     LineRef lastLine;
     DiffTextWindow* pDTW = nullptr;
     if(m_pDiffTextWindow1)
     {
         pDTW = m_pDiffTextWindow1;
         pDTW->getSelectionRange(&firstLine, &lastLine, eD3LLineCoords);
     }
     if(firstLine < 0 && m_pDiffTextWindow2)
     {
         pDTW = m_pDiffTextWindow2;
         pDTW->getSelectionRange(&firstLine, &lastLine, eD3LLineCoords);
     }
     if(firstLine < 0 && m_pDiffTextWindow3)
     {
         pDTW = m_pDiffTextWindow3;
         pDTW->getSelectionRange(&firstLine, &lastLine, eD3LLineCoords);
     }
     if(pDTW && firstLine >= 0 && m_pMergeResultWindow)
     {
         pDTW->resetSelection();
 
         m_pMergeResultWindow->slotSplitDiff(firstLine, lastLine);
     }
 }
 
 void KDiff3App::slotJoinDiffs()
 {
     LineRef firstLine;
     LineRef lastLine;
     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()
 {
     const QClipboard* clipboard = QApplication::clipboard();
     const QMimeData* mimeData = clipboard->mimeData();
     if(mimeData->hasText())
     {
         QString s = clipboard->text();
         editPaste->setEnabled(!s.isEmpty());
     }
     else
     {
         editPaste->setEnabled(false);
     }
 }
 
 void KDiff3App::slotOutputModified(bool bModified)
 {
     if(bModified && !m_bOutputModified)
     {
         m_bOutputModified = true;
         slotUpdateAvailabilities();
     }
 }
 
 void KDiff3App::slotAutoAdvanceToggled()
 {
     m_pOptions->m_bAutoAdvance = autoAdvance->isChecked();
 }
 
 void KDiff3App::slotWordWrapToggled()
 {
     m_pOptions->m_bWordWrap = wordWrap->isChecked();
     postRecalcWordWrap();
 }
 
 // Enable or disable all widgets except the status bar widget.
 void KDiff3App::mainWindowEnable(bool bEnable)
 {
     if(QMainWindow* pWindow = dynamic_cast<QMainWindow*>(window()))
     {
         QWidget* pStatusBarWidget = pWindow->statusBar();
         pWindow->setEnabled(bEnable);
         pStatusBarWidget->setEnabled(true);
     }
 }
 
 void KDiff3App::postRecalcWordWrap()
 {
     if(!m_bRecalcWordWrapPosted)
     {
         m_bRecalcWordWrapPosted = true;
         m_firstD3LIdx = -1;
         emit sigRecalcWordWrap();
     }
     else
     {
         g_pProgressDialog->cancel(ProgressDialog::eResize);
     }
 }
 
 void KDiff3App::slotRecalcWordWrap()
 {
     recalcWordWrap();
 }
 
 // visibleTextWidthForPrinting is >=0 only for printing, otherwise the really visible width is used
 void KDiff3App::recalcWordWrap(int visibleTextWidthForPrinting)
 {
     m_bRecalcWordWrapPosted = true;
     mainWindowEnable(false);
 
     if(m_firstD3LIdx < 0)
     {
         m_firstD3LIdx = 0;
         if(m_pDiffTextWindow1)
             m_firstD3LIdx = m_pDiffTextWindow1->convertLineToDiff3LineIdx(m_pDiffTextWindow1->getFirstLine());
     }
 
     // Convert selection to D3L-coords (converting back happens in DiffTextWindow::recalcWordWrap()
     if(m_pDiffTextWindow1)
         m_pDiffTextWindow1->convertSelectionToD3LCoords();
     if(m_pDiffTextWindow2)
         m_pDiffTextWindow2->convertSelectionToD3LCoords();
     if(m_pDiffTextWindow3)
         m_pDiffTextWindow3->convertSelectionToD3LCoords();
 
     g_pProgressDialog->clearCancelState(); // clear cancelled state if previously set
 
     if(!m_diff3LineList.empty())
     {
         if(m_pOptions->m_bWordWrap)
         {
             m_diff3LineList.recalcWordWrap(true);
 
             // Let every window calc how many lines will be needed.
             if(m_pDiffTextWindow1)
             {
                 m_pDiffTextWindow1->recalcWordWrap(true, 0, visibleTextWidthForPrinting);
             }
             if(m_pDiffTextWindow2)
             {
                 m_pDiffTextWindow2->recalcWordWrap(true, 0, visibleTextWidthForPrinting);
             }
             if(m_pDiffTextWindow3)
             {
                 m_pDiffTextWindow3->recalcWordWrap(true, 0, visibleTextWidthForPrinting);
             }
         }
         else
         {
             m_neededLines = m_diff3LineVector.size();
             if(m_pDiffTextWindow1)
                 m_pDiffTextWindow1->recalcWordWrap(false, 0, 0);
             if(m_pDiffTextWindow2)
                 m_pDiffTextWindow2->recalcWordWrap(false, 0, 0);
             if(m_pDiffTextWindow3)
                 m_pDiffTextWindow3->recalcWordWrap(false, 0, 0);
         }
         bool bRunnablesStarted = DiffTextWindow::startRunnables();
         if(!bRunnablesStarted)
             slotFinishRecalcWordWrap(visibleTextWidthForPrinting);
         else
         {
             g_pProgressDialog->setInformation(m_pOptions->m_bWordWrap
                                                   ? i18n("Word wrap (Cancel disables word wrap)")
                                                   : i18n("Calculating max width for horizontal scrollbar"),
                                               false);
         }
     }
     else
     {
         //don't leave proccessing incomplete if m_diff3LineList isEmpty as when an error occures during reading.
         slotFinishRecalcWordWrap(visibleTextWidthForPrinting);
     }
 }
 
 void KDiff3App::slotFinishRecalcWordWrap(int visibleTextWidthForPrinting)
 {
     g_pProgressDialog->pop();
 
     if(m_pOptions->m_bWordWrap && g_pProgressDialog->wasCancelled())
     {
         if(g_pProgressDialog->cancelReason() == ProgressDialog::eUserAbort)
         {
             wordWrap->setChecked(false);
             m_pOptions->m_bWordWrap = wordWrap->isChecked();
         }
 
         emit sigRecalcWordWrap();
         return;
     }
     else
     {
         m_bRecalcWordWrapPosted = false;
     }
 
     g_pProgressDialog->setStayHidden(false);
 
     bool bPrinting = visibleTextWidthForPrinting >= 0;
 
     if(!m_diff3LineList.empty())
     {
         if(m_pOptions->m_bWordWrap)
         {
             LineCount sumOfLines = m_diff3LineList.recalcWordWrap(false);
 
             // Finish the word wrap
             if(m_pDiffTextWindow1)
                 m_pDiffTextWindow1->recalcWordWrap(true, sumOfLines, visibleTextWidthForPrinting);
             if(m_pDiffTextWindow2)
                 m_pDiffTextWindow2->recalcWordWrap(true, sumOfLines, visibleTextWidthForPrinting);
             if(m_pDiffTextWindow3)
                 m_pDiffTextWindow3->recalcWordWrap(true, sumOfLines, visibleTextWidthForPrinting);
 
             m_neededLines = sumOfLines;
         }
         else
         {
             if(m_pDiffTextWindow1)
                 m_pDiffTextWindow1->recalcWordWrap(false, 1, 0);
             if(m_pDiffTextWindow2)
                 m_pDiffTextWindow2->recalcWordWrap(false, 1, 0);
             if(m_pDiffTextWindow3)
                 m_pDiffTextWindow3->recalcWordWrap(false, 1, 0);
         }
         slotStatusMsg(QString());
     }
 
     if(!bPrinting)
     {
         if(m_pOverview)
             m_pOverview->slotRedraw();
         if(m_pDiffVScrollBar)
             m_pDiffVScrollBar->setRange(0, std::max(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(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)
 {
     FileAccess f1(m_sd1.getFilename());
     FileAccess f2(m_sd2.getFilename());
     FileAccess f3(m_sd3.getFilename());
     FileAccess f4(m_outputFilename);
 
     if(f1.isFile() && f1.exists())
     {
         if(f2.isDir())
         {
             f2.addPath(f1.fileName());
             if(f2.isFile() && f2.exists())
                 m_sd2.setFileAccess(f2);
         }
         if(f3.isDir())
         {
             f3.addPath(f1.fileName());
             if(f3.isFile() && f3.exists())
                 m_sd3.setFileAccess(f3);
         }
         if(f4.isDir())
         {
             f4.addPath(f1.fileName());
             if(f4.isFile() && f4.exists())
                 m_outputFilename = f4.absoluteFilePath();
         }
     }
     else if(f1.isDir())
     {
         if(bCreateNewInstance)
         {
             emit createNewInstance(f1.absoluteFilePath(), f2.absoluteFilePath(), f3.absoluteFilePath());
         }
         else
         {
             bool bDirCompare = m_bDirCompare;
             FileAccess destDir;
 
             if(!m_bDefaultFilename) destDir = f4;
             m_pDirectoryMergeSplitter->show();
             if(m_pMainWidget != nullptr) m_pMainWidget->hide();
             setUpdatesEnabled(true);
 
             m_dirinfo = QSharedPointer<DirectoryInfo>::create(f1, f2, f3, destDir);
             bool bSuccess = m_pDirectoryMergeWindow->init(
                 m_dirinfo,
                 !m_outputFilename.isEmpty());
             //This is a bug if it still happens.
             Q_ASSERT(m_bDirCompare == bDirCompare);
 
             if(bSuccess)
             {
                 m_sd1.reset();
                 if(m_pDiffTextWindow1 != nullptr) m_pDiffTextWindow1->init(QString(""), nullptr, eLineEndStyleDos, nullptr, 0, nullptr, nullptr, false);
                 m_sd2.reset();
                 if(m_pDiffTextWindow2 != nullptr) m_pDiffTextWindow2->init(QString(""), nullptr, eLineEndStyleDos, nullptr, 0, nullptr, nullptr, false);
                 m_sd3.reset();
                 if(m_pDiffTextWindow3 != nullptr) m_pDiffTextWindow3->init(QString(""), nullptr, eLineEndStyleDos, nullptr, 0, nullptr, nullptr, false);
             }
             slotUpdateAvailabilities();
             return bSuccess;
         }
     }
     return true;
 }
 
 void KDiff3App::slotReload()
 {
     if(!canContinue()) return;
 
     mainInit();
 }
 
 bool KDiff3App::canContinue()
 {
     // First test if anything must be saved.
     if(m_bOutputModified)
     {
         int result = KMessageBox::warningYesNoCancel(this,
                                                      i18n("The merge result has not been saved."),
                                                      i18n("Warning"),
                                                      KGuiItem(i18n("Save && Continue")),
                                                      KGuiItem(i18n("Continue Without Saving")));
         if(result == KMessageBox::Cancel)
             return false;
         else if(result == KMessageBox::Yes)
         {
             slotFileSave();
             if(m_bOutputModified)
             {
                 KMessageBox::sorry(this, i18n("Saving the merge result failed."), i18n("Warning"));
                 return false;
             }
         }
     }
 
     m_bOutputModified = false;
     return true;
 }
 
 void KDiff3App::slotCheckIfCanContinue(bool* pbContinue)
 {
     if(pbContinue != nullptr) *pbContinue = canContinue();
 }
 
 void KDiff3App::slotDirShowBoth()
 {
     if(dirShowBoth->isChecked())
     {
         if(m_pDirectoryMergeSplitter)
             m_pDirectoryMergeSplitter->setVisible(m_bDirCompare);
 
         if(m_pMainWidget != nullptr)
             m_pMainWidget->show();
     }
     else
     {
         bool bTextDataAvailable = (m_sd1.hasData() || m_sd2.hasData() || m_sd3.hasData());
         if(m_pMainWidget != nullptr && bTextDataAvailable)
         {
             m_pMainWidget->show();
             m_pDirectoryMergeSplitter->hide();
         }
         else if(m_bDirCompare)
         {
             m_pDirectoryMergeSplitter->show();
         }
     }
 
     slotUpdateAvailabilities();
 }
 
 void KDiff3App::slotDirViewToggle()
 {
     if(m_bDirCompare)
     {
         if(!m_pDirectoryMergeSplitter->isVisible())
         {
             m_pDirectoryMergeSplitter->show();
             if(m_pMainWidget != nullptr)
                 m_pMainWidget->hide();
         }
         else
         {
             if(m_pMainWidget != nullptr)
             {
                 m_pDirectoryMergeSplitter->hide();
                 m_pMainWidget->show();
             }
         }
     }
     slotUpdateAvailabilities();
 }
 
 void KDiff3App::slotShowWindowAToggled()
 {
     if(m_pDiffTextWindow1 != nullptr)
     {
         m_pDiffTextWindowFrame1->setVisible(showWindowA->isChecked());
         slotUpdateAvailabilities();
     }
 }
 
 void KDiff3App::slotShowWindowBToggled()
 {
     if(m_pDiffTextWindow2 != nullptr)
     {
         m_pDiffTextWindowFrame2->setVisible(showWindowB->isChecked());
         slotUpdateAvailabilities();
     }
 }
 
 void KDiff3App::slotShowWindowCToggled()
 {
     if(m_pDiffTextWindow3 != nullptr)
     {
         m_pDiffTextWindowFrame3->setVisible(showWindowC->isChecked());
         slotUpdateAvailabilities();
     }
 }
 
 void KDiff3App::slotEditFind()
 {
     m_pFindDialog->currentLine = 0;
     m_pFindDialog->currentPos = 0;
     m_pFindDialog->currentWindow = 1;
 
     // Use currently selected text:
     QString s;
     if(m_pDiffTextWindow1 != nullptr) s = m_pDiffTextWindow1->getSelection();
     if(s.isEmpty() && m_pDiffTextWindow2 != nullptr) s = m_pDiffTextWindow2->getSelection();
     if(s.isEmpty() && m_pDiffTextWindow3 != nullptr) s = m_pDiffTextWindow3->getSelection();
     if(s.isEmpty() && m_pMergeResultWindow != nullptr) s = m_pMergeResultWindow->getSelection();
     if(!s.isEmpty() && !s.contains('\n'))
     {
         m_pFindDialog->m_pSearchString->setText(s);
     }
 
     if(QDialog::Accepted == m_pFindDialog->exec())
     {
         slotEditFindNext();
     }
 }
 
 void KDiff3App::slotEditFindNext()
 {
     QString s = m_pFindDialog->m_pSearchString->text();
     if(s.isEmpty())
     {
         slotEditFind();
         return;
     }
 
     bool bDirDown = true;
     bool bCaseSensitive = m_pFindDialog->m_pCaseSensitive->isChecked();
 
     LineRef d3vLine = m_pFindDialog->currentLine;
     int posInLine = m_pFindDialog->currentPos;
     LineRef l = 0;
     int p = 0;
     if(m_pFindDialog->currentWindow == 1)
     {
         if(m_pFindDialog->m_pSearchInA->isChecked() && m_pDiffTextWindow1 != nullptr &&
            m_pDiffTextWindow1->findString(s, d3vLine, posInLine, bDirDown, bCaseSensitive))
         {
             m_pDiffTextWindow1->setSelection(d3vLine, posInLine, d3vLine, posInLine + s.length(), l, p);
             m_pDiffVScrollBar->setValue(l - m_pDiffVScrollBar->pageStep() / 2);
             m_pHScrollBar->setValue(std::max(0, p + s.length() - m_pHScrollBar->pageStep()));
             m_pFindDialog->currentLine = d3vLine;
             m_pFindDialog->currentPos = posInLine + 1;
             return;
         }
         m_pFindDialog->currentWindow = 2;
         m_pFindDialog->currentLine = 0;
         m_pFindDialog->currentPos = 0;
     }
 
     d3vLine = m_pFindDialog->currentLine;
     posInLine = m_pFindDialog->currentPos;
     if(m_pFindDialog->currentWindow == 2)
     {
         if(m_pFindDialog->m_pSearchInB->isChecked() && m_pDiffTextWindow2 != nullptr &&
            m_pDiffTextWindow2->findString(s, d3vLine, posInLine, bDirDown, bCaseSensitive))
         {
             m_pDiffTextWindow2->setSelection(d3vLine, posInLine, d3vLine, posInLine + s.length(), l, p);
             m_pDiffVScrollBar->setValue(l - m_pDiffVScrollBar->pageStep() / 2);
             m_pHScrollBar->setValue(std::max(0, p + s.length() - m_pHScrollBar->pageStep()));
             m_pFindDialog->currentLine = d3vLine;
             m_pFindDialog->currentPos = posInLine + 1;
             return;
         }
         m_pFindDialog->currentWindow = 3;
         m_pFindDialog->currentLine = 0;
         m_pFindDialog->currentPos = 0;
     }
 
     d3vLine = m_pFindDialog->currentLine;
     posInLine = m_pFindDialog->currentPos;
     if(m_pFindDialog->currentWindow == 3)
     {
         if(m_pFindDialog->m_pSearchInC->isChecked() && m_pDiffTextWindow3 != nullptr &&
            m_pDiffTextWindow3->findString(s, d3vLine, posInLine, bDirDown, bCaseSensitive))
         {
             m_pDiffTextWindow3->setSelection(d3vLine, posInLine, d3vLine, posInLine + s.length(), l, p);
             m_pDiffVScrollBar->setValue(l - m_pDiffVScrollBar->pageStep() / 2);
             m_pHScrollBar->setValue(std::max(0, p + s.length() - m_pHScrollBar->pageStep()));
             m_pFindDialog->currentLine = d3vLine;
             m_pFindDialog->currentPos = posInLine + 1;
             return;
         }
         m_pFindDialog->currentWindow = 4;
         m_pFindDialog->currentLine = 0;
         m_pFindDialog->currentPos = 0;
     }
 
     d3vLine = m_pFindDialog->currentLine;
     posInLine = m_pFindDialog->currentPos;
     if(m_pFindDialog->currentWindow == 4)
     {
         if(m_pFindDialog->m_pSearchInOutput->isChecked() && m_pMergeResultWindow != nullptr && m_pMergeResultWindow->isVisible() &&
            m_pMergeResultWindow->findString(s, d3vLine, posInLine, bDirDown, bCaseSensitive))
         {
             m_pMergeResultWindow->setSelection(d3vLine, posInLine, d3vLine, posInLine + s.length());
             m_pMergeVScrollBar->setValue(d3vLine - m_pMergeVScrollBar->pageStep() / 2);
             m_pHScrollBar->setValue(std::max(0, posInLine + s.length() - m_pHScrollBar->pageStep()));
             m_pFindDialog->currentLine = d3vLine;
             m_pFindDialog->currentPos = posInLine + 1;
             return;
         }
         m_pFindDialog->currentWindow = 5;
         m_pFindDialog->currentLine = 0;
         m_pFindDialog->currentPos = 0;
     }
 
     KMessageBox::information(this, i18n("Search complete."), i18n("Search Complete"));
     m_pFindDialog->currentWindow = 1;
     m_pFindDialog->currentLine = 0;
     m_pFindDialog->currentPos = 0;
 }
 
 void KDiff3App::slotMergeCurrentFile()
 {
     if(m_bDirCompare && m_pDirectoryMergeWindow->isVisible() && m_pDirectoryMergeWindow->isFileSelected())
     {
         m_pDirectoryMergeWindow->mergeCurrentFile();
     }
     else if(m_pMainWidget != nullptr && m_pMainWidget->isVisible())
     {
         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())
         {
             /*
                 QProcess doesn't check for single quotes and uses non-standard escaping syntax for double quotes.
                     The distinction between single and double quotes is purely a command shell issue. So
                     we split the command string ourselves.
             */
             QStringList args;
             QString program;
             Utils::getArguments(m_pOptions->m_IrrelevantMergeCmd, program, args);
             QProcess process;
             process.start(program, args);
             process.waitForFinished(-1);
         }
     }
 }
 
 void ManualDiffHelpList::insertEntry(e_SrcSelector winIdx, LineRef firstLine, LineRef lastLine)
 {
     // The manual diff help list must be sorted and compact.
     // "Compact" means that upper items can't be empty if lower items contain data.
 
     // First insert the new item without regarding compactness.
     // If the new item overlaps with previous items then the previous items will be removed.
 
     ManualDiffHelpEntry mdhe;
     mdhe.firstLine(winIdx) = firstLine;
     mdhe.lastLine(winIdx) = lastLine;
 
     ManualDiffHelpList::iterator i;
     for(i = begin(); i != end(); ++i)
     {
         LineRef& l1 = i->firstLine(winIdx);
         LineRef& l2 = i->lastLine(winIdx);
         if(l1 >= 0 && l2 >= 0)
         {
             if((firstLine <= l1 && lastLine >= l1) || (firstLine <= l2 && lastLine >= l2))
             {
                 // overlap
                 l1.invalidate();
                 l2.invalidate();
             }
             if(firstLine < l1 && lastLine < l1)
             {
                 // insert before this position
                 insert(i, mdhe);
                 break;
             }
         }
     }
     if(i == end())
     {
         insert(i, mdhe);
     }
 
     // Now make the list compact
     for(int wIdx = A; wIdx <= Max; ++wIdx)
     {
         ManualDiffHelpList::iterator iEmpty = begin();
         for(i = begin(); i != end(); ++i)
         {
             if(iEmpty->firstLine((e_SrcSelector)wIdx) >= 0)
             {
                 ++iEmpty;
                 continue;
             }
             if(i->firstLine((e_SrcSelector)wIdx) >= 0) // Current item is not empty -> move it to the empty place
             {
                 iEmpty->firstLine((e_SrcSelector)wIdx) = i->firstLine((e_SrcSelector)wIdx);
                 iEmpty->lastLine((e_SrcSelector)wIdx) = i->lastLine((e_SrcSelector)wIdx);
                 i->firstLine((e_SrcSelector)wIdx).invalidate();
                 i->lastLine((e_SrcSelector)wIdx).invalidate();
                 ++iEmpty;
             }
         }
     }
     remove(ManualDiffHelpEntry()); // Remove all completely empty items.
 }
 
 void KDiff3App::slotAddManualDiffHelp()
 {
     LineRef firstLine;
     LineRef lastLine;
     e_SrcSelector winIdx = Invalid;
     if(m_pDiffTextWindow1)
     {
         m_pDiffTextWindow1->getSelectionRange(&firstLine, &lastLine, eFileCoords);
         winIdx = A;
     }
     if(firstLine < 0 && m_pDiffTextWindow2)
     {
         m_pDiffTextWindow2->getSelectionRange(&firstLine, &lastLine, eFileCoords);
         winIdx = B;
     }
     if(firstLine < 0 && m_pDiffTextWindow3)
     {
         m_pDiffTextWindow3->getSelectionRange(&firstLine, &lastLine, eFileCoords);
         winIdx = C;
     }
 
     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
     {
         m_manualDiffHelpList.insertEntry(winIdx, firstLine, lastLine);
 
         mainInit(nullptr, false); // Init without reload
         slotRefresh();
     }
 }
 
 void KDiff3App::slotClearManualDiffHelpList()
 {
     m_manualDiffHelpList.clear();
     mainInit(nullptr, false); // Init without reload
     slotRefresh();
 }
 
 void KDiff3App::slotEncodingChanged(QTextCodec* c)
 {
     Q_UNUSED(c);
     mainInit(nullptr, true, true); // Init with reload
     slotRefresh();
 }
 
 void KDiff3App::slotUpdateAvailabilities()
 {
     if(m_pMainSplitter == nullptr || m_pDiffTextWindow2 == nullptr || m_pDiffTextWindow1 == nullptr || m_pDiffTextWindow3 == nullptr)
         return;
 
     bool bTextDataAvailable = (m_sd1.hasData() || m_sd2.hasData() || m_sd3.hasData());
 
     if(dirShowBoth->isChecked())
     {
         if(m_pDirectoryMergeSplitter != nullptr)
             m_pDirectoryMergeSplitter->setVisible(m_bDirCompare);
 
         if(m_pMainWidget != nullptr && !m_pMainWidget->isVisible() &&
            bTextDataAvailable && !m_pDirectoryMergeWindow->isScanning())
             m_pMainWidget->show();
     }
 
     bool bDiffWindowVisible = m_pMainWidget != nullptr && m_pMainWidget->isVisible();
     bool bMergeEditorVisible = m_pMergeWindowFrame != nullptr && m_pMergeWindowFrame->isVisible() && m_pMergeResultWindow != nullptr;
 
     m_pDirectoryMergeWindow->updateAvailabilities(m_bDirCompare, bDiffWindowVisible, chooseA, chooseB, chooseC);
 
     dirShowBoth->setEnabled(m_bDirCompare);
     dirViewToggle->setEnabled(
         m_bDirCompare &&
         ((m_pDirectoryMergeSplitter != nullptr && m_pMainWidget != nullptr) &&
          ((!m_pDirectoryMergeSplitter->isVisible() && m_pMainWidget->isVisible()) ||
           (m_pDirectoryMergeSplitter->isVisible() && !m_pMainWidget->isVisible() && bTextDataAvailable))));
 
     bool bDirWindowHasFocus = m_pDirectoryMergeSplitter != nullptr && m_pDirectoryMergeSplitter->isVisible() && m_pDirectoryMergeWindow->hasFocus();
 
     showWhiteSpaceCharacters->setEnabled(bDiffWindowVisible);
     autoAdvance->setEnabled(bMergeEditorVisible);
     autoSolve->setEnabled(bMergeEditorVisible && m_bTripleDiff);
     unsolve->setEnabled(bMergeEditorVisible);
     if(!bDirWindowHasFocus)
     {
         chooseA->setEnabled(bMergeEditorVisible);
         chooseB->setEnabled(bMergeEditorVisible);
         chooseC->setEnabled(bMergeEditorVisible && m_bTripleDiff);
     }
     if(m_pMergeResultWindow != nullptr)
     {
         m_pMergeResultWindow->slotUpdateAvailabilities(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 != nullptr && m_pMergeResultWindow->isDeltaAboveCurrent());
     goBottom->setEnabled(bDiffWindowVisible && m_pMergeResultWindow != nullptr && m_pMergeResultWindow->isDeltaBelowCurrent());
     goCurrent->setEnabled(bDiffWindowVisible);
     goPrevUnsolvedConflict->setEnabled(bMergeEditorVisible && m_pMergeResultWindow->isUnsolvedConflictAboveCurrent());
     goNextUnsolvedConflict->setEnabled(bMergeEditorVisible && m_pMergeResultWindow->isUnsolvedConflictBelowCurrent());
     goPrevConflict->setEnabled(bDiffWindowVisible && bMergeEditorVisible && m_pMergeResultWindow->isConflictAboveCurrent());
     goNextConflict->setEnabled(bDiffWindowVisible && bMergeEditorVisible && m_pMergeResultWindow->isConflictBelowCurrent());
     goPrevDelta->setEnabled(bDiffWindowVisible && m_pMergeResultWindow != nullptr && m_pMergeResultWindow->isDeltaAboveCurrent());
     goNextDelta->setEnabled(bDiffWindowVisible && m_pMergeResultWindow != nullptr && m_pMergeResultWindow->isDeltaBelowCurrent());
 
     overviewModeNormal->setEnabled(m_bTripleDiff && bDiffWindowVisible);
     overviewModeAB->setEnabled(m_bTripleDiff && bDiffWindowVisible);
     overviewModeAC->setEnabled(m_bTripleDiff && bDiffWindowVisible);
     overviewModeBC->setEnabled(m_bTripleDiff && bDiffWindowVisible);
     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);
 }