diff --git a/CMakeLists.txt b/CMakeLists.txt
index 23fa4f8..b9d4dbf 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,85 +1,85 @@
 #cmake < 3.1 has no sane way of checking C++11 features and needed flags
 cmake_minimum_required(VERSION 3.1 FATAL_ERROR)
 
 project(kdiff3)
 
-set(CMAKE_CXX_EXTENSIONS OFF ) #don't use non-standard extentions
+set(CMAKE_CXX_EXTENSIONS OFF ) #don't use non-standard extensions
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 set(ECM_MIN_VERSION "1.7.0")
 set(QT_MIN_VERSION "5.6.0")
 set(KF5_MIN_VERSION "5.16.0")
 
 find_package(ECM ${ECM_MIN_VERSION} CONFIG REQUIRED)
 set(
     CMAKE_MODULE_PATH
     ${CMAKE_MODULE_PATH}
     ${ECM_MODULE_PATH}
     ${ECM_KDE_MODULE_DIR}
 )
 
 include(KDEInstallDirs)
 include(KDECompilerSettings NO_POLICY_SCOPE)
 include(KDECMakeSettings NO_POLICY_SCOPE)
 include(FeatureSummary)
 
 include(ECMInstallIcons)
 include(ECMAddAppIcon)
 # include(GenerateExportHeader)
 
 find_package(
     Qt5 ${QT_MIN_VERSION}
     CONFIG
     REQUIRED
     COMPONENTS
     Core
     Gui
     Widgets
     PrintSupport
 )
 
 find_package(
     KF5 ${KF5_MIN_VERSION}
     REQUIRED
     COMPONENTS
     I18n
     CoreAddons
     Crash
     DocTools
     IconThemes
 )
 
 
 set(KDiff3_LIBRARIES ${Qt5PrintSupport_LIBRARIES} KF5::I18n KF5::CoreAddons KF5::Crash KF5::IconThemes )
 
 if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
     # I don't need warnings about wired things in comments.
     set(CLANG_WARNING_FLAGS "-Wno-comment -Wshorten-64-to-32 -Wstring-conversion -Wc++11-narrowing")
     set(CMAKE_CXX_FLAGS  "${CMAKE_CXX_FLAGS} ${CLANG_WARNING_FLAGS}")
     set(CMAKE_C_FLAGS  "${CMAKE_C_FLAGS} ${CLANG_WARNING_FLAGS}")
 endif()
 
 set(
     needed_features
     cxx_nullptr
     cxx_override
 )
 
 
 add_definitions(
     -DQT_DEPRECATED_WARNINGS #Get warnings from QT about deprecated functions.
     -DQT_NO_URL_CAST_FROM_STRING #implict casting from string to url does not always behave as you might think
 )
 #remove unnneeded errors
 remove_definitions(
     -DQT_NO_CAST_FROM_ASCII #While a good idea in gerneral this triggers for many simple non-translatable strings
     )
 
 add_subdirectory(src)
 add_subdirectory(doc)
 
 add_subdirectory(kdiff3fileitemactionplugin)
 
 ki18n_install(po)
 kdoctools_install(po)
 
 feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)
diff --git a/diff_ext_for_kdiff3/diff_ext.cpp b/diff_ext_for_kdiff3/diff_ext.cpp
index a64cd97..b91c1db 100644
--- a/diff_ext_for_kdiff3/diff_ext.cpp
+++ b/diff_ext_for_kdiff3/diff_ext.cpp
@@ -1,659 +1,659 @@
 /*
  * Copyright (c) 2003-2006, Sergey Zorin. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
 
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  */
 
 #define _CRT_SECURE_NO_DEPRECATE
 
 #include <assert.h>
 #include <stdio.h>
 #include <tchar.h>
 
 #include "diff_ext.h"
 #include <map>
 #include <vector>
 
 
 #ifdef UNICODE
 
 static void parseString( const std::wstring& s, size_t& i /*pos*/, std::wstring& r /*result*/ )
 {
    size_t size = s.size();
    ++i; // Skip initial '"'
    for( ; i<size; ++i )
    {
       if ( s[i]=='"' )
       {
          ++i;
          break;
       }
       else if ( s[i]==L'\\' && i+1<size )
       {
          ++i;
          switch( s[i] ) {
             case L'n':  r+=L'\n'; break;
             case L'r':  r+=L'\r'; break;
             case L'\\': r+=L'\\'; break;
             case L'"':  r+=L'"';  break;
             case L't':  r+=L'\t'; break;
             default:    r+=L'\\'; r+=s[i]; break;
          }
       }
       else
          r+=s[i];
    }
 }
 
 static std::map< std::wstring, std::wstring > s_translationMap;
 static tstring s_translationFileName;
 
 void readTranslationFile()
 {
    s_translationMap.clear();
    FILE* pFile = _tfopen( s_translationFileName.c_str(), TEXT("rb") );
    if ( pFile )
    {
       MESSAGELOG( TEXT( "Reading translations: " ) + s_translationFileName );
       std::vector<char> buffer;
       try {
          if ( fseek(pFile, 0, SEEK_END)==0 )
          {
             size_t length = ftell(pFile); // Get the file length
             buffer.resize(length);
             fseek(pFile, 0, SEEK_SET );
             fread(&buffer[0], 1, length, pFile );
          }
       } 
       catch(...) 
       {
       }
       fclose(pFile);
 
       if (buffer.size()>0)
       {
          size_t bufferSize = buffer.size();
          int offset = 0;
          if ( buffer[0]=='\xEF' && buffer[1]=='\xBB' && buffer[2]=='\xBF' )
          {
             offset += 3;
             bufferSize -= 3;
          }
 
          size_t sLength = MultiByteToWideChar(CP_UTF8,0,&buffer[offset], (int)bufferSize, 0, 0 );
          std::wstring s( sLength, L' ' );         
          MultiByteToWideChar(CP_UTF8,0,&buffer[offset], (int)bufferSize, &s[0], (int)s.size() );
 
-         // Now analyse the file and extract translation strings
+         // Now analyze the file and extract translation strings
          std::wstring msgid;
          std::wstring msgstr;
          msgid.reserve( 1000 );
          msgstr.reserve( 1000 );
          bool bExpectingId = true;
          for( size_t i=0; i<sLength; ++i )
          {
             wchar_t c = s[i];
             if( c == L'\n' || c == L'\r' || c==L' ' || c==L'\t' )
                continue;
             else if ( s[i]==L'#' ) // Comment
                while( s[i]!='\n' && s[i]!=L'\r' && i<sLength )
                   ++i;
             else if ( s[i]==L'"' )
             {
                if ( bExpectingId ) parseString(s,i,msgid);
                else                parseString(s,i,msgstr);
             }
             else if ( sLength-i>5 && wcsncmp( &s[i], L"msgid", 5 )==0 )
             {
                if ( !msgid.empty() && !msgstr.empty() )
                {
                   s_translationMap[msgid] = msgstr;
                }
                bExpectingId = true;
                msgid.clear();
                i+=4;
             }
             else if ( sLength-i>6 && wcsncmp( &s[i], L"msgstr", 6 )==0 )
             {
                bExpectingId = false;
                msgstr.clear();
                i+=5;
             }
             else
             {
                // Unexpected ?
             }
          }
       }
    }
    else
    {
       ERRORLOG( TEXT( "Reading translations failed: " ) + s_translationFileName );
    }
 }
 
 static tstring getTranslation( const tstring& fallback )
 {
    std::map< std::wstring, std::wstring >::iterator i = s_translationMap.find( fallback );
    if (i!=s_translationMap.end())
       return i->second;
    return fallback;
 }
 #else
 
 static tstring getTranslation( const tstring& fallback )
 {
    return fallback;
 }
 
 #endif
 
 
 static void replaceArgs( tstring& s, const tstring& r1, const tstring& r2=TEXT(""), const tstring& r3=TEXT("") )
 {
    tstring arg1 = TEXT("%1");
    size_t pos1 = s.find( arg1 );
    tstring arg2 = TEXT("%2");
    size_t pos2 = s.find( arg2 );
    tstring arg3 = TEXT("%3");
    size_t pos3 = s.find( arg3 );
    if ( pos1 != size_t(-1) )
    {
       s.replace( pos1, arg1.length(), r1 );
       if ( pos2 != size_t(-1) && pos1<pos2 )
          pos2 += r1.length() - arg1.length();
       if ( pos3 != size_t(-1) && pos1<pos3 )
          pos3 += r1.length() - arg1.length();
    }
    if ( pos2 != size_t(-1) )
    {
       s.replace( pos2, arg2.length(), r2 );
       if ( pos3 != size_t(-1) && pos2<pos3 )
          pos3 += r2.length() - arg2.length();
    }
    if ( pos3 != size_t(-1) )
    {
       s.replace( pos3, arg3.length(), r3 );
    }
 }
 
 DIFF_EXT::DIFF_EXT() 
 : m_nrOfSelectedFiles(0), _ref_count(0L),
   m_recentFiles( SERVER::instance()->recent_files() )
 {
    LOG();
   _resource = SERVER::instance()->handle();
   
   SERVER::instance()->lock();
 }
 
 DIFF_EXT::~DIFF_EXT() 
 {
    LOG();
    if(_resource != SERVER::instance()->handle()) {
       FreeLibrary(_resource);
    }
   
    SERVER::instance()->release();
 }
 
 STDMETHODIMP
 DIFF_EXT::QueryInterface(REFIID refiid, void** ppv) 
 {
   HRESULT ret = E_NOINTERFACE;
   *ppv = 0;
 
   if(IsEqualIID(refiid, IID_IShellExtInit) || IsEqualIID(refiid, IID_IUnknown)) {
     *ppv = static_cast<IShellExtInit*>(this);
   } else if (IsEqualIID(refiid, IID_IContextMenu)) {
     *ppv = static_cast<IContextMenu*>(this);
   }
 
   if(*ppv != 0) {
     AddRef();
 
     ret = NOERROR;
   }
 
   return ret;
 }
 
 STDMETHODIMP_(ULONG)
 DIFF_EXT::AddRef() 
 {
   return InterlockedIncrement((LPLONG)&_ref_count);
 }
 
 STDMETHODIMP_(ULONG)
 DIFF_EXT::Release() 
 {
   ULONG ret = 0L;
   
   if(InterlockedDecrement((LPLONG)&_ref_count) != 0) {
     ret = _ref_count;
   } else {
     delete this;
   }
 
   return ret;
 }
 
 
 
 STDMETHODIMP
 DIFF_EXT::Initialize(LPCITEMIDLIST /*folder not used*/, IDataObject* data, HKEY /*key not used*/) 
 {
    LOG();
 
 #ifdef UNICODE
    tstring installDir = SERVER::instance()->getRegistryKeyString( TEXT(""), TEXT("InstallDir") );
    tstring language = SERVER::instance()->getRegistryKeyString( TEXT(""), TEXT("Language") );
    tstring translationFileName = installDir + TEXT("\\translations\\diff_ext_") + language + TEXT(".po");
    if ( s_translationFileName != translationFileName )
    {
       s_translationFileName = translationFileName;
       readTranslationFile();
    }
 #endif
 
   FORMATETC format = {CF_HDROP, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
   STGMEDIUM medium;
   medium.tymed = TYMED_HGLOBAL;
   HRESULT ret = E_INVALIDARG;
 
   if(data->GetData(&format, &medium) == S_OK) 
   {
     HDROP drop = (HDROP)medium.hGlobal;
     m_nrOfSelectedFiles = DragQueryFile(drop, 0xFFFFFFFF, 0, 0);
 
     TCHAR tmp[MAX_PATH];
     
     //initialize_language();
     
     if (m_nrOfSelectedFiles >= 1 && m_nrOfSelectedFiles <= 3)
     {
        DragQueryFile(drop, 0, tmp, MAX_PATH);
        _file_name1 = tmp;
 
        if(m_nrOfSelectedFiles >= 2) 
        {
          DragQueryFile(drop, 1, tmp, MAX_PATH);
          _file_name2 = tmp;
        }
        
        if( m_nrOfSelectedFiles == 3) 
        {
          DragQueryFile(drop, 2, tmp, MAX_PATH);
          _file_name3 = tmp;
        }
 
        ret = S_OK;
     }
   }
   else
   {
      SYSERRORLOG(TEXT("GetData"));
   }
 
   return ret;
 }
 
 static int insertMenuItemHelper( HMENU menu, UINT id, UINT position, const tstring& text, 
                                  UINT fState = MFS_ENABLED, HMENU hSubMenu=0 )
 {
    MENUITEMINFO item_info;
    ZeroMemory(&item_info, sizeof(item_info));
    item_info.cbSize = sizeof(MENUITEMINFO);
    item_info.wID = id;
    if (text.empty())
    {   // Separator
        item_info.fMask = MIIM_TYPE;
        item_info.fType = MFT_SEPARATOR;
        item_info.dwTypeData = 0;
    }
    else
    {
       item_info.fMask = MIIM_ID | MIIM_TYPE | MIIM_STATE | (hSubMenu!=0 ? MIIM_SUBMENU : 0);
       item_info.fType = MFT_STRING;
       item_info.fState = fState;
       item_info.dwTypeData = (LPTSTR)text.c_str();
       item_info.hSubMenu = hSubMenu;
    }
    if ( 0 == InsertMenuItem(menu, position, TRUE, &item_info) )
       SYSERRORLOG(TEXT("InsertMenuItem"));
    return id;
 }
 
 
 STDMETHODIMP
 DIFF_EXT::QueryContextMenu(HMENU menu, UINT position, UINT first_cmd, UINT /*last_cmd not used*/, UINT flags) 
 {
    LOG();
    
    SERVER::instance()->recent_files(); // updates recent files list (reads from registry)
    
    m_id_Diff = UINT(-1);
    m_id_DiffWith = UINT(-1);
    m_id_DiffLater = UINT(-1);
    m_id_MergeWith = UINT(-1);
    m_id_Merge3 = UINT(-1);
    m_id_Diff3 = UINT(-1);
    m_id_DiffWith_Base = UINT(-1);
    m_id_ClearList = UINT(-1);
    m_id_About = UINT(-1);
 
    HRESULT ret = MAKE_HRESULT(SEVERITY_SUCCESS, FACILITY_NULL, 0);
 
    if(!(flags & CMF_DEFAULTONLY)) 
    {
    /* Menu structure:
       KDiff3 -> (1 File selected):  Save 'selection' for later comparison (push onto history stack)
                                     Compare 'selection' with first file on history stack.
                                     Compare 'selection' with -> choice from history stack
                                     Merge 'selection' with first file on history stack.
                                     Merge 'selection' with last two files on history stack.
                 (2 Files selected): Compare 's1' with 's2'
                                     Merge 's1' with 's2' 
                 (3 Files selected): Compare 's1', 's2' and 's3'
    */
       HMENU subMenu = CreateMenu();
 
       UINT id = first_cmd;
       m_id_FirstCmd = first_cmd;
 
       insertMenuItemHelper( menu, id++, position++, TEXT("") );  // begin separator
 
       tstring menuString;
       UINT pos2=0;
       if(m_nrOfSelectedFiles == 1) 
       {  
          size_t nrOfRecentFiles = m_recentFiles.size();
          tstring menuStringCompare = i18n("Compare with %1");
          tstring menuStringMerge   = i18n("Merge with %1");
          tstring firstFileName;
          if( nrOfRecentFiles>=1 )
          {
             firstFileName = TEXT("'") + cut_to_length( m_recentFiles.front() ) + TEXT("'");
          } 
          replaceArgs( menuStringCompare, firstFileName );
          replaceArgs( menuStringMerge,   firstFileName );
          m_id_DiffWith  = insertMenuItemHelper( subMenu, id++, pos2++, menuStringCompare, nrOfRecentFiles >=1 ? MFS_ENABLED : MFS_DISABLED );
          m_id_MergeWith = insertMenuItemHelper( subMenu, id++, pos2++, menuStringMerge, nrOfRecentFiles >=1 ? MFS_ENABLED : MFS_DISABLED );
 
          //if( nrOfRecentFiles>=2 )
          //{
          //   tstring firstFileName = cut_to_length( m_recentFiles.front() );        
          //   tstring secondFileName = cut_to_length( *(++m_recentFiles.begin()) );        
          //} 
          m_id_Merge3 = insertMenuItemHelper( subMenu, id++, pos2++, i18n("3-way merge with base"), 
             nrOfRecentFiles >=2 ? MFS_ENABLED : MFS_DISABLED );
 
          menuString = i18n("Save '%1' for later");
          replaceArgs( menuString, _file_name1 );
          m_id_DiffLater = insertMenuItemHelper( subMenu, id++, pos2++, menuString );
 
          HMENU file_list = CreateMenu();
          std::list<tstring>::iterator i;
          m_id_DiffWith_Base = id;
          int n = 0;
          for( i = m_recentFiles.begin(); i!=m_recentFiles.end(); ++i )
          {
             tstring s = cut_to_length( *i );
             insertMenuItemHelper( file_list, id++, n, s );
             ++n;
          }
 
          insertMenuItemHelper( subMenu, id++, pos2++, i18n("Compare with ..."), 
             nrOfRecentFiles > 0 ? MFS_ENABLED : MFS_DISABLED, file_list );
 
          m_id_ClearList = insertMenuItemHelper( subMenu, id++, pos2++, i18n("Clear list"), nrOfRecentFiles >=1 ? MFS_ENABLED : MFS_DISABLED );
       }
       else if(m_nrOfSelectedFiles == 2) 
       {      
          //= "Diff " + cut_to_length(_file_name1, 20)+" and "+cut_to_length(_file_name2, 20);
          m_id_Diff = insertMenuItemHelper( subMenu, id++, pos2++, i18n("Compare") );
       } 
       else if ( m_nrOfSelectedFiles == 3 ) 
       {      
          m_id_Diff3 = insertMenuItemHelper( subMenu, id++, pos2++, i18n("3 way comparison") );
       } 
       else 
       {
          // More than 3 files selected?
       }
       m_id_About = insertMenuItemHelper( subMenu, id++, pos2++, i18n("About Diff-Ext ...") );
 
       insertMenuItemHelper( menu, id++, position++, TEXT("KDiff3"), MFS_ENABLED, subMenu );
 
       insertMenuItemHelper( menu, id++, position++, TEXT("") );  // final separator      
 
       ret = MAKE_HRESULT(SEVERITY_SUCCESS, FACILITY_NULL, id-first_cmd);
    }
 
    return ret;
 }
 
 STDMETHODIMP
 DIFF_EXT::InvokeCommand(LPCMINVOKECOMMANDINFO ici) 
 {
    HRESULT ret = NOERROR;
 
    _hwnd = ici->hwnd;
 
    if(HIWORD(ici->lpVerb) == 0) 
    {
       UINT id = m_id_FirstCmd + LOWORD(ici->lpVerb);
       if(id == m_id_Diff) 
       {
          LOG();
          diff( TEXT("\"") + _file_name1 + TEXT("\" \"") + _file_name2 + TEXT("\"") );
       } 
       else if(id == m_id_Diff3) 
       {
          LOG();
          diff( TEXT("\"") + _file_name1 + TEXT("\" \"") + _file_name2 + TEXT("\" \"") + _file_name3 + TEXT("\"") );
       } 
       else if(id == m_id_Merge3) 
       {
          LOG();
          std::list< tstring >::iterator iFrom = m_recentFiles.begin();
          std::list< tstring >::iterator iBase = iFrom;
          ++iBase;
          diff( TEXT("-m \"") + *iBase + TEXT("\" \"") + *iFrom + TEXT("\" \"") + _file_name1 + TEXT("\"") );
       } 
       else if(id == m_id_DiffWith) 
       {
          LOG();
          diff_with(0, false);
       } 
       else if(id == m_id_MergeWith) 
       {
          LOG();
          diff_with(0, true);
       } 
       else if(id == m_id_ClearList) 
       {
          LOG();
          m_recentFiles.clear();
          SERVER::instance()->save_history();
       } 
       else if(id == m_id_DiffLater) 
       {
          MESSAGELOG(TEXT("Diff Later: ")+_file_name1);
          m_recentFiles.remove( _file_name1 );
          m_recentFiles.push_front( _file_name1 );
          SERVER::instance()->save_history();
       } 
       else if(id >= m_id_DiffWith_Base && id < m_id_DiffWith_Base+m_recentFiles.size()) 
       {
          LOG();
          diff_with(id-m_id_DiffWith_Base, false);
       } 
       else if(id == m_id_About) 
       {
          LOG();
          std::wstring sBits = i18n("(32 Bit)");
          if (sizeof(void*)==8)
              sBits = i18n("(64 Bit)");
          MessageBox( _hwnd, (i18n("Diff-Ext Copyright (c) 2003-2006, Sergey Zorin. All rights reserved.\n")
             + i18n("This software is distributable under the BSD-2-Clause license.\n")
             + i18n("Some extensions for KDiff3 (c) 2006-2013 by Joachim Eibl.\n")
             + i18n("Homepage for Diff-Ext: http://diff-ext.sourceforge.net\n")
             + i18n("Homepage for KDiff3: http://kdiff3.sourceforge.net")).c_str()
             , (i18n("About Diff-Ext for KDiff3 ")+sBits).c_str(), MB_OK );
       } 
       else 
       {
          ret = E_INVALIDARG;
          TCHAR verb[80];
          _sntprintf(verb, 79, TEXT("Command id: %d"), LOWORD(ici->lpVerb));
          verb[79]=0;
          ERRORLOG(verb);
       }
    }
    else
    {
       ret = E_INVALIDARG;
    }
 
    return ret;
 }
 
 STDMETHODIMP
 DIFF_EXT::GetCommandString(UINT_PTR idCmd, UINT uFlags, UINT*, LPSTR pszName, UINT cchMax)
 {
    // LOG(); // Gets called very often
    HRESULT ret = NOERROR;
 
    if(uFlags == GCS_HELPTEXT) {
       tstring helpString;
       if( idCmd == m_id_Diff ) 
       {
          helpString = i18n("Compare selected files");
       } 
       else if( idCmd == m_id_DiffWith ) 
       {
          if(!m_recentFiles.empty()) 
          {
             helpString = i18n("Compare '%1' with '%2'");
             replaceArgs( helpString, _file_name1, m_recentFiles.front() );
          }
       } 
       else if(idCmd == m_id_DiffLater) 
       {
          helpString = i18n("Save '%1' for later operation");
          replaceArgs( helpString, _file_name1 );
       } 
       else if((idCmd >= m_id_DiffWith_Base) && (idCmd < m_id_DiffWith_Base+m_recentFiles.size())) 
       {
          if( !m_recentFiles.empty() ) 
          {
             unsigned int num = idCmd - m_id_DiffWith_Base;
             std::list<tstring>::iterator i = m_recentFiles.begin();
             for(unsigned int j = 0; j < num && i != m_recentFiles.end(); j++)
                i++;
 
             if ( i!=m_recentFiles.end() )
             {
                helpString = i18n("Compare '%1' with '%2'");
                replaceArgs( helpString, _file_name1, *i );
             }
          }
       }
       lstrcpyn( (LPTSTR)pszName, helpString.c_str(), cchMax );
    }
    else
    {
       ret = E_INVALIDARG;
    }
 
    return ret;
 }
 
 void
 DIFF_EXT::diff( const tstring& arguments ) 
 {
    LOG();
    STARTUPINFO si;
    PROCESS_INFORMATION pi;
    bool bError = true;
    tstring command = SERVER::instance()->getRegistryKeyString( TEXT(""), TEXT("diffcommand") );
    tstring commandLine = TEXT("\"") + command + TEXT("\" ") + arguments;
    if ( ! command.empty() )
    {
       ZeroMemory(&si, sizeof(si));
       si.cb = sizeof(si);
       if (CreateProcess(command.c_str(), (LPTSTR)commandLine.c_str(), 0, 0, FALSE, 0, 0, 0, &si, &pi) == 0) 
       {
          SYSERRORLOG(TEXT("CreateProcess") + command);
       } 
       else 
       {
          bError = false;
          CloseHandle( pi.hProcess );
          CloseHandle( pi.hThread );
       }
    }
 
    if (bError)
    {
       tstring message = i18n("Could not start KDiff3. Please rerun KDiff3 installation.");
       message += TEXT("\n") + i18n("Command") + TEXT(": ") + command;
       message += TEXT("\n") + i18n("CommandLine") + TEXT(": ") + commandLine;
       MessageBox(_hwnd, message.c_str(), i18n("Diff-Ext For KDiff3").c_str(), MB_OK);
    }
 }
 
 void
 DIFF_EXT::diff_with(unsigned int num, bool bMerge) 
 {
    LOG();
    std::list<tstring>::iterator i = m_recentFiles.begin();
    for(unsigned int j = 0; j < num && i!=m_recentFiles.end(); j++) {
       i++;
    }
 
    if ( i!=m_recentFiles.end() )
       _file_name2 = *i;
 
    diff( (bMerge ? TEXT("-m \"") : TEXT("\"") ) + _file_name2 + TEXT("\" \"") + _file_name1 + TEXT("\"") );
 }
 
 
 tstring
 DIFF_EXT::cut_to_length(const tstring& in, size_t max_len) 
 {
   tstring ret;  
   if( in.length() > max_len) 
   {
      ret = in.substr(0, (max_len-3)/2);
      ret += TEXT("...");
      ret += in.substr( in.length()-(max_len-3)/2 );
   }
   else 
   {
      ret = in;
   }
   
   return ret;
 }
diff --git a/src/common.cpp b/src/common.cpp
index 307a5f4..0abd5bb 100644
--- a/src/common.cpp
+++ b/src/common.cpp
@@ -1,382 +1,382 @@
 /***************************************************************************
  *   Copyright (C) 2004-2007 by Joachim Eibl                               *
  *   joachim.eibl at gmx.de                                                   *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  *   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 Steet, Fifth Floor, Boston, MA 02110-1301, USA.           *
  ***************************************************************************/
 
 #include "common.h"
 #include <QColor>
 #include <QSize>
 #include <QStringList>
 #include <QTextStream>
 #include <map>
 #include <qfont.h>
 #include <qpoint.h>
 
 ValueMap::ValueMap()
 {
 }
 
 ValueMap::~ValueMap()
 {
 }
 
 void ValueMap::save(QTextStream& ts)
 {
     std::map<QString, QString>::iterator i;
     for(i = m_map.begin(); i != m_map.end(); ++i)
     {
         QString key = i->first;
         QString val = i->second;
         ts << key << "=" << val << "\n";
     }
 }
 
 QString ValueMap::getAsString()
 {
     QString result;
     std::map<QString, QString>::iterator i;
     for(i = m_map.begin(); i != m_map.end(); ++i)
     {
         QString key = i->first;
         QString val = i->second;
         result += key + "=" + val + "\n";
     }
     return result;
 }
 
 void ValueMap::load(QTextStream& ts)
 {
     while(!ts.atEnd())
     {                              // until end of file...
         QString s = ts.readLine(); // line of text excluding '\n'
         int pos = s.indexOf('=');
         if(pos > 0) // seems not to have a tag
         {
             QString key = s.left(pos);
             QString val = s.mid(pos + 1);
             m_map[key] = val;
         }
     }
 }
 /*
 void ValueMap::load( const QString& s )
 {
    int pos=0;
    while ( pos<(int)s.length() )
    {                                 // until end of file...
       int pos2 = s.find('=', pos);
       int pos3 = s.find('\n', pos2 );
       if (pos3<0)
          pos3=s.length();
       if( pos2 > 0 )                     // seems not to have a tag
       {
          QString key = s.mid(pos, pos2-pos);
          QString val = s.mid(pos2+1, pos3-pos2-1);
          m_map[key] = val;
       }
       pos = pos3;
    }
 }
 */
 
 // safeStringJoin and safeStringSplit allow to convert a stringlist into a string and back
 // safely, even if the individual strings in the list contain the separator character.
 QString safeStringJoin(const QStringList& sl, char sepChar, char metaChar)
 {
     // Join the strings in the list, using the separator ','
     // If a string contains the separator character, it will be replaced with "\,".
-    // Any occurances of "\" (one backslash) will be replaced with "\\" (2 backslashes)
+    // Any occurences of "\" (one backslash) will be replaced with "\\" (2 backslashes)
 
     Q_ASSERT(sepChar != metaChar);
 
     QString sep;
     sep += sepChar;
     QString meta;
     meta += metaChar;
 
     QString safeString;
 
     QStringList::const_iterator i;
     for(i = sl.begin(); i != sl.end(); ++i)
     {
         QString s = *i;
         s.replace(meta, meta + meta); //  "\" -> "\\"
         s.replace(sep, meta + sep);   //  "," -> "\,"
         if(i == sl.begin())
             safeString = s;
         else
             safeString += sep + s;
     }
     return safeString;
 }
 
 // Split a string that was joined with safeStringJoin
 QStringList safeStringSplit(const QString& s, char sepChar, char metaChar)
 {
     Q_ASSERT(sepChar != metaChar);
     QStringList sl;
     // Miniparser
     int i = 0;
     int len = s.length();
     QString b;
     for(i = 0; i < len; ++i)
     {
         if(i + 1 < len && s[i] == metaChar && s[i + 1] == metaChar) {
             b += metaChar;
             ++i;
         }
         else if(i + 1 < len && s[i] == metaChar && s[i + 1] == sepChar)
         {
             b += sepChar;
             ++i;
         }
         else if(s[i] == sepChar) // real separator
         {
             sl.push_back(b);
             b = "";
         }
         else
         {
             b += s[i];
         }
     }
     if(!b.isEmpty())
         sl.push_back(b);
 
     return sl;
 }
 
 static QString numStr(int n)
 {
     QString s;
     s.setNum(n);
     return s;
 }
 
 static QString subSection(const QString& s, int idx, char sep)
 {
     int pos = 0;
     while(idx > 0)
     {
         pos = s.indexOf(sep, pos);
         --idx;
         if(pos < 0) break;
         ++pos;
     }
     if(pos >= 0)
     {
         int pos2 = s.indexOf(sep, pos);
         if(pos2 > 0)
             return s.mid(pos, pos2 - pos);
         else
             return s.mid(pos);
     }
 
     return "";
 }
 
 static int num(QString& s, int idx)
 {
     return subSection(s, idx, ',').toInt();
 }
 
 void ValueMap::writeEntry(const QString& k, const QFont& v)
 {
     m_map[k] = v.family() + "," + QString::number(v.pointSize()) + "," + (v.bold() ? "bold" : "normal");
 }
 
 void ValueMap::writeEntry(const QString& k, const QColor& v)
 {
     m_map[k] = numStr(v.red()) + "," + numStr(v.green()) + "," + numStr(v.blue());
 }
 
 void ValueMap::writeEntry(const QString& k, const QSize& v)
 {
     m_map[k] = numStr(v.width()) + "," + numStr(v.height());
 }
 
 void ValueMap::writeEntry(const QString& k, const QPoint& v)
 {
     m_map[k] = numStr(v.x()) + "," + numStr(v.y());
 }
 
 void ValueMap::writeEntry(const QString& k, int v)
 {
     m_map[k] = numStr(v);
 }
 
 void ValueMap::writeEntry(const QString& k, bool v)
 {
     m_map[k] = numStr(v);
 }
 
 void ValueMap::writeEntry(const QString& k, const QString& v)
 {
     m_map[k] = v;
 }
 
 void ValueMap::writeEntry(const QString& k, const char* v)
 {
     m_map[k] = v;
 }
 
 void ValueMap::writeEntry(const QString& k, const QStringList& v)
 {
     m_map[k] = safeStringJoin(v);
 }
 
 QFont ValueMap::readFontEntry(const QString& k, const QFont* defaultVal)
 {
     QFont f = *defaultVal;
     std::map<QString, QString>::iterator i = m_map.find(k);
     if(i != m_map.end())
     {
         f.setFamily(subSection(i->second, 0, ','));
         f.setPointSize(subSection(i->second, 1, ',').toInt());
         f.setBold(subSection(i->second, 2, ',') == "bold");
     }
     return f;
 }
 
 QColor ValueMap::readColorEntry(const QString& k, const QColor* defaultVal)
 {
     QColor c = *defaultVal;
     std::map<QString, QString>::iterator i = m_map.find(k);
     if(i != m_map.end())
     {
         QString s = i->second;
         c = QColor(num(s, 0), num(s, 1), num(s, 2));
     }
 
     return c;
 }
 
 QSize ValueMap::readSizeEntry(const QString& k, const QSize* defaultVal)
 {
     QSize size = defaultVal ? *defaultVal : QSize(600, 400);
     std::map<QString, QString>::iterator i = m_map.find(k);
     if(i != m_map.end())
     {
 
         QString s = i->second;
         size = QSize(num(s, 0), num(s, 1));
     }
 
     return size;
 }
 
 QPoint ValueMap::readPointEntry(const QString& k, const QPoint* defaultVal)
 {
     QPoint point = defaultVal ? *defaultVal : QPoint(0, 0);
     std::map<QString, QString>::iterator i = m_map.find(k);
     if(i != m_map.end())
     {
         QString s = i->second;
         point = QPoint(num(s, 0), num(s, 1));
     }
 
     return point;
 }
 
 bool ValueMap::readBoolEntry(const QString& k, bool bDefault)
 {
     bool b = bDefault;
     std::map<QString, QString>::iterator i = m_map.find(k);
     if(i != m_map.end())
     {
         QString s = i->second;
         b = (bool)num(s, 0);
     }
 
     return b;
 }
 
 int ValueMap::readNumEntry(const QString& k, int iDefault)
 {
     int ival = iDefault;
     std::map<QString, QString>::iterator i = m_map.find(k);
     if(i != m_map.end())
     {
         QString s = i->second;
         ival = num(s, 0);
     }
 
     return ival;
 }
 
 QString ValueMap::readStringEntry(const QString& k, const QString& sDefault)
 {
     QString sval = sDefault;
     std::map<QString, QString>::iterator i = m_map.find(k);
     if(i != m_map.end())
     {
         sval = i->second;
     }
 
     return sval;
 }
 
 QStringList ValueMap::readListEntry(const QString& k, const QStringList& defaultVal)
 {
     QStringList strList;
 
     std::map<QString, QString>::iterator i = m_map.find(k);
     if(i != m_map.end()) {
         strList = safeStringSplit(i->second);
         return strList;
     }
     else
         return defaultVal;
 }
 
 QString ValueMap::readEntry(const QString& s, const QString& defaultVal)
 {
     return readStringEntry(s, defaultVal);
 }
 QString ValueMap::readEntry(const QString& s, const char* defaultVal)
 {
     return readStringEntry(s, QString::fromLatin1(defaultVal));
 }
 QFont ValueMap::readEntry(const QString& s, const QFont& defaultVal)
 {
     return readFontEntry(s, &defaultVal);
 }
 QColor ValueMap::readEntry(const QString& s, const QColor defaultVal)
 {
     return readColorEntry(s, &defaultVal);
 }
 QSize ValueMap::readEntry(const QString& s, const QSize defaultVal)
 {
     return readSizeEntry(s, &defaultVal);
 }
 QPoint ValueMap::readEntry(const QString& s, const QPoint defaultVal)
 {
     return readPointEntry(s, &defaultVal);
 }
 bool ValueMap::readEntry(const QString& s, bool bDefault)
 {
     return readBoolEntry(s, bDefault);
 }
 int ValueMap::readEntry(const QString& s, int iDefault)
 {
     return readNumEntry(s, iDefault);
 }
 QStringList ValueMap::readEntry(const QString& s, const QStringList& defaultVal)
 {
     return readListEntry(s, defaultVal);
 }
diff --git a/src/diff.cpp b/src/diff.cpp
index 873f4ba..7fcec2a 100644
--- a/src/diff.cpp
+++ b/src/diff.cpp
@@ -1,2471 +1,2471 @@
 /***************************************************************************
                           diff.cpp  -  description
                              -------------------
     begin                : Mon Mar 18 2002
     copyright            : (C) 2002-2007 by Joachim Eibl
     email                : joachim.eibl at gmx.de
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #include <qglobal.h>
 
 #ifdef Q_OS_WIN
 #include <qt_windows.h>
 
 #include <QCoreApplication>
 #endif
 
 #include <cstdlib>
 
 #include "diff.h"
 #include "fileaccess.h"
 #include "gnudiff_diff.h"
 #include "options.h"
 #include "progress.h"
 
 #include <KLocalizedString>
 #include <KMessageBox>
 
 #include <QDir>
 #include <QFileInfo>
 #include <QProcess>
 #include <QTextCodec>
 #include <QTextStream>
 
 #include <ctype.h>
 #include <map>
 //using namespace std;
 
 int LineData::width(int tabSize) const
 {
     int w = 0;
     int j = 0;
     for(int i = 0; i < size; ++i)
     {
         if(pLine[i] == '\t')
         {
             for(j %= tabSize; j < tabSize; ++j)
                 ++w;
             j = 0;
         }
         else
         {
             ++w;
             ++j;
         }
     }
     return w;
 }
 
 // The bStrict flag is true during the test where a nonmatching area ends.
 // Then the equal()-function requires that the match has more than 2 nonwhite characters.
 // This is to avoid matches on trivial lines (e.g. with white space only).
 // This choice is good for C/C++.
 bool equal(const LineData& l1, const LineData& l2, bool bStrict)
 {
     if(l1.pLine == nullptr || l2.pLine == nullptr) return false;
 
-    if(bStrict && g_bIgnoreTrivialMatches) //&& (l1.occurances>=5 || l2.occurances>=5) )
+    if(bStrict && g_bIgnoreTrivialMatches) //&& (l1.occurences>=5 || l2.occurences>=5) )
         return false;
 
     // Ignore white space diff
     const QChar* p1 = l1.pLine;
     const QChar* p1End = p1 + l1.size;
 
     const QChar* p2 = l2.pLine;
     const QChar* p2End = p2 + l2.size;
 
     if(g_bIgnoreWhiteSpace)
     {
         int nonWhite = 0;
         for(;;)
         {
             while(isWhite(*p1) && p1 != p1End) ++p1;
             while(isWhite(*p2) && p2 != p2End) ++p2;
 
             if(p1 == p1End && p2 == p2End)
             {
                 if(bStrict && g_bIgnoreTrivialMatches)
                 { // Then equality is not enough
                     return nonWhite > 2;
                 }
                 else // equality is enough
                     return true;
             }
             else if(p1 == p1End || p2 == p2End)
                 return false;
 
             if(*p1 != *p2)
                 return false;
             ++p1;
             ++p2;
             ++nonWhite;
         }
     }
 
     else
     {
         if(l1.size == l2.size && memcmp(p1, p2, l1.size) == 0)
             return true;
         else
             return false;
     }
 }
 
 static bool isLineOrBufEnd(const QChar* p, int i, int size)
 {
     return i >= size            // End of file
            || isEndOfLine(p[i]) // Normal end of line
 
         // No support for Mac-end of line yet, because incompatible with GNU-diff-routines.
         // || ( p[i]=='\r' && (i>=size-1 || p[i+1]!='\n')
         //                 && (i==0        || p[i-1]!='\n') )  // Special case: '\r' without '\n'
         ;
 }
 
 /* Features of class SourceData:
 - Read a file (from the given URL) or accept data via a string.
 - Allocate and free buffers as necessary.
 - Run a preprocessor, when specified.
 - Run the line-matching preprocessor, when specified.
 - Run other preprocessing steps: Uppercase, ignore comments,
                                  remove carriage return, ignore numbers.
 
 Order of operation:
  1. If data was given via a string then save it to a temp file. (see setData())
  2. If the specified file is nonlocal (URL) copy it to a temp file.
  3. If a preprocessor was specified, run the input file through it.
  4. Read the output of the preprocessor.
  5. If Uppercase was specified: Turn the read data to uppercase.
  6. Write the result to a temp file.
  7. If a line-matching preprocessor was specified, run the temp file through it.
  8. Read the output of the line-matching preprocessor.
  9. If ignore numbers was specified, strip the LMPP-output of all numbers.
 10. If ignore comments was specified, strip the LMPP-output of comments.
 
 Optimizations: Skip unneeded steps.
 */
 
 SourceData::SourceData()
 {
     m_pOptions = nullptr;
     reset();
 }
 
 SourceData::~SourceData()
 {
     reset();
 }
 
 void SourceData::reset()
 {
     m_pEncoding = nullptr;
     m_fileAccess = FileAccess();
     m_normalData.reset();
     m_lmppData.reset();
     if(!m_tempInputFileName.isEmpty())
     {
         FileAccess::removeFile(m_tempInputFileName);
         m_tempInputFileName = "";
     }
 }
 
 void SourceData::setFilename(const QString& filename)
 {
     if(filename.isEmpty())
     {
         reset();
     }
     else
     {
         FileAccess fa(filename);
         setFileAccess(fa);
     }
 }
 
 bool SourceData::isEmpty()
 {
     return getFilename().isEmpty();
 }
 
 bool SourceData::hasData()
 {
     return m_normalData.m_pBuf != nullptr;
 }
 
 bool SourceData::isValid()
 {
     return isEmpty() || hasData();
 }
 
 void SourceData::setOptions(Options* pOptions)
 {
     m_pOptions = pOptions;
 }
 
 QString SourceData::getFilename()
 {
     return m_fileAccess.absoluteFilePath();
 }
 
 QString SourceData::getAliasName()
 {
     return m_aliasName.isEmpty() ? m_fileAccess.prettyAbsPath() : m_aliasName;
 }
 
 void SourceData::setAliasName(const QString& name)
 {
     m_aliasName = name;
 }
 
 void SourceData::setFileAccess(const FileAccess& fileAccess)
 {
     m_fileAccess = fileAccess;
     m_aliasName = QString();
     if(!m_tempInputFileName.isEmpty())
     {
         FileAccess::removeFile(m_tempInputFileName);
         m_tempInputFileName = "";
     }
 }
 void SourceData::setEncoding(QTextCodec* pEncoding)
 {
     m_pEncoding = pEncoding;
 }
 
 QStringList SourceData::setData(const QString& data)
 {
     QStringList errors;
 
     // Create a temp file for preprocessing:
     if(m_tempInputFileName.isEmpty())
     {
         m_tempInputFileName = FileAccess::tempFileName();
     }
 
     FileAccess f(m_tempInputFileName);
     QByteArray ba = QTextCodec::codecForName("UTF-8")->fromUnicode(data);
     bool bSuccess = f.writeFile(ba.constData(), ba.length());
     if(!bSuccess)
     {
         errors.append(i18n("Writing clipboard data to temp file failed."));
     }
     else
     {
         m_aliasName = i18n("From Clipboard");
         m_fileAccess = FileAccess(""); // Effect: m_fileAccess.isValid() is false
     }
 
     return errors;
 }
 
 const LineData* SourceData::getLineDataForDiff() const
 {
     if(m_lmppData.m_pBuf == nullptr)
         return m_normalData.m_v.size() > 0 ? &m_normalData.m_v[0] : nullptr;
     else
         return m_lmppData.m_v.size() > 0 ? &m_lmppData.m_v[0] : nullptr;
 }
 
 const LineData* SourceData::getLineDataForDisplay() const
 {
     return m_normalData.m_v.size() > 0 ? &m_normalData.m_v[0] : nullptr;
 }
 
 LineRef SourceData::getSizeLines() const
 {
     return (LineRef)m_normalData.m_vSize;
 }
 
 qint64 SourceData::getSizeBytes() const
 {
     return m_normalData.m_size;
 }
 
 const char* SourceData::getBuf() const
 {
     return m_normalData.m_pBuf;
 }
 
 const QString& SourceData::getText() const
 {
     return m_normalData.m_unicodeBuf;
 }
 
 bool SourceData::isText()
 {
     return m_normalData.m_bIsText;
 }
 
 bool SourceData::isIncompleteConversion()
 {
     return m_normalData.m_bIncompleteConversion;
 }
 
 bool SourceData::isFromBuffer()
 {
     return !m_fileAccess.isValid();
 }
 
 bool SourceData::isBinaryEqualWith(const SourceData& other) const
 {
     return m_fileAccess.exists() && other.m_fileAccess.exists() &&
            getSizeBytes() == other.getSizeBytes() &&
            (getSizeBytes() == 0 || memcmp(getBuf(), other.getBuf(), getSizeBytes()) == 0);
 }
 
 void SourceData::FileData::reset()
 {
     delete[](char*) m_pBuf;
     m_pBuf = nullptr;
     m_v.clear();
     m_size = 0;
     m_vSize = 0;
     m_bIsText = true;
     m_bIncompleteConversion = false;
     m_eLineEndStyle = eLineEndStyleUndefined;
 }
 
 bool SourceData::FileData::readFile(const QString& filename)
 {
     reset();
     if(filename.isEmpty()) {
         return true;
     }
 
     FileAccess fa(filename);
     m_size = fa.sizeForReading();
     char* pBuf;
-    m_pBuf = pBuf = new char[m_size + 100]; // Alloc 100 byte extra: Savety hack, not nice but does no harm.
+    m_pBuf = pBuf = new char[m_size + 100]; // Alloc 100 byte extra: Safety hack, not nice but does no harm.
                                             // Some extra bytes at the end of the buffer are needed by
                                             // the diff algorithm. See also GnuDiff::diff_2_files().
     bool bSuccess = fa.readFile(pBuf, m_size);
     if(!bSuccess)
     {
         delete[] pBuf;
         m_pBuf = nullptr;
         m_size = 0;
     }
     return bSuccess;
 }
 
 bool SourceData::saveNormalDataAs(const QString& fileName)
 {
     return m_normalData.writeFile(fileName);
 }
 
 bool SourceData::FileData::writeFile(const QString& filename)
 {
     if(filename.isEmpty()) {
         return true;
     }
 
     FileAccess fa(filename);
     bool bSuccess = fa.writeFile(m_pBuf, m_size);
     return bSuccess;
 }
 
 void SourceData::FileData::copyBufFrom(const FileData& src)
 {
     reset();
     char* pBuf;
     m_size = src.m_size;
     m_pBuf = pBuf = new char[m_size + 100];
     memcpy(pBuf, src.m_pBuf, m_size);
 }
 
 // Convert the input file from input encoding to output encoding and write it to the output file.
 static bool convertFileEncoding(const QString& fileNameIn, QTextCodec* pCodecIn,
                                 const QString& fileNameOut, QTextCodec* pCodecOut)
 {
     QFile in(fileNameIn);
     if(!in.open(QIODevice::ReadOnly))
         return false;
     QTextStream inStream(&in);
     inStream.setCodec(pCodecIn);
     inStream.setAutoDetectUnicode(false);
 
     QFile out(fileNameOut);
     if(!out.open(QIODevice::WriteOnly))
         return false;
     QTextStream outStream(&out);
     outStream.setCodec(pCodecOut);
 
     QString data = inStream.readAll();
     outStream << data;
 
     return true;
 }
 
 static QTextCodec* getEncodingFromTag(const QByteArray& s, const QByteArray& encodingTag)
 {
     int encodingPos = s.indexOf(encodingTag);
     if(encodingPos >= 0)
     {
         int apostrophPos = s.indexOf('"', encodingPos + encodingTag.length());
         int apostroph2Pos = s.indexOf('\'', encodingPos + encodingTag.length());
         char apostroph = '"';
         if(apostroph2Pos >= 0 && (apostrophPos < 0 || apostroph2Pos < apostrophPos))
         {
             apostroph = '\'';
             apostrophPos = apostroph2Pos;
         }
 
         int encodingEnd = s.indexOf(apostroph, apostrophPos + 1);
         if(encodingEnd >= 0) // e.g.: <meta charset="utf-8"> or <?xml version="1.0" encoding="ISO-8859-1"?>
         {
             QByteArray encoding = s.mid(apostrophPos + 1, encodingEnd - (apostrophPos + 1));
             return QTextCodec::codecForName(encoding);
         }
         else // e.g.: <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
         {
             QByteArray encoding = s.mid(encodingPos + encodingTag.length(), apostrophPos - (encodingPos + encodingTag.length()));
             return QTextCodec::codecForName(encoding);
         }
     }
     return nullptr;
 }
 
 static QTextCodec* detectEncoding(const char* buf, qint64 size, qint64& skipBytes)
 {
     if(size >= 2)
     {
         if(buf[0] == '\xFF' && buf[1] == '\xFE')
         {
             skipBytes = 2;
             return QTextCodec::codecForName("UTF-16LE");
         }
 
         if(buf[0] == '\xFE' && buf[1] == '\xFF')
         {
             skipBytes = 2;
             return QTextCodec::codecForName("UTF-16BE");
         }
     }
     if(size >= 3)
     {
         if(buf[0] == '\xEF' && buf[1] == '\xBB' && buf[2] == '\xBF')
         {
             skipBytes = 3;
             return QTextCodec::codecForName("UTF-8-BOM");
         }
     }
     skipBytes = 0;
     QByteArray s;
     /*
         We don't need the whole file here just the header.
 ]    */
     if(size <= 5000)
         s=QByteArray(buf, (int)size);
     else
         s=QByteArray(buf, 5000);
     
     int xmlHeaderPos = s.indexOf("<?xml");
     if(xmlHeaderPos >= 0)
     {
         int xmlHeaderEnd = s.indexOf("?>", xmlHeaderPos);
         if(xmlHeaderEnd >= 0)
         {
             QTextCodec* pCodec = getEncodingFromTag(s.mid(xmlHeaderPos, xmlHeaderEnd - xmlHeaderPos), "encoding=");
             if(pCodec)
                 return pCodec;
         }
     }
     else // HTML
     {
         int metaHeaderPos = s.indexOf("<meta");
         while(metaHeaderPos >= 0)
         {
             int metaHeaderEnd = s.indexOf(">", metaHeaderPos);
             if(metaHeaderEnd >= 0)
             {
                 QTextCodec* pCodec = getEncodingFromTag(s.mid(metaHeaderPos, metaHeaderEnd - metaHeaderPos), "charset=");
                 if(pCodec)
                     return pCodec;
 
                 metaHeaderPos = s.indexOf("<meta", metaHeaderEnd);
             }
             else
                 break;
         }
     }
     return nullptr;
 }
 
 QTextCodec* SourceData::detectEncoding(const QString& fileName, QTextCodec* pFallbackCodec)
 {
     QFile f(fileName);
     if(f.open(QIODevice::ReadOnly))
     {
         char buf[200];
         qint64 size = f.read(buf, sizeof(buf));
         qint64 skipBytes = 0;
         QTextCodec* pCodec = ::detectEncoding(buf, size, skipBytes);
         if(pCodec)
             return pCodec;
     }
     return pFallbackCodec;
 }
 
 /* Split the command line into arguments.
  * Normally split at white space separators except when quoting with " or '.
  * Backslash is treated as meta character within single quotes ' only.
  * Detect parsing errors like unclosed quotes.
  * The first item in the list will be the command itself.
  * Returns the error reasor as string or an empty string on success.
  * Eg. >"1" "2"<           => >1<, >2<
  * Eg. >'\'\\'<            => >'\<   backslash is a meta character between single quotes
  * Eg. > "\\" <            => >\\<   but not between double quotes
  * Eg. >"c:\sed" 's/a/\' /g'<  => >c:\sed<, >s/a/' /g<
  */
 static QString getArguments(QString cmd, QString& program, QStringList& args)
 {
     program = QString();
     args.clear();
     for(int i = 0; i < cmd.length(); ++i)
     {
         while(i < cmd.length() && cmd[i].isSpace())
         {
             ++i;
         }
         if(cmd[i] == '"' || cmd[i] == '\'') // argument beginning with a quote
         {
             QChar quoteChar = cmd[i];
             ++i;
             int argStart = i;
             bool bSkip = false;
             while(i < cmd.length() && (cmd[i] != quoteChar || bSkip))
             {
                 if(bSkip)
                 {
                     bSkip = false;
                     if(cmd[i] == '\\' || cmd[i] == quoteChar)
                     {
                         cmd.remove(i - 1, 1); // remove the backslash '\'
                         continue;
                     }
                 }
                 else if(cmd[i] == '\\' && quoteChar == '\'')
                     bSkip = true;
                 ++i;
             }
             if(i < cmd.length())
             {
                 args << cmd.mid(argStart, i - argStart);
                 if(i + 1 < cmd.length() && !cmd[i + 1].isSpace())
                     return i18n("Expecting space after closing apostroph.");
             }
             else
                 return i18n("Not matching apostrophs.");
             continue;
         }
         else
         {
             int argStart = i;
             //bool bSkip = false;
             while(i < cmd.length() && (!cmd[i].isSpace() /*|| bSkip*/))
             {
                 /*if ( bSkip )
             {
                bSkip = false;
                if ( cmd[i]=='\\' || cmd[i]=='"' || cmd[i]=='\'' || cmd[i].isSpace() )
                {
                   cmd.remove( i-1, 1 );  // remove the backslash '\'
                   continue;
                }
             }
             else if ( cmd[i]=='\\' )
                bSkip = true;
             else */
                 if(cmd[i] == '"' || cmd[i] == '\'')
                     return i18n("Unexpected apostroph within argument.");
                 ++i;
             }
             args << cmd.mid(argStart, i - argStart);
         }
     }
     if(args.isEmpty())
         return i18n("No program specified.");
     else
     {
         program = args[0];
         args.pop_front();
 #ifdef Q_OS_WIN
         if(program == "sed")
         {
             QString prg = QCoreApplication::applicationDirPath() + "/bin/sed.exe"; // in subdir bin
             if(QFile::exists(prg))
             {
                 program = prg;
             }
             else
             {
                 prg = QCoreApplication::applicationDirPath() + "/sed.exe"; // in same dir
                 if(QFile::exists(prg))
                 {
                     program = prg;
                 }
             }
         }
 #endif
     }
     return QString();
 }
 
 QStringList SourceData::readAndPreprocess(QTextCodec* pEncoding, bool bAutoDetectUnicode)
 {
     m_pEncoding = pEncoding;
     QString fileNameIn1;
     QString fileNameOut1;
     QString fileNameIn2;
     QString fileNameOut2;
     QStringList errors;
 
     bool bTempFileFromClipboard = !m_fileAccess.isValid();
 
     // Detect the input for the preprocessing operations
     if(!bTempFileFromClipboard)
     {
         if(m_fileAccess.isLocal())
         {
             fileNameIn1 = m_fileAccess.absoluteFilePath();
         }
         else // File is not local: create a temporary local copy:
         {
             if(m_tempInputFileName.isEmpty()) {
                 m_tempInputFileName = FileAccess::tempFileName();
             }
 
             m_fileAccess.copyFile(m_tempInputFileName);
             fileNameIn1 = m_tempInputFileName;
         }
         if(bAutoDetectUnicode)
         {
             m_pEncoding = detectEncoding(fileNameIn1, pEncoding);
         }
     }
     else // The input was set via setData(), probably from clipboard.
     {
         fileNameIn1 = m_tempInputFileName;
         m_pEncoding = QTextCodec::codecForName("UTF-8");
     }
     QTextCodec* pEncoding1 = m_pEncoding;
     QTextCodec* pEncoding2 = m_pEncoding;
 
     m_normalData.reset();
     m_lmppData.reset();
 
     FileAccess faIn(fileNameIn1);
     qint64 fileInSize = faIn.size();
 
     if(faIn.exists())
     {
         // Run the first preprocessor
         if(m_pOptions->m_PreProcessorCmd.isEmpty())
         {
             // No preprocessing: Read the file directly:
             m_normalData.readFile(fileNameIn1);
         }
         else
         {
             QString fileNameInPP = fileNameIn1;
 
             if(pEncoding1 != m_pOptions->m_pEncodingPP)
             {
                 // Before running the preprocessor convert to the format that the preprocessor expects.
                 fileNameInPP = FileAccess::tempFileName();
                 pEncoding1 = m_pOptions->m_pEncodingPP;
                 convertFileEncoding(fileNameIn1, pEncoding, fileNameInPP, pEncoding1);
             }
 
             QString ppCmd = m_pOptions->m_PreProcessorCmd;
             fileNameOut1 = FileAccess::tempFileName();
 
             QProcess ppProcess;
             ppProcess.setStandardInputFile(fileNameInPP);
             ppProcess.setStandardOutputFile(fileNameOut1);
             QString program;
             QStringList args;
             QString errorReason = getArguments(ppCmd, program, args);
             if(errorReason.isEmpty())
             {
                 ppProcess.start(program, args);
                 ppProcess.waitForFinished(-1);
             }
             else
                 errorReason = "\n(" + errorReason + ")";
             
             bool bSuccess = errorReason.isEmpty() && m_normalData.readFile(fileNameOut1);
             if(fileInSize > 0 && (!bSuccess || m_normalData.m_size == 0))
             {
 
                 errors.append(
                     i18n("Preprocessing possibly failed. Check this command:\n\n  %1"
                          "\n\nThe preprocessing command will be disabled now.", ppCmd) +
                     errorReason);
                 m_pOptions->m_PreProcessorCmd = "";
                 m_normalData.readFile(fileNameIn1);
                 pEncoding1 = m_pEncoding;
             }
             if(fileNameInPP != fileNameIn1)
             {
                 FileAccess::removeTempFile(fileNameInPP);
             }
         }
 
         // LineMatching Preprocessor
         if(!m_pOptions->m_LineMatchingPreProcessorCmd.isEmpty())
         {
             fileNameIn2 = fileNameOut1.isEmpty() ? fileNameIn1 : fileNameOut1;
             QString fileNameInPP = fileNameIn2;
             pEncoding2 = pEncoding1;
             if(pEncoding2 != m_pOptions->m_pEncodingPP)
             {
                 // Before running the preprocessor convert to the format that the preprocessor expects.
                 fileNameInPP = FileAccess::tempFileName();
                 pEncoding2 = m_pOptions->m_pEncodingPP;
                 convertFileEncoding(fileNameIn2, pEncoding1, fileNameInPP, pEncoding2);
             }
 
             QString ppCmd = m_pOptions->m_LineMatchingPreProcessorCmd;
             fileNameOut2 = FileAccess::tempFileName();
             QProcess ppProcess;
             ppProcess.setStandardInputFile(fileNameInPP);
             ppProcess.setStandardOutputFile(fileNameOut2);
             QString program;
             QStringList args;
             QString errorReason = getArguments(ppCmd, program, args);
             if(errorReason.isEmpty())
             {
                 ppProcess.start(program, args);
                 ppProcess.waitForFinished(-1);
             }
             else
                 errorReason = "\n(" + errorReason + ")";
             
             bool bSuccess = errorReason.isEmpty() && m_lmppData.readFile(fileNameOut2);
             if(FileAccess(fileNameIn2).size() > 0 && (!bSuccess || m_lmppData.m_size == 0))
             {
                 errors.append(
                     i18n("The line-matching-preprocessing possibly failed. Check this command:\n\n  %1"
                          "\n\nThe line-matching-preprocessing command will be disabled now.", ppCmd) +
                     errorReason);
                 m_pOptions->m_LineMatchingPreProcessorCmd = "";
                 m_lmppData.readFile(fileNameIn2);
             }
             FileAccess::removeTempFile(fileNameOut2);
             if(fileNameInPP != fileNameIn2)
             {
                 FileAccess::removeTempFile(fileNameInPP);
             }
         }
         else if(m_pOptions->m_bIgnoreComments || m_pOptions->m_bIgnoreCase)
         {
             // We need a copy of the normal data.
             m_lmppData.copyBufFrom(m_normalData);
         }
         else
         { // We don't need any lmpp data at all.
             m_lmppData.reset();
         }
     }
 
     if(!m_normalData.preprocess(m_pOptions->m_bPreserveCarriageReturn, pEncoding1) ||
        !m_lmppData.preprocess(false, pEncoding2))
     {
 
         errors.append(i18n("File %1 too large to process. Skipping.", fileNameIn1));
     }
     else
     {
         //FIXME: Remove this hack after determining root cause.
         if(m_lmppData.m_vSize < m_normalData.m_vSize)
         {
             //This a bug that needs fixed elsewhere not hacked around
             Q_ASSERT(m_lmppData.m_vSize == m_normalData.m_vSize);
             // This probably is the fault of the LMPP-Command, but not worth reporting.
             m_lmppData.m_v.resize((int)m_normalData.m_vSize);
             for(qint64 i = m_lmppData.m_vSize; i < m_normalData.m_vSize; ++i)
             { // Set all empty lines to point to the end of the buffer.
                 m_lmppData.m_v[(int)i].pLine = m_lmppData.m_unicodeBuf.unicode() + m_lmppData.m_unicodeBuf.length();
             }
 
             m_lmppData.m_vSize = m_normalData.m_vSize;
         }
 
         // Internal Preprocessing: Uppercase-conversion
         if(m_pOptions->m_bIgnoreCase)
         {
             m_lmppData.m_unicodeBuf = QLocale::system().toUpper(m_lmppData.m_unicodeBuf);
         }
 
         // Ignore comments
         if(m_pOptions->m_bIgnoreComments)
         {
             m_lmppData.removeComments();
             LineRef vSize = (LineRef)min2(m_normalData.m_vSize, m_lmppData.m_vSize);
             for(int i = 0; i < (int)vSize; ++i)
             {
                 m_normalData.m_v[i].bContainsPureComment = m_lmppData.m_v[i].bContainsPureComment;
             }
         }
     }
     // Remove unneeded temporary files. (A temp file from clipboard must not be deleted.)
     if(!bTempFileFromClipboard && !m_tempInputFileName.isEmpty())
     {
         FileAccess::removeTempFile(m_tempInputFileName);
         m_tempInputFileName = "";
     }
 
     if(!fileNameOut1.isEmpty())
     {
         FileAccess::removeTempFile(fileNameOut1);
         fileNameOut1 = "";
     }
 
     return errors;
 }
 
 /** Prepare the linedata vector for every input line.*/
 bool SourceData::FileData::preprocess(bool bPreserveCR, QTextCodec* pEncoding)
 {
     qint64 i;
     // detect line end style
     QVector<e_LineEndStyle> vOrigDataLineEndStyle;
     m_eLineEndStyle = eLineEndStyleUndefined;
     for(i = 0; i < m_size; ++i)
     {
         if(m_pBuf[i] == '\r')
         {
             if(i + 1 < m_size && m_pBuf[i + 1] == '\n') // not 16-bit unicode
             {
                 vOrigDataLineEndStyle.push_back(eLineEndStyleDos);
                 ++i;
             }
             else if(i > 0 && i + 2 < m_size && m_pBuf[i - 1] == '\0' && m_pBuf[i + 1] == '\0' && m_pBuf[i + 2] == '\n') // 16-bit unicode
             {
                 vOrigDataLineEndStyle.push_back(eLineEndStyleDos);
                 i += 2;
             }
             else // old mac line end style ?
             {
                 vOrigDataLineEndStyle.push_back(eLineEndStyleUndefined);
                 const_cast<char*>(m_pBuf)[i] = '\n'; // fix it in original data
             }
         }
         else if(m_pBuf[i] == '\n')
         {
             vOrigDataLineEndStyle.push_back(eLineEndStyleUnix);
         }
     }
 
     if(!vOrigDataLineEndStyle.isEmpty())
         m_eLineEndStyle = vOrigDataLineEndStyle[0];
 
     qint64 skipBytes = 0;
     QTextCodec* pCodec = ::detectEncoding(m_pBuf, m_size, skipBytes);
     if(pCodec != pEncoding)
         skipBytes = 0;
     
     if(m_size - skipBytes > INT_MAX)
         return false;
     
     QByteArray ba = QByteArray::fromRawData(m_pBuf + skipBytes, (int)(m_size - skipBytes));
     QTextStream ts(ba, QIODevice::ReadOnly | QIODevice::Text);
     ts.setCodec(pEncoding);
     ts.setAutoDetectUnicode(false);
     m_unicodeBuf = ts.readAll();
     ba.clear();
 
     int ucSize = m_unicodeBuf.length();
     const QChar* p = m_unicodeBuf.unicode();
 
     m_bIsText = true;
     int lines = 1;
     m_bIncompleteConversion = false;
     for(i = 0; i < ucSize; ++i)
     {
         if(i >= ucSize || p[i] == '\n')
         {
             ++lines;
         }
         if(p[i].isNull())
         {
             m_bIsText = false;
         }
         if(p[i] == QChar::ReplacementCharacter)
         {
             m_bIncompleteConversion = true;
         }
     }
 
     m_v.resize(lines + 5);
     int lineIdx = 0;
     int lineLength = 0;
     bool bNonWhiteFound = false;
     int whiteLength = 0;
     for(i = 0; i <= ucSize; ++i)
     {
         if(i >= ucSize || p[i] == '\n')
         {
             m_v[lineIdx].pLine = &p[i - lineLength];
             while(/*!bPreserveCR  &&*/ lineLength > 0 && m_v[lineIdx].pLine[lineLength - 1] == '\r')
             {
                 --lineLength;
             }
             m_v[lineIdx].pFirstNonWhiteChar = m_v[lineIdx].pLine + min2(whiteLength, lineLength);
             m_v[lineIdx].size = lineLength;
             if(lineIdx < vOrigDataLineEndStyle.count() && bPreserveCR && i < ucSize)
             {
                 ++m_v[lineIdx].size;
                 const_cast<QChar*>(m_v[lineIdx].pLine)[lineLength] = '\r';
                 //switch ( vOrigDataLineEndStyle[lineIdx] )
                 //{
                 //case eLineEndStyleUnix: const_cast<QChar*>(m_v[lineIdx].pLine)[lineLength] = '\n'; break;
                 //case eLineEndStyleDos:  const_cast<QChar*>(m_v[lineIdx].pLine)[lineLength] = '\r'; break;
                 //case eLineEndStyleUndefined: const_cast<QChar*>(m_v[lineIdx].pLine)[lineLength] = '\x0b'; break;
                 //}
             }
             lineLength = 0;
             bNonWhiteFound = false;
             whiteLength = 0;
             ++lineIdx;
         }
         else
         {
             ++lineLength;
 
             if(!bNonWhiteFound && isWhite(p[i]))
                 ++whiteLength;
             else
                 bNonWhiteFound = true;
         }
     }
     Q_ASSERT(lineIdx == lines);
 
     m_vSize = lines;
     return true;
 }
 
 // Must not be entered, when within a comment.
 // Returns either at a newline-character p[i]=='\n' or when i==size.
 // A line that contains only comments is still "white".
 // Comments in white lines must remain, while comments in
 // non-white lines are overwritten with spaces.
 void SourceData::FileData::checkLineForComments(
     const QChar* p,          // pointer to start of buffer
     int& i,                  // index of current position (in, out)
     int size,                // size of buffer
     bool& bWhite,            // false if this line contains nonwhite characters (in, out)
     bool& bCommentInLine,    // true if any comment is within this line (in, out)
     bool& bStartsOpenComment // true if the line ends within an comment (out)
     )
 {
     bStartsOpenComment = false;
     for(; i < size; ++i)
     {
         // A single apostroph ' has prio over a double apostroph " (e.g. '"')
         // (if not in a string)
         if(p[i] == '\'')
         {
             bWhite = false;
             ++i;
             for(; !isLineOrBufEnd(p, i, size) && p[i] != '\''; ++i)
                 ;
             if(p[i] == '\'') ++i;
         }
 
         // Strings have priority over comments: e.g. "/* Not a comment, but a string. */"
         else if(p[i] == '"')
         {
             bWhite = false;
             ++i;
             for(; !isLineOrBufEnd(p, i, size) && !(p[i] == '"' && p[i - 1] != '\\'); ++i)
                 ;
             if(p[i] == '"') ++i;
         }
 
         // C++-comment
         else if(p[i] == '/' && i + 1 < size && p[i + 1] == '/')
         {
             int commentStart = i;
             bCommentInLine = true;
             i += 2;
             for(; !isLineOrBufEnd(p, i, size); ++i)
                 ;
             if(!bWhite)
             {
                 int size = i - commentStart;
                 m_unicodeBuf.replace(commentStart, size, QString(" ").repeated(size));
             }
             return;
         }
 
         // C-comment
         else if(p[i] == '/' && i + 1 < size && p[i + 1] == '*')
         {
             int commentStart = i;
             bCommentInLine = true;
             i += 2;
             for(; !isLineOrBufEnd(p, i, size); ++i)
             {
                 if(i + 1 < size && p[i] == '*' && p[i + 1] == '/') // end of the comment
                 {
                     i += 2;
 
                     // More comments in the line?
                     checkLineForComments(p, i, size, bWhite, bCommentInLine, bStartsOpenComment);
                     if(!bWhite)
                     {
                         int size = i - commentStart;
                         m_unicodeBuf.replace(commentStart, size, QString(" ").repeated(size));                    }
                     return;
                 }
             }
             bStartsOpenComment = true;
             return;
         }
 
         if(isLineOrBufEnd(p, i, size))
         {
             return;
         }
         else if(!p[i].isSpace())
         {
             bWhite = false;
         }
     }
 }
 
 // Modifies the input data, and replaces C/C++ comments with whitespace
 // when the line contains other data too. If the line contains only
 // a comment or white data, remember this in the flag bContainsPureComment.
 void SourceData::FileData::removeComments()
 {
     int line = 0;
     const QChar* p = m_unicodeBuf.unicode();
     bool bWithinComment = false;
     int size = m_unicodeBuf.length();
     for(int i = 0; i < size; ++i)
     {
         //      std::cout << "2        " << std::string(&p[i], m_v[line].size) << std::endl;
         bool bWhite = true;
         bool bCommentInLine = false;
 
         if(bWithinComment)
         {
             int commentStart = i;
             bCommentInLine = true;
 
             for(; !isLineOrBufEnd(p, i, size); ++i)
             {
                 if(i + 1 < size && p[i] == '*' && p[i + 1] == '/') // end of the comment
                 {
                     i += 2;
 
                     // More comments in the line?
                     checkLineForComments(p, i, size, bWhite, bCommentInLine, bWithinComment);
                     if(!bWhite)
                     {
                         int size = i - commentStart;
                         m_unicodeBuf.replace(commentStart, size, QString(" ").repeated(size));
                     }
                     break;
                 }
             }
         }
         else
         {
             checkLineForComments(p, i, size, bWhite, bCommentInLine, bWithinComment);
         }
 
         // end of line
         Q_ASSERT(isLineOrBufEnd(p, i, size));
         m_v[line].bContainsPureComment = bCommentInLine && bWhite;
         /*      std::cout << line << " : " <<
        ( bCommentInLine ?  "c" : " " ) <<
        ( bWhite ? "w " : "  ") <<
        std::string(pLD[line].pLine, pLD[line].size) << std::endl;*/
 
         ++line;
     }
 }
 
 // First step
 void calcDiff3LineListUsingAB(
     const DiffList* pDiffListAB,
     Diff3LineList& d3ll)
 {
     // First make d3ll for AB (from pDiffListAB)
 
     DiffList::const_iterator i = pDiffListAB->begin();
     int lineA = 0;
     int lineB = 0;
     Diff d(0, 0, 0);
 
     for(;;)
     {
         if(d.nofEquals == 0 && d.diff1 == 0 && d.diff2 == 0)
         {
             if(i != pDiffListAB->end())
             {
                 d = *i;
                 ++i;
             }
             else
                 break;
         }
 
         Diff3Line d3l;
         if(d.nofEquals > 0)
         {
             d3l.bAEqB = true;
             d3l.lineA = lineA;
             d3l.lineB = lineB;
             --d.nofEquals;
             ++lineA;
             ++lineB;
         }
         else if(d.diff1 > 0 && d.diff2 > 0)
         {
             d3l.lineA = lineA;
             d3l.lineB = lineB;
             --d.diff1;
             --d.diff2;
             ++lineA;
             ++lineB;
         }
         else if(d.diff1 > 0)
         {
             d3l.lineA = lineA;
             --d.diff1;
             ++lineA;
         }
         else if(d.diff2 > 0)
         {
             d3l.lineB = lineB;
             --d.diff2;
             ++lineB;
         }
         
         Q_ASSERT(d.nofEquals >= 0);
 
         d3ll.push_back(d3l);
     }
 }
 
 // Second step
 void calcDiff3LineListUsingAC(
     const DiffList* pDiffListAC,
     Diff3LineList& d3ll)
 {
     ////////////////
     // Now insert data from C using pDiffListAC
 
     DiffList::const_iterator i = pDiffListAC->begin();
     Diff3LineList::iterator i3 = d3ll.begin();
     int lineA = 0;
     int lineC = 0;
     Diff d(0, 0, 0);
 
     for(;;)
     {
         if(d.nofEquals == 0 && d.diff1 == 0 && d.diff2 == 0)
         {
             if(i != pDiffListAC->end())
             {
                 d = *i;
                 ++i;
             }
             else
                 break;
         }
 
         Diff3Line d3l;
         if(d.nofEquals > 0)
         {
             // Find the corresponding lineA
             while((*i3).lineA != lineA)
                 ++i3;
 
             (*i3).lineC = lineC;
             (*i3).bAEqC = true;
             (*i3).bBEqC = (*i3).bAEqB;
 
             --d.nofEquals;
             ++lineA;
             ++lineC;
             ++i3;
         }
         else if(d.diff1 > 0 && d.diff2 > 0)
         {
             d3l.lineC = lineC;
             d3ll.insert(i3, d3l);
             --d.diff1;
             --d.diff2;
             ++lineA;
             ++lineC;
         }
         else if(d.diff1 > 0)
         {
             --d.diff1;
             ++lineA;
         }
         else if(d.diff2 > 0)
         {
             d3l.lineC = lineC;
             d3ll.insert(i3, d3l);
             --d.diff2;
             ++lineC;
         }
     }
 }
 
 // Third step
 void calcDiff3LineListUsingBC(
     const DiffList* pDiffListBC,
     Diff3LineList& d3ll)
 {
     ////////////////
     // Now improve the position of data from C using pDiffListBC
     // If a line from C equals a line from A then it is in the
     // same Diff3Line already.
     // If a line from C equals a line from B but not A, this
     // information will be used here.
 
     DiffList::const_iterator i = pDiffListBC->begin();
     Diff3LineList::iterator i3b = d3ll.begin();
     Diff3LineList::iterator i3c = d3ll.begin();
     int lineB = 0;
     int lineC = 0;
     Diff d(0, 0, 0);
 
     for(;;)
     {
         if(d.nofEquals == 0 && d.diff1 == 0 && d.diff2 == 0)
         {
             if(i != pDiffListBC->end())
             {
                 d = *i;
                 ++i;
             }
             else
                 break;
         }
 
         Diff3Line d3l;
         if(d.nofEquals > 0)
         {
             // Find the corresponding lineB and lineC
             while(i3b != d3ll.end() && (*i3b).lineB != lineB)
                 ++i3b;
 
             while(i3c != d3ll.end() && (*i3c).lineC != lineC)
                 ++i3c;
 
             Q_ASSERT(i3b != d3ll.end());
             Q_ASSERT(i3c != d3ll.end());
 
             if(i3b == i3c)
             {
                 Q_ASSERT((*i3b).lineC == lineC);
                 (*i3b).bBEqC = true;
             }
             else
             {
                 // Is it possible to move this line up?
                 // Test if no other B's are used between i3c and i3b
 
                 // First test which is before: i3c or i3b ?
                 Diff3LineList::iterator i3c1 = i3c;
                 Diff3LineList::iterator i3b1 = i3b;
                 while(i3c1 != i3b && i3b1 != i3c)
                 {
                     Q_ASSERT(i3b1 != d3ll.end() || i3c1 != d3ll.end());
                     if(i3c1 != d3ll.end()) ++i3c1;
                     if(i3b1 != d3ll.end()) ++i3b1;
                 }
 
                 if(i3c1 == i3b && !(*i3b).bAEqB) // i3c before i3b
                 {
                     Diff3LineList::iterator i3 = i3c;
                     int nofDisturbingLines = 0;
                     while(i3 != i3b && i3 != d3ll.end())
                     {
                         if((*i3).lineB != -1)
                             ++nofDisturbingLines;
                         ++i3;
                     }
 
                     if(nofDisturbingLines > 0) //&& nofDisturbingLines < d.nofEquals*d.nofEquals+4 )
                     {
                         Diff3LineList::iterator i3_last_equal_A = d3ll.end();
 
                         i3 = i3c;
                         while(i3 != i3b)
                         {
                             if(i3->bAEqB)
                             {
                                 i3_last_equal_A = i3;
                             }
                             ++i3;
                         }
 
                         /* If i3_last_equal_A isn't still set to d3ll.end(), then
                    * we've found a line in A that is equal to one in B
                    * somewhere between i3c and i3b
                    */
                         bool before_or_on_equal_line_in_A = (i3_last_equal_A != d3ll.end());
 
                         // Move the disturbing lines up, out of sight.
                         i3 = i3c;
                         while(i3 != i3b)
                         {
                             if((*i3).lineB != -1 ||
                                (before_or_on_equal_line_in_A && i3->lineA != -1))
                             {
                                 Diff3Line d3l;
                                 d3l.lineB = (*i3).lineB;
                                 (*i3).lineB = -1;
 
                                 // Move A along if it matched B
                                 if(before_or_on_equal_line_in_A)
                                 {
                                     d3l.lineA = i3->lineA;
                                     d3l.bAEqB = i3->bAEqB;
                                     i3->lineA = -1;
                                     i3->bAEqC = false;
                                 }
 
                                 (*i3).bAEqB = false;
                                 (*i3).bBEqC = false;
                                 d3ll.insert(i3c, d3l);
                             }
 
                             if(i3 == i3_last_equal_A)
                             {
                                 before_or_on_equal_line_in_A = false;
                             }
 
                             ++i3;
                         }
                         nofDisturbingLines = 0;
                     }
 
                     if(nofDisturbingLines == 0)
                     {
                         // Yes, the line from B can be moved.
                         (*i3b).lineB = -1; // This might leave an empty line: removed later.
                         (*i3b).bAEqB = false;
                         (*i3b).bBEqC = false;
                         (*i3c).lineB = lineB;
                         (*i3c).bBEqC = true;
                         (*i3c).bAEqB = (*i3c).bAEqC;
                     }
                 }
                 else if(i3b1 == i3c && !(*i3c).bAEqC)
                 {
                     Diff3LineList::iterator i3 = i3b;
                     int nofDisturbingLines = 0;
                     while(i3 != i3c && i3 != d3ll.end())
                     {
                         if((*i3).lineC != -1)
                             ++nofDisturbingLines;
                         ++i3;
                     }
 
                     if(nofDisturbingLines > 0) //&& nofDisturbingLines < d.nofEquals*d.nofEquals+4 )
                     {
                         Diff3LineList::iterator i3_last_equal_A = d3ll.end();
 
                         i3 = i3b;
                         while(i3 != i3c)
                         {
                             if(i3->bAEqC)
                             {
                                 i3_last_equal_A = i3;
                             }
                             ++i3;
                         }
 
                         /* If i3_last_equal_A isn't still set to d3ll.end(), then
                    * we've found a line in A that is equal to one in C
                    * somewhere between i3b and i3c
                    */
                         bool before_or_on_equal_line_in_A = (i3_last_equal_A != d3ll.end());
 
                         // Move the disturbing lines up.
                         i3 = i3b;
                         while(i3 != i3c)
                         {
                             if((*i3).lineC != -1 ||
                                (before_or_on_equal_line_in_A && i3->lineA != -1))
                             {
                                 Diff3Line d3l;
                                 d3l.lineC = (*i3).lineC;
                                 (*i3).lineC = -1;
 
                                 // Move A along if it matched C
                                 if(before_or_on_equal_line_in_A)
                                 {
                                     d3l.lineA = i3->lineA;
                                     d3l.bAEqC = i3->bAEqC;
                                     i3->lineA = -1;
                                     i3->bAEqB = false;
                                 }
 
                                 (*i3).bAEqC = false;
                                 (*i3).bBEqC = false;
                                 d3ll.insert(i3b, d3l);
                             }
 
                             if(i3 == i3_last_equal_A)
                             {
                                 before_or_on_equal_line_in_A = false;
                             }
 
                             ++i3;
                         }
                         nofDisturbingLines = 0;
                     }
 
                     if(nofDisturbingLines == 0)
                     {
                         // Yes, the line from C can be moved.
                         (*i3c).lineC = -1; // This might leave an empty line: removed later.
                         (*i3c).bAEqC = false;
                         (*i3c).bBEqC = false;
                         (*i3b).lineC = lineC;
                         (*i3b).bBEqC = true;
                         (*i3b).bAEqC = (*i3b).bAEqB;
                     }
                 }
             }
 
             --d.nofEquals;
             ++lineB;
             ++lineC;
             ++i3b;
             ++i3c;
         }
         else if(d.diff1 > 0)
         {
             Diff3LineList::iterator i3 = i3b;
             while((*i3).lineB != lineB)
                 ++i3;
             if(i3 != i3b && (*i3).bAEqB == false)
             {
                 // Take B from this line and move it up as far as possible
                 d3l.lineB = lineB;
                 d3ll.insert(i3b, d3l);
                 (*i3).lineB = -1;
             }
             else
             {
                 i3b = i3;
             }
             --d.diff1;
             ++lineB;
             ++i3b;
 
             if(d.diff2 > 0)
             {
                 --d.diff2;
                 ++lineC;
             }
         }
         else if(d.diff2 > 0)
         {
             --d.diff2;
             ++lineC;
         }
     }
     /*
    Diff3LineList::iterator it = d3ll.begin();
    int li=0;
    for( ; it!=d3ll.end(); ++it, ++li )
    {
       printf( "%4d %4d %4d %4d  A%c=B A%c=C B%c=C\n",
          li, (*it).lineA, (*it).lineB, (*it).lineC,
          (*it).bAEqB ? '=' : '!', (*it).bAEqC ? '=' : '!', (*it).bBEqC ? '=' : '!' );
    }
    printf("\n");*/
 }
 
 #ifdef Q_OS_WIN
 using ::equal;
 #endif
 
 // Test if the move would pass a barrier. Return true if not.
 static bool isValidMove(ManualDiffHelpList* pManualDiffHelpList, int line1, int line2, int winIdx1, int winIdx2)
 {
     if(line1 >= 0 && line2 >= 0)
     {
         ManualDiffHelpList::const_iterator i;
         for(i = pManualDiffHelpList->begin(); i != pManualDiffHelpList->end(); ++i)
         {
             const ManualDiffHelpEntry& mdhe = *i;
 
             // Barrier
             int l1 = winIdx1 == 1 ? mdhe.lineA1 : winIdx1 == 2 ? mdhe.lineB1 : mdhe.lineC1;
             int l2 = winIdx2 == 1 ? mdhe.lineA1 : winIdx2 == 2 ? mdhe.lineB1 : mdhe.lineC1;
 
             if(l1 >= 0 && l2 >= 0)
             {
                 if((line1 >= l1 && line2 < l2) || (line1 < l1 && line2 >= l2))
                     return false;
                 l1 = winIdx1 == 1 ? mdhe.lineA2 : winIdx1 == 2 ? mdhe.lineB2 : mdhe.lineC2;
                 l2 = winIdx2 == 1 ? mdhe.lineA2 : winIdx2 == 2 ? mdhe.lineB2 : mdhe.lineC2;
                 ++l1;
                 ++l2;
                 if((line1 >= l1 && line2 < l2) || (line1 < l1 && line2 >= l2))
                     return false;
             }
         }
     }
     return true; // no barrier passed.
 }
 
 static bool runDiff(const LineData* p1, LineRef size1, const LineData* p2, LineRef size2, DiffList& diffList,
                     Options* pOptions)
 {
     ProgressProxy pp;
     static GnuDiff gnuDiff; // All values are initialized with zeros.
 
     pp.setCurrent(0);
 
     diffList.clear();
     if(p1[0].pLine == nullptr || p2[0].pLine == nullptr || size1 == 0 || size2 == 0)
     {
         Diff d(0, 0, 0);
         if(p1[0].pLine == nullptr && p2[0].pLine == nullptr && size1 == size2)
             d.nofEquals = size1;
         else
         {
             d.diff1 = size1;
             d.diff2 = size2;
         }
 
         diffList.push_back(d);
     }
     else
     {
         GnuDiff::comparison comparisonInput;
         memset(&comparisonInput, 0, sizeof(comparisonInput));
         comparisonInput.parent = nullptr;
         comparisonInput.file[0].buffer = p1[0].pLine;                                                //ptr to buffer
         comparisonInput.file[0].buffered = (p1[size1 - 1].pLine - p1[0].pLine + p1[size1 - 1].size); // size of buffer
         comparisonInput.file[1].buffer = p2[0].pLine;                                                //ptr to buffer
         comparisonInput.file[1].buffered = (p2[size2 - 1].pLine - p2[0].pLine + p2[size2 - 1].size); // size of buffer
 
         gnuDiff.ignore_white_space = GnuDiff::IGNORE_ALL_SPACE; // I think nobody needs anything else ...
         gnuDiff.bIgnoreWhiteSpace = true;
         gnuDiff.bIgnoreNumbers = pOptions->m_bIgnoreNumbers;
         gnuDiff.minimal = pOptions->m_bTryHard;
         gnuDiff.ignore_case = false;
         GnuDiff::change* script = gnuDiff.diff_2_files(&comparisonInput);
 
         LineRef equalLinesAtStart = comparisonInput.file[0].prefix_lines;
         LineRef currentLine1 = 0;
         LineRef currentLine2 = 0;
         GnuDiff::change* p = nullptr;
         for(GnuDiff::change* e = script; e; e = p)
         {
             Diff d(0, 0, 0);
             d.nofEquals = e->line0 - currentLine1;
             Q_ASSERT(d.nofEquals == e->line1 - currentLine2);
             d.diff1 = e->deleted;
             d.diff2 = e->inserted;
             currentLine1 += d.nofEquals + d.diff1;
             currentLine2 += d.nofEquals + d.diff2;
             diffList.push_back(d);
 
             p = e->link;
             free(e);
         }
 
         if(diffList.empty())
         {
             Diff d(0, 0, 0);
             d.nofEquals = min2(size1, size2);
             d.diff1 = size1 - d.nofEquals;
             d.diff2 = size2 - d.nofEquals;
             diffList.push_back(d);
             /*         Diff d(0,0,0);
          d.nofEquals = equalLinesAtStart;
          if ( gnuDiff.files[0].missing_newline != gnuDiff.files[1].missing_newline )
          {
             d.diff1 = gnuDiff.files[0].missing_newline ? 0 : 1;
             d.diff2 = gnuDiff.files[1].missing_newline ? 0 : 1;
             ++d.nofEquals;
          }
          else if ( !gnuDiff.files[0].missing_newline )
          {
             ++d.nofEquals;
          }
          diffList.push_back(d);
 */
         }
         else
         {
             diffList.front().nofEquals += equalLinesAtStart;
             currentLine1 += equalLinesAtStart;
             currentLine2 += equalLinesAtStart;
 
             LineRef nofEquals = min2(size1 - currentLine1, size2 - currentLine2);
             if(nofEquals == 0)
             {
                 diffList.back().diff1 += size1 - currentLine1;
                 diffList.back().diff2 += size2 - currentLine2;
             }
             else
             {
                 Diff d(nofEquals, size1 - currentLine1 - nofEquals, size2 - currentLine2 - nofEquals);
                 diffList.push_back(d);
             }
 
             /*
          if ( gnuDiff.files[0].missing_newline != gnuDiff.files[1].missing_newline )
          {
             diffList.back().diff1 += gnuDiff.files[0].missing_newline ? 0 : 1;
             diffList.back().diff2 += gnuDiff.files[1].missing_newline ? 0 : 1;
          }
          else if ( !gnuDiff.files[0].missing_newline )
          {
             ++ diffList.back().nofEquals;
          }
          */
         }
     }
 
     // Verify difflist
     {
         LineRef l1 = 0;
         LineRef l2 = 0;
         DiffList::iterator i;
         for(i = diffList.begin(); i != diffList.end(); ++i)
         {
             l1 += i->nofEquals + i->diff1;
             l2 += i->nofEquals + i->diff2;
         }
 
         //if( l1!=p1-p1start || l2!=p2-p2start )
         Q_ASSERT(l1 == size1 && l2 == size2);
     }
 
     pp.setCurrent(1.0);
 
     return true;
 }
 
 bool runDiff(const LineData* p1, LineRef size1, const LineData* p2, LineRef size2, DiffList& diffList,
              int winIdx1, int winIdx2,
              ManualDiffHelpList* pManualDiffHelpList,
              Options* pOptions)
 {
     diffList.clear();
     DiffList diffList2;
 
     int l1begin = 0;
     int l2begin = 0;
     ManualDiffHelpList::const_iterator i;
     for(i = pManualDiffHelpList->begin(); i != pManualDiffHelpList->end(); ++i)
     {
         const ManualDiffHelpEntry& mdhe = *i;
 
         int l1end = winIdx1 == 1 ? mdhe.lineA1 : winIdx1 == 2 ? mdhe.lineB1 : mdhe.lineC1;
         int l2end = winIdx2 == 1 ? mdhe.lineA1 : winIdx2 == 2 ? mdhe.lineB1 : mdhe.lineC1;
 
         if(l1end >= 0 && l2end >= 0)
         {
             runDiff(p1 + l1begin, l1end - l1begin, p2 + l2begin, l2end - l2begin, diffList2, pOptions);
             diffList.splice(diffList.end(), diffList2);
             l1begin = l1end;
             l2begin = l2end;
 
             l1end = winIdx1 == 1 ? mdhe.lineA2 : winIdx1 == 2 ? mdhe.lineB2 : mdhe.lineC2;
             l2end = winIdx2 == 1 ? mdhe.lineA2 : winIdx2 == 2 ? mdhe.lineB2 : mdhe.lineC2;
 
             if(l1end >= 0 && l2end >= 0)
             {
                 ++l1end; // point to line after last selected line
                 ++l2end;
                 runDiff(p1 + l1begin, l1end - l1begin, p2 + l2begin, l2end - l2begin, diffList2, pOptions);
                 diffList.splice(diffList.end(), diffList2);
                 l1begin = l1end;
                 l2begin = l2end;
             }
         }
     }
     runDiff(p1 + l1begin, size1 - l1begin, p2 + l2begin, size2 - l2begin, diffList2, pOptions);
     diffList.splice(diffList.end(), diffList2);
     return true;
 }
 
 void correctManualDiffAlignment(Diff3LineList& d3ll, ManualDiffHelpList* pManualDiffHelpList)
 {
     if(pManualDiffHelpList->empty())
         return;
 
     // If a line appears unaligned in comparison to the manual alignment, correct this.
 
     ManualDiffHelpList::iterator iMDHL;
     for(iMDHL = pManualDiffHelpList->begin(); iMDHL != pManualDiffHelpList->end(); ++iMDHL)
     {
         Diff3LineList::iterator i3 = d3ll.begin();
         int missingWinIdx = 0;
         int alignedSum = (iMDHL->lineA1 < 0 ? 0 : 1) + (iMDHL->lineB1 < 0 ? 0 : 1) + (iMDHL->lineC1 < 0 ? 0 : 1);
         if(alignedSum == 2)
         {
             // If only A & B are aligned then let C rather be aligned with A
             // If only A & C are aligned then let B rather be aligned with A
             // If only B & C are aligned then let A rather be aligned with B
             missingWinIdx = iMDHL->lineA1 < 0 ? 1 : (iMDHL->lineB1 < 0 ? 2 : 3);
         }
         else if(alignedSum <= 1)
         {
             return;
         }
 
         // At the first aligned line, move up the two other lines into new d3ls until the second input is aligned
         // Then move up the third input until all three lines are aligned.
         int wi = 0;
         for(; i3 != d3ll.end(); ++i3)
         {
             for(wi = 1; wi <= 3; ++wi)
             {
                 if(i3->getLineInFile(wi) >= 0 && iMDHL->firstLine(wi) == i3->getLineInFile(wi))
                     break;
             }
             if(wi <= 3)
                 break;
         }
 
         if(wi >= 1 && wi <= 3)
         {
             // Found manual alignment for one source
             Diff3LineList::iterator iDest = i3;
 
             // Move lines up until the next firstLine is found. Omit wi from move and search.
             int wi2 = 0;
             for(; i3 != d3ll.end(); ++i3)
             {
                 for(wi2 = 1; wi2 <= 3; ++wi2)
                 {
                     if(wi != wi2 && i3->getLineInFile(wi2) >= 0 && iMDHL->firstLine(wi2) == i3->getLineInFile(wi2))
                         break;
                 }
                 if(wi2 > 3)
                 { // Not yet found
                     // Move both others up
                     Diff3Line d3l;
                     // Move both up
                     if(wi == 1) // Move B and C up
                     {
                         d3l.bBEqC = i3->bBEqC;
                         d3l.lineB = i3->lineB;
                         d3l.lineC = i3->lineC;
                         i3->lineB = -1;
                         i3->lineC = -1;
                     }
                     if(wi == 2) // Move A and C up
                     {
                         d3l.bAEqC = i3->bAEqC;
                         d3l.lineA = i3->lineA;
                         d3l.lineC = i3->lineC;
                         i3->lineA = -1;
                         i3->lineC = -1;
                     }
                     if(wi == 3) // Move A and B up
                     {
                         d3l.bAEqB = i3->bAEqB;
                         d3l.lineA = i3->lineA;
                         d3l.lineB = i3->lineB;
                         i3->lineA = -1;
                         i3->lineB = -1;
                     }
                     i3->bAEqB = false;
                     i3->bAEqC = false;
                     i3->bBEqC = false;
                     d3ll.insert(iDest, d3l);
                 }
                 else
                 {
                     // align the found line with the line we already have here
                     if(i3 != iDest)
                     {
                         if(wi2 == 1)
                         {
                             iDest->lineA = i3->lineA;
                             i3->lineA = -1;
                             i3->bAEqB = false;
                             i3->bAEqC = false;
                         }
                         else if(wi2 == 2)
                         {
                             iDest->lineB = i3->lineB;
                             i3->lineB = -1;
                             i3->bAEqB = false;
                             i3->bBEqC = false;
                         }
                         else if(wi2 == 3)
                         {
                             iDest->lineC = i3->lineC;
                             i3->lineC = -1;
                             i3->bBEqC = false;
                             i3->bAEqC = false;
                         }
                     }
 
                     if(missingWinIdx != 0)
                     {
                         for(; i3 != d3ll.end(); ++i3)
                         {
                             int wi3 = missingWinIdx;
                             if(i3->getLineInFile(wi3) >= 0)
                             {
                                 // not found, move the line before iDest
                                 Diff3Line d3l;
                                 if(wi3 == 1)
                                 {
                                     if(i3->bAEqB) // Stop moving lines up if one equal is found.
                                         break;
                                     d3l.lineA = i3->lineA;
                                     i3->lineA = -1;
                                     i3->bAEqB = false;
                                     i3->bAEqC = false;
                                 }
                                 if(wi3 == 2)
                                 {
                                     if(i3->bAEqB)
                                         break;
                                     d3l.lineB = i3->lineB;
                                     i3->lineB = -1;
                                     i3->bAEqB = false;
                                     i3->bBEqC = false;
                                 }
                                 if(wi3 == 3)
                                 {
                                     if(i3->bAEqC)
                                         break;
                                     d3l.lineC = i3->lineC;
                                     i3->lineC = -1;
                                     i3->bAEqC = false;
                                     i3->bBEqC = false;
                                 }
                                 d3ll.insert(iDest, d3l);
                             }
                         } // for(), searching for wi3
                     }
                     break;
                 }
             } // for(), searching for wi2
         }     // if, wi found
     }         // for (iMDHL)
 }
 
 // Fourth step
 void calcDiff3LineListTrim(
     Diff3LineList& d3ll, const LineData* pldA, const LineData* pldB, const LineData* pldC, ManualDiffHelpList* pManualDiffHelpList)
 {
     const Diff3Line d3l_empty;
     d3ll.removeAll(d3l_empty);
 
     Diff3LineList::iterator i3 = d3ll.begin();
     Diff3LineList::iterator i3A = d3ll.begin();
     Diff3LineList::iterator i3B = d3ll.begin();
     Diff3LineList::iterator i3C = d3ll.begin();
 
     int line = 0;  // diff3line counters
     int lineA = 0; //
     int lineB = 0;
     int lineC = 0;
 
     ManualDiffHelpList::iterator iMDHL = pManualDiffHelpList->begin();
     // The iterator i3 and the variable line look ahead.
     // The iterators i3A, i3B, i3C and corresponding lineA, lineB and lineC stop at empty lines, if found.
     // If possible, then the texts from the look ahead will be moved back to the empty places.
 
     for(; i3 != d3ll.end(); ++i3, ++line)
     {
         if(iMDHL != pManualDiffHelpList->end())
         {
             if((i3->lineA >= 0 && i3->lineA == iMDHL->lineA1) ||
                (i3->lineB >= 0 && i3->lineB == iMDHL->lineB1) ||
                (i3->lineC >= 0 && i3->lineC == iMDHL->lineC1))
             {
                 i3A = i3;
                 i3B = i3;
                 i3C = i3;
                 lineA = line;
                 lineB = line;
                 lineC = line;
                 ++iMDHL;
             }
         }
 
         if(line > lineA && (*i3).lineA != -1 && (*i3A).lineB != -1 && (*i3A).bBEqC &&
            ::equal(pldA[(*i3).lineA], pldB[(*i3A).lineB], false) &&
            isValidMove(pManualDiffHelpList, (*i3).lineA, (*i3A).lineB, 1, 2) &&
            isValidMove(pManualDiffHelpList, (*i3).lineA, (*i3A).lineC, 1, 3))
         {
             // Empty space for A. A matches B and C in the empty line. Move it up.
             (*i3A).lineA = (*i3).lineA;
             (*i3A).bAEqB = true;
             (*i3A).bAEqC = true;
 
             (*i3).lineA = -1;
             (*i3).bAEqB = false;
             (*i3).bAEqC = false;
             ++i3A;
             ++lineA;
         }
 
         if(line > lineB && (*i3).lineB != -1 && (*i3B).lineA != -1 && (*i3B).bAEqC &&
            ::equal(pldB[(*i3).lineB], pldA[(*i3B).lineA], false) &&
            isValidMove(pManualDiffHelpList, (*i3).lineB, (*i3B).lineA, 2, 1) &&
            isValidMove(pManualDiffHelpList, (*i3).lineB, (*i3B).lineC, 2, 3))
         {
             // Empty space for B. B matches A and C in the empty line. Move it up.
             (*i3B).lineB = (*i3).lineB;
             (*i3B).bAEqB = true;
             (*i3B).bBEqC = true;
             (*i3).lineB = -1;
             (*i3).bAEqB = false;
             (*i3).bBEqC = false;
             ++i3B;
             ++lineB;
         }
 
         if(line > lineC && (*i3).lineC != -1 && (*i3C).lineA != -1 && (*i3C).bAEqB &&
            ::equal(pldC[(*i3).lineC], pldA[(*i3C).lineA], false) &&
            isValidMove(pManualDiffHelpList, (*i3).lineC, (*i3C).lineA, 3, 1) &&
            isValidMove(pManualDiffHelpList, (*i3).lineC, (*i3C).lineB, 3, 2))
         {
             // Empty space for C. C matches A and B in the empty line. Move it up.
             (*i3C).lineC = (*i3).lineC;
             (*i3C).bAEqC = true;
             (*i3C).bBEqC = true;
             (*i3).lineC = -1;
             (*i3).bAEqC = false;
             (*i3).bBEqC = false;
             ++i3C;
             ++lineC;
         }
 
         if(line > lineA && (*i3).lineA != -1 && !(*i3).bAEqB && !(*i3).bAEqC &&
            isValidMove(pManualDiffHelpList, (*i3).lineA, (*i3A).lineB, 1, 2) &&
            isValidMove(pManualDiffHelpList, (*i3).lineA, (*i3A).lineC, 1, 3)) {
             // Empty space for A. A doesn't match B or C. Move it up.
             (*i3A).lineA = (*i3).lineA;
             (*i3).lineA = -1;
 
             if(i3A->lineB != -1 && ::equal(pldA[i3A->lineA], pldB[i3A->lineB], false))
             {
                 i3A->bAEqB = true;
             }
             if((i3A->bAEqB && i3A->bBEqC) ||
                (i3A->lineC != -1 && ::equal(pldA[i3A->lineA], pldC[i3A->lineC], false)))
             {
                 i3A->bAEqC = true;
             }
 
             ++i3A;
             ++lineA;
         }
 
         if(line > lineB && (*i3).lineB != -1 && !(*i3).bAEqB && !(*i3).bBEqC &&
            isValidMove(pManualDiffHelpList, (*i3).lineB, (*i3B).lineA, 2, 1) &&
            isValidMove(pManualDiffHelpList, (*i3).lineB, (*i3B).lineC, 2, 3))
         {
             // Empty space for B. B matches neither A nor C. Move B up.
             (*i3B).lineB = (*i3).lineB;
             (*i3).lineB = -1;
 
             if(i3B->lineA != -1 && ::equal(pldA[i3B->lineA], pldB[i3B->lineB], false))
             {
                 i3B->bAEqB = true;
             }
             if((i3B->bAEqB && i3B->bAEqC) ||
                (i3B->lineC != -1 && ::equal(pldB[i3B->lineB], pldC[i3B->lineC], false)))
             {
                 i3B->bBEqC = true;
             }
 
             ++i3B;
             ++lineB;
         }
 
         if(line > lineC && (*i3).lineC != -1 && !(*i3).bAEqC && !(*i3).bBEqC &&
            isValidMove(pManualDiffHelpList, (*i3).lineC, (*i3C).lineA, 3, 1) &&
            isValidMove(pManualDiffHelpList, (*i3).lineC, (*i3C).lineB, 3, 2))
         {
             // Empty space for C. C matches neither A nor B. Move C up.
             (*i3C).lineC = (*i3).lineC;
             (*i3).lineC = -1;
 
             if(i3C->lineA != -1 && ::equal(pldA[i3C->lineA], pldC[i3C->lineC], false))
             {
                 i3C->bAEqC = true;
             }
             if((i3C->bAEqC && i3C->bAEqB) ||
                (i3C->lineB != -1 && ::equal(pldB[i3C->lineB], pldC[i3C->lineC], false)))
             {
                 i3C->bBEqC = true;
             }
 
             ++i3C;
             ++lineC;
         }
 
         if(line > lineA && line > lineB && (*i3).lineA != -1 && (*i3).bAEqB && !(*i3).bAEqC)
         {
             // Empty space for A and B. A matches B, but not C. Move A & B up.
             Diff3LineList::iterator i = lineA > lineB ? i3A : i3B;
             int l = lineA > lineB ? lineA : lineB;
 
             if(isValidMove(pManualDiffHelpList, i->lineC, (*i3).lineA, 3, 1) &&
                isValidMove(pManualDiffHelpList, i->lineC, (*i3).lineB, 3, 2))
             {
                 (*i).lineA = (*i3).lineA;
                 (*i).lineB = (*i3).lineB;
                 (*i).bAEqB = true;
 
                 if(i->lineC != -1 && ::equal(pldA[i->lineA], pldC[i->lineC], false))
                 {
                     (*i).bAEqC = true;
                     (*i).bBEqC = true;
                 }
 
                 (*i3).lineA = -1;
                 (*i3).lineB = -1;
                 (*i3).bAEqB = false;
                 i3A = i;
                 i3B = i;
                 ++i3A;
                 ++i3B;
                 lineA = l + 1;
                 lineB = l + 1;
             }
         }
         else if(line > lineA && line > lineC && (*i3).lineA != -1 && (*i3).bAEqC && !(*i3).bAEqB)
         {
             // Empty space for A and C. A matches C, but not B. Move A & C up.
             Diff3LineList::iterator i = lineA > lineC ? i3A : i3C;
             int l = lineA > lineC ? lineA : lineC;
 
             if(isValidMove(pManualDiffHelpList, i->lineB, (*i3).lineA, 2, 1) &&
                isValidMove(pManualDiffHelpList, i->lineB, (*i3).lineC, 2, 3))
             {
                 (*i).lineA = (*i3).lineA;
                 (*i).lineC = (*i3).lineC;
                 (*i).bAEqC = true;
 
                 if(i->lineB != -1 && ::equal(pldA[i->lineA], pldB[i->lineB], false))
                 {
                     (*i).bAEqB = true;
                     (*i).bBEqC = true;
                 }
 
                 (*i3).lineA = -1;
                 (*i3).lineC = -1;
                 (*i3).bAEqC = false;
                 i3A = i;
                 i3C = i;
                 ++i3A;
                 ++i3C;
                 lineA = l + 1;
                 lineC = l + 1;
             }
         }
         else if(line > lineB && line > lineC && (*i3).lineB != -1 && (*i3).bBEqC && !(*i3).bAEqC)
         {
             // Empty space for B and C. B matches C, but not A. Move B & C up.
             Diff3LineList::iterator i = lineB > lineC ? i3B : i3C;
             int l = lineB > lineC ? lineB : lineC;
 
             if(isValidMove(pManualDiffHelpList, i->lineA, (*i3).lineB, 1, 2) &&
                isValidMove(pManualDiffHelpList, i->lineA, (*i3).lineC, 1, 3))
             {
                 (*i).lineB = (*i3).lineB;
                 (*i).lineC = (*i3).lineC;
                 (*i).bBEqC = true;
 
                 if(i->lineA != -1 && ::equal(pldA[i->lineA], pldB[i->lineB], false))
                 {
                     (*i).bAEqB = true;
                     (*i).bAEqC = true;
                 }
 
                 (*i3).lineB = -1;
                 (*i3).lineC = -1;
                 (*i3).bBEqC = false;
                 i3B = i;
                 i3C = i;
                 ++i3B;
                 ++i3C;
                 lineB = l + 1;
                 lineC = l + 1;
             }
         }
 
         if((*i3).lineA != -1)
         {
             lineA = line + 1;
             i3A = i3;
             ++i3A;
         }
         if((*i3).lineB != -1)
         {
             lineB = line + 1;
             i3B = i3;
             ++i3B;
         }
         if((*i3).lineC != -1)
         {
             lineC = line + 1;
             i3C = i3;
             ++i3C;
         }
     }
 
     d3ll.removeAll(d3l_empty);
 
     /*
 
    Diff3LineList::iterator it = d3ll.begin();
    int li=0;
    for( ; it!=d3ll.end(); ++it, ++li )
    {
       printf( "%4d %4d %4d %4d  A%c=B A%c=C B%c=C\n",
          li, (*it).lineA, (*it).lineB, (*it).lineC,
          (*it).bAEqB ? '=' : '!', (*it).bAEqC ? '=' : '!', (*it).bBEqC ? '=' : '!' );
 
    }
 */
 }
 
 void DiffBufferInfo::init(Diff3LineList* pD3ll, const Diff3LineVector* pD3lv,
                           const LineData* pldA, LineRef sizeA, const LineData* pldB, LineRef sizeB, const LineData* pldC, LineRef sizeC)
 {
     m_pDiff3LineList = pD3ll;
     m_pDiff3LineVector = pD3lv;
     m_pLineDataA = pldA;
     m_pLineDataB = pldB;
     m_pLineDataC = pldC;
     m_sizeA = sizeA;
     m_sizeB = sizeB;
     m_sizeC = sizeC;
     Diff3LineList::iterator i3 = pD3ll->begin();
     for(; i3 != pD3ll->end(); ++i3)
     {
         i3->m_pDiffBufferInfo = this;
     }
 }
 
 void calcWhiteDiff3Lines(
     Diff3LineList& d3ll, const LineData* pldA, const LineData* pldB, const LineData* pldC)
 {
     Diff3LineList::iterator i3 = d3ll.begin();
 
     for(; i3 != d3ll.end(); ++i3)
     {
         i3->bWhiteLineA = ((*i3).lineA == -1 || pldA == nullptr || pldA[(*i3).lineA].whiteLine() || pldA[(*i3).lineA].bContainsPureComment);
         i3->bWhiteLineB = ((*i3).lineB == -1 || pldB == nullptr || pldB[(*i3).lineB].whiteLine() || pldB[(*i3).lineB].bContainsPureComment);
         i3->bWhiteLineC = ((*i3).lineC == -1 || pldC == nullptr || pldC[(*i3).lineC].whiteLine() || pldC[(*i3).lineC].bContainsPureComment);
     }
 }
 
 inline bool equal(QChar c1, QChar c2, bool /*bStrict*/)
 {
     // If bStrict then white space doesn't match
 
     //if ( bStrict &&  ( c1==' ' || c1=='\t' ) )
     //   return false;
 
     return c1 == c2;
 }
 
 // My own diff-invention:
 template <class T>
 void calcDiff(const T* p1, LineRef size1, const T* p2, LineRef size2, DiffList& diffList, int match, int maxSearchRange)
 {
     diffList.clear();
 
     const T* p1start = p1;
     const T* p2start = p2;
     const T* p1end = p1 + size1;
     const T* p2end = p2 + size2;
     for(;;)
     {
         int nofEquals = 0;
         while(p1 != p1end && p2 != p2end && equal(*p1, *p2, false))
         {
             ++p1;
             ++p2;
             ++nofEquals;
         }
 
         bool bBestValid = false;
         int bestI1 = 0;
         int bestI2 = 0;
         int i1 = 0;
         int i2 = 0;
         for(i1 = 0;; ++i1)
         {
             if(&p1[i1] == p1end || (bBestValid && i1 >= bestI1 + bestI2))
             {
                 break;
             }
             for(i2 = 0; i2 < maxSearchRange; ++i2)
             {
                 if(&p2[i2] == p2end || (bBestValid && i1 + i2 >= bestI1 + bestI2))
                 {
                     break;
                 }
                 else if(equal(p2[i2], p1[i1], true) &&
                         (match == 1 || abs(i1 - i2) < 3 || (&p2[i2 + 1] == p2end && &p1[i1 + 1] == p1end) ||
                          (&p2[i2 + 1] != p2end && &p1[i1 + 1] != p1end && equal(p2[i2 + 1], p1[i1 + 1], false))))
                 {
                     if(i1 + i2 < bestI1 + bestI2 || bBestValid == false)
                     {
                         bestI1 = i1;
                         bestI2 = i2;
                         bBestValid = true;
                         break;
                     }
                 }
             }
         }
 
         // The match was found using the strict search. Go back if there are non-strict
         // matches.
         while(bestI1 >= 1 && bestI2 >= 1 && equal(p1[bestI1 - 1], p2[bestI2 - 1], false))
         {
             --bestI1;
             --bestI2;
         }
 
         bool bEndReached = false;
         if(bBestValid)
         {
             // continue somehow
             Diff d(nofEquals, bestI1, bestI2);
             diffList.push_back(d);
 
             p1 += bestI1;
             p2 += bestI2;
         }
         else
         {
             // Nothing else to match.
             Diff d(nofEquals, p1end - p1, p2end - p2);
             diffList.push_back(d);
 
             bEndReached = true; //break;
         }
 
         // Sometimes the algorithm that chooses the first match unfortunately chooses
         // a match where later actually equal parts don't match anymore.
         // A different match could be achieved, if we start at the end.
         // Do it, if it would be a better match.
         int nofUnmatched = 0;
         const T* pu1 = p1 - 1;
         const T* pu2 = p2 - 1;
         while(pu1 >= p1start && pu2 >= p2start && equal(*pu1, *pu2, false))
         {
             ++nofUnmatched;
             --pu1;
             --pu2;
         }
 
         Diff d = diffList.back();
         if(nofUnmatched > 0)
         {
             // We want to go backwards the nofUnmatched elements and redo
             // the matching
             d = diffList.back();
             Diff origBack = d;
             diffList.pop_back();
 
             while(nofUnmatched > 0)
             {
                 if(d.diff1 > 0 && d.diff2 > 0)
                 {
                     --d.diff1;
                     --d.diff2;
                     --nofUnmatched;
                 }
                 else if(d.nofEquals > 0)
                 {
                     --d.nofEquals;
                     --nofUnmatched;
                 }
 
                 if(d.nofEquals == 0 && (d.diff1 == 0 || d.diff2 == 0) && nofUnmatched > 0)
                 {
                     if(diffList.empty())
                         break;
                     d.nofEquals += diffList.back().nofEquals;
                     d.diff1 += diffList.back().diff1;
                     d.diff2 += diffList.back().diff2;
                     diffList.pop_back();
                     bEndReached = false;
                 }
             }
 
             if(bEndReached)
                 diffList.push_back(origBack);
             else
             {
 
                 p1 = pu1 + 1 + nofUnmatched;
                 p2 = pu2 + 1 + nofUnmatched;
                 diffList.push_back(d);
             }
         }
         if(bEndReached)
             break;
     }
 
     // Verify difflist
     {
         LineRef l1 = 0;
         LineRef l2 = 0;
         DiffList::iterator i;
         for(i = diffList.begin(); i != diffList.end(); ++i)
         {
             l1 += i->nofEquals + i->diff1;
             l2 += i->nofEquals + i->diff2;
         }
 
         Q_ASSERT(l1 == size1 && l2 == size2);
     }
 }
 
 bool fineDiff(
     Diff3LineList& diff3LineList,
     int selector,
     const LineData* v1,
     const LineData* v2)
 {
     // Finetuning: Diff each line with deltas
     ProgressProxy pp;
     int maxSearchLength = 500;
     Diff3LineList::iterator i;
     LineRef k1 = 0;
     LineRef k2 = 0;
     bool bTextsTotalEqual = true;
     int listSize = diff3LineList.size();
     pp.setMaxNofSteps(listSize);
     int listIdx = 0;
     for(i = diff3LineList.begin(); i != diff3LineList.end(); ++i)
     {
         Q_ASSERT(selector == 1 || selector == 2 || selector == 3);
 
         if(selector == 1) {
             k1 = i->lineA;
             k2 = i->lineB;
         }
         else if(selector == 2)
         {
             k1 = i->lineB;
             k2 = i->lineC;
         }
         else if(selector == 3)
         {
             k1 = i->lineC;
             k2 = i->lineA;
         }
         
         if((k1 == -1 && k2 != -1) || (k1 != -1 && k2 == -1)) bTextsTotalEqual = false;
         if(k1 != -1 && k2 != -1)
         {
             if(v1[k1].size != v2[k2].size || memcmp(v1[k1].pLine, v2[k2].pLine, v1[k1].size << 1) != 0)
             {
                 bTextsTotalEqual = false;
                 DiffList* pDiffList = new DiffList;
                 calcDiff(v1[k1].pLine, v1[k1].size, v2[k2].pLine, v2[k2].size, *pDiffList, 2, maxSearchLength);
 
                 // Optimize the diff list.
                 DiffList::iterator dli;
                 bool bUsefulFineDiff = false;
                 for(dli = pDiffList->begin(); dli != pDiffList->end(); ++dli)
                 {
                     if(dli->nofEquals >= 4)
                     {
                         bUsefulFineDiff = true;
                         break;
                     }
                 }
 
                 for(dli = pDiffList->begin(); dli != pDiffList->end(); ++dli)
                 {
                     if(dli->nofEquals < 4 && (dli->diff1 > 0 || dli->diff2 > 0) && !(bUsefulFineDiff && dli == pDiffList->begin()))
                     {
                         dli->diff1 += dli->nofEquals;
                         dli->diff2 += dli->nofEquals;
                         dli->nofEquals = 0;
                     }
                 }
 
                 Q_ASSERT(selector == 1 || selector == 2 || selector == 3);
                 if(selector == 1) {
                     delete(*i).pFineAB;
                     (*i).pFineAB = pDiffList;
                 }
                 else if(selector == 2)
                 {
                     delete(*i).pFineBC;
                     (*i).pFineBC = pDiffList;
                 }
                 else if(selector == 3)
                 {
                     delete(*i).pFineCA;
                     (*i).pFineCA = pDiffList;
                 }
             }
 
             if((v1[k1].bContainsPureComment || v1[k1].whiteLine()) && (v2[k2].bContainsPureComment || v2[k2].whiteLine()))
             {
                 Q_ASSERT(selector == 1 || selector == 2 || selector == 3);
 
                 if(selector == 1) {
                     i->bAEqB = true;
                 }
                 else if(selector == 2)
                 {
                     i->bBEqC = true;
                 }
                 else if(selector == 3)
                 {
                     i->bAEqC = true;
                 }
             }
         }
         ++listIdx;
         pp.step();
     }
     return bTextsTotalEqual;
 }
 
 // Convert the list to a vector of pointers
 void calcDiff3LineVector(Diff3LineList& d3ll, Diff3LineVector& d3lv)
 {
     d3lv.resize(d3ll.size());
     Diff3LineList::iterator i;
     int j = 0;
     for(i = d3ll.begin(); i != d3ll.end(); ++i, ++j)
     {
         d3lv[j] = &(*i);
     }
     Q_ASSERT(j == (int)d3lv.size());
 }
diff --git a/src/diff.h b/src/diff.h
index d722a39..c5345a5 100644
--- a/src/diff.h
+++ b/src/diff.h
@@ -1,431 +1,431 @@
 /***************************************************************************
                           diff.h  -  description
                              -------------------
     begin                : Mon Mar 18 2002
     copyright            : (C) 2002-2007 by Joachim Eibl
     email                : joachim.eibl at gmx.de
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #ifndef DIFF_H
 #define DIFF_H
 
 #include <QPainter>
 #include <QLinkedList>
 #include <QVector>
 #include "common.h"
 #include "fileaccess.h"
 #include "options.h"
 #include "gnudiff_diff.h"
 
 // Each range with matching elements is followed by a range with differences on either side.
 // Then again range of matching elements should follow.
 struct Diff
 {
    LineRef nofEquals;
 
    qint64 diff1;
    qint64 diff2;
 
    Diff(LineRef eq, qint64 d1, qint64 d2){nofEquals=eq; diff1=d1; diff2=d2; }
 };
 
 typedef std::list<Diff> DiffList;
 
 struct LineData
 {
    const QChar* pLine;
    const QChar* pFirstNonWhiteChar;
    int size;
 
-   LineData(){ pLine=nullptr; pFirstNonWhiteChar=nullptr; size=0; /*occurances=0;*/ 
+   LineData(){ pLine=nullptr; pFirstNonWhiteChar=nullptr; size=0; /*occurences=0;*/ 
                bContainsPureComment=false; }
    int width(int tabSize) const;  // Calcs width considering tabs.
-   //int occurances;
+   //int occurences;
    bool whiteLine() const { return pFirstNonWhiteChar-pLine == size; }
    bool bContainsPureComment;
 };
 
 class Diff3LineList;
 class Diff3LineVector;
 
 struct DiffBufferInfo
 {
    const LineData* m_pLineDataA;
    const LineData* m_pLineDataB;
    const LineData* m_pLineDataC;
    LineRef m_sizeA;
    LineRef m_sizeB;
    LineRef m_sizeC;
    const Diff3LineList* m_pDiff3LineList;
    const Diff3LineVector* m_pDiff3LineVector;
    void init( Diff3LineList* d3ll, const Diff3LineVector* d3lv,
       const LineData* pldA, LineRef sizeA, const LineData* pldB, LineRef sizeB, const LineData* pldC, LineRef sizeC );
 };
 
 struct Diff3Line
 {
    LineRef lineA;
    LineRef lineB;
    LineRef lineC;
 
    bool bAEqC : 1;             // These are true if equal or only white-space changes exist.
    bool bBEqC : 1;
    bool bAEqB : 1;
 
    bool bWhiteLineA : 1;
    bool bWhiteLineB : 1;
    bool bWhiteLineC : 1;
 
    DiffList* pFineAB;          // These are 0 only if completely equal or if either source doesn't exist.
    DiffList* pFineBC;
    DiffList* pFineCA;
 
    int linesNeededForDisplay; // Due to wordwrap
    int sumLinesNeededForDisplay; // For fast conversion to m_diff3WrapLineVector
 
    DiffBufferInfo* m_pDiffBufferInfo; // For convenience
 
    Diff3Line()
    {
       lineA=-1; lineB=-1; lineC=-1;
       bAEqC=false; bAEqB=false; bBEqC=false;
       pFineAB=nullptr; pFineBC=nullptr; pFineCA=nullptr;
       linesNeededForDisplay=1;
       sumLinesNeededForDisplay=0;
       bWhiteLineA=false; bWhiteLineB=false; bWhiteLineC=false;
       m_pDiffBufferInfo=nullptr;
    }
 
    ~Diff3Line()
    {
       if (pFineAB!=nullptr) delete pFineAB;
       if (pFineBC!=nullptr) delete pFineBC;
       if (pFineCA!=nullptr) delete pFineCA;
       pFineAB=nullptr; pFineBC=nullptr; pFineCA=nullptr;
    }
 
    bool operator==( const Diff3Line& d3l ) const
    {
       return lineA == d3l.lineA  &&  lineB == d3l.lineB  &&  lineC == d3l.lineC  
          && bAEqB == d3l.bAEqB  && bAEqC == d3l.bAEqC  && bBEqC == d3l.bBEqC;
    }
 
    const LineData* getLineData( int src ) const
    {
       Q_ASSERT( m_pDiffBufferInfo!=nullptr );
       if ( src == 1 && lineA >= 0 ) return &m_pDiffBufferInfo->m_pLineDataA[lineA];
       if ( src == 2 && lineB >= 0 ) return &m_pDiffBufferInfo->m_pLineDataB[lineB];
       if ( src == 3 && lineC >= 0 ) return &m_pDiffBufferInfo->m_pLineDataC[lineC];
       return nullptr;
    }
    QString getString( int src ) const
    {
       const LineData* pld = getLineData(src);
       if ( pld )
          return QString( pld->pLine, pld->size);
       else
          return QString();
    }
    LineRef getLineInFile( int src ) const
    {
       if ( src == 1 ) return lineA;
       if ( src == 2 ) return lineB;
       if ( src == 3 ) return lineC;
       return -1;
    }
 };
 
 
 class Diff3LineList : public QLinkedList<Diff3Line>
 {
 };
 class Diff3LineVector : public QVector<Diff3Line*>
 {
 };
 
 class Diff3WrapLine
 {
 public:
    Diff3Line* pD3L;
    int diff3LineIndex;
    int wrapLineOffset;
    int wrapLineLength;
 };
 
 typedef QVector<Diff3WrapLine> Diff3WrapLineVector;
 
 
 class TotalDiffStatus
 {
 public:
    TotalDiffStatus(){ reset(); }
    void reset() {bBinaryAEqC=false; bBinaryBEqC=false; bBinaryAEqB=false;
                  bTextAEqC=false;   bTextBEqC=false;   bTextAEqB=false;
                  nofUnsolvedConflicts=0; nofSolvedConflicts=0;
                  nofWhitespaceConflicts=0;
                 }
    bool bBinaryAEqC : 1;
    bool bBinaryBEqC : 1;
    bool bBinaryAEqB : 1;
 
    bool bTextAEqC : 1;
    bool bTextBEqC : 1;
    bool bTextAEqB : 1;
 
    int nofUnsolvedConflicts;
    int nofSolvedConflicts;
    int nofWhitespaceConflicts;
 };
 
 // Three corresponding ranges. (Minimum size of a valid range is one line.)
 class ManualDiffHelpEntry
 {
 public:
    ManualDiffHelpEntry() { lineA1=-1; lineA2=-1; 
                            lineB1=-1; lineB2=-1; 
                            lineC1=-1; lineC2=-1; }
    LineRef lineA1;
    LineRef lineA2;
    LineRef lineB1;
    LineRef lineB2;
    LineRef lineC1;
    LineRef lineC2;
    LineRef& firstLine( int winIdx )
    {
       return winIdx==1 ? lineA1 : (winIdx==2 ? lineB1 : lineC1 );
    }
    LineRef& lastLine( int winIdx )
    {
       return winIdx==1 ? lineA2 : (winIdx==2 ? lineB2 : lineC2 );
    }
    bool isLineInRange( LineRef line, int winIdx )
    {
       return line>=0 && line>=firstLine(winIdx) && line<=lastLine(winIdx);
    }
    bool operator==(const ManualDiffHelpEntry& r) const
    {
       return lineA1 == r.lineA1   &&   lineB1 == r.lineB1   &&   lineC1 == r.lineC1  &&
              lineA2 == r.lineA2   &&   lineB2 == r.lineB2   &&   lineC2 == r.lineC2;
    }
 };
 
 // A list of corresponding ranges
 typedef std::list<ManualDiffHelpEntry> ManualDiffHelpList;
 
 void calcDiff3LineListUsingAB(
    const DiffList* pDiffListAB,
    Diff3LineList& d3ll
    );
 
 void calcDiff3LineListUsingAC(
    const DiffList* pDiffListBC,
    Diff3LineList& d3ll
    );
 
 void calcDiff3LineListUsingBC(
    const DiffList* pDiffListBC,
    Diff3LineList& d3ll
    );
 
 void correctManualDiffAlignment( Diff3LineList& d3ll, ManualDiffHelpList* pManualDiffHelpList );
 
 class SourceData
 {
 public:
    SourceData();
    ~SourceData();
 
    void setOptions( Options* pOptions );
 
    LineRef getSizeLines() const;
    qint64 getSizeBytes() const;
    const char* getBuf() const;
    const QString& getText() const;
    const LineData* getLineDataForDisplay() const;
    const LineData* getLineDataForDiff() const;
 
    void setFilename(const QString& filename);
    void setFileAccess( const FileAccess& fa );
    void setEncoding(QTextCodec* pEncoding);
    //FileAccess& getFileAccess();
    QString getFilename();
    void setAliasName(const QString& a);
    QString getAliasName();
    bool isEmpty();  // File was set
    bool hasData();  // Data was readable
    bool isText();   // is it pure text (vs. binary data)
    bool isIncompleteConversion(); // true if some replacement characters were found
    bool isFromBuffer();  // was it set via setData() (vs. setFileAccess() or setFilename())
    QStringList setData( const QString& data );
    bool isValid(); // Either no file is specified or reading was successful
 
    // Returns a list of error messages if anything went wrong
    QStringList readAndPreprocess(QTextCodec* pEncoding, bool bAutoDetectUnicode );
    bool saveNormalDataAs( const QString& fileName );
 
    bool isBinaryEqualWith( const SourceData& other ) const;
 
    void reset();
 
    QTextCodec* getEncoding() const { return m_pEncoding; }
    e_LineEndStyle getLineEndStyle() const { return m_normalData.m_eLineEndStyle; }
 
 private:
    QTextCodec* detectEncoding( const QString& fileName, QTextCodec* pFallbackCodec );
    QString m_aliasName;
    FileAccess m_fileAccess;
    Options* m_pOptions;
    QString m_tempInputFileName;
 
    struct FileData
    {
       FileData(){ m_pBuf=nullptr; m_size=0; m_vSize=0; m_bIsText=false; m_eLineEndStyle=eLineEndStyleUndefined; m_bIncompleteConversion=false;}
       ~FileData(){ reset(); }
       const char* m_pBuf;
       qint64 m_size;
       qint64 m_vSize; // Nr of lines in m_pBuf1 and size of m_v1, m_dv12 and m_dv13
       QString m_unicodeBuf;
       QVector<LineData> m_v;
       bool m_bIsText;
       bool m_bIncompleteConversion;
       e_LineEndStyle m_eLineEndStyle;
       bool readFile( const QString& filename );
       bool writeFile( const QString& filename );
       bool preprocess(bool bPreserveCR, QTextCodec* pEncoding );
       void reset();
       void removeComments();
       void copyBufFrom( const FileData& src );
 
       void checkLineForComments(
           const QChar* p,          // pointer to start of buffer
           int& i,                  // index of current position (in, out)
           int size,                // size of buffer
           bool& bWhite,            // false if this line contains nonwhite characters (in, out)
           bool& bCommentInLine,    // true if any comment is within this line (in, out)
           bool& bStartsOpenComment // true if the line ends within an comment (out)
       );
    };
    FileData m_normalData;
    FileData m_lmppData;  
    QTextCodec* m_pEncoding; 
 };
 
 void calcDiff3LineListTrim( Diff3LineList& d3ll, const LineData* pldA, const LineData* pldB, const LineData* pldC, ManualDiffHelpList* pManualDiffHelpList );
 void calcWhiteDiff3Lines(   Diff3LineList& d3ll, const LineData* pldA, const LineData* pldB, const LineData* pldC );
 
 void calcDiff3LineVector( Diff3LineList& d3ll, Diff3LineVector& d3lv );
 
 // Helper class that swaps left and right for some commands.
 class MyPainter : public QPainter
 {
    int m_factor;
    int m_xOffset;
    int m_fontWidth;
 public:
    MyPainter(QPaintDevice* pd, bool bRTL, int width, int fontWidth) 
    : QPainter(pd)
    {
       if (bRTL) 
       {
          m_fontWidth = fontWidth;
          m_factor = -1;
          m_xOffset = width-1;
       }
       else
       {
          m_fontWidth = 0;
          m_factor = 1;
          m_xOffset = 0;
       }
    }
 
    void fillRect( int x, int y, int w, int h, const QBrush& b )
    {
       if (m_factor==1)
          QPainter::fillRect( m_xOffset + x    , y, w, h, b );
       else
          QPainter::fillRect( m_xOffset - x - w, y, w, h, b );
    }
 
    void drawText( int x, int y, const QString& s, bool bAdapt=false )
    {
       Qt::LayoutDirection ld = (m_factor==1 || bAdapt == false) ? Qt::LeftToRight : Qt::RightToLeft;
       //QPainter::setLayoutDirection( ld );
       if ( ld==Qt::RightToLeft ) // Reverse the text
       {
          QString s2;
          for( int i=s.length()-1; i>=0; --i )
          {
             s2 += s[i];
          }
          QPainter::drawText( m_xOffset-m_fontWidth*s.length() + m_factor*x, y, s2 );
          return;
       }
       QPainter::drawText( m_xOffset-m_fontWidth*s.length() + m_factor*x, y, s );
    }
 
    void drawLine( int x1, int y1, int x2, int y2 )
    {
       QPainter::drawLine( m_xOffset + m_factor*x1, y1, m_xOffset + m_factor*x2, y2 );
    }
 };
 
 bool runDiff( const LineData* p1, LineRef size1, const LineData* p2, LineRef size2, DiffList& diffList, int winIdx1, int winIdx2,
               ManualDiffHelpList *pManualDiffHelpList, Options *pOptions);
 
 bool fineDiff(
    Diff3LineList& diff3LineList,
    int selector,
    const LineData* v1,
    const LineData* v2
    );
 
 
 bool equal( const LineData& l1, const LineData& l2, bool bStrict );
 
 
 
 
 inline bool isWhite( QChar c )
 {
    return c==' ' || c=='\t' ||  c=='\r';
 }
 
 /** Returns the number of equivalent spaces at position outPos.
 */
 inline int tabber( int outPos, int tabSize )
 {
    return tabSize - ( outPos % tabSize );
 }
 
 /** Returns a line number where the linerange [line, line+nofLines] can
     be displayed best. If it fits into the currently visible range then
     the returned value is the current firstLine.
 */
 int getBestFirstLine( int line, int nofLines, int firstLine, int visibleLines );
 
 extern bool g_bIgnoreWhiteSpace;
 extern bool g_bIgnoreTrivialMatches;
 extern int g_bAutoSolve;
 
 // Cursor conversions that consider g_tabSize.
 int convertToPosInText( const QString& s, int posOnScreen, int tabSize );
 int convertToPosOnScreen( const QString& s, int posInText, int tabSize );
 
 enum e_CoordType { eFileCoords, eD3LLineCoords, eWrapCoords };
 
 void calcTokenPos( const QString&, int posOnScreen, int& pos1, int& pos2, int tabSize );
 
 QString calcHistorySortKey( const QString& keyOrder, QRegExp& matchedRegExpr, const QStringList& parenthesesGroupList );
 bool findParenthesesGroups( const QString& s, QStringList& sl );
 #endif
 
diff --git a/src/directorymergewindow.cpp b/src/directorymergewindow.cpp
index b53bf0f..9665e27 100644
--- a/src/directorymergewindow.cpp
+++ b/src/directorymergewindow.cpp
@@ -1,3743 +1,3743 @@
 /***************************************************************************
                           directorymergewindow.cpp
                              -----------------
     begin                : Sat Oct 19 2002
     copyright            : (C) 2002-2011 by Joachim Eibl
     email                : joachim.eibl at gmx.de
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 #include <qglobal.h>
 
 #ifdef Q_OS_WIN
 #include <qt_windows.h>
 #endif
 
 #include "directorymergewindow.h"
 #include "guiutils.h"
 #include "options.h"
 #include "progress.h"
 
 #include <algorithm>
 #include <map>
 #include <vector>
 
 #include <QAction>
 #include <QApplication>
 #include <QDir>
 #include <QDialogButtonBox>
 #include <QFileDialog>
 #include <QImage>
 #include <QKeyEvent>
 #include <QLabel>
 #include <QLayout>
 #include <QMenu>
 #include <QMessageBox>
 #include <QPixmap>
 #include <QPushButton>
 #include <QRegExp>
 #include <QSplitter>
 #include <QStyledItemDelegate>
 #include <QTextEdit>
 #include <QTextStream>
 
 #include <KIconLoader>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KToggleAction>
 
 static bool conflictingFileTypes(MergeFileInfos& mfi);
 static QPixmap getOnePixmap(e_Age eAge, bool bLink, bool bDir);
 
 class StatusInfo : public QDialog
 {
     QTextEdit* m_pTextEdit;
 
   public:
     explicit StatusInfo(QWidget* pParent) : QDialog(pParent)
     {
         QVBoxLayout* pVLayout = new QVBoxLayout(this);
         m_pTextEdit = new QTextEdit(this);
         pVLayout->addWidget(m_pTextEdit);
         setObjectName("StatusInfo");
         setWindowFlags(Qt::Dialog);
         m_pTextEdit->setWordWrapMode(QTextOption::NoWrap);
         m_pTextEdit->setReadOnly(true);
         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);
     }
 };
 
 class TempRemover
 {
   public:
     TempRemover(const QString& origName, FileAccess& fa);
     ~TempRemover();
     QString name() { return m_name; }
     bool success() { return m_bSuccess; }
 
   private:
     QString m_name;
     bool m_bTemp;
     bool m_bSuccess;
 };
 TempRemover::TempRemover(const QString& origName, FileAccess& fa)
 {
     if(fa.isLocal())
     {
         m_name = origName;
         m_bTemp = false;
         m_bSuccess = true;
     }
     else
     {
         m_name = FileAccess::tempFileName();
         m_bSuccess = fa.copyFile(m_name);
         m_bTemp = m_bSuccess;
     }
 }
 TempRemover::~TempRemover()
 {
     if(m_bTemp && !m_name.isEmpty())
         FileAccess::removeTempFile(m_name);
 }
 
 enum Columns
 {
     s_NameCol = 0,
     s_ACol = 1,
     s_BCol = 2,
     s_CCol = 3,
     s_OpCol = 4,
     s_OpStatusCol = 5,
     s_UnsolvedCol = 6, // Nr of unsolved conflicts (for 3 input files)
     s_SolvedCol = 7,   // Nr of auto-solvable conflicts (for 3 input files)
     s_NonWhiteCol = 8, // Nr of nonwhite deltas (for 2 input files)
     s_WhiteCol = 9     // Nr of white deltas (for 2 input files)
 };
 
 enum e_OperationStatus
 {
     eOpStatusNone,
     eOpStatusDone,
     eOpStatusError,
     eOpStatusSkipped,
     eOpStatusNotSaved,
     eOpStatusInProgress,
     eOpStatusToDo
 };
 
 class MergeFileInfos
 {
   public:
     MergeFileInfos()
     {
         m_bEqualAB = false;
         m_bEqualAC = false;
         m_bEqualBC = false;
         m_pParent = nullptr;
         m_bOperationComplete = false;
         m_bSimOpComplete = false;
         m_eMergeOperation = eNoOperation;
         m_eOpStatus = eOpStatusNone;
         m_ageA = eNotThere;
         m_ageB = eNotThere;
         m_ageC = eNotThere;
         m_bConflictingAges = false;
         m_pFileInfoA = nullptr;
         m_pFileInfoB = nullptr;
         m_pFileInfoC = nullptr;
     }
     ~MergeFileInfos()
     {
         //for( int i=0; i<m_children.count(); ++i )
         //   delete m_children[i];
         m_children.clear();
     }
     //bool operator>( const MergeFileInfos& );
     QString subPath() const
     {
         return m_pFileInfoA && m_pFileInfoA->exists() ? m_pFileInfoA->filePath() : m_pFileInfoB && m_pFileInfoB->exists() ? m_pFileInfoB->filePath() : m_pFileInfoC && m_pFileInfoC->exists() ? m_pFileInfoC->filePath() : QString("");
     }
     QString fileName() const
     {
         return m_pFileInfoA && m_pFileInfoA->exists() ? m_pFileInfoA->fileName() : m_pFileInfoB && m_pFileInfoB->exists() ? m_pFileInfoB->fileName() : m_pFileInfoC && m_pFileInfoC->exists() ? m_pFileInfoC->fileName() : QString("");
     }
     bool dirA() const { return m_pFileInfoA ? m_pFileInfoA->isDir() : false; }
     bool dirB() const { return m_pFileInfoB ? m_pFileInfoB->isDir() : false; }
     bool dirC() const { return m_pFileInfoC ? m_pFileInfoC->isDir() : false; }
     bool isLinkA() const { return m_pFileInfoA ? m_pFileInfoA->isSymLink() : false; }
     bool isLinkB() const { return m_pFileInfoB ? m_pFileInfoB->isSymLink() : false; }
     bool isLinkC() const { return m_pFileInfoC ? m_pFileInfoC->isSymLink() : false; }
     bool existsInA() const { return m_pFileInfoA != nullptr; }
     bool existsInB() const { return m_pFileInfoB != nullptr; }
     bool existsInC() const { return m_pFileInfoC != nullptr; }
     MergeFileInfos* m_pParent;
     FileAccess* m_pFileInfoA;
     FileAccess* m_pFileInfoB;
     FileAccess* m_pFileInfoC;
     TotalDiffStatus m_totalDiffStatus;
     QList<MergeFileInfos*> m_children;
 
     e_MergeOperation m_eMergeOperation : 5;
     e_OperationStatus m_eOpStatus : 4;
 
     e_Age m_ageA : 3;
     e_Age m_ageB : 3;
     e_Age m_ageC : 3;
 
     bool m_bOperationComplete : 1;
     bool m_bSimOpComplete : 1;
 
     bool m_bEqualAB : 1;
     bool m_bEqualAC : 1;
     bool m_bEqualBC : 1;
     bool m_bConflictingAges : 1; // Equal age but files are not!
 };
 
 static Qt::CaseSensitivity s_eCaseSensitivity = Qt::CaseSensitive;
 
 class DirectoryMergeWindow::Data : public QAbstractItemModel
 {
   public:
     DirectoryMergeWindow* q;
     explicit Data(DirectoryMergeWindow* pDMW)
     {
         q = pDMW;
         m_pOptions = nullptr;
         m_pIconLoader = nullptr;
         m_pDirectoryMergeInfo = nullptr;
         m_bSimulatedMergeStarted = false;
         m_bRealMergeStarted = false;
         m_bError = false;
         m_bSyncMode = false;
         m_pStatusInfo = new StatusInfo(q);
         m_pStatusInfo->hide();
         m_bScanning = false;
         m_bCaseSensitive = true;
         m_bUnfoldSubdirs = false;
         m_bSkipDirStatus = false;
         m_pRoot = new MergeFileInfos;
     }
     ~Data() override
     {
         delete m_pRoot;
     }
     // Implement QAbstractItemModel
     QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
     //Qt::ItemFlags flags ( const QModelIndex & index ) const
     QModelIndex parent(const QModelIndex& index) const override
     {
         MergeFileInfos* pMFI = getMFI(index);
         if(pMFI == nullptr || pMFI == m_pRoot || pMFI->m_pParent == m_pRoot)
             return QModelIndex();
         else
         {
             MergeFileInfos* pParentsParent = pMFI->m_pParent->m_pParent;
             return createIndex(pParentsParent->m_children.indexOf(pMFI->m_pParent), 0, pMFI->m_pParent);
         }
     }
     int rowCount(const QModelIndex& parent = QModelIndex()) const override
     {
         MergeFileInfos* pParentMFI = getMFI(parent);
         if(pParentMFI != nullptr)
             return pParentMFI->m_children.count();
         else
             return m_pRoot->m_children.count();
     }
     int columnCount(const QModelIndex& /*parent*/) const override
     {
         return 10;
     }
     QModelIndex index(int row, int column, const QModelIndex& parent) const override
     {
         MergeFileInfos* pParentMFI = getMFI(parent);
         if(pParentMFI == nullptr && row < m_pRoot->m_children.count())
             return createIndex(row, column, m_pRoot->m_children[row]);
         else if(pParentMFI != nullptr && row < pParentMFI->m_children.count())
             return createIndex(row, column, pParentMFI->m_children[row]);
         else
             return QModelIndex();
     }
     QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
     void sort(int column, Qt::SortOrder order) override;
     // private data and helper methods
     MergeFileInfos* getMFI(const QModelIndex& mi) const
     {
         if(mi.isValid())
             return (MergeFileInfos*)mi.internalPointer();
         else
             return nullptr;
     }
     MergeFileInfos* m_pRoot;
 
     QString fullNameA(const MergeFileInfos& mfi)
     {
         return mfi.existsInA() ? mfi.m_pFileInfoA->absoluteFilePath() : m_dirA.absoluteFilePath() + "/" + mfi.subPath();
     }
     QString fullNameB(const MergeFileInfos& mfi)
     {
         return mfi.existsInB() ? mfi.m_pFileInfoB->absoluteFilePath() : m_dirB.absoluteFilePath() + "/" + mfi.subPath();
     }
     QString fullNameC(const MergeFileInfos& mfi)
     {
         return mfi.existsInC() ? mfi.m_pFileInfoC->absoluteFilePath() : m_dirC.absoluteFilePath() + "/" + mfi.subPath();
     }
     QString fullNameDest(const MergeFileInfos& mfi)
     {
         if(m_dirDestInternal.prettyAbsPath() == m_dirC.prettyAbsPath())
             return fullNameC(mfi);
         else if(m_dirDestInternal.prettyAbsPath() == m_dirB.prettyAbsPath())
             return fullNameB(mfi);
         else
             return m_dirDestInternal.absoluteFilePath() + "/" + mfi.subPath();
     }
 
     FileAccess m_dirA;
     FileAccess m_dirB;
     FileAccess m_dirC;
     FileAccess m_dirDest;
     FileAccess m_dirDestInternal;
     Options* m_pOptions;
 
     void calcDirStatus(bool bThreeDirs, const QModelIndex& mi,
                        int& nofFiles, int& nofDirs, int& nofEqualFiles, int& nofManualMerges);
 
     void mergeContinue(bool bStart, bool bVerbose);
 
     void prepareListView(ProgressProxy& pp);
     void calcSuggestedOperation(const QModelIndex& mi, e_MergeOperation eDefaultOperation);
     void setAllMergeOperations(e_MergeOperation eDefaultOperation);
     friend class MergeFileInfos;
 
     bool canContinue();
     QModelIndex treeIterator(QModelIndex mi, bool bVisitChildren = true, bool bFindInvisible = false);
     void prepareMergeStart(const QModelIndex& miBegin, const QModelIndex& miEnd, bool bVerbose);
     bool executeMergeOperation(MergeFileInfos& mfi, bool& bSingleFileMerge);
 
     void scanDirectory(const QString& dirName, t_DirectoryList& dirList);
     void scanLocalDirectory(const QString& dirName, t_DirectoryList& dirList);
     bool fastFileComparison(FileAccess& fi1, FileAccess& fi2,
                             bool& bError, QString& status);
     void compareFilesAndCalcAges(MergeFileInfos& mfi);
 
     void setMergeOperation(const QModelIndex& mi, e_MergeOperation eMergeOp, bool bRecursive = true);
     bool isDir(const QModelIndex& mi);
     QString getFileName(const QModelIndex& mi);
 
     bool copyFLD(const QString& srcName, const QString& destName);
     bool deleteFLD(const QString& name, bool bCreateBackup);
     bool makeDir(const QString& name, bool bQuiet = false);
     bool renameFLD(const QString& srcName, const QString& destName);
     bool mergeFLD(const QString& nameA, const QString& nameB, const QString& nameC,
                   const QString& nameDest, bool& bSingleFileMerge);
 
     t_DirectoryList m_dirListA;
     t_DirectoryList m_dirListB;
     t_DirectoryList m_dirListC;
 
     QString m_dirMergeStateFilename;
 
     class FileKey
     {
       public:
         const FileAccess* m_pFA;
         explicit FileKey(const FileAccess& fa) : m_pFA(&fa) {}
 
         int getParents(const FileAccess* pFA, const FileAccess* v[]) const
         {
             int s = 0;
             for(s = 0; pFA->parent() != nullptr; pFA = pFA->parent(), ++s)
                 v[s] = pFA;
             return s;
         }
 
         // This is essentially the same as
         // int r = filePath().compare( fa.filePath() )
         // if ( r<0 ) return true;
         // if ( r==0 ) return m_col < fa.m_col;
         // return false;
         bool operator<(const FileKey& fk) const
         {
             const FileAccess* v1[100];
             const FileAccess* v2[100];
             int v1Size = getParents(m_pFA, v1);
             int v2Size = getParents(fk.m_pFA, v2);
 
             for(int i = 0; i < v1Size && i < v2Size; ++i)
             {
                 int r = v1[v1Size - i - 1]->fileName().compare(v2[v2Size - i - 1]->fileName(), s_eCaseSensitivity);
                 if(r < 0)
                     return true;
                 else if(r > 0)
                     return false;
             }
 
             if(v1Size < v2Size)
                 return true;
             return false;
         }
     };
     typedef QMap<FileKey, MergeFileInfos> t_fileMergeMap;
     t_fileMergeMap m_fileMergeMap;
 
     bool m_bFollowDirLinks;
     bool m_bFollowFileLinks;
     bool m_bSimulatedMergeStarted;
     bool m_bRealMergeStarted;
     bool m_bError;
     bool m_bSyncMode;
     bool m_bDirectoryMerge; // if true, then merge is the default operation, otherwise it's diff.
     bool m_bCaseSensitive;
     bool m_bUnfoldSubdirs;
     bool m_bSkipDirStatus;
     bool m_bScanning; // true while in init()
 
     KIconLoader* m_pIconLoader;
     DirectoryMergeInfo* m_pDirectoryMergeInfo;
     StatusInfo* m_pStatusInfo;
 
     typedef std::list<QModelIndex> MergeItemList; // linked list
     MergeItemList m_mergeItemList;
     MergeItemList::iterator m_currentIndexForOperation;
 
     QModelIndex m_selection1Index;
     QModelIndex m_selection2Index;
     QModelIndex m_selection3Index;
     void selectItemAndColumn(const QModelIndex& mi, bool bContextMenu);
     friend class DirMergeItem;
 
     QAction* m_pDirStartOperation;
     QAction* m_pDirRunOperationForCurrentItem;
     QAction* m_pDirCompareCurrent;
     QAction* m_pDirMergeCurrent;
     QAction* m_pDirRescan;
     QAction* m_pDirChooseAEverywhere;
     QAction* m_pDirChooseBEverywhere;
     QAction* m_pDirChooseCEverywhere;
     QAction* m_pDirAutoChoiceEverywhere;
     QAction* m_pDirDoNothingEverywhere;
     QAction* m_pDirFoldAll;
     QAction* m_pDirUnfoldAll;
 
     KToggleAction* m_pDirShowIdenticalFiles;
     KToggleAction* m_pDirShowDifferentFiles;
     KToggleAction* m_pDirShowFilesOnlyInA;
     KToggleAction* m_pDirShowFilesOnlyInB;
     KToggleAction* m_pDirShowFilesOnlyInC;
 
     KToggleAction* m_pDirSynchronizeDirectories;
     KToggleAction* m_pDirChooseNewerFiles;
 
     QAction* m_pDirCompareExplicit;
     QAction* m_pDirMergeExplicit;
 
     QAction* m_pDirCurrentDoNothing;
     QAction* m_pDirCurrentChooseA;
     QAction* m_pDirCurrentChooseB;
     QAction* m_pDirCurrentChooseC;
     QAction* m_pDirCurrentMerge;
     QAction* m_pDirCurrentDelete;
 
     QAction* m_pDirCurrentSyncDoNothing;
     QAction* m_pDirCurrentSyncCopyAToB;
     QAction* m_pDirCurrentSyncCopyBToA;
     QAction* m_pDirCurrentSyncDeleteA;
     QAction* m_pDirCurrentSyncDeleteB;
     QAction* m_pDirCurrentSyncDeleteAAndB;
     QAction* m_pDirCurrentSyncMergeToA;
     QAction* m_pDirCurrentSyncMergeToB;
     QAction* m_pDirCurrentSyncMergeToAAndB;
 
     QAction* m_pDirSaveMergeState;
     QAction* m_pDirLoadMergeState;
 
     bool init(FileAccess& dirA, FileAccess& dirB, FileAccess& dirC, FileAccess& dirDest, bool bDirectoryMerge, bool bReload);
     void setOpStatus(const QModelIndex& mi, e_OperationStatus eOpStatus)
     {
         if(MergeFileInfos* pMFI = getMFI(mi))
         {
             pMFI->m_eOpStatus = eOpStatus;
             emit dataChanged(mi, mi);
         }
     }
 };
 
 QVariant DirectoryMergeWindow::Data::data(const QModelIndex& index, int role) const
 {
     MergeFileInfos* pMFI = getMFI(index);
     if(pMFI)
     {
         if(role == Qt::DisplayRole)
         {
             switch(index.column())
             {
             case s_NameCol:
                 return QFileInfo(pMFI->subPath()).fileName();
             case s_ACol:
                 return "A";
             case s_BCol:
                 return "B";
             case s_CCol:
                 return "C";
             //case s_OpCol:       return i18n("Operation");
             //case s_OpStatusCol: return i18n("Status");
             case s_UnsolvedCol:
                 return i18n("Unsolved");
             case s_SolvedCol:
                 return i18n("Solved");
             case s_NonWhiteCol:
                 return i18n("Nonwhite");
             case s_WhiteCol:
                 return i18n("White");
                 //default :           return QVariant();
             }
 
             if(s_OpCol == index.column())
             {
                 bool bDir = pMFI->dirA() || pMFI->dirB() || pMFI->dirC();
                 switch(pMFI->m_eMergeOperation)
                 {
                 case eNoOperation:
                     return "";
                     break;
                 case eCopyAToB:
                     return i18n("Copy A to B");
                     break;
                 case eCopyBToA:
                     return i18n("Copy B to A");
                     break;
                 case eDeleteA:
                     return i18n("Delete A");
                     break;
                 case eDeleteB:
                     return i18n("Delete B");
                     break;
                 case eDeleteAB:
                     return i18n("Delete A & B");
                     break;
                 case eMergeToA:
                     return i18n("Merge to A");
                     break;
                 case eMergeToB:
                     return i18n("Merge to B");
                     break;
                 case eMergeToAB:
                     return i18n("Merge to A & B");
                     break;
                 case eCopyAToDest:
                     return "A";
                     break;
                 case eCopyBToDest:
                     return "B";
                     break;
                 case eCopyCToDest:
                     return "C";
                     break;
                 case eDeleteFromDest:
                     return i18n("Delete (if exists)");
                     break;
                 case eMergeABCToDest:
                     return bDir ? i18n("Merge") : i18n("Merge (manual)");
                     break;
                 case eMergeABToDest:
                     return bDir ? i18n("Merge") : i18n("Merge (manual)");
                     break;
                 case eConflictingFileTypes:
                     return i18n("Error: Conflicting File Types");
                     break;
                 case eChangedAndDeleted:
                     return i18n("Error: Changed and Deleted");
                     break;
                 case eConflictingAges:
                     return i18n("Error: Dates are equal but files are not.");
                     break;
                 default:
                     Q_ASSERT(true);
                     break;
                 }
             }
             if(s_OpStatusCol == index.column())
             {
                 switch(pMFI->m_eOpStatus)
                 {
                 case eOpStatusNone:
                     return "";
                 case eOpStatusDone:
                     return i18n("Done");
                 case eOpStatusError:
                     return i18n("Error");
                 case eOpStatusSkipped:
                     return i18n("Skipped.");
                 case eOpStatusNotSaved:
                     return i18n("Not saved.");
                 case eOpStatusInProgress:
                     return i18n("In progress...");
                 case eOpStatusToDo:
                     return i18n("To do.");
                 }
             }
         }
         else if(role == Qt::DecorationRole)
         {
             if(s_NameCol == index.column())
             {
                 return getOnePixmap(eAgeEnd, pMFI->isLinkA() || pMFI->isLinkB() || pMFI->isLinkC(),
                                     pMFI->dirA() || pMFI->dirB() || pMFI->dirC());
             }
 
             if(s_ACol == index.column())
             {
                 return getOnePixmap(pMFI->m_ageA, pMFI->isLinkA(), pMFI->dirA());
             }
             if(s_BCol == index.column())
             {
                 return getOnePixmap(pMFI->m_ageB, pMFI->isLinkB(), pMFI->dirB());
             }
             if(s_CCol == index.column())
             {
                 return getOnePixmap(pMFI->m_ageC, pMFI->isLinkC(), pMFI->dirC());
             }
         }
         else if(role == Qt::TextAlignmentRole)
         {
             if(s_UnsolvedCol == index.column() || s_SolvedCol == index.column() || s_NonWhiteCol == index.column() || s_WhiteCol == index.column())
                 return Qt::AlignRight;
         }
     }
     return QVariant();
 }
 
 QVariant DirectoryMergeWindow::Data::headerData(int section, Qt::Orientation orientation, int role) const
 {
     if(orientation == Qt::Horizontal && section >= 0 && section < columnCount(QModelIndex()) && role == Qt::DisplayRole)
     {
         switch(section)
         {
         case s_NameCol:
             return i18n("Name");
         case s_ACol:
             return "A";
         case s_BCol:
             return "B";
         case s_CCol:
             return "C";
         case s_OpCol:
             return i18n("Operation");
         case s_OpStatusCol:
             return i18n("Status");
         case s_UnsolvedCol:
             return i18n("Unsolved");
         case s_SolvedCol:
             return i18n("Solved");
         case s_NonWhiteCol:
             return i18n("Nonwhite");
         case s_WhiteCol:
             return i18n("White");
         default:
             return QVariant();
         }
     }
     return QVariant();
 }
 
 // Previously  Q3ListViewItem::paintCell(p,cg,column,width,align);
 class DirectoryMergeWindow::DirMergeItemDelegate : public QStyledItemDelegate
 {
     DirectoryMergeWindow* m_pDMW;
     DirectoryMergeWindow::Data* d;
 
   public:
     explicit DirMergeItemDelegate(DirectoryMergeWindow* pParent)
         : QStyledItemDelegate(pParent), m_pDMW(pParent), d(pParent->d)
     {
     }
     void paint(QPainter* p, const QStyleOptionViewItem& option, const QModelIndex& index) const override
     {
         int column = index.column();
         if(column == s_ACol || column == s_BCol || column == s_CCol)
         {
             QVariant value = index.data(Qt::DecorationRole);
             QPixmap icon;
             if(value.isValid())
             {
                 if(value.type() == QVariant::Icon)
                 {
                     icon = qvariant_cast<QIcon>(value).pixmap(16, 16);
                     //icon = qvariant_cast<QIcon>(value);
                     //decorationRect = QRect(QPoint(0, 0), icon.actualSize(option.decorationSize, iconMode, iconState));
                 }
                 else
                 {
                     icon = qvariant_cast<QPixmap>(value);
                     //decorationRect = QRect(QPoint(0, 0), option.decorationSize).intersected(pixmap.rect());
                 }
             }
 
             int x = option.rect.left();
             int y = option.rect.top();
             //QPixmap icon = value.value<QPixmap>(); //pixmap(column);
             if(!icon.isNull())
             {
                 int yOffset = (sizeHint(option, index).height() - icon.height()) / 2;
                 p->drawPixmap(x + 2, y + yOffset, icon);
 
                 int i = index == d->m_selection1Index ? 1 : index == d->m_selection2Index ? 2 : index == d->m_selection3Index ? 3 : 0;
                 if(i != 0)
                 {
                     Options* pOpts = d->m_pOptions;
                     QColor c(i == 1 ? pOpts->m_colorA : i == 2 ? pOpts->m_colorB : pOpts->m_colorC);
                     p->setPen(c); // highlight() );
                     p->drawRect(x + 2, y + yOffset, icon.width(), icon.height());
                     p->setPen(QPen(c, 0, Qt::DotLine));
                     p->drawRect(x + 1, y + yOffset - 1, icon.width() + 2, icon.height() + 2);
                     p->setPen(Qt::white);
                     QString s(QChar('A' + i - 1));
                     p->drawText(x + 2 + (icon.width() - p->fontMetrics().width(s)) / 2,
                                 y + yOffset + (icon.height() + p->fontMetrics().ascent()) / 2 - 1,
                                 s);
                 }
                 else
                 {
                     p->setPen(m_pDMW->palette().background().color());
                     p->drawRect(x + 1, y + yOffset - 1, icon.width() + 2, icon.height() + 2);
                 }
                 return;
             }
         }
         QStyleOptionViewItem option2 = option;
         if(column >= s_UnsolvedCol)
         {
             option2.displayAlignment = Qt::AlignRight;
         }
         QStyledItemDelegate::paint(p, option2, index);
     }
     QSize sizeHint(const QStyleOptionViewItem& option, const QModelIndex& index) const override
     {
         QSize sz = QStyledItemDelegate::sizeHint(option, index);
         return sz.expandedTo(QSize(0, 18));
     }
 };
 
 DirectoryMergeWindow::DirectoryMergeWindow(QWidget* pParent, Options* pOptions, KIconLoader* pIconLoader)
     : QTreeView(pParent)
 {
     d = new Data(this);
     setModel(d);
     setItemDelegate(new DirMergeItemDelegate(this));
     connect(this, &DirectoryMergeWindow::doubleClicked, this, &DirectoryMergeWindow::onDoubleClick);
     connect(this, &DirectoryMergeWindow::expanded, this, &DirectoryMergeWindow::onExpanded);
 
     d->m_pOptions = pOptions;
     d->m_pIconLoader = pIconLoader;
 
     setSortingEnabled(true);
 }
 
 DirectoryMergeWindow::~DirectoryMergeWindow()
 {
     delete d;
 }
 
 QString DirectoryMergeWindow::getDirNameA() { return d->m_dirA.prettyAbsPath(); }
 QString DirectoryMergeWindow::getDirNameB() { return d->m_dirB.prettyAbsPath(); }
 QString DirectoryMergeWindow::getDirNameC() { return d->m_dirC.prettyAbsPath(); }
 QString DirectoryMergeWindow::getDirNameDest() { return d->m_dirDest.prettyAbsPath(); }
 void DirectoryMergeWindow::setDirectoryMergeInfo(DirectoryMergeInfo* p) { d->m_pDirectoryMergeInfo = p; }
 bool DirectoryMergeWindow::isDirectoryMergeInProgress() { return d->m_bRealMergeStarted; }
 bool DirectoryMergeWindow::isSyncMode() { return d->m_bSyncMode; }
 bool DirectoryMergeWindow::isScanning() { return d->m_bScanning; }
 
 bool DirectoryMergeWindow::Data::fastFileComparison(
     FileAccess& fi1, FileAccess& fi2,
     bool& bError, QString& status)
 {
     ProgressProxy pp;
     status = "";
     bool bEqual = false;
     bError = true;
 
     if(!m_bFollowFileLinks)
     {
         if(fi1.isSymLink() != fi2.isSymLink())
         {
             status = i18n("Mix of links and normal files.");
             return bEqual;
         }
         else if(fi1.isSymLink() && fi2.isSymLink())
         {
             bError = false;
             bEqual = fi1.readLink() == fi2.readLink();
             status = i18n("Link: ");
             return bEqual;
         }
     }
 
     if(fi1.size() != fi2.size())
     {
         bEqual = false;
         status = i18n("Size. ");
         return bEqual;
     }
     else if(m_pOptions->m_bDmTrustSize)
     {
         bEqual = true;
         return bEqual;
     }
 
     if(m_pOptions->m_bDmTrustDate)
     {
         bEqual = (fi1.lastModified() == fi2.lastModified() && fi1.size() == fi2.size());
         bError = false;
         status = i18n("Date & Size: ");
         return bEqual;
     }
 
     if(m_pOptions->m_bDmTrustDateFallbackToBinary)
     {
         bEqual = (fi1.lastModified() == fi2.lastModified() && fi1.size() == fi2.size());
         if(bEqual)
         {
             bError = false;
             status = i18n("Date & Size: ");
             return bEqual;
         }
     }
 
     QString fileName1 = fi1.absoluteFilePath();
     QString fileName2 = fi2.absoluteFilePath();
     TempRemover tr1(fileName1, fi1);
     if(!tr1.success())
     {
         status = i18n("Creating temp copy of %1 failed.", fileName1);
         return bEqual;
     }
     TempRemover tr2(fileName2, fi2);
     if(!tr2.success())
     {
         status = i18n("Creating temp copy of %1 failed.", fileName2);
         return bEqual;
     }
 
     std::vector<char> buf1(100000);
     std::vector<char> buf2(buf1.size());
 
     QFile file1(tr1.name());
 
     if(!file1.open(QIODevice::ReadOnly))
     {
         status = i18n("Opening %1 failed.", fileName1);
         return bEqual;
     }
 
     QFile file2(tr2.name());
 
     if(!file2.open(QIODevice::ReadOnly))
     {
         status = i18n("Opening %1 failed.", fileName2);
         return bEqual;
     }
 
     pp.setInformation(i18n("Comparing file..."), 0, false);
     typedef qint64 t_FileSize;
     t_FileSize fullSize = file1.size();
     t_FileSize sizeLeft = fullSize;
 
     pp.setMaxNofSteps(fullSize / buf1.size());
 
     while(sizeLeft > 0 && !pp.wasCancelled())
     {
         qint64 len = min2(sizeLeft, (t_FileSize)buf1.size());
         if(len != file1.read(&buf1[0], len))
         {
             status = i18n("Error reading from %1", fileName1);
             return bEqual;
         }
 
         if(len != file2.read(&buf2[0], len))
         {
             status = i18n("Error reading from %1", fileName2);
             return bEqual;
         }
 
         if(memcmp(&buf1[0], &buf2[0], len) != 0)
         {
             bError = false;
             return bEqual;
         }
         sizeLeft -= len;
         //pp.setCurrent(double(fullSize-sizeLeft)/fullSize, false );
         pp.step();
     }
 
     // If the program really arrives here, then the files are really equal.
     bError = false;
     bEqual = true;
     return bEqual;
 }
 
 int DirectoryMergeWindow::totalColumnWidth()
 {
     int w = 0;
     for(int i = 0; i < s_OpStatusCol; ++i)
     {
         w += columnWidth(i);
     }
     return w;
 }
 
 void DirectoryMergeWindow::reload()
 {
     if(isDirectoryMergeInProgress())
     {
         int result = KMessageBox::warningYesNo(this,
                                                i18n("You are currently doing a directory merge. Are you sure, you want to abort the merge and rescan the directory?"),
                                                i18n("Warning"),
                                                KGuiItem(i18n("Rescan")),
                                                KGuiItem(i18n("Continue Merging")));
         if(result != KMessageBox::Yes)
             return;
     }
 
     init(d->m_dirA, d->m_dirB, d->m_dirC, d->m_dirDest, d->m_bDirectoryMerge, true);
     //fix file visibilities after reload or menu will be out of sync with display if changed from defaults.
     updateFileVisibilities();
 }
 
 // Copy pm2 onto pm1, but preserve the alpha value from pm1 where pm2 is transparent.
 static QPixmap pixCombiner(const QPixmap* pm1, const QPixmap* pm2)
 {
     QImage img1 = pm1->toImage().convertToFormat(QImage::Format_ARGB32);
     QImage img2 = pm2->toImage().convertToFormat(QImage::Format_ARGB32);
 
     for(int y = 0; y < img1.height(); y++)
     {
         quint32* line1 = reinterpret_cast<quint32*>(img1.scanLine(y));
         quint32* line2 = reinterpret_cast<quint32*>(img2.scanLine(y));
         for(int x = 0; x < img1.width(); x++)
         {
             if(qAlpha(line2[x]) > 0)
                 line1[x] = (line2[x] | 0xff000000);
         }
     }
     return QPixmap::fromImage(img1);
 }
 
 // like pixCombiner but let the pm1 color shine through
 static QPixmap pixCombiner2(const QPixmap* pm1, const QPixmap* pm2)
 {
     QPixmap pix = *pm1;
     QPainter p(&pix);
     p.setOpacity(0.5);
     p.drawPixmap(0, 0, *pm2);
     p.end();
 
     return pix;
 }
 
 void DirectoryMergeWindow::Data::calcDirStatus(bool bThreeDirs, const QModelIndex& mi,
                                                int& nofFiles, int& nofDirs, int& nofEqualFiles, int& nofManualMerges)
 {
     MergeFileInfos* pMFI = getMFI(mi);
     if(pMFI->dirA() || pMFI->dirB() || pMFI->dirC())
     {
         ++nofDirs;
     }
     else
     {
         ++nofFiles;
         if(pMFI->m_bEqualAB && (!bThreeDirs || pMFI->m_bEqualAC))
         {
             ++nofEqualFiles;
         }
         else
         {
             if(pMFI->m_eMergeOperation == eMergeABCToDest || pMFI->m_eMergeOperation == eMergeABToDest)
                 ++nofManualMerges;
         }
     }
     for(int childIdx = 0; childIdx < rowCount(mi); ++childIdx)
         calcDirStatus(bThreeDirs, index(childIdx, 0, mi), nofFiles, nofDirs, nofEqualFiles, nofManualMerges);
 }
 
 struct t_ItemInfo {
     bool bExpanded;
     bool bOperationComplete;
     QString status;
     e_MergeOperation eMergeOperation;
 };
 
 bool DirectoryMergeWindow::init(
     FileAccess& dirA,
     FileAccess& dirB,
     FileAccess& dirC,
     FileAccess& dirDest,
     bool bDirectoryMerge,
     bool bReload)
 {
     return d->init(dirA, dirB, dirC, dirDest, bDirectoryMerge, bReload);
 }
 
 bool DirectoryMergeWindow::Data::init(
     FileAccess& dirA,
     FileAccess& dirB,
     FileAccess& dirC,
     FileAccess& dirDest,
     bool bDirectoryMerge,
     bool bReload)
 {
     if(m_pOptions->m_bDmFullAnalysis)
     {
-        // A full analysis uses the same ressources that a normal text-diff/merge uses.
+        // 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 q->checkIfCanContinue(&bCanContinue);
         if(!bCanContinue)
             return false;
         emit q->startDiffMerge("", "", "", "", "", "", "", nullptr); // hide main window
     }
 
     q->show();
     q->setUpdatesEnabled(true);
 
     std::map<QString, t_ItemInfo> expandedDirsMap;
 
     if(bReload)
     {
         // Remember expanded items TODO
         //QTreeWidgetItemIterator it( this );
         //while ( *it )
         //{
         //   DirMergeItem* pDMI = static_cast<DirMergeItem*>( *it );
         //   t_ItemInfo& ii = expandedDirsMap[ pDMI->m_pMFI->subPath() ];
         //   ii.bExpanded = pDMI->isExpanded();
         //   ii.bOperationComplete = pDMI->m_pMFI->m_bOperationComplete;
         //   ii.status = pDMI->text( s_OpStatusCol );
         //   ii.eMergeOperation = pDMI->m_pMFI->m_eMergeOperation;
         //   ++it;
         //}
     }
 
     ProgressProxy pp;
     m_bFollowDirLinks = m_pOptions->m_bDmFollowDirLinks;
     m_bFollowFileLinks = m_pOptions->m_bDmFollowFileLinks;
     m_bSimulatedMergeStarted = false;
     m_bRealMergeStarted = false;
     m_bError = false;
     m_bDirectoryMerge = bDirectoryMerge;
     m_selection1Index = QModelIndex();
     m_selection2Index = QModelIndex();
     m_selection3Index = QModelIndex();
     m_bCaseSensitive = m_pOptions->m_bDmCaseSensitiveFilenameComparison;
     m_bUnfoldSubdirs = m_pOptions->m_bDmUnfoldSubdirs;
     m_bSkipDirStatus = m_pOptions->m_bDmSkipDirStatus;
 
     beginResetModel();
     m_pRoot->m_children.clear();
     m_mergeItemList.clear();
     endResetModel();
 
     m_currentIndexForOperation = m_mergeItemList.end();
 
     m_dirA = dirA;
     m_dirB = dirB;
     m_dirC = dirC;
     m_dirDest = dirDest;
 
     if(!bReload)
     {
         m_pDirShowIdenticalFiles->setChecked(true);
         m_pDirShowDifferentFiles->setChecked(true);
         m_pDirShowFilesOnlyInA->setChecked(true);
         m_pDirShowFilesOnlyInB->setChecked(true);
         m_pDirShowFilesOnlyInC->setChecked(true);
     }
 
     // Check if all input directories exist and are valid. The dest dir is not tested now.
     // The test will happen only when we are going to write to it.
     if(!m_dirA.isDir() || !m_dirB.isDir() ||
        (m_dirC.isValid() && !m_dirC.isDir()))
     {
         QString text(i18n("Opening of directories failed:"));
         text += "\n\n";
         if(!dirA.isDir())
         {
             text += i18n("Dir A \"%1\" does not exist or is not a directory.\n", m_dirA.prettyAbsPath());
         }
 
         if(!dirB.isDir())
         {
             text += i18n("Dir B \"%1\" does not exist or is not a directory.\n", m_dirB.prettyAbsPath());
         }
 
         if(m_dirC.isValid() && !m_dirC.isDir())
         {
             text += i18n("Dir C \"%1\" does not exist or is not a directory.\n", m_dirC.prettyAbsPath());
         }
 
         KMessageBox::sorry(q, text, i18n("Directory Open Error"));
         return false;
     }
 
     if(m_dirC.isValid() &&
        (m_dirDest.prettyAbsPath() == m_dirA.prettyAbsPath() || m_dirDest.prettyAbsPath() == m_dirB.prettyAbsPath()))
     {
         KMessageBox::error(q,
                            i18n("The destination directory must not be the same as A or B when "
                                 "three directories are merged.\nCheck again before continuing."),
                            i18n("Parameter Warning"));
         return false;
     }
 
     m_bScanning = true;
     emit q->statusBarMessage(i18n("Scanning directories..."));
 
     m_bSyncMode = m_pOptions->m_bDmSyncMode && !m_dirC.isValid() && !m_dirDest.isValid();
 
     if(m_dirDest.isValid())
         m_dirDestInternal = m_dirDest;
     else
         m_dirDestInternal = m_dirC.isValid() ? m_dirC : m_dirB;
 
     QString origCurrentDirectory = QDir::currentPath();
 
     m_fileMergeMap.clear();
     s_eCaseSensitivity = m_bCaseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive;
     t_DirectoryList::iterator i;
 
     // calc how many directories will be read:
     double nofScans = (m_dirA.isValid() ? 1 : 0) + (m_dirB.isValid() ? 1 : 0) + (m_dirC.isValid() ? 1 : 0);
     int currentScan = 0;
 
     //TODO   setColumnWidthMode(s_UnsolvedCol, Q3ListView::Manual);
     //   setColumnWidthMode(s_SolvedCol,   Q3ListView::Manual);
     //   setColumnWidthMode(s_WhiteCol,    Q3ListView::Manual);
     //   setColumnWidthMode(s_NonWhiteCol, Q3ListView::Manual);
     q->setColumnHidden(s_CCol, !m_dirC.isValid());
     q->setColumnHidden(s_WhiteCol, !m_pOptions->m_bDmFullAnalysis);
     q->setColumnHidden(s_NonWhiteCol, !m_pOptions->m_bDmFullAnalysis);
     q->setColumnHidden(s_UnsolvedCol, !m_pOptions->m_bDmFullAnalysis);
     q->setColumnHidden(s_SolvedCol, !(m_pOptions->m_bDmFullAnalysis && m_dirC.isValid()));
 
     bool bListDirSuccessA = true;
     bool bListDirSuccessB = true;
     bool bListDirSuccessC = true;
     m_dirListA.clear();
     m_dirListB.clear();
     m_dirListC.clear();
     if(m_dirA.isValid())
     {
         pp.setInformation(i18n("Reading Directory A"));
         pp.setSubRangeTransformation(currentScan / nofScans, (currentScan + 1) / nofScans);
         ++currentScan;
 
         bListDirSuccessA = m_dirA.listDir(&m_dirListA,
                                           m_pOptions->m_bDmRecursiveDirs, m_pOptions->m_bDmFindHidden,
                                           m_pOptions->m_DmFilePattern, m_pOptions->m_DmFileAntiPattern,
                                           m_pOptions->m_DmDirAntiPattern, m_pOptions->m_bDmFollowDirLinks,
                                           m_pOptions->m_bDmUseCvsIgnore);
 
         for(i = m_dirListA.begin(); i != m_dirListA.end(); ++i)
         {
             MergeFileInfos& mfi = m_fileMergeMap[FileKey(*i)];
             //std::cout <<i->filePath()<<std::endl;
             mfi.m_pFileInfoA = &(*i);
         }
     }
 
     if(m_dirB.isValid())
     {
         pp.setInformation(i18n("Reading Directory B"));
         pp.setSubRangeTransformation(currentScan / nofScans, (currentScan + 1) / nofScans);
         ++currentScan;
 
         bListDirSuccessB = m_dirB.listDir(&m_dirListB,
                                           m_pOptions->m_bDmRecursiveDirs, m_pOptions->m_bDmFindHidden,
                                           m_pOptions->m_DmFilePattern, m_pOptions->m_DmFileAntiPattern,
                                           m_pOptions->m_DmDirAntiPattern, m_pOptions->m_bDmFollowDirLinks,
                                           m_pOptions->m_bDmUseCvsIgnore);
 
         for(i = m_dirListB.begin(); i != m_dirListB.end(); ++i)
         {
             MergeFileInfos& mfi = m_fileMergeMap[FileKey(*i)];
             mfi.m_pFileInfoB = &(*i);
             if(mfi.m_pFileInfoA && mfi.m_pFileInfoA->fileName() == mfi.m_pFileInfoB->fileName())
                 mfi.m_pFileInfoB->setSharedName(mfi.m_pFileInfoA->fileName()); // Reduce memory by sharing the name.
         }
     }
 
     e_MergeOperation eDefaultMergeOp;
     if(m_dirC.isValid())
     {
         pp.setInformation(i18n("Reading Directory C"));
         pp.setSubRangeTransformation(currentScan / nofScans, (currentScan + 1) / nofScans);
         ++currentScan;
 
         bListDirSuccessC = m_dirC.listDir(&m_dirListC,
                                           m_pOptions->m_bDmRecursiveDirs, m_pOptions->m_bDmFindHidden,
                                           m_pOptions->m_DmFilePattern, m_pOptions->m_DmFileAntiPattern,
                                           m_pOptions->m_DmDirAntiPattern, m_pOptions->m_bDmFollowDirLinks,
                                           m_pOptions->m_bDmUseCvsIgnore);
 
         for(i = m_dirListC.begin(); i != m_dirListC.end(); ++i)
         {
             MergeFileInfos& mfi = m_fileMergeMap[FileKey(*i)];
             mfi.m_pFileInfoC = &(*i);
         }
 
         eDefaultMergeOp = eMergeABCToDest;
     }
     else
         eDefaultMergeOp = m_bSyncMode ? eMergeToAB : eMergeABToDest;
 
     bool bContinue = true;
     if(!bListDirSuccessA || !bListDirSuccessB || !bListDirSuccessC)
     {
         QString s = i18n("Some subdirectories were not readable in");
         if(!bListDirSuccessA) s += "\nA: " + m_dirA.prettyAbsPath();
         if(!bListDirSuccessB) s += "\nB: " + m_dirB.prettyAbsPath();
         if(!bListDirSuccessC) s += "\nC: " + m_dirC.prettyAbsPath();
         s += "\n";
         s += i18n("Check the permissions of the subdirectories.");
         bContinue = KMessageBox::Continue == KMessageBox::warningContinueCancel(q, s);
     }
 
     if(bContinue)
     {
         prepareListView(pp);
 
         q->updateFileVisibilities();
 
         for(int childIdx = 0; childIdx < rowCount(); ++childIdx)
         {
             QModelIndex mi = index(childIdx, 0, QModelIndex());
             calcSuggestedOperation(mi, eDefaultMergeOp);
         }
     }
 
     q->sortByColumn(0, Qt::AscendingOrder);
 
     for(int i = 0; i < columnCount(QModelIndex()); ++i)
         q->resizeColumnToContents(i);
 
     // Try to improve the view a little bit.
     QWidget* pParent = q->parentWidget();
     QSplitter* pSplitter = static_cast<QSplitter*>(pParent);
     if(pSplitter != nullptr)
     {
         QList<int> sizes = pSplitter->sizes();
         int total = sizes[0] + sizes[1];
         if(total < 10)
             total = 100;
         sizes[0] = total * 6 / 10;
         sizes[1] = total - sizes[0];
         pSplitter->setSizes(sizes);
     }
 
     QDir::setCurrent(origCurrentDirectory);
 
     m_bScanning = false;
     emit q->statusBarMessage(i18n("Ready."));
 
     if(bContinue && !m_bSkipDirStatus)
     {
         // Generate a status report
         int nofFiles = 0;
         int nofDirs = 0;
         int nofEqualFiles = 0;
         int nofManualMerges = 0;
         //TODO
         for(int childIdx = 0; childIdx < rowCount(); ++childIdx)
             calcDirStatus(m_dirC.isValid(), index(childIdx, 0, QModelIndex()),
                           nofFiles, nofDirs, nofEqualFiles, nofManualMerges);
 
         QString s;
         s = i18n("Directory Comparison Status\n\n"
                  "Number of subdirectories: %1\n"
                  "Number of equal files: %2\n"
                  "Number of different files: %3",
                  nofDirs, nofEqualFiles, nofFiles - nofEqualFiles);
 
         if(m_dirC.isValid())
             s += "\n" + i18n("Number of manual merges: %1", nofManualMerges);
         KMessageBox::information(q, s);
         //
         //TODO
         //if ( topLevelItemCount()>0 )
         //{
         //   topLevelItem(0)->setSelected(true);
         //   setCurrentItem( topLevelItem(0) );
         //}
     }
 
     if(bReload)
     {
         // Remember expanded items
         //TODO
         //QTreeWidgetItemIterator it( this );
         //while ( *it )
         //{
         //   DirMergeItem* pDMI = static_cast<DirMergeItem*>( *it );
         //   std::map<QString,t_ItemInfo>::iterator i = expandedDirsMap.find( pDMI->m_pMFI->subPath() );
         //   if ( i!=expandedDirsMap.end() )
         //   {
         //      t_ItemInfo& ii = i->second;
         //      pDMI->setExpanded( ii.bExpanded );
         //      //pDMI->m_pMFI->setMergeOperation( ii.eMergeOperation, false ); unsafe, might have changed
         //      pDMI->m_pMFI->m_bOperationComplete = ii.bOperationComplete;
         //      pDMI->setText( s_OpStatusCol, ii.status );
         //   }
         //   ++it;
         //}
     }
     else if(m_bUnfoldSubdirs)
     {
         m_pDirUnfoldAll->trigger();
     }
 
     return true;
 }
 
 void DirectoryMergeWindow::onExpanded()
 {
     resizeColumnToContents(s_NameCol);
 }
 
 void DirectoryMergeWindow::slotChooseAEverywhere() { d->setAllMergeOperations(eCopyAToDest); }
 
 void DirectoryMergeWindow::slotChooseBEverywhere() { d->setAllMergeOperations(eCopyBToDest); }
 
 void DirectoryMergeWindow::slotChooseCEverywhere() { d->setAllMergeOperations(eCopyCToDest); }
 
 void DirectoryMergeWindow::slotAutoChooseEverywhere()
 {
     e_MergeOperation eDefaultMergeOp = d->m_dirC.isValid() ? eMergeABCToDest : d->m_bSyncMode ? eMergeToAB : eMergeABToDest;
     d->setAllMergeOperations(eDefaultMergeOp);
 }
 
 void DirectoryMergeWindow::slotNoOpEverywhere() { d->setAllMergeOperations(eNoOperation); }
 
 void DirectoryMergeWindow::slotFoldAllSubdirs()
 {
     collapseAll();
 }
 
 void DirectoryMergeWindow::slotUnfoldAllSubdirs()
 {
     expandAll();
 }
 
 // Merge current item (merge mode)
 void DirectoryMergeWindow::slotCurrentDoNothing() { d->setMergeOperation(currentIndex(), eNoOperation); }
 void DirectoryMergeWindow::slotCurrentChooseA() { d->setMergeOperation(currentIndex(), d->m_bSyncMode ? eCopyAToB : eCopyAToDest); }
 void DirectoryMergeWindow::slotCurrentChooseB() { d->setMergeOperation(currentIndex(), d->m_bSyncMode ? eCopyBToA : eCopyBToDest); }
 void DirectoryMergeWindow::slotCurrentChooseC() { d->setMergeOperation(currentIndex(), eCopyCToDest); }
 void DirectoryMergeWindow::slotCurrentMerge()
 {
     bool bThreeDirs = d->m_dirC.isValid();
     d->setMergeOperation(currentIndex(), bThreeDirs ? eMergeABCToDest : eMergeABToDest);
 }
 void DirectoryMergeWindow::slotCurrentDelete() { d->setMergeOperation(currentIndex(), eDeleteFromDest); }
 // Sync current item
 void DirectoryMergeWindow::slotCurrentCopyAToB() { d->setMergeOperation(currentIndex(), eCopyAToB); }
 void DirectoryMergeWindow::slotCurrentCopyBToA() { d->setMergeOperation(currentIndex(), eCopyBToA); }
 void DirectoryMergeWindow::slotCurrentDeleteA() { d->setMergeOperation(currentIndex(), eDeleteA); }
 void DirectoryMergeWindow::slotCurrentDeleteB() { d->setMergeOperation(currentIndex(), eDeleteB); }
 void DirectoryMergeWindow::slotCurrentDeleteAAndB() { d->setMergeOperation(currentIndex(), eDeleteAB); }
 void DirectoryMergeWindow::slotCurrentMergeToA() { d->setMergeOperation(currentIndex(), eMergeToA); }
 void DirectoryMergeWindow::slotCurrentMergeToB() { d->setMergeOperation(currentIndex(), eMergeToB); }
 void DirectoryMergeWindow::slotCurrentMergeToAAndB() { d->setMergeOperation(currentIndex(), eMergeToAB); }
 
 void DirectoryMergeWindow::keyPressEvent(QKeyEvent* e)
 {
     if((e->QInputEvent::modifiers() & Qt::ControlModifier) != 0)
     {
         bool bThreeDirs = d->m_dirC.isValid();
 
         MergeFileInfos* pMFI = d->getMFI(currentIndex());
 
         if(pMFI == nullptr)
             return;
         bool bMergeMode = bThreeDirs || !d->m_bSyncMode;
         bool bFTConflict = pMFI == nullptr ? false : conflictingFileTypes(*pMFI);
 
         if(bMergeMode)
         {
             switch(e->key())
             {
             case Qt::Key_1:
                 if(pMFI->existsInA()) {
                     slotCurrentChooseA();
                 }
                 return;
             case Qt::Key_2:
                 if(pMFI->existsInB()) {
                     slotCurrentChooseB();
                 }
                 return;
             case Qt::Key_3:
                 if(pMFI->existsInC()) {
                     slotCurrentChooseC();
                 }
                 return;
             case Qt::Key_Space:
                 slotCurrentDoNothing();
                 return;
             case Qt::Key_4:
                 if(!bFTConflict) {
                     slotCurrentMerge();
                 }
                 return;
             case Qt::Key_Delete:
                 slotCurrentDelete();
                 return;
             default:
                 break;
             }
         }
         else
         {
             switch(e->key())
             {
             case Qt::Key_1:
                 if(pMFI->existsInA()) {
                     slotCurrentCopyAToB();
                 }
                 return;
             case Qt::Key_2:
                 if(pMFI->existsInB()) {
                     slotCurrentCopyBToA();
                 }
                 return;
             case Qt::Key_Space:
                 slotCurrentDoNothing();
                 return;
             case Qt::Key_4:
                 if(!bFTConflict) {
                     slotCurrentMergeToAAndB();
                 }
                 return;
             case Qt::Key_Delete:
                 if(pMFI->existsInA() && pMFI->existsInB())
                     slotCurrentDeleteAAndB();
                 else if(pMFI->existsInA())
                     slotCurrentDeleteA();
                 else if(pMFI->existsInB())
                     slotCurrentDeleteB();
                 return;
             default:
                 break;
             }
         }
     }
     else if(e->key() == Qt::Key_Return || e->key() == Qt::Key_Enter)
     {
         onDoubleClick(currentIndex());
         return;
     }
 
     QTreeView::keyPressEvent(e);
 }
 
 void DirectoryMergeWindow::focusInEvent(QFocusEvent*)
 {
     emit updateAvailabilities();
 }
 void DirectoryMergeWindow::focusOutEvent(QFocusEvent*)
 {
     emit updateAvailabilities();
 }
 
 void DirectoryMergeWindow::Data::setAllMergeOperations(e_MergeOperation eDefaultOperation)
 {
     if(KMessageBox::Yes == KMessageBox::warningYesNo(q,
                                                      i18n("This affects all merge operations."),
                                                      i18n("Changing All Merge Operations"),
                                                      KStandardGuiItem::cont(),
                                                      KStandardGuiItem::cancel()))
     {
         for(int i = 0; i < rowCount(); ++i)
         {
             calcSuggestedOperation(index(i, 0, QModelIndex()), eDefaultOperation);
         }
     }
 }
 
 void DirectoryMergeWindow::Data::compareFilesAndCalcAges(MergeFileInfos& mfi)
 {
     std::map<QDateTime, int> dateMap;
 
     if(mfi.existsInA())
     {
         dateMap[mfi.m_pFileInfoA->lastModified()] = 0;
     }
     if(mfi.existsInB())
     {
         dateMap[mfi.m_pFileInfoB->lastModified()] = 1;
     }
     if(mfi.existsInC())
     {
         dateMap[mfi.m_pFileInfoC->lastModified()] = 2;
     }
 
     if(m_pOptions->m_bDmFullAnalysis)
     {
         if((mfi.existsInA() && mfi.dirA()) || (mfi.existsInB() && mfi.dirB()) || (mfi.existsInC() && mfi.dirC()))
         {
             // If any input is a directory, don't start any comparison.
             mfi.m_bEqualAB = mfi.existsInA() && mfi.existsInB();
             mfi.m_bEqualAC = mfi.existsInA() && mfi.existsInC();
             mfi.m_bEqualBC = mfi.existsInB() && mfi.existsInC();
         }
         else
         {
             emit q->startDiffMerge(
                 mfi.existsInA() ? mfi.m_pFileInfoA->absoluteFilePath() : QString(""),
                 mfi.existsInB() ? mfi.m_pFileInfoB->absoluteFilePath() : QString(""),
                 mfi.existsInC() ? mfi.m_pFileInfoC->absoluteFilePath() : QString(""),
                 "",
                 "", "", "", &mfi.m_totalDiffStatus);
             int nofNonwhiteConflicts = mfi.m_totalDiffStatus.nofUnsolvedConflicts +
                                        mfi.m_totalDiffStatus.nofSolvedConflicts - mfi.m_totalDiffStatus.nofWhitespaceConflicts;
 
             if(m_pOptions->m_bDmWhiteSpaceEqual && nofNonwhiteConflicts == 0)
             {
                 mfi.m_bEqualAB = mfi.existsInA() && mfi.existsInB();
                 mfi.m_bEqualAC = mfi.existsInA() && mfi.existsInC();
                 mfi.m_bEqualBC = mfi.existsInB() && mfi.existsInC();
             }
             else
             {
                 mfi.m_bEqualAB = mfi.m_totalDiffStatus.bBinaryAEqB;
                 mfi.m_bEqualBC = mfi.m_totalDiffStatus.bBinaryBEqC;
                 mfi.m_bEqualAC = mfi.m_totalDiffStatus.bBinaryAEqC;
             }
         }
     }
     else
     {
         bool bError;
         QString eqStatus;
         if(mfi.existsInA() && mfi.existsInB())
         {
             if(mfi.dirA())
                 mfi.m_bEqualAB = true;
             else
                 mfi.m_bEqualAB = fastFileComparison(*mfi.m_pFileInfoA, *mfi.m_pFileInfoB, bError, eqStatus);
         }
         if(mfi.existsInA() && mfi.existsInC())
         {
             if(mfi.dirA())
                 mfi.m_bEqualAC = true;
             else
                 mfi.m_bEqualAC = fastFileComparison(*mfi.m_pFileInfoA, *mfi.m_pFileInfoC, bError, eqStatus);
         }
         if(mfi.existsInB() && mfi.existsInC())
         {
             if(mfi.m_bEqualAB && mfi.m_bEqualAC)
                 mfi.m_bEqualBC = true;
             else
             {
                 if(mfi.dirB())
                     mfi.m_bEqualBC = true;
                 else
                     mfi.m_bEqualBC = fastFileComparison(*mfi.m_pFileInfoB, *mfi.m_pFileInfoC, bError, eqStatus);
             }
         }
     }
 
     if(mfi.isLinkA() != mfi.isLinkB()) mfi.m_bEqualAB = false;
     if(mfi.isLinkA() != mfi.isLinkC()) mfi.m_bEqualAC = false;
     if(mfi.isLinkB() != mfi.isLinkC()) mfi.m_bEqualBC = false;
 
     if(mfi.dirA() != mfi.dirB()) mfi.m_bEqualAB = false;
     if(mfi.dirA() != mfi.dirC()) mfi.m_bEqualAC = false;
     if(mfi.dirB() != mfi.dirC()) mfi.m_bEqualBC = false;
 
     Q_ASSERT(eNew == 0 && eMiddle == 1 && eOld == 2);
 
     // The map automatically sorts the keys.
     int age = eNew;
     std::map<QDateTime, int>::reverse_iterator i;
     for(i = dateMap.rbegin(); i != dateMap.rend(); ++i)
     {
         int n = i->second;
         if(n == 0 && mfi.m_ageA == eNotThere)
         {
             mfi.m_ageA = (e_Age)age;
             ++age;
             if(mfi.m_bEqualAB) {
                 mfi.m_ageB = mfi.m_ageA;
                 ++age;
             }
             if(mfi.m_bEqualAC) {
                 mfi.m_ageC = mfi.m_ageA;
                 ++age;
             }
         }
         else if(n == 1 && mfi.m_ageB == eNotThere)
         {
             mfi.m_ageB = (e_Age)age;
             ++age;
             if(mfi.m_bEqualAB) {
                 mfi.m_ageA = mfi.m_ageB;
                 ++age;
             }
             if(mfi.m_bEqualBC) {
                 mfi.m_ageC = mfi.m_ageB;
                 ++age;
             }
         }
         else if(n == 2 && mfi.m_ageC == eNotThere)
         {
             mfi.m_ageC = (e_Age)age;
             ++age;
             if(mfi.m_bEqualAC) {
                 mfi.m_ageA = mfi.m_ageC;
                 ++age;
             }
             if(mfi.m_bEqualBC) {
                 mfi.m_ageB = mfi.m_ageC;
                 ++age;
             }
         }
     }
 
     // The checks below are necessary when the dates of the file are equal but the
     // files are not. One wouldn't expect this to happen, yet it happens sometimes.
     if(mfi.existsInC() && mfi.m_ageC == eNotThere)
     {
         mfi.m_ageC = (e_Age)age;
         ++age;
         mfi.m_bConflictingAges = true;
     }
     if(mfi.existsInB() && mfi.m_ageB == eNotThere)
     {
         mfi.m_ageB = (e_Age)age;
         ++age;
         mfi.m_bConflictingAges = true;
     }
     if(mfi.existsInA() && mfi.m_ageA == eNotThere)
     {
         mfi.m_ageA = (e_Age)age;
         ++age;
         mfi.m_bConflictingAges = true;
     }
 
     if(mfi.m_ageA != eOld && mfi.m_ageB != eOld && mfi.m_ageC != eOld)
     {
         if(mfi.m_ageA == eMiddle) mfi.m_ageA = eOld;
         if(mfi.m_ageB == eMiddle) mfi.m_ageB = eOld;
         if(mfi.m_ageC == eMiddle) mfi.m_ageC = eOld;
     }
 }
 
 static QPixmap* s_pm_dir;
 static QPixmap* s_pm_file;
 
 static QPixmap* pmNotThere;
 static QPixmap* pmNew;
 static QPixmap* pmOld;
 static QPixmap* pmMiddle;
 
 static QPixmap* pmLink;
 
 static QPixmap* pmDirLink;
 static QPixmap* pmFileLink;
 
 static QPixmap* pmNewLink;
 static QPixmap* pmOldLink;
 static QPixmap* pmMiddleLink;
 
 static QPixmap* pmNewDir;
 static QPixmap* pmMiddleDir;
 static QPixmap* pmOldDir;
 
 static QPixmap* pmNewDirLink;
 static QPixmap* pmMiddleDirLink;
 static QPixmap* pmOldDirLink;
 
 static QPixmap colorToPixmap(QColor c)
 {
     QPixmap pm(16, 16);
     QPainter p(&pm);
     p.setPen(Qt::black);
     p.setBrush(c);
     p.drawRect(0, 0, pm.width(), pm.height());
     return pm;
 }
 
 static void initPixmaps(QColor newest, QColor oldest, QColor middle, QColor notThere)
 {
     if(pmNew == nullptr)
     {
         pmNotThere = new QPixmap;
         pmNew = new QPixmap;
         pmOld = new QPixmap;
         pmMiddle = new QPixmap;
 
 #include "xpm/link_arrow.xpm"
         pmLink = new QPixmap(link_arrow);
 
         pmDirLink = new QPixmap;
         pmFileLink = new QPixmap;
 
         pmNewLink = new QPixmap;
         pmOldLink = new QPixmap;
         pmMiddleLink = new QPixmap;
 
         pmNewDir = new QPixmap;
         pmMiddleDir = new QPixmap;
         pmOldDir = new QPixmap;
 
         pmNewDirLink = new QPixmap;
         pmMiddleDirLink = new QPixmap;
         pmOldDirLink = new QPixmap;
     }
 
     *pmNotThere = colorToPixmap(notThere);
     *pmNew = colorToPixmap(newest);
     *pmOld = colorToPixmap(oldest);
     *pmMiddle = colorToPixmap(middle);
 
     *pmDirLink = pixCombiner(s_pm_dir, pmLink);
     *pmFileLink = pixCombiner(s_pm_file, pmLink);
 
     *pmNewLink = pixCombiner(pmNew, pmLink);
     *pmOldLink = pixCombiner(pmOld, pmLink);
     *pmMiddleLink = pixCombiner(pmMiddle, pmLink);
 
     *pmNewDir = pixCombiner2(pmNew, s_pm_dir);
     *pmMiddleDir = pixCombiner2(pmMiddle, s_pm_dir);
     *pmOldDir = pixCombiner2(pmOld, s_pm_dir);
 
     *pmNewDirLink = pixCombiner(pmNewDir, pmLink);
     *pmMiddleDirLink = pixCombiner(pmMiddleDir, pmLink);
     *pmOldDirLink = pixCombiner(pmOldDir, pmLink);
 }
 
 static QPixmap getOnePixmap(e_Age eAge, bool bLink, bool bDir)
 {
     static QPixmap* ageToPm[] = {pmNew, pmMiddle, pmOld, pmNotThere, s_pm_file};
     static QPixmap* ageToPmLink[] = {pmNewLink, pmMiddleLink, pmOldLink, pmNotThere, pmFileLink};
     static QPixmap* ageToPmDir[] = {pmNewDir, pmMiddleDir, pmOldDir, pmNotThere, s_pm_dir};
     static QPixmap* ageToPmDirLink[] = {pmNewDirLink, pmMiddleDirLink, pmOldDirLink, pmNotThere, pmDirLink};
 
     QPixmap** ppPm = bDir ? (bLink ? ageToPmDirLink : ageToPmDir) : (bLink ? ageToPmLink : ageToPm);
 
     return *ppPm[eAge];
 }
 
 static void setPixmaps(MergeFileInfos& mfi, bool)
 {
     if(mfi.dirA() || mfi.dirB() || mfi.dirC())
     {
         mfi.m_ageA = eNotThere;
         mfi.m_ageB = eNotThere;
         mfi.m_ageC = eNotThere;
         int age = eNew;
         if(mfi.existsInC())
         {
             mfi.m_ageC = (e_Age)age;
             if(mfi.m_bEqualAC) mfi.m_ageA = (e_Age)age;
             if(mfi.m_bEqualBC) mfi.m_ageB = (e_Age)age;
             ++age;
         }
         if(mfi.existsInB() && mfi.m_ageB == eNotThere)
         {
             mfi.m_ageB = (e_Age)age;
             if(mfi.m_bEqualAB) mfi.m_ageA = (e_Age)age;
             ++age;
         }
         if(mfi.existsInA() && mfi.m_ageA == eNotThere)
         {
             mfi.m_ageA = (e_Age)age;
         }
         if(mfi.m_ageA != eOld && mfi.m_ageB != eOld && mfi.m_ageC != eOld)
         {
             if(mfi.m_ageA == eMiddle) mfi.m_ageA = eOld;
             if(mfi.m_ageB == eMiddle) mfi.m_ageB = eOld;
             if(mfi.m_ageC == eMiddle) mfi.m_ageC = eOld;
         }
     }
 }
 
 static QModelIndex nextSibling(const QModelIndex& mi)
 {
     QModelIndex miParent = mi.parent();
     int currentIdx = mi.row();
     if(currentIdx + 1 < mi.model()->rowCount(miParent))
         return mi.model()->index(mi.row() + 1, 0, miParent); // next child of parent
     return QModelIndex();
 }
 
 // Iterate through the complete tree. Start by specifying QListView::firstChild().
 QModelIndex DirectoryMergeWindow::Data::treeIterator(QModelIndex mi, bool bVisitChildren, bool bFindInvisible)
 {
     if(mi.isValid())
     {
         do
         {
             if(bVisitChildren && mi.model()->rowCount(mi) != 0)
                 mi = mi.model()->index(0, 0, mi);
             else
             {
                 QModelIndex miNextSibling = nextSibling(mi);
                 if(miNextSibling.isValid())
                     mi = miNextSibling;
                 else
                 {
                     mi = mi.parent();
                     while(mi.isValid())
                     {
                         QModelIndex miNextSibling = nextSibling(mi);
                         if(miNextSibling.isValid())
                         {
                             mi = miNextSibling;
                             break;
                         }
                         else
                         {
                             mi = mi.parent();
                         }
                     }
                 }
             }
         } while(mi.isValid() && q->isRowHidden(mi.row(), mi.parent()) && !bFindInvisible);
     }
     return mi;
 }
 
 void DirectoryMergeWindow::Data::prepareListView(ProgressProxy& pp)
 {
     static bool bFirstTime = true;
     if(bFirstTime)
     {
 #include "xpm/file.xpm"
 #include "xpm/folder.xpm"
         // FIXME specify correct icon loader group
         s_pm_dir = new QPixmap(m_pIconLoader->loadIcon("folder", KIconLoader::NoGroup, KIconLoader::Small));
         if(s_pm_dir->size() != QSize(16, 16))
         {
             delete s_pm_dir;
             s_pm_dir = new QPixmap(folder_pm);
         }
         s_pm_file = new QPixmap(file_pm);
         bFirstTime = false;
     }
 
     //TODO   clear();
     initPixmaps(m_pOptions->m_newestFileColor, m_pOptions->m_oldestFileColor,
                 m_pOptions->m_midAgeFileColor, m_pOptions->m_missingFileColor);
 
     q->setRootIsDecorated(true);
 
     bool bCheckC = m_dirC.isValid();
 
     t_fileMergeMap::iterator j;
     int nrOfFiles = m_fileMergeMap.size();
     int currentIdx = 1;
     QTime t;
     t.start();
     pp.setMaxNofSteps(nrOfFiles);
     for(j = m_fileMergeMap.begin(); j != m_fileMergeMap.end(); ++j)
     {
         MergeFileInfos& mfi = j.value();
 
         // const QString& fileName = j->first;
         const QString& fileName = mfi.subPath();
 
         pp.setInformation(
             i18n("Processing %1 / %2\n%3", currentIdx, nrOfFiles, fileName), currentIdx, false);
         if(pp.wasCancelled()) break;
         ++currentIdx;
 
         // The comparisons and calculations for each file take place here.
         compareFilesAndCalcAges(mfi);
 
         // Get dirname from fileName: Search for "/" from end:
         int pos = fileName.lastIndexOf('/');
         QString dirPart;
         QString filePart;
         if(pos == -1)
         {
             // Top dir
             filePart = fileName;
         }
         else
         {
             dirPart = fileName.left(pos);
             filePart = fileName.mid(pos + 1);
         }
         if(dirPart.isEmpty()) // Top level
         {
             m_pRoot->m_children.push_back(&mfi); //new DirMergeItem( this, filePart, &mfi );
             mfi.m_pParent = m_pRoot;
         }
         else
         {
             FileAccess* pFA = mfi.m_pFileInfoA ? mfi.m_pFileInfoA : mfi.m_pFileInfoB ? mfi.m_pFileInfoB : mfi.m_pFileInfoC;
             MergeFileInfos& dirMfi = pFA->parent() ? m_fileMergeMap[FileKey(*pFA->parent())] : *m_pRoot; // parent
 
             dirMfi.m_children.push_back(&mfi); //new DirMergeItem( dirMfi.m_pDMI, filePart, &mfi );
             mfi.m_pParent = &dirMfi;
 
             //   // Equality for parent dirs is set in updateFileVisibilities()
         }
 
         setPixmaps(mfi, bCheckC);
     }
     beginResetModel();
     endResetModel();
 }
 
 static bool conflictingFileTypes(MergeFileInfos& mfi)
 {
     // Now check if file/dir-types fit.
     if(mfi.isLinkA() || mfi.isLinkB() || mfi.isLinkC())
     {
         if((mfi.existsInA() && !mfi.isLinkA()) ||
            (mfi.existsInB() && !mfi.isLinkB()) ||
            (mfi.existsInC() && !mfi.isLinkC()))
         {
             return true;
         }
     }
 
     if(mfi.dirA() || mfi.dirB() || mfi.dirC())
     {
         if((mfi.existsInA() && !mfi.dirA()) ||
            (mfi.existsInB() && !mfi.dirB()) ||
            (mfi.existsInC() && !mfi.dirC()))
         {
             return true;
         }
     }
     return false;
 }
 
 void DirectoryMergeWindow::Data::calcSuggestedOperation(const QModelIndex& mi, e_MergeOperation eDefaultMergeOp)
 {
     MergeFileInfos* pMFI = getMFI(mi);
     if(pMFI == nullptr)
         return;
     MergeFileInfos& mfi = *pMFI;
     bool bCheckC = m_dirC.isValid();
     bool bCopyNewer = m_pOptions->m_bDmCopyNewer;
     bool bOtherDest = !((m_dirDestInternal.absoluteFilePath() == m_dirA.absoluteFilePath()) ||
                         (m_dirDestInternal.absoluteFilePath() == m_dirB.absoluteFilePath()) ||
                         (bCheckC && m_dirDestInternal.absoluteFilePath() == m_dirC.absoluteFilePath()));
 
     if(eDefaultMergeOp == eMergeABCToDest && !bCheckC) {
         eDefaultMergeOp = eMergeABToDest;
     }
     if(eDefaultMergeOp == eMergeToAB && bCheckC) {
         Q_ASSERT(true);
     }
 
     if(eDefaultMergeOp == eMergeToA || eDefaultMergeOp == eMergeToB ||
        eDefaultMergeOp == eMergeABCToDest || eDefaultMergeOp == eMergeABToDest || eDefaultMergeOp == eMergeToAB)
     {
         if(!bCheckC)
         {
             if(mfi.m_bEqualAB)
             {
                 setMergeOperation(mi, bOtherDest ? eCopyBToDest : eNoOperation);
             }
             else if(mfi.existsInA() && mfi.existsInB())
             {
                 if(!bCopyNewer || mfi.dirA())
                     setMergeOperation(mi, eDefaultMergeOp);
                 else if(bCopyNewer && mfi.m_bConflictingAges)
                 {
                     setMergeOperation(mi, eConflictingAges);
                 }
                 else
                 {
                     if(mfi.m_ageA == eNew)
                         setMergeOperation(mi, eDefaultMergeOp == eMergeToAB ? eCopyAToB : eCopyAToDest);
                     else
                         setMergeOperation(mi, eDefaultMergeOp == eMergeToAB ? eCopyBToA : eCopyBToDest);
                 }
             }
             else if(!mfi.existsInA() && mfi.existsInB())
             {
                 if(eDefaultMergeOp == eMergeABToDest)
                     setMergeOperation(mi, eCopyBToDest);
                 else if(eDefaultMergeOp == eMergeToB)
                     setMergeOperation(mi, eNoOperation);
                 else
                     setMergeOperation(mi, eCopyBToA);
             }
             else if(mfi.existsInA() && !mfi.existsInB())
             {
                 if(eDefaultMergeOp == eMergeABToDest)
                     setMergeOperation(mi, eCopyAToDest);
                 else if(eDefaultMergeOp == eMergeToA)
                     setMergeOperation(mi, eNoOperation);
                 else
                     setMergeOperation(mi, eCopyAToB);
             }
             else //if ( !mfi.existsInA() && !mfi.existsInB() )
             {
                 setMergeOperation(mi, eNoOperation);
             }
         }
         else
         {
             if(mfi.m_bEqualAB && mfi.m_bEqualAC)
             {
                 setMergeOperation(mi, bOtherDest ? eCopyCToDest : eNoOperation);
             }
             else if(mfi.existsInA() && mfi.existsInB() && mfi.existsInC())
             {
                 if(mfi.m_bEqualAB)
                     setMergeOperation(mi, eCopyCToDest);
                 else if(mfi.m_bEqualAC)
                     setMergeOperation(mi, eCopyBToDest);
                 else if(mfi.m_bEqualBC)
                     setMergeOperation(mi, eCopyCToDest);
                 else
                     setMergeOperation(mi, eMergeABCToDest);
             }
             else if(mfi.existsInA() && mfi.existsInB() && !mfi.existsInC())
             {
                 if(mfi.m_bEqualAB)
                     setMergeOperation(mi, eDeleteFromDest);
                 else
                     setMergeOperation(mi, eChangedAndDeleted);
             }
             else if(mfi.existsInA() && !mfi.existsInB() && mfi.existsInC())
             {
                 if(mfi.m_bEqualAC)
                     setMergeOperation(mi, eDeleteFromDest);
                 else
                     setMergeOperation(mi, eChangedAndDeleted);
             }
             else if(!mfi.existsInA() && mfi.existsInB() && mfi.existsInC())
             {
                 if(mfi.m_bEqualBC)
                     setMergeOperation(mi, eCopyCToDest);
                 else
                     setMergeOperation(mi, eMergeABCToDest);
             }
             else if(!mfi.existsInA() && !mfi.existsInB() && mfi.existsInC())
             {
                 setMergeOperation(mi, eCopyCToDest);
             }
             else if(!mfi.existsInA() && mfi.existsInB() && !mfi.existsInC())
             {
                 setMergeOperation(mi, eCopyBToDest);
             }
             else if(mfi.existsInA() && !mfi.existsInB() && !mfi.existsInC())
             {
                 setMergeOperation(mi, eDeleteFromDest);
             }
             else //if ( !mfi.existsInA() && !mfi.existsInB() && !mfi.existsInC() )
             {
                 setMergeOperation(mi, eNoOperation);
             }
         }
 
         // Now check if file/dir-types fit.
         if(conflictingFileTypes(mfi))
         {
             setMergeOperation(mi, eConflictingFileTypes);
         }
     }
     else
     {
         e_MergeOperation eMO = eDefaultMergeOp;
         switch(eDefaultMergeOp)
         {
         case eConflictingFileTypes:
         case eChangedAndDeleted:
         case eConflictingAges:
         case eDeleteA:
         case eDeleteB:
         case eDeleteAB:
         case eDeleteFromDest:
         case eNoOperation:
             break;
         case eCopyAToB:
             if(!mfi.existsInA()) {
                 eMO = eDeleteB;
             }
             break;
         case eCopyBToA:
             if(!mfi.existsInB()) {
                 eMO = eDeleteA;
             }
             break;
         case eCopyAToDest:
             if(!mfi.existsInA()) {
                 eMO = eDeleteFromDest;
             }
             break;
         case eCopyBToDest:
             if(!mfi.existsInB()) {
                 eMO = eDeleteFromDest;
             }
             break;
         case eCopyCToDest:
             if(!mfi.existsInC()) {
                 eMO = eDeleteFromDest;
             }
             break;
 
         case eMergeToA:
         case eMergeToB:
         case eMergeToAB:
         case eMergeABCToDest:
         case eMergeABToDest:
             break;
         default:
             Q_ASSERT(true);
             break;
         }
         setMergeOperation(mi, eMO);
     }
 }
 
 void DirectoryMergeWindow::onDoubleClick(const QModelIndex& mi)
 {
     if(!mi.isValid())
         return;
 
     d->m_bSimulatedMergeStarted = false;
     if(d->m_bDirectoryMerge)
         mergeCurrentFile();
     else
         compareCurrentFile();
 }
 
 void DirectoryMergeWindow::currentChanged(const QModelIndex& current, const QModelIndex& previous)
 {
     QTreeView::currentChanged(current, previous);
     MergeFileInfos* pMFI = d->getMFI(current);
     if(pMFI == nullptr)
         return;
 
     d->m_pDirectoryMergeInfo->setInfo(d->m_dirA, d->m_dirB, d->m_dirC, d->m_dirDestInternal, *pMFI);
 }
 
 void DirectoryMergeWindow::mousePressEvent(QMouseEvent* e)
 {
     QTreeView::mousePressEvent(e);
     QModelIndex mi = indexAt(e->pos());
     int c = mi.column();
     QPoint p = e->globalPos();
     MergeFileInfos* pMFI = d->getMFI(mi);
     if(pMFI == nullptr)
         return;
     MergeFileInfos& mfi = *pMFI;
 
     if(c == s_OpCol)
     {
         bool bThreeDirs = d->m_dirC.isValid();
 
         QMenu m(this);
         if(bThreeDirs)
         {
             m.addAction(d->m_pDirCurrentDoNothing);
             int count = 0;
             if(mfi.existsInA()) {
                 m.addAction(d->m_pDirCurrentChooseA);
                 ++count;
             }
             if(mfi.existsInB()) {
                 m.addAction(d->m_pDirCurrentChooseB);
                 ++count;
             }
             if(mfi.existsInC()) {
                 m.addAction(d->m_pDirCurrentChooseC);
                 ++count;
             }
             if(!conflictingFileTypes(mfi) && count > 1) m.addAction(d->m_pDirCurrentMerge);
             m.addAction(d->m_pDirCurrentDelete);
         }
         else if(d->m_bSyncMode)
         {
             m.addAction(d->m_pDirCurrentSyncDoNothing);
             if(mfi.existsInA()) m.addAction(d->m_pDirCurrentSyncCopyAToB);
             if(mfi.existsInB()) m.addAction(d->m_pDirCurrentSyncCopyBToA);
             if(mfi.existsInA()) m.addAction(d->m_pDirCurrentSyncDeleteA);
             if(mfi.existsInB()) m.addAction(d->m_pDirCurrentSyncDeleteB);
             if(mfi.existsInA() && mfi.existsInB())
             {
                 m.addAction(d->m_pDirCurrentSyncDeleteAAndB);
                 if(!conflictingFileTypes(mfi))
                 {
                     m.addAction(d->m_pDirCurrentSyncMergeToA);
                     m.addAction(d->m_pDirCurrentSyncMergeToB);
                     m.addAction(d->m_pDirCurrentSyncMergeToAAndB);
                 }
             }
         }
         else
         {
             m.addAction(d->m_pDirCurrentDoNothing);
             if(mfi.existsInA()) {
                 m.addAction(d->m_pDirCurrentChooseA);
             }
             if(mfi.existsInB()) {
                 m.addAction(d->m_pDirCurrentChooseB);
             }
             if(!conflictingFileTypes(mfi) && mfi.existsInA() && mfi.existsInB()) m.addAction(d->m_pDirCurrentMerge);
             m.addAction(d->m_pDirCurrentDelete);
         }
 
         m.exec(p);
     }
     else if(c == s_ACol || c == s_BCol || c == s_CCol)
     {
         QString itemPath;
         if(c == s_ACol && mfi.existsInA()) {
             itemPath = d->fullNameA(mfi);
         }
         else if(c == s_BCol && mfi.existsInB())
         {
             itemPath = d->fullNameB(mfi);
         }
         else if(c == s_CCol && mfi.existsInC())
         {
             itemPath = d->fullNameC(mfi);
         }
 
         if(!itemPath.isEmpty())
         {
             d->selectItemAndColumn(mi, e->button() == Qt::RightButton);
         }
     }
 }
 
 void DirectoryMergeWindow::contextMenuEvent(QContextMenuEvent* e)
 {
     QModelIndex mi = indexAt(e->pos());
     int c = mi.column();
     QPoint p = e->globalPos();
 
     MergeFileInfos* pMFI = d->getMFI(mi);
     if(pMFI == nullptr)
         return;
     if(c == s_ACol || c == s_BCol || c == s_CCol)
     {
         QString itemPath;
         if(c == s_ACol && pMFI->existsInA()) {
             itemPath = d->fullNameA(*pMFI);
         }
         else if(c == s_BCol && pMFI->existsInB())
         {
             itemPath = d->fullNameB(*pMFI);
         }
         else if(c == s_CCol && pMFI->existsInC())
         {
             itemPath = d->fullNameC(*pMFI);
         }
 
         if(!itemPath.isEmpty())
         {
             d->selectItemAndColumn(mi, true);
             QMenu m(this);
             m.addAction(d->m_pDirCompareExplicit);
             m.addAction(d->m_pDirMergeExplicit);
 
             // TODO: Do we need the special Windows implementation?! -- Disabled for now.
 //#ifndef Q_OS_WIN
             m.exec(p);
 // #else
 //             void showShellContextMenu(const QString&, QPoint, QWidget*, QMenu*);
 //             showShellContextMenu(itemPath, p, this, &m);
 // #endif
         }
     }
 }
 
 QString DirectoryMergeWindow::Data::getFileName(const QModelIndex& mi)
 {
     MergeFileInfos* pMFI = getMFI(mi);
     if(pMFI != nullptr)
     {
         return mi.column() == s_ACol ? pMFI->m_pFileInfoA->absoluteFilePath() : mi.column() == s_BCol ? pMFI->m_pFileInfoB->absoluteFilePath() : mi.column() == s_CCol ? pMFI->m_pFileInfoC->absoluteFilePath() : QString("");
     }
     return "";
 }
 
 bool DirectoryMergeWindow::Data::isDir(const QModelIndex& mi)
 {
     MergeFileInfos* pMFI = getMFI(mi);
     if(pMFI != nullptr)
     {
         return mi.column() == s_ACol ? pMFI->dirA() : mi.column() == s_BCol ? pMFI->dirB() : pMFI->dirC();
     }
     return false;
 }
 
 void DirectoryMergeWindow::Data::selectItemAndColumn(const QModelIndex& mi, bool bContextMenu)
 {
     if(bContextMenu && (mi == m_selection1Index || mi == m_selection2Index || mi == m_selection3Index))
         return;
 
     QModelIndex old1 = m_selection1Index;
     QModelIndex old2 = m_selection2Index;
     QModelIndex old3 = m_selection3Index;
 
     bool bReset = false;
 
     if(m_selection1Index.isValid())
     {
         if(isDir(m_selection1Index) != isDir(mi))
             bReset = true;
     }
 
     if(bReset || m_selection3Index.isValid() || mi == m_selection1Index || mi == m_selection2Index || mi == m_selection3Index)
     {
         // restart
         m_selection1Index = QModelIndex();
         m_selection2Index = QModelIndex();
         m_selection3Index = QModelIndex();
     }
     else if(!m_selection1Index.isValid())
     {
         m_selection1Index = mi;
         m_selection2Index = QModelIndex();
         m_selection3Index = QModelIndex();
     }
     else if(!m_selection2Index.isValid())
     {
         m_selection2Index = mi;
         m_selection3Index = QModelIndex();
     }
     else if(!m_selection3Index.isValid())
     {
         m_selection3Index = mi;
     }
     if(old1.isValid()) 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 q->updateAvailabilities();
 }
 
 //TODO
 //void DirMergeItem::init(MergeFileInfos* pMFI)
 //{
 //   pMFI->m_pDMI = this;
 //   m_pMFI = pMFI;
 //   TotalDiffStatus& tds = pMFI->m_totalDiffStatus;
 //   if ( m_pMFI->dirA() || m_pMFI->dirB() || m_pMFI->dirC() )
 //   {
 //   }
 //   else
 //   {
 //      setText( s_UnsolvedCol, QString::number( tds.nofUnsolvedConflicts ) );
 //      setText( s_SolvedCol,   QString::number( tds.nofSolvedConflicts ) );
 //      setText( s_NonWhiteCol, QString::number( tds.nofUnsolvedConflicts + tds.nofSolvedConflicts - tds.nofWhitespaceConflicts ) );
 //      setText( s_WhiteCol,    QString::number( tds.nofWhitespaceConflicts ) );
 //   }
 //   setSizeHint( s_ACol, QSize(17,17) ); // Iconsize
 //   setSizeHint( s_BCol, QSize(17,17) ); // Iconsize
 //   setSizeHint( s_CCol, QSize(17,17) ); // Iconsize
 //}
 
 class MfiCompare
 {
     Qt::SortOrder mOrder;
 
   public:
     explicit MfiCompare(Qt::SortOrder order)
     {
         mOrder = order;
     }
     bool operator()(MergeFileInfos* pMFI1, MergeFileInfos* pMFI2)
     {
         bool bDir1 = pMFI1->dirA() || pMFI1->dirB() || pMFI1->dirC();
         bool bDir2 = pMFI2->dirA() || pMFI2->dirB() || pMFI2->dirC();
         if(bDir1 == bDir2) {
             if(mOrder == Qt::AscendingOrder)
             {
                 return pMFI1->fileName().compare(pMFI2->fileName(), Qt::CaseInsensitive) < 0;
             }
             else
             {
                 return pMFI1->fileName().compare(pMFI2->fileName(), Qt::CaseInsensitive) > 0;
             }
         }
         else
             return bDir1;
     }
 };
 
 static void sortHelper(MergeFileInfos* pMFI, Qt::SortOrder order)
 {
     std::sort(pMFI->m_children.begin(), pMFI->m_children.end(), MfiCompare(order));
 
     for(int i = 0; i < pMFI->m_children.count(); ++i)
         sortHelper(pMFI->m_children[i], order);
 }
 
 void DirectoryMergeWindow::Data::sort(int column, Qt::SortOrder order)
 {
     Q_UNUSED(column);
     beginResetModel();
     sortHelper(m_pRoot, order);
     endResetModel();
 }
 
 //
 //DirMergeItem::~DirMergeItem()
 //{
 //   m_pMFI->m_pDMI = 0;
 //}
 
 void DirectoryMergeWindow::Data::setMergeOperation(const QModelIndex& mi, e_MergeOperation eMOp, bool bRecursive)
 {
     MergeFileInfos* pMFI = getMFI(mi);
     if(pMFI == nullptr)
         return;
 
     MergeFileInfos& mfi = *pMFI;
 
     if(eMOp != mfi.m_eMergeOperation)
     {
         mfi.m_bOperationComplete = false;
         setOpStatus(mi, eOpStatusNone);
     }
 
     mfi.m_eMergeOperation = eMOp;
     if(bRecursive)
     {
         e_MergeOperation eChildrenMergeOp = mfi.m_eMergeOperation;
         if(eChildrenMergeOp == eConflictingFileTypes) eChildrenMergeOp = eMergeABCToDest;
         for(int childIdx = 0; childIdx < mfi.m_children.count(); ++childIdx)
         {
             calcSuggestedOperation(index(childIdx, 0, mi), eChildrenMergeOp);
         }
     }
 }
 
 void DirectoryMergeWindow::compareCurrentFile()
 {
     if(!d->canContinue()) return;
 
     if(d->m_bRealMergeStarted)
     {
         KMessageBox::sorry(this, i18n("This operation is currently not possible."), i18n("Operation Not Possible"));
         return;
     }
 
     if(MergeFileInfos* pMFI = d->getMFI(currentIndex()))
     {
         if(!(pMFI->dirA() || pMFI->dirB() || pMFI->dirC()))
         {
             emit startDiffMerge(
                 pMFI->existsInA() ? pMFI->m_pFileInfoA->absoluteFilePath() : QString(""),
                 pMFI->existsInB() ? pMFI->m_pFileInfoB->absoluteFilePath() : QString(""),
                 pMFI->existsInC() ? pMFI->m_pFileInfoC->absoluteFilePath() : QString(""),
                 "",
                 "", "", "", nullptr);
         }
     }
     emit updateAvailabilities();
 }
 
 void DirectoryMergeWindow::slotCompareExplicitlySelectedFiles()
 {
     if(!d->isDir(d->m_selection1Index) && !d->canContinue()) return;
 
     if(d->m_bRealMergeStarted)
     {
         KMessageBox::sorry(this, i18n("This operation is currently not possible."), i18n("Operation Not Possible"));
         return;
     }
 
     emit startDiffMerge(
         d->getFileName(d->m_selection1Index),
         d->getFileName(d->m_selection2Index),
         d->getFileName(d->m_selection3Index),
         "",
         "", "", "", nullptr);
     d->m_selection1Index = QModelIndex();
     d->m_selection2Index = QModelIndex();
     d->m_selection3Index = QModelIndex();
 
     emit updateAvailabilities();
     update();
 }
 
 void DirectoryMergeWindow::slotMergeExplicitlySelectedFiles()
 {
     if(!d->isDir(d->m_selection1Index) && !d->canContinue()) return;
 
     if(d->m_bRealMergeStarted)
     {
         KMessageBox::sorry(this, i18n("This operation is currently not possible."), i18n("Operation Not Possible"));
         return;
     }
 
     QString fn1 = d->getFileName(d->m_selection1Index);
     QString fn2 = d->getFileName(d->m_selection2Index);
     QString fn3 = d->getFileName(d->m_selection3Index);
 
     emit startDiffMerge(fn1, fn2, fn3,
                         fn3.isEmpty() ? fn2 : fn3,
                         "", "", "", nullptr);
     d->m_selection1Index = QModelIndex();
     d->m_selection2Index = QModelIndex();
     d->m_selection3Index = QModelIndex();
 
     emit updateAvailabilities();
     update();
 }
 
 bool DirectoryMergeWindow::isFileSelected()
 {
     if(MergeFileInfos* pMFI = d->getMFI(currentIndex()))
     {
         return !(pMFI->dirA() || pMFI->dirB() || pMFI->dirC() || conflictingFileTypes(*pMFI));
     }
     return false;
 }
 
 void DirectoryMergeWindow::mergeResultSaved(const QString& fileName)
 {
     QModelIndex mi = (d->m_mergeItemList.empty() || d->m_currentIndexForOperation == d->m_mergeItemList.end())
                          ? QModelIndex()
                          : *d->m_currentIndexForOperation;
 
     MergeFileInfos* pMFI = d->getMFI(mi);
     if(pMFI == nullptr)
     {
         // This can happen if the same file is saved and modified and saved again. Nothing to do then.
         return;
     }
     if(fileName == d->fullNameDest(*pMFI))
     {
         MergeFileInfos& mfi = *pMFI;
         if(mfi.m_eMergeOperation == eMergeToAB)
         {
             bool bSuccess = d->copyFLD(d->fullNameB(mfi), d->fullNameA(mfi));
             if(!bSuccess)
             {
                 KMessageBox::error(this, i18n("An error occurred while copying."));
                 d->m_pStatusInfo->setWindowTitle(i18n("Merge Error"));
                 d->m_pStatusInfo->exec();
                 //if ( m_pStatusInfo->firstChild()!=0 )
                 //   m_pStatusInfo->ensureItemVisible( m_pStatusInfo->last() );
                 d->m_bError = true;
                 d->setOpStatus(mi, eOpStatusError);
                 mfi.m_eMergeOperation = eCopyBToA;
                 return;
             }
         }
         d->setOpStatus(mi, eOpStatusDone);
         pMFI->m_bOperationComplete = true;
         if(d->m_mergeItemList.size() == 1)
         {
             d->m_mergeItemList.clear();
             d->m_bRealMergeStarted = false;
         }
     }
 
     emit updateAvailabilities();
 }
 
 bool DirectoryMergeWindow::Data::canContinue()
 {
     bool bCanContinue = false;
     
     emit q->checkIfCanContinue(&bCanContinue);
     
     if(bCanContinue && !m_bError)
     {
         QModelIndex mi = (m_mergeItemList.empty() || m_currentIndexForOperation == m_mergeItemList.end()) ? QModelIndex() : *m_currentIndexForOperation;
         MergeFileInfos* pMFI = getMFI(mi);
         if(pMFI && !pMFI->m_bOperationComplete)
         {
             setOpStatus(mi, eOpStatusNotSaved);
             pMFI->m_bOperationComplete = true;
             if(m_mergeItemList.size() == 1)
             {
                 m_mergeItemList.clear();
                 m_bRealMergeStarted = false;
             }
         }
     }
     return bCanContinue;
 }
 
 bool DirectoryMergeWindow::Data::executeMergeOperation(MergeFileInfos& mfi, bool& bSingleFileMerge)
 {
     bool bCreateBackups = m_pOptions->m_bDmCreateBakFiles;
     // First decide destname
     QString destName;
     switch(mfi.m_eMergeOperation)
     {
     case eNoOperation:
         break;
     case eDeleteAB:
         break;
     case eMergeToAB: // let the user save in B. In mergeResultSaved() the file will be copied to A.
     case eMergeToB:
     case eDeleteB:
     case eCopyAToB:
         destName = fullNameB(mfi);
         break;
     case eMergeToA:
     case eDeleteA:
     case eCopyBToA:
         destName = fullNameA(mfi);
         break;
     case eMergeABToDest:
     case eMergeABCToDest:
     case eCopyAToDest:
     case eCopyBToDest:
     case eCopyCToDest:
     case eDeleteFromDest:
         destName = fullNameDest(mfi);
         break;
     default:
         KMessageBox::error(q, i18n("Unknown merge operation. (This must never happen!)"));
     }
 
     bool bSuccess = false;
     bSingleFileMerge = false;
     switch(mfi.m_eMergeOperation)
     {
     case eNoOperation:
         bSuccess = true;
         break;
     case eCopyAToDest:
     case eCopyAToB:
         bSuccess = copyFLD(fullNameA(mfi), destName);
         break;
     case eCopyBToDest:
     case eCopyBToA:
         bSuccess = copyFLD(fullNameB(mfi), destName);
         break;
     case eCopyCToDest:
         bSuccess = copyFLD(fullNameC(mfi), destName);
         break;
     case eDeleteFromDest:
     case eDeleteA:
     case eDeleteB:
         bSuccess = deleteFLD(destName, bCreateBackups);
         break;
     case eDeleteAB:
         bSuccess = deleteFLD(fullNameA(mfi), bCreateBackups) &&
                    deleteFLD(fullNameB(mfi), bCreateBackups);
         break;
     case eMergeABToDest:
     case eMergeToA:
     case eMergeToAB:
     case eMergeToB:
         bSuccess = mergeFLD(fullNameA(mfi), fullNameB(mfi), "",
                             destName, bSingleFileMerge);
         break;
     case eMergeABCToDest:
         bSuccess = mergeFLD(
             mfi.existsInA() ? fullNameA(mfi) : QString(""),
             mfi.existsInB() ? fullNameB(mfi) : QString(""),
             mfi.existsInC() ? fullNameC(mfi) : QString(""),
             destName, bSingleFileMerge);
         break;
     default:
         KMessageBox::error(q, i18n("Unknown merge operation."));
     }
 
     return bSuccess;
 }
 
 // Check if the merge can start, and prepare the m_mergeItemList which then contains all
 // items that must be merged.
 void DirectoryMergeWindow::Data::prepareMergeStart(const QModelIndex& miBegin, const QModelIndex& miEnd, bool bVerbose)
 {
     if(bVerbose)
     {
         int status = KMessageBox::warningYesNoCancel(q,
                                                      i18n("The merge is about to begin.\n\n"
                                                           "Choose \"Do it\" if you have read the instructions and know what you are doing.\n"
                                                           "Choosing \"Simulate it\" will tell you what would happen.\n\n"
                                                           "Be aware that this program still has beta status "
                                                           "and there is NO WARRANTY whatsoever! Make backups of your vital data!"),
                                                      i18n("Starting Merge"),
                                                      KGuiItem(i18n("Do It")),
                                                      KGuiItem(i18n("Simulate It")));
         if(status == KMessageBox::Yes)
             m_bRealMergeStarted = true;
         else if(status == KMessageBox::No)
             m_bSimulatedMergeStarted = true;
         else
             return;
     }
     else
     {
         m_bRealMergeStarted = true;
     }
 
     m_mergeItemList.clear();
     if(!miBegin.isValid())
         return;
 
     for(QModelIndex mi = miBegin; mi != miEnd; mi = treeIterator(mi))
     {
         MergeFileInfos* pMFI = getMFI(mi);
         if(pMFI && !pMFI->m_bOperationComplete)
         {
             m_mergeItemList.push_back(mi);
             QString errorText;
             if(pMFI->m_eMergeOperation == eConflictingFileTypes)
             {
                 errorText = i18n("The highlighted item has a different type in the different directories. Select what to do.");
             }
             if(pMFI->m_eMergeOperation == eConflictingAges)
             {
                 errorText = i18n("The modification dates of the file are equal but the files are not. Select what to do.");
             }
             if(pMFI->m_eMergeOperation == eChangedAndDeleted)
             {
                 errorText = i18n("The highlighted item was changed in one directory and deleted in the other. Select what to do.");
             }
             if(!errorText.isEmpty())
             {
                 q->scrollTo(mi, QAbstractItemView::EnsureVisible);
                 q->setCurrentIndex(mi);
                 KMessageBox::error(q, errorText);
                 m_mergeItemList.clear();
                 m_bRealMergeStarted = false;
                 return;
             }
         }
     }
 
     m_currentIndexForOperation = m_mergeItemList.begin();
     return;
 }
 
 void DirectoryMergeWindow::slotRunOperationForCurrentItem()
 {
     if(!d->canContinue()) return;
 
     bool bVerbose = false;
     if(d->m_mergeItemList.empty())
     {
         QModelIndex miBegin = currentIndex();
         QModelIndex miEnd = d->treeIterator(miBegin, false, false); // find next visible sibling (no children)
 
         d->prepareMergeStart(miBegin, miEnd, bVerbose);
         d->mergeContinue(true, bVerbose);
     }
     else
         d->mergeContinue(false, bVerbose);
 }
 
 void DirectoryMergeWindow::slotRunOperationForAllItems()
 {
     if(!d->canContinue()) return;
 
     bool bVerbose = true;
     if(d->m_mergeItemList.empty())
     {
         QModelIndex miBegin = d->rowCount() > 0 ? d->index(0, 0, QModelIndex()) : QModelIndex();
 
         d->prepareMergeStart(miBegin, QModelIndex(), bVerbose);
         d->mergeContinue(true, bVerbose);
     }
     else
         d->mergeContinue(false, bVerbose);
 }
 
 void DirectoryMergeWindow::mergeCurrentFile()
 {
     if(!d->canContinue()) return;
 
     if(d->m_bRealMergeStarted)
     {
         KMessageBox::sorry(this, i18n("This operation is currently not possible because directory merge is currently running."), i18n("Operation Not Possible"));
         return;
     }
 
     if(isFileSelected())
     {
         MergeFileInfos* pMFI = d->getMFI(currentIndex());
         if(pMFI != nullptr)
         {
             MergeFileInfos& mfi = *pMFI;
             d->m_mergeItemList.clear();
             d->m_mergeItemList.push_back(currentIndex());
             d->m_currentIndexForOperation = d->m_mergeItemList.begin();
             bool bDummy = false;
             d->mergeFLD(
                 mfi.existsInA() ? mfi.m_pFileInfoA->absoluteFilePath() : QString(""),
                 mfi.existsInB() ? mfi.m_pFileInfoB->absoluteFilePath() : QString(""),
                 mfi.existsInC() ? mfi.m_pFileInfoC->absoluteFilePath() : QString(""),
                 d->fullNameDest(mfi),
                 bDummy);
         }
     }
     emit updateAvailabilities();
 }
 
 // When bStart is true then m_currentIndexForOperation must still be processed.
 // When bVerbose is true then a messagebox will tell when the merge is complete.
 void DirectoryMergeWindow::Data::mergeContinue(bool bStart, bool bVerbose)
 {
     ProgressProxy pp;
     if(m_mergeItemList.empty())
         return;
 
     int nrOfItems = 0;
     int nrOfCompletedItems = 0;
     int nrOfCompletedSimItems = 0;
 
     // Count the number of completed items (for the progress bar).
     for(MergeItemList::iterator i = m_mergeItemList.begin(); i != m_mergeItemList.end(); ++i)
     {
         MergeFileInfos* pMFI = getMFI(*i);
         ++nrOfItems;
         if(pMFI->m_bOperationComplete)
             ++nrOfCompletedItems;
         if(pMFI->m_bSimOpComplete)
             ++nrOfCompletedSimItems;
     }
 
     m_pStatusInfo->hide();
     m_pStatusInfo->clear();
 
     QModelIndex miCurrent = m_currentIndexForOperation == m_mergeItemList.end() ? QModelIndex() : *m_currentIndexForOperation;
 
     bool bContinueWithCurrentItem = bStart; // true for first item, else false
     bool bSkipItem = false;
     if(!bStart && m_bError && miCurrent.isValid())
     {
         int status = KMessageBox::warningYesNoCancel(q,
                                                      i18n("There was an error in the last step.\n"
                                                           "Do you want to continue with the item that caused the error or do you want to skip this item?"),
                                                      i18n("Continue merge after an error"),
                                                      KGuiItem(i18n("Continue With Last Item")),
                                                      KGuiItem(i18n("Skip Item")));
         if(status == KMessageBox::Yes)
             bContinueWithCurrentItem = true;
         else if(status == KMessageBox::No)
             bSkipItem = true;
         else
             return;
         m_bError = false;
     }
 
     pp.setMaxNofSteps(nrOfItems);
 
     bool bSuccess = true;
     bool bSingleFileMerge = false;
     bool bSim = m_bSimulatedMergeStarted;
     while(bSuccess)
     {
         MergeFileInfos* pMFI = getMFI(miCurrent);
         if(pMFI == nullptr)
         {
             m_mergeItemList.clear();
             m_bRealMergeStarted = false;
             break;
         }
 
         if(pMFI != nullptr && !bContinueWithCurrentItem)
         {
             if(bSim)
             {
                 if(rowCount(miCurrent) == 0)
                 {
                     pMFI->m_bSimOpComplete = true;
                 }
             }
             else
             {
                 if(rowCount(miCurrent) == 0)
                 {
                     if(!pMFI->m_bOperationComplete)
                     {
                         setOpStatus(miCurrent, bSkipItem ? eOpStatusSkipped : eOpStatusDone);
                         pMFI->m_bOperationComplete = true;
                         bSkipItem = false;
                     }
                 }
                 else
                 {
                     setOpStatus(miCurrent, eOpStatusInProgress);
                 }
             }
         }
 
         if(!bContinueWithCurrentItem)
         {
             // Depth first
             QModelIndex miPrev = miCurrent;
             ++m_currentIndexForOperation;
             miCurrent = m_currentIndexForOperation == m_mergeItemList.end() ? QModelIndex() : *m_currentIndexForOperation;
             if((!miCurrent.isValid() || miCurrent.parent() != miPrev.parent()) && miPrev.parent().isValid())
             {
                 // Check if the parent may be set to "Done"
                 QModelIndex miParent = miPrev.parent();
                 bool bDone = true;
                 while(bDone && miParent.isValid())
                 {
                     for(int childIdx = 0; childIdx < rowCount(miParent); ++childIdx)
                     {
                         MergeFileInfos* pMFI = getMFI(index(childIdx, 0, miParent));
                         if((!bSim && !pMFI->m_bOperationComplete) || (bSim && pMFI->m_bSimOpComplete))
                         {
                             bDone = false;
                             break;
                         }
                     }
                     if(bDone)
                     {
                         MergeFileInfos* pMFI = getMFI(miParent);
                         if(bSim)
                             pMFI->m_bSimOpComplete = bDone;
                         else
                         {
                             setOpStatus(miParent, eOpStatusDone);
                             pMFI->m_bOperationComplete = bDone;
                         }
                     }
                     miParent = miParent.parent();
                 }
             }
         }
 
         if(!miCurrent.isValid()) // end?
         {
             if(m_bRealMergeStarted)
             {
                 if(bVerbose)
                 {
                     KMessageBox::information(q, i18n("Merge operation complete."), i18n("Merge Complete"));
                 }
                 m_bRealMergeStarted = false;
                 m_pStatusInfo->setWindowTitle(i18n("Merge Complete"));
             }
             if(m_bSimulatedMergeStarted)
             {
                 m_bSimulatedMergeStarted = false;
                 QModelIndex mi = rowCount() > 0 ? index(0, 0, QModelIndex()) : QModelIndex();
                 for(; mi.isValid(); mi = treeIterator(mi))
                 {
                     getMFI(mi)->m_bSimOpComplete = false;
                 }
                 m_pStatusInfo->setWindowTitle(i18n("Simulated merge complete: Check if you agree with the proposed operations."));
                 m_pStatusInfo->exec();
             }
             m_mergeItemList.clear();
             m_bRealMergeStarted = false;
             return;
         }
 
         MergeFileInfos& mfi = *getMFI(miCurrent);
 
         pp.setInformation(mfi.subPath(),
                           bSim ? nrOfCompletedSimItems : nrOfCompletedItems,
                           false // bRedrawUpdate
                           );
 
         bSuccess = executeMergeOperation(mfi, bSingleFileMerge); // Here the real operation happens.
 
         if(bSuccess)
         {
             if(bSim)
                 ++nrOfCompletedSimItems;
             else
                 ++nrOfCompletedItems;
             bContinueWithCurrentItem = false;
         }
 
         if(pp.wasCancelled())
             break;
     } // end while
 
     //g_pProgressDialog->hide();
 
     q->setCurrentIndex(miCurrent);
     q->scrollTo(miCurrent, EnsureVisible);
     if(!bSuccess && !bSingleFileMerge)
     {
         KMessageBox::error(q, i18n("An error occurred. Press OK to see detailed information."));
         m_pStatusInfo->setWindowTitle(i18n("Merge Error"));
         m_pStatusInfo->exec();
         //if ( m_pStatusInfo->firstChild()!=0 )
         //   m_pStatusInfo->ensureItemVisible( m_pStatusInfo->last() );
         m_bError = true;
 
         setOpStatus(miCurrent, eOpStatusError);
     }
     else
     {
         m_bError = false;
     }
     emit q->updateAvailabilities();
 
     if(m_currentIndexForOperation == m_mergeItemList.end())
     {
         m_mergeItemList.clear();
         m_bRealMergeStarted = false;
     }
 }
 
 bool DirectoryMergeWindow::Data::deleteFLD(const QString& name, bool bCreateBackup)
 {
     FileAccess fi(name, true);
     if(!fi.exists())
         return true;
 
     if(bCreateBackup)
     {
         bool bSuccess = renameFLD(name, name + ".orig");
         if(!bSuccess)
         {
             m_pStatusInfo->addText(i18n("Error: While deleting %1: Creating backup failed.", name));
             return false;
         }
     }
     else
     {
         if(fi.isDir() && !fi.isSymLink())
             m_pStatusInfo->addText(i18n("delete directory recursively( %1 )", name));
         else
             m_pStatusInfo->addText(i18n("delete( %1 )", name));
 
         if(m_bSimulatedMergeStarted)
         {
             return true;
         }
 
         if(fi.isDir() && !fi.isSymLink()) // recursive directory delete only for real dirs, not symlinks
         {
             t_DirectoryList dirList;
             bool bSuccess = fi.listDir(&dirList, false, true, "*", "", "", false, false); // not recursive, find hidden files
 
             if(!bSuccess)
             {
                 // No Permission to read directory or other error.
                 m_pStatusInfo->addText(i18n("Error: delete dir operation failed while trying to read the directory."));
                 return false;
             }
 
             t_DirectoryList::iterator it; // create list iterator
 
             for(it = dirList.begin(); it != dirList.end(); ++it) // for each file...
             {
                 FileAccess& fi2 = *it;
                 if(fi2.fileName() == "." || fi2.fileName() == "..")
                     continue;
                 bSuccess = deleteFLD(fi2.absoluteFilePath(), false);
                 if(!bSuccess) break;
             }
             if(bSuccess)
             {
                 bSuccess = FileAccess::removeDir(name);
                 if(!bSuccess)
                 {
                     m_pStatusInfo->addText(i18n("Error: rmdir( %1 ) operation failed.", name));
                     return false;
                 }
             }
         }
         else
         {
             bool bSuccess = FileAccess::removeFile(name);
             if(!bSuccess)
             {
                 m_pStatusInfo->addText(i18n("Error: delete operation failed."));
                 return false;
             }
         }
     }
     return true;
 }
 
 bool DirectoryMergeWindow::Data::mergeFLD(const QString& nameA, const QString& nameB, const QString& nameC, const QString& nameDest, bool& bSingleFileMerge)
 {
     FileAccess fi(nameA);
     if(fi.isDir())
     {
         return makeDir(nameDest);
     }
 
     // Make sure that the dir exists, into which we will save the file later.
     int pos = nameDest.lastIndexOf('/');
     if(pos > 0)
     {
         QString parentName = nameDest.left(pos);
         bool bSuccess = makeDir(parentName, true /*quiet*/);
         if(!bSuccess)
             return false;
     }
 
     m_pStatusInfo->addText(i18n("manual merge( %1, %2, %3 -> %4)", nameA, nameB, nameC, nameDest));
     if(m_bSimulatedMergeStarted)
     {
         m_pStatusInfo->addText(i18n("     Note: After a manual merge the user should continue by pressing F7."));
         return true;
     }
 
     bSingleFileMerge = true;
     setOpStatus(*m_currentIndexForOperation, eOpStatusInProgress);
     q->scrollTo(*m_currentIndexForOperation, EnsureVisible);
 
     emit q->startDiffMerge(nameA, nameB, nameC, nameDest, "", "", "", nullptr);
 
     return false;
 }
 
 bool DirectoryMergeWindow::Data::copyFLD(const QString& srcName, const QString& destName)
 {
     if(srcName == destName)
         return true;
 
     FileAccess fi(srcName);
     FileAccess faDest(destName, true);
     if(faDest.exists() && !(fi.isDir() && faDest.isDir() && (fi.isSymLink() == faDest.isSymLink())))
     {
         bool bSuccess = deleteFLD(destName, m_pOptions->m_bDmCreateBakFiles);
         if(!bSuccess)
         {
             m_pStatusInfo->addText(i18n("Error: copy( %1 -> %2 ) failed."
                                         "Deleting existing destination failed.",
                                         srcName, destName));
             return false;
         }
     }
 
     if(fi.isSymLink() && ((fi.isDir() && !m_bFollowDirLinks) || (!fi.isDir() && !m_bFollowFileLinks)))
     {
         m_pStatusInfo->addText(i18n("copyLink( %1 -> %2 )", srcName, destName));
 #if defined(Q_OS_WIN)
 // What are links?
 #else
         if(m_bSimulatedMergeStarted)
         {
             return true;
         }
         FileAccess destFi(destName);
         if(!destFi.isLocal() || !fi.isLocal())
         {
             m_pStatusInfo->addText(i18n("Error: copyLink failed: Remote links are not yet supported."));
             return false;
         }
         QString linkTarget = fi.readLink();
         bool bSuccess = FileAccess::symLink(linkTarget, destName);
         if(!bSuccess)
             m_pStatusInfo->addText(i18n("Error: copyLink failed."));
         return bSuccess;
 #endif
     }
 
     if(fi.isDir())
     {
         if(faDest.exists())
             return true;
         else
         {
             bool bSuccess = makeDir(destName);
             return bSuccess;
         }
     }
 
     int pos = destName.lastIndexOf('/');
     if(pos > 0)
     {
         QString parentName = destName.left(pos);
         bool bSuccess = makeDir(parentName, true /*quiet*/);
         if(!bSuccess)
             return false;
     }
 
     m_pStatusInfo->addText(i18n("copy( %1 -> %2 )", srcName, destName));
 
     if(m_bSimulatedMergeStarted)
     {
         return true;
     }
 
     FileAccess faSrc(srcName);
     bool bSuccess = faSrc.copyFile(destName);
     if(!bSuccess) m_pStatusInfo->addText(faSrc.getStatusText());
     return bSuccess;
 }
 
 // Rename is not an operation that can be selected by the user.
 // It will only be used to create backups.
 // Hence it will delete an existing destination without making a backup (of the old backup.)
 bool DirectoryMergeWindow::Data::renameFLD(const QString& srcName, const QString& destName)
 {
     if(srcName == destName)
         return true;
 
     if(FileAccess(destName, true).exists())
     {
         bool bSuccess = deleteFLD(destName, false /*no backup*/);
         if(!bSuccess)
         {
             m_pStatusInfo->addText(i18n("Error during rename( %1 -> %2 ): "
                                         "Cannot delete existing destination.",
                                         srcName, destName));
             return false;
         }
     }
 
     m_pStatusInfo->addText(i18n("rename( %1 -> %2 )", srcName, destName));
     if(m_bSimulatedMergeStarted)
     {
         return true;
     }
 
     bool bSuccess = FileAccess(srcName).rename(destName);
     if(!bSuccess)
     {
         m_pStatusInfo->addText(i18n("Error: Rename failed."));
         return false;
     }
 
     return true;
 }
 
 bool DirectoryMergeWindow::Data::makeDir(const QString& name, bool bQuiet)
 {
     FileAccess fi(name, true);
     if(fi.exists() && fi.isDir())
         return true;
 
     if(fi.exists() && !fi.isDir())
     {
         bool bSuccess = deleteFLD(name, true);
         if(!bSuccess)
         {
             m_pStatusInfo->addText(i18n("Error during makeDir of %1. "
                                         "Cannot delete existing file.",
                                         name));
             return false;
         }
     }
 
     int pos = name.lastIndexOf('/');
     if(pos > 0)
     {
         QString parentName = name.left(pos);
         bool bSuccess = makeDir(parentName, true);
         if(!bSuccess)
             return false;
     }
 
     if(!bQuiet)
         m_pStatusInfo->addText(i18n("makeDir( %1 )", name));
 
     if(m_bSimulatedMergeStarted)
     {
         return true;
     }
 
     bool bSuccess = FileAccess::makeDir(name);
     if(bSuccess == false)
     {
         m_pStatusInfo->addText(i18n("Error while creating directory."));
         return false;
     }
     return true;
 }
 
 DirectoryMergeInfo::DirectoryMergeInfo(QWidget* pParent)
     : QFrame(pParent)
 {
     QVBoxLayout* topLayout = new QVBoxLayout(this);
     topLayout->setMargin(0);
 
     QGridLayout* grid = new QGridLayout();
     topLayout->addLayout(grid);
     grid->setColumnStretch(1, 10);
 
     int line = 0;
 
     m_pA = new QLabel("A", this);
     grid->addWidget(m_pA, line, 0);
     m_pInfoA = new QLabel(this);
     grid->addWidget(m_pInfoA, line, 1);
     ++line;
     
     m_pB = new QLabel("B", this);
     grid->addWidget(m_pB, line, 0);
     m_pInfoB = new QLabel(this);
     grid->addWidget(m_pInfoB, line, 1);
     ++line;
     
     m_pC = new QLabel("C", this);
     grid->addWidget(m_pC, line, 0);
     m_pInfoC = new QLabel(this);
     grid->addWidget(m_pInfoC, line, 1);
     ++line;
     
     m_pDest = new QLabel(i18n("Dest"), this);
     grid->addWidget(m_pDest, line, 0);
     m_pInfoDest = new QLabel(this);
     grid->addWidget(m_pInfoDest, line, 1);
     ++line;
 
     m_pInfoList = new QTreeWidget(this);
     topLayout->addWidget(m_pInfoList);
     m_pInfoList->setHeaderLabels(QStringList() << i18n("Dir") << i18n("Type") << i18n("Size")
                                                << i18n("Attr") << i18n("Last Modification") << i18n("Link-Destination"));
     setMinimumSize(100, 100);
 
     m_pInfoList->installEventFilter(this);
     m_pInfoList->setRootIsDecorated(false);
 }
 
 bool DirectoryMergeInfo::eventFilter(QObject* o, QEvent* e)
 {
     if(e->type() == QEvent::FocusIn && o == m_pInfoList)
         emit gotFocus();
     return false;
 }
 
 static void addListViewItem(QTreeWidget* pListView, const QString& dir,
                             const QString& basePath, FileAccess* fi)
 {
     if(basePath.isEmpty())
     {
         return;
     }
     else
     {
         if(fi != nullptr && fi->exists())
         {
             QString dateString = fi->lastModified().toString("yyyy-MM-dd hh:mm:ss");
 
             new QTreeWidgetItem(
                 pListView,
                 QStringList() << dir << QString(fi->isDir() ? i18n("Dir") : i18n("File")) + (fi->isSymLink() ? "-Link" : "") << QString::number(fi->size()) << QString(fi->isReadable() ? "r" : " ") + (fi->isWritable() ? "w" : " ")
 #ifdef Q_OS_WIN
                               /*Future: Use GetFileAttributes()*/
                               <<
 #else
                                                                                                                                                                    + (fi->isExecutable() ? "x" : " ")
                               <<
 #endif
                     dateString << QString(fi->isSymLink() ? (" -> " + fi->readLink()) : QString("")));
         }
         else
         {
             new QTreeWidgetItem(
                 pListView,
                 QStringList() << dir << i18n("not available") << ""
                               << ""
                               << ""
                               << "");
         }
     }
 }
 
 void DirectoryMergeInfo::setInfo(
     const FileAccess& dirA,
     const FileAccess& dirB,
     const FileAccess& dirC,
     const FileAccess& dirDest,
     MergeFileInfos& mfi)
 {
     bool bHideDest = false;
     if(dirA.absoluteFilePath() == dirDest.absoluteFilePath())
     {
         m_pA->setText(i18n("A (Dest): "));
         bHideDest = true;
     }
     else
         m_pA->setText(!dirC.isValid() ? QString("A:    ") : i18n("A (Base): "));
 
     m_pInfoA->setText(dirA.prettyAbsPath());
 
     if(dirB.absoluteFilePath() == dirDest.absoluteFilePath())
     {
         m_pB->setText(i18n("B (Dest): "));
         bHideDest = true;
     }
     else
         m_pB->setText("B:    ");
     m_pInfoB->setText(dirB.prettyAbsPath());
 
     if(dirC.absoluteFilePath() == dirDest.absoluteFilePath())
     {
         m_pC->setText(i18n("C (Dest): "));
         bHideDest = true;
     }
     else
         m_pC->setText("C:    ");
     m_pInfoC->setText(dirC.prettyAbsPath());
 
     m_pDest->setText(i18n("Dest: "));
     m_pInfoDest->setText(dirDest.prettyAbsPath());
 
     if(!dirC.isValid()) {
         m_pC->hide();
         m_pInfoC->hide();
     }
     else
     {
         m_pC->show();
         m_pInfoC->show();
     }
 
     if(!dirDest.isValid() || bHideDest) {
         m_pDest->hide();
         m_pInfoDest->hide();
     }
     else
     {
         m_pDest->show();
         m_pInfoDest->show();
     }
 
     m_pInfoList->clear();
     addListViewItem(m_pInfoList, "A", dirA.prettyAbsPath(), mfi.m_pFileInfoA);
     addListViewItem(m_pInfoList, "B", dirB.prettyAbsPath(), mfi.m_pFileInfoB);
     addListViewItem(m_pInfoList, "C", dirC.prettyAbsPath(), mfi.m_pFileInfoC);
     if(!bHideDest)
     {
         FileAccess fiDest(dirDest.prettyAbsPath() + "/" + mfi.subPath(), true);
         addListViewItem(m_pInfoList, i18n("Dest"), dirDest.prettyAbsPath(), &fiDest);
     }
     for(int i = 0; i < m_pInfoList->columnCount(); ++i)
         m_pInfoList->resizeColumnToContents(i);
 }
 
 QTextStream& operator<<(QTextStream& ts, MergeFileInfos& mfi)
 {
     ts << "{\n";
     ValueMap vm;
     vm.writeEntry("SubPath", mfi.subPath());
     vm.writeEntry("ExistsInA", mfi.existsInA());
     vm.writeEntry("ExistsInB", mfi.existsInB());
     vm.writeEntry("ExistsInC", mfi.existsInC());
     vm.writeEntry("EqualAB", mfi.m_bEqualAB);
     vm.writeEntry("EqualAC", mfi.m_bEqualAC);
     vm.writeEntry("EqualBC", mfi.m_bEqualBC);
     //DirMergeItem* m_pDMI;
     //MergeFileInfos* m_pParent;
     vm.writeEntry("MergeOperation", (int)mfi.m_eMergeOperation);
     vm.writeEntry("DirA", mfi.dirA());
     vm.writeEntry("DirB", mfi.dirB());
     vm.writeEntry("DirC", mfi.dirC());
     vm.writeEntry("LinkA", mfi.isLinkA());
     vm.writeEntry("LinkB", mfi.isLinkB());
     vm.writeEntry("LinkC", mfi.isLinkC());
     vm.writeEntry("OperationComplete", mfi.m_bOperationComplete);
     //bool m_bSimOpComplete );
 
     vm.writeEntry("AgeA", (int)mfi.m_ageA);
     vm.writeEntry("AgeB", (int)mfi.m_ageB);
     vm.writeEntry("AgeC", (int)mfi.m_ageC);
     vm.writeEntry("ConflictingAges", mfi.m_bConflictingAges); // Equal age but files are not!
 
     //FileAccess m_fileInfoA;
     //FileAccess m_fileInfoB;
     //FileAccess m_fileInfoC;
 
     //TotalDiffStatus m_totalDiffStatus;
 
     vm.save(ts);
 
     ts << "}\n";
 
     return ts;
 }
 
 void DirectoryMergeWindow::slotSaveMergeState()
 {
     //slotStatusMsg(i18n("Saving Directory Merge State ..."));
 
     //QString s = KFileDialog::getSaveUrl( QDir::currentPath(), 0, this, i18n("Save As...") ).url();
     QString s = QFileDialog::getSaveFileName(this, i18n("Save Directory Merge State As..."), QDir::currentPath(), nullptr);
     if(!s.isEmpty())
     {
         d->m_dirMergeStateFilename = s;
 
         QFile file(d->m_dirMergeStateFilename);
         bool bSuccess = file.open(QIODevice::WriteOnly);
         if(bSuccess)
         {
             QTextStream ts(&file);
 
             QModelIndex mi(d->index(0, 0, QModelIndex()));
             while(mi.isValid()) {
                 MergeFileInfos* pMFI = d->getMFI(mi);
                 ts << *pMFI;
                 mi = d->treeIterator(mi, true, true);
             }
         }
     }
 
     //slotStatusMsg(i18n("Ready."));
 }
 
 void DirectoryMergeWindow::slotLoadMergeState()
 {
 }
 
 void DirectoryMergeWindow::updateFileVisibilities()
 {
     bool bShowIdentical = d->m_pDirShowIdenticalFiles->isChecked();
     bool bShowDifferent = d->m_pDirShowDifferentFiles->isChecked();
     bool bShowOnlyInA = d->m_pDirShowFilesOnlyInA->isChecked();
     bool bShowOnlyInB = d->m_pDirShowFilesOnlyInB->isChecked();
     bool bShowOnlyInC = d->m_pDirShowFilesOnlyInC->isChecked();
     bool bThreeDirs = d->m_dirC.isValid();
     d->m_selection1Index = QModelIndex();
     d->m_selection2Index = QModelIndex();
     d->m_selection3Index = QModelIndex();
 
     // in first run set all dirs to equal and determine if they are not equal.
     // on second run don't change the equal-status anymore; it is needed to
     // set the visibility (when bShowIdentical is false).
     for(int loop = 0; loop < 2; ++loop)
     {
         QModelIndex mi = d->rowCount() > 0 ? d->index(0, 0, QModelIndex()) : QModelIndex();
         while(mi.isValid())
         {
             MergeFileInfos* pMFI = d->getMFI(mi);
             bool bDir = pMFI->dirA() || pMFI->dirB() || pMFI->dirC();
             if(loop == 0 && bDir)
             {
                 bool bChange = false;
                 if(!pMFI->m_bEqualAB && pMFI->dirA() == pMFI->dirB() && pMFI->isLinkA() == pMFI->isLinkB())
                 {
                     pMFI->m_bEqualAB = true;
                     bChange = true;
                 }
                 if(!pMFI->m_bEqualBC && pMFI->dirC() == pMFI->dirB() && pMFI->isLinkC() == pMFI->isLinkB())
                 {
                     pMFI->m_bEqualBC = true;
                     bChange = true;
                 }
                 if(!pMFI->m_bEqualAC && pMFI->dirA() == pMFI->dirC() && pMFI->isLinkA() == pMFI->isLinkC())
                 {
                     pMFI->m_bEqualAC = true;
                     bChange = true;
                 }
 
                 if(bChange)
                     setPixmaps(*pMFI, bThreeDirs);
             }
             bool bExistsEverywhere = pMFI->existsInA() && pMFI->existsInB() && (pMFI->existsInC() || !bThreeDirs);
             int existCount = int(pMFI->existsInA()) + int(pMFI->existsInB()) + int(pMFI->existsInC());
             bool bVisible =
                 (bShowIdentical && bExistsEverywhere && pMFI->m_bEqualAB && (pMFI->m_bEqualAC || !bThreeDirs)) || ((bShowDifferent || bDir) && existCount >= 2 && (!pMFI->m_bEqualAB || !(pMFI->m_bEqualAC || !bThreeDirs))) || (bShowOnlyInA && pMFI->existsInA() && !pMFI->existsInB() && !pMFI->existsInC()) || (bShowOnlyInB && !pMFI->existsInA() && pMFI->existsInB() && !pMFI->existsInC()) || (bShowOnlyInC && !pMFI->existsInA() && !pMFI->existsInB() && pMFI->existsInC());
 
             QString fileName = pMFI->fileName();
             bVisible = bVisible && ((bDir && !wildcardMultiMatch(d->m_pOptions->m_DmDirAntiPattern, fileName, d->m_bCaseSensitive)) || (wildcardMultiMatch(d->m_pOptions->m_DmFilePattern, fileName, d->m_bCaseSensitive) && !wildcardMultiMatch(d->m_pOptions->m_DmFileAntiPattern, fileName, d->m_bCaseSensitive)));
 
             setRowHidden(mi.row(), mi.parent(), !bVisible);
 
             bool bEqual = bThreeDirs ? pMFI->m_bEqualAB && pMFI->m_bEqualAC : pMFI->m_bEqualAB;
             if(!bEqual && bVisible && loop == 0) // Set all parents to "not equal"
             {
                 MergeFileInfos* p2 = pMFI->m_pParent;
                 while(p2 != nullptr)
                 {
                     bool bChange = false;
                     if(!pMFI->m_bEqualAB && p2->m_bEqualAB) {
                         p2->m_bEqualAB = false;
                         bChange = true;
                     }
                     if(!pMFI->m_bEqualAC && p2->m_bEqualAC) {
                         p2->m_bEqualAC = false;
                         bChange = true;
                     }
                     if(!pMFI->m_bEqualBC && p2->m_bEqualBC) {
                         p2->m_bEqualBC = false;
                         bChange = true;
                     }
 
                     if(bChange)
                         setPixmaps(*p2, bThreeDirs);
                     else
                         break;
 
                     p2 = p2->m_pParent;
                 }
             }
             mi = d->treeIterator(mi, true, true);
         }
     }
 }
 
 void DirectoryMergeWindow::slotShowIdenticalFiles()
 {
     d->m_pOptions->m_bDmShowIdenticalFiles = d->m_pDirShowIdenticalFiles->isChecked();
     updateFileVisibilities();
 }
 void DirectoryMergeWindow::slotShowDifferentFiles() { updateFileVisibilities(); }
 void DirectoryMergeWindow::slotShowFilesOnlyInA() { updateFileVisibilities(); }
 void DirectoryMergeWindow::slotShowFilesOnlyInB() { updateFileVisibilities(); }
 void DirectoryMergeWindow::slotShowFilesOnlyInC() { updateFileVisibilities(); }
 
 void DirectoryMergeWindow::slotSynchronizeDirectories() {}
 void DirectoryMergeWindow::slotChooseNewerFiles() {}
 
 void DirectoryMergeWindow::initDirectoryMergeActions(QObject* pKDiff3App, KActionCollection* ac)
 {
 #include "xpm/showequalfiles.xpm"
 #include "xpm/showfilesonlyina.xpm"
 #include "xpm/showfilesonlyinb.xpm"
 #include "xpm/showfilesonlyinc.xpm"
 #include "xpm/startmerge.xpm"
     DirectoryMergeWindow* p = this;
 
     d->m_pDirStartOperation = KDiff3::createAction<QAction>(i18n("Start/Continue Directory Merge"), QKeySequence(Qt::Key_F7), p, SLOT(slotRunOperationForAllItems()), ac, "dir_start_operation");
     d->m_pDirRunOperationForCurrentItem = KDiff3::createAction<QAction>(i18n("Run Operation for Current Item"), QKeySequence(Qt::Key_F6), p, SLOT(slotRunOperationForCurrentItem()), ac, "dir_run_operation_for_current_item");
     d->m_pDirCompareCurrent = KDiff3::createAction<QAction>(i18n("Compare Selected File"), p, SLOT(compareCurrentFile()), ac, "dir_compare_current");
     d->m_pDirMergeCurrent = KDiff3::createAction<QAction>(i18n("Merge Current File"), QIcon(QPixmap(startmerge)), i18n("Merge\nFile"), pKDiff3App, SLOT(slotMergeCurrentFile()), ac, "merge_current");
     d->m_pDirFoldAll = KDiff3::createAction<QAction>(i18n("Fold All Subdirs"), p, SLOT(collapseAll()), ac, "dir_fold_all");
     d->m_pDirUnfoldAll = KDiff3::createAction<QAction>(i18n("Unfold All Subdirs"), p, SLOT(expandAll()), ac, "dir_unfold_all");
     d->m_pDirRescan = KDiff3::createAction<QAction>(i18n("Rescan"), QKeySequence(Qt::SHIFT + Qt::Key_F5), p, SLOT(reload()), ac, "dir_rescan");
     d->m_pDirSaveMergeState = nullptr; //KDiff3::createAction< QAction >(i18n("Save Directory Merge State ..."), 0, p, SLOT(slotSaveMergeState()), ac, "dir_save_merge_state");
     d->m_pDirLoadMergeState = nullptr; //KDiff3::createAction< QAction >(i18n("Load Directory Merge State ..."), 0, p, SLOT(slotLoadMergeState()), ac, "dir_load_merge_state");
     d->m_pDirChooseAEverywhere = KDiff3::createAction<QAction>(i18n("Choose A for All Items"), p, SLOT(slotChooseAEverywhere()), ac, "dir_choose_a_everywhere");
     d->m_pDirChooseBEverywhere = KDiff3::createAction<QAction>(i18n("Choose B for All Items"), p, SLOT(slotChooseBEverywhere()), ac, "dir_choose_b_everywhere");
     d->m_pDirChooseCEverywhere = KDiff3::createAction<QAction>(i18n("Choose C for All Items"), p, SLOT(slotChooseCEverywhere()), ac, "dir_choose_c_everywhere");
     d->m_pDirAutoChoiceEverywhere = KDiff3::createAction<QAction>(i18n("Auto-Choose Operation for All Items"), p, SLOT(slotAutoChooseEverywhere()), ac, "dir_autochoose_everywhere");
     d->m_pDirDoNothingEverywhere = KDiff3::createAction<QAction>(i18n("No Operation for All Items"), p, SLOT(slotNoOpEverywhere()), ac, "dir_nothing_everywhere");
 
     //   d->m_pDirSynchronizeDirectories = KDiff3::createAction< KToggleAction >(i18n("Synchronize Directories"), 0, this, SLOT(slotSynchronizeDirectories()), ac, "dir_synchronize_directories");
     //   d->m_pDirChooseNewerFiles = KDiff3::createAction< KToggleAction >(i18n("Copy Newer Files Instead of Merging"), 0, this, SLOT(slotChooseNewerFiles()), ac, "dir_choose_newer_files");
 
     d->m_pDirShowIdenticalFiles = KDiff3::createAction<KToggleAction>(i18n("Show Identical Files"), QIcon(QPixmap(showequalfiles)), i18n("Identical\nFiles"), this, SLOT(slotShowIdenticalFiles()), ac, "dir_show_identical_files");
     d->m_pDirShowDifferentFiles = KDiff3::createAction<KToggleAction>(i18n("Show Different Files"), this, SLOT(slotShowDifferentFiles()), ac, "dir_show_different_files");
     d->m_pDirShowFilesOnlyInA = KDiff3::createAction<KToggleAction>(i18n("Show Files only in A"), QIcon(QPixmap(showfilesonlyina)), i18n("Files\nonly in A"), this, SLOT(slotShowFilesOnlyInA()), ac, "dir_show_files_only_in_a");
     d->m_pDirShowFilesOnlyInB = KDiff3::createAction<KToggleAction>(i18n("Show Files only in B"), QIcon(QPixmap(showfilesonlyinb)), i18n("Files\nonly in B"), this, SLOT(slotShowFilesOnlyInB()), ac, "dir_show_files_only_in_b");
     d->m_pDirShowFilesOnlyInC = KDiff3::createAction<KToggleAction>(i18n("Show Files only in C"), QIcon(QPixmap(showfilesonlyinc)), i18n("Files\nonly in C"), this, SLOT(slotShowFilesOnlyInC()), ac, "dir_show_files_only_in_c");
 
     d->m_pDirShowIdenticalFiles->setChecked(d->m_pOptions->m_bDmShowIdenticalFiles);
 
     d->m_pDirCompareExplicit = KDiff3::createAction<QAction>(i18n("Compare Explicitly Selected Files"), p, SLOT(slotCompareExplicitlySelectedFiles()), ac, "dir_compare_explicitly_selected_files");
     d->m_pDirMergeExplicit = KDiff3::createAction<QAction>(i18n("Merge Explicitly Selected Files"), p, SLOT(slotMergeExplicitlySelectedFiles()), ac, "dir_merge_explicitly_selected_files");
 
     d->m_pDirCurrentDoNothing = KDiff3::createAction<QAction>(i18n("Do Nothing"), p, SLOT(slotCurrentDoNothing()), ac, "dir_current_do_nothing");
     d->m_pDirCurrentChooseA = KDiff3::createAction<QAction>(i18n("A"), p, SLOT(slotCurrentChooseA()), ac, "dir_current_choose_a");
     d->m_pDirCurrentChooseB = KDiff3::createAction<QAction>(i18n("B"), p, SLOT(slotCurrentChooseB()), ac, "dir_current_choose_b");
     d->m_pDirCurrentChooseC = KDiff3::createAction<QAction>(i18n("C"), p, SLOT(slotCurrentChooseC()), ac, "dir_current_choose_c");
     d->m_pDirCurrentMerge = KDiff3::createAction<QAction>(i18n("Merge"), p, SLOT(slotCurrentMerge()), ac, "dir_current_merge");
     d->m_pDirCurrentDelete = KDiff3::createAction<QAction>(i18n("Delete (if exists)"), p, SLOT(slotCurrentDelete()), ac, "dir_current_delete");
 
     d->m_pDirCurrentSyncDoNothing = KDiff3::createAction<QAction>(i18n("Do Nothing"), p, SLOT(slotCurrentDoNothing()), ac, "dir_current_sync_do_nothing");
     d->m_pDirCurrentSyncCopyAToB = KDiff3::createAction<QAction>(i18n("Copy A to B"), p, SLOT(slotCurrentCopyAToB()), ac, "dir_current_sync_copy_a_to_b");
     d->m_pDirCurrentSyncCopyBToA = KDiff3::createAction<QAction>(i18n("Copy B to A"), p, SLOT(slotCurrentCopyBToA()), ac, "dir_current_sync_copy_b_to_a");
     d->m_pDirCurrentSyncDeleteA = KDiff3::createAction<QAction>(i18n("Delete A"), p, SLOT(slotCurrentDeleteA()), ac, "dir_current_sync_delete_a");
     d->m_pDirCurrentSyncDeleteB = KDiff3::createAction<QAction>(i18n("Delete B"), p, SLOT(slotCurrentDeleteB()), ac, "dir_current_sync_delete_b");
     d->m_pDirCurrentSyncDeleteAAndB = KDiff3::createAction<QAction>(i18n("Delete A && B"), p, SLOT(slotCurrentDeleteAAndB()), ac, "dir_current_sync_delete_a_and_b");
     d->m_pDirCurrentSyncMergeToA = KDiff3::createAction<QAction>(i18n("Merge to A"), p, SLOT(slotCurrentMergeToA()), ac, "dir_current_sync_merge_to_a");
     d->m_pDirCurrentSyncMergeToB = KDiff3::createAction<QAction>(i18n("Merge to B"), p, SLOT(slotCurrentMergeToB()), ac, "dir_current_sync_merge_to_b");
     d->m_pDirCurrentSyncMergeToAAndB = KDiff3::createAction<QAction>(i18n("Merge to A && B"), p, SLOT(slotCurrentMergeToAAndB()), ac, "dir_current_sync_merge_to_a_and_b");
 }
 
 void DirectoryMergeWindow::updateAvailabilities(bool bDirCompare, bool bDiffWindowVisible,
                                                 KToggleAction* chooseA, KToggleAction* chooseB, KToggleAction* chooseC)
 {
     d->m_pDirStartOperation->setEnabled(bDirCompare);
     d->m_pDirRunOperationForCurrentItem->setEnabled(bDirCompare);
     d->m_pDirFoldAll->setEnabled(bDirCompare);
     d->m_pDirUnfoldAll->setEnabled(bDirCompare);
 
     d->m_pDirCompareCurrent->setEnabled(bDirCompare && isVisible() && isFileSelected());
 
     d->m_pDirMergeCurrent->setEnabled((bDirCompare && isVisible() && isFileSelected()) || bDiffWindowVisible);
 
     d->m_pDirRescan->setEnabled(bDirCompare);
 
     d->m_pDirAutoChoiceEverywhere->setEnabled(bDirCompare && isVisible());
     d->m_pDirDoNothingEverywhere->setEnabled(bDirCompare && isVisible());
     d->m_pDirChooseAEverywhere->setEnabled(bDirCompare && isVisible());
     d->m_pDirChooseBEverywhere->setEnabled(bDirCompare && isVisible());
     d->m_pDirChooseCEverywhere->setEnabled(bDirCompare && isVisible());
 
     bool bThreeDirs = d->m_dirC.isValid();
 
     MergeFileInfos* pMFI = d->getMFI(currentIndex());
 
     bool bItemActive = bDirCompare && isVisible() && pMFI != nullptr; //  &&  hasFocus();
     bool bMergeMode = bThreeDirs || !d->m_bSyncMode;
     bool bFTConflict = pMFI == nullptr ? false : conflictingFileTypes(*pMFI);
 
     bool bDirWindowHasFocus = isVisible() && hasFocus();
 
     d->m_pDirShowIdenticalFiles->setEnabled(bDirCompare && isVisible());
     d->m_pDirShowDifferentFiles->setEnabled(bDirCompare && isVisible());
     d->m_pDirShowFilesOnlyInA->setEnabled(bDirCompare && isVisible());
     d->m_pDirShowFilesOnlyInB->setEnabled(bDirCompare && isVisible());
     d->m_pDirShowFilesOnlyInC->setEnabled(bDirCompare && isVisible() && bThreeDirs);
 
     d->m_pDirCompareExplicit->setEnabled(bDirCompare && isVisible() && d->m_selection2Index.isValid());
     d->m_pDirMergeExplicit->setEnabled(bDirCompare && isVisible() && d->m_selection2Index.isValid());
 
     d->m_pDirCurrentDoNothing->setEnabled(bItemActive && bMergeMode);
     d->m_pDirCurrentChooseA->setEnabled(bItemActive && bMergeMode && pMFI->existsInA());
     d->m_pDirCurrentChooseB->setEnabled(bItemActive && bMergeMode && pMFI->existsInB());
     d->m_pDirCurrentChooseC->setEnabled(bItemActive && bMergeMode && pMFI->existsInC());
     d->m_pDirCurrentMerge->setEnabled(bItemActive && bMergeMode && !bFTConflict);
     d->m_pDirCurrentDelete->setEnabled(bItemActive && bMergeMode);
     if(bDirWindowHasFocus)
     {
         chooseA->setEnabled(bItemActive && pMFI->existsInA());
         chooseB->setEnabled(bItemActive && pMFI->existsInB());
         chooseC->setEnabled(bItemActive && pMFI->existsInC());
         chooseA->setChecked(false);
         chooseB->setChecked(false);
         chooseC->setChecked(false);
     }
 
     d->m_pDirCurrentSyncDoNothing->setEnabled(bItemActive && !bMergeMode);
     d->m_pDirCurrentSyncCopyAToB->setEnabled(bItemActive && !bMergeMode && pMFI->existsInA());
     d->m_pDirCurrentSyncCopyBToA->setEnabled(bItemActive && !bMergeMode && pMFI->existsInB());
     d->m_pDirCurrentSyncDeleteA->setEnabled(bItemActive && !bMergeMode && pMFI->existsInA());
     d->m_pDirCurrentSyncDeleteB->setEnabled(bItemActive && !bMergeMode && pMFI->existsInB());
     d->m_pDirCurrentSyncDeleteAAndB->setEnabled(bItemActive && !bMergeMode && pMFI->existsInA() && pMFI->existsInB());
     d->m_pDirCurrentSyncMergeToA->setEnabled(bItemActive && !bMergeMode && !bFTConflict);
     d->m_pDirCurrentSyncMergeToB->setEnabled(bItemActive && !bMergeMode && !bFTConflict);
     d->m_pDirCurrentSyncMergeToAAndB->setEnabled(bItemActive && !bMergeMode && !bFTConflict);
 }
 
 //#include "directorymergewindow.moc"
diff --git a/src/fileaccess.cpp b/src/fileaccess.cpp
index 3bb89c6..8df4a39 100644
--- a/src/fileaccess.cpp
+++ b/src/fileaccess.cpp
@@ -1,1783 +1,1783 @@
 /***************************************************************************
  *   Copyright (C) 2003-2011 by Joachim Eibl                               *
  *   joachim.eibl at gmx.de                                                *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  ***************************************************************************/
 #include "fileaccess.h"
 #include "common.h"
 #include "progress.h"
 
 #include <QDir>
 #include <QProcess>
 #include <QRegExp>
 #include <QTemporaryFile>
 #include <QTextStream>
 
 #include <cstdlib>
 #include <vector>
 
 #include <KIO/CopyJob>
 #include <KIO/Job>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <kio/global.h>
 #include <kio/jobclasses.h>
 #include <kio/jobuidelegate.h>
 
 #include <sys/stat.h>
 #include <sys/types.h>
 
 #ifdef Q_OS_WIN
 #include <io.h>
 #include <process.h>
 #include <sys/utime.h>
 #include <windows.h>
 #else
 #include <unistd.h> // Needed for creating symbolic links via symlink().
 #include <utime.h>
 #endif
 
 class FileAccess::Data
 {
   public:
     Data()
     {
         reset();
     }
     void reset()
     {
         m_url = QUrl();
         m_bValidData = false;
         m_name = QString();
         //m_creationTime = QDateTime();
         //m_accessTime = QDateTime();
         m_bReadable = false;
         m_bExecutable = false;
         m_linkTarget = "";
         //m_fileType = -1;
         m_bLocal = true;
         m_pParent = nullptr;
     }
 
     QUrl m_url;
     bool m_bLocal;
     bool m_bValidData;
 
     //QDateTime m_accessTime;
     //QDateTime m_creationTime;
     bool m_bReadable;
     bool m_bExecutable;
     //long m_fileType; // for testing only
     FileAccess* m_pParent;
 
     QString m_linkTarget;
     //QString m_user;
     //QString m_group;
     QString m_name;
     QString m_localCopy;
     QString m_statusText; // Might contain an error string, when the last operation didn't succeed.
 };
 
 FileAccess::FileAccess(const QString& name, bool bWantToWrite)
 {
     m_pData = nullptr;
     m_bUseData = false;
     setFile(name, bWantToWrite);
 }
 
 FileAccess::FileAccess()
 {
     m_bUseData = false;
     m_bExists = false;
     m_bFile = false;
     m_bDir = false;
     m_bSymLink = false;
     m_bWritable = false;
     m_bHidden = false;
     m_pParent = nullptr;
     m_size = 0;
 }
 
 FileAccess::FileAccess(const FileAccess& other)
 {
     m_pData = nullptr;
     m_bUseData = false;
     *this = other;
 }
 
 void FileAccess::createData()
 {
     if(d() == nullptr)
     {
         FileAccess* pParent = m_pParent; // backup because in union with m_pData
         m_pData = new Data();
         m_bUseData = true;
         m_pData->m_pParent = pParent;
     }
 }
 
 FileAccess& FileAccess::operator=(const FileAccess& other)
 {
     m_size = other.m_size;
     m_filePath = other.m_filePath;
     m_modificationTime = other.m_modificationTime;
     m_bSymLink = other.m_bSymLink;
     m_bFile = other.m_bFile;
     m_bDir = other.m_bDir;
     m_bExists = other.m_bExists;
     m_bWritable = other.m_bWritable;
     m_bHidden = other.m_bHidden;
 
     if(other.m_bUseData)
     {
         createData();
         *m_pData = *other.m_pData;
     }
     else
     {
         if(m_bUseData)
         {
             delete m_pData;
         }
         m_bUseData = false;
         m_pParent = other.parent(); // should be 0 anyway
     }
     return *this;
 }
 
 FileAccess::~FileAccess()
 {
     if(m_bUseData)
     {
         if(!d()->m_localCopy.isEmpty())
         {
             removeTempFile(d()->m_localCopy);
         }
         delete m_pData;
     }
 }
 
 static QString nicePath(const QFileInfo& fi)
 {
     QString fp = fi.filePath();
     if(fp.length() > 2 && fp[0] == '.' && fp[1] == '/')
     {
         return fp.mid(2);
     }
     return fp;
 }
 
 // Two kinds of optimization are applied here:
 // 1. Speed: don't ask for data as long as it is not needed or cheap to get.
 //    When opening a file it is early enough to ask for details.
 // 2. Memory usage: Don't store data that is not needed, and avoid redundancy.
 //    For recursive directory trees don't store the full path if a parent is available.
 //    Store urls only if files are not local.
 
 void FileAccess::setFile(const QFileInfo& fi, FileAccess* pParent)
 {
     m_filePath = pParent == nullptr ? fi.absoluteFilePath() : nicePath(fi.filePath()); // remove "./" at start
 
     m_bSymLink = fi.isSymLink();
     if(m_bSymLink || (!m_bExists && m_filePath.contains("@@")))
     {
         createData();
     }
 
     if(m_bUseData)
         d()->m_pParent = pParent;
     else
         m_pParent = pParent;
 
     if(parent() || d()) // if a parent is specified then we arrive here because of listing a directory
     {
         m_bFile = fi.isFile();
         m_bDir = fi.isDir();
         m_bExists = fi.exists();
         m_size = fi.size();
         m_modificationTime = fi.lastModified();
         m_bHidden = fi.isHidden();
 
 #if defined(Q_OS_WIN)
         m_bWritable = pParent == 0 || fi.isWritable(); // in certain situations this might become a problem though
 #else
         m_bWritable = fi.isWritable();
 #endif
     }
 
     if(d() != nullptr)
     {
 #if defined(Q_OS_WIN)
         // On some windows machines in a network this takes very long.
         // and it's not so important anyway.
         d()->m_bReadable = true;
         d()->m_bExecutable = false;
 #else
         d()->m_bReadable = fi.isReadable();
         d()->m_bExecutable = fi.isExecutable();
 #endif
 
         //d()->m_creationTime = fi.created();
         //d()->m_modificationTime = fi.lastModified();
         //d()->m_accessTime = fi.lastRead();
         d()->m_name = fi.fileName();
         if(m_bSymLink)
         {
             d()->m_linkTarget = fi.readLink();
 #ifndef Q_OS_WIN 
             // Unfortunately Qt5 symLinkTarget/readLink always returns an absolute path, even if the link is relative
             char s[PATH_MAX + 1];
             ssize_t len = readlink(QFile::encodeName(fi.absoluteFilePath()).constData(), s, PATH_MAX);
             if(len > 0)
             {
                 s[len] = '\0';
                 d()->m_linkTarget = QFile::decodeName(s);
             }
 #endif
         }
         d()->m_bLocal = true;
         d()->m_bValidData = true;
         d()->m_url = QUrl::fromLocalFile(fi.filePath());
         if(d()->m_url.isRelative())
         {
             d()->m_url.setPath(absoluteFilePath());
         }
 
         if(!m_bExists && absoluteFilePath().contains("@@"))
         {
             // Try reading a clearcase file
             d()->m_localCopy = FileAccess::tempFileName();
             QString cmd = "cleartool get -to \"" + d()->m_localCopy + "\"  \"" + absoluteFilePath() + "\"";
             QProcess process;
             process.start(cmd);
             process.waitForFinished(-1);
             //::system( cmd.local8Bit() );
             QFile::setPermissions(d()->m_localCopy, QFile::ReadUser | QFile::WriteUser); // Clearcase creates a write protected file, allow delete.
 
             QFileInfo fi(d()->m_localCopy);
 #if defined(Q_OS_WIN)
             d()->m_bReadable = true;    //fi.isReadable();
             m_bWritable = true;         //fi.isWritable();
             d()->m_bExecutable = false; //fi.isExecutable();
 #else
             d()->m_bReadable = fi.isReadable();
             d()->m_bExecutable = fi.isExecutable();
 #endif
             //d()->m_creationTime = fi.created();
             //d()->m_accessTime = fi.lastRead();
             m_bExists = fi.exists();
             m_size = fi.size();
         }
     }
 }
 
 void FileAccess::setFile(const QString& name, bool bWantToWrite)
 {
     m_bExists = false;
     m_bFile = false;
     m_bDir = false;
     m_bSymLink = false;
     m_size = 0;
     m_modificationTime = QDateTime();
 
     if(d() != nullptr)
     {
         d()->reset();
         d()->m_pParent = nullptr;
     }
     else
         m_pParent = nullptr;
 
     // Note: Checking if the filename-string is empty is necessary for Win95/98/ME.
     //       The isFile() / isDir() queries would cause the program to crash.
     //       (This is a Win95-bug which has been corrected only in WinNT/2000/XP.)
     if(!name.isEmpty())
     {
         QUrl url = QUrl::fromUserInput(name, QString(), QUrl::AssumeLocalFile);
 
         // FileAccess tries to detect if the given name is an URL or a local file.
         // This is a problem if the filename looks like an URL (i.e. contains a colon ':').
         // e.g. "file:f.txt" is a valid filename.
         // Most of the time it is sufficient to check if the file exists locally.
         // 2 Problems remain:
         //   1. When the local file exists and the remote location is wanted nevertheless. (unlikely)
         //   2. When the local file doesn't exist and should be written to.
 
         bool bExistsLocal = QDir().exists(name);
         if(url.isLocalFile() || url.isRelative() || !url.isValid() || bExistsLocal) // assuming that invalid means relative
         {
             QString localName = name;
 
 #if defined(Q_OS_WIN)
-            if(localName.startsWith("/tmp/"))
+            if(localName.startsWith(QLatin1String{"/tmp/")))
             {
                 // git on Cygwin will put files in /tmp
                 // A workaround for the a native kdiff3 binary to find them...
 
                 QString cygwinBin = getenv("CYGWIN_BIN");
                 if(!cygwinBin.isEmpty())
                 {
                     localName = QString("%1\\..%2").arg(cygwinBin).arg(name);
                 }
             }
 #endif
 
             if(!bExistsLocal && url.isLocalFile() && name.left(5).toLower() == "file:")
             {
                 localName = url.path(); // I want the path without preceding "file:"
             }
 
             QFileInfo fi(localName);
             setFile(fi, nullptr);
         }
         else
         {
             createData();
             d()->m_url = url;
             d()->m_name = d()->m_url.fileName();
             d()->m_bLocal = false;
 
             FileAccessJobHandler jh(this);            // A friend, which writes to the parameters of this class!
             jh.stat(2 /*all details*/, bWantToWrite); // returns bSuccess, ignored
 
             m_filePath = name;
             d()->m_bValidData = true; // After running stat() the variables are initialised
                                       // and valid even if the file doesn't exist and the stat
                                       // query failed.
         }
     }
 }
 
 void FileAccess::addPath(const QString& txt)
 {
     if(d() != nullptr && d()->m_url.isValid())
     {
         QUrl url = d()->m_url.adjusted(QUrl::StripTrailingSlash);
         d()->m_url.setPath(url.path() + '/' + txt);
         setFile(d()->m_url.url()); // reinitialise
     }
     else
     {
         QString slash = (txt.isEmpty() || txt[0] == '/') ? "" : "/";
         setFile(absoluteFilePath() + slash + txt);
     }
 }
 
 /*     Filetype:
        S_IFMT     0170000   bitmask for the file type bitfields
        S_IFSOCK   0140000   socket
        S_IFLNK    0120000   symbolic link
        S_IFREG    0100000   regular file
        S_IFBLK    0060000   block device
        S_IFDIR    0040000   directory
        S_IFCHR    0020000   character device
        S_IFIFO    0010000   fifo
        S_ISUID    0004000   set UID bit
        S_ISGID    0002000   set GID bit (see below)
        S_ISVTX    0001000   sticky bit (see below)
 
        Access:
        S_IRWXU    00700     mask for file owner permissions
        S_IRUSR    00400     owner has read permission
        S_IWUSR    00200     owner has write permission
        S_IXUSR    00100     owner has execute permission
        S_IRWXG    00070     mask for group permissions
        S_IRGRP    00040     group has read permission
        S_IWGRP    00020     group has write permission
        S_IXGRP    00010     group has execute permission
        S_IRWXO    00007     mask for permissions for others (not in group)
        S_IROTH    00004     others have read permission
        S_IWOTH    00002     others have write permisson
        S_IXOTH    00001     others have execute permission
 */
 //TODO: Change this to kf5/kde auto test
 #ifdef Q_OS_WIN
 void FileAccess::setUdsEntry(const KIO::UDSEntry&)
 {
 } // not needed if KDE is not available
 #else
 void FileAccess::setUdsEntry(const KIO::UDSEntry& e)
 {
     long acc = 0;
     long fileType = 0;
     QVector<uint> fields = e.fields();
     for(QVector<uint>::ConstIterator ei = fields.constBegin(); ei != fields.constEnd(); ++ei)
     {
         uint f = *ei;
         switch(f)
         {
         case KIO::UDSEntry::UDS_SIZE:
             m_size = e.numberValue(f);
             break;
         //case KIO::UDSEntry::UDS_USER :               d()->m_user   = e.stringValue(f);    break;
         //case KIO::UDSEntry::UDS_GROUP :              d()->m_group  = e.stringValue(f);    break;
         case KIO::UDSEntry::UDS_NAME:
             m_filePath = e.stringValue(f);
             break; // During listDir the relative path is given here.
         case KIO::UDSEntry::UDS_MODIFICATION_TIME:
             m_modificationTime = QDateTime::fromMSecsSinceEpoch(e.numberValue(f));
             break;
         //case KIO::UDSEntry::UDS_ACCESS_TIME :       d()->m_accessTime.setTime_t( e.numberValue(f) ); break;
         //case KIO::UDSEntry::UDS_CREATION_TIME :     d()->m_creationTime.setTime_t( e.numberValue(f) ); break;
         case KIO::UDSEntry::UDS_LINK_DEST:
             d()->m_linkTarget = e.stringValue(f);
             break;
         case KIO::UDSEntry::UDS_ACCESS:
         {
             acc = e.numberValue(f);
             d()->m_bReadable = (acc & S_IRUSR) != 0;
             m_bWritable = (acc & S_IWUSR) != 0;
             d()->m_bExecutable = (acc & S_IXUSR) != 0;
             break;
         }
         case KIO::UDSEntry::UDS_FILE_TYPE:
         {
             fileType = e.numberValue(f);
             m_bDir = (fileType & S_IFMT) == S_IFDIR;
             m_bFile = (fileType & S_IFMT) == S_IFREG;
             m_bSymLink = (fileType & S_IFMT) == S_IFLNK;
             m_bExists = fileType != 0;
             //d()->m_fileType = fileType;
             break;
         }
 
         case KIO::UDSEntry::UDS_URL: // m_url = QUrlFix( e.stringValue(f) );
             break;
         case KIO::UDSEntry::UDS_MIME_TYPE:
             break;
         case KIO::UDSEntry::UDS_GUESSED_MIME_TYPE:
             break;
         case KIO::UDSEntry::UDS_XML_PROPERTIES:
             break;
         default:
             break;
         }
     }
 
     m_bExists = acc != 0 || fileType != 0;
 
     d()->m_bLocal = false;
     d()->m_bValidData = true;
     m_bSymLink = !d()->m_linkTarget.isEmpty();
     if(d()->m_name.isEmpty())
     {
         int pos = m_filePath.lastIndexOf('/') + 1;
         d()->m_name = m_filePath.mid(pos);
     }
     m_bHidden = d()->m_name[0] == '.';
 }
 #endif
 
 bool FileAccess::isValid() const
 {
     return d() == nullptr ? !m_filePath.isEmpty() : d()->m_bValidData;
 }
 
 bool FileAccess::isFile() const
 {
     if(parent() || d())
         return m_bFile;
     else
         return QFileInfo(absoluteFilePath()).isFile();
 }
 
 bool FileAccess::isDir() const
 {
     if(parent() || d())
         return m_bDir;
     else
         return QFileInfo(absoluteFilePath()).isDir();
 }
 
 bool FileAccess::isSymLink() const
 {
     return m_bSymLink;
 }
 
 bool FileAccess::exists() const
 {
     if(parent() || d())
         return m_bExists;
     else
         return QFileInfo::exists(absoluteFilePath());
 }
 
 qint64 FileAccess::size() const
 {
     if(parent() || d())
         return m_size;
     else
         return QFileInfo(absoluteFilePath()).size();
 }
 
 QUrl FileAccess::url() const
 {
     if(d() != nullptr)
         return d()->m_url;
     else
     {
         QUrl url = QUrl::fromLocalFile(m_filePath);
         if(url.isRelative())
         {
             url.setPath(absoluteFilePath());
         }
         return url;
     }
 }
 
 bool FileAccess::isLocal() const
 {
     return d() == nullptr || d()->m_bLocal;
 }
 
 bool FileAccess::isReadable() const
 {
 #if defined(Q_OS_WIN)
     // On some windows machines in a network this takes very long to find out and it's not so important anyway.
     return true;
 #else
     if(d() != nullptr)
         return d()->m_bReadable;
     else
         return QFileInfo(absoluteFilePath()).isReadable();
 #endif
 }
 
 bool FileAccess::isWritable() const
 {
     if(parent() || d())
         return m_bWritable;
     else
         return QFileInfo(absoluteFilePath()).isWritable();
 }
 
 bool FileAccess::isExecutable() const
 {
 #if defined(Q_OS_WIN)
     // On some windows machines in a network this takes very long to find out and it's not so important anyway.
     return true;
 #else
     if(d() != nullptr)
         return d()->m_bExecutable;
     else
         return QFileInfo(absoluteFilePath()).isExecutable();
 #endif
 }
 
 bool FileAccess::isHidden() const
 {
     if(parent() || d())
         return m_bHidden;
     else
         return QFileInfo(absoluteFilePath()).isHidden();
 }
 
 QString FileAccess::readLink() const
 {
     if(d() != nullptr)
         return d()->m_linkTarget;
     else
         return QString();
 }
 
 QString FileAccess::absoluteFilePath() const
 {
     if(parent() != nullptr)
         return parent()->absoluteFilePath() + "/" + m_filePath;
     else
     {
         if(m_filePath.isEmpty())
             return QString();
 
         if(!isLocal())
             return m_filePath; // return complete url
 
         QFileInfo fi(m_filePath);
         if(fi.isAbsolute())
             return m_filePath;
         else
             return fi.absoluteFilePath(); // Probably never reached
     }
 } // Full abs path
 
 // Just the name-part of the path, without parent directories
 QString FileAccess::fileName() const
 {
     if(d() != nullptr)
         return d()->m_name;
     else if(parent())
         return m_filePath;
     else
         return QFileInfo(m_filePath).fileName();
 }
 
 void FileAccess::setSharedName(const QString& name)
 {
     if(name == m_filePath)
         m_filePath = name; // reduce memory because string is only used once.
 }
 
 QString FileAccess::filePath() const
 {
     if(parent() && parent()->parent())
         return parent()->filePath() + "/" + m_filePath;
     else
         return m_filePath; // The path-string that was used during construction
 }
 
 FileAccess* FileAccess::parent() const
 {
     if(m_bUseData)
         return d()->m_pParent;
     else
         return m_pParent;
 }
 
 FileAccess::Data* FileAccess::d()
 {
     if(m_bUseData)
         return m_pData;
     else
         return nullptr;
 }
 
 const FileAccess::Data* FileAccess::d() const
 {
     if(m_bUseData)
         return m_pData;
     else
         return nullptr;
 }
 
 QString FileAccess::prettyAbsPath() const
 {
     return isLocal() ? absoluteFilePath() : d()->m_url.toDisplayString();
 }
 
 /*
 QDateTime FileAccess::created() const
 {
    if ( d()!=0 )
    {
       if ( isLocal() && d()->m_creationTime.isNull() )
          const_cast<FileAccess*>(this)->d()->m_creationTime = QFileInfo( absoluteFilePath() ).created();
       return ( d()->m_creationTime.isValid() ?  d()->m_creationTime : lastModified() );
    }
    else
    {
       QDateTime created = QFileInfo( absoluteFilePath() ).created();
       return created.isValid() ? created : lastModified();
    }
 }
 */
 
 QDateTime FileAccess::lastModified() const
 {
     if(isLocal() && m_modificationTime.isNull())
         const_cast<FileAccess*>(this)->m_modificationTime = QFileInfo(absoluteFilePath()).lastModified();
     return m_modificationTime;
 }
 
 /*
 QDateTime FileAccess::lastRead() const
 {
    QDateTime accessTime = d()!=0 ? d()->m_accessTime : QFileInfo( absoluteFilePath() ).lastRead();
    return ( accessTime.isValid() ?  accessTime : lastModified() );
 }
 */
 
 static bool interruptableReadFile(QFile& f, void* pDestBuffer, qint64 maxLength)
 {
     ProgressProxy pp;
     const qint64 maxChunkSize = 100000;
     qint64 i = 0;
     pp.setMaxNofSteps(maxLength / maxChunkSize + 1);
     while(i < maxLength)
     {
         qint64 nextLength = min2(maxLength - i, maxChunkSize);
         qint64 reallyRead = f.read((char*)pDestBuffer + i, nextLength);
         if(reallyRead != nextLength)
         {
             return false;
         }
         i += reallyRead;
 
         pp.setCurrent(double(i) / maxLength);
         if(pp.wasCancelled())
             return false;
     }
     return true;
 }
 
 bool FileAccess::readFile(void* pDestBuffer, qint64 maxLength)
 {
     if(d() != nullptr && !d()->m_localCopy.isEmpty())
     {
         QFile f(d()->m_localCopy);
         if(f.open(QIODevice::ReadOnly))
             return interruptableReadFile(f, pDestBuffer, maxLength); // maxLength == f.read( (char*)pDestBuffer, maxLength );
     }
     else if(isLocal())
     {
         QFile f(absoluteFilePath());
 
         if(f.open(QIODevice::ReadOnly))
             return interruptableReadFile(f, pDestBuffer, maxLength); //maxLength == f.read( (char*)pDestBuffer, maxLength );
     }
     else
     {
         FileAccessJobHandler jh(this);
         return jh.get(pDestBuffer, maxLength);
     }
     return false;
 }
 
 bool FileAccess::writeFile(const void* pSrcBuffer, qint64 length)
 {
     ProgressProxy pp;
     if(isLocal())
     {
         QFile f(absoluteFilePath());
         if(f.open(QIODevice::WriteOnly))
         {
             const qint64 maxChunkSize = 100000;
             pp.setMaxNofSteps(length / maxChunkSize + 1);
             qint64 i = 0;
             while(i < length)
             {
                 qint64 nextLength = min2(length - i, maxChunkSize);
                 qint64 reallyWritten = f.write((char*)pSrcBuffer + i, nextLength);
                 if(reallyWritten != nextLength)
                 {
                     return false;
                 }
                 i += reallyWritten;
 
                 pp.step();
                 if(pp.wasCancelled())
                     return false;
             }
             f.close();
 #ifndef Q_OS_WIN
             if(isExecutable()) // value is true if the old file was executable
             {
                 // Preserve attributes
                 f.setPermissions(f.permissions() | QFile::ExeUser);
                 //struct stat srcFileStatus;
                 //int statResult = ::stat( filePath().toLocal8Bit().constData(), &srcFileStatus );
                 //if (statResult==0)
                 //{
                 //   ::chmod ( filePath().toLocal8Bit().constData(), srcFileStatus.st_mode | S_IXUSR );
                 //}
             }
 #endif
 
             return true;
         }
     }
     else
     {
         FileAccessJobHandler jh(this);
         return jh.put(pSrcBuffer, length, true /*overwrite*/);
     }
     return false;
 }
 
 bool FileAccess::copyFile(const QString& dest)
 {
     FileAccessJobHandler jh(this);
     return jh.copyFile(dest); // Handles local and remote copying.
 }
 
 bool FileAccess::rename(const QString& dest)
 {
     FileAccessJobHandler jh(this);
     return jh.rename(dest);
 }
 
 bool FileAccess::removeFile()
 {
     if(isLocal())
     {
         return QDir().remove(absoluteFilePath());
     }
     else
     {
         FileAccessJobHandler jh(this);
         return jh.removeFile(url());
     }
 }
 
 bool FileAccess::removeFile(const QString& name) // static
 {
     return FileAccess(name).removeFile();
 }
 
 bool FileAccess::listDir(t_DirectoryList* pDirList, bool bRecursive, bool bFindHidden,
                          const QString& filePattern, const QString& fileAntiPattern, const QString& dirAntiPattern,
                          bool bFollowDirLinks, bool bUseCvsIgnore)
 {
     FileAccessJobHandler jh(this);
     return jh.listDir(pDirList, bRecursive, bFindHidden, filePattern, fileAntiPattern,
                       dirAntiPattern, bFollowDirLinks, bUseCvsIgnore);
 }
 
 QString FileAccess::tempFileName()
 {
     QTemporaryFile tmpFile;
     tmpFile.open();
     //tmpFile.setAutoDelete( true );  // We only want the name. Delete the precreated file immediately.
     QString name = tmpFile.fileName() + ".2";
     tmpFile.close();
     return name;
 }
 
 bool FileAccess::removeTempFile(const QString& name) // static
 {
-    if(name.endsWith(".2"))
+    if(name.endsWith(QLatin1String(".2")))
         FileAccess(name.left(name.length() - 2)).removeFile();
     return FileAccess(name).removeFile();
 }
 
 bool FileAccess::makeDir(const QString& dirName)
 {
     FileAccessJobHandler fh(nullptr);
     return fh.mkDir(dirName);
 }
 
 bool FileAccess::removeDir(const QString& dirName)
 {
     FileAccessJobHandler fh(nullptr);
     return fh.rmDir(dirName);
 }
 
 #if defined(Q_OS_WIN)
 bool FileAccess::symLink(const QString& /*linkTarget*/, const QString& /*linkLocation*/)
 {
     return false;
 }
 #else
 bool FileAccess::symLink(const QString& linkTarget, const QString& linkLocation)
 {
     return 0 == ::symlink(linkTarget.toLocal8Bit().constData(), linkLocation.toLocal8Bit().constData());
     //FileAccessJobHandler fh(0);
     //return fh.symLink( linkTarget, linkLocation );
 }
 #endif
 
 bool FileAccess::exists(const QString& name)
 {
     FileAccess fa(name);
     return fa.exists();
 }
 
 // If the size couldn't be determined by stat() then the file is copied to a local temp file.
 qint64 FileAccess::sizeForReading()
 {
     if(!isLocal() && m_size == 0)
     {
         // Size couldn't be determined. Copy the file to a local temp place.
         QString localCopy = tempFileName();
         bool bSuccess = copyFile(localCopy);
         if(bSuccess)
         {
             QFileInfo fi(localCopy);
             m_size = fi.size();
             d()->m_localCopy = localCopy;
             return m_size;
         }
         else
         {
             return 0;
         }
     }
     else
         return size();
 }
 
 QString FileAccess::getStatusText()
 {
     return d() == nullptr ? QString() : d()->m_statusText;
 }
 
 void FileAccess::setStatusText(const QString& s)
 {
     if(!s.isEmpty() || d() != nullptr)
     {
         createData();
         d()->m_statusText = s;
     }
 }
 
 QString FileAccess::cleanPath(const QString& path) // static
 {
     QUrl url = QUrl::fromUserInput(path, QString(""), QUrl::AssumeLocalFile);
     if(url.isLocalFile() || !url.isValid())
     {
         return QDir().cleanPath(path);
     }
     else
     {
         return path;
     }
 }
 
 bool FileAccess::createBackup(const QString& bakExtension)
 {
     if(exists())
     {
         createData();
         setFile(absoluteFilePath()); // make sure Data is initialized
         // First rename the existing file to the bak-file. If a bak-file file exists, delete that.
         QString bakName = absoluteFilePath() + bakExtension;
         FileAccess bakFile(bakName, true /*bWantToWrite*/);
         if(bakFile.exists())
         {
             bool bSuccess = bakFile.removeFile();
             if(!bSuccess)
             {
                 setStatusText(i18n("While trying to make a backup, deleting an older backup failed.\nFilename: %1", bakName));
                 return false;
             }
         }
         bool bSuccess = rename(bakName);
         if(!bSuccess)
         {
             setStatusText(i18n("While trying to make a backup, renaming failed.\nFilenames: %1 -> %2",
                                absoluteFilePath(), bakName));
             return false;
         }
     }
     return true;
 }
 
 FileAccessJobHandler::FileAccessJobHandler(FileAccess* pFileAccess)
 {
     m_pFileAccess = pFileAccess;
     m_bSuccess = false;
 }
 
 bool FileAccessJobHandler::stat(int detail, bool bWantToWrite)
 {
     m_bSuccess = false;
     m_pFileAccess->setStatusText(QString());
     KIO::StatJob* pStatJob = KIO::stat(m_pFileAccess->url(),
                                        bWantToWrite ? KIO::StatJob::DestinationSide : KIO::StatJob::SourceSide,
                                        detail, KIO::HideProgressInfo);
 
     connect(pStatJob, &KIO::StatJob::result, this, &FileAccessJobHandler::slotStatResult);
 
     ProgressProxy::enterEventLoop(pStatJob, i18n("Getting file status: %1", m_pFileAccess->prettyAbsPath()));
 
     return m_bSuccess;
 }
 
 void FileAccessJobHandler::slotStatResult(KJob* pJob)
 {
     if(pJob->error())
     {
         //pJob->uiDelegate()->showErrorMessage();
         m_pFileAccess->m_bExists = false;
         m_bSuccess = true;
     }
     else
     {
         m_bSuccess = true;
 
         m_pFileAccess->d()->m_bValidData = true;
         const KIO::UDSEntry e = static_cast<KIO::StatJob*>(pJob)->statResult();
 
         m_pFileAccess->setUdsEntry(e);
     }
 
     ProgressProxy::exitEventLoop();
 }
 
 bool FileAccessJobHandler::get(void* pDestBuffer, long maxLength)
 {
     ProgressProxyExtender pp; // Implicitly used in slotPercent()
     if(maxLength > 0 && !pp.wasCancelled())
     {
         KIO::TransferJob* pJob = KIO::get(m_pFileAccess->url(), KIO::NoReload);
         m_transferredBytes = 0;
         m_pTransferBuffer = (char*)pDestBuffer;
         m_maxLength = maxLength;
         m_bSuccess = false;
         m_pFileAccess->setStatusText(QString());
 
         connect(pJob, &KIO::TransferJob::result, this, &FileAccessJobHandler::slotSimpleJobResult);
         connect(pJob, &KIO::TransferJob::data, this, &FileAccessJobHandler::slotGetData);
         connect(pJob, SIGNAL(percent(KJob*, qint64)), &pp, SLOT(slotPercent(KJob*, qint64)));
 
         ProgressProxy::enterEventLoop(pJob, i18n("Reading file: %1", m_pFileAccess->prettyAbsPath()));
         return m_bSuccess;
     }
     else
         return true;
 }
 
 void FileAccessJobHandler::slotGetData(KJob* pJob, const QByteArray& newData)
 {
     if(pJob->error())
     {
         pJob->uiDelegate()->showErrorMessage();
     }
     else
     {
         qint64 length = min2(qint64(newData.size()), m_maxLength - m_transferredBytes);
         ::memcpy(m_pTransferBuffer + m_transferredBytes, newData.data(), newData.size());
         m_transferredBytes += length;
     }
 }
 
 bool FileAccessJobHandler::put(const void* pSrcBuffer, long maxLength, bool bOverwrite, bool bResume, int permissions)
 {
     ProgressProxyExtender pp; // Implicitly used in slotPercent()
     if(maxLength > 0)
     {
         KIO::TransferJob* pJob = KIO::put(m_pFileAccess->url(), permissions,
                                           KIO::HideProgressInfo | (bOverwrite ? KIO::Overwrite : KIO::DefaultFlags) | (bResume ? KIO::Resume : KIO::DefaultFlags));
         m_transferredBytes = 0;
         m_pTransferBuffer = (char*)pSrcBuffer;
         m_maxLength = maxLength;
         m_bSuccess = false;
         m_pFileAccess->setStatusText(QString());
 
         connect(pJob, &KIO::TransferJob::result, this, &FileAccessJobHandler::slotPutJobResult);
         connect(pJob, &KIO::TransferJob::dataReq, this, &FileAccessJobHandler::slotPutData);
         connect(pJob, SIGNAL(percent(KJob*, qint64)), &pp, SLOT(slotPercent(KJob*, qint64)));
 
         ProgressProxy::enterEventLoop(pJob, i18n("Writing file: %1", m_pFileAccess->prettyAbsPath()));
         return m_bSuccess;
     }
     else
         return true;
 }
 
 void FileAccessJobHandler::slotPutData(KIO::Job* pJob, QByteArray& data)
 {
     if(pJob->error())
     {
         pJob->uiDelegate()->showErrorMessage();
     }
     else
     {
         /*
             Think twice before doing this in new code.        
             The maxChunkSize must be able to fit a 32-bit int. Given that the fallowing is safe.
             
         */
         qint64 maxChunkSize = 100000;
         qint64 length = min2(maxChunkSize, m_maxLength - m_transferredBytes);
         data.resize((int)length);
         if(data.size() == (int)length)
         {
             if(length > 0)
             {
                 ::memcpy(data.data(), m_pTransferBuffer + m_transferredBytes, data.size());
                 m_transferredBytes += length;
             }
         }
         else
         {
             KMessageBox::error(ProgressProxy::getDialog(), i18n("Out of memory"));
             data.resize(0);
             m_bSuccess = false;
         }
     }
 }
 
 void FileAccessJobHandler::slotPutJobResult(KJob* pJob)
 {
     if(pJob->error())
     {
         pJob->uiDelegate()->showErrorMessage();
     }
     else
     {
         m_bSuccess = (m_transferredBytes == m_maxLength); // Special success condition
     }
     ProgressProxy::exitEventLoop(); // Close the dialog, return from exec()
 }
 
 bool FileAccessJobHandler::mkDir(const QString& dirName)
 {
     QUrl dirURL = QUrl::fromUserInput(dirName, QString(""), QUrl::AssumeLocalFile);
     if(dirName.isEmpty())
         return false;
     else if(dirURL.isLocalFile() || dirURL.isRelative())
     {
         return QDir().mkdir(dirURL.path());
     }
     else
     {
         m_bSuccess = false;
         KIO::SimpleJob* pJob = KIO::mkdir(dirURL);
         connect(pJob, &KIO::SimpleJob::result, this, &FileAccessJobHandler::slotSimpleJobResult);
 
         ProgressProxy::enterEventLoop(pJob, i18n("Making directory: %1", dirName));
         return m_bSuccess;
     }
 }
 
 bool FileAccessJobHandler::rmDir(const QString& dirName)
 {
     QUrl dirURL = QUrl::fromUserInput(dirName, QString(""), QUrl::AssumeLocalFile);
     if(dirName.isEmpty())
         return false;
     else if(dirURL.isLocalFile())
     {
         return QDir().rmdir(dirURL.path());
     }
     else
     {
         m_bSuccess = false;
         KIO::SimpleJob* pJob = KIO::rmdir(dirURL);
         connect(pJob, &KIO::SimpleJob::result, this, &FileAccessJobHandler::slotSimpleJobResult);
 
         ProgressProxy::enterEventLoop(pJob, i18n("Removing directory: %1", dirName));
         return m_bSuccess;
     }
 }
 
 bool FileAccessJobHandler::removeFile(const QUrl& fileName)
 {
     if(fileName.isEmpty())
         return false;
     else
     {
         m_bSuccess = false;
         KIO::SimpleJob* pJob = KIO::file_delete(fileName, KIO::HideProgressInfo);
         connect(pJob, &KIO::SimpleJob::result, this, &FileAccessJobHandler::slotSimpleJobResult);
 
         ProgressProxy::enterEventLoop(pJob, i18n("Removing file: %1", fileName.toDisplayString()));
         return m_bSuccess;
     }
 }
 
 bool FileAccessJobHandler::symLink(const QUrl& linkTarget, const QUrl& linkLocation)
 {
     if(linkTarget.isEmpty() || linkLocation.isEmpty())
         return false;
     else
     {
         m_bSuccess = false;
         KIO::CopyJob* pJob = KIO::link(linkTarget, linkLocation, KIO::HideProgressInfo);
         connect(pJob, &KIO::CopyJob::result, this, &FileAccessJobHandler::slotSimpleJobResult);
 
         ProgressProxy::enterEventLoop(pJob,
                                       i18n("Creating symbolic link: %1 -> %2", linkLocation.toDisplayString(), linkTarget.toDisplayString()));
         return m_bSuccess;
     }
 }
 
 bool FileAccessJobHandler::rename(const QString& dest)
 {
     if(dest.isEmpty())
         return false;
 
     QUrl kurl = QUrl::fromUserInput(dest, QString(""), QUrl::AssumeLocalFile);
     if(kurl.isRelative())
         kurl = QUrl::fromUserInput(QDir().absoluteFilePath(dest), QString(""), QUrl::AssumeLocalFile); // assuming that invalid means relative
 
     if(m_pFileAccess->isLocal() && kurl.isLocalFile())
     {
         return QDir().rename(m_pFileAccess->absoluteFilePath(), kurl.path());
     }
     else
     {
         ProgressProxyExtender pp;
         int permissions = -1;
         m_bSuccess = false;
         KIO::FileCopyJob* pJob = KIO::file_move(m_pFileAccess->url(), kurl, permissions, KIO::HideProgressInfo);
         connect(pJob, &KIO::FileCopyJob::result, this, &FileAccessJobHandler::slotSimpleJobResult);
         connect(pJob, SIGNAL(percent(KJob*, qint64)), &pp, SLOT(slotPercent(KJob*, qint64)));
 
         ProgressProxy::enterEventLoop(pJob,
                                       i18n("Renaming file: %1 -> %2", m_pFileAccess->prettyAbsPath(), dest));
         return m_bSuccess;
     }
 }
 
 void FileAccessJobHandler::slotSimpleJobResult(KJob* pJob)
 {
     if(pJob->error())
     {
         pJob->uiDelegate()->showErrorMessage();
     }
     else
     {
         m_bSuccess = true;
     }
     ProgressProxy::exitEventLoop(); // Close the dialog, return from exec()
 }
 
 // Copy local or remote files.
 bool FileAccessJobHandler::copyFile(const QString& dest)
 {
     ProgressProxyExtender pp;
     QUrl destUrl = QUrl::fromUserInput(dest, QString(""), QUrl::AssumeLocalFile);
     m_pFileAccess->setStatusText(QString());
     if(!m_pFileAccess->isLocal() || !destUrl.isLocalFile()) // if either url is nonlocal
     {
         int permissions = (m_pFileAccess->isExecutable() ? 0111 : 0) + (m_pFileAccess->isWritable() ? 0222 : 0) + (m_pFileAccess->isReadable() ? 0444 : 0);
         m_bSuccess = false;
         KIO::FileCopyJob* pJob = KIO::file_copy(m_pFileAccess->url(), destUrl, permissions, KIO::HideProgressInfo);
         connect(pJob, &KIO::FileCopyJob::result, this, &FileAccessJobHandler::slotSimpleJobResult);
         connect(pJob, SIGNAL(percent(KJob*, qint64)), &pp, SLOT(slotPercent(KJob*, qint64)));
         ProgressProxy::enterEventLoop(pJob,
                                       i18n("Copying file: %1 -> %2", m_pFileAccess->prettyAbsPath(), dest));
 
         return m_bSuccess;
         // Note that the KIO-slave preserves the original date, if this is supported.
     }
 
     // Both files are local:
     QString srcName = m_pFileAccess->absoluteFilePath();
     QString destName = dest;
     QFile srcFile(srcName);
     QFile destFile(destName);
     bool bReadSuccess = srcFile.open(QIODevice::ReadOnly);
     if(bReadSuccess == false)
     {
         m_pFileAccess->setStatusText(i18n("Error during file copy operation: Opening file for reading failed. Filename: %1", srcName));
         return false;
     }
     bool bWriteSuccess = destFile.open(QIODevice::WriteOnly);
     if(bWriteSuccess == false)
     {
         m_pFileAccess->setStatusText(i18n("Error during file copy operation: Opening file for writing failed. Filename: %1", destName));
         return false;
     }
 
     std::vector<char> buffer(100000);
     qint64 bufSize = buffer.size();
     qint64 srcSize = srcFile.size();
     while(srcSize > 0 && !pp.wasCancelled())
     {
         qint64 readSize = srcFile.read(&buffer[0], min2(srcSize, bufSize));
         if(readSize == -1 || readSize == 0)
         {
             m_pFileAccess->setStatusText(i18n("Error during file copy operation: Reading failed. Filename: %1", srcName));
             return false;
         }
         srcSize -= readSize;
         while(readSize > 0)
         {
             qint64 writeSize = destFile.write(&buffer[0], readSize);
             if(writeSize == -1 || writeSize == 0)
             {
                 m_pFileAccess->setStatusText(i18n("Error during file copy operation: Writing failed. Filename: %1", destName));
                 return false;
             }
             readSize -= writeSize;
         }
         destFile.flush();
         pp.setCurrent((double)(srcFile.size() - srcSize) / srcFile.size(), false);
     }
     srcFile.close();
     destFile.close();
 
 // Update the times of the destFile
 #ifdef Q_OS_WIN
     struct _stat srcFileStatus;
     int statResult = ::_stat(srcName.toLocal8Bit().constData(), &srcFileStatus);
     if(statResult == 0)
     {
         _utimbuf destTimes;
         destTimes.actime = srcFileStatus.st_atime;  /* time of last access */
         destTimes.modtime = srcFileStatus.st_mtime; /* time of last modification */
 
         _utime(destName.toLocal8Bit().constData(), &destTimes);
         _chmod(destName.toLocal8Bit().constData(), srcFileStatus.st_mode);
     }
 #else
     struct stat srcFileStatus;
     int statResult = ::stat(srcName.toLocal8Bit().constData(), &srcFileStatus);
     if(statResult == 0)
     {
         utimbuf destTimes;
         destTimes.actime = srcFileStatus.st_atime;  /* time of last access */
         destTimes.modtime = srcFileStatus.st_mtime; /* time of last modification */
 
         utime(destName.toLocal8Bit().constData(), &destTimes);
         chmod(destName.toLocal8Bit().constData(), srcFileStatus.st_mode);
     }
 #endif
     return true;
 }
 
 bool wildcardMultiMatch(const QString& wildcard, const QString& testString, bool bCaseSensitive)
 {
     static QHash<QString, QRegExp> s_patternMap;
 
     QStringList sl = wildcard.split(";");
 
     for(QStringList::Iterator it = sl.begin(); it != sl.end(); ++it)
     {
         QHash<QString, QRegExp>::iterator patIt = s_patternMap.find(*it);
         if(patIt == s_patternMap.end())
         {
             QRegExp pattern(*it, bCaseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive, QRegExp::Wildcard);
             patIt = s_patternMap.insert(*it, pattern);
         }
 
         if(patIt.value().exactMatch(testString))
             return true;
     }
 
     return false;
 }
 
 // class CvsIgnoreList from Cervisia cvsdir.cpp
 //    Copyright (C) 1999-2002 Bernd Gehrmann <bernd at mail.berlios.de>
 // with elements from class StringMatcher
 //    Copyright (c) 2003 Andre Woebbeking <Woebbeking at web.de>
 // Modifications for KDiff3 by Joachim Eibl
 class CvsIgnoreList
 {
   public:
     CvsIgnoreList() {}
     void init(FileAccess& dir, bool bUseLocalCvsIgnore);
     bool matches(const QString& fileName, bool bCaseSensitive) const;
 
   private:
     void addEntriesFromString(const QString& str);
     void addEntriesFromFile(const QString& name);
     void addEntry(const QString& entry);
 
     QStringList m_exactPatterns;
     QStringList m_startPatterns;
     QStringList m_endPatterns;
     QStringList m_generalPatterns;
 };
 
 void CvsIgnoreList::init(FileAccess& dir, bool bUseLocalCvsIgnore)
 {
     static const char* ignorestr = ". .. core RCSLOG tags TAGS RCS SCCS .make.state "
                                    ".nse_depinfo #* .#* cvslog.* ,* CVS CVS.adm .del-* *.a *.olb *.o *.obj "
                                    "*.so *.Z *~ *.old *.elc *.ln *.bak *.BAK *.orig *.rej *.exe _$* *$";
 
     addEntriesFromString(QString::fromLatin1(ignorestr));
     addEntriesFromFile(QDir::homePath() + "/.cvsignore");
     addEntriesFromString(QString::fromLocal8Bit(::getenv("CVSIGNORE")));
 
     if(bUseLocalCvsIgnore)
     {
         FileAccess file(dir);
         file.addPath(".cvsignore");
         qint64 size = file.exists() ? file.sizeForReading() : 0;
         if(size > 0)
         {
             char* buf = new char[size];
             if(buf != nullptr)
             {
                 file.readFile(buf, size);
                 int pos1 = 0;
                 for(int pos = 0; pos <= size; ++pos)
                 {
                     if(pos == size || buf[pos] == ' ' || buf[pos] == '\t' || buf[pos] == '\n' || buf[pos] == '\r')
                     {
                         if(pos > pos1)
                         {
                             addEntry(QString::fromLatin1(&buf[pos1], pos - pos1));
                         }
                         ++pos1;
                     }
                 }
                 delete[] buf;
             }
         }
     }
 }
 
 void CvsIgnoreList::addEntriesFromString(const QString& str)
 {
     int posLast(0);
     int pos;
     while((pos = str.indexOf(' ', posLast)) >= 0)
     {
         if(pos > posLast)
             addEntry(str.mid(posLast, pos - posLast));
         posLast = pos + 1;
     }
 
     if(posLast < static_cast<int>(str.length()))
         addEntry(str.mid(posLast));
 }
 
 void CvsIgnoreList::addEntriesFromFile(const QString& name)
 {
     QFile file(name);
 
     if(file.open(QIODevice::ReadOnly))
     {
         QTextStream stream(&file);
         while(!stream.atEnd())
         {
             addEntriesFromString(stream.readLine());
         }
     }
 }
 
 void CvsIgnoreList::addEntry(const QString& pattern)
 {
     if(pattern != QString("!"))
     {
         if(pattern.isEmpty()) return;
 
         // The general match is general but slow.
         // Special tests for '*' and '?' at the beginning or end of a pattern
         // allow fast checks.
 
         // Count number of '*' and '?'
         unsigned int nofMetaCharacters = 0;
 
         const QChar* pos;
         pos = pattern.unicode();
         const QChar* posEnd;
         posEnd = pos + pattern.length();
         while(pos < posEnd)
         {
             if(*pos == QChar('*') || *pos == QChar('?')) ++nofMetaCharacters;
             ++pos;
         }
 
         if(nofMetaCharacters == 0)
         {
             m_exactPatterns.append(pattern);
         }
         else if(nofMetaCharacters == 1)
         {
             if(pattern.at(0) == QChar('*'))
             {
                 m_endPatterns.append(pattern.right(pattern.length() - 1));
             }
             else if(pattern.at(pattern.length() - 1) == QChar('*'))
             {
                 m_startPatterns.append(pattern.left(pattern.length() - 1));
             }
             else
             {
                 m_generalPatterns.append(pattern.toLocal8Bit());
             }
         }
         else
         {
             m_generalPatterns.append(pattern.toLocal8Bit());
         }
     }
     else
     {
         m_exactPatterns.clear();
         m_startPatterns.clear();
         m_endPatterns.clear();
         m_generalPatterns.clear();
     }
 }
 
 bool CvsIgnoreList::matches(const QString& text, bool bCaseSensitive) const
 {
     if(m_exactPatterns.indexOf(text) >= 0)
     {
         return true;
     }
 
     QStringList::ConstIterator it;
     QStringList::ConstIterator itEnd;
     for(it = m_startPatterns.begin(), itEnd = m_startPatterns.end(); it != itEnd; ++it)
     {
         if(text.startsWith(*it))
         {
             return true;
         }
     }
 
     for(it = m_endPatterns.begin(), itEnd = m_endPatterns.end(); it != itEnd; ++it)
     {
         if(text.mid(text.length() - (*it).length()) == *it) //(text.endsWith(*it))
         {
             return true;
         }
     }
 
     /*
     for (QValueList<QCString>::const_iterator it(m_generalPatterns.begin()),
                                               itEnd(m_generalPatterns.end());
          it != itEnd; ++it)
     {
         if (::fnmatch(*it, text.local8Bit(), FNM_PATHNAME) == 0)
         {
             return true;
         }
     }
     */
 
     for(it = m_generalPatterns.begin(); it != m_generalPatterns.end(); ++it)
     {
         QRegExp pattern(*it, bCaseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive, QRegExp::Wildcard);
         if(pattern.exactMatch(text))
             return true;
     }
 
     return false;
 }
 
 static bool cvsIgnoreExists(t_DirectoryList* pDirList)
 {
     t_DirectoryList::iterator i;
     for(i = pDirList->begin(); i != pDirList->end(); ++i)
     {
         if(i->fileName() == ".cvsignore")
             return true;
     }
     return false;
 }
 
 bool FileAccessJobHandler::listDir(t_DirectoryList* pDirList, bool bRecursive, bool bFindHidden, const QString& filePattern,
                                    const QString& fileAntiPattern, const QString& dirAntiPattern, bool bFollowDirLinks, bool bUseCvsIgnore)
 {
     ProgressProxyExtender pp;
     m_pDirList = pDirList;
     m_pDirList->clear();
     m_bFindHidden = bFindHidden;
     m_bRecursive = bRecursive;
     m_bFollowDirLinks = bFollowDirLinks; // Only relevant if bRecursive==true.
     m_fileAntiPattern = fileAntiPattern;
     m_filePattern = filePattern;
     m_dirAntiPattern = dirAntiPattern;
 
     if(pp.wasCancelled())
         return true; // Cancelled is not an error.
 
     pp.setInformation(i18n("Reading directory: %1", m_pFileAccess->absoluteFilePath()), 0, false);
 
     if(m_pFileAccess->isLocal())
     {
         QString currentPath = QDir::currentPath();
         m_bSuccess = QDir::setCurrent(m_pFileAccess->absoluteFilePath());
         if(m_bSuccess)
         {
 #ifndef Q_OS_WIN
             m_bSuccess = true;
             QDir dir(".");
 
             dir.setSorting(QDir::Name | QDir::DirsFirst);
             dir.setFilter(QDir::Files | QDir::Dirs | /* from KDE3 QDir::TypeMaskDirs | */ QDir::Hidden | QDir::System);
 
             QFileInfoList fiList = dir.entryInfoList();
             if(fiList.isEmpty())
             {
                 // No Permission to read directory or other error.
                 m_bSuccess = false;
             }
             else
             {
                 foreach(const QFileInfo& fi, fiList) // for each file...
                 {
                     if(fi.fileName() == "." || fi.fileName() == "..")
                         continue;
 
                     FileAccess fa;
                     fa.setFile(fi, m_pFileAccess);
                     pDirList->push_back(fa);
                 }
             }
 #else
             QString pattern = "*.*";
             WIN32_FIND_DATA findData;
 
             Qt::HANDLE searchHandle = FindFirstFileW((const wchar_t*)pattern.utf16(), &findData);
 
             if(searchHandle != INVALID_HANDLE_VALUE)
             {
                 QString absPath = m_pFileAccess->absoluteFilePath();
                 QString relPath = m_pFileAccess->filePath();
                 bool bFirst = true;
                 while(!pp.wasCancelled())
                 {
                     if(!bFirst)
                     {
                         if(!FindNextFileW(searchHandle, &findData))
                             break;
                     }
                     bFirst = false;
                     FileAccess fa;
 
                     fa.m_filePath = QString::fromUtf16((const ushort*)findData.cFileName);
                     if(fa.m_filePath != "." && fa.m_filePath != "..")
                     {
                         fa.m_size = (qint64(findData.nFileSizeHigh) << 32) + findData.nFileSizeLow;
 
                         FILETIME ft;
                         SYSTEMTIME t;
                         FileTimeToLocalFileTime(&findData.ftLastWriteTime, &ft);
                         FileTimeToSystemTime(&ft, &t);
                         fa.m_modificationTime = QDateTime(QDate(t.wYear, t.wMonth, t.wDay), QTime(t.wHour, t.wMinute, t.wSecond));
                         //FileTimeToLocalFileTime( &findData.ftLastAccessTime, &ft ); FileTimeToSystemTime(&ft,&t);
                         //fa.m_accessTime       = QDateTime( QDate(t.wYear, t.wMonth, t.wDay), QTime(t.wHour, t.wMinute, t.wSecond) );
                         //FileTimeToLocalFileTime( &findData.ftCreationTime, &ft ); FileTimeToSystemTime(&ft,&t);
                         //fa.m_creationTime     = QDateTime( QDate(t.wYear, t.wMonth, t.wDay), QTime(t.wHour, t.wMinute, t.wSecond) );
 
                         int a = findData.dwFileAttributes;
                         fa.m_bWritable = (a & FILE_ATTRIBUTE_READONLY) == 0;
                         fa.m_bDir = (a & FILE_ATTRIBUTE_DIRECTORY) != 0;
                         fa.m_bFile = !fa.m_bDir;
                         fa.m_bHidden = (a & FILE_ATTRIBUTE_HIDDEN) != 0;
 
                         //fa.m_bExecutable = false; // Useless on windows
                         fa.m_bExists = true;
                         //fa.m_bReadable   = true;
                         //fa.m_bLocal      = true;
                         //fa.m_bValidData  = true;
                         fa.m_bSymLink = false;
                         //fa.m_fileType    = 0;
 
                         //fa.m_filePath = fa.m_name;
                         //fa.m_absoluteFilePath = absPath + "/" + fa.m_name;
                         //fa.m_url.setPath( fa.m_absoluteFilePath );
                         if(fa.d())
                             fa.m_pData->m_pParent = m_pFileAccess;
                         else
                             fa.m_pParent = m_pFileAccess;
                         pDirList->push_back(fa);
                     }
                 }
                 FindClose(searchHandle);
             }
             else
             {
                 QDir::setCurrent(currentPath); // restore current path
                 return false;
             }
 #endif
         }
         QDir::setCurrent(currentPath); // restore current path
     }
     else
     {
         KIO::ListJob* pListJob = nullptr;
         pListJob = KIO::listDir(m_pFileAccess->url(), KIO::HideProgressInfo, true /*bFindHidden*/);
 
         m_bSuccess = false;
         if(pListJob != nullptr)
         {
             connect(pListJob, &KIO::ListJob::entries, this, &FileAccessJobHandler::slotListDirProcessNewEntries);
             connect(pListJob, &KIO::ListJob::result, this, &FileAccessJobHandler::slotSimpleJobResult);
 
             connect(pListJob, &KIO::ListJob::infoMessage, &pp, &ProgressProxyExtender::slotListDirInfoMessage);
 
             // This line makes the transfer via fish unreliable.:-(
             //connect( pListJob, SIGNAL(percent(KJob*,qint64)), &pp, SLOT(slotPercent(KJob*, qint64)));
 
             ProgressProxy::enterEventLoop(pListJob,
                                           i18n("Listing directory: %1", m_pFileAccess->prettyAbsPath()));
         }
     }
 
     CvsIgnoreList cvsIgnoreList;
     if(bUseCvsIgnore)
     {
         cvsIgnoreList.init(*m_pFileAccess, cvsIgnoreExists(pDirList));
     }
 #if defined(Q_OS_WIN)
     bool bCaseSensitive = false;
 #else
     bool bCaseSensitive = true;
 #endif
 
     // Now remove all entries that should be ignored:
     t_DirectoryList::iterator i;
     for(i = pDirList->begin(); i != pDirList->end();)
     {
         t_DirectoryList::iterator i2 = i;
         ++i2;
         QString fn = i->fileName();
         if((!bFindHidden && i->isHidden()) ||
            (i->isFile() &&
             (!wildcardMultiMatch(filePattern, fn, bCaseSensitive) ||
              wildcardMultiMatch(fileAntiPattern, fn, bCaseSensitive))) ||
            (i->isDir() && wildcardMultiMatch(dirAntiPattern, fn, bCaseSensitive)) ||
            cvsIgnoreList.matches(fn, bCaseSensitive))
         {
             // Remove it
             pDirList->erase(i);
             i = i2;
         }
         else
         {
             ++i;
         }
     }
 
     if(bRecursive)
     {
         t_DirectoryList subDirsList;
 
         t_DirectoryList::iterator i;
         for(i = m_pDirList->begin(); i != m_pDirList->end(); ++i)
         {
             if(i->isDir() && (!i->isSymLink() || m_bFollowDirLinks))
             {
                 t_DirectoryList dirList;
                 i->listDir(&dirList, bRecursive, bFindHidden,
                            filePattern, fileAntiPattern, dirAntiPattern, bFollowDirLinks, bUseCvsIgnore);
 
                 t_DirectoryList::iterator j;
                 for(j = dirList.begin(); j != dirList.end(); ++j)
                 {
                     if(j->parent() == nullptr)
                         j->m_filePath = i->fileName() + "/" + j->m_filePath;
                 }
 
                 // append data onto the main list
                 subDirsList.splice(subDirsList.end(), dirList);
             }
         }
 
         m_pDirList->splice(m_pDirList->end(), subDirsList);
     }
 
     return m_bSuccess;
 }
 
 void FileAccessJobHandler::slotListDirProcessNewEntries(KIO::Job*, const KIO::UDSEntryList& l)
 {
     //This function is called for non-local urls. Don't use QUrl::fromLocalFile here as it does not handle these.
     QUrl parentUrl = QUrl::fromUserInput(m_pFileAccess->absoluteFilePath(), QString(""), QUrl::AssumeLocalFile);
 
     KIO::UDSEntryList::ConstIterator i;
     for(i = l.begin(); i != l.end(); ++i)
     {
         const KIO::UDSEntry& e = *i;
         FileAccess fa;
         fa.createData();
         fa.m_pData->m_pParent = m_pFileAccess;
         fa.setUdsEntry(e);
 
         if(fa.fileName() != "." && fa.fileName() != "..")
         {
             fa.d()->m_url = parentUrl;
             QUrl url = fa.d()->m_url.adjusted(QUrl::StripTrailingSlash);
             fa.d()->m_url.setPath(url.path() + "/" + fa.fileName());
             //fa.d()->m_absoluteFilePath = fa.url().url();
             m_pDirList->push_back(fa);
         }
     }
 }
 
 void ProgressProxyExtender::slotListDirInfoMessage(KJob*, const QString& msg)
 {
     setInformation(msg, 0);
 }
 
 void ProgressProxyExtender::slotPercent(KJob*, qint64 percent)
 {
     setCurrent(percent);
 }
 
 //#include "fileaccess.moc"
diff --git a/src/kdiff3.h b/src/kdiff3.h
index ed77e4a..4d9ccc9 100644
--- a/src/kdiff3.h
+++ b/src/kdiff3.h
@@ -1,432 +1,432 @@
 /***************************************************************************
                           kdiff3.h  -  description
                              -------------------
     begin                : Don Jul 11 12:31:29 CEST 2002
     copyright            : (C) 2002-2007 by Joachim Eibl
     email                : joachim.eibl at gmx.de
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #ifndef KDIFF3_H
 #define KDIFF3_H
 
 #include "diff.h"
 
 // include files for Qt
 #include <QSplitter>
 #include <QScrollBar>
 #include <QPointer>
 #include <QEventLoop>
 
 // include files for KDE
 #include <QApplication>
 #include <KMainWindow>
 #include <QAction>
 #include <QUrl>
 #include <KParts/MainWindow>
 #include <KToggleAction>
 #include <KAboutData>
 #include <KSharedConfig>
 #include <KConfigGroup>
 // forward declaration of the KDiff3 classes
 class OptionDialog;
 class FindDialog;
 class ManualDiffHelpDialog;
 class DiffTextWindow;
 class DiffTextWindowFrame;
 class MergeResultWindow;
 class WindowTitleWidget;
 class Overview;
 
 class QScrollBar;
 class QSplitter;
 class QStatusBar;
 class QMenu;
 
 class KToggleAction;
 class KToolBar;
 class KActionCollection;
 
 namespace KParts {
 	class MainWindow;
 }
 
 class KDiff3Part;
 class DirectoryMergeWindow;
 class DirectoryMergeInfo;
 
 
 class ReversibleScrollBar : public QScrollBar
 {
    Q_OBJECT
    bool* m_pbRightToLeftLanguage;
    int m_realVal;
 public:
    ReversibleScrollBar( Qt::Orientation o, bool* pbRightToLeftLanguage )
       : QScrollBar( o )
    {
       m_pbRightToLeftLanguage=pbRightToLeftLanguage;
       m_realVal=0;
       connect( this, SIGNAL(valueChanged(int)), this, SLOT(slotValueChanged(int)));
    }
    void setAgain(){ setValue(m_realVal); }
 public Q_SLOTS:
    void slotValueChanged(int i)
    {
       m_realVal = i;
       if(m_pbRightToLeftLanguage && *m_pbRightToLeftLanguage)
          m_realVal = maximum()-(i-minimum());
       emit valueChanged2(m_realVal);
    }
    void setValue(int i)
    {
       if(m_pbRightToLeftLanguage && *m_pbRightToLeftLanguage)
          QScrollBar::setValue( maximum()-(i-minimum())  );
       else
          QScrollBar::setValue( i );
    }
    int value() const
    {
       return m_realVal;
    }
 Q_SIGNALS:
    void valueChanged2(int);
 };
 
 class KDiff3App : public QSplitter
 {
   Q_OBJECT
 
   public:
     /** constructor of KDiff3App, calls all init functions to create the application.
      */
     KDiff3App( QWidget* parent, const QString name, KDiff3Part* pKDiff3Part );
     ~KDiff3App() override;
 
     bool isPart();
 
     /** initializes the KActions of the application */
     void initActions( KActionCollection* );
 
     /** save general Options like all bar positions and status as well as the geometry
         and the recent file list to the configuration file */
     void saveOptions( KSharedConfigPtr );
 
     /** read general Options again and initialize all variables like the recent file list */
     void readOptions( KSharedConfigPtr );
 
     // Finish initialisation (virtual, so that it can be called from the shell too.)
     virtual void completeInit(const QString& fn1="", const QString& fn2="", const QString& fn3="");
 
     /** queryClose is called by KMainWindow on each closeEvent of a window. Against the
      * default implementation (only returns true), this calles saveModified() on the document object to ask if the document shall
      * be saved if Modified; on cancel the closeEvent is rejected.
      * @see KMainWindow#queryClose
      * @see KMainWindow#closeEvent
      */
     virtual bool queryClose();
     virtual bool isFileSaved();
     virtual bool isDirComparison();
 
   Q_SIGNALS:
      void createNewInstance( const QString& fn1, const QString& fn2, const QString& fn3 );
   protected:
     void initDirectoryMergeActions();
     /** sets up the statusbar for the main window by initialzing a statuslabel. */
     void initStatusBar();
 
     /** creates the centerwidget of the KMainWindow instance and sets it as the view */
     void initView();
 
   public Q_SLOTS:
 
     /** open a file and load it into the document*/
     void slotFileOpen();
     void slotFileOpen2( QString fn1, QString fn2, QString fn3, QString ofn,
                         QString an1, QString an2, QString an3, TotalDiffStatus* pTotalDiffStatus );
 
     void slotFileNameChanged(const QString& fileName, int winIdx);
 
     /** save a document */
     void slotFileSave();
     /** save a document by a new filename*/
     void slotFileSaveAs();
 
     void slotFilePrint();
 
     /** closes all open windows by calling close() on each memberList item until the list is empty, then quits the application.
      * If queryClose() returns false because the user canceled the saveModified() dialog, the closing breaks.
      */
     void slotFileQuit();
     /** put the marked text/object into the clipboard and remove
      *  it from the document
      */
     void slotEditCut();
     /** put the marked text/object into the clipboard
      */
     void slotEditCopy();
     /** paste the clipboard into the document
      */
     void slotEditPaste();
     /** toggles the toolbar
      */
     void slotViewToolBar();
     /** toggles the statusbar
      */
     void slotViewStatusBar();
     /** changes the statusbar contents for the standard label permanently, used to indicate current actions.
      * @param text the text that is displayed in the statusbar
      */
     void slotStatusMsg(const QString &text);
 
   private:
     /** the configuration object of the application */
     //KConfig *config;
 
     // QAction pointers to enable/disable actions
     QAction *fileOpen;
     QAction *fileSave;
     QAction *fileSaveAs;
     QAction *filePrint;
     QAction *fileQuit;
     QAction *fileReload;
     QAction *editCut;
     QAction *editCopy;
     QAction *editPaste;
     QAction *editSelectAll;
     KToggleAction* viewToolBar;
     KToggleAction* viewStatusBar;
 
 ////////////////////////////////////////////////////////////////////////
 // Special KDiff3 specific stuff starts here
     QAction *editFind;
     QAction *editFindNext;
 
     QAction *goCurrent;
     QAction *goTop;
     QAction *goBottom;
     QAction *goPrevUnsolvedConflict;
     QAction *goNextUnsolvedConflict;
     QAction *goPrevConflict;
     QAction *goNextConflict;
     QAction *goPrevDelta;
     QAction *goNextDelta;
     KToggleAction *chooseA;
     KToggleAction *chooseB;
     KToggleAction *chooseC;
     KToggleAction *autoAdvance;
     KToggleAction *wordWrap;
     QAction * splitDiff;
     QAction * joinDiffs;
     QAction * addManualDiffHelp;
     QAction * clearManualDiffHelpList;
     KToggleAction *showWhiteSpaceCharacters;
     KToggleAction *showWhiteSpace;
     KToggleAction *showLineNumbers;
     QAction * chooseAEverywhere;
     QAction * chooseBEverywhere;
     QAction * chooseCEverywhere;
     QAction * chooseAForUnsolvedConflicts;
     QAction * chooseBForUnsolvedConflicts;
     QAction * chooseCForUnsolvedConflicts;
     QAction * chooseAForUnsolvedWhiteSpaceConflicts;
     QAction * chooseBForUnsolvedWhiteSpaceConflicts;
     QAction * chooseCForUnsolvedWhiteSpaceConflicts;
     QAction * autoSolve;
     QAction * unsolve;
     QAction * mergeHistory;
     QAction * mergeRegExp;
     KToggleAction *showWindowA;
     KToggleAction *showWindowB;
     KToggleAction *showWindowC;
     QAction *winFocusNext;
     QAction *winFocusPrev;
     QAction *winToggleSplitOrientation;
     KToggleAction *dirShowBoth;
     QAction *dirViewToggle;
     KToggleAction *overviewModeNormal;
     KToggleAction *overviewModeAB;
     KToggleAction *overviewModeAC;
     KToggleAction *overviewModeBC;
 
 
     QMenu* m_pMergeEditorPopupMenu;
 
     QSplitter*  m_pMainSplitter;
     QWidget*    m_pMainWidget;
     QWidget*    m_pMergeWindowFrame;
     ReversibleScrollBar* m_pHScrollBar;
     QScrollBar* m_pDiffVScrollBar;
     QScrollBar* m_pMergeVScrollBar;
 
     DiffTextWindow* m_pDiffTextWindow1;
     DiffTextWindow* m_pDiffTextWindow2;
     DiffTextWindow* m_pDiffTextWindow3;
     DiffTextWindowFrame* m_pDiffTextWindowFrame1;
     DiffTextWindowFrame* m_pDiffTextWindowFrame2;
     DiffTextWindowFrame* m_pDiffTextWindowFrame3;
     QSplitter* m_pDiffWindowSplitter;
 
     MergeResultWindow* m_pMergeResultWindow;
     WindowTitleWidget* m_pMergeResultWindowTitle;
     bool m_bTripleDiff;
 
     QSplitter* m_pDirectoryMergeSplitter;
     DirectoryMergeWindow* m_pDirectoryMergeWindow;
     DirectoryMergeInfo* m_pDirectoryMergeInfo;
     bool m_bDirCompare;
 
     Overview* m_pOverview;
 
     QWidget* m_pCornerWidget;
 
     TotalDiffStatus m_totalDiffStatus;
 
     SourceData m_sd1;
     SourceData m_sd2;
     SourceData m_sd3;
 
    QString m_outputFilename;
    bool m_bDefaultFilename;
 
    DiffList m_diffList12;
    DiffList m_diffList23;
    DiffList m_diffList13;
 
    DiffBufferInfo m_diffBufferInfo;
    Diff3LineList m_diff3LineList;
    Diff3LineVector m_diff3LineVector;
    //ManualDiffHelpDialog* m_pManualDiffHelpDialog;
    ManualDiffHelpList m_manualDiffHelpList;
 
    int m_neededLines;
    int m_DTWHeight;
    bool m_bOutputModified;
    bool m_bFileSaved;
-   bool m_bTimerBlock;      // Synchronisation
+   bool m_bTimerBlock;      // Synchronization
 
    OptionDialog* m_pOptionDialog;
    Options*      m_pOptions;
    FindDialog*   m_pFindDialog;
 
    void mainInit( TotalDiffStatus* pTotalDiffStatus=nullptr, bool bLoadFiles=true, bool bUseCurrentEncoding = false);
    bool m_bFinishMainInit;
    bool m_bLoadFiles;
 
    bool eventFilter( QObject* o, QEvent* e ) override;
    void resizeEvent(QResizeEvent*) override;
    void childEvent(QChildEvent *c) override;
 
    bool improveFilenames(bool bCreateNewInstance);
 
    bool canContinue();
 
    void choose(int choice);
 
    KActionCollection* actionCollection();
    QStatusBar*        statusBar();
    KToolBar*          toolBar(const char*);
    KDiff3Part*        m_pKDiff3Part;
    KParts::MainWindow*       m_pKDiff3Shell;
    bool m_bAutoFlag;
    bool m_bAutoMode;
    void recalcWordWrap(int nofVisibleColumns=-1);
    bool m_bRecalcWordWrapPosted;
    void setHScrollBarRange();
 
    int m_iCumulativeWheelDelta;
 
    int m_visibleTextWidthForPrinting; // only needed during recalcWordWrap
    int m_firstD3LIdx;                   // only needed during recalcWordWrap
    QPointer<QEventLoop> m_pEventLoopForPrinting;
 
 public Q_SLOTS:
    void resizeDiffTextWindowHeight(int newHeight);
    void resizeMergeResultWindow();
    void slotRecalcWordWrap();
    void postRecalcWordWrap();
    void slotFinishRecalcWordWrap();
 
    void showPopupMenu( const QPoint& point );
 
    void scrollDiffTextWindow( int deltaX, int deltaY );
    void scrollMergeResultWindow( int deltaX, int deltaY );
    void setDiff3Line( int line );
    void sourceMask( int srcMask, int enabledMask );
 
    void slotDirShowBoth();
    void slotDirViewToggle();
 
    void slotUpdateAvailabilities();
    void slotEditSelectAll();
    void slotEditFind();
    void slotEditFindNext();
    void slotGoCurrent();
    void slotGoTop();
    void slotGoBottom();
    void slotGoPrevUnsolvedConflict();
    void slotGoNextUnsolvedConflict();
    void slotGoPrevConflict();
    void slotGoNextConflict();
    void slotGoPrevDelta();
    void slotGoNextDelta();
    void slotChooseA();
    void slotChooseB();
    void slotChooseC();
    void slotAutoSolve();
    void slotUnsolve();
    void slotMergeHistory();
    void slotRegExpAutoMerge();
    void slotChooseAEverywhere();
    void slotChooseBEverywhere();
    void slotChooseCEverywhere();
    void slotChooseAForUnsolvedConflicts();
    void slotChooseBForUnsolvedConflicts();
    void slotChooseCForUnsolvedConflicts();
    void slotChooseAForUnsolvedWhiteSpaceConflicts();
    void slotChooseBForUnsolvedWhiteSpaceConflicts();
    void slotChooseCForUnsolvedWhiteSpaceConflicts();
    void slotConfigure();
    void slotConfigureKeys();
    void slotRefresh();
    void slotSelectionEnd();
    void slotSelectionStart();
    void slotClipboardChanged();
    void slotOutputModified(bool);
    void slotFinishMainInit();
    void slotMergeCurrentFile();
    void slotReload();
    void slotCheckIfCanContinue( bool* pbContinue );
    void slotShowWhiteSpaceToggled();
    void slotShowLineNumbersToggled();
    void slotAutoAdvanceToggled();
    void slotWordWrapToggled();
    void slotShowWindowAToggled();
    void slotShowWindowBToggled();
    void slotShowWindowCToggled();
    void slotWinFocusNext();
    void slotWinFocusPrev();
    void slotWinToggleSplitterOrientation();
    void slotOverviewNormal();
    void slotOverviewAB();
    void slotOverviewAC();
    void slotOverviewBC();
    void slotSplitDiff();
    void slotJoinDiffs();
    void slotAddManualDiffHelp();
    void slotClearManualDiffHelpList();
    void slotNoRelevantChangesDetected();
    void slotEncodingChangedA(QTextCodec*);
    void slotEncodingChangedB(QTextCodec*);
    void slotEncodingChangedC(QTextCodec*);
 };
 
 #endif // KDIFF3_H
diff --git a/src/kdiff3os2.rc b/src/kdiff3os2.rc
index bdf7832..f0e4704 100644
--- a/src/kdiff3os2.rc
+++ b/src/kdiff3os2.rc
@@ -1 +1 @@
-ICON 1    DISCARDABLE     "kdiff3_os2.ico"
\ No newline at end of file
+ICON 1    DISCARDABLE     "kdiff3_os2.ico"
diff --git a/src/main.cpp b/src/main.cpp
index 4d24d9c..f38f9a8 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,212 +1,212 @@
 /***************************************************************************
                           main.cpp  -  Where everything starts.
                              -------------------
     begin                : Don Jul 11 12:31:29 CEST 2002
     copyright            : (C) 2002-2007 by Joachim Eibl
     email                : joachim.eibl at gmx.de
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 #include "common.h"
 #include "kdiff3_shell.h"
 #include "version.h"
 
 #include <KAboutData>
 #include <KCrash/KCrash>
 #include <KLocalizedString>
 
 #include <QApplication>
 #include <QCommandLineOption>
 #include <QCommandLineParser>
 #include <QFile>
 #include <QFont>
 #include <QLocale>
 #include <QMessageBox>
 #include <QStandardPaths>
 #include <QTextCodec>
 #include <QTextStream>
 #include <QTranslator>
 //#include <QClipboard>
 #include <vector>
 
 #ifdef Q_OS_WIN
 #include <process.h>
 #include <qt_windows.h>
 #endif
 
 void initialiseCmdLineArgs(QCommandLineParser* cmdLineParser)
 {
     QString configFileName = QStandardPaths::locate(QStandardPaths::GenericConfigLocation, "kdiff3rc");
     QFile configFile(configFileName);
     QString ignorableOptionsLine = "-u;-query;-html;-abort";
     if(configFile.open(QIODevice::ReadOnly))
     {
         QTextStream ts(&configFile);
         while(!ts.atEnd())
         {
             QString line = ts.readLine();
-            if(line.startsWith("IgnorableCmdLineOptions="))
+            if(line.startsWith(QLatin1String("IgnorableCmdLineOptions=")))
             {
                 int pos = line.indexOf('=');
                 if(pos >= 0)
                 {
                     ignorableOptionsLine = line.mid(pos + 1);
                 }
                 break;
             }
         }
     }
     //support our own old preferances this is obsolete
     QStringList sl = ignorableOptionsLine.split(',');
 
     if(!sl.isEmpty())
     {
         QStringList ignorableOptions = sl.front().split(';');
         for(QStringList::iterator i = ignorableOptions.begin(); i != ignorableOptions.end(); ++i)
         {
             (*i).remove('-');
             if(!(*i).isEmpty())
             {
                 if(i->length() == 1) {
                     cmdLineParser->addOption(QCommandLineOption(QStringList() << i->toLatin1() << QLatin1String("ignore"), i18n("Ignored. (User defined.)")));
                 }
                 else
                 {
                     cmdLineParser->addOption(QCommandLineOption(QStringList() << i->toLatin1(), i18n("Ignored. (User defined.)")));
                 }
             }
         }
     }
 }
 
 #ifdef Q_OS_WIN
 // This command checks the comm
 static bool isOptionUsed(const QString& s, int argc, char* argv[])
 {
     for(int j = 0; j < argc; ++j)
     {
         if(QString("-" + s) == argv[j] || QString("--" + s) == argv[j])
         {
             return true;
         }
     }
     return false;
 }
 #endif
 
 int main(int argc, char* argv[])
 {
     QApplication app(argc, argv); // KAboutData and QCommandLineParser depend on this being setup.
     KLocalizedString::setApplicationDomain("kdiff3");
 
     KCrash::initialize();
 
     const QByteArray& appName = QByteArray::fromRawData("kdiff3", 6);
     const QString i18nName = i18n("KDiff3");
     QByteArray appVersion = QByteArray::fromRawData(VERSION, sizeof(VERSION));
     if(sizeof(void*) == 8)
         appVersion += " (64 bit)";
     else if(sizeof(void*) == 4)
         appVersion += " (32 bit)";
     const QString description = i18n("Tool for Comparison and Merge of Files and Directories");
     const QString copyright = i18n("(c) 2002-2014 Joachim Eibl, (c) 2017 Michael Reeves KF5/Qt5 port");
     const QString& homePage = QStringLiteral("");
     const QString& bugsAddress = QStringLiteral("reeves.87""@""gmail.com");
 
     KAboutData aboutData(appName, i18nName,
                          appVersion, description, KAboutLicense::GPL_V2, copyright, description,
                          homePage, bugsAddress);
 
     KAboutData::setApplicationData(aboutData);
 
     QCommandLineParser* cmdLineParser = KDiff3Shell::getParser();
     cmdLineParser->setApplicationDescription(aboutData.shortDescription());
     cmdLineParser->addVersionOption();
     cmdLineParser->addHelpOption();
 
     aboutData.setupCommandLine(cmdLineParser);
     
     initialiseCmdLineArgs(cmdLineParser);
     // ignorable command options
     cmdLineParser->addOption(QCommandLineOption(QStringList() << QLatin1String("m") << QLatin1String("merge"), i18n("Merge the input.")));
     cmdLineParser->addOption(QCommandLineOption(QStringList() << QLatin1String("b") << QLatin1String("base"), i18n("Explicit base file. For compatibility with certain tools."), QLatin1String("file")));
     cmdLineParser->addOption(QCommandLineOption(QStringList() << QLatin1String("o") << QLatin1String("output"), i18n("Output file. Implies -m. E.g.: -o newfile.txt"), QLatin1String("file")));
     cmdLineParser->addOption(QCommandLineOption(QStringList() << QLatin1String("out"), i18n("Output file, again. (For compatibility with certain tools.)"), QLatin1String("file")));
     cmdLineParser->addOption(QCommandLineOption(QStringList() << QLatin1String("auto"), i18n("No GUI if all conflicts are auto-solvable. (Needs -o file)")));
     cmdLineParser->addOption(QCommandLineOption(QStringList() << QLatin1String("qall"), i18n("Do not solve conflicts automatically.")));
     cmdLineParser->addOption(QCommandLineOption(QStringList() << QLatin1String("L1"), i18n("Visible name replacement for input file 1 (base)."), QLatin1String("alias1")));
     cmdLineParser->addOption(QCommandLineOption(QStringList() << QLatin1String("L2"), i18n("Visible name replacement for input file 2."), QLatin1String("alias2")));
     cmdLineParser->addOption(QCommandLineOption(QStringList() << QLatin1String("L3"), i18n("Visible name replacement for input file 3."), QLatin1String("alias3")));
     cmdLineParser->addOption(QCommandLineOption(QStringList() << QLatin1String("L") << QLatin1String("fname alias"), i18n("Alternative visible name replacement. Supply this once for every input.")));
     cmdLineParser->addOption(QCommandLineOption(QStringList() << QLatin1String("cs"), i18n("Override a config setting. Use once for every setting. E.g.: --cs \"AutoAdvance=1\""), QLatin1String("string")));
     cmdLineParser->addOption(QCommandLineOption(QStringList() << QLatin1String("confighelp"), i18n("Show list of config settings and current values.")));
     cmdLineParser->addOption(QCommandLineOption(QStringList() << QLatin1String("config"), i18n("Use a different config file."), QLatin1String("file")));
 
     // other command options
     cmdLineParser->addPositionalArgument(QLatin1String("[File1]"), i18n("file1 to open (base, if not specified via --base)"));
     cmdLineParser->addPositionalArgument(QLatin1String("[File2]"), i18n("file2 to open"));
     cmdLineParser->addPositionalArgument(QLatin1String("[File3]"), i18n("file3 to open"));
 
     /*
         Don't use QCommandLineParser::process as it auto terminates the program if an option is not reconized.
         Further more errors are directed to the console alone if not running on windows. This makes for a bad
         user experiance when run from a graphical interface such as kde. Don't assume that this only happens
         when running from a commandline.
     */
     if(!cmdLineParser->parse(QCoreApplication::arguments())) {
         QString errorMessage = cmdLineParser->errorText();
         QString helpText = cmdLineParser->helpText();
         QMessageBox::warning(nullptr, aboutData.displayName(), "<html><head/><body><h2>" + errorMessage + "</h2><pre>" + i18n("See kdiff3 --help for supported options.") + "</pre></body></html>");
 #if !defined(Q_OS_WIN) 
         fputs(qPrintable(errorMessage), stderr);
         fputs("\n\n", stderr);
         fputs(qPrintable(helpText + "\n"), stderr);
         fputs("\n", stderr);
 #endif
         exit(1);
     }
 
     if(cmdLineParser->isSet(QStringLiteral("version"))) {
         QMessageBox::information(nullptr, aboutData.displayName(),
                                  aboutData.displayName() + ' ' + aboutData.version());
 #if !defined(Q_OS_WIN) 
         printf("%s %s\n", appName.constData(), appVersion.constData());
 #endif
         exit(0);
     }
     if(cmdLineParser->isSet(QStringLiteral("help"))) {
         QMessageBox::warning(nullptr, aboutData.displayName(), "<html><head/><body><pre>" + cmdLineParser->helpText() + "</pre></body></html>");
 #if !defined(Q_OS_WIN) 
         fputs(qPrintable(cmdLineParser->helpText()), stdout);
 #endif
         exit(0);
     }
 
     aboutData.processCommandLine(cmdLineParser);
     /**
      * take component name and org. name from KAboutData
      */
     app.setApplicationName(aboutData.componentName());
     app.setApplicationDisplayName(aboutData.displayName());
     app.setOrganizationDomain(aboutData.organizationDomain());
     app.setApplicationVersion(aboutData.version());
 
     KDiff3Shell* p = new KDiff3Shell();
     p->show();
     //p->setWindowState( p->windowState() | Qt::WindowActive ); // Patch for ubuntu: window not active on startup
     //app.installEventFilter( new CFilter );
     int retVal = app.exec();
     /*  if (QApplication::clipboard()->text().size() == 0)
      QApplication::clipboard()->clear(); // Patch for Ubuntu: Fix issue with Qt clipboard*/
     return retVal;
 }
 
 // Suppress warning with --enable-final
 #undef VERSION
diff --git a/src/mergeresultwindow.cpp b/src/mergeresultwindow.cpp
index a55053e..3a9f363 100644
--- a/src/mergeresultwindow.cpp
+++ b/src/mergeresultwindow.cpp
@@ -1,3595 +1,3594 @@
 /***************************************************************************
                           mergeresultwindow.cpp  -  description
                              -------------------
     begin                : Sun Apr 14 2002
     copyright            : (C) 2002-2007 by Joachim Eibl
     email                : joachim.eibl at gmx.de
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #include "mergeresultwindow.h"
 #include "options.h"
 
 #include <QApplication>
 #include <QClipboard>
 #include <QComboBox>
 #include <QCursor>
 #include <QDir>
 #include <QFile>
 #include <QHBoxLayout>
 #include <QKeyEvent>
 #include <QLabel>
 #include <QLineEdit>
 #include <QMouseEvent>
 #include <QPainter>
 #include <QRegExp>
 #include <QStatusBar>
 #include <QTextCodec>
 #include <QTextLayout>
 #include <QTextStream>
 #include <QUrl>
 
 #include <QDropEvent>
 #include <QEvent>
 #include <QFocusEvent>
 #include <QInputEvent>
 #include <QMimeData>
 #include <QPaintEvent>
 #include <QPixmap>
 #include <QResizeEvent>
-#include <QTextStream>
 #include <QTimerEvent>
 #include <QWheelEvent>
 
 #include <KLocalizedString>
 #include <KMessageBox>
 
 int g_bAutoSolve = true;
 
 #undef leftInfoWidth
 
 MergeResultWindow::MergeResultWindow(
     QWidget* pParent,
     Options* pOptions,
     QStatusBar* pStatusBar)
     : QWidget(pParent)
 {
     setObjectName("MergeResultWindow");
     setFocusPolicy(Qt::ClickFocus);
 
     m_firstLine = 0;
     m_horizScrollOffset = 0;
     m_nofLines = 0;
     m_totalSize = 0;
     m_bMyUpdate = false;
     m_bInsertMode = true;
     m_scrollDeltaX = 0;
     m_scrollDeltaY = 0;
     m_bModified = false;
     m_eOverviewMode = Overview::eOMNormal;
 
     m_pldA = nullptr;
     m_pldB = nullptr;
     m_pldC = nullptr;
     m_sizeA = 0;
     m_sizeB = 0;
     m_sizeC = 0;
 
     m_pDiff3LineList = nullptr;
     m_pTotalDiffStatus = nullptr;
     m_pStatusBar = pStatusBar;
     if(m_pStatusBar)
         connect(m_pStatusBar, SIGNAL(messageChanged(const QString&)), this, SLOT(slotStatusMessageChanged(const QString&)));
 
     m_pOptions = pOptions;
     m_bPaintingAllowed = false;
     m_delayedDrawTimer = 0;
 
     m_cursorXPos = 0;
     m_cursorOldXPixelPos = 0;
     m_cursorYPos = 0;
     m_bCursorOn = true;
     m_bCursorUpdate = false;
     m_maxTextWidth = -1;
     connect(&m_cursorTimer, SIGNAL(timeout()), this, SLOT(slotCursorUpdate()));
     m_cursorTimer.setSingleShot(true);
     m_cursorTimer.start(500 /*ms*/);
     m_selection.reset();
 
     setMinimumSize(QSize(20, 20));
     setFont(m_pOptions->m_font);
 }
 
 void MergeResultWindow::init(
     const LineData* pLineDataA, LineRef sizeA,
     const LineData* pLineDataB, LineRef sizeB,
     const LineData* pLineDataC, LineRef sizeC,
     const Diff3LineList* pDiff3LineList,
     TotalDiffStatus* pTotalDiffStatus)
 {
     m_firstLine = 0;
     m_horizScrollOffset = 0;
     m_nofLines = 0;
     m_bMyUpdate = false;
     m_bInsertMode = true;
     m_scrollDeltaX = 0;
     m_scrollDeltaY = 0;
     setModified(false);
 
     m_pldA = pLineDataA;
     m_pldB = pLineDataB;
     m_pldC = pLineDataC;
     m_sizeA = sizeA;
     m_sizeB = sizeB;
     m_sizeC = sizeC;
 
     m_pDiff3LineList = pDiff3LineList;
     m_pTotalDiffStatus = pTotalDiffStatus;
 
     m_selection.reset();
     m_cursorXPos = 0;
     m_cursorOldXPixelPos = 0;
     m_cursorYPos = 0;
 
     m_maxTextWidth = -1;
 
     merge(g_bAutoSolve, -1);
     g_bAutoSolve = true;
     update();
     updateSourceMask();
 
     showUnsolvedConflictsStatusMessage();
 }
 
 void MergeResultWindow::showUnsolvedConflictsStatusMessage()
 {
     if(m_pStatusBar)
     {
         int wsc;
         int nofUnsolved = getNrOfUnsolvedConflicts(&wsc);
 
         m_persistentStatusMessage = i18n("Number of remaining unsolved conflicts: %1 (of which %2 are whitespace)", nofUnsolved, wsc);
         m_pStatusBar->showMessage(m_persistentStatusMessage);
     }
 }
 
 void MergeResultWindow::slotStatusMessageChanged(const QString& s)
 {
     if(s.isEmpty() && !m_persistentStatusMessage.isEmpty())
     {
         m_pStatusBar->showMessage(m_persistentStatusMessage, 0);
     }
 }
 
 void MergeResultWindow::reset()
 {
     m_pDiff3LineList = nullptr;
     m_pTotalDiffStatus = nullptr;
     m_pldA = nullptr;
     m_pldB = nullptr;
     m_pldC = nullptr;
     if(!m_persistentStatusMessage.isEmpty())
     {
         m_persistentStatusMessage = QString();
     }
 }
 
 // Calculate the merge information for the given Diff3Line.
 // Results will be stored in mergeDetails, bConflict, bLineRemoved and src.
 void mergeOneLine(
     const Diff3Line& d, e_MergeDetails& mergeDetails, bool& bConflict,
     bool& bLineRemoved, int& src, bool bTwoInputs)
 {
     mergeDetails = eDefault;
     bConflict = false;
     bLineRemoved = false;
     src = 0;
 
     if(bTwoInputs) // Only two input files
     {
         if(d.lineA != -1 && d.lineB != -1)
         {
             if(d.pFineAB == nullptr)
             {
                 mergeDetails = eNoChange;
                 src = A;
             }
             else
             {
                 mergeDetails = eBChanged;
                 bConflict = true;
             }
         }
         else
         {
             if(d.lineA != -1 && d.lineB == -1)
             {
                 mergeDetails = eBDeleted;
                 bConflict = true;
             }
             else if(d.lineA == -1 && d.lineB != -1)
             {
                 mergeDetails = eBDeleted;
                 bConflict = true;
             }
         }
         return;
     }
 
     // A is base.
     if(d.lineA != -1 && d.lineB != -1 && d.lineC != -1)
     {
         if(d.pFineAB == nullptr && d.pFineBC == nullptr && d.pFineCA == nullptr)
         {
             mergeDetails = eNoChange;
             src = A;
         }
         else if(d.pFineAB == nullptr && d.pFineBC != nullptr && d.pFineCA != nullptr)
         {
             mergeDetails = eCChanged;
             src = C;
         }
         else if(d.pFineAB != nullptr && d.pFineBC != nullptr && d.pFineCA == nullptr)
         {
             mergeDetails = eBChanged;
             src = B;
         }
         else if(d.pFineAB != nullptr && d.pFineBC == nullptr && d.pFineCA != nullptr)
         {
             mergeDetails = eBCChangedAndEqual;
             src = C;
         }
         else if(d.pFineAB != nullptr && d.pFineBC != nullptr && d.pFineCA != nullptr)
         {
             mergeDetails = eBCChanged;
             bConflict = true;
         }
         else
             Q_ASSERT(true);
     }
     else if(d.lineA != -1 && d.lineB != -1 && d.lineC == -1)
     {
         if(d.pFineAB != nullptr)
         {
             mergeDetails = eBChanged_CDeleted;
             bConflict = true;
         }
         else
         {
             mergeDetails = eCDeleted;
             bLineRemoved = true;
             src = C;
         }
     }
     else if(d.lineA != -1 && d.lineB == -1 && d.lineC != -1)
     {
         if(d.pFineCA != nullptr)
         {
             mergeDetails = eCChanged_BDeleted;
             bConflict = true;
         }
         else
         {
             mergeDetails = eBDeleted;
             bLineRemoved = true;
             src = B;
         }
     }
     else if(d.lineA == -1 && d.lineB != -1 && d.lineC != -1)
     {
         if(d.pFineBC != nullptr)
         {
             mergeDetails = eBCAdded;
             bConflict = true;
         }
         else // B==C
         {
             mergeDetails = eBCAddedAndEqual;
             src = C;
         }
     }
     else if(d.lineA == -1 && d.lineB == -1 && d.lineC != -1)
     {
         mergeDetails = eCAdded;
         src = C;
     }
     else if(d.lineA == -1 && d.lineB != -1 && d.lineC == -1)
     {
         mergeDetails = eBAdded;
         src = B;
     }
     else if(d.lineA != -1 && d.lineB == -1 && d.lineC == -1)
     {
         mergeDetails = eBCDeleted;
         bLineRemoved = true;
         src = C;
     }
     else
         Q_ASSERT(true);
 }
 
 bool MergeResultWindow::sameKindCheck(const MergeLine& ml1, const MergeLine& ml2)
 {
     if(ml1.bConflict && ml2.bConflict)
     {
         // Both lines have conflicts: If one is only a white space conflict and
         // the other one is a real conflict, then this line returns false.
         return ml1.id3l->bAEqC == ml2.id3l->bAEqC && ml1.id3l->bAEqB == ml2.id3l->bAEqB;
     }
     else
         return (
             (!ml1.bConflict && !ml2.bConflict && ml1.bDelta && ml2.bDelta && ml1.srcSelect == ml2.srcSelect && (ml1.mergeDetails == ml2.mergeDetails || (ml1.mergeDetails != eBCAddedAndEqual && ml2.mergeDetails != eBCAddedAndEqual))) ||
             (!ml1.bDelta && !ml2.bDelta));
 }
 
 void MergeResultWindow::merge(bool bAutoSolve, int defaultSelector, bool bConflictsOnly, bool bWhiteSpaceOnly)
 {
     if(!bConflictsOnly)
     {
         if(m_bModified)
         {
             int result = KMessageBox::warningYesNo(this,
                                                    i18n("The output has been modified.\n"
                                                         "If you continue your changes will be lost."),
                                                    i18n("Warning"),
                                                    KStandardGuiItem::cont(),
                                                    KStandardGuiItem::cancel());
             if(result == KMessageBox::No)
                 return;
         }
 
         m_mergeLineList.clear();
         m_totalSize = 0;
         int lineIdx = 0;
         Diff3LineList::const_iterator it;
         for(it = m_pDiff3LineList->begin(); it != m_pDiff3LineList->end(); ++it, ++lineIdx)
         {
             const Diff3Line& d = *it;
 
             MergeLine ml;
             bool bLineRemoved;
             mergeOneLine(d, ml.mergeDetails, ml.bConflict, bLineRemoved, ml.srcSelect, m_pldC == nullptr);
 
             // Automatic solving for only whitespace changes.
             if(ml.bConflict &&
                ((m_pldC == nullptr && (d.bAEqB || (d.bWhiteLineA && d.bWhiteLineB))) ||
                 (m_pldC != nullptr && ((d.bAEqB && d.bAEqC) || (d.bWhiteLineA && d.bWhiteLineB && d.bWhiteLineC)))))
             {
                 ml.bWhiteSpaceConflict = true;
             }
 
             ml.d3lLineIdx = lineIdx;
             ml.bDelta = ml.srcSelect != A;
             ml.id3l = it;
             ml.srcRangeLength = 1;
 
             MergeLine* back = m_mergeLineList.empty() ? nullptr : &m_mergeLineList.back();
 
             bool bSame = back != nullptr && sameKindCheck(ml, *back);
             if(bSame)
             {
                 ++back->srcRangeLength;
                 if(back->bWhiteSpaceConflict && !ml.bWhiteSpaceConflict)
                     back->bWhiteSpaceConflict = false;
             }
             else
             {
                 ml.mergeEditLineList.setTotalSizePtr(&m_totalSize);
                 m_mergeLineList.push_back(ml);
             }
 
             if(!ml.bConflict)
             {
                 MergeLine& tmpBack = m_mergeLineList.back();
                 MergeEditLine mel(ml.id3l);
                 mel.setSource(ml.srcSelect, bLineRemoved);
                 tmpBack.mergeEditLineList.push_back(mel);
             }
             else if(back == nullptr || !back->bConflict || !bSame)
             {
                 MergeLine& tmpBack = m_mergeLineList.back();
                 MergeEditLine mel(ml.id3l);
                 mel.setConflict();
                 tmpBack.mergeEditLineList.push_back(mel);
             }
         }
     }
 
     bool bSolveWhiteSpaceConflicts = false;
     if(bAutoSolve) // when true, then the other params are not used and we can change them here. (see all invocations of merge())
     {
         if(m_pldC == nullptr && m_pOptions->m_whiteSpace2FileMergeDefault != 0) // Only two inputs
         {
             defaultSelector = m_pOptions->m_whiteSpace2FileMergeDefault;
             bWhiteSpaceOnly = true;
             bSolveWhiteSpaceConflicts = true;
         }
         else if(m_pldC != nullptr && m_pOptions->m_whiteSpace3FileMergeDefault != 0)
         {
             defaultSelector = m_pOptions->m_whiteSpace3FileMergeDefault;
             bWhiteSpaceOnly = true;
             bSolveWhiteSpaceConflicts = true;
         }
     }
 
     if(!bAutoSolve || bSolveWhiteSpaceConflicts)
     {
         // Change all auto selections
         MergeLineList::iterator mlIt;
         for(mlIt = m_mergeLineList.begin(); mlIt != m_mergeLineList.end(); ++mlIt)
         {
             MergeLine& ml = *mlIt;
             bool bConflict = ml.mergeEditLineList.empty() || ml.mergeEditLineList.begin()->isConflict();
             if(ml.bDelta && (!bConflictsOnly || bConflict) && (!bWhiteSpaceOnly || ml.bWhiteSpaceConflict))
             {
                 ml.mergeEditLineList.clear();
                 if(defaultSelector == -1 && ml.bDelta)
                 {
                     MergeEditLine mel(ml.id3l);
                     ;
                     mel.setConflict();
                     ml.bConflict = true;
                     ml.mergeEditLineList.push_back(mel);
                 }
                 else
                 {
                     Diff3LineList::const_iterator d3llit = ml.id3l;
                     int j;
 
                     for(j = 0; j < ml.srcRangeLength; ++j)
                     {
                         MergeEditLine mel(d3llit);
                         mel.setSource(defaultSelector, false);
 
                         LineRef srcLine = defaultSelector == 1 ? d3llit->lineA : defaultSelector == 2 ? d3llit->lineB : defaultSelector == 3 ? d3llit->lineC : -1;
 
                         if(srcLine != -1)
                         {
                             ml.mergeEditLineList.push_back(mel);
                         }
 
                         ++d3llit;
                     }
 
                     if(ml.mergeEditLineList.empty()) // Make a line nevertheless
                     {
                         MergeEditLine mel(ml.id3l);
                         mel.setRemoved(defaultSelector);
                         ml.mergeEditLineList.push_back(mel);
                     }
                 }
             }
         }
     }
 
     MergeLineList::iterator mlIt;
     for(mlIt = m_mergeLineList.begin(); mlIt != m_mergeLineList.end(); ++mlIt)
     {
         MergeLine& ml = *mlIt;
         // Remove all lines that are empty, because no src lines are there.
 
         LineRef oldSrcLine = -1;
         int oldSrc = -1;
         MergeEditLineList::iterator melIt;
         for(melIt = ml.mergeEditLineList.begin(); melIt != ml.mergeEditLineList.end();)
         {
             MergeEditLine& mel = *melIt;
             int melsrc = mel.src();
 
             LineRef srcLine = mel.isRemoved() ? -1 : melsrc == 1 ? mel.id3l()->lineA : melsrc == 2 ? mel.id3l()->lineB : melsrc == 3 ? mel.id3l()->lineC : -1;
 
             // At least one line remains because oldSrc != melsrc for first line in list
             // Other empty lines will be removed
             if(srcLine == -1 && oldSrcLine == -1 && oldSrc == melsrc)
                 melIt = ml.mergeEditLineList.erase(melIt);
             else
                 ++melIt;
 
             oldSrcLine = srcLine;
             oldSrc = melsrc;
         }
     }
 
     if(bAutoSolve && !bConflictsOnly)
     {
         if(m_pOptions->m_bRunHistoryAutoMergeOnMergeStart)
             slotMergeHistory();
         if(m_pOptions->m_bRunRegExpAutoMergeOnMergeStart)
             slotRegExpAutoMerge();
         if(m_pldC != nullptr && !doRelevantChangesExist())
             emit noRelevantChangesDetected();
     }
 
     int nrOfSolvedConflicts = 0;
     int nrOfUnsolvedConflicts = 0;
     int nrOfWhiteSpaceConflicts = 0;
 
     MergeLineList::iterator i;
     for(i = m_mergeLineList.begin(); i != m_mergeLineList.end(); ++i)
     {
         if(i->bConflict)
             ++nrOfUnsolvedConflicts;
         else if(i->bDelta)
             ++nrOfSolvedConflicts;
 
         if(i->bWhiteSpaceConflict)
             ++nrOfWhiteSpaceConflicts;
     }
 
     m_pTotalDiffStatus->nofUnsolvedConflicts = nrOfUnsolvedConflicts;
     m_pTotalDiffStatus->nofSolvedConflicts = nrOfSolvedConflicts;
     m_pTotalDiffStatus->nofWhitespaceConflicts = nrOfWhiteSpaceConflicts;
 
     m_cursorXPos = 0;
     m_cursorOldXPixelPos = 0;
     m_cursorYPos = 0;
     m_maxTextWidth = -1;
 
     //m_firstLine = 0; // Must not set line/column without scrolling there
     //m_horizScrollOffset = 0;
 
     setModified(false);
 
     m_currentMergeLineIt = m_mergeLineList.begin();
     slotGoTop();
 
     emit updateAvailabilities();
     update();
 }
 
 void MergeResultWindow::setFirstLine(int firstLine)
 {
     m_firstLine = max2(0, firstLine);
     update();
 }
 
 void MergeResultWindow::setHorizScrollOffset(int horizScrollOffset)
 {
     m_horizScrollOffset = max2(0, horizScrollOffset);
     update();
 }
 
 int MergeResultWindow::getMaxTextWidth()
 {
     if(m_maxTextWidth < 0)
     {
         m_maxTextWidth = 0;
 
         MergeLineList::iterator mlIt = m_mergeLineList.begin();
         for(mlIt = m_mergeLineList.begin(); mlIt != m_mergeLineList.end(); ++mlIt)
         {
             MergeLine& ml = *mlIt;
             MergeEditLineList::iterator melIt;
             for(melIt = ml.mergeEditLineList.begin(); melIt != ml.mergeEditLineList.end(); ++melIt)
             {
                 MergeEditLine& mel = *melIt;
                 QString s = mel.getString(this);
 
                 QTextLayout textLayout(s, font(), this);
                 textLayout.beginLayout();
                 textLayout.createLine();
                 textLayout.endLayout();
                 if(m_maxTextWidth < textLayout.maximumWidth())
                 {
                     m_maxTextWidth = textLayout.maximumWidth();
                 }
             }
         }
         m_maxTextWidth += 5; // cursorwidth
     }
     return m_maxTextWidth;
 }
 
 int MergeResultWindow::getNofLines()
 {
     return m_totalSize;
 }
 
 int MergeResultWindow::getVisibleTextAreaWidth()
 {
     // QFontMetrics fm = fontMetrics(); // FIXME used?
     return width() - getTextXOffset();
 }
 
 int MergeResultWindow::getNofVisibleLines()
 {
     QFontMetrics fm = fontMetrics();
     return (height() - 3) / fm.lineSpacing() - 2;
 }
 
 int MergeResultWindow::getTextXOffset()
 {
     QFontMetrics fm = fontMetrics();
     return 3 * fm.width('0');
 }
 
 void MergeResultWindow::resizeEvent(QResizeEvent* e)
 {
     QWidget::resizeEvent(e);
     emit resizeSignal();
 }
 
 Overview::e_OverviewMode MergeResultWindow::getOverviewMode()
 {
     return m_eOverviewMode;
 }
 
 void MergeResultWindow::setOverviewMode(Overview::e_OverviewMode eOverviewMode)
 {
     m_eOverviewMode = eOverviewMode;
 }
 
 // Check whether we should ignore current delta when moving to next/previous delta
 bool MergeResultWindow::checkOverviewIgnore(MergeLineList::iterator& i)
 {
     if(m_eOverviewMode == Overview::eOMNormal) return false;
     if(m_eOverviewMode == Overview::eOMAvsB)
         return i->mergeDetails == eCAdded || i->mergeDetails == eCDeleted || i->mergeDetails == eCChanged;
     if(m_eOverviewMode == Overview::eOMAvsC)
         return i->mergeDetails == eBAdded || i->mergeDetails == eBDeleted || i->mergeDetails == eBChanged;
     if(m_eOverviewMode == Overview::eOMBvsC)
         return i->mergeDetails == eBCAddedAndEqual || i->mergeDetails == eBCDeleted || i->mergeDetails == eBCChangedAndEqual;
     return false;
 }
 
 // Go to prev/next delta/conflict or first/last delta.
 void MergeResultWindow::go(e_Direction eDir, e_EndPoint eEndPoint)
 {
     Q_ASSERT(eDir == eUp || eDir == eDown);
     MergeLineList::iterator i = m_currentMergeLineIt;
     bool bSkipWhiteConflicts = !m_pOptions->m_bShowWhiteSpace;
     if(eEndPoint == eEnd)
     {
         if(eDir == eUp)
             i = m_mergeLineList.begin(); // first mergeline
         else
             i = --m_mergeLineList.end(); // last mergeline
 
         while(isItAtEnd(eDir == eUp, i) && !i->bDelta)
         {
             if(eDir == eUp)
                 ++i; // search downwards
             else
                 --i; // search upwards
         }
     }
     else if(eEndPoint == eDelta && isItAtEnd(eDir != eUp, i))
     {
         do
         {
             if(eDir == eUp)
                 --i;
             else
                 ++i;
         } while(isItAtEnd(eDir != eUp, i) && (i->bDelta == false || checkOverviewIgnore(i) || (bSkipWhiteConflicts && i->bWhiteSpaceConflict)));
     }
     else if(eEndPoint == eConflict && isItAtEnd(eDir != eUp, i))
     {
         do
         {
             if(eDir == eUp)
                 --i;
             else
                 ++i;
         } while(isItAtEnd(eDir != eUp, i) && (i->bConflict == false || (bSkipWhiteConflicts && i->bWhiteSpaceConflict)));
     }
     else if(isItAtEnd(eDir != eUp, i) && eEndPoint == eUnsolvedConflict)
     {
         do
         {
             if(eDir == eUp)
                 --i;
             else
                 ++i;
         } while(isItAtEnd(eDir != eUp, i) && !i->mergeEditLineList.begin()->isConflict());
     }
 
     if(isVisible())
         setFocus();
 
     setFastSelector(i);
 }
 
 bool MergeResultWindow::isDeltaAboveCurrent()
 {
     bool bSkipWhiteConflicts = !m_pOptions->m_bShowWhiteSpace;
     if(m_mergeLineList.empty()) return false;
     MergeLineList::iterator i = m_currentMergeLineIt;
     if(i == m_mergeLineList.begin()) return false;
     do
     {
         --i;
         if(i->bDelta && !checkOverviewIgnore(i) && !(bSkipWhiteConflicts && i->bWhiteSpaceConflict)) return true;
     } while(i != m_mergeLineList.begin());
 
     return false;
 }
 
 bool MergeResultWindow::isDeltaBelowCurrent()
 {
     bool bSkipWhiteConflicts = !m_pOptions->m_bShowWhiteSpace;
     if(m_mergeLineList.empty()) return false;
 
     MergeLineList::iterator i = m_currentMergeLineIt;
     if(i != m_mergeLineList.end())
     {
         ++i;
         for(; i != m_mergeLineList.end(); ++i)
         {
             if(i->bDelta && !checkOverviewIgnore(i) && !(bSkipWhiteConflicts && i->bWhiteSpaceConflict)) return true;
         }
     }
     return false;
 }
 
 bool MergeResultWindow::isConflictAboveCurrent()
 {
     if(m_mergeLineList.empty()) return false;
     MergeLineList::iterator i = m_currentMergeLineIt;
     if(i == m_mergeLineList.begin()) return false;
 
     bool bSkipWhiteConflicts = !m_pOptions->m_bShowWhiteSpace;
 
     do
     {
         --i;
         if(i->bConflict && !(bSkipWhiteConflicts && i->bWhiteSpaceConflict)) return true;
     } while(i != m_mergeLineList.begin());
 
     return false;
 }
 
 bool MergeResultWindow::isConflictBelowCurrent()
 {
     MergeLineList::iterator i = m_currentMergeLineIt;
     if(m_mergeLineList.empty()) return false;
 
     bool bSkipWhiteConflicts = !m_pOptions->m_bShowWhiteSpace;
 
     if(i != m_mergeLineList.end())
     {
         ++i;
         for(; i != m_mergeLineList.end(); ++i)
         {
             if(i->bConflict && !(bSkipWhiteConflicts && i->bWhiteSpaceConflict)) return true;
         }
     }
     return false;
 }
 
 bool MergeResultWindow::isUnsolvedConflictAtCurrent()
 {
     if(m_mergeLineList.empty()) return false;
     MergeLineList::iterator i = m_currentMergeLineIt;
     return i->mergeEditLineList.begin()->isConflict();
 }
 
 bool MergeResultWindow::isUnsolvedConflictAboveCurrent()
 {
     if(m_mergeLineList.empty()) return false;
     MergeLineList::iterator i = m_currentMergeLineIt;
     if(i == m_mergeLineList.begin()) return false;
 
     do
     {
         --i;
         if(i->mergeEditLineList.begin()->isConflict()) return true;
     } while(i != m_mergeLineList.begin());
 
     return false;
 }
 
 bool MergeResultWindow::isUnsolvedConflictBelowCurrent()
 {
     MergeLineList::iterator i = m_currentMergeLineIt;
     if(m_mergeLineList.empty()) return false;
 
     if(i != m_mergeLineList.end())
     {
         ++i;
         for(; i != m_mergeLineList.end(); ++i)
         {
             if(i->mergeEditLineList.begin()->isConflict()) return true;
         }
     }
     return false;
 }
 
 void MergeResultWindow::slotGoTop()
 {
     go(eUp, eEnd);
 }
 
 void MergeResultWindow::slotGoCurrent()
 {
     setFastSelector(m_currentMergeLineIt);
 }
 
 void MergeResultWindow::slotGoBottom()
 {
     go(eDown, eEnd);
 }
 
 void MergeResultWindow::slotGoPrevDelta()
 {
     go(eUp, eDelta);
 }
 
 void MergeResultWindow::slotGoNextDelta()
 {
     go(eDown, eDelta);
 }
 
 void MergeResultWindow::slotGoPrevConflict()
 {
     go(eUp, eConflict);
 }
 
 void MergeResultWindow::slotGoNextConflict()
 {
     go(eDown, eConflict);
 }
 
 void MergeResultWindow::slotGoPrevUnsolvedConflict()
 {
     go(eUp, eUnsolvedConflict);
 }
 
 void MergeResultWindow::slotGoNextUnsolvedConflict()
 {
     go(eDown, eUnsolvedConflict);
 }
 
 /** The line is given as a index in the Diff3LineList.
     The function calculates the corresponding iterator. */
 void MergeResultWindow::slotSetFastSelectorLine(int line)
 {
     MergeLineList::iterator i;
     for(i = m_mergeLineList.begin(); i != m_mergeLineList.end(); ++i)
     {
         if(line >= i->d3lLineIdx && line < i->d3lLineIdx + i->srcRangeLength)
         {
             //if ( i->bDelta )
             {
                 setFastSelector(i);
             }
             break;
         }
     }
 }
 
 int MergeResultWindow::getNrOfUnsolvedConflicts(int* pNrOfWhiteSpaceConflicts)
 {
     int nrOfUnsolvedConflicts = 0;
     if(pNrOfWhiteSpaceConflicts != nullptr)
         *pNrOfWhiteSpaceConflicts = 0;
 
     MergeLineList::iterator mlIt = m_mergeLineList.begin();
     for(mlIt = m_mergeLineList.begin(); mlIt != m_mergeLineList.end(); ++mlIt)
     {
         MergeLine& ml = *mlIt;
         MergeEditLineList::iterator melIt = ml.mergeEditLineList.begin();
         if(melIt->isConflict())
         {
             ++nrOfUnsolvedConflicts;
             if(ml.bWhiteSpaceConflict && pNrOfWhiteSpaceConflicts != nullptr)
                 ++*pNrOfWhiteSpaceConflicts;
         }
     }
 
     return nrOfUnsolvedConflicts;
 }
 
 void MergeResultWindow::showNrOfConflicts()
 {
     if(!m_pOptions->m_bShowInfoDialogs)
         return;
     int nrOfConflicts = 0;
     MergeLineList::iterator i;
     for(i = m_mergeLineList.begin(); i != m_mergeLineList.end(); ++i)
     {
         if(i->bConflict || i->bDelta)
             ++nrOfConflicts;
     }
     QString totalInfo;
     if(m_pTotalDiffStatus->bBinaryAEqB && m_pTotalDiffStatus->bBinaryAEqC)
         totalInfo += i18n("All input files are binary equal.");
     else if(m_pTotalDiffStatus->bTextAEqB && m_pTotalDiffStatus->bTextAEqC)
         totalInfo += i18n("All input files contain the same text.");
     else
     {
         if(m_pTotalDiffStatus->bBinaryAEqB)
             totalInfo += i18n("Files %1 and %2 are binary equal.\n", QString("A"), QString("B"));
         else if(m_pTotalDiffStatus->bTextAEqB)
             totalInfo += i18n("Files %1 and %2 have equal text.\n", QString("A"), QString("B"));
         if(m_pTotalDiffStatus->bBinaryAEqC)
             totalInfo += i18n("Files %1 and %2 are binary equal.\n", QString("A"), QString("C"));
         else if(m_pTotalDiffStatus->bTextAEqC)
             totalInfo += i18n("Files %1 and %2 have equal text.\n", QString("A"), QString("C"));
         if(m_pTotalDiffStatus->bBinaryBEqC)
             totalInfo += i18n("Files %1 and %2 are binary equal.\n", QString("B"), QString("C"));
         else if(m_pTotalDiffStatus->bTextBEqC)
             totalInfo += i18n("Files %1 and %2 have equal text.\n", QString("B"), QString("C"));
     }
 
     int nrOfUnsolvedConflicts = getNrOfUnsolvedConflicts();
 
     KMessageBox::information(this,
                              i18n("Total number of conflicts: %1\n"
                                   "Nr of automatically solved conflicts: %2\n"
                                   "Nr of unsolved conflicts: %3\n"
                                   "%4",
                                   nrOfConflicts, nrOfConflicts - nrOfUnsolvedConflicts,
                                   nrOfUnsolvedConflicts, totalInfo),
                              i18n("Conflicts"));
 }
 
 void MergeResultWindow::setFastSelector(MergeLineList::iterator i)
 {
     if(i == m_mergeLineList.end())
         return;
     m_currentMergeLineIt = i;
     emit setFastSelectorRange(i->d3lLineIdx, i->srcRangeLength);
 
     int line1 = 0;
 
     MergeLineList::iterator mlIt = m_mergeLineList.begin();
     for(mlIt = m_mergeLineList.begin(); mlIt != m_mergeLineList.end(); ++mlIt)
     {
         if(mlIt == m_currentMergeLineIt)
             break;
         line1 += mlIt->mergeEditLineList.size();
     }
 
     int nofLines = m_currentMergeLineIt->mergeEditLineList.size();
     int newFirstLine = getBestFirstLine(line1, nofLines, m_firstLine, getNofVisibleLines());
     if(newFirstLine != m_firstLine)
     {
         scroll(0, newFirstLine - m_firstLine);
     }
 
     if(m_selection.isEmpty())
     {
         m_cursorXPos = 0;
         m_cursorOldXPixelPos = 0;
         m_cursorYPos = line1;
     }
 
     update();
     updateSourceMask();
     emit updateAvailabilities();
 }
 
 void MergeResultWindow::choose(int selector)
 {
     if(m_currentMergeLineIt == m_mergeLineList.end())
         return;
 
     setModified();
 
     // First find range for which this change works.
     MergeLine& ml = *m_currentMergeLineIt;
 
     MergeEditLineList::iterator melIt;
 
     // Now check if selector is active for this range already.
     bool bActive = false;
 
     // Remove unneeded lines in the range.
     for(melIt = ml.mergeEditLineList.begin(); melIt != ml.mergeEditLineList.end();)
     {
         MergeEditLine& mel = *melIt;
         if(mel.src() == selector)
             bActive = true;
 
         if(mel.src() == selector || !mel.isEditableText() || mel.isModified())
             melIt = ml.mergeEditLineList.erase(melIt);
         else
             ++melIt;
     }
 
     if(!bActive) // Selected source wasn't active.
     {            // Append the lines from selected source here at rangeEnd.
         Diff3LineList::const_iterator d3llit = ml.id3l;
         int j;
 
         for(j = 0; j < ml.srcRangeLength; ++j)
         {
             MergeEditLine mel(d3llit);
             mel.setSource(selector, false);
             ml.mergeEditLineList.push_back(mel);
 
             ++d3llit;
         }
     }
 
     if(!ml.mergeEditLineList.empty())
     {
         // Remove all lines that are empty, because no src lines are there.
         for(melIt = ml.mergeEditLineList.begin(); melIt != ml.mergeEditLineList.end();)
         {
             MergeEditLine& mel = *melIt;
 
             LineRef srcLine = mel.src() == 1 ? mel.id3l()->lineA : mel.src() == 2 ? mel.id3l()->lineB : mel.src() == 3 ? mel.id3l()->lineC : -1;
 
             if(srcLine == -1)
                 melIt = ml.mergeEditLineList.erase(melIt);
             else
                 ++melIt;
         }
     }
 
     if(ml.mergeEditLineList.empty())
     {
         // Insert a dummy line:
         MergeEditLine mel(ml.id3l);
 
         if(bActive)
             mel.setConflict(); // All src entries deleted => conflict
         else
             mel.setRemoved(selector); // No lines in corresponding src found.
 
         ml.mergeEditLineList.push_back(mel);
     }
 
     if(m_cursorYPos >= m_totalSize)
     {
         m_cursorYPos = m_totalSize - 1;
         m_cursorXPos = 0;
     }
 
     m_maxTextWidth = -1;
     update();
     updateSourceMask();
     emit updateAvailabilities();
     showUnsolvedConflictsStatusMessage();
 }
 
 // bConflictsOnly: automatically choose for conflicts only (true) or for everywhere (false)
 void MergeResultWindow::chooseGlobal(int selector, bool bConflictsOnly, bool bWhiteSpaceOnly)
 {
     resetSelection();
 
     merge(false, selector, bConflictsOnly, bWhiteSpaceOnly);
     setModified(true);
     update();
     showUnsolvedConflictsStatusMessage();
 }
 
 void MergeResultWindow::slotAutoSolve()
 {
     resetSelection();
     merge(true, -1);
     setModified(true);
     update();
     showUnsolvedConflictsStatusMessage();
 }
 
 void MergeResultWindow::slotUnsolve()
 {
     resetSelection();
     merge(false, -1);
     setModified(true);
     update();
     showUnsolvedConflictsStatusMessage();
 }
 
 static QString calcHistoryLead(const QString& s)
 {
     // Return the start of the line until the first white char after the first non white char.
     int i;
     for(i = 0; i < s.length(); ++i)
     {
         if(s[i] != ' ' && s[i] != '\t')
         {
             for(; i < s.length(); ++i)
             {
                 if(s[i] == ' ' || s[i] == '\t')
                 {
                     return s.left(i);
                 }
             }
             return s; // Very unlikely
         }
     }
     return ""; // Must be an empty string, not a null string.
 }
 
 static void findHistoryRange(const QRegExp& historyStart, bool bThreeFiles, const Diff3LineList* pD3LList,
                              Diff3LineList::const_iterator& iBegin, Diff3LineList::const_iterator& iEnd, int& idxBegin, int& idxEnd)
 {
     QString historyLead;
     // Search for start of history
     for(iBegin = pD3LList->begin(), idxBegin = 0; iBegin != pD3LList->end(); ++iBegin, ++idxBegin)
     {
         if(historyStart.exactMatch(iBegin->getString(A)) &&
            historyStart.exactMatch(iBegin->getString(B)) &&
            (!bThreeFiles || historyStart.exactMatch(iBegin->getString(C))))
         {
             historyLead = calcHistoryLead(iBegin->getString(A));
             break;
         }
     }
     // Search for end of history
     for(iEnd = iBegin, idxEnd = idxBegin; iEnd != pD3LList->end(); ++iEnd, ++idxEnd)
     {
         QString sA = iEnd->getString(A);
         QString sB = iEnd->getString(B);
         QString sC = iEnd->getString(C);
         if(!((sA.isEmpty() || historyLead == calcHistoryLead(sA)) &&
              (sB.isEmpty() || historyLead == calcHistoryLead(sB)) &&
              (!bThreeFiles || sC.isEmpty() || historyLead == calcHistoryLead(sC))))
         {
             break; // End of the history
         }
     }
 }
 
 bool findParenthesesGroups(const QString& s, QStringList& sl)
 {
     sl.clear();
     int i = 0;
     std::list<int> startPosStack;
     int length = s.length();
     for(i = 0; i < length; ++i)
     {
         if(s[i] == '\\' && i + 1 < length && (s[i + 1] == '\\' || s[i + 1] == '(' || s[i + 1] == ')'))
         {
             ++i;
             continue;
         }
         if(s[i] == '(')
         {
             startPosStack.push_back(i);
         }
         else if(s[i] == ')')
         {
             if(startPosStack.empty())
                 return false; // Parentheses don't match
             int startPos = startPosStack.back();
             startPosStack.pop_back();
             sl.push_back(s.mid(startPos + 1, i - startPos - 1));
         }
     }
     return startPosStack.empty(); // false if parentheses don't match
 }
 
 QString calcHistorySortKey(const QString& keyOrder, QRegExp& matchedRegExpr, const QStringList& parenthesesGroupList)
 {
     QStringList keyOrderList = keyOrder.split(',');
     QString key;
     for(QStringList::iterator keyIt = keyOrderList.begin(); keyIt != keyOrderList.end(); ++keyIt)
     {
         if((*keyIt).isEmpty())
             continue;
         bool bOk = false;
         int groupIdx = (*keyIt).toInt(&bOk);
         if(!bOk || groupIdx < 0 || groupIdx > (int)parenthesesGroupList.size())
             continue;
         QString s = matchedRegExpr.cap(groupIdx);
         if(groupIdx == 0)
         {
             key += s + " ";
             continue;
         }
 
         QString groupRegExp = parenthesesGroupList[groupIdx - 1];
         if(groupRegExp.indexOf('|') < 0 || groupRegExp.indexOf('(') >= 0)
         {
             bool bOk = false;
             int i = s.toInt(&bOk);
             if(bOk && i >= 0 && i < 10000)
                 s.sprintf("%04d", i); // This should help for correct sorting of numbers.
             key += s + " ";
         }
         else
         {
             // Assume that the groupRegExp consists of something like "Jan|Feb|Mar|Apr"
             // s is the string that managed to match.
             // Now we want to know at which position it occurred. e.g. Jan=0, Feb=1, Mar=2, etc.
             QStringList sl = groupRegExp.split('|');
             int idx = sl.indexOf(s);
             if(idx < 0)
             {
                 // Didn't match
             }
             else
             {
                 QString sIdx;
                 sIdx.sprintf("%02d", idx + 1); // Up to 99 words in the groupRegExp (more than 12 aren't expected)
                 key += sIdx + " ";
             }
         }
     }
     return key;
 }
 
 void MergeResultWindow::collectHistoryInformation(
     int src, Diff3LineList::const_iterator iHistoryBegin, Diff3LineList::const_iterator iHistoryEnd,
     HistoryMap& historyMap,
     std::list<HistoryMap::iterator>& hitList // list of iterators
     )
 {
     std::list<HistoryMap::iterator>::iterator itHitListFront = hitList.begin();
     Diff3LineList::const_iterator id3l = iHistoryBegin;
     QString historyLead;
     {
         const LineData* pld = id3l->getLineData(src);
         QString s(pld->pLine, pld->size);
         historyLead = calcHistoryLead(s);
     }
     QRegExp historyStart(m_pOptions->m_historyStartRegExp);
     if(id3l == iHistoryEnd)
         return;
     ++id3l; // Skip line with "$Log ... $"
     QRegExp newHistoryEntry(m_pOptions->m_historyEntryStartRegExp);
     QStringList parenthesesGroups;
     findParenthesesGroups(m_pOptions->m_historyEntryStartRegExp, parenthesesGroups);
     QString key;
     MergeEditLineList melList;
     bool bPrevLineIsEmpty = true;
     bool bUseRegExp = !m_pOptions->m_historyEntryStartRegExp.isEmpty();
     for(; id3l != iHistoryEnd; ++id3l)
     {
         const LineData* pld = id3l->getLineData(src);
         if(!pld) continue;
         QString s(pld->pLine, pld->size);
         if(historyLead.isEmpty()) historyLead = calcHistoryLead(s);
         QString sLine = s.mid(historyLead.length());
         if((!bUseRegExp && !sLine.trimmed().isEmpty() && bPrevLineIsEmpty) || (bUseRegExp && newHistoryEntry.exactMatch(sLine)))
         {
             if(!key.isEmpty() && !melList.empty())
             {
                 // Only insert new HistoryMapEntry if key not found; in either case p.first is a valid iterator to element key.
                 std::pair<HistoryMap::iterator, bool> p = historyMap.insert(HistoryMap::value_type(key, HistoryMapEntry()));
                 HistoryMapEntry& hme = p.first->second;
                 if(src == A) hme.mellA = melList;
                 if(src == B) hme.mellB = melList;
                 if(src == C) hme.mellC = melList;
                 if(p.second) // Not in list yet?
                 {
                     hitList.insert(itHitListFront, p.first);
                 }
             }
 
             if(!bUseRegExp)
                 key = sLine;
             else
                 key = calcHistorySortKey(m_pOptions->m_historyEntryStartSortKeyOrder, newHistoryEntry, parenthesesGroups);
 
             melList.clear();
             melList.push_back(MergeEditLine(id3l, src));
         }
         else if(!historyStart.exactMatch(s))
         {
             melList.push_back(MergeEditLine(id3l, src));
         }
 
         bPrevLineIsEmpty = sLine.trimmed().isEmpty();
     }
     if(!key.isEmpty())
     {
         // Only insert new HistoryMapEntry if key not found; in either case p.first is a valid iterator to element key.
         std::pair<HistoryMap::iterator, bool> p = historyMap.insert(HistoryMap::value_type(key, HistoryMapEntry()));
         HistoryMapEntry& hme = p.first->second;
         if(src == A) hme.mellA = melList;
         if(src == B) hme.mellB = melList;
         if(src == C) hme.mellC = melList;
         if(p.second) // Not in list yet?
         {
             hitList.insert(itHitListFront, p.first);
         }
     }
     // End of the history
 }
 
 MergeResultWindow::MergeEditLineList& MergeResultWindow::HistoryMapEntry::choice(bool bThreeInputs)
 {
     if(!bThreeInputs)
         return mellA.empty() ? mellB : mellA;
     else
     {
         if(mellA.empty())
             return mellC.empty() ? mellB : mellC; // A doesn't exist, return one that exists
         else if(!mellB.empty() && !mellC.empty())
         { // A, B and C exist
             return mellA;
         }
         else
             return mellB.empty() ? mellB : mellC; // A exists, return the one that doesn't exist
     }
 }
 
 bool MergeResultWindow::HistoryMapEntry::staysInPlace(bool bThreeInputs, Diff3LineList::const_iterator& iHistoryEnd)
 {
     // The entry should stay in place if the decision made by the automerger is correct.
     Diff3LineList::const_iterator& iHistoryLast = iHistoryEnd;
     --iHistoryLast;
     if(!bThreeInputs)
     {
         if(!mellA.empty() && !mellB.empty() && mellA.begin()->id3l() == mellB.begin()->id3l() &&
            mellA.back().id3l() == iHistoryLast && mellB.back().id3l() == iHistoryLast)
         {
             iHistoryEnd = mellA.begin()->id3l();
             return true;
         }
         else
         {
             return false;
         }
     }
     else
     {
         if(!mellA.empty() && !mellB.empty() && !mellC.empty() && mellA.begin()->id3l() == mellB.begin()->id3l() && mellA.begin()->id3l() == mellC.begin()->id3l() && mellA.back().id3l() == iHistoryLast && mellB.back().id3l() == iHistoryLast && mellC.back().id3l() == iHistoryLast)
         {
             iHistoryEnd = mellA.begin()->id3l();
             return true;
         }
         else
         {
             return false;
         }
     }
 }
 
 void MergeResultWindow::slotMergeHistory()
 {
     Diff3LineList::const_iterator iD3LHistoryBegin;
     Diff3LineList::const_iterator iD3LHistoryEnd;
     int d3lHistoryBeginLineIdx = -1;
     int d3lHistoryEndLineIdx = -1;
 
     // Search for history start, history end in the diff3LineList
     findHistoryRange(QRegExp(m_pOptions->m_historyStartRegExp), m_pldC != nullptr, m_pDiff3LineList, iD3LHistoryBegin, iD3LHistoryEnd, d3lHistoryBeginLineIdx, d3lHistoryEndLineIdx);
 
     if(iD3LHistoryBegin != m_pDiff3LineList->end())
     {
         // Now collect the historyMap information
         HistoryMap historyMap;
         std::list<HistoryMap::iterator> hitList;
         if(m_pldC == nullptr)
         {
             collectHistoryInformation(A, iD3LHistoryBegin, iD3LHistoryEnd, historyMap, hitList);
             collectHistoryInformation(B, iD3LHistoryBegin, iD3LHistoryEnd, historyMap, hitList);
         }
         else
         {
             collectHistoryInformation(A, iD3LHistoryBegin, iD3LHistoryEnd, historyMap, hitList);
             collectHistoryInformation(B, iD3LHistoryBegin, iD3LHistoryEnd, historyMap, hitList);
             collectHistoryInformation(C, iD3LHistoryBegin, iD3LHistoryEnd, historyMap, hitList);
         }
 
         Diff3LineList::const_iterator iD3LHistoryOrigEnd = iD3LHistoryEnd;
 
         bool bHistoryMergeSorting = m_pOptions->m_bHistoryMergeSorting && !m_pOptions->m_historyEntryStartSortKeyOrder.isEmpty() &&
                                     !m_pOptions->m_historyEntryStartRegExp.isEmpty();
 
         if(m_pOptions->m_maxNofHistoryEntries == -1)
         {
             // Remove parts from the historyMap and hitList that stay in place
             if(bHistoryMergeSorting)
             {
                 while(!historyMap.empty())
                 {
                     HistoryMap::iterator hMapIt = historyMap.begin();
                     if(hMapIt->second.staysInPlace(m_pldC != nullptr, iD3LHistoryEnd))
                         historyMap.erase(hMapIt);
                     else
                         break;
                 }
             }
             else
             {
                 while(!hitList.empty())
                 {
                     HistoryMap::iterator hMapIt = hitList.back();
                     if(hMapIt->second.staysInPlace(m_pldC != nullptr, iD3LHistoryEnd))
                         hitList.pop_back();
                     else
                         break;
                 }
             }
             while(iD3LHistoryOrigEnd != iD3LHistoryEnd)
             {
                 --iD3LHistoryOrigEnd;
                 --d3lHistoryEndLineIdx;
             }
         }
 
         MergeLineList::iterator iMLLStart = splitAtDiff3LineIdx(d3lHistoryBeginLineIdx);
         MergeLineList::iterator iMLLEnd = splitAtDiff3LineIdx(d3lHistoryEndLineIdx);
         // Now join all MergeLines in the history
         MergeLineList::iterator i = iMLLStart;
         if(i != iMLLEnd)
         {
             ++i;
             while(i != iMLLEnd)
             {
                 iMLLStart->join(*i);
                 i = m_mergeLineList.erase(i);
             }
         }
         iMLLStart->mergeEditLineList.clear();
         // Now insert the complete history into the first MergeLine of the history
         iMLLStart->mergeEditLineList.push_back(MergeEditLine(iD3LHistoryBegin, m_pldC == nullptr ? B : C));
         QString lead = calcHistoryLead(iD3LHistoryBegin->getString(A));
         MergeEditLine mel(m_pDiff3LineList->end());
         mel.setString(lead);
         iMLLStart->mergeEditLineList.push_back(mel);
 
         int historyCount = 0;
         if(bHistoryMergeSorting)
         {
             // Create a sorted history
             HistoryMap::reverse_iterator hmit;
             for(hmit = historyMap.rbegin(); hmit != historyMap.rend(); ++hmit)
             {
                 if(historyCount == m_pOptions->m_maxNofHistoryEntries)
                     break;
                 ++historyCount;
                 HistoryMapEntry& hme = hmit->second;
                 MergeEditLineList& mell = hme.choice(m_pldC != nullptr);
                 if(!mell.empty())
                     iMLLStart->mergeEditLineList.splice(iMLLStart->mergeEditLineList.end(), mell, mell.begin(), mell.end());
             }
         }
         else
         {
             // Create history in order of appearance
             std::list<HistoryMap::iterator>::iterator hlit;
             for(hlit = hitList.begin(); hlit != hitList.end(); ++hlit)
             {
                 if(historyCount == m_pOptions->m_maxNofHistoryEntries)
                     break;
                 ++historyCount;
                 HistoryMapEntry& hme = (*hlit)->second;
                 MergeEditLineList& mell = hme.choice(m_pldC != nullptr);
                 if(!mell.empty())
                     iMLLStart->mergeEditLineList.splice(iMLLStart->mergeEditLineList.end(), mell, mell.begin(), mell.end());
             }
             // If the end of start is empty and the first line at the end is empty remove the last line of start
             if(!iMLLStart->mergeEditLineList.empty() && !iMLLEnd->mergeEditLineList.empty())
             {
                 QString lastLineOfStart = iMLLStart->mergeEditLineList.back().getString(this);
                 QString firstLineOfEnd = iMLLEnd->mergeEditLineList.front().getString(this);
                 if(lastLineOfStart.mid(lead.length()).trimmed().isEmpty() && firstLineOfEnd.mid(lead.length()).trimmed().isEmpty())
                     iMLLStart->mergeEditLineList.pop_back();
             }
         }
         setFastSelector(iMLLStart);
         update();
     }
 }
 
 void MergeResultWindow::slotRegExpAutoMerge()
 {
     if(m_pOptions->m_autoMergeRegExp.isEmpty())
         return;
 
     QRegExp vcsKeywords(m_pOptions->m_autoMergeRegExp);
     MergeLineList::iterator i;
     for(i = m_mergeLineList.begin(); i != m_mergeLineList.end(); ++i)
     {
         if(i->bConflict)
         {
             Diff3LineList::const_iterator id3l = i->id3l;
             if(vcsKeywords.exactMatch(id3l->getString(A)) &&
                vcsKeywords.exactMatch(id3l->getString(B)) &&
                (m_pldC == nullptr || vcsKeywords.exactMatch(id3l->getString(C))))
             {
                 MergeEditLine& mel = *i->mergeEditLineList.begin();
                 mel.setSource(m_pldC == nullptr ? B : C, false);
                 splitAtDiff3LineIdx(i->d3lLineIdx + 1);
             }
         }
     }
     update();
 }
 
 // This doesn't detect user modifications and should only be called after automatic merge
 // This will only do something for three file merge.
 // Irrelevant changes are those where all contributions from B are already contained in C.
 // Also irrelevant are conflicts automatically solved (automerge regexp and history automerge)
 // Precondition: The VCS-keyword would also be C.
 bool MergeResultWindow::doRelevantChangesExist()
 {
     if(m_pldC == nullptr || m_mergeLineList.size() <= 1)
         return true;
 
     MergeLineList::iterator i;
     for(i = m_mergeLineList.begin(); i != m_mergeLineList.end(); ++i)
     {
         if((i->bConflict && i->mergeEditLineList.begin()->src() != C) || i->srcSelect == B)
         {
             return true;
         }
     }
 
     return false;
 }
 
 // Returns the iterator to the MergeLine after the split
 MergeResultWindow::MergeLineList::iterator MergeResultWindow::splitAtDiff3LineIdx(int d3lLineIdx)
 {
     MergeLineList::iterator i;
     for(i = m_mergeLineList.begin(); i != m_mergeLineList.end(); ++i)
     {
         if(i->d3lLineIdx == d3lLineIdx)
         {
             // No split needed, this is the beginning of a MergeLine
             return i;
         }
         else if(i->d3lLineIdx > d3lLineIdx)
         {
             // The split must be in the previous MergeLine
             --i;
             MergeLine& ml = *i;
             MergeLine newML;
             ml.split(newML, d3lLineIdx);
             ++i;
             return m_mergeLineList.insert(i, newML);
         }
     }
     // The split must be in the previous MergeLine
     --i;
     MergeLine& ml = *i;
     MergeLine newML;
     ml.split(newML, d3lLineIdx);
     ++i;
     return m_mergeLineList.insert(i, newML);
 }
 
 void MergeResultWindow::slotSplitDiff(int firstD3lLineIdx, int lastD3lLineIdx)
 {
     if(lastD3lLineIdx >= 0)
         splitAtDiff3LineIdx(lastD3lLineIdx + 1);
     setFastSelector(splitAtDiff3LineIdx(firstD3lLineIdx));
 }
 
 void MergeResultWindow::slotJoinDiffs(int firstD3lLineIdx, int lastD3lLineIdx)
 {
     MergeLineList::iterator i;
     MergeLineList::iterator iMLLStart = m_mergeLineList.end();
     MergeLineList::iterator iMLLEnd = m_mergeLineList.end();
     for(i = m_mergeLineList.begin(); i != m_mergeLineList.end(); ++i)
     {
         MergeLine& ml = *i;
         if(firstD3lLineIdx >= ml.d3lLineIdx && firstD3lLineIdx < ml.d3lLineIdx + ml.srcRangeLength)
         {
             iMLLStart = i;
         }
         if(lastD3lLineIdx >= ml.d3lLineIdx && lastD3lLineIdx < ml.d3lLineIdx + ml.srcRangeLength)
         {
             iMLLEnd = i;
             ++iMLLEnd;
             break;
         }
     }
 
     bool bJoined = false;
     for(i = iMLLStart; i != iMLLEnd && i != m_mergeLineList.end();)
     {
         if(i == iMLLStart)
         {
             ++i;
         }
         else
         {
             iMLLStart->join(*i);
             i = m_mergeLineList.erase(i);
             bJoined = true;
         }
     }
     if(bJoined)
     {
         iMLLStart->mergeEditLineList.clear();
         // Insert a conflict line as placeholder
         iMLLStart->mergeEditLineList.push_back(MergeEditLine(iMLLStart->id3l));
     }
     setFastSelector(iMLLStart);
 }
 
 void MergeResultWindow::myUpdate(int afterMilliSecs)
 {
     if(m_delayedDrawTimer)
         killTimer(m_delayedDrawTimer);
     m_bMyUpdate = true;
     m_delayedDrawTimer = startTimer(afterMilliSecs);
 }
 
 void MergeResultWindow::timerEvent(QTimerEvent*)
 {
     killTimer(m_delayedDrawTimer);
     m_delayedDrawTimer = 0;
 
     if(m_bMyUpdate)
     {
         update();
         m_bMyUpdate = false;
     }
 
     if(m_scrollDeltaX != 0 || m_scrollDeltaY != 0)
     {
         m_selection.end(m_selection.getLastLine() + m_scrollDeltaY, m_selection.getLastPos() + m_scrollDeltaX);
         scroll(m_scrollDeltaX, m_scrollDeltaY);
         killTimer(m_delayedDrawTimer);
         m_delayedDrawTimer = startTimer(50);
     }
 }
 
 QString MergeResultWindow::MergeEditLine::getString(const MergeResultWindow* mrw)
 {
     if(isRemoved()) {
         return QString();
     }
 
     if(!isModified())
     {
         int src = m_src;
         if(src == 0) {
             return QString();
         }
         const Diff3Line& d3l = *m_id3l;
         const LineData* pld = nullptr;
         Q_ASSERT(src == A || src == B || src == C);
         if(src == A && d3l.lineA != -1)
             pld = &mrw->m_pldA[d3l.lineA];
         else if(src == B && d3l.lineB != -1)
             pld = &mrw->m_pldB[d3l.lineB];
         else if(src == C && d3l.lineC != -1)
             pld = &mrw->m_pldC[d3l.lineC];
 
         //Not an error.
         if(pld == nullptr)
         {
             return QString();
         }
 
         return QString(pld->pLine, pld->size);
     }
     else
     {
         return m_str;
     }
     return nullptr;
 }
 
 /// Converts the cursor-posOnScreen into a text index, considering tabulators.
 int convertToPosInText(const QString& /*s*/, int posOnScreen, int /*tabSize*/)
 {
     return posOnScreen;
 }
 
 //   int localPosOnScreen = 0;
 //   int size=s.length();
 //   for ( int i=0; i<size; ++i )
 //   {
 //      if ( localPosOnScreen>=posOnScreen )
 //         return i;
 
 //      // All letters except tabulator have width one.
 //      int letterWidth = s[i]!='\t' ? 1 : tabber( localPosOnScreen, tabSize );
 
 //      localPosOnScreen += letterWidth;
 
 //      if ( localPosOnScreen>posOnScreen )
 //         return i;
 //   }
 //   return size;
 //}
 
 /// Converts the index into the text to a cursor-posOnScreen considering tabulators.
 int convertToPosOnScreen(const QString& /*p*/, int posInText, int /*tabSize*/)
 {
     return posInText;
 }
 //   int posOnScreen = 0;
 //   for ( int i=0; i<posInText; ++i )
 //   {
 //      // All letters except tabulator have width one.
 //      int letterWidth = p[i]!='\t' ? 1 : tabber( posOnScreen, tabSize );
 
 //      posOnScreen += letterWidth;
 //   }
 //   return posOnScreen;
 //}
 
 QVector<QTextLayout::FormatRange> MergeResultWindow::getTextLayoutForLine(int line, const QString& str, QTextLayout& textLayout)
 {
     // tabs
     QTextOption textOption;
 #if QT_VERSION < QT_VERSION_CHECK(5,10,0)
     textOption.setTabStop(QFontMetricsF(font()).width(' ') * m_pOptions->m_tabSize);
 #else
     textOption.setTabStopDistance(QFontMetricsF(font()).width(' ') * m_pOptions->m_tabSize);
 #endif
     if(m_pOptions->m_bShowWhiteSpaceCharacters)
     {
         textOption.setFlags(QTextOption::ShowTabsAndSpaces);
     }
     textLayout.setTextOption(textOption);
 
     if(m_pOptions->m_bShowWhiteSpaceCharacters)
     {
         // This additional format is only necessary for the tab arrow
         QVector<QTextLayout::FormatRange> formats;
         QTextLayout::FormatRange formatRange;
         formatRange.start = 0;
         formatRange.length = str.length();
         formatRange.format.setFont(font());
         formats.append(formatRange);
         textLayout.setFormats(formats);
     }
     QVector<QTextLayout::FormatRange> selectionFormat;
     textLayout.beginLayout();
     if(m_selection.lineWithin(line))
     {
         int firstPosInText = convertToPosInText(str, m_selection.firstPosInLine(line), m_pOptions->m_tabSize);
         int lastPosInText = convertToPosInText(str, m_selection.lastPosInLine(line), m_pOptions->m_tabSize);
         int lengthInText = max2(0, lastPosInText - firstPosInText);
         if(lengthInText > 0)
             m_selection.bSelectionContainsData = true;
 
         QTextLayout::FormatRange selection;
         selection.start = firstPosInText;
         selection.length = lengthInText;
         selection.format.setBackground(palette().highlight());
         selection.format.setForeground(palette().highlightedText().color());
         selectionFormat.push_back(selection);
     }
     QTextLine textLine = textLayout.createLine();
     textLine.setPosition(QPointF(0, fontMetrics().leading()));
     textLayout.endLayout();
     int cursorWidth = 5;
     if(m_pOptions->m_bRightToLeftLanguage)
         textLayout.setPosition(QPointF(width() - textLayout.maximumWidth() - getTextXOffset() + m_horizScrollOffset - cursorWidth, 0));
     else
         textLayout.setPosition(QPointF(getTextXOffset() - m_horizScrollOffset, 0));
     return selectionFormat;
 }
 
 void MergeResultWindow::writeLine(
     MyPainter& p, int line, const QString& str,
     int srcSelect, e_MergeDetails mergeDetails, int rangeMark, bool bUserModified, bool bLineRemoved, bool bWhiteSpaceConflict)
 {
     const QFontMetrics& fm = fontMetrics();
     int fontHeight = fm.lineSpacing();
     int fontAscent = fm.ascent();
 
     int topLineYOffset = 0;
     int xOffset = getTextXOffset();
 
     int yOffset = (line - m_firstLine) * fontHeight;
     if(yOffset < 0 || yOffset > height())
         return;
 
     yOffset += topLineYOffset;
 
     QString srcName = " ";
     if(bUserModified)
         srcName = "m";
     else if(srcSelect == A && mergeDetails != eNoChange)
         srcName = "A";
     else if(srcSelect == B)
         srcName = "B";
     else if(srcSelect == C)
         srcName = "C";
 
     if(rangeMark & 4)
     {
         p.fillRect(xOffset, yOffset, width(), fontHeight, m_pOptions->m_currentRangeBgColor);
     }
 
     if((srcSelect > 0 || bUserModified) && !bLineRemoved)
     {
         if(!m_pOptions->m_bRightToLeftLanguage)
             p.setClipRect(QRectF(xOffset, 0, width() - xOffset, height()));
         else
             p.setClipRect(QRectF(0, 0, width() - xOffset, height()));
 
         int outPos = 0;
         QString s;
         int size = str.length();
         for(int i = 0; i < size; ++i)
         {
             int spaces = 1;
             if(str[i] == '\t')
             {
                 spaces = tabber(outPos, m_pOptions->m_tabSize);
                 for(int j = 0; j < spaces; ++j)
                     s += ' ';
             }
             else
             {
                 s += str[i];
             }
             outPos += spaces;
         }
 
         p.setPen(m_pOptions->m_fgColor);
 
         QTextLayout textLayout(str, font(), this);
         QVector<QTextLayout::FormatRange> selectionFormat = getTextLayoutForLine(line, str, textLayout);
         textLayout.draw(&p, QPointF(0, yOffset), selectionFormat);
 
         if(line == m_cursorYPos)
         {
             m_cursorXPixelPos = textLayout.lineAt(0).cursorToX(m_cursorXPos);
             if(m_pOptions->m_bRightToLeftLanguage)
                 m_cursorXPixelPos += textLayout.position().x() - m_horizScrollOffset;
         }
 
         p.setClipping(false);
 
         p.setPen(m_pOptions->m_fgColor);
 
         p.drawText(1, yOffset + fontAscent, srcName, true);
     }
     else if(bLineRemoved)
     {
         p.setPen(m_pOptions->m_colorForConflict);
         p.drawText(xOffset, yOffset + fontAscent, i18n("<No src line>"));
         p.drawText(1, yOffset + fontAscent, srcName);
         if(m_cursorYPos == line) m_cursorXPos = 0;
     }
     else if(srcSelect == 0)
     {
         p.setPen(m_pOptions->m_colorForConflict);
         if(bWhiteSpaceConflict)
             p.drawText(xOffset, yOffset + fontAscent, i18n("<Merge Conflict (Whitespace only)>"));
         else
             p.drawText(xOffset, yOffset + fontAscent, i18n("<Merge Conflict>"));
         p.drawText(1, yOffset + fontAscent, "?");
         if(m_cursorYPos == line) m_cursorXPos = 0;
     }
     else
         Q_ASSERT(true);
 
     xOffset -= fm.width('0');
     p.setPen(m_pOptions->m_fgColor);
     if(rangeMark & 1) // begin mark
     {
         p.drawLine(xOffset, yOffset + 1, xOffset, yOffset + fontHeight / 2);
         p.drawLine(xOffset, yOffset + 1, xOffset - 2, yOffset + 1);
     }
     else
     {
         p.drawLine(xOffset, yOffset, xOffset, yOffset + fontHeight / 2);
     }
 
     if(rangeMark & 2) // end mark
     {
         p.drawLine(xOffset, yOffset + fontHeight / 2, xOffset, yOffset + fontHeight - 1);
         p.drawLine(xOffset, yOffset + fontHeight - 1, xOffset - 2, yOffset + fontHeight - 1);
     }
     else
     {
         p.drawLine(xOffset, yOffset + fontHeight / 2, xOffset, yOffset + fontHeight);
     }
 
     if(rangeMark & 4)
     {
         p.fillRect(xOffset + 3, yOffset, 3, fontHeight, m_pOptions->m_fgColor);
         /*      p.setPen( blue );
       p.drawLine( xOffset+2, yOffset, xOffset+2, yOffset+fontHeight-1 );
       p.drawLine( xOffset+3, yOffset, xOffset+3, yOffset+fontHeight-1 );*/
     }
 }
 
 void MergeResultWindow::setPaintingAllowed(bool bPaintingAllowed)
 {
     m_bPaintingAllowed = bPaintingAllowed;
     if(!m_bPaintingAllowed)
     {
         m_currentMergeLineIt = m_mergeLineList.end();
         reset();
     }
     update();
 }
 
 void MergeResultWindow::paintEvent(QPaintEvent*)
 {
     if(m_pDiff3LineList == nullptr || !m_bPaintingAllowed)
         return;
 
     bool bOldSelectionContainsData = m_selection.selectionContainsData();
     const QFontMetrics& fm = fontMetrics();
     int fontWidth = fm.width('0');
 
     if(!m_bCursorUpdate) // Don't redraw everything for blinking cursor?
     {
         m_selection.bSelectionContainsData = false;
         if(size() != m_pixmap.size())
             m_pixmap = QPixmap(size());
 
         MyPainter p(&m_pixmap, m_pOptions->m_bRightToLeftLanguage, width(), fontWidth);
         p.setFont(font());
         p.QPainter::fillRect(rect(), m_pOptions->m_bgColor);
 
         //int visibleLines = height() / fontHeight;
 
         int lastVisibleLine = m_firstLine + getNofVisibleLines() + 5;
         int line = 0;
         MergeLineList::iterator mlIt = m_mergeLineList.begin();
         for(mlIt = m_mergeLineList.begin(); mlIt != m_mergeLineList.end(); ++mlIt)
         {
             MergeLine& ml = *mlIt;
             if(line > lastVisibleLine || line + ml.mergeEditLineList.size() < m_firstLine)
             {
                 line += ml.mergeEditLineList.size();
             }
             else
             {
                 MergeEditLineList::iterator melIt;
                 for(melIt = ml.mergeEditLineList.begin(); melIt != ml.mergeEditLineList.end(); ++melIt)
                 {
                     if(line >= m_firstLine && line <= lastVisibleLine)
                     {
                         MergeEditLine& mel = *melIt;
                         MergeEditLineList::iterator melIt1 = melIt;
                         ++melIt1;
 
                         int rangeMark = 0;
                         if(melIt == ml.mergeEditLineList.begin()) rangeMark |= 1; // Begin range mark
                         if(melIt1 == ml.mergeEditLineList.end()) rangeMark |= 2;  // End range mark
 
                         if(mlIt == m_currentMergeLineIt) rangeMark |= 4; // Mark of the current line
 
                         QString s;
                         s = mel.getString(this);
 
                         writeLine(p, line, s, mel.src(), ml.mergeDetails, rangeMark,
                                   mel.isModified(), mel.isRemoved(), ml.bWhiteSpaceConflict);
                     }
                     ++line;
                 }
             }
         }
 
         if(line != m_nofLines)
         {
             m_nofLines = line;
             Q_ASSERT(m_nofLines == m_totalSize);
 
             emit resizeSignal();
         }
 
         p.end();
     }
 
     QPainter painter(this);
 
     if(!m_bCursorUpdate)
         painter.drawPixmap(0, 0, m_pixmap);
     else
     {
         painter.drawPixmap(0, 0, m_pixmap); // Draw everything. (Internally cursor rect is clipped anyway.)
         m_bCursorUpdate = false;
     }
     painter.end();
 
     if(m_bCursorOn && hasFocus() && m_cursorYPos >= m_firstLine)
     {
         QPainter painter(this);
 
         painter.setPen(m_pOptions->m_fgColor);
 
         QString str = getString(m_cursorYPos);
         QTextLayout textLayout(str, font(), this);
         getTextLayoutForLine(m_cursorYPos, str, textLayout);
         textLayout.drawCursor(&painter, QPointF(0, (m_cursorYPos - m_firstLine) * fontMetrics().lineSpacing()), m_cursorXPos);
     }
 
     if(!bOldSelectionContainsData && m_selection.selectionContainsData())
         emit newSelection();
 }
 
 void MergeResultWindow::updateSourceMask()
 {
     int srcMask = 0;
     int enabledMask = 0;
     if(!hasFocus() || m_pDiff3LineList == nullptr || !m_bPaintingAllowed || m_currentMergeLineIt == m_mergeLineList.end())
     {
         srcMask = 0;
         enabledMask = 0;
     }
     else
     {
         enabledMask = m_pldC == nullptr ? 3 : 7;
         MergeLine& ml = *m_currentMergeLineIt;
 
         srcMask = 0;
         bool bModified = false;
         MergeEditLineList::iterator melIt;
         for(melIt = ml.mergeEditLineList.begin(); melIt != ml.mergeEditLineList.end(); ++melIt)
         {
             MergeEditLine& mel = *melIt;
             if(mel.src() == 1) srcMask |= 1;
             if(mel.src() == 2) srcMask |= 2;
             if(mel.src() == 3) srcMask |= 4;
             if(mel.isModified() || !mel.isEditableText()) bModified = true;
         }
 
         if(ml.mergeDetails == eNoChange)
         {
             srcMask = 0;
             enabledMask = bModified ? 1 : 0;
         }
     }
 
     emit sourceMask(srcMask, enabledMask);
 }
 
 void MergeResultWindow::focusInEvent(QFocusEvent* e)
 {
     updateSourceMask();
     QWidget::focusInEvent(e);
 }
 
 int MergeResultWindow::convertToLine(int y)
 {
     const QFontMetrics& fm = fontMetrics();
     int fontHeight = fm.lineSpacing();
     int topLineYOffset = 0;
 
     int yOffset = topLineYOffset - m_firstLine * fontHeight;
 
     int line = min2((y - yOffset) / fontHeight, m_totalSize - 1);
     return line;
 }
 
 void MergeResultWindow::mousePressEvent(QMouseEvent* e)
 {
     m_bCursorOn = true;
 
     int xOffset = getTextXOffset();
 
     int line = convertToLine(e->y());
     QString s = getString(line);
     QTextLayout textLayout(s, font(), this);
     getTextLayoutForLine(line, s, textLayout);
     int pos = textLayout.lineAt(0).xToCursor(e->x() - textLayout.position().x());
 
     bool bLMB = e->button() == Qt::LeftButton;
     bool bMMB = e->button() == Qt::MidButton;
     bool bRMB = e->button() == Qt::RightButton;
 
     if((bLMB && (e->x() < xOffset)) || bRMB) // Fast range selection
     {
         m_cursorXPos = 0;
         m_cursorOldXPixelPos = 0;
         m_cursorYPos = max2(line, 0);
         int l = 0;
         MergeLineList::iterator i = m_mergeLineList.begin();
         for(i = m_mergeLineList.begin(); i != m_mergeLineList.end(); ++i)
         {
             if(l == line)
                 break;
 
             l += i->mergeEditLineList.size();
             if(l > line)
                 break;
         }
         m_selection.reset(); // Disable current selection
 
         m_bCursorOn = true;
         setFastSelector(i);
 
         if(bRMB)
         {
             emit showPopupMenu(QCursor::pos());
         }
     }
     else if(bLMB) // Normal cursor placement
     {
         pos = max2(pos, 0);
         line = max2(line, 0);
         if(e->QInputEvent::modifiers() & Qt::ShiftModifier)
         {
             if(!m_selection.isValidFirstLine())
                 m_selection.start(line, pos);
             m_selection.end(line, pos);
         }
         else
         {
             // Selection
             m_selection.reset();
             m_selection.start(line, pos);
             m_selection.end(line, pos);
         }
         m_cursorXPos = pos;
         m_cursorXPixelPos = textLayout.lineAt(0).cursorToX(pos);
         if(m_pOptions->m_bRightToLeftLanguage)
             m_cursorXPixelPos += textLayout.position().x() - m_horizScrollOffset;
         m_cursorOldXPixelPos = m_cursorXPixelPos;
         m_cursorYPos = line;
 
         update();
         //showStatusLine( line, m_winIdx, m_pFilename, m_pDiff3LineList, m_pStatusBar );
     }
     else if(bMMB) // Paste clipboard
     {
         pos = max2(pos, 0);
         line = max2(line, 0);
 
         m_selection.reset();
         m_cursorXPos = pos;
         m_cursorOldXPixelPos = m_cursorXPixelPos;
         m_cursorYPos = line;
 
         pasteClipboard(true);
     }
 }
 
 void MergeResultWindow::mouseDoubleClickEvent(QMouseEvent* e)
 {
     if(e->button() == Qt::LeftButton)
     {
         int line = convertToLine(e->y());
         QString s = getString(line);
         QTextLayout textLayout(s, font(), this);
         getTextLayoutForLine(line, s, textLayout);
         int pos = textLayout.lineAt(0).xToCursor(e->x() - textLayout.position().x());
         m_cursorXPos = pos;
         m_cursorOldXPixelPos = m_cursorXPixelPos;
         m_cursorYPos = line;
 
         if(!s.isEmpty())
         {
             int pos1, pos2;
 
             calcTokenPos(s, pos, pos1, pos2, m_pOptions->m_tabSize);
 
             resetSelection();
             m_selection.start(line, convertToPosOnScreen(s, pos1, m_pOptions->m_tabSize));
             m_selection.end(line, convertToPosOnScreen(s, pos2, m_pOptions->m_tabSize));
 
             update();
             // emit selectionEnd() happens in the mouseReleaseEvent.
         }
     }
 }
 
 void MergeResultWindow::mouseReleaseEvent(QMouseEvent* e)
 {
     if(e->button() == Qt::LeftButton)
     {
         if(m_delayedDrawTimer)
         {
             killTimer(m_delayedDrawTimer);
             m_delayedDrawTimer = 0;
         }
 
         if(m_selection.isValidFirstLine())
         {
             emit selectionEnd();
         }
     }
 }
 
 void MergeResultWindow::mouseMoveEvent(QMouseEvent* e)
 {
     int line = convertToLine(e->y());
     QString s = getString(line);
     QTextLayout textLayout(s, font(), this);
     getTextLayoutForLine(line, s, textLayout);
     int pos = textLayout.lineAt(0).xToCursor(e->x() - textLayout.position().x());
     m_cursorXPos = pos;
     m_cursorOldXPixelPos = m_cursorXPixelPos;
     m_cursorYPos = line;
     if(m_selection.isValidFirstLine())
     {
         m_selection.end(line, pos);
         myUpdate(0);
 
         //showStatusLine( line, m_winIdx, m_pFilename, m_pDiff3LineList, m_pStatusBar );
 
         // Scroll because mouse moved out of the window
         const QFontMetrics& fm = fontMetrics();
         int fontWidth = fm.width('0');
         int topLineYOffset = 0;
         int deltaX = 0;
         int deltaY = 0;
         if(!m_pOptions->m_bRightToLeftLanguage)
         {
             if(e->x() < getTextXOffset()) deltaX = -1;
             if(e->x() > width()) deltaX = +1;
         }
         else
         {
             if(e->x() > width() - 1 - getTextXOffset()) deltaX = -1;
             if(e->x() < fontWidth) deltaX = +1;
         }
         if(e->y() < topLineYOffset) deltaY = -1;
         if(e->y() > height()) deltaY = +1;
         m_scrollDeltaX = deltaX;
         m_scrollDeltaY = deltaY;
         if(deltaX != 0 || deltaY != 0)
         {
             scroll(deltaX, deltaY);
         }
     }
 }
 
 void MergeResultWindow::slotCursorUpdate()
 {
     m_cursorTimer.stop();
     m_bCursorOn = !m_bCursorOn;
 
     if(isVisible())
     {
         m_bCursorUpdate = true;
 
         const QFontMetrics& fm = fontMetrics();
         int topLineYOffset = 0;
         int yOffset = (m_cursorYPos - m_firstLine) * fm.lineSpacing() + topLineYOffset;
 
         repaint(0, yOffset, width(), fm.lineSpacing() + 2);
 
         m_bCursorUpdate = false;
     }
 
     m_cursorTimer.start(500);
 }
 
 void MergeResultWindow::wheelEvent(QWheelEvent* e)
 {
     int d = -e->delta() * QApplication::wheelScrollLines() / 120;
     e->accept();
     scroll(0, min2(d, getNofVisibleLines()));
 }
 
 bool MergeResultWindow::event(QEvent* e)
 {
     if(e->type() == QEvent::KeyPress)
     {
         QKeyEvent* ke = static_cast<QKeyEvent*>(e);
         if(ke->key() == Qt::Key_Tab)
         {
             // special tab handling here to avoid moving focus
             keyPressEvent(ke);
             return true;
         }
     }
     return QWidget::event(e);
 }
 void MergeResultWindow::keyPressEvent(QKeyEvent* e)
 {
     int y = m_cursorYPos;
     MergeLineList::iterator mlIt;
     MergeEditLineList::iterator melIt;
     calcIteratorFromLineNr(y, mlIt, melIt);
 
     QString str = melIt->getString(this);
     int x = convertToPosInText(str, m_cursorXPos, m_pOptions->m_tabSize);
 
     QTextLayout textLayoutOrig(str, font(), this);
     getTextLayoutForLine(y, str, textLayoutOrig);
 
     bool bCtrl = (e->QInputEvent::modifiers() & Qt::ControlModifier) != 0;
     bool bShift = (e->QInputEvent::modifiers() & Qt::ShiftModifier) != 0;
 #ifdef Q_OS_WIN
     bool bAlt = (e->QInputEvent::modifiers() & Qt::AltModifier) != 0;
     if(bCtrl && bAlt) {
         bCtrl = false;
         bAlt = false;
     } // AltGr-Key pressed.
 #endif
 
     bool bYMoveKey = false;
     // Special keys
     switch(e->key())
     {
     case Qt::Key_Escape:
         break;
     //case  Key_Tab:          break;
     case Qt::Key_Backtab:
         break;
     case Qt::Key_Delete:
     {
         if(deleteSelection2(str, x, y, mlIt, melIt)) break;
         if(!melIt->isEditableText()) break;
         if(x >= (int)str.length())
         {
             if(y < m_totalSize - 1)
             {
                 setModified();
                 MergeLineList::iterator mlIt1;
                 MergeEditLineList::iterator melIt1;
                 calcIteratorFromLineNr(y + 1, mlIt1, melIt1);
                 if(melIt1->isEditableText())
                 {
                     QString s2 = melIt1->getString(this);
                     melIt->setString(str + s2);
 
                     // Remove the line
                     if(mlIt1->mergeEditLineList.size() > 1)
                         mlIt1->mergeEditLineList.erase(melIt1);
                     else
                         melIt1->setRemoved();
                 }
             }
         }
         else
         {
             QString s = str.left(x);
             s += str.midRef(x + 1);
             melIt->setString(s);
             setModified();
         }
         break;
     }
     case Qt::Key_Backspace:
     {
         if(deleteSelection2(str, x, y, mlIt, melIt)) break;
         if(!melIt->isEditableText()) break;
         if(x == 0)
         {
             if(y > 0)
             {
                 setModified();
                 MergeLineList::iterator mlIt1;
                 MergeEditLineList::iterator melIt1;
                 calcIteratorFromLineNr(y - 1, mlIt1, melIt1);
                 if(melIt1->isEditableText())
                 {
                     QString s1 = melIt1->getString(this);
                     melIt1->setString(s1 + str);
 
                     // Remove the previous line
                     if(mlIt->mergeEditLineList.size() > 1)
                         mlIt->mergeEditLineList.erase(melIt);
                     else
                         melIt->setRemoved();
 
                     --y;
                     x = str.length();
                 }
             }
         }
         else
         {
             QString s = str.left(x - 1);
             s += str.midRef(x);
             --x;
             melIt->setString(s);
             setModified();
         }
         break;
     }
     case Qt::Key_Return:
     case Qt::Key_Enter:
     {
         if(!melIt->isEditableText()) break;
         deleteSelection2(str, x, y, mlIt, melIt);
         setModified();
         QString indentation;
         if(m_pOptions->m_bAutoIndentation)
         { // calc last indentation
             MergeLineList::iterator mlIt1 = mlIt;
             MergeEditLineList::iterator melIt1 = melIt;
             for(;;) {
                 const QString s = melIt1->getString(this);
                 if(!s.isEmpty()) {
                     int i;
                     for(i = 0; i < s.length(); ++i) {
                         if(s[i] != ' ' && s[i] != '\t') break;
                     }
                     if(i < s.length()) {
                         indentation = s.left(i);
                         break;
                     }
                 }
                 // Go back one line
                 if(melIt1 != mlIt1->mergeEditLineList.begin())
                     --melIt1;
                 else
                 {
                     if(mlIt1 == m_mergeLineList.begin()) break;
                     --mlIt1;
                     melIt1 = mlIt1->mergeEditLineList.end();
                     --melIt1;
                 }
             }
         }
         MergeEditLine mel(mlIt->id3l); // Associate every mel with an id3l, even if not really valid.
         mel.setString(indentation + str.mid(x));
 
         if(x < (int)str.length()) // Cut off the old line.
         {
             // Since ps possibly points into melIt->str, first copy it into a temporary.
             QString temp = str.left(x);
             melIt->setString(temp);
         }
 
         ++melIt;
         mlIt->mergeEditLineList.insert(melIt, mel);
         x = indentation.length();
         ++y;
         break;
     }
     case Qt::Key_Insert:
         m_bInsertMode = !m_bInsertMode;
         break;
     case Qt::Key_Pause:
         break;
     case Qt::Key_Print:
         break;
     case Qt::Key_SysReq:
         break;
     case Qt::Key_Home:
         x = 0;
         if(bCtrl) {
             y = 0;
         }
         break; // cursor movement
     case Qt::Key_End:
         x = INT_MAX;
         if(bCtrl) {
             y = INT_MAX;
         }
         break;
 
     case Qt::Key_Left:
     case Qt::Key_Right:
         if((e->key() == Qt::Key_Left) != m_pOptions->m_bRightToLeftLanguage)
         {
             if(!bCtrl)
             {
                 int newX = textLayoutOrig.previousCursorPosition(x);
                 if(newX == x && y > 0) {
                     --y;
                     x = INT_MAX;
                 }
                 else
                 {
                     x = newX;
                 }
             }
             else
             {
                 while(x > 0 && (str[x - 1] == ' ' || str[x - 1] == '\t'))
                 {
                     int newX = textLayoutOrig.previousCursorPosition(x);
                     if(newX == x) break;
                     x = newX;
                 }
                 while(x > 0 && (str[x - 1] != ' ' && str[x - 1] != '\t'))
                 {
                     int newX = textLayoutOrig.previousCursorPosition(x);
                     if(newX == x) break;
                     x = newX;
                 }
             }
         }
         else
         {
             if(!bCtrl)
             {
                 int newX = textLayoutOrig.nextCursorPosition(x);
                 if(newX == x && y < m_totalSize - 1) {
                     ++y;
                     x = 0;
                 }
                 else
                 {
                     x = newX;
                 }
             }
             else
             {
                 while(x < (int)str.length() && (str[x] == ' ' || str[x] == '\t'))
                 {
                     int newX = textLayoutOrig.nextCursorPosition(x);
                     if(newX == x) break;
                     x = newX;
                 }
                 while(x < (int)str.length() && (str[x] != ' ' && str[x] != '\t'))
                 {
                     int newX = textLayoutOrig.nextCursorPosition(x);
                     if(newX == x) break;
                     x = newX;
                 }
             }
         }
         break;
 
     case Qt::Key_Up:
         if(!bCtrl) {
             --y;
             bYMoveKey = true;
         }
         break;
     case Qt::Key_Down:
         if(!bCtrl) {
             ++y;
             bYMoveKey = true;
         }
         break;
     case Qt::Key_PageUp:
         if(!bCtrl) {
             y -= getNofVisibleLines();
             bYMoveKey = true;
         }
         break;
     case Qt::Key_PageDown:
         if(!bCtrl) {
             y += getNofVisibleLines();
             bYMoveKey = true;
         }
         break;
     default:
     {
         QString t = e->text();
         if(t.isEmpty() || bCtrl)
         {
             e->ignore();
             return;
         }
         else
         {
             if(bCtrl)
             {
                 e->ignore();
                 return;
             }
             else
             {
                 if(!melIt->isEditableText()) break;
                 deleteSelection2(str, x, y, mlIt, melIt);
 
                 setModified();
                 // Characters to insert
                 QString s = str;
                 if(t[0] == '\t' && m_pOptions->m_bReplaceTabs)
                 {
                     int spaces = (m_cursorXPos / m_pOptions->m_tabSize + 1) * m_pOptions->m_tabSize - m_cursorXPos;
                     t.fill(' ', spaces);
                 }
                 if(m_bInsertMode)
                     s.insert(x, t);
                 else
                     s.replace(x, t.length(), t);
 
                 melIt->setString(s);
                 x += t.length();
                 bShift = false;
             }
         }
     }
     }
 
     y = minMaxLimiter(y, 0, m_totalSize - 1);
 
     calcIteratorFromLineNr(y, mlIt, melIt);
     str = melIt->getString(this);
 
     x = minMaxLimiter(x, 0, (int)str.length());
 
     int newFirstLine = m_firstLine;
     int newHorizScrollOffset = m_horizScrollOffset;
 
     if(y < m_firstLine)
         newFirstLine = y;
     else if(y > m_firstLine + getNofVisibleLines())
         newFirstLine = y - getNofVisibleLines();
 
     QTextLayout textLayout(str, font(), this);
     getTextLayoutForLine(m_cursorYPos, str, textLayout);
 
     // try to preserve cursor x pixel position when moving to another line
     if(bYMoveKey)
     {
         if(m_pOptions->m_bRightToLeftLanguage)
             x = textLayout.lineAt(0).xToCursor(m_cursorOldXPixelPos - (textLayout.position().x() - m_horizScrollOffset));
         else
             x = textLayout.lineAt(0).xToCursor(m_cursorOldXPixelPos);
     }
 
     m_cursorXPixelPos = textLayout.lineAt(0).cursorToX(x);
     int hF = 1; // horizontal factor
     if(m_pOptions->m_bRightToLeftLanguage)
     {
         m_cursorXPixelPos += textLayout.position().x() - m_horizScrollOffset;
         hF = -1;
     }
     int cursorWidth = 5;
     if(m_cursorXPixelPos < hF * m_horizScrollOffset)
         newHorizScrollOffset = hF * m_cursorXPixelPos;
     else if(m_cursorXPixelPos > hF * m_horizScrollOffset + getVisibleTextAreaWidth() - cursorWidth)
         newHorizScrollOffset = hF * (m_cursorXPixelPos - (getVisibleTextAreaWidth() - cursorWidth));
 
     int newCursorX = x;
     if(bShift)
     {
         if(!m_selection.isValidFirstLine())
             m_selection.start(m_cursorYPos, m_cursorXPos);
 
         m_selection.end(y, newCursorX);
     }
     else
         m_selection.reset();
 
     m_cursorYPos = y;
     m_cursorXPos = newCursorX;
 
     // TODO if width of current line exceeds the current maximum width then force recalculating the scrollbars
     if(textLayout.maximumWidth() > getMaxTextWidth())
     {
         m_maxTextWidth = textLayout.maximumWidth();
         emit resizeSignal();
     }
     if(!bYMoveKey)
         m_cursorOldXPixelPos = m_cursorXPixelPos;
 
     m_bCursorOn = true;
     m_cursorTimer.start(500);
 
     update();
     if(newFirstLine != m_firstLine || newHorizScrollOffset != m_horizScrollOffset)
     {
         scroll(newHorizScrollOffset - m_horizScrollOffset, newFirstLine - m_firstLine);
         return;
     }
 }
 
 void MergeResultWindow::calcIteratorFromLineNr(
     int line,
     MergeResultWindow::MergeLineList::iterator& mlIt,
     MergeResultWindow::MergeEditLineList::iterator& melIt)
 {
     for(mlIt = m_mergeLineList.begin(); mlIt != m_mergeLineList.end(); ++mlIt)
     {
         MergeLine& ml = *mlIt;
         if(line > ml.mergeEditLineList.size())
         {
             line -= ml.mergeEditLineList.size();
         }
         else
         {
             for(melIt = ml.mergeEditLineList.begin(); melIt != ml.mergeEditLineList.end(); ++melIt)
             {
                 --line;
                 if(line < 0) return;
             }
         }
     }
 }
 
 QString MergeResultWindow::getSelection()
 {
     QString selectionString;
 
     int line = 0;
     MergeLineList::iterator mlIt = m_mergeLineList.begin();
     for(mlIt = m_mergeLineList.begin(); mlIt != m_mergeLineList.end(); ++mlIt)
     {
         MergeLine& ml = *mlIt;
         MergeEditLineList::iterator melIt;
         for(melIt = ml.mergeEditLineList.begin(); melIt != ml.mergeEditLineList.end(); ++melIt)
         {
             MergeEditLine& mel = *melIt;
 
             if(m_selection.lineWithin(line))
             {
                 int outPos = 0;
                 if(mel.isEditableText())
                 {
                     const QString str = mel.getString(this);
 
                     // Consider tabs
 
                     for(int i = 0; i < str.length(); ++i)
                     {
                         int spaces = 1;
                         if(str[i] == '\t')
                         {
                             spaces = tabber(outPos, m_pOptions->m_tabSize);
                         }
 
                         if(m_selection.within(line, outPos))
                         {
                             selectionString += str[i];
                         }
 
                         outPos += spaces;
                     }
                 }
                 else if(mel.isConflict())
                 {
                     selectionString += i18n("<Merge Conflict>");
                 }
 
                 if(m_selection.within(line, outPos))
                 {
 #ifdef Q_OS_WIN
                     selectionString += '\r';
 #endif
                     selectionString += '\n';
                 }
             }
 
             ++line;
         }
     }
 
     return selectionString;
 }
 
 bool MergeResultWindow::deleteSelection2(QString& s, int& x, int& y,
                                          MergeLineList::iterator& mlIt, MergeEditLineList::iterator& melIt)
 {
     if(m_selection.selectionContainsData())
     {
         Q_ASSERT(m_selection.isValidFirstLine());
         deleteSelection();
         y = m_cursorYPos;
         calcIteratorFromLineNr(y, mlIt, melIt);
         s = melIt->getString(this);
         x = convertToPosInText(s, m_cursorXPos, m_pOptions->m_tabSize);
         return true;
     }
 
     return false;
 }
 
 void MergeResultWindow::deleteSelection()
 {
     if(!m_selection.selectionContainsData())
     {
         return;
     }
     Q_ASSERT(m_selection.isValidFirstLine());
     
     setModified();
 
     int line = 0;
     MergeLineList::iterator mlItFirst;
     MergeEditLineList::iterator melItFirst;
     QString firstLineString;
 
     int firstLine = -1;
     int lastLine = -1;
 
     MergeLineList::iterator mlIt;
     for(mlIt = m_mergeLineList.begin(); mlIt != m_mergeLineList.end(); ++mlIt)
     {
         MergeLine& ml = *mlIt;
         MergeEditLineList::iterator melIt;
         for(melIt = ml.mergeEditLineList.begin(); melIt != ml.mergeEditLineList.end(); ++melIt)
         {
             MergeEditLine& mel = *melIt;
 
             if(mel.isEditableText() && m_selection.lineWithin(line))
             {
                 if(firstLine == -1)
                     firstLine = line;
                 lastLine = line;
             }
 
             ++line;
         }
     }
 
     if(firstLine == -1)
     {
         return; // Nothing to delete.
     }
 
     line = 0;
     for(mlIt = m_mergeLineList.begin(); mlIt != m_mergeLineList.end(); ++mlIt)
     {
         MergeLine& ml = *mlIt;
         MergeEditLineList::iterator melIt, melIt1;
         for(melIt = ml.mergeEditLineList.begin(); melIt != ml.mergeEditLineList.end();)
         {
             MergeEditLine& mel = *melIt;
             melIt1 = melIt;
             ++melIt1;
 
             if(mel.isEditableText() && m_selection.lineWithin(line))
             {
                 QString lineString = mel.getString(this);
 
                 int firstPosInLine = m_selection.firstPosInLine(line);
                 int lastPosInLine = m_selection.lastPosInLine(line);
 
                 if(line == firstLine)
                 {
                     mlItFirst = mlIt;
                     melItFirst = melIt;
                     int pos = convertToPosInText(lineString, firstPosInLine, m_pOptions->m_tabSize);
                     firstLineString = lineString.left(pos);
                 }
 
                 if(line == lastLine)
                 {
                     // This is the last line in the selection
                     int pos = convertToPosInText(lineString, lastPosInLine, m_pOptions->m_tabSize);
                     firstLineString += lineString.midRef(pos); // rest of line
                     melItFirst->setString(firstLineString);
                 }
 
                 if(line != firstLine || (m_selection.endPos() - m_selection.beginPos()) == lineString.length())
                 {
                     // Remove the line
                     if(mlIt->mergeEditLineList.size() > 1)
                         mlIt->mergeEditLineList.erase(melIt);
                     else
                         melIt->setRemoved();
                 }
             }
 
             ++line;
             melIt = melIt1;
         }
     }
 
     m_cursorYPos = m_selection.beginLine();
     m_cursorXPos = m_selection.beginPos();
     m_cursorOldXPixelPos = m_cursorXPixelPos;
 
     m_selection.reset();
 }
 
 void MergeResultWindow::pasteClipboard(bool bFromSelection)
 {
     //checking of m_selection if needed is done by deleteSelection no need for check here.
     deleteSelection();
 
     setModified();
 
     int y = m_cursorYPos;
     MergeLineList::iterator mlIt;
     MergeEditLineList::iterator melIt, melItAfter;
     calcIteratorFromLineNr(y, mlIt, melIt);
     melItAfter = melIt;
     ++melItAfter;
     QString str = melIt->getString(this);
     int x = convertToPosInText(str, m_cursorXPos, m_pOptions->m_tabSize);
 
     if(!QApplication::clipboard()->supportsSelection())
         bFromSelection = false;
 
     QString clipBoard = QApplication::clipboard()->text(bFromSelection ? QClipboard::Selection : QClipboard::Clipboard);
 
     QString currentLine = str.left(x);
     QString endOfLine = str.mid(x);
     int i;
     int len = clipBoard.length();
     for(i = 0; i < len; ++i)
     {
         QChar c = clipBoard[i];
         if(c == '\r') continue;
         if(c == '\n')
         {
             melIt->setString(currentLine);
             MergeEditLine mel(mlIt->id3l); // Associate every mel with an id3l, even if not really valid.
             melIt = mlIt->mergeEditLineList.insert(melItAfter, mel);
             currentLine = "";
             x = 0;
             ++y;
         }
         else
         {
             currentLine += c;
             ++x;
         }
     }
 
     currentLine += endOfLine;
     melIt->setString(currentLine);
 
     m_cursorYPos = y;
     m_cursorXPos = convertToPosOnScreen(currentLine, x, m_pOptions->m_tabSize);
     m_cursorOldXPixelPos = m_cursorXPixelPos;
 
     update();
 }
 
 void MergeResultWindow::resetSelection()
 {
     m_selection.reset();
     update();
 }
 
 void MergeResultWindow::setModified(bool bModified)
 {
     if(bModified != m_bModified)
     {
         m_bModified = bModified;
         emit modifiedChanged(m_bModified);
     }
 }
 
 /// Saves and returns true when successful.
 bool MergeResultWindow::saveDocument(const QString& fileName, QTextCodec* pEncoding, e_LineEndStyle eLineEndStyle)
 {
     // Are still conflicts somewhere?
     if(getNrOfUnsolvedConflicts() > 0)
     {
         KMessageBox::error(this,
                            i18n("Not all conflicts are solved yet.\n"
                                 "File not saved."),
                            i18n("Conflicts Left"));
         return false;
     }
 
     if(eLineEndStyle == eLineEndStyleConflict || eLineEndStyle == eLineEndStyleUndefined)
     {
         KMessageBox::error(this,
                            i18n("There is a line end style conflict. Please choose the line end style manually.\n"
                                 "File not saved."),
                            i18n("Conflicts Left"));
         return false;
     }
 
     update();
 
     FileAccess file(fileName, true /*bWantToWrite*/);
     if(m_pOptions->m_bDmCreateBakFiles && file.exists())
     {
         bool bSuccess = file.createBackup(".orig");
         if(!bSuccess)
         {
             KMessageBox::error(this, file.getStatusText() + i18n("\n\nCreating backup failed. File not saved."), i18n("File Save Error"));
             return false;
         }
     }
 
     QByteArray dataArray;
     QTextStream textOutStream(&dataArray, QIODevice::WriteOnly);
     if(pEncoding->name() == "UTF-8")
         textOutStream.setGenerateByteOrderMark(false); // Shouldn't be necessary. Bug in Qt or docs
     else
         textOutStream.setGenerateByteOrderMark(true); // Only for UTF-16
     textOutStream.setCodec(pEncoding);
 
     int line = 0;
     MergeLineList::iterator mlIt = m_mergeLineList.begin();
     for(mlIt = m_mergeLineList.begin(); mlIt != m_mergeLineList.end(); ++mlIt)
     {
         MergeLine& ml = *mlIt;
         MergeEditLineList::iterator melIt;
         for(melIt = ml.mergeEditLineList.begin(); melIt != ml.mergeEditLineList.end(); ++melIt)
         {
             MergeEditLine& mel = *melIt;
 
             if(mel.isEditableText())
             {
                 QString str = mel.getString(this);
 
                 if(line > 0) // Prepend line feed, but not for first line
                 {
                     if(eLineEndStyle == eLineEndStyleDos)
                     {
                         str.prepend("\r\n");
                     }
                     else
                     {
                         str.prepend("\n");
                     }
                 }
 
                 textOutStream << str;
                 ++line;
             }
         }
     }
     textOutStream.flush();
     bool bSuccess = file.writeFile(dataArray.data(), dataArray.size());
     if(!bSuccess)
     {
         KMessageBox::error(this, i18n("Error while writing."), i18n("File Save Error"));
         return false;
     }
 
     setModified(false);
     update();
 
     return true;
 }
 
 QString MergeResultWindow::getString(int lineIdx)
 {
     MergeResultWindow::MergeLineList::iterator mlIt;
     MergeResultWindow::MergeEditLineList::iterator melIt;
     calcIteratorFromLineNr(lineIdx, mlIt, melIt);
     QString s = melIt->getString(this);
     return s;
 }
 
 bool MergeResultWindow::findString(const QString& s, int& d3vLine, int& posInLine, bool bDirDown, bool bCaseSensitive)
 {
     int it = d3vLine;
     int endIt = bDirDown ? getNofLines() : -1;
     int step = bDirDown ? 1 : -1;
     int startPos = posInLine;
 
     for(; it != endIt; it += step)
     {
         QString line = getString(it);
         if(!line.isEmpty())
         {
             int pos = line.indexOf(s, startPos, bCaseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive);
             if(pos != -1)
             {
                 d3vLine = it;
                 posInLine = pos;
                 return true;
             }
 
             startPos = 0;
         }
     }
     return false;
 }
 
 void MergeResultWindow::setSelection(int firstLine, int startPos, int lastLine, int endPos)
 {
     if(lastLine >= getNofLines())
     {
         lastLine = getNofLines() - 1;
         QString s = getString(lastLine);
         endPos = s.length();
     }
     m_selection.reset();
     m_selection.start(firstLine, convertToPosOnScreen(getString(firstLine), startPos, m_pOptions->m_tabSize));
     m_selection.end(lastLine, convertToPosOnScreen(getString(lastLine), endPos, m_pOptions->m_tabSize));
     update();
 }
 
 Overview::Overview(Options* pOptions)
 //: QWidget( pParent, 0, Qt::WNoAutoErase )
 {
     m_pDiff3LineList = nullptr;
     m_pOptions = pOptions;
     m_bTripleDiff = false;
     m_eOverviewMode = eOMNormal;
     m_nofLines = 1;
     m_bPaintingAllowed = false;
     m_firstLine = 0;
     m_pageHeight = 0;
     
     setFixedWidth(20);
 }
 
 void Overview::init(Diff3LineList* pDiff3LineList, bool bTripleDiff)
 {
     m_pDiff3LineList = pDiff3LineList;
     m_bTripleDiff = bTripleDiff;
     m_pixmap = QPixmap(QSize(0, 0)); // make sure that a redraw happens
     update();
 }
 
 void Overview::reset()
 {
     m_pDiff3LineList = nullptr;
 }
 
 void Overview::slotRedraw()
 {
     m_pixmap = QPixmap(QSize(0, 0)); // make sure that a redraw happens
     update();
 }
 
 void Overview::setRange(int firstLine, int pageHeight)
 {
     m_firstLine = firstLine;
     m_pageHeight = pageHeight;
     update();
 }
 void Overview::setFirstLine(int firstLine)
 {
     m_firstLine = firstLine;
     update();
 }
 
 void Overview::setOverviewMode(e_OverviewMode eOverviewMode)
 {
     m_eOverviewMode = eOverviewMode;
     slotRedraw();
 }
 
 Overview::e_OverviewMode Overview::getOverviewMode()
 {
     return m_eOverviewMode;
 }
 
 void Overview::mousePressEvent(QMouseEvent* e)
 {
     int h = height() - 1;
     int h1 = h * m_pageHeight / max2(1, m_nofLines) + 3;
     if(h > 0)
         emit setLine((e->y() - h1 / 2) * m_nofLines / h);
 }
 
 void Overview::mouseMoveEvent(QMouseEvent* e)
 {
     mousePressEvent(e);
 }
 
 void Overview::setPaintingAllowed(bool bAllowPainting)
 {
     if(m_bPaintingAllowed != bAllowPainting)
     {
         m_bPaintingAllowed = bAllowPainting;
         if(m_bPaintingAllowed)
             update();
         else
             reset();
     }
 }
 
 void Overview::drawColumn(QPainter& p, e_OverviewMode eOverviewMode, int x, int w, int h, int nofLines)
 {
     p.setPen(Qt::black);
     p.drawLine(x, 0, x, h);
 
     if(nofLines == 0) return;
 
     int line = 0;
     int oldY = 0;
     int oldConflictY = -1;
     int wrapLineIdx = 0;
     Diff3LineList::const_iterator i;
     for(i = m_pDiff3LineList->begin(); i != m_pDiff3LineList->end();)
     {
         const Diff3Line& d3l = *i;
         int y = h * (line + 1) / nofLines;
         e_MergeDetails md;
         bool bConflict;
         bool bLineRemoved;
         int src;
         mergeOneLine(d3l, md, bConflict, bLineRemoved, src, !m_bTripleDiff);
 
         QColor c = m_pOptions->m_bgColor;
         bool bWhiteSpaceChange = false;
         //if( bConflict )  c=m_pOptions->m_colorForConflict;
         //else
         if(eOverviewMode == eOMNormal)
         {
             switch(md)
             {
             case eDefault:
             case eNoChange:
                 c = m_pOptions->m_bgColor;
                 break;
 
             case eBAdded:
             case eBDeleted:
             case eBChanged:
                 c = bConflict ? m_pOptions->m_colorForConflict : m_pOptions->m_colorB;
                 bWhiteSpaceChange = d3l.bAEqB || (d3l.bWhiteLineA && d3l.bWhiteLineB);
                 break;
 
             case eCAdded:
             case eCDeleted:
             case eCChanged:
                 bWhiteSpaceChange = d3l.bAEqC || (d3l.bWhiteLineA && d3l.bWhiteLineC);
                 c = bConflict ? m_pOptions->m_colorForConflict : m_pOptions->m_colorC;
                 break;
 
             case eBCChanged:         // conflict
             case eBCChangedAndEqual: // possible conflict
             case eBCDeleted:         // possible conflict
             case eBChanged_CDeleted: // conflict
             case eCChanged_BDeleted: // conflict
             case eBCAdded:           // conflict
             case eBCAddedAndEqual:   // possible conflict
                 c = m_pOptions->m_colorForConflict;
                 break;
             default:
                 Q_ASSERT(true);
                 break;
             }
         }
         else if(eOverviewMode == eOMAvsB)
         {
             switch(md)
             {
             case eDefault:
             case eNoChange:
             case eCAdded:
             case eCDeleted:
             case eCChanged:
                 break;
             default:
                 c = m_pOptions->m_colorForConflict;
                 bWhiteSpaceChange = d3l.bAEqB || (d3l.bWhiteLineA && d3l.bWhiteLineB);
                 break;
             }
         }
         else if(eOverviewMode == eOMAvsC)
         {
             switch(md)
             {
             case eDefault:
             case eNoChange:
             case eBAdded:
             case eBDeleted:
             case eBChanged:
                 break;
             default:
                 c = m_pOptions->m_colorForConflict;
                 bWhiteSpaceChange = d3l.bAEqC || (d3l.bWhiteLineA && d3l.bWhiteLineC);
                 break;
             }
         }
         else if(eOverviewMode == eOMBvsC)
         {
             switch(md)
             {
             case eDefault:
             case eNoChange:
             case eBCChangedAndEqual:
             case eBCDeleted:
             case eBCAddedAndEqual:
                 break;
             default:
                 c = m_pOptions->m_colorForConflict;
                 bWhiteSpaceChange = d3l.bBEqC || (d3l.bWhiteLineB && d3l.bWhiteLineC);
                 break;
             }
         }
 
         int x2 = x;
         int w2 = w;
 
         if(!m_bTripleDiff)
         {
             if(d3l.lineA == -1 && d3l.lineB >= 0)
             {
                 c = m_pOptions->m_colorA;
                 x2 = w / 2;
                 w2 = x2;
             }
             if(d3l.lineA >= 0 && d3l.lineB == -1)
             {
                 c = m_pOptions->m_colorB;
                 w2 = w / 2;
             }
         }
 
         if(!bWhiteSpaceChange || m_pOptions->m_bShowWhiteSpace)
         {
             // Make sure that lines with conflict are not overwritten.
             if(c == m_pOptions->m_colorForConflict)
             {
                 p.fillRect(x2 + 1, oldY, w2, max2(1, y - oldY), bWhiteSpaceChange ? QBrush(c, Qt::Dense4Pattern) : QBrush(c));
                 oldConflictY = oldY;
             }
             else if(c != m_pOptions->m_bgColor && oldY > oldConflictY)
             {
                 p.fillRect(x2 + 1, oldY, w2, max2(1, y - oldY), bWhiteSpaceChange ? QBrush(c, Qt::Dense4Pattern) : QBrush(c));
             }
         }
 
         oldY = y;
 
         ++line;
         if(m_pOptions->m_bWordWrap)
         {
             ++wrapLineIdx;
             if(wrapLineIdx >= d3l.linesNeededForDisplay)
             {
                 wrapLineIdx = 0;
                 ++i;
             }
         }
         else
         {
             ++i;
         }
     }
 }
 
 void Overview::paintEvent(QPaintEvent*)
 {
     if(m_pDiff3LineList == nullptr || !m_bPaintingAllowed) return;
     int h = height() - 1;
     int w = width();
 
     if(m_pixmap.size() != size())
     {
         if(m_pOptions->m_bWordWrap)
         {
             m_nofLines = 0;
             Diff3LineList::const_iterator i;
             for(i = m_pDiff3LineList->begin(); i != m_pDiff3LineList->end(); ++i)
             {
                 m_nofLines += i->linesNeededForDisplay;
             }
         }
         else
         {
             m_nofLines = m_pDiff3LineList->size();
         }
 
         m_pixmap = QPixmap(size());
 
         QPainter p(&m_pixmap);
         p.fillRect(rect(), m_pOptions->m_bgColor);
 
         if(!m_bTripleDiff || m_eOverviewMode == eOMNormal)
         {
             drawColumn(p, eOMNormal, 0, w, h, m_nofLines);
         }
         else
         {
             drawColumn(p, eOMNormal, 0, w / 2, h, m_nofLines);
             drawColumn(p, m_eOverviewMode, w / 2, w / 2, h, m_nofLines);
         }
     }
 
     QPainter painter(this);
     painter.drawPixmap(0, 0, m_pixmap);
 
     int y1 = h * m_firstLine / m_nofLines - 1;
     int h1 = h * m_pageHeight / m_nofLines + 3;
     painter.setPen(Qt::black);
     painter.drawRect(1, y1, w - 1, h1);
 }
 
 WindowTitleWidget::WindowTitleWidget(Options* pOptions)
 {
     m_pOptions = pOptions;
     setAutoFillBackground(true);
 
     QHBoxLayout* pHLayout = new QHBoxLayout(this);
     pHLayout->setMargin(2);
     pHLayout->setSpacing(2);
 
     m_pLabel = new QLabel(i18n("Output:"));
     pHLayout->addWidget(m_pLabel);
 
     m_pFileNameLineEdit = new QLineEdit();
     pHLayout->addWidget(m_pFileNameLineEdit, 6);
     m_pFileNameLineEdit->installEventFilter(this);
     m_pFileNameLineEdit->setReadOnly(true);
 
     //m_pBrowseButton = new QPushButton("...");
     //pHLayout->addWidget( m_pBrowseButton, 0 );
     //connect( m_pBrowseButton, SIGNAL(clicked()), this, SLOT(slotBrowseButtonClicked()));
 
     m_pModifiedLabel = new QLabel(i18n("[Modified]"));
     pHLayout->addWidget(m_pModifiedLabel);
     m_pModifiedLabel->setMinimumSize(m_pModifiedLabel->sizeHint());
     m_pModifiedLabel->setText("");
 
     pHLayout->addStretch(1);
 
     m_pEncodingLabel = new QLabel(i18n("Encoding for saving:"));
     pHLayout->addWidget(m_pEncodingLabel);
 
     m_pEncodingSelector = new QComboBox();
     m_pEncodingSelector->setSizeAdjustPolicy(QComboBox::AdjustToContents);
     pHLayout->addWidget(m_pEncodingSelector, 2);
     setEncodings(nullptr, nullptr, nullptr);
 
     m_pLineEndStyleLabel = new QLabel(i18n("Line end style:"));
     pHLayout->addWidget(m_pLineEndStyleLabel);
     m_pLineEndStyleSelector = new QComboBox();
     m_pLineEndStyleSelector->setSizeAdjustPolicy(QComboBox::AdjustToContents);
     pHLayout->addWidget(m_pLineEndStyleSelector);
     setLineEndStyles(eLineEndStyleUndefined, eLineEndStyleUndefined, eLineEndStyleUndefined);
 }
 
 void WindowTitleWidget::setFileName(const QString& fileName)
 {
     m_pFileNameLineEdit->setText(QDir::toNativeSeparators(fileName));
 }
 
 QString WindowTitleWidget::getFileName()
 {
     return m_pFileNameLineEdit->text();
 }
 
 //static QString getLineEndStyleName( e_LineEndStyle eLineEndStyle )
 //{
 //   if ( eLineEndStyle == eLineEndStyleDos )
 //      return "DOS";
 //   else if ( eLineEndStyle == eLineEndStyleUnix )
 //      return "Unix";
 //   return QString();
 //}
 
 void WindowTitleWidget::setLineEndStyles(e_LineEndStyle eLineEndStyleA, e_LineEndStyle eLineEndStyleB, e_LineEndStyle eLineEndStyleC)
 {
     m_pLineEndStyleSelector->clear();
     QString dosUsers;
     if(eLineEndStyleA == eLineEndStyleDos)
         dosUsers += "A";
     if(eLineEndStyleB == eLineEndStyleDos)
         dosUsers += (dosUsers.isEmpty() ? "" : ", ") + QString("B");
     if(eLineEndStyleC == eLineEndStyleDos)
         dosUsers += (dosUsers.isEmpty() ? "" : ", ") + QString("C");
     QString unxUsers;
     if(eLineEndStyleA == eLineEndStyleUnix)
         unxUsers += "A";
     if(eLineEndStyleB == eLineEndStyleUnix)
         unxUsers += (unxUsers.isEmpty() ? "" : ", ") + QString("B");
     if(eLineEndStyleC == eLineEndStyleUnix)
         unxUsers += (unxUsers.isEmpty() ? "" : ", ") + QString("C");
 
     m_pLineEndStyleSelector->addItem(i18n("Unix") + (unxUsers.isEmpty() ? QString("") : " (" + unxUsers + ")"));
     m_pLineEndStyleSelector->addItem(i18n("DOS") + (dosUsers.isEmpty() ? QString("") : " (" + dosUsers + ")"));
 
     e_LineEndStyle autoChoice = (e_LineEndStyle)m_pOptions->m_lineEndStyle;
 
     if(m_pOptions->m_lineEndStyle == eLineEndStyleAutoDetect)
     {
         if(eLineEndStyleA != eLineEndStyleUndefined && eLineEndStyleB != eLineEndStyleUndefined && eLineEndStyleC != eLineEndStyleUndefined)
         {
             if(eLineEndStyleA == eLineEndStyleB)
                 autoChoice = eLineEndStyleC;
             else if(eLineEndStyleA == eLineEndStyleC)
                 autoChoice = eLineEndStyleB;
             else
                 autoChoice = eLineEndStyleConflict; //conflict (not likely while only two values exist)
         }
         else
         {
             e_LineEndStyle c1, c2;
             if(eLineEndStyleA == eLineEndStyleUndefined) {
                 c1 = eLineEndStyleB;
                 c2 = eLineEndStyleC;
             }
             else if(eLineEndStyleB == eLineEndStyleUndefined)
             {
                 c1 = eLineEndStyleA;
                 c2 = eLineEndStyleC;
             }
             else /*if( eLineEndStyleC == eLineEndStyleUndefined )*/
             {
                 c1 = eLineEndStyleA;
                 c2 = eLineEndStyleB;
             }
             if(c1 == c2 && c1 != eLineEndStyleUndefined)
                 autoChoice = c1;
             else
                 autoChoice = eLineEndStyleConflict;
         }
     }
 
     if(autoChoice == eLineEndStyleUnix)
         m_pLineEndStyleSelector->setCurrentIndex(0);
     else if(autoChoice == eLineEndStyleDos)
         m_pLineEndStyleSelector->setCurrentIndex(1);
     else if(autoChoice == eLineEndStyleConflict)
     {
         m_pLineEndStyleSelector->addItem(i18n("Conflict"));
         m_pLineEndStyleSelector->setCurrentIndex(2);
     }
 }
 
 e_LineEndStyle WindowTitleWidget::getLineEndStyle()
 {
 
     int current = m_pLineEndStyleSelector->currentIndex();
     if(current == 0)
         return eLineEndStyleUnix;
     else if(current == 1)
         return eLineEndStyleDos;
     else
         return eLineEndStyleConflict;
 }
 
 void WindowTitleWidget::setEncodings(QTextCodec* pCodecForA, QTextCodec* pCodecForB, QTextCodec* pCodecForC)
 {
     m_pEncodingSelector->clear();
 
     // First sort codec names:
     std::map<QString, QTextCodec*> names;
     QList<int> mibs = QTextCodec::availableMibs();
     foreach(int i, mibs)
     {
         QTextCodec* c = QTextCodec::codecForMib(i);
         if(c != nullptr)
             names[QString(c->name())] = c;
     }
 
     if(pCodecForA)
         m_pEncodingSelector->addItem(i18n("Codec from A: %1", QLatin1String(pCodecForA->name())), QVariant::fromValue((void*)pCodecForA));
     if(pCodecForB)
         m_pEncodingSelector->addItem(i18n("Codec from B: %1", QLatin1String(pCodecForB->name())), QVariant::fromValue((void*)pCodecForB));
     if(pCodecForC)
         m_pEncodingSelector->addItem(i18n("Codec from C: %1", QLatin1String(pCodecForC->name())), QVariant::fromValue((void*)pCodecForC));
 
     std::map<QString, QTextCodec*>::iterator it;
     for(it = names.begin(); it != names.end(); ++it)
     {
         m_pEncodingSelector->addItem(it->first, QVariant::fromValue((void*)it->second));
     }
     m_pEncodingSelector->setMinimumSize(m_pEncodingSelector->sizeHint());
 
     if(pCodecForC && pCodecForB && pCodecForA)
     {
         if(pCodecForA == pCodecForB)
             m_pEncodingSelector->setCurrentIndex(2); // C
         else if(pCodecForA == pCodecForC)
             m_pEncodingSelector->setCurrentIndex(1); // B
         else
             m_pEncodingSelector->setCurrentIndex(2); // C
     }
     else if(pCodecForA && pCodecForB)
         m_pEncodingSelector->setCurrentIndex(1); // B
     else
         m_pEncodingSelector->setCurrentIndex(0);
 }
 
 QTextCodec* WindowTitleWidget::getEncoding()
 {
     return (QTextCodec*)m_pEncodingSelector->itemData(m_pEncodingSelector->currentIndex()).value<void*>();
 }
 
 void WindowTitleWidget::setEncoding(QTextCodec* pEncoding)
 {
     int idx = m_pEncodingSelector->findText(pEncoding->name());
     if(idx >= 0)
         m_pEncodingSelector->setCurrentIndex(idx);
 }
 
 //void WindowTitleWidget::slotBrowseButtonClicked()
 //{
 //   QString current = m_pFileNameLineEdit->text();
 //
 //   QUrl newURL = KFileDialog::getSaveUrl( current, 0, this, i18n("Select file (not saving yet)"));
 //   if ( !newURL.isEmpty() )
 //   {
 //      m_pFileNameLineEdit->setText( newURL.url() );
 //   }
 //}
 
 void WindowTitleWidget::slotSetModified(bool bModified)
 {
     m_pModifiedLabel->setText(bModified ? i18n("[Modified]") : "");
 }
 
 bool WindowTitleWidget::eventFilter(QObject* o, QEvent* e)
 {
     if(e->type() == QEvent::FocusIn || e->type() == QEvent::FocusOut)
     {
         QPalette p = m_pLabel->palette();
 
         QColor c1 = m_pOptions->m_fgColor;
         QColor c2 = Qt::lightGray;
         if(e->type() == QEvent::FocusOut)
             c2 = m_pOptions->m_bgColor;
 
         p.setColor(QPalette::Window, c2);
         setPalette(p);
 
         p.setColor(QPalette::WindowText, c1);
         m_pLabel->setPalette(p);
         m_pEncodingLabel->setPalette(p);
         m_pEncodingSelector->setPalette(p);
     }
     if(o == m_pFileNameLineEdit && e->type() == QEvent::Drop)
     {
         QDropEvent* d = static_cast<QDropEvent*>(e);
 
         if(d->mimeData()->hasUrls())
         {
             QList<QUrl> lst = d->mimeData()->urls();
 
             if(lst.count() > 0)
             {
                 static_cast<QLineEdit*>(o)->setText(lst[0].toString());
                 static_cast<QLineEdit*>(o)->setFocus();
                 return true;
             }
         }
     }
     return false;
 }
 
 //#include "mergeresultwindow.moc"
diff --git a/src/optiondialog.cpp b/src/optiondialog.cpp
index 43011a2..c57422b 100644
--- a/src/optiondialog.cpp
+++ b/src/optiondialog.cpp
@@ -1,1904 +1,1904 @@
 /*
  *   kdiff3 - Text Diff And Merge Tool
  *   Copyright (C) 2002-2009  Joachim Eibl, joachim.eibl at gmx.de
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
  *   the Free Software Foundation; either version 2 of the License, or
  *   (at your option) any later version.
  *
  *   This program is distributed in the hope that it will be useful,
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *   GNU General Public License for more details.
  *
  *   You should have received a copy of the GNU General Public License
  *   along with this program; if not, write to the Free Software
  *   Foundation, Inc., 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA.
  *
  */
 
 #include <QApplication>
 #include <QCheckBox>
 #include <QComboBox>
 #include <QDialogButtonBox>
 #include <QDir>
 #include <QFontDatabase>
 #include <QFontDialog>
 #include <QFrame>
 #include <QGridLayout>
 #include <QGroupBox>
 #include <QLabel>
 #include <QLayout>
 #include <QLineEdit>
 #include <QLocale>
 #include <QPixmap>
 #include <QPlainTextEdit>
 #include <QPushButton>
 #include <QRadioButton>
 #include <QSettings>
 #include <QTextCodec>
 #include <QToolTip>
 
 #include <KColorButton>
 #include <KConfigGroup>
 #include <KHelpClient>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KSharedConfig>
 #include <KToolBar>
 #include <map>
 
 #include "diff.h"
 #include "optiondialog.h"
 #include "smalldialogs.h"
 
 #define KDIFF3_CONFIG_GROUP "KDiff3 Options"
 
 QString s_historyEntryStartRegExpToolTip;
 QString s_historyEntryStartSortKeyOrderToolTip;
 QString s_autoMergeRegExpToolTip;
 QString s_historyStartRegExpToolTip;
 
 void OptionDialog::addOptionItem(OptionItem* p)
 {
     m_optionItemList.push_back(p);
 }
 
 class OptionItem
 {
   public:
     OptionItem(OptionDialog* pOptionDialog, const QString& saveName)
     {
         Q_ASSERT(pOptionDialog != nullptr);
         pOptionDialog->addOptionItem(this);
         m_saveName = saveName;
         m_bPreserved = false;
     }
     virtual ~OptionItem() {}
     virtual void setToDefault() = 0;
     virtual void setToCurrent() = 0;
     virtual void apply() = 0;
     virtual void write(ValueMap*) = 0;
     virtual void read(ValueMap*) = 0;
     void doPreserve()
     {
         if(!m_bPreserved) {
             m_bPreserved = true;
             preserve();
         }
     }
     void doUnpreserve()
     {
         if(m_bPreserved) {
             unpreserve();
         }
     }
     QString getSaveName() { return m_saveName; }
 
   protected:
     virtual void preserve() = 0;
     virtual void unpreserve() = 0;
     bool m_bPreserved;
     QString m_saveName;
 };
 
 template <class T>
 class OptionItemT : public OptionItem
 {
   public:
     OptionItemT(OptionDialog* pOptionDialog, const QString& saveName)
         : OptionItem(pOptionDialog, saveName)
     {
     }
 
   protected:
     void preserve() override { m_preservedVal = *m_pVar; }
     void unpreserve() override { *m_pVar = m_preservedVal; }
     T* m_pVar;
     T m_preservedVal;
     T m_defaultVal;
 };
 
 class OptionCheckBox : public QCheckBox, public OptionItemT<bool>
 {
   public:
     OptionCheckBox(QString text, bool bDefaultVal, const QString& saveName, bool* pbVar,
                    QWidget* pParent, OptionDialog* pOD)
         : QCheckBox(text, pParent), OptionItemT<bool>(pOD, saveName)
     {
         m_pVar = pbVar;
         m_defaultVal = bDefaultVal;
     }
     void setToDefault() override { setChecked(m_defaultVal); }
     void setToCurrent() override { setChecked(*m_pVar); }
     void apply() override { *m_pVar = isChecked(); }
     void write(ValueMap* config) override { config->writeEntry(m_saveName, *m_pVar); }
     void read(ValueMap* config) override { *m_pVar = config->readBoolEntry(m_saveName, *m_pVar); }
 
   private:
     OptionCheckBox(const OptionCheckBox&); // private copy constructor without implementation
 };
 
 class OptionRadioButton : public QRadioButton, public OptionItemT<bool>
 {
   public:
     OptionRadioButton(QString text, bool bDefaultVal, const QString& saveName, bool* pbVar,
                       QWidget* pParent, OptionDialog* pOD)
         : QRadioButton(text, pParent), OptionItemT<bool>(pOD, saveName)
     {
         m_pVar = pbVar;
         m_defaultVal = bDefaultVal;
     }
     void setToDefault() override { setChecked(m_defaultVal); }
     void setToCurrent() override { setChecked(*m_pVar); }
     void apply() override { *m_pVar = isChecked(); }
     void write(ValueMap* config) override { config->writeEntry(m_saveName, *m_pVar); }
     void read(ValueMap* config) override { *m_pVar = config->readBoolEntry(m_saveName, *m_pVar); }
 
   private:
     OptionRadioButton(const OptionRadioButton&); // private copy constructor without implementation
 };
 
 template <class T>
 class OptionT : public OptionItemT<T>
 {
   public:
     OptionT(const T& defaultVal, const QString& saveName, T* pVar, OptionDialog* pOD)
         : OptionItemT<T>(pOD, saveName)
     {
         this->m_pVar = pVar;
         *this->m_pVar = defaultVal;
     }
     OptionT(const QString& saveName, T* pVar, OptionDialog* pOD)
         : OptionItemT<T>(pOD, saveName)
     {
         this->m_pVar = pVar;
     }
     void setToDefault() override {}
     void setToCurrent() override {}
     void apply() override {}
     void write(ValueMap* vm) override { writeEntry(vm, this->m_saveName, *this->m_pVar); }
     void read(ValueMap* vm) override { *this->m_pVar = vm->readEntry(this->m_saveName, *this->m_pVar); }
 
   private:
     OptionT(const OptionT&); // private copy constructor without implementation
 };
 
 template <class T>
 void writeEntry(ValueMap* vm, const QString& saveName, const T& v)
 {
     vm->writeEntry(saveName, v);
 }
 static void writeEntry(ValueMap* vm, const QString& saveName, const QStringList& v)
 {
     vm->writeEntry(saveName, v);
 }
 
 //static void readEntry(ValueMap* vm, const QString& saveName, bool& v )       {   v = vm->readBoolEntry( saveName, v ); }
 //static void readEntry(ValueMap* vm, const QString& saveName, int&  v )       {   v = vm->readNumEntry( saveName, v ); }
 //static void readEntry(ValueMap* vm, const QString& saveName, QSize& v )      {   v = vm->readSizeEntry( saveName, &v ); }
 //static void readEntry(ValueMap* vm, const QString& saveName, QPoint& v )     {   v = vm->readPointEntry( saveName, &v ); }
 //static void readEntry(ValueMap* vm, const QString& saveName, QStringList& v ){   v = vm->readListEntry( saveName, QStringList(), '|' ); }
 
 typedef OptionT<bool> OptionToggleAction;
 typedef OptionT<int> OptionNum;
 typedef OptionT<QPoint> OptionPoint;
 typedef OptionT<QSize> OptionSize;
 typedef OptionT<QStringList> OptionStringList;
 
 FontChooser::FontChooser(QWidget* pParent)
     : QGroupBox(pParent)
 {
     QVBoxLayout* pLayout = new QVBoxLayout(this);
     m_pLabel = new QLabel(QString(), this);
     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"), this);
     m_pSelectFont->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
     connect(m_pSelectFont, SIGNAL(clicked()), this, SLOT(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 OptionItemT<QFont>
 {
   public:
     OptionFontChooser(const QFont& defaultVal, const QString& saveName, QFont* pVar, QWidget* pParent, OptionDialog* pOD) : FontChooser(pParent),
                                                                                                                             OptionItemT<QFont>(pOD, saveName)
     {
         m_pVar = pVar;
         *m_pVar = defaultVal;
         m_defaultVal = defaultVal;
     }
     void setToDefault() override { setFont(m_defaultVal, false); }
     void setToCurrent() override { setFont(*m_pVar, false); }
     void apply() override { *m_pVar = font(); }
     void write(ValueMap* config) override { config->writeEntry(m_saveName, *m_pVar); }
     void read(ValueMap* config) override { *m_pVar = config->readFontEntry(m_saveName, m_pVar); }
 
   private:
     OptionFontChooser(const OptionToggleAction&); // private copy constructor without implementation
 };
 
 class OptionColorButton : public KColorButton, public OptionItemT<QColor>
 {
   public:
     OptionColorButton(QColor defaultVal, const QString& saveName, QColor* pVar, QWidget* pParent, OptionDialog* pOD)
         : KColorButton(pParent), OptionItemT<QColor>(pOD, saveName)
     {
         m_pVar = pVar;
         m_defaultVal = defaultVal;
     }
     void setToDefault() override { setColor(m_defaultVal); }
     void setToCurrent() override { setColor(*m_pVar); }
     void apply() override { *m_pVar = color(); }
     void write(ValueMap* config) override { config->writeEntry(m_saveName, *m_pVar); }
     void read(ValueMap* config) override { *m_pVar = config->readColorEntry(m_saveName, m_pVar); }
 
   private:
     OptionColorButton(const OptionColorButton&); // private copy constructor without implementation
 };
 
 class OptionLineEdit : public QComboBox, public OptionItemT<QString>
 {
   public:
     OptionLineEdit(const QString& defaultVal, const QString& saveName, QString* pVar,
                    QWidget* pParent, OptionDialog* pOD)
         : QComboBox(pParent), OptionItemT<QString>(pOD, saveName)
     {
         setMinimumWidth(50);
         setEditable(true);
         m_pVar = pVar;
         m_defaultVal = defaultVal;
         m_list.push_back(defaultVal);
         insertText();
     }
     void setToDefault() override
     {
         setEditText(m_defaultVal);
     }
     void setToCurrent() override
     {
         setEditText(*m_pVar);
     }
     void apply() override
     {
         *m_pVar = currentText();
         insertText();
     }
     void write(ValueMap* config) override
     {
         config->writeEntry(m_saveName, m_list);
     }
     void read(ValueMap* config) override
     {
         m_list = config->readListEntry(m_saveName, QStringList(m_defaultVal));
         if(!m_list.empty()) *m_pVar = 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);
     }
     OptionLineEdit(const OptionLineEdit&); // private copy constructor without implementation
     QStringList m_list;
 };
 
 #if defined QT_NO_VALIDATOR
 #error No validator
 #endif
 class OptionIntEdit : public QLineEdit, public OptionItemT<int>
 {
   public:
     OptionIntEdit(int defaultVal, const QString& saveName, int* pVar, int rangeMin, int rangeMax,
                   QWidget* pParent, OptionDialog* pOD)
         : QLineEdit(pParent), OptionItemT<int>(pOD, saveName)
     {
         m_pVar = pVar;
         m_defaultVal = defaultVal;
         QIntValidator* v = new QIntValidator(this);
         v->setRange(rangeMin, rangeMax);
         setValidator(v);
     }
     void setToDefault() override
     {
         QString s;
         s.setNum(m_defaultVal);
         setText(s);
     }
     void setToCurrent() override
     {
         QString s;
         s.setNum(*m_pVar);
         setText(s);
     }
     void apply() override
     {
         const QIntValidator* v = static_cast<const QIntValidator*>(validator());
         *m_pVar = minMaxLimiter(text().toInt(), v->bottom(), v->top());
         setText(QString::number(*m_pVar));
     }
     void write(ValueMap* config) override { config->writeEntry(m_saveName, *m_pVar); }
     void read(ValueMap* config) override { *m_pVar = config->readNumEntry(m_saveName, *m_pVar); }
 
   private:
     OptionIntEdit(const OptionIntEdit&); // private copy constructor without implementation
 };
 
 class OptionComboBox : public QComboBox, public OptionItem
 {
   public:
     OptionComboBox(int defaultVal, const QString& saveName, int* pVarNum,
                    QWidget* pParent, OptionDialog* pOD)
         : QComboBox(pParent), OptionItem(pOD, saveName)
     {
         setMinimumWidth(50);
         m_pVarNum = pVarNum;
         m_pVarStr = nullptr;
         m_defaultVal = defaultVal;
         setEditable(false);
     }
     OptionComboBox(int defaultVal, const QString& saveName, QString* pVarStr,
                    QWidget* pParent, OptionDialog* pOD)
         : QComboBox(pParent), OptionItem(pOD, 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);
     }
     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->readNumEntry(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:
     OptionComboBox(const OptionIntEdit&); // private copy constructor without implementation
     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 OptionItem
 {
     Q_OBJECT
     QVector<QTextCodec*> m_codecVec;
     QTextCodec** m_ppVarCodec;
 
   public:
     OptionEncodingComboBox(const QString& saveName, QTextCodec** ppVarCodec,
                            QWidget* pParent, OptionDialog* pOD)
         : QComboBox(pParent), OptionItem(pOD, saveName)
     {
         m_ppVarCodec = ppVarCodec;
         insertCodec(i18n("Unicode, 8 bit"), QTextCodec::codecForName("UTF-8"));
         insertCodec(i18n("Unicode"), QTextCodec::codecForName("iso-10646-UCS-2"));
         insertCodec(i18n("Latin1"), QTextCodec::codecForName("iso 8859-1"));
 
         // First sort codec names:
         std::map<QString, QTextCodec*> names;
         QList<int> mibs = QTextCodec::availableMibs();
         foreach(int i, mibs)
         {
             QTextCodec* c = QTextCodec::codecForMib(i);
             if(c != nullptr)
                 names[QString(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)
         {
             for(int i = 0; i < m_codecVec.size(); ++i)
             {
                 if(c == m_codecVec[i])
                     return; // don't insert any codec twice
             }
             addItem(visibleCodecName.isEmpty() ? QString(c->name()) : visibleCodecName + " (" + c->name() + ")", (int)m_codecVec.size());
             m_codecVec.push_back(c);
         }
     }
     void setToDefault() override
     {
         QString defaultName = QTextCodec::codecForLocale()->name();
         for(int i = 0; i < count(); ++i)
         {
             if(defaultName == itemText(i) &&
                m_codecVec[i] == QTextCodec::codecForLocale())
             {
                 setCurrentIndex(i);
                 if(m_ppVarCodec != nullptr) {
                     *m_ppVarCodec = m_codecVec[i];
                 }
                 return;
             }
         }
 
         setCurrentIndex(0);
         if(m_ppVarCodec != nullptr) {
             *m_ppVarCodec = m_codecVec[0];
         }
     }
     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;
                 }
             }
         }
     }
     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, QString((*m_ppVarCodec)->name()));
     }
     void read(ValueMap* config) override
     {
         QString codecName = config->readEntry(m_saveName, QString(m_codecVec[currentIndex()]->name()));
         for(int i = 0; i < m_codecVec.size(); ++i)
         {
             if(codecName == 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;
 };
 
 OptionDialog::OptionDialog(bool bShowDirMergeSettings, QWidget* parent, char* name) : //    KPageDialog( IconList, i18n("Configure"), Help|Default|Apply|Ok|Cancel,
                                                                                       //                 Ok, parent, name, true /*modal*/, true )
                                                                                       KPageDialog(parent)
 {
     setFaceType(List);
     setWindowTitle(i18n("Configure"));
     setStandardButtons(QDialogButtonBox::Help | QDialogButtonBox::RestoreDefaults | QDialogButtonBox::Apply | QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
     // TODO KF5 necessary?  setDefaultButton( Ok );
     setObjectName(name);
     setModal(true);
 
     //showButtonSeparator( true );
     //setHelp( "kdiff3/index.html", QString::null );
 
     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"), QString());
 }
 
 OptionDialog::~OptionDialog(void)
 {
 }
 
 void OptionDialog::setupOtherOptions()
 {
     //TODO move to Options class
     new OptionToggleAction(false, "AutoAdvance", &m_options.m_bAutoAdvance, this);
     new OptionToggleAction(true, "ShowWhiteSpaceCharacters", &m_options.m_bShowWhiteSpaceCharacters, this);
     new OptionToggleAction(true, "ShowWhiteSpace", &m_options.m_bShowWhiteSpace, this);
     new OptionToggleAction(false, "ShowLineNumbers", &m_options.m_bShowLineNumbers, this);
     new OptionToggleAction(true, "HorizDiffWindowSplitting", &m_options.m_bHorizDiffWindowSplitting, this);
     new OptionToggleAction(false, "WordWrap", &m_options.m_bWordWrap, this);
 
     new OptionToggleAction(true, "ShowIdenticalFiles", &m_options.m_bDmShowIdenticalFiles, this);
 
     new OptionToggleAction(true, "Show Toolbar", &m_options.m_bShowToolBar, this);
     new OptionToggleAction(true, "Show Statusbar", &m_options.m_bShowStatusBar, this);
 
     /*
    TODO manage toolbar positioning
    */
     new OptionNum( Qt::TopToolBarArea, "ToolBarPos", (int*)&m_options.m_toolBarPos, this );
     new OptionSize(QSize(600, 400), "Geometry", &m_options.m_geometry, this);
     new OptionPoint(QPoint(0, 22), "Position", &m_options.m_position, this);
     new OptionToggleAction(false, "WindowStateMaximised", &m_options.m_bMaximised, this);
 
     new OptionStringList("RecentAFiles", &m_options.m_recentAFiles, this);
     new OptionStringList("RecentBFiles", &m_options.m_recentBFiles, this);
     new OptionStringList("RecentCFiles", &m_options.m_recentCFiles, this);
     new OptionStringList("RecentOutputFiles", &m_options.m_recentOutputFiles, this);
     new OptionStringList("RecentEncodings", &m_options.m_recentEncodings, this);
 }
 
 void OptionDialog::setupFontPage(void)
 {
     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, this);
     topLayout->addWidget(pAppFontChooser);
     pAppFontChooser->setTitle(i18n("Application font"));
 
     OptionFontChooser* pFontChooser = new OptionFontChooser(defaultFont, "Font", &m_options.m_font, page, this);
     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 );
     //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(void)
 {
     QFrame* page = new QFrame();
     KPageWidgetItem* pageItem = new KPageWidgetItem(page, i18n("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, this);
     label = new QLabel(i18n("Foreground color:"), page);
     label->setBuddy(pFgColor);
     gbox->addWidget(label, line, 0);
     gbox->addWidget(pFgColor, line, 1);
     ++line;
 
     OptionColorButton* pBgColor = new OptionColorButton(Qt::white, "BgColor", &m_options.m_bgColor, page, this);
     label = new QLabel(i18n("Background color:"), page);
     label->setBuddy(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, this);
     label = new QLabel(i18n("Diff background color:"), page);
     label->setBuddy(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, this);
     label = new QLabel(i18n("Color A:"), page);
     label->setBuddy(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, this);
     label = new QLabel(i18n("Color B:"), page);
     label->setBuddy(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, this);
     label = new QLabel(i18n("Color C:"), page);
     label->setBuddy(pColorC);
     gbox->addWidget(label, line, 0);
     gbox->addWidget(pColorC, line, 1);
     ++line;
 
     OptionColorButton* pColorForConflict = new OptionColorButton(Qt::red, "ColorForConflict", &m_options.m_colorForConflict, page, this);
     label = new QLabel(i18n("Conflict color:"), page);
     label->setBuddy(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, this);
     label = new QLabel(i18n("Current range background color:"), page);
     label->setBuddy(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, this);
     label = new QLabel(i18n("Current range diff background color:"), page);
     label->setBuddy(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, this);
     label = new QLabel(i18n("Color for manually aligned difference ranges:"), page);
     label->setBuddy(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, this);
     label = new QLabel(i18n("Newest file color:"), page);
     label->setBuddy(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, this);
     label = new QLabel(i18n("Oldest file color:"), page);
     label->setBuddy(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, this);
     label = new QLabel(i18n("Middle age file color:"), page);
     label->setBuddy(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, this);
     label = new QLabel(i18n("Color for missing files:"), page);
     label->setBuddy(pColor);
     gbox->addWidget(label, line, 0);
     gbox->addWidget(pColor, line, 1);
     label->setToolTip(dirColorTip);
     ++line;
 
     topLayout->addStretch(10);
 }
 
 void OptionDialog::setupEditPage(void)
 {
     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, this);
     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, this);
     label = new QLabel(i18n("Tab size:"), page);
     label->setBuddy(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, this);
     gbox->addWidget(pAutoIndentation, line, 0, 1, 2);
     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, this);
     gbox->addWidget(pAutoCopySelection, line, 0, 1, 2);
     pAutoCopySelection->setToolTip(i18n(
         "On: Any selection is immediately written to the clipboard.\n"
-        "Off: You must explicitely copy e.g. via Ctrl-C."));
+        "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", &m_options.m_lineEndStyle, page, this);
     gbox->addWidget(pLineEndStyle, line, 1);
     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(void)
 {
     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 );
     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, this);
     gbox->addWidget(pIgnoreNumbers, line, 0, 1, 2);
     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, this);
     gbox->addWidget(pIgnoreComments, line, 0, 1, 2);
     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, this);
     gbox->addWidget(pIgnoreCase, line, 0, 1, 2);
     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, this);
     gbox->addWidget(pLE, line, 1);
     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, this);
     gbox->addWidget(pLE, line, 1);
     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, this);
     gbox->addWidget(pTryHard, line, 0, 1, 2);
     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, this);
     gbox->addWidget(pDiff3AlignBC, line, 0, 1, 2);
     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(void)
 {
     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, this);
     gbox->addWidget(pAutoAdvanceDelay, line, 1);
     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, this);
     gbox->addWidget(pShowInfoDialogs, line, 0, 1, 2);
     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, this);
     gbox->addWidget(pWhiteSpace2FileMergeDefault, line, 1);
     pWhiteSpace2FileMergeDefault->insertItem(0, i18n("Manual Choice"));
     pWhiteSpace2FileMergeDefault->insertItem(1, "A");
     pWhiteSpace2FileMergeDefault->insertItem(2, "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, this);
     gbox->addWidget(pWhiteSpace3FileMergeDefault, line, 1);
     pWhiteSpace3FileMergeDefault->insertItem(0, i18n("Manual Choice"));
     pWhiteSpace3FileMergeDefault->insertItem(1, "A");
     pWhiteSpace3FileMergeDefault->insertItem(2, "B");
     pWhiteSpace3FileMergeDefault->insertItem(3, "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;
     {
         QGridLayout* gbox = new QGridLayout(pGroupBox);
         gbox->setColumnStretch(1, 10);
         int 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, this);
         gbox->addWidget(m_pAutoMergeRegExpLineEdit, line, 1);
         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, this);
         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;
     {
         QGridLayout* gbox = new QGridLayout(pGroupBox);
         gbox->setColumnStretch(1, 10);
         int 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, this);
         gbox->addWidget(m_pHistoryStartRegExpLineEdit, line, 1);
         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, this);
         gbox->addWidget(m_pHistoryEntryStartRegExpLineEdit, line, 1);
         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, this);
         gbox->addWidget(m_pHistoryMergeSorting, line, 0, 1, 2);
         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, this);
         gbox->addWidget(m_pHistorySortKeyOrderLineEdit, line, 1);
         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, this);
         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, this);
         label = new QLabel(i18n("Max number of history entries:"), page);
         gbox->addWidget(label, line, 0);
         gbox->addWidget(pMaxNofHistoryEntries, line, 1);
         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, this);
     gbox->addWidget(pLE, line, 1);
     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, this);
     gbox->addWidget(pAutoSaveAndQuit, line, 0, 1, 2);
     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(void)
 {
     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, this);
     gbox->addWidget(pRecursiveDirs, line, 0, 1, 2);
     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, this);
     gbox->addWidget(pFilePattern, line, 1);
     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, this);
     gbox->addWidget(pFileAntiPattern, line, 1);
     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, this);
     gbox->addWidget(pDirAntiPattern, line, 1);
     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, this);
     gbox->addWidget(pUseCvsIgnore, line, 0, 1, 2);
     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, this);
     gbox->addWidget(pFindHidden, line, 0, 1, 2);
 #if defined(Q_OS_WIN)
     pFindHidden->setToolTip(i18n("Finds files and directories with the hidden attribute."));
 #else
     pFindHidden->setToolTip(i18n("Finds files and directories starting with '.'."));
 #endif
     ++line;
 
     OptionCheckBox* pFollowFileLinks = new OptionCheckBox(i18n("Follow file links"), false, "FollowFileLinks", &m_options.m_bDmFollowFileLinks, page, this);
     gbox->addWidget(pFollowFileLinks, line, 0, 1, 2);
     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, this);
     gbox->addWidget(pFollowDirLinks, line, 0, 1, 2);
     pFollowDirLinks->setToolTip(i18n(
         "On: Compare the directory the link points to.\n"
         "Off: Compare the links."));
     ++line;
 
 //OptionCheckBox* pShowOnlyDeltas = new OptionCheckBox( i18n("List only deltas"),false,"ListOnlyDeltas", &m_options.m_bDmShowOnlyDeltas, page, this );
 //gbox->addWidget( pShowOnlyDeltas, line, 0, 1, 2 );
 //pShowOnlyDeltas->setToolTip( i18n(
 //              "Files and directories without change will not appear in the list."));
 //++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, this);
     gbox->addWidget(pCaseSensitiveFileNames, line, 0, 1, 2);
     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, this);
     gbox->addWidget(pUnfoldSubdirs, line, 0, 1, 2);
     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, this);
     gbox->addWidget(pSkipDirStatus, line, 0, 1, 2);
     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, this);
     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, this);
     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, this);
     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, this);
     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, this);
     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, this);
     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, this);
     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, this);
     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, this);
     gbox->addWidget(pCreateBakFiles, line, 0, 1, 2);
     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(void)
 {
     /*
      TODO: What is this line supposed to do besides leak memmory? Intruduced as is in .91 no explaination
         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, this);
     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, this);
     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, this);
     gbox->addWidget(m_pAutoDetectUnicodeA, line, 2);
     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, this);
     gbox->addWidget(m_pEncodingBComboBox, line, 1);
     m_pAutoDetectUnicodeB = new OptionCheckBox(i18n("Auto Detect Unicode"), true, "AutoDetectUnicodeB", &m_options.m_bAutoDetectUnicodeB, page, this);
     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, this);
     gbox->addWidget(m_pEncodingCComboBox, line, 1);
     m_pAutoDetectUnicodeC = new OptionCheckBox(i18n("Auto Detect Unicode"), true, "AutoDetectUnicodeC", &m_options.m_bAutoDetectUnicodeC, page, this);
     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, this);
     gbox->addWidget(m_pEncodingOutComboBox, line, 1);
     m_pAutoSelectOutEncoding = new OptionCheckBox(i18n("Auto Select"), true, "AutoSelectOutEncoding", &m_options.m_bAutoSelectOutEncoding, page, this);
     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, this);
     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, this);
     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);
 }
 
 // TODO: Integrate this properly in the build system.
 // Currently breaks compilation on Windows b/c of:
-//   src\ccInstHelper.cpp(15): fatal error C1083: Cannot open include file: 'C:/Programme/NSIS/Contrib/ExDll/exdll.h': No such file or directory
+//   src\ccInstHelper.cpp(15): fatal error C1083: Cannot open include file: 'C:/Program Files/NSIS/Contrib/ExDll/exdll.h': No such file or directory
 #define ENABLE_CC_INTEGRATION 0
 
 #if ENABLE_CC_INTEGRATION
 #include "ccInstHelper.cpp"
 #endif
 
 void OptionDialog::setupIntegrationPage(void)
 {
     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, this);
     gbox->addWidget(pIgnorableCmdLineOptions, line, 1, 1, 2);
     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, this);
     gbox->addWidget(pEscapeKeyQuits, line, 0, 1, 2);
     pEscapeKeyQuits->setToolTip(i18n(
         "Fast method to exit.\n"
         "For those who are used to using the Escape key."));
     ++line;
 
 #if ENABLE_CC_INTEGRATION
     QPushButton* pIntegrateWithClearCase = new QPushButton(i18n("Integrate with ClearCase"), page);
     gbox->addWidget(pIntegrateWithClearCase, line, 0);
     pIntegrateWithClearCase->setToolTip(i18n(
         "Integrate with Rational ClearCase from IBM.\n"
         "Modifies the \"map\" file in ClearCase subdir \"lib/mgrs\"\n"
         "(Only enabled when ClearCase \"bin\" directory is in the path.)"));
     connect(pIntegrateWithClearCase, &QPushButton::clicked, this, &OptionDialog::slotIntegrateWithClearCase);
     pIntegrateWithClearCase->setEnabled(integrateWithClearCase("existsClearCase", "") != 0);
 
     QPushButton* pRemoveClearCaseIntegration = new QPushButton(i18n("Remove ClearCase Integration"), page);
     gbox->addWidget(pRemoveClearCaseIntegration, line, 1);
     pRemoveClearCaseIntegration->setToolTip(i18n(
         "Restore the old \"map\" file from before doing the ClearCase integration."));
     connect(pRemoveClearCaseIntegration, &QPushButton::clicked, this, &OptionDialog::slotRemoveClearCaseIntegration);
     pRemoveClearCaseIntegration->setEnabled(integrateWithClearCase("existsClearCase", "") != 0);
 
     ++line;
 #endif
 
     topLayout->addStretch(10);
 }
 
 void OptionDialog::slotIntegrateWithClearCase()
 {
 #if ENABLE_CC_INTEGRATION
     char kdiff3CommandPath[1000];
     GetModuleFileNameA(0, kdiff3CommandPath, sizeof(kdiff3CommandPath) - 1);
     integrateWithClearCase("install", kdiff3CommandPath);
 #endif
 }
 
 void OptionDialog::slotRemoveClearCaseIntegration()
 {
 #if ENABLE_CC_INTEGRATION
     char kdiff3CommandPath[1000];
     GetModuleFileNameA(0, kdiff3CommandPath, sizeof(kdiff3CommandPath) - 1);
     integrateWithClearCase("uninstall", kdiff3CommandPath);
 #endif
 }
 
 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(void)
 {
     //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(void)
 {
     slotApply();
 
     accept();
 }
 
 /** Copy the values from the widgets to the public variables.*/
 void OptionDialog::slotApply(void)
 {
     std::list<OptionItem*>::iterator i;
     for(i = m_optionItemList.begin(); i != m_optionItemList.end(); ++i)
     {
         (*i)->apply();
     }
 
     emit applyDone();
 
 #ifdef Q_OS_WIN
     QString locale = m_options.m_language;
     if(locale == "Auto" || locale.isEmpty())
         locale = QLocale::system().name().left(2);
     int spacePos = locale.indexOf(' ');
     if(spacePos > 0) locale = locale.left(spacePos);
     QSettings settings("HKEY_CURRENT_USER\\Software\\KDiff3\\diff-ext", QSettings::NativeFormat);
     settings.setValue("Language", locale);
 #endif
 }
 
 /** 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()
 {
     std::list<OptionItem*>::iterator i;
     for(i = m_optionItemList.begin(); i != m_optionItemList.end(); ++i)
     {
         (*i)->setToDefault();
     }
 
     slotEncodingChanged();
 }
 
 /** Initialise the widgets using the values in the public varibles. */
 void OptionDialog::setState()
 {
     std::list<OptionItem*>::iterator i;
     for(i = m_optionItemList.begin(); i != m_optionItemList.end(); ++i)
     {
         (*i)->setToCurrent();
     }
 
     slotEncodingChanged();
 }
 
 class ConfigValueMap : public ValueMap
 {
   private:
     KConfigGroup m_config;
 
   public:
     explicit ConfigValueMap(const KConfigGroup& config) : m_config(config) {}
 
     void writeEntry(const QString& s, const QFont& v) override
     {
         m_config.writeEntry(s, v);
     }
     void writeEntry(const QString& s, const QColor& v) override
     {
         m_config.writeEntry(s, v);
     }
     void writeEntry(const QString& s, const QSize& v) override
     {
         m_config.writeEntry(s, v);
     }
     void writeEntry(const QString& s, const QPoint& v) override
     {
         m_config.writeEntry(s, v);
     }
     void writeEntry(const QString& s, int v) override
     {
         m_config.writeEntry(s, v);
     }
     void writeEntry(const QString& s, bool v) override
     {
         m_config.writeEntry(s, v);
     }
     void writeEntry(const QString& s, const QString& v) override
     {
         m_config.writeEntry(s, v);
     }
     void writeEntry(const QString& s, const char* v) override
     {
         m_config.writeEntry(s, v);
     }
 
     QFont readFontEntry(const QString& s, const QFont* defaultVal) override
     {
         return m_config.readEntry(s, *defaultVal);
     }
     QColor readColorEntry(const QString& s, const QColor* defaultVal) override
     {
         return m_config.readEntry(s, *defaultVal);
     }
     QSize readSizeEntry(const QString& s, const QSize* defaultVal) override
     {
         return m_config.readEntry(s, *defaultVal);
     }
     QPoint readPointEntry(const QString& s, const QPoint* defaultVal) override
     {
         return m_config.readEntry(s, *defaultVal);
     }
     bool readBoolEntry(const QString& s, bool defaultVal) override
     {
         return m_config.readEntry(s, defaultVal);
     }
     int readNumEntry(const QString& s, int defaultVal) override
     {
         return m_config.readEntry(s, defaultVal);
     }
     QString readStringEntry(const QString& s, const QString& defaultVal) override
     {
         return m_config.readEntry(s, defaultVal);
     }
 
     void writeEntry(const QString& s, const QStringList& v) override
     {
         m_config.writeEntry(s, v);
     }
     QStringList readListEntry(const QString& s, const QStringList& def) override
     {
         return m_config.readEntry(s, def);
     }
 };
 
 void OptionDialog::saveOptions(KSharedConfigPtr config)
 {
     // No i18n()-Translations here!
 
     ConfigValueMap cvm(config->group(KDIFF3_CONFIG_GROUP));
     std::list<OptionItem*>::iterator i;
     for(i = m_optionItemList.begin(); i != m_optionItemList.end(); ++i)
     {
         (*i)->doUnpreserve();
         (*i)->write(&cvm);
     }
 }
 
 void OptionDialog::readOptions(KSharedConfigPtr config)
 {
     // No i18n()-Translations here!
 
     ConfigValueMap cvm(config->group(KDIFF3_CONFIG_GROUP));
     std::list<OptionItem*>::iterator i;
     for(i = m_optionItemList.begin(); i != m_optionItemList.end(); ++i)
     {
         (*i)->read(&cvm);
     }
 
     setState();
 }
 
 QString OptionDialog::parseOptions(const QStringList& optionList)
 {
     QString result;
     QStringList::const_iterator i;
     for(i = optionList.begin(); i != optionList.end(); ++i)
     {
         QString s = *i;
 
         int pos = s.indexOf('=');
         if(pos > 0) // seems not to have a tag
         {
             QString key = s.left(pos);
             QString val = s.mid(pos + 1);
             std::list<OptionItem*>::iterator j;
             bool bFound = false;
             for(j = m_optionItemList.begin(); j != m_optionItemList.end(); ++j)
             {
                 if((*j)->getSaveName() == key)
                 {
                     (*j)->doPreserve();
                     ValueMap config;
                     config.writeEntry(key, val); // Write the value as a string and
                     (*j)->read(&config);         // use the internal conversion from string to the needed value.
                     bFound = true;
                     break;
                 }
             }
             if(!bFound)
             {
                 result += "No config item named \"" + key + "\"\n";
             }
         }
         else
         {
             result += "No '=' found in \"" + s + "\"\n";
         }
     }
     return result;
 }
 
 QString OptionDialog::calcOptionHelp()
 {
     ValueMap config;
     std::list<OptionItem*>::iterator j;
     for(j = m_optionItemList.begin(); j != m_optionItemList.end(); ++j)
     {
         (*j)->write(&config);
     }
     return config.getAsString();
 }
 
 void OptionDialog::slotHistoryMergeRegExpTester()
 {
     RegExpTester dlg(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/progress.cpp b/src/progress.cpp
index 39efc0e..ee61908 100644
--- a/src/progress.cpp
+++ b/src/progress.cpp
@@ -1,540 +1,540 @@
 /***************************************************************************
  *   Copyright (C) 2003-2011 by Joachim Eibl                               *
  *   joachim.eibl at gmx.de                                                *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  ***************************************************************************/
 
 #include "progress.h"
 #include "common.h"
 
 #include <QApplication>
 #include <QLabel>
 #include <QProgressBar>
 #include <QPushButton>
 #include <QStatusBar>
 #include <QThread>
 #include <QVBoxLayout>
 
 #include <KIO/Job>
 #include <KLocalizedString>
 
 ProgressDialog* g_pProgressDialog = nullptr;
 
 ProgressDialog::ProgressDialog(QWidget* pParent, QStatusBar* pStatusBar)
     : QDialog(pParent), m_pStatusBar(pStatusBar)
 {
     m_pGuiThread = QThread::currentThread();
 
     setObjectName("ProgressDialog");
     m_bStayHidden = false;
     setModal(true);
     QVBoxLayout* layout = new QVBoxLayout(this);
 
     m_pInformation = new QLabel(" ", this);
     layout->addWidget(m_pInformation);
 
     m_pProgressBar = new QProgressBar();
     m_pProgressBar->setRange(0, 1000);
     layout->addWidget(m_pProgressBar);
 
     m_pSubInformation = new QLabel(" ", this);
     layout->addWidget(m_pSubInformation);
 
     m_pSubProgressBar = new QProgressBar();
     m_pSubProgressBar->setRange(0, 1000);
     layout->addWidget(m_pSubProgressBar);
 
     m_pSlowJobInfo = new QLabel(" ", this);
     layout->addWidget(m_pSlowJobInfo);
 
     QHBoxLayout* hlayout = new QHBoxLayout();
     layout->addLayout(hlayout);
     hlayout->addStretch(1);
     m_pAbortButton = new QPushButton(i18n("&Cancel"), this);
     hlayout->addWidget(m_pAbortButton);
     connect(m_pAbortButton, &QPushButton::clicked, this, &ProgressDialog::slotAbort);
     if(m_pStatusBar)
     {
         m_pStatusBarWidget = new QWidget;
         QHBoxLayout* pStatusBarLayout = new QHBoxLayout(m_pStatusBarWidget);
         pStatusBarLayout->setMargin(0);
         pStatusBarLayout->setSpacing(3);
         m_pStatusProgressBar = new QProgressBar;
         m_pStatusProgressBar->setRange(0, 1000);
         m_pStatusProgressBar->setTextVisible(false);
         m_pStatusAbortButton = new QPushButton(i18n("&Cancel"));
         connect(m_pStatusAbortButton, SIGNAL(clicked()), this, SLOT(slotAbort()));
         pStatusBarLayout->addWidget(m_pStatusProgressBar);
         pStatusBarLayout->addWidget(m_pStatusAbortButton);
         m_pStatusBar->addPermanentWidget(m_pStatusBarWidget, 0);
         m_pStatusBarWidget->setFixedHeight(m_pStatusBar->height());
         m_pStatusBarWidget->hide();
     }
     else
     {
         m_pStatusProgressBar = nullptr;
         m_pStatusAbortButton = nullptr;
     }
 
     m_progressDelayTimer = 0;
     m_delayedHideTimer = 0;
     m_delayedHideStatusBarWidgetTimer = 0;
     resize(400, 100);
     m_t1.start();
     m_t2.start();
     m_bWasCancelled = false;
     m_eCancelReason = eUserAbort;
     m_pJob = nullptr;
 }
 
 void ProgressDialog::setStayHidden(bool bStayHidden)
 {
     if(m_bStayHidden != bStayHidden)
     {
         m_bStayHidden = bStayHidden;
         if(m_pStatusBarWidget)
         {
             if(m_bStayHidden)
             {
                 if(m_delayedHideStatusBarWidgetTimer)
                 {
                     killTimer(m_delayedHideStatusBarWidgetTimer);
                     m_delayedHideStatusBarWidgetTimer = 0;
                 }
                 m_pStatusBarWidget->show();
             }
             else
                 hideStatusBarWidget(); // delayed
         }
         if(isVisible() && m_bStayHidden)
             hide(); // delayed hide
     }
 }
 
 void ProgressDialog::push()
 {
     ProgressLevelData pld;
     if(!m_progressStack.empty())
     {
         pld.m_dRangeMax = m_progressStack.back().m_dSubRangeMax;
         pld.m_dRangeMin = m_progressStack.back().m_dSubRangeMin;
     }
     else
     {
         m_bWasCancelled = false;
         m_t1.restart();
         m_t2.restart();
         if(!m_bStayHidden)
             show();
     }
 
     m_progressStack.push_back(pld);
 }
 
 void ProgressDialog::pop(bool bRedrawUpdate)
 {
     if(!m_progressStack.empty())
     {
         m_progressStack.pop_back();
         if(m_progressStack.empty())
         {
             hide();
         }
         else
             recalc(bRedrawUpdate);
     }
 }
 
 void ProgressDialog::setInformation(const QString& info, int current, bool bRedrawUpdate)
 {
     if(m_progressStack.empty())
         return;
     ProgressLevelData& pld = m_progressStack.back();
     pld.m_current = current;
     int level = m_progressStack.size();
     if(level == 1)
     {
         m_pInformation->setText(info);
         m_pSubInformation->setText("");
         if(m_pStatusBar && m_bStayHidden)
             m_pStatusBar->showMessage(info);
     }
     else if(level == 2)
     {
         m_pSubInformation->setText(info);
     }
     recalc(bRedrawUpdate);
 }
 
 void ProgressDialog::setInformation(const QString& info, bool bRedrawUpdate)
 {
     if(m_progressStack.empty())
         return;
     //ProgressLevelData& pld = m_progressStack.back();
     int level = m_progressStack.size();
     if(level == 1)
     {
         m_pInformation->setText(info);
         m_pSubInformation->setText("");
         if(m_pStatusBar && m_bStayHidden)
             m_pStatusBar->showMessage(info);
     }
     else if(level == 2)
     {
         m_pSubInformation->setText(info);
     }
     recalc(bRedrawUpdate);
 }
 
 void ProgressDialog::setMaxNofSteps(const qint64 maxNofSteps)
 {
     if(m_progressStack.empty())
         return;
     ProgressLevelData& pld = m_progressStack.back();
     pld.m_maxNofSteps = maxNofSteps;
     pld.m_current = 0;
 }
 
 void ProgressDialog::addNofSteps(const qint64 nofSteps)
 {
     if(m_progressStack.empty())
         return;
     ProgressLevelData& pld = m_progressStack.back();
     pld.m_maxNofSteps.fetchAndAddRelaxed(nofSteps);
 }
 
 void ProgressDialog::step(bool bRedrawUpdate)
 {
     if(m_progressStack.empty())
         return;
     ProgressLevelData& pld = m_progressStack.back();
     pld.m_current.fetchAndAddRelaxed(1);
     recalc(bRedrawUpdate);
 }
 
 void ProgressDialog::setCurrent(qint64 subCurrent, bool bRedrawUpdate)
 {
     if(m_progressStack.empty())
         return;
     ProgressLevelData& pld = m_progressStack.back();
     pld.m_current = subCurrent;
     recalc(bRedrawUpdate);
 }
 
 // The progressbar goes from 0 to 1 usually.
 // By supplying a subrange transformation the subCurrent-values
 // 0 to 1 will be transformed to dMin to dMax instead.
 // Requirement: 0 < dMin < dMax < 1
 void ProgressDialog::setRangeTransformation(double dMin, double dMax)
 {
     if(m_progressStack.empty())
         return;
     ProgressLevelData& pld = m_progressStack.back();
     pld.m_dRangeMin = dMin;
     pld.m_dRangeMax = dMax;
     pld.m_current = 0;
 }
 
 void ProgressDialog::setSubRangeTransformation(double dMin, double dMax)
 {
     if(m_progressStack.empty())
         return;
     ProgressLevelData& pld = m_progressStack.back();
     pld.m_dSubRangeMin = dMin;
     pld.m_dSubRangeMax = dMax;
 }
 
 void qt_enter_modal(QWidget*);
 void qt_leave_modal(QWidget*);
 
 void ProgressDialog::enterEventLoop(KJob* pJob, const QString& jobInfo)
 {
     m_pJob = pJob;
     m_currentJobInfo = jobInfo;
     m_pSlowJobInfo->setText(m_currentJobInfo);
     if(m_progressDelayTimer)
         killTimer(m_progressDelayTimer);
     m_progressDelayTimer = startTimer(3000); /* 3 s delay */
 
-    // immediately show the progess dialog for KIO jobs, because some KIO jobs require password authentication,
+    // immediately show the progress dialog for KIO jobs, because some KIO jobs require password authentication,
     // but if the progress dialog pops up at a later moment, this might cover the login dialog and hide it from the user.
     if(m_pJob && !m_bStayHidden)
         show();
 
     // instead of using exec() the eventloop is entered and exited often without hiding/showing the window.
     //qt_enter_modal(this);
     QEventLoop* pEventLoop = new QEventLoop(this);
     m_eventLoopStack.push_back(pEventLoop);
     pEventLoop->exec(); // this function only returns after ProgressDialog::exitEventLoop() is called.
     delete pEventLoop;
     m_eventLoopStack.pop_back();
     //qt_leave_modal(this);
 }
 
 void ProgressDialog::exitEventLoop()
 {
     if(m_progressDelayTimer)
         killTimer(m_progressDelayTimer);
     m_progressDelayTimer = 0;
     m_pJob = nullptr;
     if(!m_eventLoopStack.empty())
         m_eventLoopStack.back()->exit();
 }
 
 void ProgressDialog::recalc(bool bUpdate)
 {
     if(!m_bWasCancelled)
     {
         if(QThread::currentThread() == m_pGuiThread)
         {
             if(m_progressDelayTimer)
                 killTimer(m_progressDelayTimer);
             m_progressDelayTimer = 0;
             if(!m_bStayHidden)
                 m_progressDelayTimer = startTimer(3000); /* 3 s delay */
 
             int level = m_progressStack.size();
             if((bUpdate && level == 1) || m_t1.elapsed() > 200)
             {
                 if(m_progressStack.empty())
                 {
                     m_pProgressBar->setValue(0);
                     m_pSubProgressBar->setValue(0);
                 }
                 else
                 {
                     QList<ProgressLevelData>::iterator i = m_progressStack.begin();
                     int value = int(1000.0 * (getAtomic(i->m_current) * (i->m_dRangeMax - i->m_dRangeMin) / getAtomic(i->m_maxNofSteps) + i->m_dRangeMin));
                     m_pProgressBar->setValue(value);
                     if(m_bStayHidden && m_pStatusProgressBar)
                         m_pStatusProgressBar->setValue(value);
 
                     ++i;
                     if(i != m_progressStack.end())
                         m_pSubProgressBar->setValue(int(1000.0 * (getAtomic(i->m_current) * (i->m_dRangeMax - i->m_dRangeMin) / getAtomic(i->m_maxNofSteps) + i->m_dRangeMin)));
                     else
                         m_pSubProgressBar->setValue(int(1000.0 * m_progressStack.front().m_dSubRangeMin));
                 }
 
                 if(!m_bStayHidden && !isVisible())
                     show();
                 qApp->processEvents();
                 m_t1.restart();
             }
         }
         else
         {
             QMetaObject::invokeMethod(this, "recalc", Qt::QueuedConnection, Q_ARG(bool, bUpdate));
         }
     }
 }
 
 #include <QTimer>
 void ProgressDialog::show()
 {
     if(m_progressDelayTimer)
         killTimer(m_progressDelayTimer);
     if(m_delayedHideTimer)
         killTimer(m_delayedHideTimer);
     m_progressDelayTimer = 0;
     m_delayedHideTimer = 0;
     if(!isVisible() && (parentWidget() == nullptr || parentWidget()->isVisible()))
     {
         QDialog::show();
     }
 }
 
 void ProgressDialog::hide()
 {
     if(m_progressDelayTimer)
         killTimer(m_progressDelayTimer);
     m_progressDelayTimer = 0;
     // Calling QDialog::hide() directly doesn't always work. (?)
     if(m_delayedHideTimer)
         killTimer(m_delayedHideTimer);
     m_delayedHideTimer = startTimer(100);
 }
 
 void ProgressDialog::delayedHide()
 {
     if(m_pJob != nullptr)
     {
         m_pJob->kill(KJob::Quietly);
         m_pJob = nullptr;
     }
     QDialog::hide();
     m_pInformation->setText("");
 
     //m_progressStack.clear();
 
     m_pProgressBar->setValue(0);
     m_pSubProgressBar->setValue(0);
     m_pSubInformation->setText("");
     m_pSlowJobInfo->setText("");
 }
 
 void ProgressDialog::hideStatusBarWidget()
 {
     if(m_delayedHideStatusBarWidgetTimer)
         killTimer(m_delayedHideStatusBarWidgetTimer);
     m_delayedHideStatusBarWidgetTimer = startTimer(100);
 }
 
 void ProgressDialog::delayedHideStatusBarWidget()
 {
     if(m_progressDelayTimer)
         killTimer(m_progressDelayTimer);
     m_progressDelayTimer = 0;
     if(m_pStatusBarWidget)
     {
         m_pStatusBarWidget->hide();
         m_pStatusProgressBar->setValue(0);
         m_pStatusBar->clearMessage();
     }
 }
 
 void ProgressDialog::reject()
 {
     cancel(eUserAbort);
     QDialog::reject();
 }
 
 void ProgressDialog::slotAbort()
 {
     reject();
 }
 
 bool ProgressDialog::wasCancelled()
 {
     if(QThread::currentThread() == m_pGuiThread)
     {
         if(m_t2.elapsed() > 100)
         {
             qApp->processEvents();
             m_t2.restart();
         }
     }
     return m_bWasCancelled;
 }
 
 void ProgressDialog::clearCancelState()
 {
     m_bWasCancelled = false;
 }
 
 void ProgressDialog::cancel(e_CancelReason eCancelReason)
 {
     if(!m_bWasCancelled)
     {
         m_bWasCancelled = true;
         m_eCancelReason = eCancelReason;
     }
 }
 
 ProgressDialog::e_CancelReason ProgressDialog::cancelReason()
 {
     return m_eCancelReason;
 }
 
 void ProgressDialog::timerEvent(QTimerEvent* te)
 {
     if(te->timerId() == m_progressDelayTimer)
     {
         if(!isVisible() && !m_bStayHidden)
         {
             show();
         }
         m_pSlowJobInfo->setText(m_currentJobInfo);
     }
     else if(te->timerId() == m_delayedHideTimer)
     {
         killTimer(m_delayedHideTimer);
         m_delayedHideTimer = 0;
         delayedHide();
     }
     else if(te->timerId() == m_delayedHideStatusBarWidgetTimer)
     {
         killTimer(m_delayedHideStatusBarWidgetTimer);
         m_delayedHideStatusBarWidgetTimer = 0;
         delayedHideStatusBarWidget();
     }
 }
 
 ProgressProxy::ProgressProxy()
 {
     g_pProgressDialog->push();
 }
 
 ProgressProxy::~ProgressProxy()
 {
     g_pProgressDialog->pop(false);
 }
 
 void ProgressProxy::enterEventLoop(KJob* pJob, const QString& jobInfo)
 {
     g_pProgressDialog->enterEventLoop(pJob, jobInfo);
 }
 
 void ProgressProxy::exitEventLoop()
 {
     g_pProgressDialog->exitEventLoop();
 }
 
 QDialog* ProgressProxy::getDialog()
 {
     return g_pProgressDialog;
 }
 
 void ProgressProxy::setInformation(const QString& info, bool bRedrawUpdate)
 {
     g_pProgressDialog->setInformation(info, bRedrawUpdate);
 }
 
 void ProgressProxy::setInformation(const QString& info, int current, bool bRedrawUpdate)
 {
     g_pProgressDialog->setInformation(info, current, bRedrawUpdate);
 }
 
 void ProgressProxy::setCurrent(qint64 current, bool bRedrawUpdate)
 {
     g_pProgressDialog->setCurrent(current, bRedrawUpdate);
 }
 
 void ProgressProxy::step(bool bRedrawUpdate)
 {
     g_pProgressDialog->step(bRedrawUpdate);
 }
 
 void ProgressProxy::setMaxNofSteps(const qint64 maxNofSteps)
 {
     g_pProgressDialog->setMaxNofSteps(maxNofSteps);
 }
 
 void ProgressProxy::addNofSteps(const qint64 nofSteps)
 {
     g_pProgressDialog->addNofSteps(nofSteps);
 }
 
 bool ProgressProxy::wasCancelled()
 {
     return g_pProgressDialog->wasCancelled();
 }
 
 void ProgressProxy::setRangeTransformation(double dMin, double dMax)
 {
     g_pProgressDialog->setRangeTransformation(dMin, dMax);
 }
 
 void ProgressProxy::setSubRangeTransformation(double dMin, double dMax)
 {
     g_pProgressDialog->setSubRangeTransformation(dMin, dMax);
 }
 
 void ProgressProxy::recalc()
 {
     g_pProgressDialog->recalc(true);
 }
diff --git a/src/selection.h b/src/selection.h
index bcce88a..086b119 100644
--- a/src/selection.h
+++ b/src/selection.h
@@ -1,78 +1,78 @@
 /***************************************************************************
  *   Copyright (C) 2003-2011 by Joachim Eibl                               *
  *   joachim.eibl at gmx.de                                                *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  ***************************************************************************/
 
 #include "gnudiff_diff.h"
 #include "common.h"
 
 class Selection
 {
 public:
   Selection(){}
 private:
   const LineRef invalidRef = -1;
   LineRef firstLine = invalidRef;
   LineRef lastLine = invalidRef;
 
   int firstPos = -1;
   int lastPos = -1;
   
   LineRef oldFirstLine = invalidRef;
   LineRef oldLastLine = invalidRef;
 public:
 //private:
   bool bSelectionContainsData = false;
 public:
   inline LineRef getFirstLine() { return firstLine; };
   inline LineRef getLastLine() { return lastLine; };
 
   inline int getFirstPos() { return firstPos; };
   inline int getLastPos() { return lastPos; };
 
   inline bool isValidFirstLine() { return firstLine != invalidRef; }
   inline void clearOldSelection() { oldLastLine = invalidRef, oldFirstLine = invalidRef; };
   
   inline LineRef getOldLastLine() { return oldLastLine; };
   inline LineRef getOldFirstLine() { return oldFirstLine; };
   inline bool selectionContainsData(void) { return bSelectionContainsData; };
   bool isEmpty() { return firstLine == invalidRef || (firstLine == lastLine && firstPos == lastPos) || bSelectionContainsData == false; }
   void reset()
   {
       oldLastLine = lastLine;
       oldFirstLine = firstLine;
       firstLine = invalidRef;
       lastLine = invalidRef;
       bSelectionContainsData = false;
    }
    void start( LineRef l, int p ) { firstLine = l; firstPos = p; }
    void end( LineRef l, int p )  {
       if ( oldLastLine == invalidRef )
          oldLastLine = lastLine;
       lastLine  = l;
       lastPos  = p;
       //bSelectionContainsData = (firstLine == lastLine && firstPos == lastPos);
    }
    bool within( LineRef l, LineRef p );
 
    bool lineWithin( LineRef l );
    int firstPosInLine(LineRef l);
    int lastPosInLine(LineRef l);
    LineRef beginLine(){ 
       if (firstLine<0 && lastLine<0) return invalidRef;
       return max2((LineRef)0,min2(firstLine,lastLine)); 
    }
    LineRef endLine(){ 
       if (firstLine<0 && lastLine<0) return invalidRef;
       return max2(firstLine,lastLine); 
    }
    int beginPos() { return firstLine==lastLine ? min2(firstPos,lastPos) :
                            firstLine<lastLine ? (firstLine<0?0:firstPos) : (lastLine<0?0:lastPos);  }
    int endPos()   { return firstLine==lastLine ? max2(firstPos,lastPos) :
                            firstLine<lastLine ? lastPos : firstPos;      }
-};
\ No newline at end of file
+};