diff --git a/src/diff.h b/src/diff.h
index 0f529c7..8494561 100644
--- a/src/diff.h
+++ b/src/diff.h
@@ -1,472 +1,492 @@
 /***************************************************************************
                           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 <assert.h>
 #include "common.h"
 #include "fileaccess.h"
 #include "options.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
 {
    int nofEquals;
 
    int diff1;
    int diff2;
 
    Diff(int eq, int d1, int 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;*/ 
                bContainsPureComment=false; }
    int width(int tabSize) const;  // Calcs width considering tabs.
    //int occurances;
    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;
    int m_sizeA;
    int m_sizeB;
    int m_sizeC;
    const Diff3LineList* m_pDiff3LineList;
    const Diff3LineVector* m_pDiff3LineVector;
    void init( Diff3LineList* d3ll, const Diff3LineVector* d3lv,
       const LineData* pldA, int sizeA, const LineData* pldB, int sizeB, const LineData* pldC, int sizeC );
 };
 
 struct Diff3Line
 {
    int lineA;
    int lineB;
    int 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
    {
       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();
    }
    int 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; }
    int lineA1;
    int lineA2;
    int lineB1;
    int lineB2;
    int lineC1;
    int lineC2;
    int& firstLine( int winIdx )
    {
       return winIdx==1 ? lineA1 : (winIdx==2 ? lineB1 : lineC1 );
    }
    int& lastLine( int winIdx )
    {
       return winIdx==1 ? lineA2 : (winIdx==2 ? lineB2 : lineC2 );
    }
    bool isLineInRange( int 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 );
 
    int getSizeLines() const;
    int 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;
       int m_size;
       int 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 );
       void preprocess(bool bPreserveCR, QTextCodec* pEncoding );
       void reset();
       void removeComments();
       void copyBufFrom( const FileData& src );
    };
    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 );
 
 
 
 class Selection
 {
 public:
   Selection(){}
+private:
   int firstLine = -1;
-  int firstPos = -1;
   int lastLine = -1;
+
+  int firstPos = -1;
   int lastPos = -1;
-  int oldLastLine = -1;
+  
   int oldFirstLine = -1;
+  int oldLastLine = -1;
+public:
+//private:
   bool bSelectionContainsData = false;
+public:
+  inline int getFirstLine() { return firstLine; };
+  inline int getLastLine() { return lastLine; };
+
+  inline int getFirstPos() { return firstPos; };
+  inline int getLastPos() { return lastPos; };
+
+  inline void invalidate() { firstLine = -1; };
+  inline bool isValidFirstLine() { return firstLine != -1; }
+  inline void clearOldSelection() { oldLastLine = -1, oldFirstLine = -1; };
+  
+  inline int getOldLastLine() { return oldLastLine; };
+  inline int getOldFirstLine() { return oldFirstLine; };
+  inline bool selectionContainsData(void) { return bSelectionContainsData; };
   bool isEmpty() { return firstLine == -1 || (firstLine == lastLine && firstPos == lastPos) || bSelectionContainsData == false; }
   void reset()
   {
-      oldFirstLine = firstLine;
       oldLastLine = lastLine;
+      oldFirstLine = firstLine;
       firstLine = -1;
       lastLine = -1;
       bSelectionContainsData = false;
    }
    void start( int l, int p ) { firstLine = l; firstPos = p; }
    void end( int l, int p )  {
       if ( oldLastLine == -1 )
          oldLastLine = lastLine;
       lastLine  = l;
       lastPos  = p;
+      //bSelectionContainsData = (firstLine == lastLine && firstPos == lastPos);
    }
    bool within( int l, int p );
 
    bool lineWithin( int l );
    int firstPosInLine(int l);
    int lastPosInLine(int l);
    int beginLine(){ 
       if (firstLine<0 && lastLine<0) return -1;
       return max2(0,min2(firstLine,lastLine)); 
    }
    int endLine(){ 
       if (firstLine<0 && lastLine<0) return -1;
       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;      }
 };
 
 
 // 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, int size1, const LineData* p2, int 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/difftextwindow.cpp b/src/difftextwindow.cpp
