Added abandoned KDE3 version of kdiff3

git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/kdiff3@1088041 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 1751 insertions, 0 deletions

diff --git a/src/difftextwindow.cpp b/src/difftextwindow.cpp
new file mode 100644
index 0000000..79d55ed
--- /dev/null
+++ b/src/difftextwindow.cpp
@@ -0,0 +1,1751 @@
+/***************************************************************************
+                          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 "merger.h"
+#include <qpainter.h>
+#include <assert.h>
+#include <qpixmap.h>
+#include <qstatusbar.h>
+#include <qapplication.h>
+#include <qtooltip.h>
+#include <qfont.h>
+#include <qstringlist.h>
+#include <qlineedit.h>
+#include <qlabel.h>
+#include <qpushbutton.h>
+#include <qlayout.h>
+#include <qtextcodec.h>
+#include <optiondialog.h>
+#include <math.h>
+#include <cstdlib>
+#include <qdragobject.h>
+#include <klocale.h>
+#include <kfiledialog.h>
+
+class DiffTextWindowData
+{
+public:
+   DiffTextWindowData( DiffTextWindow* p )
+   {
+      m_pDiffTextWindow = p;
+      m_bPaintingAllowed = false;
+      m_pLineData = 0;
+      m_size = 0;
+      m_bWordWrap = false;
+      m_delayedDrawTimer = 0;
+      m_pDiff3LineVector = 0;
+      m_pManualDiffHelpList = 0;
+      m_pOptionDialog = 0;
+      m_fastSelectorLine1 = 0;
+      m_fastSelectorNofLines = 0;
+      m_bTriple = 0;
+      m_winIdx = 0;
+      m_firstLine = 0;
+      m_oldFirstLine = 0;
+      m_oldFirstColumn = 0;
+      m_firstColumn = 0;
+      m_lineNumberWidth = 0;
+      m_pStatusBar = 0;
+      m_scrollDeltaX = 0;
+      m_scrollDeltaY = 0;
+      m_bMyUpdate = false;
+      m_bSelectionInProgress = false;
+   }
+   DiffTextWindow* m_pDiffTextWindow;
+   DiffTextWindowFrame* m_pDiffTextWindowFrame;
+
+   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;
+
+   OptionDialog* m_pOptionDialog;
+   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_oldFirstColumn;
+   int m_firstColumn;
+   int m_lineNumberWidth;
+
+   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;
+};
+
+DiffTextWindow::DiffTextWindow(
+   DiffTextWindowFrame* pParent,
+   QStatusBar* pStatusBar,
+   OptionDialog* pOptionDialog,
+   int winIdx
+   )
+   : QWidget(pParent, 0, Qt::WResizeNoErase | Qt::WRepaintNoErase)
+{
+   d = new DiffTextWindowData(this);
+   d->m_pDiffTextWindowFrame = pParent;
+   setFocusPolicy( ClickFocus );
+   setAcceptDrops( true );
+
+   d->m_pOptionDialog = pOptionDialog;
+   init( 0, 0, 0, 0, 0, false );
+
+   setMinimumSize(QSize(20,20));
+
+   d->m_pStatusBar = pStatusBar;
+   d->m_bPaintingAllowed = true;
+   d->m_bWordWrap = false;
+   d->m_winIdx = winIdx;
+
+   setFont(d->m_pOptionDialog->m_font);
+}
+
+DiffTextWindow::~DiffTextWindow()
+{
+   delete d;
+}
+
+void DiffTextWindow::init(
+   const QString& filename,
+   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_firstColumn = 0;
+   d->m_oldFirstColumn = -1;
+   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_selection.reset();
+   d->m_selection.oldFirstLine = -1; // reset is not enough here.
+   d->m_selection.oldLastLine = -1;
+   d->m_selection.lastLine = -1;
+
+   update();
+   d->m_pDiffTextWindowFrame->init();
+}
+
+void DiffTextWindow::reset()
+{
+   d->m_pLineData=0;
+   d->m_size=0;
+   d->m_pDiff3LineVector=0;
+   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->accept( QUriDrag::canDecode(e) || QTextDrag::canDecode(e) );
+   // Note that the corresponding drop is handled in KDiff3App::eventFilter().
+}
+
+
+void DiffTextWindow::setFirstLine(int firstLine)
+{
+   int fontHeight = fontMetrics().height();
+
+   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 )
+   {
+      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::setFirstColumn(int firstCol)
+{
+   int fontWidth = fontMetrics().width('W');
+   int xOffset = d->leftInfoWidth() * fontWidth;
+
+   int newFirstColumn = max2(0,firstCol);
+
+   int deltaX = fontWidth * ( d->m_firstColumn - newFirstColumn );
+
+   d->m_firstColumn = newFirstColumn;
+
+   QRect r( xOffset, 0, width()-xOffset, height() );
+
+   if ( d->m_pOptionDialog->m_bRightToLeftLanguage )
+   {
+      deltaX = -deltaX;
+      r = QRect( width()-1-xOffset, 0, -(width()-xOffset), height() ).normalize();
+   }
+
+   if ( d->m_bSelectionInProgress && d->m_selection.firstLine != -1 )
+   {
+      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::getNofColumns()
+{
+   if (d->m_bWordWrap)
+   {
+      return getNofVisibleColumns();
+   }
+   else
+   {
+      int nofColumns = 0;
+      for( int i = 0; i< d->m_size; ++i )
+      {
+         if ( d->m_pLineData[i].width( d->m_pOptionDialog->m_tabSize ) > nofColumns )
+            nofColumns = d->m_pLineData[i].width( d->m_pOptionDialog->m_tabSize );
+      }
+      return nofColumns;
+   }
+}
+
+int DiffTextWindow::getNofLines()
+{
+   return d->m_bWordWrap ? d->m_diff3WrapLineVector.size() : 
+                        d->m_pDiff3LineVector->size();
+}
+
+
+int DiffTextWindow::convertLineToDiff3LineIdx( int line )
+{
+   if ( 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!=0 && 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(d3lIdx >= 0 && d3lIdx<(int)d->m_pDiff3LineVector->size() )
+   {
+      const Diff3Line* pD3l = (*d->m_pDiff3LineVector)[d3lIdx];
+      if ( pD3l != 0 )
+      {
+         int l = pD3l->getLineInFile( d->m_winIdx );
+
+         QString s;
+         if ( l!=-1 )
+            s.sprintf("File %s: Line %d", d->m_filename.ascii(), l+1 );
+         else
+            s.sprintf("File %s: Line not available", d->m_filename.ascii() );
+         if (d->m_pStatusBar!=0) d->m_pStatusBar->message(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 );
+      if ( pos < d->m_firstColumn )
+      {
+         emit setFastSelectorLine( convertLineToDiff3LineIdx(line) );
+         d->m_selection.firstLine = -1;     // 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_pOptionDialog->m_tabSize );
+
+         resetSelection();
+         d->m_selection.start( line, convertToPosOnScreen( s, pos1, d->m_pOptionDialog->m_tabSize ) );
+         d->m_selection.end( line, convertToPosOnScreen( s, pos2, d->m_pOptionDialog->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 )
+   {
+      killTimer(d->m_delayedDrawTimer);
+      d->m_delayedDrawTimer = 0;
+      if (d->m_selection.firstLine != -1 )
+      {
+         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 )
+   {
+      d->m_selection.end( line, pos );
+
+      showStatusLine( line );
+
+      // Scroll because mouse moved out of the window
+      const QFontMetrics& fm = fontMetrics();
+      int fontWidth = fm.width('W');
+      int deltaX=0;
+      int deltaY=0;
+      if ( ! d->m_pOptionDialog->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.height());
+      if ( e->y() > height() )   deltaY = +1 + sqr( e->y() - height() ) / sqr(fm.height());
+      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 );
+         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)
+{
+   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().height();
+
+      if ( d->m_selection.oldLastLine != -1 )
+      {
+         int lastLine;
+         int firstLine;
+         if ( d->m_selection.oldFirstLine != -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 );
+         }
+         else
+         {
+            firstLine = min2( d->m_selection.lastLine, d->m_selection.oldLastLine );
+            lastLine = max2( d->m_selection.lastLine, d->m_selection.oldLastLine );
+         }
+         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, width(), y2-y1 );
+            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 );
+      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.height();
+   int fontWidth = fm.width('W');
+   int xOffset = ( d->leftInfoWidth() - d->m_firstColumn ) * fontWidth;
+
+   int yOffset = - d->m_firstLine * fontHeight;
+
+   line = ( y - yOffset ) / fontHeight;
+   if ( ! d->m_pOptionDialog->m_bRightToLeftLanguage )
+      pos  = ( x - xOffset ) / fontWidth;
+   else 
+      pos  = ( (width() - 1 - x) - xOffset ) / fontWidth;
+}
+
+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 );
+}
+
+
+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;
+   diffFont.setItalic( m_pOptionDialog->m_bItalicForDeltas );
+   const QFontMetrics& fm = p.fontMetrics();
+   int fontHeight = fm.height();
+   int fontAscent = fm.ascent();
+   int fontDescent = fm.descent();
+   int fontWidth = fm.width('W');
+
+   int xOffset = (leftInfoWidth() - m_firstColumn)*fontWidth;
+   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_pOptionDialog->m_bgColor;
+   QColor diffBgColor = m_pOptionDialog->m_diffBgColor;
+
+   if ( bFastSelectionRange )
+   {
+      bgColor = m_pOptionDialog->m_currentRangeBgColor;
+      diffBgColor = m_pOptionDialog->m_currentRangeDiffBgColor;
+   }
+
+   if ( yOffset+fontHeight<invalidRect.top()  ||  invalidRect.bottom() < yOffset-fontHeight )
+      return;
+
+   int changed = whatChanged;
+   if ( pLineDiff1 != 0 ) changed |= 1;
+   if ( pLineDiff2 != 0 ) changed |= 2;
+
+   QColor c = m_pOptionDialog->m_fgColor;
+   if ( changed == 2 ) {
+      c = m_cDiff2;
+   } else if ( changed == 1 ) {
+      c = m_cDiff1;
+   } else if ( changed == 3 ) {
+      c = m_cDiffBoth;
+   }
+
+   p.fillRect( leftInfoWidth()*fontWidth, yOffset, deviceWidth, fontHeight, bgColor );
+
+   if (pld!=0)
+   {
+      // First calculate the "changed" information for each character.
+      int i=0;
+      std::vector<UINT8> charChanged( pld->size );
+      if ( pLineDiff1!=0 || pLineDiff2 != 0 )
+      {
+         Merger merger( pLineDiff1, pLineDiff2 );
+         while( ! merger.isEndReached() &&  i<pld->size )
+         {
+            if ( i < pld->size )
+            {
+               charChanged[i] = merger.whatChanged();
+               ++i;
+            }
+            merger.next();
+         }
+      }
+
+      QString s=" ";
+      // Convert tabs
+      int outPos = 0;
+
+      QString lineString( pld->pLine, pld->size );
+      int lineLength = m_bWordWrap ? wrapLineOffset+wrapLineLength : lineString.length();
+
+      for( i=wrapLineOffset; i<lineLength; ++i )
+      {
+         int spaces = 1;
+
+         if ( lineString[i]=='\t' )
+         {
+            spaces = tabber( outPos, m_pOptionDialog->m_tabSize );
+            s[0] = ' ';
+         }
+         else
+         {
+            s[0] = lineString[i];
+         }
+
+         QColor c = m_pOptionDialog->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_pOptionDialog->m_fgColor && whatChanged2==0 && !m_pOptionDialog->m_bShowWhiteSpace )
+         {
+            // The user doesn't want to see highlighted white space.
+            c = m_pOptionDialog->m_fgColor;
+         }
+
+         QRect outRect( xOffset + fontWidth*outPos, yOffset, fontWidth*spaces, fontHeight );
+         if ( m_pOptionDialog->m_bRightToLeftLanguage )
+            outRect = QRect( deviceWidth-1-(xOffset + fontWidth*outPos), yOffset, -fontWidth*spaces, fontHeight ).normalize();
+         if ( invalidRect.intersects( outRect ) )
+         {
+            if( !m_selection.within( line, outPos ) )
+            {
+
+               if( c!=m_pOptionDialog->m_fgColor )
+               {
+                  QColor lightc = diffBgColor;
+                  p.fillRect( xOffset + fontWidth*outPos, yOffset,
+                           fontWidth*spaces, fontHeight, lightc );
+                  p.setFont(diffFont);
+               }
+
+               p.setPen( c );
+               if ( s[0]==' '  &&  c!=m_pOptionDialog->m_fgColor  &&  charChanged[i]!=0 )
+               {
+                  if ( m_pOptionDialog->m_bShowWhiteSpaceCharacters && m_pOptionDialog->m_bShowWhiteSpace)
+                  {
+                     p.fillRect( xOffset + fontWidth*outPos, yOffset+fontAscent,
+                                 fontWidth*spaces-1, fontDescent, c );  // QT3
+                                 //fontWidth*spaces-1, fontDescent, c );  // QT4
+                  }
+               }
+               else
+               {
+                  p.drawText( xOffset + fontWidth*outPos, yOffset + fontAscent, s );
+               }
+               p.setFont(normalFont);
+            }
+            else
+            {
+               p.fillRect( xOffset + fontWidth*outPos, yOffset,
+                           fontWidth*(spaces), fontHeight, m_pDiffTextWindow->colorGroup().highlight() );
+
+               p.setPen( m_pDiffTextWindow->colorGroup().highlightedText() );
+               p.drawText( xOffset + fontWidth*outPos, yOffset + fontAscent, s );
+
+               m_selection.bSelectionContainsData = true;
+            }
+         }
+
+         outPos += spaces;
+      }
+
+      if( m_selection.lineWithin( line ) && m_selection.lineWithin( line+1 ) )
+      {
+         p.fillRect( xOffset + fontWidth*outPos, yOffset,
+                     deviceWidth, fontHeight, m_pDiffTextWindow->colorGroup().highlight() );
+      }
+   }
+
+   p.fillRect( 0, yOffset, leftInfoWidth()*fontWidth, fontHeight, m_pOptionDialog->m_bgColor );
+
+   xOffset = (m_lineNumberWidth+2)*fontWidth;
+   int xLeft =   m_lineNumberWidth*fontWidth;
+   p.setPen( m_pOptionDialog->m_fgColor );
+   if ( pld!=0 )
+   {
+      if ( m_pOptionDialog->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 )
+      {
+         p.setPen( QPen( m_pOptionDialog->m_fgColor, 0, bWrapLine ? Qt::DotLine : Qt::SolidLine) );
+         p.drawLine( xOffset +1, yOffset, xOffset +1, yOffset+fontHeight-1 );
+         p.setPen( QPen( m_pOptionDialog->m_fgColor, 0, Qt::SolidLine) );
+      }
+   }
+   if ( c!=m_pOptionDialog->m_fgColor && whatChanged2==0 )//&& whatChanged==0 )
+   {
+      if ( m_pOptionDialog->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_pOptionDialog->m_fgColor ? bgColor : c );
+   }
+
+   if ( bFastSelectionRange )
+   {
+      p.fillRect( xOffset + fontWidth-1, yOffset, 3, fontHeight, m_pOptionDialog->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_pOptionDialog->m_manualHelpRangeColor );
+         break;
+      }
+   }
+}
+
+void DiffTextWindow::paintEvent( QPaintEvent* e )
+{
+   if ( d->m_pDiff3LineVector==0 || ! d->m_bPaintingAllowed ||
+        ( d->m_diff3WrapLineVector.empty() && d->m_bWordWrap ) ) 
+      return;
+
+   QRect invalidRect = e->rect();
+   if ( invalidRect.isEmpty() )
+      return;
+
+   bool bOldSelectionContainsData = d->m_selection.bSelectionContainsData;
+   d->m_selection.bSelectionContainsData = false;
+
+   int endLine = min2( d->m_firstLine + getNofVisibleLines()+2, getNofLines() );
+
+   //if ( invalidRect.size()==size() )
+   {  // double buffering, obsolete with Qt4
+      QPainter painter(this); // Remove for Qt4
+      QPixmap pixmap( invalidRect.size() );// Remove for Qt4
+
+      MyPainter p( &pixmap, d->m_pOptionDialog->m_bRightToLeftLanguage, width(), fontMetrics().width('W') ); // For Qt4 change pixmap to this
+
+      p.translate( -invalidRect.x(), -invalidRect.y() );// Remove for Qt4
+
+      p.setFont( font() );
+      p.QPainter::fillRect( invalidRect, d->m_pOptionDialog->m_bgColor );
+
+      d->draw( p, invalidRect, width(), d->m_firstLine, endLine );
+      // p.drawLine( m_invalidRect.x(), m_invalidRect.y(), m_invalidRect.right(), m_invalidRect.bottom() ); // For test only
+      p.end();
+
+      painter.drawPixmap( invalidRect.x(), invalidRect.y(), pixmap );// Remove for Qt4
+   }
+//    else
+//    {  // no double buffering
+//       MyPainter p( this, d->m_pOptionDialog->m_bRightToLeftLanguage, width(), fontMetrics().width('W') );
+//       p.setFont( font() );
+//       p.QPainter::fillRect( invalidRect, d->m_pOptionDialog->m_bgColor );
+//       d->draw( p, invalidRect, width(), d->m_firstLine, endLine );
+//    }
+
+
+   d->m_oldFirstLine = d->m_firstLine;
+   d->m_oldFirstColumn = d->m_firstColumn;
+   d->m_selection.oldLastLine = -1;
+   if ( d->m_selection.oldFirstLine !=-1 )
+      d->m_selection.oldFirstLine = -1;
+
+   if( !bOldSelectionContainsData  &&  d->m_selection.bSelectionContainsData )
+      emit newSelection();
+}
+
+void DiffTextWindow::print( MyPainter& p, const QRect&, int firstLine, int nofLinesPerPage )
+{
+   if ( d->m_pDiff3LineVector==0 || ! d->m_bPaintingAllowed ||
+        ( d->m_diff3WrapLineVector.empty() && d->m_bWordWrap ) ) 
+      return;
+   resetSelection();
+//   MyPainter p( this, d->m_pOptionDialog->m_bRightToLeftLanguage, width(), fontMetrics().width('W') );
+   int oldFirstLine = d->m_firstLine;
+   d->m_firstLine = firstLine;
+   QRect invalidRect = QRect(0,0,QCOORD_MAX,QCOORD_MAX);
+   QColor bgColor = d->m_pOptionDialog->m_bgColor;
+   d->m_pOptionDialog->m_bgColor = Qt::white;
+   d->draw( p, invalidRect, p.window().width(), firstLine, min2(firstLine+nofLinesPerPage,getNofLines()) );
+   d->m_pOptionDialog->m_bgColor = bgColor;
+   d->m_firstLine = oldFirstLine;
+}
+
+void DiffTextWindowData::draw( MyPainter& p, const QRect& invalidRect, int deviceWidth, int beginLine, int endLine )
+{
+   m_lineNumberWidth =  m_pOptionDialog->m_bShowLineNumbers ? (int)log10((double)m_size)+1 : 0;
+
+   if ( m_winIdx==1 )
+   {
+      m_cThis = m_pOptionDialog->m_colorA;
+      m_cDiff1 = m_pOptionDialog->m_colorB;
+      m_cDiff2 = m_pOptionDialog->m_colorC;
+   }
+   if ( m_winIdx==2 )
+   {
+      m_cThis = m_pOptionDialog->m_colorB;
+      m_cDiff1 = m_pOptionDialog->m_colorC;
+      m_cDiff2 = m_pOptionDialog->m_colorA;
+   }
+   if ( m_winIdx==3 )
+   {
+      m_cThis = m_pOptionDialog->m_colorC;
+      m_cDiff1 = m_pOptionDialog->m_colorA;
+      m_cDiff2 = m_pOptionDialog->m_colorB;
+   }
+   m_cDiffBoth = m_pOptionDialog->m_colorForConflict;  // Conflict color
+
+   p.setPen( m_cThis );
+
+   for ( int line = beginLine; line<endLine; ++line )
+   {
+      int wrapLineOffset=0;
+      int wrapLineLength=0;
+      const Diff3Line* d3l =0;
+      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 ? 0 : &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 )
+   {
+      int d3LIdx = m_pDiffTextWindow->convertLineToDiff3LineIdx(line);
+      return getString( d3LIdx ).mid( m_diff3WrapLineVector[line].wrapLineOffset, m_diff3WrapLineVector[line].wrapLineLength );
+   }
+   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.height()-2;
+   int visibleColumns = s.width()/fm.width('W') - d->leftInfoWidth();
+   emit resizeSignal( visibleColumns, visibleLines );
+   QWidget::resizeEvent(e);
+}
+
+int DiffTextWindow::getNofVisibleLines()
+{
+   QFontMetrics fm = fontMetrics();
+   int fmh = fm.height();
+   int h = height();
+   return h/fmh -1;//height()/fm.height()-2;
+}
+
+int DiffTextWindow::getNofVisibleColumns()
+{
+   QFontMetrics fm = fontMetrics();
+   return width()/fm.width('W') - d->leftInfoWidth();
+}
+
+QString DiffTextWindow::getSelection()
+{
+   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 );
+         }
+
+         // Consider tabs
+         int outPos = 0;
+         for( int i=0; i<size; ++i )
+         {
+            int spaces = 1;
+            if ( lineString[i]=='\t' )
+            {
+               spaces = tabber( outPos, d->m_pOptionDialog->m_tabSize );
+            }
+
+            if( d->m_selection.within( line, outPos ) )
+            {
+               selectionString += lineString[i];
+            }
+
+            outPos += spaces;
+         }
+
+         if( d->m_selection.within( line, outPos ) &&
+            !( d->m_bWordWrap && it+1<vectorSize && d3l == d->m_diff3WrapLineVector[it+1].pD3L ) 
+           )
+         {
+            #ifdef _WIN32
+            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.find( s, startPos, bCaseSensitive );
+         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_pOptionDialog->m_tabSize);
+   }
+
+   if ( d->m_bWordWrap && d->m_pDiff3LineVector!=0 )
+   {
+      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_pOptionDialog->m_tabSize ) );
+      d->m_selection.end( lastWrapLine, convertToPosOnScreen( s2, wrapEndPos, d->m_pOptionDialog->m_tabSize ) );
+      l=firstWrapLine;
+      p=wrapStartPos;
+   }
+   else
+   {
+      d->m_selection.start( firstLine, convertToPosOnScreen( d->getString(firstLine), startPos, d->m_pOptionDialog->m_tabSize ) );
+      d->m_selection.end( lastLine, convertToPosOnScreen( d->getString(lastLine), endPos, d->m_pOptionDialog->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 );
+}
+
+// Returns the number of wrapped lines
+// if pWrappedLines != 0 then the stringlist will contain the wrapped lines.
+int wordWrap( const QString& origLine, int nofColumns, Diff3WrapLine* pDiff3WrapLine )
+{
+   if (nofColumns<=0)
+      nofColumns = 1;
+
+   int nofNeededLines = 0;
+   int length = origLine.length();
+
+   if (length==0)
+   {
+      nofNeededLines = 1;
+      if( pDiff3WrapLine )
+      {
+         pDiff3WrapLine->wrapLineOffset=0;
+         pDiff3WrapLine->wrapLineLength=0;
+      }
+   }
+   else
+   {
+      int pos = 0;
+
+      while ( pos < length )
+      {
+         int wrapPos = pos + nofColumns;
+
+         if ( length-pos <= nofColumns  )
+         {
+            wrapPos = length;
+         }
+         else
+         {
+            int wsPos = max2( origLine.findRev( ' ', wrapPos ), origLine.findRev( '\t', wrapPos ) );
+
+            if ( wsPos > pos )
+            {
+               // Wrap line at wsPos
+               wrapPos = wsPos;
+            }
+         }
+
+         if ( pDiff3WrapLine )
+         {
+            pDiff3WrapLine->wrapLineOffset = pos;
+            pDiff3WrapLine->wrapLineLength = wrapPos-pos;
+            ++pDiff3WrapLine;
+         }
+
+         pos = wrapPos;
+
+         ++nofNeededLines;
+      }
+   }
+   return nofNeededLines;
+}
+
+void DiffTextWindow::convertSelectionToD3LCoords()
+{
+   if ( d->m_pDiff3LineVector==0 || ! 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_pOptionDialog->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_pOptionDialog->m_tabSize );
+   convertLineCoordsToD3LCoords( d->m_selection.endLine(), lastPosInText, lastD3LIdx, lastD3LPos );
+
+   //d->m_selection.reset();
+   d->m_selection.start( firstD3LIdx, firstD3LPos );
+   d->m_selection.end( lastD3LIdx, lastD3LPos );
+}
+
+void DiffTextWindow::recalcWordWrap( bool bWordWrap, int wrapLineVectorSize, int nofVisibleColumns )
+{
+   if ( d->m_pDiff3LineVector==0 || ! d->m_bPaintingAllowed || !isVisible() )
+   {
+      d->m_bWordWrap = bWordWrap;
+      if (!bWordWrap)  d->m_diff3WrapLineVector.resize( 0 );
+      return;
+   }
+
+   d->m_bWordWrap = bWordWrap;
+
+   if ( bWordWrap )
+   {
+      d->m_diff3WrapLineVector.resize( wrapLineVectorSize );
+
+      if (nofVisibleColumns<0)
+         nofVisibleColumns = getNofVisibleColumns();
+      else
+         nofVisibleColumns-= d->leftInfoWidth();
+      int i;
+      int wrapLineIdx = 0;
+      int size = d->m_pDiff3LineVector->size();
+      for( i=0; i<size; ++i )
+      {
+         QString s = d->getString( i );
+         int linesNeeded = wordWrap( s, nofVisibleColumns, wrapLineVectorSize==0 ? 0 : &d->m_diff3WrapLineVector[wrapLineIdx] );
+         Diff3Line& d3l = *(*d->m_pDiff3LineVector)[i];
+         if ( d3l.linesNeededForDisplay<linesNeeded )
+         {
+            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_firstColumn = 0;
+         d->m_pDiffTextWindowFrame->setFirstLine( d->m_firstLine );
+      }
+   }
+   else
+   {
+      d->m_diff3WrapLineVector.resize( 0 );
+   }
+
+   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.reset();
+      d->m_selection.start( firstLine, convertToPosOnScreen( d->getLineString( firstLine ), firstPos, d->m_pOptionDialog->m_tabSize ) );
+      d->m_selection.end( lastLine, convertToPosOnScreen( d->getLineString( lastLine ),lastPos, d->m_pOptionDialog->m_tabSize ) );
+   }
+}
+
+
+class DiffTextWindowFrameData
+{
+public:
+   DiffTextWindow* m_pDiffTextWindow;
+   QLineEdit* m_pFileSelection;
+   QPushButton* m_pBrowseButton;
+   OptionDialog* m_pOptionDialog;
+   QLabel*       m_pLabel;
+   QLabel*       m_pTopLine;
+   QWidget*      m_pTopLineWidget;
+};
+
+DiffTextWindowFrame::DiffTextWindowFrame( QWidget* pParent, QStatusBar* pStatusBar, OptionDialog* pOptionDialog, int winIdx )
+   : QWidget( pParent )
+{
+   d = new DiffTextWindowFrameData;
+   d->m_pOptionDialog = pOptionDialog;
+   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,SIGNAL(clicked()), this, SLOT(slotBrowseButtonClicked()));
+   connect(d->m_pFileSelection,SIGNAL(returnPressed()), this, SLOT(slotReturnPressed()));
+
+   d->m_pLabel = new QLabel("A:",d->m_pTopLineWidget);
+   d->m_pTopLine = new QLabel(d->m_pTopLineWidget);
+   d->m_pDiffTextWindow = 0;
+   d->m_pDiffTextWindow = new DiffTextWindow( this, pStatusBar, pOptionDialog, winIdx );
+   QHBoxLayout* pHL = new QHBoxLayout(d->m_pTopLineWidget);
+   pHL->setMargin(2);
+   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 );
+
+   QVBoxLayout* pVL = new QVBoxLayout( this, 0, 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 = pDTW->d->m_filename ;
+      d->m_pFileSelection->setText( QDir::convertSeparators(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 + ":" );
+   }
+}
+
+// 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)pDTW->d->m_size)+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_pOptionDialog->m_bgColor;
+      QColor c2 = pDTW->d->m_cThis;
+      QPalette p = d->m_pTopLineWidget->palette();
+      if ( e->type()==QEvent::FocusOut )
+         std::swap(c1,c2);
+
+      p.setColor(QColorGroup::Background, c2);
+      d->m_pTopLineWidget->setPalette( p );
+      d->m_pBrowseButton->setPalette( p );
+      d->m_pFileSelection->setPalette( p );
+
+      p.setColor(QColorGroup::Foreground, c1);
+      d->m_pLabel->setPalette( p );
+      d->m_pTopLine->setPalette( p );
+   }
+   if (o == d->m_pFileSelection && e->type()==QEvent::Drop)
+   {
+      QDropEvent* d = static_cast<QDropEvent*>(e);
+      
+      if ( QUriDrag::canDecode( d ) ) 
+      {
+         QStringList lst;
+         QUriDrag::decodeLocalFiles( d, lst );
+
+         if ( lst.count() > 0 )
+         {
+            static_cast<QLineEdit*>(o)->setText( lst[0] );
+            static_cast<QLineEdit*>(o)->setFocus();
+            emit fileNameChanged( lst[0], pDTW->d->m_winIdx );
+            return true;
+         }
+      }
+      /* The following lines work for Qt>4.1 but not for 4.0.x*/
+      /*if ( d->mimeData()->hasUrls() )
+      {
+         QList<QUrl> lst = d->mimeData()->urls();
+         if ( !lst.empty() )
+         {
+            static_cast<QLineEdit*>(o)->setText( lst[0].toLocalFile() );
+            static_cast<QLineEdit*>(o)->setFocus();
+            emit fileNameChanged( lst[0], 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();
+
+   KURL newURL = KFileDialog::getOpenURL( current, 0, this);
+   if ( !newURL.isEmpty() )
+   {
+      DiffTextWindow* pDTW = d->m_pDiffTextWindow;
+      emit fileNameChanged( newURL.url(), pDTW->d->m_winIdx );
+   }
+}
+
+QCString encodeString( const QString& s )
+{
+   QTextCodec* c = QTextCodec::codecForLocale();
+   if (c!=0)
+      return c->fromUnicode( s );
+   else
+      return QCString( s.latin1() );
+}
+
+#include "difftextwindow.moc"