index 3f35778..6c3ea75 100644
--- a/src/difftextwindow.cpp
+++ b/src/difftextwindow.cpp
@@ -1,2175 +1,2169 @@
 /***************************************************************************
                           difftextwindow.cpp  -  description
                              -------------------
     begin                : Mon Apr 8 2002
     copyright            : (C) 2002-2007 by Joachim Eibl
     email                : joachim.eibl at gmx.de
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #include "difftextwindow.h"
 #include "kdiff3.h"
 #include "merger.h"
 #include "options.h"
 
 #include <QApplication>
 #include <QDir>
 #include <QDragEnterEvent>
 #include <QFileDialog>
 #include <QLabel>
 #include <QLayout>
 #include <QLineEdit>
 #include <QMenu>
 #include <QMimeData>
 #include <QPushButton>
 #include <QRunnable>
 #include <QStatusBar>
 #include <QTextCodec>
 #include <QTextLayout>
 #include <QThreadPool>
 #include <QToolTip>
 #include <QUrl>
 #include <qnamespace.h>
 
 #include <KLocalizedString>
 
 #include <assert.h>
 #include <cmath>
 #include <cstdlib>
 
 static QAtomicInt s_runnableCount = 0;
 
 class DiffTextWindowData
 {
   public:
     explicit DiffTextWindowData(DiffTextWindow* p)
     {
         m_pDiffTextWindow = p;
         m_bPaintingAllowed = false;
         m_pLineData = nullptr;
         m_size = 0;
         m_bWordWrap = false;
         m_delayedDrawTimer = 0;
         m_pDiff3LineVector = nullptr;
         m_pManualDiffHelpList = nullptr;
         m_pOptions = nullptr;
         m_fastSelectorLine1 = 0;
         m_fastSelectorNofLines = 0;
         m_bTriple = 0;
         m_winIdx = 0;
         m_firstLine = 0;
         m_oldFirstLine = 0;
         m_horizScrollOffset = 0;
         m_lineNumberWidth = 0;
         m_maxTextWidth = -1;
         m_pStatusBar = nullptr;
         m_scrollDeltaX = 0;
         m_scrollDeltaY = 0;
         m_bMyUpdate = false;
         m_bSelectionInProgress = false;
         m_pTextCodec = nullptr;
 #if defined(_WIN32) || defined(Q_OS_OS2)
         m_eLineEndStyle = eLineEndStyleDos;
 #else
         m_eLineEndStyle = eLineEndStyleUnix;
 #endif
     }
     DiffTextWindow* m_pDiffTextWindow;
     DiffTextWindowFrame* m_pDiffTextWindowFrame = nullptr;
     QTextCodec* m_pTextCodec;
     e_LineEndStyle m_eLineEndStyle;
 
     bool m_bPaintingAllowed;
     const LineData* m_pLineData;
     int m_size;
     QString m_filename;
     bool m_bWordWrap;
     int m_delayedDrawTimer;
 
     const Diff3LineVector* m_pDiff3LineVector;
     Diff3WrapLineVector m_diff3WrapLineVector;
     const ManualDiffHelpList* m_pManualDiffHelpList;
 
     class WrapLineCacheData
     {
       public:
         WrapLineCacheData() : m_d3LineIdx(0), m_textStart(0), m_textLength(0) {}
         WrapLineCacheData(int d3LineIdx, int textStart, int textLength)
             : m_d3LineIdx(d3LineIdx), m_textStart(textStart), m_textLength(textLength) {}
         int m_d3LineIdx;
         int m_textStart;
         int m_textLength;
     };
     QList<QVector<WrapLineCacheData>> m_wrapLineCacheList;
 
     Options* m_pOptions;
     QColor m_cThis;
     QColor m_cDiff1;
     QColor m_cDiff2;
     QColor m_cDiffBoth;
 
     int m_fastSelectorLine1;
     int m_fastSelectorNofLines;
 
     bool m_bTriple;
     int m_winIdx;
     int m_firstLine;
     int m_oldFirstLine;
     int m_horizScrollOffset;
     int m_lineNumberWidth;
     QAtomicInt m_maxTextWidth;
 
     void getLineInfo(
         const Diff3Line& d,
         int& lineIdx,
         DiffList*& pFineDiff1, DiffList*& pFineDiff2, // return values
         int& changed, int& changed2);
 
     QString getString(int d3lIdx);
     QString getLineString(int line);
 
     void writeLine(
         MyPainter& p, const LineData* pld,
         const DiffList* pLineDiff1, const DiffList* pLineDiff2, int line,
         int whatChanged, int whatChanged2, int srcLineIdx,
         int wrapLineOffset, int wrapLineLength, bool bWrapLine, const QRect& invalidRect, int deviceWidth);
 
     void draw(MyPainter& p, const QRect& invalidRect, int deviceWidth, int beginLine, int endLine);
 
     QStatusBar* m_pStatusBar;
 
     Selection m_selection;
 
     int m_scrollDeltaX;
     int m_scrollDeltaY;
 
     bool m_bMyUpdate;
     void myUpdate(int afterMilliSecs);
 
     int leftInfoWidth() { return 4 + m_lineNumberWidth; } // Nr of information columns on left side
     int convertLineOnScreenToLineInSource(int lineOnScreen, e_CoordType coordType, bool bFirstLine);
 
     bool m_bSelectionInProgress;
     QPoint m_lastKnownMousePos;
     void prepareTextLayout(QTextLayout& textLayout, bool bFirstLine, int visibleTextWidth = -1);
 };
 
 DiffTextWindow::DiffTextWindow(
     DiffTextWindowFrame* pParent,
     QStatusBar* pStatusBar,
     Options* pOptions,
     int winIdx)
     : QWidget(pParent)
 {
     setObjectName(QString("DiffTextWindow%1").arg(winIdx));
     setAttribute(Qt::WA_OpaquePaintEvent);
     //setAttribute( Qt::WA_PaintOnScreen );
 
     d = new DiffTextWindowData(this);
     d->m_pDiffTextWindowFrame = pParent;
     setFocusPolicy(Qt::ClickFocus);
     setAcceptDrops(true);
 
     d->m_pOptions = pOptions;
     init(nullptr, nullptr, d->m_eLineEndStyle, nullptr, 0, nullptr, nullptr, false);
 
     setMinimumSize(QSize(20, 20));
 
     d->m_pStatusBar = pStatusBar;
     d->m_bPaintingAllowed = true;
     d->m_bWordWrap = false;
     d->m_winIdx = winIdx;
 
     setFont(d->m_pOptions->m_font);
 }
 
 DiffTextWindow::~DiffTextWindow()
 {
     delete d;
 }
 
 void DiffTextWindow::init(
     const QString& filename,
     QTextCodec* pTextCodec,
     e_LineEndStyle eLineEndStyle,
     const LineData* pLineData,
     int size,
     const Diff3LineVector* pDiff3LineVector,
     const ManualDiffHelpList* pManualDiffHelpList,
     bool bTriple)
 {
     d->m_filename = filename;
     d->m_pLineData = pLineData;
     d->m_size = size;
     d->m_pDiff3LineVector = pDiff3LineVector;
     d->m_diff3WrapLineVector.clear();
     d->m_pManualDiffHelpList = pManualDiffHelpList;
 
     d->m_firstLine = 0;
     d->m_oldFirstLine = -1;
     d->m_horizScrollOffset = 0;
     d->m_bTriple = bTriple;
     d->m_scrollDeltaX = 0;
     d->m_scrollDeltaY = 0;
     d->m_bMyUpdate = false;
     d->m_fastSelectorLine1 = 0;
     d->m_fastSelectorNofLines = 0;
     d->m_lineNumberWidth = 0;
     d->m_maxTextWidth = -1;
-    d->m_selection.reset();
-    d->m_selection.oldFirstLine = -1; // reset is not enough here.
-    d->m_selection.oldLastLine = -1;
-    d->m_selection.lastLine = -1;
 
     d->m_pTextCodec = pTextCodec;
     d->m_eLineEndStyle = eLineEndStyle;
 
     update();
     d->m_pDiffTextWindowFrame->init();
 }
 
 void DiffTextWindow::reset()
 {
     d->m_pLineData = nullptr;
     d->m_size = 0;
     d->m_pDiff3LineVector = nullptr;
     d->m_filename = "";
     d->m_diff3WrapLineVector.clear();
 }
 
 void DiffTextWindow::setPaintingAllowed(bool bAllowPainting)
 {
     if(d->m_bPaintingAllowed != bAllowPainting)
     {
         d->m_bPaintingAllowed = bAllowPainting;
         if(d->m_bPaintingAllowed)
             update();
         else
             reset();
     }
 }
 
 void DiffTextWindow::dragEnterEvent(QDragEnterEvent* e)
 {
     e->setAccepted(e->mimeData()->hasUrls() || e->mimeData()->hasText());
     // Note that the corresponding drop is handled in KDiff3App::eventFilter().
 }
 
 void DiffTextWindow::setFirstLine(int firstLine)
 {
     int fontHeight = fontMetrics().lineSpacing();
 
     int newFirstLine = max2(0, firstLine);
 
     int deltaY = fontHeight * (d->m_firstLine - newFirstLine);
 
     d->m_firstLine = newFirstLine;
 
-    if(d->m_bSelectionInProgress && d->m_selection.firstLine != -1)
+    if(d->m_bSelectionInProgress && d->m_selection.isValidFirstLine())
     {
         int line, pos;
         convertToLinePos(d->m_lastKnownMousePos.x(), d->m_lastKnownMousePos.y(), line, pos);
         d->m_selection.end(line, pos);
         update();
     }
     else
     {
         QWidget::scroll(0, deltaY);
     }
     d->m_pDiffTextWindowFrame->setFirstLine(d->m_firstLine);
 }
 
 int DiffTextWindow::getFirstLine()
 {
     return d->m_firstLine;
 }
 
 void DiffTextWindow::setHorizScrollOffset(int horizScrollOffset)
 {
     int fontWidth = fontMetrics().width('0');
     int xOffset = d->leftInfoWidth() * fontWidth;
 
     int deltaX = d->m_horizScrollOffset - qMax(0, horizScrollOffset);
 
     d->m_horizScrollOffset = qMax(0, horizScrollOffset);
 
     QRect r(xOffset, 0, width() - xOffset, height());
 
     if(d->m_pOptions->m_bRightToLeftLanguage)
     {
         deltaX = -deltaX;
         r = QRect(width() - xOffset - 2, 0, -(width() - xOffset), height()).normalized();
     }
 
-    if(d->m_bSelectionInProgress && d->m_selection.firstLine != -1)
+    if(d->m_bSelectionInProgress && d->m_selection.isValidFirstLine())
     {
         int line, pos;
         convertToLinePos(d->m_lastKnownMousePos.x(), d->m_lastKnownMousePos.y(), line, pos);
         d->m_selection.end(line, pos);
         update();
     }
     else
     {
         QWidget::scroll(deltaX, 0, r);
     }
 }
 
 int DiffTextWindow::getMaxTextWidth()
 {
     if(d->m_bWordWrap)
     {
         return getVisibleTextAreaWidth();
     }
     else if(getAtomic(d->m_maxTextWidth) < 0)
     {
         d->m_maxTextWidth = 0;
         QTextLayout textLayout(QString(), font(), this);
         for(int i = 0; i < d->m_size; ++i)
         {
             textLayout.clearLayout();
             textLayout.setText(d->getString(i));
             d->prepareTextLayout(textLayout, true);
             if(textLayout.maximumWidth() > getAtomic(d->m_maxTextWidth))
                 d->m_maxTextWidth = textLayout.maximumWidth();
         }
     }
     return getAtomic(d->m_maxTextWidth);
 }
 
 int DiffTextWindow::getNofLines()
 {
     return d->m_bWordWrap ? d->m_diff3WrapLineVector.size() : d->m_pDiff3LineVector->size();
 }
 
 int DiffTextWindow::convertLineToDiff3LineIdx(int line)
 {
     if(line >= 0 && d->m_bWordWrap && d->m_diff3WrapLineVector.size() > 0)
         return d->m_diff3WrapLineVector[min2(line, (int)d->m_diff3WrapLineVector.size() - 1)].diff3LineIndex;
     else
         return line;
 }
 
 int DiffTextWindow::convertDiff3LineIdxToLine(int d3lIdx)
 {
     if(d->m_bWordWrap && d->m_pDiff3LineVector != nullptr && d->m_pDiff3LineVector->size() > 0)
         return (*d->m_pDiff3LineVector)[min2(d3lIdx, (int)d->m_pDiff3LineVector->size() - 1)]->sumLinesNeededForDisplay;
     else
         return d3lIdx;
 }
 
 /** Returns a line number where the linerange [line, line+nofLines] can
     be displayed best. If it fits into the currently visible range then
     the returned value is the current firstLine.
 */
 int getBestFirstLine(int line, int nofLines, int firstLine, int visibleLines)
 {
     int newFirstLine = firstLine;
     if(line < firstLine || line + nofLines + 2 > firstLine + visibleLines)
     {
         if(nofLines > visibleLines || nofLines <= (2 * visibleLines / 3 - 1))
             newFirstLine = line - visibleLines / 3;
         else
             newFirstLine = line - (visibleLines - nofLines);
     }
 
     return newFirstLine;
 }
 
 void DiffTextWindow::setFastSelectorRange(int line1, int nofLines)
 {
     d->m_fastSelectorLine1 = line1;
     d->m_fastSelectorNofLines = nofLines;
     if(isVisible())
     {
         int newFirstLine = getBestFirstLine(
             convertDiff3LineIdxToLine(d->m_fastSelectorLine1),
             convertDiff3LineIdxToLine(d->m_fastSelectorLine1 + d->m_fastSelectorNofLines) - convertDiff3LineIdxToLine(d->m_fastSelectorLine1),
             d->m_firstLine,
             getNofVisibleLines());
         if(newFirstLine != d->m_firstLine)
         {
             scroll(0, newFirstLine - d->m_firstLine);
         }
 
         update();
     }
 }
 
 void DiffTextWindow::showStatusLine(int line)
 {
     int d3lIdx = convertLineToDiff3LineIdx(line);
     if(d->m_pDiff3LineVector != nullptr && d3lIdx >= 0 && d3lIdx < (int)d->m_pDiff3LineVector->size())
     {
         const Diff3Line* pD3l = (*d->m_pDiff3LineVector)[d3lIdx];
         if(pD3l != nullptr)
         {
             int l = pD3l->getLineInFile(d->m_winIdx);
 
             QString s = i18n("File") + " " + d->m_filename;
             if(l != -1)
                 s += ": " + i18n("Line") + " " + QString::number(l + 1);
             else
                 s += ": " + i18n("Line not available");
             if(d->m_pStatusBar != nullptr) d->m_pStatusBar->showMessage(s);
 
             emit lineClicked(d->m_winIdx, l);
         }
     }
 }
 
 void DiffTextWindow::focusInEvent(QFocusEvent* e)
 {
     emit gotFocus();
     QWidget::focusInEvent(e);
 }
 
 void DiffTextWindow::mousePressEvent(QMouseEvent* e)
 {
     if(e->button() == Qt::LeftButton)
     {
         int line;
         int pos;
         convertToLinePos(e->x(), e->y(), line, pos);
 
         int fontWidth = fontMetrics().width('0');
         int xOffset = d->leftInfoWidth() * fontWidth;
 
         if((!d->m_pOptions->m_bRightToLeftLanguage && e->x() < xOffset) || (d->m_pOptions->m_bRightToLeftLanguage && e->x() > width() - xOffset))
         {
             emit setFastSelectorLine(convertLineToDiff3LineIdx(line));
-            d->m_selection.firstLine = -1; // Disable current d->m_selection
+            d->m_selection.invalidate(); // Disable current d->m_selection
         }
         else
         { // Selection
             resetSelection();
             d->m_selection.start(line, pos);
             d->m_selection.end(line, pos);
             d->m_bSelectionInProgress = true;
             d->m_lastKnownMousePos = e->pos();
 
             showStatusLine(line);
         }
     }
 }
 
 bool isCTokenChar(QChar c)
 {
     return (c == '_') ||
            (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') ||
            (c >= '0' && c <= '9');
 }
 
 /// Calculate where a token starts and ends, given the x-position on screen.
 void calcTokenPos(const QString& s, int posOnScreen, int& pos1, int& pos2, int tabSize)
 {
     // Cursor conversions that consider g_tabSize
     int pos = convertToPosInText(s, max2(0, posOnScreen), tabSize);
     if(pos >= (int)s.length())
     {
         pos1 = s.length();
         pos2 = s.length();
         return;
     }
 
     pos1 = pos;
     pos2 = pos + 1;
 
     if(isCTokenChar(s[pos1]))
     {
         while(pos1 >= 0 && isCTokenChar(s[pos1]))
             --pos1;
         ++pos1;
 
         while(pos2 < (int)s.length() && isCTokenChar(s[pos2]))
             ++pos2;
     }
 }
 
 void DiffTextWindow::mouseDoubleClickEvent(QMouseEvent* e)
 {
     d->m_bSelectionInProgress = false;
     d->m_lastKnownMousePos = e->pos();
     if(e->button() == Qt::LeftButton)
     {
         int line;
         int pos;
         convertToLinePos(e->x(), e->y(), line, pos);
 
         // Get the string data of the current line
         QString s;
         if(d->m_bWordWrap)
         {
             if(line < 0 || line >= (int)d->m_diff3WrapLineVector.size())
                 return;
             const Diff3WrapLine& d3wl = d->m_diff3WrapLineVector[line];
             s = d->getString(d3wl.diff3LineIndex).mid(d3wl.wrapLineOffset, d3wl.wrapLineLength);
         }
         else
         {
             if(line < 0 || line >= (int)d->m_pDiff3LineVector->size())
                 return;
             s = d->getString(line);
         }
 
         if(!s.isEmpty())
         {
             int pos1, pos2;
             calcTokenPos(s, pos, pos1, pos2, d->m_pOptions->m_tabSize);
 
             resetSelection();
             d->m_selection.start(line, convertToPosOnScreen(s, pos1, d->m_pOptions->m_tabSize));
             d->m_selection.end(line, convertToPosOnScreen(s, pos2, d->m_pOptions->m_tabSize));
             update();
             // emit d->m_selectionEnd() happens in the mouseReleaseEvent.
             showStatusLine(line);
         }
     }
 }
 
 void DiffTextWindow::mouseReleaseEvent(QMouseEvent* e)
 {
     d->m_bSelectionInProgress = false;
     d->m_lastKnownMousePos = e->pos();
     //if ( e->button() == LeftButton )
     {
         if(d->m_delayedDrawTimer)
             killTimer(d->m_delayedDrawTimer);
         d->m_delayedDrawTimer = 0;
-        if(d->m_selection.firstLine != -1)
+        if(d->m_selection.isValidFirstLine())
         {
             emit selectionEnd();
         }
     }
     d->m_scrollDeltaX = 0;
     d->m_scrollDeltaY = 0;
 }
 
 inline int sqr(int x) { return x * x; }
 
 void DiffTextWindow::mouseMoveEvent(QMouseEvent* e)
 {
     int line;
     int pos;
     convertToLinePos(e->x(), e->y(), line, pos);
     d->m_lastKnownMousePos = e->pos();
 
-    if(d->m_selection.firstLine != -1)
+    if(d->m_selection.isValidFirstLine())
     {
         d->m_selection.end(line, pos);
 
         showStatusLine(line);
 
         // Scroll because mouse moved out of the window
         const QFontMetrics& fm = fontMetrics();
         int fontWidth = fm.width('0');
         int deltaX = 0;
         int deltaY = 0;
         if(!d->m_pOptions->m_bRightToLeftLanguage)
         {
             if(e->x() < d->leftInfoWidth() * fontWidth) deltaX = -1 - abs(e->x() - d->leftInfoWidth() * fontWidth) / fontWidth;
             if(e->x() > width()) deltaX = +1 + abs(e->x() - width()) / fontWidth;
         }
         else
         {
             if(e->x() > width() - 1 - d->leftInfoWidth() * fontWidth) deltaX = +1 + abs(e->x() - (width() - 1 - d->leftInfoWidth() * fontWidth)) / fontWidth;
             if(e->x() < fontWidth) deltaX = -1 - abs(e->x() - fontWidth) / fontWidth;
         }
         if(e->y() < 0) deltaY = -1 - sqr(e->y()) / sqr(fm.lineSpacing());
         if(e->y() > height()) deltaY = +1 + sqr(e->y() - height()) / sqr(fm.lineSpacing());
         if((deltaX != 0 && d->m_scrollDeltaX != deltaX) || (deltaY != 0 && d->m_scrollDeltaY != deltaY))
         {
             d->m_scrollDeltaX = deltaX;
             d->m_scrollDeltaY = deltaY;
             emit scroll(deltaX, deltaY);
             if(d->m_delayedDrawTimer)
                 killTimer(d->m_delayedDrawTimer);
             d->m_delayedDrawTimer = startTimer(50);
         }
         else
         {
             d->m_scrollDeltaX = deltaX;
             d->m_scrollDeltaY = deltaY;
             d->myUpdate(0);
         }
     }
 }
 
 void DiffTextWindowData::myUpdate(int afterMilliSecs)
 {
     if(m_delayedDrawTimer)
         m_pDiffTextWindow->killTimer(m_delayedDrawTimer);
     m_bMyUpdate = true;
     m_delayedDrawTimer = m_pDiffTextWindow->startTimer(afterMilliSecs);
 }
 
 void DiffTextWindow::timerEvent(QTimerEvent*)
 {
     killTimer(d->m_delayedDrawTimer);
     d->m_delayedDrawTimer = 0;
 
     if(d->m_bMyUpdate)
     {
         int fontHeight = fontMetrics().lineSpacing();
 
-        if(d->m_selection.oldLastLine != -1)
+        if(d->m_selection.getOldLastLine() != -1)
         {
             int lastLine;
             int firstLine;
-            if(d->m_selection.oldFirstLine != -1)
+            if(d->m_selection.getOldFirstLine() != -1)
             {
-                firstLine = min3(d->m_selection.oldFirstLine, d->m_selection.lastLine, d->m_selection.oldLastLine);
-                lastLine = max3(d->m_selection.oldFirstLine, d->m_selection.lastLine, d->m_selection.oldLastLine);
+                firstLine = min3(d->m_selection.getOldFirstLine(), d->m_selection.getLastLine(), d->m_selection.getOldLastLine());
+                lastLine = max3(d->m_selection.getOldFirstLine(), d->m_selection.getLastLine(), d->m_selection.getOldLastLine());
             }
             else
             {
-                firstLine = min2(d->m_selection.lastLine, d->m_selection.oldLastLine);
-                lastLine = max2(d->m_selection.lastLine, d->m_selection.oldLastLine);
+                firstLine = min2(d->m_selection.getLastLine(), d->m_selection.getOldLastLine());
+                lastLine = max2(d->m_selection.getLastLine(), d->m_selection.getOldLastLine());
             }
             int y1 = (firstLine - d->m_firstLine) * fontHeight;
             int y2 = min2(height(), (lastLine - d->m_firstLine + 1) * fontHeight);
 
             if(y1 < height() && y2 > 0)
             {
                 QRect invalidRect = QRect(0, y1 - 1, width(), y2 - y1 + fontHeight); // Some characters in exotic exceed the regular bottom.
                 update(invalidRect);
             }
         }
 
         d->m_bMyUpdate = false;
     }
 
     if(d->m_scrollDeltaX != 0 || d->m_scrollDeltaY != 0)
     {
-        d->m_selection.end(d->m_selection.lastLine + d->m_scrollDeltaY, d->m_selection.lastPos + d->m_scrollDeltaX);
+        d->m_selection.end(d->m_selection.getLastLine() + d->m_scrollDeltaY, d->m_selection.getLastPos() + d->m_scrollDeltaX);
         emit scroll(d->m_scrollDeltaX, d->m_scrollDeltaY);
         killTimer(d->m_delayedDrawTimer);
         d->m_delayedDrawTimer = startTimer(50);
     }
 }
 
 void DiffTextWindow::resetSelection()
 {
     d->m_selection.reset();
     update();
 }
 
 void DiffTextWindow::convertToLinePos(int x, int y, int& line, int& pos)
 {
     const QFontMetrics& fm = fontMetrics();
     int fontHeight = fm.lineSpacing();
 
     int yOffset = -d->m_firstLine * fontHeight;
 
     line = (y - yOffset) / fontHeight;
     if(line >= 0 && (!d->m_pOptions->m_bWordWrap || line < d->m_diff3WrapLineVector.count()))
     {
         QString s = d->getLineString(line);
         QTextLayout textLayout(s, font(), this);
         d->prepareTextLayout(textLayout, !d->m_pOptions->m_bWordWrap || d->m_diff3WrapLineVector[line].wrapLineOffset == 0);
         pos = textLayout.lineAt(0).xToCursor(x - textLayout.position().x());
     }
     else
         pos = -1;
 }
 
 int Selection::firstPosInLine(int l)
 {
     assert(firstLine != -1);
 
     int l1 = firstLine;
     int l2 = lastLine;
     int p1 = firstPos;
     int p2 = lastPos;
     if(l1 > l2) {
         std::swap(l1, l2);
         std::swap(p1, p2);
     }
     if(l1 == l2 && p1 > p2) {
         std::swap(p1, p2);
     }
 
     if(l == l1)
         return p1;
     return 0;
 }
 
 int Selection::lastPosInLine(int l)
 {
     assert(firstLine != -1);
 
     int l1 = firstLine;
     int l2 = lastLine;
     int p1 = firstPos;
     int p2 = lastPos;
 
     if(l1 > l2) {
         std::swap(l1, l2);
         std::swap(p1, p2);
     }
     if(l1 == l2 && p1 > p2) {
         std::swap(p1, p2);
     }
 
     if(l == l2)
         return p2;
     return INT_MAX;
 }
 
 bool Selection::within(int l, int p)
 {
     if(firstLine == -1) return false;
     int l1 = firstLine;
     int l2 = lastLine;
     int p1 = firstPos;
     int p2 = lastPos;
     if(l1 > l2) {
         std::swap(l1, l2);
         std::swap(p1, p2);
     }
     if(l1 == l2 && p1 > p2) {
         std::swap(p1, p2);
     }
     if(l1 <= l && l <= l2)
     {
         if(l1 == l2)
             return p >= p1 && p < p2;
         if(l == l1)
             return p >= p1;
         if(l == l2)
             return p < p2;
         return true;
     }
     return false;
 }
 
 bool Selection::lineWithin(int l)
 {
     if(firstLine == -1) return false;
     int l1 = firstLine;
     int l2 = lastLine;
 
     if(l1 > l2) {
         std::swap(l1, l2);
     }
 
     return (l1 <= l && l <= l2);
 }
 
 class FormatRangeHelper
 {
   private:
     QFont m_font;
     QPen m_pen;
     QColor m_background;
     int m_currentPos;
 
   public:
     QVector<QTextLayout::FormatRange> m_formatRanges;
 
     FormatRangeHelper()
     {
         m_pen = QColor(Qt::black);
         m_background = QColor(Qt::white);
         m_currentPos = 0;
     }
     void setFont(const QFont& f)
     {
         m_font = f;
     }
     void setPen(const QPen& pen)
     {
         m_pen = pen;
     }
     void setBackground(const QColor& background)
     {
         m_background = background;
     }
 
     void next()
     {
         if(m_formatRanges.isEmpty() || m_formatRanges.back().format.foreground().color() != m_pen.color() || m_formatRanges.back().format.background().color() != m_background)
         {
             QTextLayout::FormatRange fr;
             fr.length = 1;
             fr.start = m_currentPos;
             fr.format.setForeground(m_pen.color());
             fr.format.setBackground(m_background);
             m_formatRanges.append(fr);
         }
         else
         {
             ++m_formatRanges.back().length;
         }
         ++m_currentPos;
     }
 };
 
 void DiffTextWindowData::prepareTextLayout(QTextLayout& textLayout, bool /*bFirstLine*/, int visibleTextWidth)
 {
     QTextOption textOption;
     textOption.setTabStop(QFontMetricsF(m_pDiffTextWindow->font()).width(' ') * m_pOptions->m_tabSize);
     if(m_pOptions->m_bShowWhiteSpaceCharacters)
         textOption.setFlags(QTextOption::ShowTabsAndSpaces);
     if(m_pOptions->m_bRightToLeftLanguage)
         textOption.setAlignment(Qt::AlignRight); // only relevant for multi line text layout
     if(visibleTextWidth >= 0)
         textOption.setWrapMode(QTextOption::WrapAtWordBoundaryOrAnywhere);
 
     textLayout.setTextOption(textOption);
 
     if(m_pOptions->m_bShowWhiteSpaceCharacters)
     {
         // This additional format is only necessary for the tab arrow
         QVector<QTextLayout::FormatRange> formats;
         QTextLayout::FormatRange formatRange;
         formatRange.start = 0;
         formatRange.length = textLayout.text().length();
         formatRange.format.setFont(m_pDiffTextWindow->font());
         formats.append(formatRange);
         textLayout.setFormats(formats);
     }
     textLayout.beginLayout();
 
     int leading = m_pDiffTextWindow->fontMetrics().leading();
     int height = 0;
 
     int fontWidth = m_pDiffTextWindow->fontMetrics().width('0');
     int xOffset = leftInfoWidth() * fontWidth - m_horizScrollOffset;
     int textWidth = visibleTextWidth;
     if(textWidth < 0)
         textWidth = m_pDiffTextWindow->width() - xOffset;
 
     int indentation = 0;
     while(1)
     {
         QTextLine line = textLayout.createLine();
         if(!line.isValid())
             break;
 
         height += leading;
         //if ( !bFirstLine )
         //   indentation = m_pDiffTextWindow->fontMetrics().width(' ') * m_pOptions->m_tabSize;
         if(visibleTextWidth >= 0)
         {
             line.setLineWidth(visibleTextWidth - indentation);
             line.setPosition(QPointF(indentation, height));
             height += line.height();
             //bFirstLine = false;
         }
         else // only one line
         {
             line.setPosition(QPointF(indentation, height));
             break;
         }
     }
 
     textLayout.endLayout();
     if(m_pOptions->m_bRightToLeftLanguage)
         textLayout.setPosition(QPointF(textWidth - textLayout.maximumWidth(), 0));
     else
         textLayout.setPosition(QPointF(xOffset, 0));
 }
 
 void DiffTextWindowData::writeLine(
     MyPainter& p,
     const LineData* pld,
     const DiffList* pLineDiff1,
     const DiffList* pLineDiff2,
     int line,
     int whatChanged,
     int whatChanged2,
     int srcLineIdx,
     int wrapLineOffset,
     int wrapLineLength,
     bool bWrapLine,
     const QRect& invalidRect,
     int deviceWidth)
 {
     QFont normalFont = p.font();
     QFont diffFont = normalFont;
     //never set
     //diffFont.setItalic(m_pOptions->m_bItalicForDeltas);
     const QFontMetrics& fm = p.fontMetrics();
     int fontHeight = fm.lineSpacing();
     int fontAscent = fm.ascent();
     int fontWidth = fm.width('0');
 
     int xOffset = leftInfoWidth() * fontWidth - m_horizScrollOffset;
     int yOffset = (line - m_firstLine) * fontHeight;
 
     QRect lineRect(0, yOffset, deviceWidth, fontHeight);
     if(!invalidRect.intersects(lineRect))
     {
         return;
     }
 
     int fastSelectorLine1 = m_pDiffTextWindow->convertDiff3LineIdxToLine(m_fastSelectorLine1);
     int fastSelectorLine2 = m_pDiffTextWindow->convertDiff3LineIdxToLine(m_fastSelectorLine1 + m_fastSelectorNofLines) - 1;
 
     bool bFastSelectionRange = (line >= fastSelectorLine1 && line <= fastSelectorLine2);
     QColor bgColor = m_pOptions->m_bgColor;
     QColor diffBgColor = m_pOptions->m_diffBgColor;
 
     if(bFastSelectionRange)
     {
         bgColor = m_pOptions->m_currentRangeBgColor;
         diffBgColor = m_pOptions->m_currentRangeDiffBgColor;
     }
 
     if(yOffset + fontHeight < invalidRect.top() || invalidRect.bottom() < yOffset - fontHeight)
         return;
 
     int changed = whatChanged;
     if(pLineDiff1 != nullptr) changed |= 1;
     if(pLineDiff2 != nullptr) changed |= 2;
 
     QColor c = m_pOptions->m_fgColor;
     p.setPen(c);
     if(changed == 2) {
         c = m_cDiff2;
     }
     else if(changed == 1)
     {
         c = m_cDiff1;
     }
     else if(changed == 3)
     {
         c = m_cDiffBoth;
     }
 
     if(pld != nullptr)
     {
         // First calculate the "changed" information for each character.
         int i = 0;
         QString lineString(pld->pLine, pld->size);
         if(!lineString.isEmpty())
         {
             switch(lineString[lineString.length() - 1].unicode())
             {
             case '\n':
                 lineString[lineString.length() - 1] = 0x00B6;
                 break; // "Pilcrow", "paragraph mark"
             case '\r':
                 lineString[lineString.length() - 1] = 0x00A4;
                 break; // Currency sign ;0x2761 "curved stem paragraph sign ornament"
                 //case '\0b' : lineString[lineString.length()-1] = 0x2756; break; // some other nice looking character
             }
         }
         QVector<UINT8> charChanged(pld->size);
         Merger merger(pLineDiff1, pLineDiff2);
         while(!merger.isEndReached() && i < pld->size)
         {
             if(i < pld->size)
             {
                 charChanged[i] = merger.whatChanged();
                 ++i;
             }
             merger.next();
         }
 
         int outPos = 0;
 
         int lineLength = m_bWordWrap ? wrapLineOffset + wrapLineLength : lineString.length();
 
         FormatRangeHelper frh;
 
         for(i = wrapLineOffset; i < lineLength; ++i)
         {
             QColor c = m_pOptions->m_fgColor;
             int cchanged = charChanged[i] | whatChanged;
 
             if(cchanged == 2) {
                 c = m_cDiff2;
             }
             else if(cchanged == 1)
             {
                 c = m_cDiff1;
             }
             else if(cchanged == 3)
             {
                 c = m_cDiffBoth;
             }
 
             if(c != m_pOptions->m_fgColor && whatChanged2 == 0 && !m_pOptions->m_bShowWhiteSpace)
             {
                 // The user doesn't want to see highlighted white space.
                 c = m_pOptions->m_fgColor;
             }
 
             //QRect outRect( xOffset + outPixelPos, yOffset, charWidth*spaces, fontHeight );
             //if ( m_pOptions->m_bRightToLeftLanguage )
             //   outRect = QRect( deviceWidth-1-(xOffset + outPixelPos), yOffset, -charWidth*spaces, fontHeight ).normalized();
             //if ( invalidRect.intersects( outRect ) )
             {
                 frh.setBackground(bgColor);
                 if(!m_selection.within(line, outPos))
                 {
 
                     if(c != m_pOptions->m_fgColor)
                     {
                         QColor lightc = diffBgColor;
                         frh.setBackground(lightc);
                         // Setting italic font here doesn't work: Changing the font only when drawing is too late
                     }
 
                     frh.setPen(c);
                     frh.next();
                     frh.setFont(normalFont);
                 }
                 else
                 {
                     frh.setBackground(m_pDiffTextWindow->palette().highlight().color());
                     frh.setPen(m_pDiffTextWindow->palette().highlightedText().color());
                     frh.next();
 
                     m_selection.bSelectionContainsData = true;
                 }
             }
 
             ++outPos;
         } // end for
 
         QTextLayout textLayout(lineString.mid(wrapLineOffset, lineLength - wrapLineOffset), m_pDiffTextWindow->font(), m_pDiffTextWindow);
         prepareTextLayout(textLayout, !m_bWordWrap || wrapLineOffset == 0);
         textLayout.draw(&p, QPoint(0, yOffset), frh.m_formatRanges /*, const QRectF & clip = QRectF() */);
     }
 
     p.fillRect(0, yOffset, leftInfoWidth() * fontWidth, fontHeight, m_pOptions->m_bgColor);
 
     xOffset = (m_lineNumberWidth + 2) * fontWidth;
     int xLeft = m_lineNumberWidth * fontWidth;
     p.setPen(m_pOptions->m_fgColor);
     if(pld != nullptr)
     {
         if(m_pOptions->m_bShowLineNumbers && !bWrapLine)
         {
             QString num;
             num.sprintf("%0*d", m_lineNumberWidth, srcLineIdx + 1);
             p.drawText(0, yOffset + fontAscent, num);
             //p.drawLine( xLeft -1, yOffset, xLeft -1, yOffset+fontHeight-1 );
         }
         if(!bWrapLine || wrapLineLength > 0)
         {
 #if defined(__APPLE__) && (QT_VERSION < QT_VERSION_CHECK(5, 0, 0))
             Qt::PenStyle wrapLinePenStyle = Qt::DashLine; // Qt::DotLine doesn't work on Mac (Qt4.8.6).
 #else
             Qt::PenStyle wrapLinePenStyle = Qt::DotLine;
 #endif
             p.setPen(QPen(m_pOptions->m_fgColor, 0, bWrapLine ? wrapLinePenStyle : Qt::SolidLine));
             p.drawLine(xOffset + 1, yOffset, xOffset + 1, yOffset + fontHeight - 1);
             p.setPen(QPen(m_pOptions->m_fgColor, 0, Qt::SolidLine));
         }
     }
     if(c != m_pOptions->m_fgColor && whatChanged2 == 0) //&& whatChanged==0 )
     {
         if(m_pOptions->m_bShowWhiteSpace)
         {
             p.setBrushOrigin(0, 0);
             p.fillRect(xLeft, yOffset, fontWidth * 2 - 1, fontHeight, QBrush(c, Qt::Dense5Pattern));
         }
     }
     else
     {
         p.fillRect(xLeft, yOffset, fontWidth * 2 - 1, fontHeight, c == m_pOptions->m_fgColor ? bgColor : c);
     }
 
     if(bFastSelectionRange)
     {
         p.fillRect(xOffset + fontWidth - 1, yOffset, 3, fontHeight, m_pOptions->m_fgColor);
     }
 
     // Check if line needs a manual diff help mark
     ManualDiffHelpList::const_iterator ci;
     for(ci = m_pManualDiffHelpList->begin(); ci != m_pManualDiffHelpList->end(); ++ci)
     {
         const ManualDiffHelpEntry& mdhe = *ci;
         int rangeLine1 = -1;
         int rangeLine2 = -1;
         if(m_winIdx == 1) {
             rangeLine1 = mdhe.lineA1;
             rangeLine2 = mdhe.lineA2;
         }
         if(m_winIdx == 2) {
             rangeLine1 = mdhe.lineB1;
             rangeLine2 = mdhe.lineB2;
         }
         if(m_winIdx == 3) {
             rangeLine1 = mdhe.lineC1;
             rangeLine2 = mdhe.lineC2;
         }
         if(rangeLine1 >= 0 && rangeLine2 >= 0 && srcLineIdx >= rangeLine1 && srcLineIdx <= rangeLine2)
         {
             p.fillRect(xOffset - fontWidth, yOffset, fontWidth - 1, fontHeight, m_pOptions->m_manualHelpRangeColor);
             break;
         }
     }
 }
 
 void DiffTextWindow::paintEvent(QPaintEvent* e)
 {
     QRect invalidRect = e->rect();
     if(invalidRect.isEmpty() || !d->m_bPaintingAllowed)
         return;
 
     if(d->m_pDiff3LineVector == nullptr || (d->m_diff3WrapLineVector.empty() && d->m_bWordWrap))
     {
         QPainter p(this);
         p.fillRect(invalidRect, d->m_pOptions->m_bgColor);
         return;
     }
 
     bool bOldSelectionContainsData = d->m_selection.bSelectionContainsData;
     d->m_selection.bSelectionContainsData = false;
 
     int endLine = min2(d->m_firstLine + getNofVisibleLines() + 2, getNofLines());
 
     MyPainter p(this, d->m_pOptions->m_bRightToLeftLanguage, width(), fontMetrics().width('0'));
 
     p.setFont(font());
     p.QPainter::fillRect(invalidRect, d->m_pOptions->m_bgColor);
 
     d->draw(p, invalidRect, width(), d->m_firstLine, endLine);
     p.end();
 
     d->m_oldFirstLine = d->m_firstLine;
-    d->m_selection.oldLastLine = -1;
-    if(d->m_selection.oldFirstLine != -1)
-        d->m_selection.oldFirstLine = -1;
+    d->m_selection.clearOldSelection();
 
-    if(!bOldSelectionContainsData && d->m_selection.bSelectionContainsData)
+    if(!bOldSelectionContainsData && d->m_selection.selectionContainsData())
         emit newSelection();
 }
 
 void DiffTextWindow::print(MyPainter& p, const QRect&, int firstLine, int nofLinesPerPage)
 {
     if(d->m_pDiff3LineVector == nullptr || !d->m_bPaintingAllowed ||
        (d->m_diff3WrapLineVector.empty() && d->m_bWordWrap))
         return;
     resetSelection();
     int oldFirstLine = d->m_firstLine;
     d->m_firstLine = firstLine;
     QRect invalidRect = QRect(0, 0, 1000000000, 1000000000);
     QColor bgColor = d->m_pOptions->m_bgColor;
     d->m_pOptions->m_bgColor = Qt::white;
     d->draw(p, invalidRect, p.window().width(), firstLine, min2(firstLine + nofLinesPerPage, getNofLines()));
     d->m_pOptions->m_bgColor = bgColor;
     d->m_firstLine = oldFirstLine;
 }
 
 void DiffTextWindowData::draw(MyPainter& p, const QRect& invalidRect, int deviceWidth, int beginLine, int endLine)
 {
     m_lineNumberWidth = m_pOptions->m_bShowLineNumbers ? (int)log10((double)qMax(m_size, 1)) + 1 : 0;
 
     if(m_winIdx == 1)
     {
         m_cThis = m_pOptions->m_colorA;
         m_cDiff1 = m_pOptions->m_colorB;
         m_cDiff2 = m_pOptions->m_colorC;
     }
     if(m_winIdx == 2)
     {
         m_cThis = m_pOptions->m_colorB;
         m_cDiff1 = m_pOptions->m_colorC;
         m_cDiff2 = m_pOptions->m_colorA;
     }
     if(m_winIdx == 3)
     {
         m_cThis = m_pOptions->m_colorC;
         m_cDiff1 = m_pOptions->m_colorA;
         m_cDiff2 = m_pOptions->m_colorB;
     }
     m_cDiffBoth = m_pOptions->m_colorForConflict; // Conflict color
 
     p.setPen(m_cThis);
 
     for(int line = beginLine; line < endLine; ++line)
     {
         int wrapLineOffset = 0;
         int wrapLineLength = 0;
         const Diff3Line* d3l = nullptr;
         bool bWrapLine = false;
         if(m_bWordWrap)
         {
             Diff3WrapLine& d3wl = m_diff3WrapLineVector[line];
             wrapLineOffset = d3wl.wrapLineOffset;
             wrapLineLength = d3wl.wrapLineLength;
             d3l = d3wl.pD3L;
             bWrapLine = line > 0 && m_diff3WrapLineVector[line - 1].pD3L == d3l;
         }
         else
         {
             d3l = (*m_pDiff3LineVector)[line];
         }
         DiffList* pFineDiff1;
         DiffList* pFineDiff2;
         int changed = 0;
         int changed2 = 0;
 
         int srcLineIdx = -1;
         getLineInfo(*d3l, srcLineIdx, pFineDiff1, pFineDiff2, changed, changed2);
 
         writeLine(
             p,                                               // QPainter
             srcLineIdx == -1 ? nullptr : &m_pLineData[srcLineIdx], // Text in this line
             pFineDiff1,
             pFineDiff2,
             line, // Line on the screen
             changed,
             changed2,
             srcLineIdx,
             wrapLineOffset,
             wrapLineLength,
             bWrapLine,
             invalidRect,
             deviceWidth);
     }
 }
 
 QString DiffTextWindowData::getString(int d3lIdx)
 {
     if(d3lIdx < 0 || d3lIdx >= (int)m_pDiff3LineVector->size())
         return QString();
     const Diff3Line* d3l = (*m_pDiff3LineVector)[d3lIdx];
     DiffList* pFineDiff1;
     DiffList* pFineDiff2;
     int changed = 0;
     int changed2 = 0;
     int lineIdx;
     getLineInfo(*d3l, lineIdx, pFineDiff1, pFineDiff2, changed, changed2);
 
     if(lineIdx == -1)
         return QString();
     else
     {
         const LineData* ld = &m_pLineData[lineIdx];
         return QString(ld->pLine, ld->size);
     }
     return QString();
 }
 
 QString DiffTextWindowData::getLineString(int line)
 {
     if(m_bWordWrap)
     {
         if(line < m_diff3WrapLineVector.count())
         {
             int d3LIdx = m_pDiffTextWindow->convertLineToDiff3LineIdx(line);
             return getString(d3LIdx).mid(m_diff3WrapLineVector[line].wrapLineOffset, m_diff3WrapLineVector[line].wrapLineLength);
         }
         else
             return QString();
     }
     else
     {
         return getString(line);
     }
 }
 
 void DiffTextWindowData::getLineInfo(
     const Diff3Line& d3l,
     int& lineIdx,
     DiffList*& pFineDiff1, DiffList*& pFineDiff2, // return values
     int& changed, int& changed2)
 {
     changed = 0;
     changed2 = 0;
     bool bAEqB = d3l.bAEqB || (d3l.bWhiteLineA && d3l.bWhiteLineB);
     bool bAEqC = d3l.bAEqC || (d3l.bWhiteLineA && d3l.bWhiteLineC);
     bool bBEqC = d3l.bBEqC || (d3l.bWhiteLineB && d3l.bWhiteLineC);
     if(m_winIdx == 1) {
         lineIdx = d3l.lineA;
         pFineDiff1 = d3l.pFineAB;
         pFineDiff2 = d3l.pFineCA;
         changed |= ((d3l.lineB == -1) != (lineIdx == -1) ? 1 : 0) +
                    ((d3l.lineC == -1) != (lineIdx == -1) && m_bTriple ? 2 : 0);
         changed2 |= (bAEqB ? 0 : 1) + (bAEqC || !m_bTriple ? 0 : 2);
     }
     else if(m_winIdx == 2)
     {
         lineIdx = d3l.lineB;
         pFineDiff1 = d3l.pFineBC;
         pFineDiff2 = d3l.pFineAB;
         changed |= ((d3l.lineC == -1) != (lineIdx == -1) && m_bTriple ? 1 : 0) +
                    ((d3l.lineA == -1) != (lineIdx == -1) ? 2 : 0);
         changed2 |= (bBEqC || !m_bTriple ? 0 : 1) + (bAEqB ? 0 : 2);
     }
     else if(m_winIdx == 3)
     {
         lineIdx = d3l.lineC;
         pFineDiff1 = d3l.pFineCA;
         pFineDiff2 = d3l.pFineBC;
         changed |= ((d3l.lineA == -1) != (lineIdx == -1) ? 1 : 0) +
                    ((d3l.lineB == -1) != (lineIdx == -1) ? 2 : 0);
         changed2 |= (bAEqC ? 0 : 1) + (bBEqC ? 0 : 2);
     }
     else
         assert(false);
 }
 
 void DiffTextWindow::resizeEvent(QResizeEvent* e)
 {
     QSize s = e->size();
     QFontMetrics fm = fontMetrics();
     int visibleLines = s.height() / fm.lineSpacing() - 2;
     int visibleColumns = s.width() / fm.width('0') - d->leftInfoWidth();
     if(e->size().height() != e->oldSize().height())
         emit resizeHeightChangedSignal(visibleLines);
     if(e->size().width() != e->oldSize().width())
         emit resizeWidthChangedSignal(visibleColumns);
     QWidget::resizeEvent(e);
 }
 
 int DiffTextWindow::getNofVisibleLines()
 {
     QFontMetrics fm = fontMetrics();
     int fmh = fm.lineSpacing();
     int h = height();
     return h / fmh - 1;
 }
 
 int DiffTextWindow::getVisibleTextAreaWidth()
 {
     QFontMetrics fm = fontMetrics();
     return width() - d->leftInfoWidth() * fm.width('0');
 }
 
 QString DiffTextWindow::getSelection()
 {
     if(d->m_pLineData == nullptr)
         return QString();
 
     QString selectionString;
 
     int line = 0;
     int lineIdx = 0;
 
     int it;
     int vectorSize = d->m_bWordWrap ? d->m_diff3WrapLineVector.size() : d->m_pDiff3LineVector->size();
     for(it = 0; it < vectorSize; ++it)
     {
         const Diff3Line* d3l = d->m_bWordWrap ? d->m_diff3WrapLineVector[it].pD3L : (*d->m_pDiff3LineVector)[it];
         if(d->m_winIdx == 1) {
             lineIdx = d3l->lineA;
         }
         else if(d->m_winIdx == 2)
         {
             lineIdx = d3l->lineB;
         }
         else if(d->m_winIdx == 3)
         {
             lineIdx = d3l->lineC;
         }
         else
             assert(false);
 
         if(lineIdx != -1)
         {
             const QChar* pLine = d->m_pLineData[lineIdx].pLine;
             int size = d->m_pLineData[lineIdx].size;
             QString lineString = QString(pLine, size);
 
             if(d->m_bWordWrap)
             {
                 size = d->m_diff3WrapLineVector[it].wrapLineLength;
                 lineString = lineString.mid(d->m_diff3WrapLineVector[it].wrapLineOffset, size);
             }
 
             for(int i = 0; i < size; ++i)
             {
                 if(d->m_selection.within(line, i))
                 {
                     selectionString += lineString[i];
                 }
             }
 
             if(d->m_selection.within(line, size) &&
                !(d->m_bWordWrap && it + 1 < vectorSize && d3l == d->m_diff3WrapLineVector[it + 1].pD3L))
             {
 #if defined(_WIN32) || defined(Q_OS_OS2)
                 selectionString += '\r';
 #endif
                 selectionString += '\n';
             }
         }
 
         ++line;
     }
 
     return selectionString;
 }
 
 bool DiffTextWindow::findString(const QString& s, int& d3vLine, int& posInLine, bool bDirDown, bool bCaseSensitive)
 {
     int it = d3vLine;
     int endIt = bDirDown ? (int)d->m_pDiff3LineVector->size() : -1;
     int step = bDirDown ? 1 : -1;
     int startPos = posInLine;
 
     for(; it != endIt; it += step)
     {
         QString line = d->getString(it);
         if(!line.isEmpty())
         {
             int pos = line.indexOf(s, startPos, bCaseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive);
             if(pos != -1)
             {
                 d3vLine = it;
                 posInLine = pos;
                 return true;
             }
 
             startPos = 0;
         }
     }
     return false;
 }
 
 void DiffTextWindow::convertD3LCoordsToLineCoords(int d3LIdx, int d3LPos, int& line, int& pos)
 {
     if(d->m_bWordWrap)
     {
         int wrapPos = d3LPos;
         int wrapLine = convertDiff3LineIdxToLine(d3LIdx);
         while(wrapPos > d->m_diff3WrapLineVector[wrapLine].wrapLineLength)
         {
             wrapPos -= d->m_diff3WrapLineVector[wrapLine].wrapLineLength;
             ++wrapLine;
         }
         pos = wrapPos;
         line = wrapLine;
     }
     else
     {
         pos = d3LPos;
         line = d3LIdx;
     }
 }
 
 void DiffTextWindow::convertLineCoordsToD3LCoords(int line, int pos, int& d3LIdx, int& d3LPos)
 {
     if(d->m_bWordWrap)
     {
         d3LPos = pos;
         d3LIdx = convertLineToDiff3LineIdx(line);
         int wrapLine = convertDiff3LineIdxToLine(d3LIdx); // First wrap line belonging to this d3LIdx
         while(wrapLine < line)
         {
             d3LPos += d->m_diff3WrapLineVector[wrapLine].wrapLineLength;
             ++wrapLine;
         }
     }
     else
     {
         d3LPos = pos;
         d3LIdx = line;
     }
 }
 
 void DiffTextWindow::setSelection(int firstLine, int startPos, int lastLine, int endPos, int& l, int& p)
 {
     d->m_selection.reset();
     if(lastLine >= getNofLines())
     {
         lastLine = getNofLines() - 1;
 
         const Diff3Line* d3l = (*d->m_pDiff3LineVector)[convertLineToDiff3LineIdx(lastLine)];
         int line = -1;
         if(d->m_winIdx == 1) line = d3l->lineA;
         if(d->m_winIdx == 2) line = d3l->lineB;
         if(d->m_winIdx == 3) line = d3l->lineC;
         if(line >= 0)
             endPos = d->m_pLineData[line].width(d->m_pOptions->m_tabSize);
     }
 
     if(d->m_bWordWrap && d->m_pDiff3LineVector != nullptr)
     {
         QString s1 = d->getString(firstLine);
         int firstWrapLine = convertDiff3LineIdxToLine(firstLine);
         int wrapStartPos = startPos;
         while(wrapStartPos > d->m_diff3WrapLineVector[firstWrapLine].wrapLineLength)
         {
             wrapStartPos -= d->m_diff3WrapLineVector[firstWrapLine].wrapLineLength;
             s1 = s1.mid(d->m_diff3WrapLineVector[firstWrapLine].wrapLineLength);
             ++firstWrapLine;
         }
 
         QString s2 = d->getString(lastLine);
         int lastWrapLine = convertDiff3LineIdxToLine(lastLine);
         int wrapEndPos = endPos;
         while(wrapEndPos > d->m_diff3WrapLineVector[lastWrapLine].wrapLineLength)
         {
             wrapEndPos -= d->m_diff3WrapLineVector[lastWrapLine].wrapLineLength;
             s2 = s2.mid(d->m_diff3WrapLineVector[lastWrapLine].wrapLineLength);
             ++lastWrapLine;
         }
 
         d->m_selection.start(firstWrapLine, convertToPosOnScreen(s1, wrapStartPos, d->m_pOptions->m_tabSize));
         d->m_selection.end(lastWrapLine, convertToPosOnScreen(s2, wrapEndPos, d->m_pOptions->m_tabSize));
         l = firstWrapLine;
         p = wrapStartPos;
     }
     else
     {
         if(d->m_pDiff3LineVector != nullptr){
             d->m_selection.start(firstLine, convertToPosOnScreen(d->getString(firstLine), startPos, d->m_pOptions->m_tabSize));
             d->m_selection.end(lastLine, convertToPosOnScreen(d->getString(lastLine), endPos, d->m_pOptions->m_tabSize));
             l = firstLine;
             p = startPos;
         }
     }
     update();
 }
 
 int DiffTextWindowData::convertLineOnScreenToLineInSource(int lineOnScreen, e_CoordType coordType, bool bFirstLine)
 {
     int line = -1;
     if(lineOnScreen >= 0)
     {
         if(coordType == eWrapCoords) return lineOnScreen;
         int d3lIdx = m_pDiffTextWindow->convertLineToDiff3LineIdx(lineOnScreen);
         if(!bFirstLine && d3lIdx >= (int)m_pDiff3LineVector->size())
             d3lIdx = m_pDiff3LineVector->size() - 1;
         if(coordType == eD3LLineCoords) return d3lIdx;
         while(line < 0 && d3lIdx < (int)m_pDiff3LineVector->size() && d3lIdx >= 0)
         {
             const Diff3Line* d3l = (*m_pDiff3LineVector)[d3lIdx];
             if(m_winIdx == 1) line = d3l->lineA;
             if(m_winIdx == 2) line = d3l->lineB;
             if(m_winIdx == 3) line = d3l->lineC;
             if(bFirstLine)
                 ++d3lIdx;
             else
                 --d3lIdx;
         }
         if(coordType == eFileCoords) return line;
     }
     return line;
 }
 
 void DiffTextWindow::getSelectionRange(int* pFirstLine, int* pLastLine, e_CoordType coordType)
 {
     if(pFirstLine)
         *pFirstLine = d->convertLineOnScreenToLineInSource(d->m_selection.beginLine(), coordType, true);
     if(pLastLine)
         *pLastLine = d->convertLineOnScreenToLineInSource(d->m_selection.endLine(), coordType, false);
 }
 
 void DiffTextWindow::convertSelectionToD3LCoords()
 {
     if(d->m_pDiff3LineVector == nullptr || !d->m_bPaintingAllowed || !isVisible() || d->m_selection.isEmpty())
     {
         return;
     }
 
     // convert the d->m_selection to unwrapped coordinates: Later restore to new coords
     int firstD3LIdx, firstD3LPos;
     QString s = d->getLineString(d->m_selection.beginLine());
     int firstPosInText = convertToPosInText(s, d->m_selection.beginPos(), d->m_pOptions->m_tabSize);
     convertLineCoordsToD3LCoords(d->m_selection.beginLine(), firstPosInText, firstD3LIdx, firstD3LPos);
 
     int lastD3LIdx, lastD3LPos;
     s = d->getLineString(d->m_selection.endLine());
     int lastPosInText = convertToPosInText(s, d->m_selection.endPos(), d->m_pOptions->m_tabSize);
     convertLineCoordsToD3LCoords(d->m_selection.endLine(), lastPosInText, lastD3LIdx, lastD3LPos);
 
     d->m_selection.start(firstD3LIdx, firstD3LPos);
     d->m_selection.end(lastD3LIdx, lastD3LPos);
 }
 
 int s_maxNofRunnables = 0;
 
 class RecalcWordWrapRunnable : public QRunnable
 {
     DiffTextWindow* m_pDTW;
     // DiffTextWindowData* m_pDTWData; // TODO unused?
     int m_visibleTextWidth;
     int m_cacheIdx;
 
   public:
     RecalcWordWrapRunnable(DiffTextWindow* p, DiffTextWindowData* pData, int visibleTextWidth, int cacheIdx)
         : m_pDTW(p), /* m_pDTWData(pData),*/ m_visibleTextWidth(visibleTextWidth), m_cacheIdx(cacheIdx)
     {
         Q_UNUSED(pData) // TODO really unused?
         setAutoDelete(true);
         //++s_runnableCount; // in Qt>=5.3 only
         s_runnableCount.fetchAndAddOrdered(1);
     }
     void run()
     {
         m_pDTW->recalcWordWrapHelper(0, m_visibleTextWidth, m_cacheIdx);
         // int newValue = --s_runnableCount; // in Qt>=5.3 only
         int newValue = s_runnableCount.fetchAndAddOrdered(-1) - 1;
         g_pProgressDialog->setCurrent(s_maxNofRunnables - getAtomic(s_runnableCount));
         if(newValue == 0)
         {
             QWidget* p = m_pDTW;
             while(p)
             {
                 p = p->parentWidget();
                 if(KDiff3App* pKDiff3App = dynamic_cast<KDiff3App*>(p))
                 {
                     QMetaObject::invokeMethod(pKDiff3App, "slotFinishRecalcWordWrap", Qt::QueuedConnection);
                     break;
                 }
             }
         }
     }
 };
 
 static QList<QRunnable*> s_runnables;
 
 bool startRunnables()
 {
     if(s_runnables.count() == 0)
     {
         return false;
     }
     else
     {
         g_pProgressDialog->setStayHidden(true);
         g_pProgressDialog->push();
         g_pProgressDialog->setMaxNofSteps(s_runnables.count());
         s_maxNofRunnables = s_runnables.count();
         g_pProgressDialog->setCurrent(0);
 
         for(int i = 0; i < s_runnables.count(); ++i)
         {
             QThreadPool::globalInstance()->start(s_runnables[i]);
         }
 
         s_runnables.clear();
         return true;
     }
 }
 
 static const int s_linesPerRunnable = 2000;
 
 void DiffTextWindow::recalcWordWrap(bool bWordWrap, int wrapLineVectorSize, int visibleTextWidth)
 {
     if(d->m_pDiff3LineVector == nullptr || !isVisible())
     {
         d->m_bWordWrap = bWordWrap;
         if(!bWordWrap) d->m_diff3WrapLineVector.resize(0);
         return;
     }
 
     d->m_bWordWrap = bWordWrap;
 
     if(bWordWrap)
     {
         d->m_lineNumberWidth = d->m_pOptions->m_bShowLineNumbers ? (int)log10((double)qMax(d->m_size, 1)) + 1 : 0;
 
         d->m_diff3WrapLineVector.resize(wrapLineVectorSize);
 
         if(wrapLineVectorSize == 0)
             d->m_wrapLineCacheList.clear();
 
         if(wrapLineVectorSize == 0)
         {
             d->m_bPaintingAllowed = false;
             for(int i = 0, j = 0; i < d->m_pDiff3LineVector->size(); i += s_linesPerRunnable, ++j)
             //int i=0;
             {
                 d->m_wrapLineCacheList.append(QVector<DiffTextWindowData::WrapLineCacheData>());
                 s_runnables.push_back(new RecalcWordWrapRunnable(this, d, visibleTextWidth, j));
             }
             //recalcWordWrap( bWordWrap, wrapLineVectorSize, visibleTextWidth, 0 );
         }
         else
         {
             recalcWordWrapHelper(wrapLineVectorSize, visibleTextWidth, 0);
             d->m_bPaintingAllowed = true;
         }
     }
     else
     {
         if(wrapLineVectorSize == 0 && getAtomic(d->m_maxTextWidth) < 0)
         {
             d->m_diff3WrapLineVector.resize(0);
             d->m_wrapLineCacheList.clear();
             d->m_bPaintingAllowed = false;
             for(int i = 0, j = 0; i < d->m_pDiff3LineVector->size(); i += s_linesPerRunnable, ++j)
             {
                 s_runnables.push_back(new RecalcWordWrapRunnable(this, d, visibleTextWidth, j));
             }
         }
         else
         {
             d->m_bPaintingAllowed = true;
         }
     }
 }
 
 void DiffTextWindow::recalcWordWrapHelper(int wrapLineVectorSize, int visibleTextWidth, int cacheListIdx)
 {
     if(d->m_bWordWrap)
     {
         if(g_pProgressDialog->wasCancelled())
             return;
         if(visibleTextWidth < 0)
             visibleTextWidth = getVisibleTextAreaWidth();
         else
             visibleTextWidth -= d->leftInfoWidth() * fontMetrics().width('0');
         int i;
         int wrapLineIdx = 0;
         int size = d->m_pDiff3LineVector->size();
         int firstD3LineIdx = wrapLineVectorSize > 0 ? 0 : cacheListIdx * s_linesPerRunnable;
         int endIdx = wrapLineVectorSize > 0 ? size : qMin(firstD3LineIdx + s_linesPerRunnable, size);
         QVector<DiffTextWindowData::WrapLineCacheData>& wrapLineCache = d->m_wrapLineCacheList[cacheListIdx];
         int cacheListIdx2 = 0;
         QTextLayout textLayout(QString(), font(), this);
         for(i = firstD3LineIdx; i < endIdx; ++i)
         {
             if(g_pProgressDialog->wasCancelled())
                 return;
 
             int linesNeeded = 0;
             if(wrapLineVectorSize == 0)
             {
                 QString s = d->getString(i);
                 textLayout.clearLayout();
                 textLayout.setText(s);
                 d->prepareTextLayout(textLayout, true, visibleTextWidth);
                 linesNeeded = textLayout.lineCount();
                 for(int l = 0; l < linesNeeded; ++l)
                 {
                     QTextLine line = textLayout.lineAt(l);
                     wrapLineCache.push_back(DiffTextWindowData::WrapLineCacheData(i, line.textStart(), line.textLength()));
                 }
             }
             else if(wrapLineVectorSize > 0 && cacheListIdx2 < d->m_wrapLineCacheList.count())
             {
                 DiffTextWindowData::WrapLineCacheData* pWrapLineCache = d->m_wrapLineCacheList[cacheListIdx2].data();
                 int cacheIdx = 0;
                 int clc = d->m_wrapLineCacheList.count() - 1;
                 int cllc = d->m_wrapLineCacheList.last().count();
                 int curCount = d->m_wrapLineCacheList[cacheListIdx2].count() - 1;
                 int l = 0;
                 while((cacheListIdx2 < clc || (cacheListIdx2 == clc && cacheIdx < cllc)) && pWrapLineCache->m_d3LineIdx <= i)
                 {
                     if(pWrapLineCache->m_d3LineIdx == i)
                     {
                         Diff3WrapLine* pDiff3WrapLine = &d->m_diff3WrapLineVector[wrapLineIdx + l];
                         pDiff3WrapLine->wrapLineOffset = pWrapLineCache->m_textStart;
                         pDiff3WrapLine->wrapLineLength = pWrapLineCache->m_textLength;
                         ++l;
                     }
                     if(cacheIdx < curCount)
                     {
                         ++cacheIdx;
                         ++pWrapLineCache;
                     }
                     else
                     {
                         ++cacheListIdx2;
                         if(cacheListIdx2 >= d->m_wrapLineCacheList.count())
                             break;
                         pWrapLineCache = d->m_wrapLineCacheList[cacheListIdx2].data();
                         curCount = d->m_wrapLineCacheList[cacheListIdx2].count();
                         cacheIdx = 0;
                     }
                 }
                 linesNeeded = l;
             }
 
             Diff3Line& d3l = *(*d->m_pDiff3LineVector)[i];
             if(d3l.linesNeededForDisplay < linesNeeded)
             {
                 assert(wrapLineVectorSize == 0);
                 d3l.linesNeededForDisplay = linesNeeded;
             }
 
             if(wrapLineVectorSize > 0)
             {
                 int j;
                 for(j = 0; j < d3l.linesNeededForDisplay; ++j, ++wrapLineIdx)
                 {
                     Diff3WrapLine& d3wl = d->m_diff3WrapLineVector[wrapLineIdx];
                     d3wl.diff3LineIndex = i;
                     d3wl.pD3L = (*d->m_pDiff3LineVector)[i];
                     if(j >= linesNeeded)
                     {
                         d3wl.wrapLineOffset = 0;
                         d3wl.wrapLineLength = 0;
                     }
                 }
             }
         }
 
         if(wrapLineVectorSize > 0)
         {
             d->m_firstLine = min2(d->m_firstLine, wrapLineVectorSize - 1);
             d->m_horizScrollOffset = 0;
             d->m_pDiffTextWindowFrame->setFirstLine(d->m_firstLine);
         }
     }
     else // no word wrap, just calc the maximum text width
     {
         if(g_pProgressDialog->wasCancelled())
             return;
         int size = d->m_pDiff3LineVector->size();
         int firstD3LineIdx = cacheListIdx * s_linesPerRunnable;
         int endIdx = qMin(firstD3LineIdx + s_linesPerRunnable, size);
 
         int maxTextWidth = getAtomic(d->m_maxTextWidth); // current value
         QTextLayout textLayout(QString(), font(), this);
         for(int i = firstD3LineIdx; i < endIdx; ++i)
         {
             if(g_pProgressDialog->wasCancelled())
                 return;
             textLayout.clearLayout();
             textLayout.setText(d->getString(i));
             d->prepareTextLayout(textLayout, true);
             if(textLayout.maximumWidth() > maxTextWidth)
                 maxTextWidth = textLayout.maximumWidth();
         }
 
         for(;;)
         {
             int prevMaxTextWidth = d->m_maxTextWidth.fetchAndStoreOrdered(maxTextWidth);
             if(prevMaxTextWidth <= maxTextWidth)
                 break;
             maxTextWidth = prevMaxTextWidth;
         }
     }
 
     if(!d->m_selection.isEmpty() && (!d->m_bWordWrap || wrapLineVectorSize > 0))
     {
         // Assume unwrapped coordinates
         //( Why? ->Conversion to unwrapped coords happened a few lines above in this method.
         //  Also see KDiff3App::recalcWordWrap() on the role of wrapLineVectorSize)
 
         // Wrap them now.
 
         // convert the d->m_selection to unwrapped coordinates.
         int firstLine, firstPos;
         convertD3LCoordsToLineCoords(d->m_selection.beginLine(), d->m_selection.beginPos(), firstLine, firstPos);
 
         int lastLine, lastPos;
         convertD3LCoordsToLineCoords(d->m_selection.endLine(), d->m_selection.endPos(), lastLine, lastPos);
 
         d->m_selection.start(firstLine, convertToPosOnScreen(d->getLineString(firstLine), firstPos, d->m_pOptions->m_tabSize));
         d->m_selection.end(lastLine, convertToPosOnScreen(d->getLineString(lastLine), lastPos, d->m_pOptions->m_tabSize));
     }
 }
 
 class DiffTextWindowFrameData
 {
   public:
     DiffTextWindow* m_pDiffTextWindow;
     QLineEdit* m_pFileSelection;
     QPushButton* m_pBrowseButton;
     Options* m_pOptions;
     QLabel* m_pLabel;
     QLabel* m_pTopLine;
     QLabel* m_pEncoding;
     QLabel* m_pLineEndStyle;
     QWidget* m_pTopLineWidget;
     int m_winIdx;
 };
 
 DiffTextWindowFrame::DiffTextWindowFrame(QWidget* pParent, QStatusBar* pStatusBar, Options* pOptions, int winIdx, SourceData* psd)
     : QWidget(pParent)
 {
     d = new DiffTextWindowFrameData;
     d->m_winIdx = winIdx;
     setAutoFillBackground(true);
     d->m_pOptions = pOptions;
     d->m_pTopLineWidget = new QWidget(this);
     d->m_pFileSelection = new QLineEdit(d->m_pTopLineWidget);
     d->m_pBrowseButton = new QPushButton("...", d->m_pTopLineWidget);
     d->m_pBrowseButton->setFixedWidth(30);
     connect(d->m_pBrowseButton, &QPushButton::clicked, this, &DiffTextWindowFrame::slotBrowseButtonClicked);
     connect(d->m_pFileSelection, &QLineEdit::returnPressed, this, &DiffTextWindowFrame::slotReturnPressed);
 
     d->m_pLabel = new QLabel("A:", d->m_pTopLineWidget);
     d->m_pTopLine = new QLabel(d->m_pTopLineWidget);
     d->m_pDiffTextWindow = nullptr;
     d->m_pDiffTextWindow = new DiffTextWindow(this, pStatusBar, pOptions, winIdx);
 
     QVBoxLayout* pVTopLayout = new QVBoxLayout(d->m_pTopLineWidget);
     pVTopLayout->setMargin(2);
     pVTopLayout->setSpacing(0);
     QHBoxLayout* pHL = new QHBoxLayout();
     QHBoxLayout* pHL2 = new QHBoxLayout();
     pVTopLayout->addLayout(pHL);
     pVTopLayout->addLayout(pHL2);
 
     // Upper line:
     pHL->setMargin(0);
     pHL->setSpacing(2);
 
     pHL->addWidget(d->m_pLabel, 0);
     pHL->addWidget(d->m_pFileSelection, 1);
     pHL->addWidget(d->m_pBrowseButton, 0);
     pHL->addWidget(d->m_pTopLine, 0);
 
     // Lower line
     pHL2->setMargin(0);
     pHL2->setSpacing(2);
     pHL2->addWidget(d->m_pTopLine, 0);
     d->m_pEncoding = new EncodingLabel(i18n("Encoding:"), this, psd, pOptions);
 
     d->m_pLineEndStyle = new QLabel(i18n("Line end style:"));
     pHL2->addWidget(d->m_pEncoding);
     pHL2->addWidget(d->m_pLineEndStyle);
 
     QVBoxLayout* pVL = new QVBoxLayout(this);
     pVL->setMargin(0);
     pVL->setSpacing(0);
     pVL->addWidget(d->m_pTopLineWidget, 0);
     pVL->addWidget(d->m_pDiffTextWindow, 1);
 
     d->m_pDiffTextWindow->installEventFilter(this);
     d->m_pFileSelection->installEventFilter(this);
     d->m_pBrowseButton->installEventFilter(this);
     init();
 }
 
 DiffTextWindowFrame::~DiffTextWindowFrame()
 {
     delete d;
 }
 
 void DiffTextWindowFrame::init()
 {
     DiffTextWindow* pDTW = d->m_pDiffTextWindow;
     if(pDTW)
     {
         QString s = QDir::toNativeSeparators(pDTW->d->m_filename);
         d->m_pFileSelection->setText(s);
         QString winId = pDTW->d->m_winIdx == 1 ? (pDTW->d->m_bTriple ? "A (Base)" : "A") : (pDTW->d->m_winIdx == 2 ? "B" : "C");
         d->m_pLabel->setText(winId + ":");
         d->m_pEncoding->setText(i18n("Encoding:") + " " + (pDTW->d->m_pTextCodec != nullptr ? pDTW->d->m_pTextCodec->name() : QString()));
         d->m_pLineEndStyle->setText(i18n("Line end style:") + " " + (pDTW->d->m_eLineEndStyle == eLineEndStyleDos ? i18n("DOS") : i18n("Unix")));
     }
 }
 
 // Search for the first visible line (search loop needed when no line exist for this file.)
 int DiffTextWindow::calcTopLineInFile(int firstLine)
 {
     int l = -1;
     for(int i = convertLineToDiff3LineIdx(firstLine); i < (int)d->m_pDiff3LineVector->size(); ++i)
     {
         const Diff3Line* d3l = (*d->m_pDiff3LineVector)[i];
         l = d3l->getLineInFile(d->m_winIdx);
         if(l != -1) break;
     }
     return l;
 }
 
 void DiffTextWindowFrame::setFirstLine(int firstLine)
 {
     DiffTextWindow* pDTW = d->m_pDiffTextWindow;
     if(pDTW && pDTW->d->m_pDiff3LineVector)
     {
         QString s = i18n("Top line");
         int lineNumberWidth = (int)log10((double)qMax(pDTW->d->m_size, 1)) + 1;
 
         int l = pDTW->calcTopLineInFile(firstLine);
 
         int w = d->m_pTopLine->fontMetrics().width(
             s + " " + QString().fill('0', lineNumberWidth));
         d->m_pTopLine->setMinimumWidth(w);
 
         if(l == -1)
             s = i18n("End");
         else
             s += " " + QString::number(l + 1);
 
         d->m_pTopLine->setText(s);
         d->m_pTopLine->repaint();
     }
 }
 
 DiffTextWindow* DiffTextWindowFrame::getDiffTextWindow()
 {
     return d->m_pDiffTextWindow;
 }
 
 bool DiffTextWindowFrame::eventFilter(QObject* o, QEvent* e)
 {
     DiffTextWindow* pDTW = d->m_pDiffTextWindow;
     if(e->type() == QEvent::FocusIn || e->type() == QEvent::FocusOut)
     {
         QColor c1 = d->m_pOptions->m_bgColor;
         QColor c2;
         if(d->m_winIdx == 1)
             c2 = d->m_pOptions->m_colorA;
         else if(d->m_winIdx == 2)
             c2 = d->m_pOptions->m_colorB;
         else if(d->m_winIdx == 3)
             c2 = d->m_pOptions->m_colorC;
 
         QPalette p = d->m_pTopLineWidget->palette();
         if(e->type() == QEvent::FocusOut)
             std::swap(c1, c2);
 
         p.setColor(QPalette::Window, c2);
         setPalette(p);
 
         p.setColor(QPalette::WindowText, c1);
         d->m_pLabel->setPalette(p);
         d->m_pTopLine->setPalette(p);
         d->m_pEncoding->setPalette(p);
         d->m_pLineEndStyle->setPalette(p);
     }
     if(o == d->m_pFileSelection && e->type() == QEvent::Drop)
     {
         QDropEvent* d = static_cast<QDropEvent*>(e);
 
         if(d->mimeData()->hasUrls())
         {
             QList<QUrl> lst = d->mimeData()->urls();
 
             if(lst.count() > 0)
             {
                 static_cast<QLineEdit*>(o)->setText(lst[0].toString());
                 static_cast<QLineEdit*>(o)->setFocus();
                 emit fileNameChanged(lst[0].toString(), pDTW->d->m_winIdx);
                 return true;
             }
         }
     }
 
     return false;
 }
 
 void DiffTextWindowFrame::slotReturnPressed()
 {
     DiffTextWindow* pDTW = d->m_pDiffTextWindow;
     if(pDTW->d->m_filename != d->m_pFileSelection->text())
     {
         emit fileNameChanged(d->m_pFileSelection->text(), pDTW->d->m_winIdx);
     }
 }
 
 void DiffTextWindowFrame::slotBrowseButtonClicked()
 {
     QString current = d->m_pFileSelection->text();
 
     QUrl newURL = QFileDialog::getOpenFileUrl(this, i18n("Open File"), QUrl::fromUserInput(current, QString(), QUrl::AssumeLocalFile));
     if(!newURL.isEmpty())
     {
         DiffTextWindow* pDTW = d->m_pDiffTextWindow;
         emit fileNameChanged(newURL.url(), pDTW->d->m_winIdx);
     }
 }
 
 void DiffTextWindowFrame::sendEncodingChangedSignal(QTextCodec* c)
 {
     emit encodingChanged(c);
 }
 
 EncodingLabel::EncodingLabel(const QString& text, DiffTextWindowFrame* pDiffTextWindowFrame, SourceData* pSD, Options* pOptions)
     : QLabel(text)
 {
     m_pDiffTextWindowFrame = pDiffTextWindowFrame;
     m_pOptions = pOptions;
     m_pSourceData = pSD;
     m_pContextEncodingMenu = nullptr;
     setMouseTracking(true);
 }
 
 void EncodingLabel::mouseMoveEvent(QMouseEvent*)
 {
     // When there is no data to display or it came from clipboard,
     // we will be use UTF-8 only,
     // in that case there is no possibility to change the encoding in the SourceData
     // so, we should hide the HandCursor and display usual ArrowCursor
     if(m_pSourceData->isFromBuffer() || m_pSourceData->isEmpty())
         setCursor(QCursor(Qt::ArrowCursor));
     else
         setCursor(QCursor(Qt::PointingHandCursor));
 }
 
 void EncodingLabel::mousePressEvent(QMouseEvent*)
 {
     if(!(m_pSourceData->isFromBuffer() || m_pSourceData->isEmpty()))
     {
         delete m_pContextEncodingMenu;
         m_pContextEncodingMenu = new QMenu(this);
         QMenu* pContextEncodingSubMenu = new QMenu(m_pContextEncodingMenu);
 
         int currentTextCodecEnum = m_pSourceData->getEncoding()->mibEnum(); // the codec that will be checked in the context menu
         QList<int> mibs = QTextCodec::availableMibs();
         QList<int> codecEnumList;
 
         // Adding "main" encodings
         insertCodec(i18n("Unicode, 8 bit"), QTextCodec::codecForName("UTF-8"), codecEnumList, m_pContextEncodingMenu, currentTextCodecEnum);
         if(QTextCodec::codecForName("System")) {
             insertCodec(QString(), QTextCodec::codecForName("System"), codecEnumList, m_pContextEncodingMenu, currentTextCodecEnum);
         }
 
         // Adding recent encodings
         if(m_pOptions != nullptr)
         {
             QStringList& recentEncodings = m_pOptions->m_recentEncodings;
             foreach(const QString& s, recentEncodings)
             {
                 insertCodec("", QTextCodec::codecForName(s.toLatin1()), codecEnumList, m_pContextEncodingMenu, currentTextCodecEnum);
             }
         }
         // Submenu to add the rest of available encodings
         pContextEncodingSubMenu->setTitle(i18n("Other"));
         foreach(int i, mibs)
         {
             QTextCodec* c = QTextCodec::codecForMib(i);
             if(c != nullptr)
                 insertCodec("", c, codecEnumList, pContextEncodingSubMenu, currentTextCodecEnum);
         }
 
         m_pContextEncodingMenu->addMenu(pContextEncodingSubMenu);
 
         m_pContextEncodingMenu->exec(QCursor::pos());
     }
 }
 
 void EncodingLabel::insertCodec(const QString& visibleCodecName, QTextCodec* pCodec, QList<int>& codecEnumList, QMenu* pMenu, int currentTextCodecEnum)
 {
     int CodecMIBEnum = pCodec->mibEnum();
     if(pCodec != nullptr && !codecEnumList.contains(CodecMIBEnum))
     {
         QAction* pAction = new QAction(pMenu); // menu takes ownership, so deleting the menu deletes the action too.
         pAction->setText(visibleCodecName.isEmpty() ? QString(pCodec->name()) : visibleCodecName + " (" + pCodec->name() + ")");
         pAction->setData(CodecMIBEnum);
         pAction->setCheckable(true);
         if(currentTextCodecEnum == CodecMIBEnum)
             pAction->setChecked(true);
         pMenu->addAction(pAction);
         connect(pAction, SIGNAL(triggered()), this, SLOT(slotEncodingChanged()));
         codecEnumList.append(CodecMIBEnum);
     }
 }
 
 void EncodingLabel::slotEncodingChanged()
 {
     QAction* pAction = qobject_cast<QAction*>(sender());
     if(pAction)
     {
         QTextCodec* pCodec = QTextCodec::codecForMib(pAction->data().toInt());
         if(pCodec != nullptr)
         {
             QString s(pCodec->name());
             QStringList& recentEncodings = m_pOptions->m_recentEncodings;
             if(!recentEncodings.contains(s) && s != "UTF-8" && s != "System")
             {
                 int itemsToRemove = recentEncodings.size() - m_maxRecentEncodings + 1;
                 for(int i = 0; i < itemsToRemove; ++i)
                 {
                     recentEncodings.removeFirst();
                 }
                 recentEncodings.append(s);
             }
         }
         m_pDiffTextWindowFrame->sendEncodingChangedSignal(pCodec);
     }
 }
diff --git a/src/mergeresultwindow.cpp b/src/mergeresultwindow.cpp
index 9d01a0c..080d67f 100644
--- a/src/mergeresultwindow.cpp
+++ b/src/mergeresultwindow.cpp
@@ -1,3586 +1,3590 @@
 /***************************************************************************
                           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>
 //Added by qt3to4:
 #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, int sizeA,
     const LineData* pLineDataB, int sizeB,
     const LineData* pLineDataC, int 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
             assert(false);
     }
     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
         assert(false);
 }
 
 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);
 
                         int 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.
 
         int oldSrcLine = -1;
         int oldSrc = -1;
         MergeEditLineList::iterator melIt;
         for(melIt = ml.mergeEditLineList.begin(); melIt != ml.mergeEditLineList.end();)
         {
             MergeEditLine& mel = *melIt;
             int melsrc = mel.src();
 
             int 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();
 
     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)
 {
     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: ") + QString::number(nrOfConflicts) +
                                  i18n("\nNr of automatically solved conflicts: ") + QString::number(nrOfConflicts - nrOfUnsolvedConflicts) +
                                  i18n("\nNr of unsolved conflicts: ") + QString::number(nrOfUnsolvedConflicts) +
                                  "\n" + 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;
 
             int 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.lastLine + m_scrollDeltaY, m_selection.lastPos + m_scrollDeltaX);
+        m_selection.end(m_selection.getLastLine() + m_scrollDeltaY, m_selection.getLastPos() + m_scrollDeltaX);
         emit 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;
         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];
 
         if(pld == nullptr)
         {
             // assert(false);      This is no error.
             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;
     textOption.setTabStop(QFontMetricsF(font()).width(' ') * m_pOptions->m_tabSize);
     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
         assert(false);
 
     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.bSelectionContainsData;
+    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;
             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.bSelectionContainsData)
+    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)
         {
             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.firstLine == -1)
+            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.firstLine != -1)
+        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.firstLine != -1)
+    if(m_selection.isValidFirstLine())
     {
         m_selection.end(line, pos);
         myUpdate(0);
 
         //showStatusLine( line, m_winIdx, m_pFilename, m_pDiff3LineList, m_pStatusBar );
 
         // Scroll because mouse moved out of the window
         const QFontMetrics& fm = fontMetrics();
         int fontWidth = fm.width('0');
         int topLineYOffset = 0;
         int deltaX = 0;
         int deltaY = 0;
         if(!m_pOptions->m_bRightToLeftLanguage)
         {
             if(e->x() < getTextXOffset()) deltaX = -1;
             if(e->x() > width()) deltaX = +1;
         }
         else
         {
             if(e->x() > width() - 1 - getTextXOffset()) deltaX = -1;
             if(e->x() < fontWidth) deltaX = +1;
         }
         if(e->y() < topLineYOffset) deltaY = -1;
         if(e->y() > height()) deltaY = +1;
         m_scrollDeltaX = deltaX;
         m_scrollDeltaY = deltaY;
         if(deltaX != 0 || deltaY != 0)
         {
             emit 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 _WIN32
     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.firstLine == -1)
+        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;
             }
         }
     }
     assert(false);
 }
 
 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 _WIN32
                     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.firstLine != -1 && m_selection.bSelectionContainsData)
+    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.firstLine == -1 || !m_selection.bSelectionContainsData)
+    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.lastPos - m_selection.firstPos == lineString.length())
+
+                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)
 {
-    if(m_selection.firstLine != -1)
-        deleteSelection();
+    //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.\n"),
                            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.\n"),
                            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:
                 assert(false);
                 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: " + pCodecForA->name(), QVariant::fromValue((void*)pCodecForA));
     if(pCodecForB)
         m_pEncodingSelector->addItem(i18n("Codec from") + " B: " + pCodecForB->name(), QVariant::fromValue((void*)pCodecForB));
     if(pCodecForC)
         m_pEncodingSelector->addItem(i18n("Codec from") + " C: " + 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"