62ebbb006b
2009-07-14 15:57:33 +0200 os r273979 : #i103542# no access to members after deletion 2009-06-15 13:18:52 +0200 os r272980 : #i40827# wrong param in Copy() fixed 2009-06-15 10:09:27 +0200 os r272964 : #i40827# first document copied with storage, later only copy SwDoc 2009-06-11 10:37:51 +0200 os r272851 : CWS-TOOLING: rebase CWS os131 to trunk@272827 (milestone: DEV300:m50) 2009-06-08 10:07:50 +0200 os r272721 : #i40827# warnings fixed 2009-06-04 16:31:04 +0200 os r272644 : #i40827# enable document copies - inactive
1827 lines
55 KiB
C++
1827 lines
55 KiB
C++
/*************************************************************************
|
||
*
|
||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||
*
|
||
* Copyright 2008 by Sun Microsystems, Inc.
|
||
*
|
||
* OpenOffice.org - a multi-platform office productivity suite
|
||
*
|
||
* $RCSfile: doccomp.cxx,v $
|
||
* $Revision: 1.24 $
|
||
*
|
||
* This file is part of OpenOffice.org.
|
||
*
|
||
* OpenOffice.org is free software: you can redistribute it and/or modify
|
||
* it under the terms of the GNU Lesser General Public License version 3
|
||
* only, as published by the Free Software Foundation.
|
||
*
|
||
* OpenOffice.org is distributed in the hope that it will be useful,
|
||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
* GNU Lesser General Public License version 3 for more details
|
||
* (a copy is included in the LICENSE file that accompanied this code).
|
||
*
|
||
* You should have received a copy of the GNU Lesser General Public License
|
||
* version 3 along with OpenOffice.org. If not, see
|
||
* <http://www.openoffice.org/license.html>
|
||
* for a copy of the LGPLv3 License.
|
||
*
|
||
************************************************************************/
|
||
|
||
// MARKER(update_precomp.py): autogen include statement, do not remove
|
||
#include "precompiled_sw.hxx"
|
||
|
||
|
||
#include <hintids.hxx>
|
||
#include <tools/list.hxx>
|
||
#include <vcl/vclenum.hxx>
|
||
#include <svx/crsditem.hxx>
|
||
#include <svx/colritem.hxx>
|
||
#include <svx/boxitem.hxx>
|
||
#include <svx/udlnitem.hxx>
|
||
#include <doc.hxx>
|
||
#include <docary.hxx>
|
||
#include <pam.hxx>
|
||
#include <ndtxt.hxx>
|
||
#include <redline.hxx>
|
||
#include <undobj.hxx>
|
||
#include <section.hxx>
|
||
#include <tox.hxx>
|
||
#include <docsh.hxx>
|
||
|
||
#include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
|
||
#include <com/sun/star/document/XDocumentProperties.hpp>
|
||
|
||
using namespace ::com::sun::star;
|
||
|
||
|
||
class CompareLine
|
||
{
|
||
public:
|
||
CompareLine() {}
|
||
virtual ~CompareLine();
|
||
|
||
virtual ULONG GetHashValue() const = 0;
|
||
virtual BOOL Compare( const CompareLine& rLine ) const = 0;
|
||
};
|
||
|
||
DECLARE_LIST( CompareList, CompareLine* )
|
||
|
||
class CompareData
|
||
{
|
||
ULONG* pIndex;
|
||
BOOL* pChangedFlag;
|
||
|
||
protected:
|
||
CompareList aLines;
|
||
ULONG nSttLineNum;
|
||
|
||
// Anfang und Ende beschneiden und alle anderen in das
|
||
// LinesArray setzen
|
||
virtual void CheckRanges( CompareData& ) = 0;
|
||
|
||
public:
|
||
CompareData();
|
||
virtual ~CompareData();
|
||
|
||
// gibt es unterschiede?
|
||
BOOL HasDiffs( const CompareData& rData ) const;
|
||
|
||
// startet das Vergleichen und Erzeugen der Unterschiede zweier
|
||
// Dokumente
|
||
void CompareLines( CompareData& rData );
|
||
// lasse die Unterschiede anzeigen - ruft die beiden Methoden
|
||
// ShowInsert / ShowDelete. Diese bekommen die Start und EndLine-Nummer
|
||
// uebergeben. Die Abbildung auf den tatsaechline Inhalt muss die
|
||
// Ableitung uebernehmen!
|
||
ULONG ShowDiffs( const CompareData& rData );
|
||
|
||
virtual void ShowInsert( ULONG nStt, ULONG nEnd );
|
||
virtual void ShowDelete( const CompareData& rData, ULONG nStt,
|
||
ULONG nEnd, ULONG nInsPos );
|
||
virtual void CheckForChangesInLine( const CompareData& rData,
|
||
ULONG& nStt, ULONG& nEnd,
|
||
ULONG& nThisStt, ULONG& nThisEnd );
|
||
|
||
// Eindeutigen Index fuer eine Line setzen. Gleiche Lines haben den
|
||
// selben Index; auch in den anderen CompareData!
|
||
void SetIndex( ULONG nLine, ULONG nIndex );
|
||
ULONG GetIndex( ULONG nLine ) const
|
||
{ return nLine < aLines.Count() ? pIndex[ nLine ] : 0; }
|
||
|
||
// setze/erfrage ob eine Zeile veraendert ist
|
||
void SetChanged( ULONG nLine, BOOL bFlag = TRUE );
|
||
BOOL GetChanged( ULONG nLine ) const
|
||
{
|
||
return (pChangedFlag && nLine < aLines.Count())
|
||
? pChangedFlag[ nLine ]
|
||
: 0;
|
||
}
|
||
|
||
ULONG GetLineCount() const { return aLines.Count(); }
|
||
ULONG GetLineOffset() const { return nSttLineNum; }
|
||
const CompareLine* GetLine( ULONG nLine ) const
|
||
{ return aLines.GetObject( nLine ); }
|
||
void InsertLine( CompareLine* pLine )
|
||
{ aLines.Insert( pLine, LIST_APPEND ); }
|
||
};
|
||
|
||
class Hash
|
||
{
|
||
struct _HashData
|
||
{
|
||
ULONG nNext, nHash;
|
||
const CompareLine* pLine;
|
||
|
||
_HashData()
|
||
: nNext( 0 ), nHash( 0 ), pLine(0) {}
|
||
};
|
||
|
||
ULONG* pHashArr;
|
||
_HashData* pDataArr;
|
||
ULONG nCount, nPrime;
|
||
|
||
public:
|
||
Hash( ULONG nSize );
|
||
~Hash();
|
||
|
||
void CalcHashValue( CompareData& rData );
|
||
|
||
ULONG GetCount() const { return nCount; }
|
||
};
|
||
|
||
class Compare
|
||
{
|
||
public:
|
||
class MovedData
|
||
{
|
||
ULONG* pIndex;
|
||
ULONG* pLineNum;
|
||
ULONG nCount;
|
||
|
||
public:
|
||
MovedData( CompareData& rData, sal_Char* pDiscard );
|
||
~MovedData();
|
||
|
||
ULONG GetIndex( ULONG n ) const { return pIndex[ n ]; }
|
||
ULONG GetLineNum( ULONG n ) const { return pLineNum[ n ]; }
|
||
ULONG GetCount() const { return nCount; }
|
||
};
|
||
|
||
private:
|
||
// Suche die verschobenen Lines
|
||
class CompareSequence
|
||
{
|
||
CompareData &rData1, &rData2;
|
||
const MovedData &rMoved1, &rMoved2;
|
||
long *pMemory, *pFDiag, *pBDiag;
|
||
|
||
void Compare( ULONG nStt1, ULONG nEnd1, ULONG nStt2, ULONG nEnd2 );
|
||
ULONG CheckDiag( ULONG nStt1, ULONG nEnd1,
|
||
ULONG nStt2, ULONG nEnd2, ULONG* pCost );
|
||
public:
|
||
CompareSequence( CompareData& rData1, CompareData& rData2,
|
||
const MovedData& rD1, const MovedData& rD2 );
|
||
~CompareSequence();
|
||
};
|
||
|
||
|
||
static void CountDifference( const CompareData& rData, ULONG* pCounts );
|
||
static void SetDiscard( const CompareData& rData,
|
||
sal_Char* pDiscard, ULONG* pCounts );
|
||
static void CheckDiscard( ULONG nLen, sal_Char* pDiscard );
|
||
static ULONG SetChangedFlag( CompareData& rData, sal_Char* pDiscard, int bFirst );
|
||
static void ShiftBoundaries( CompareData& rData1, CompareData& rData2 );
|
||
|
||
public:
|
||
Compare( ULONG nDiff, CompareData& rData1, CompareData& rData2 );
|
||
};
|
||
|
||
// ====================================================================
|
||
|
||
CompareLine::~CompareLine() {}
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
CompareData::CompareData()
|
||
: pIndex( 0 ), pChangedFlag( 0 ), nSttLineNum( 0 )
|
||
{
|
||
}
|
||
|
||
CompareData::~CompareData()
|
||
{
|
||
delete[] pIndex;
|
||
delete[] pChangedFlag;
|
||
}
|
||
|
||
void CompareData::SetIndex( ULONG nLine, ULONG nIndex )
|
||
{
|
||
if( !pIndex )
|
||
{
|
||
pIndex = new ULONG[ aLines.Count() ];
|
||
memset( pIndex, 0, aLines.Count() * sizeof( ULONG ) );
|
||
}
|
||
if( nLine < aLines.Count() )
|
||
pIndex[ nLine ] = nIndex;
|
||
}
|
||
|
||
void CompareData::SetChanged( ULONG nLine, BOOL bFlag )
|
||
{
|
||
if( !pChangedFlag )
|
||
{
|
||
pChangedFlag = new BOOL[ aLines.Count() +1 ];
|
||
memset( pChangedFlag, 0, aLines.Count() +1 * sizeof( BOOL ) );
|
||
}
|
||
if( nLine < aLines.Count() )
|
||
pChangedFlag[ nLine ] = bFlag;
|
||
}
|
||
|
||
void CompareData::CompareLines( CompareData& rData )
|
||
{
|
||
CheckRanges( rData );
|
||
|
||
ULONG nDifferent;
|
||
{
|
||
Hash aH( GetLineCount() + rData.GetLineCount() + 1 );
|
||
aH.CalcHashValue( *this );
|
||
aH.CalcHashValue( rData );
|
||
nDifferent = aH.GetCount();
|
||
}
|
||
{
|
||
Compare aComp( nDifferent, *this, rData );
|
||
}
|
||
}
|
||
|
||
ULONG CompareData::ShowDiffs( const CompareData& rData )
|
||
{
|
||
ULONG nLen1 = rData.GetLineCount(), nLen2 = GetLineCount();
|
||
ULONG nStt1 = 0, nStt2 = 0;
|
||
ULONG nCnt = 0;
|
||
|
||
while( nStt1 < nLen1 || nStt2 < nLen2 )
|
||
{
|
||
if( rData.GetChanged( nStt1 ) || GetChanged( nStt2 ) )
|
||
{
|
||
ULONG nSav1 = nStt1, nSav2 = nStt2;
|
||
while( nStt1 < nLen1 && rData.GetChanged( nStt1 )) ++nStt1;
|
||
while( nStt2 < nLen2 && GetChanged( nStt2 )) ++nStt2;
|
||
|
||
// rData ist das Original,
|
||
// this ist das, in das die Veraenderungen sollen
|
||
if( nSav2 != nStt2 && nSav1 != nStt1 )
|
||
CheckForChangesInLine( rData, nSav1, nStt1, nSav2, nStt2 );
|
||
|
||
if( nSav2 != nStt2 )
|
||
ShowInsert( nSav2, nStt2 );
|
||
|
||
if( nSav1 != nStt1 )
|
||
ShowDelete( rData, nSav1, nStt1, nStt2 );
|
||
++nCnt;
|
||
}
|
||
++nStt1, ++nStt2;
|
||
}
|
||
return nCnt;
|
||
}
|
||
|
||
BOOL CompareData::HasDiffs( const CompareData& rData ) const
|
||
{
|
||
BOOL bRet = FALSE;
|
||
ULONG nLen1 = rData.GetLineCount(), nLen2 = GetLineCount();
|
||
ULONG nStt1 = 0, nStt2 = 0;
|
||
|
||
while( nStt1 < nLen1 || nStt2 < nLen2 )
|
||
{
|
||
if( rData.GetChanged( nStt1 ) || GetChanged( nStt2 ) )
|
||
{
|
||
bRet = TRUE;
|
||
break;
|
||
}
|
||
++nStt1, ++nStt2;
|
||
}
|
||
return bRet;
|
||
}
|
||
|
||
void CompareData::ShowInsert( ULONG, ULONG )
|
||
{
|
||
}
|
||
|
||
void CompareData::ShowDelete( const CompareData&, ULONG, ULONG, ULONG )
|
||
{
|
||
}
|
||
|
||
void CompareData::CheckForChangesInLine( const CompareData& ,
|
||
ULONG&, ULONG&, ULONG&, ULONG& )
|
||
{
|
||
}
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
Hash::Hash( ULONG nSize )
|
||
: nCount( 1 )
|
||
{
|
||
|
||
static const ULONG primes[] =
|
||
{
|
||
509,
|
||
1021,
|
||
2039,
|
||
4093,
|
||
8191,
|
||
16381,
|
||
32749,
|
||
65521,
|
||
131071,
|
||
262139,
|
||
524287,
|
||
1048573,
|
||
2097143,
|
||
4194301,
|
||
8388593,
|
||
16777213,
|
||
33554393,
|
||
67108859, /* Preposterously large . . . */
|
||
134217689,
|
||
268435399,
|
||
536870909,
|
||
1073741789,
|
||
2147483647,
|
||
0
|
||
};
|
||
int i;
|
||
|
||
pDataArr = new _HashData[ nSize ];
|
||
pDataArr[0].nNext = 0;
|
||
pDataArr[0].nHash = 0,
|
||
pDataArr[0].pLine = 0;
|
||
|
||
for( i = 0; primes[i] < nSize / 3; i++)
|
||
if( !primes[i] )
|
||
{
|
||
pHashArr = 0;
|
||
return;
|
||
}
|
||
nPrime = primes[ i ];
|
||
pHashArr = new ULONG[ nPrime ];
|
||
memset( pHashArr, 0, nPrime * sizeof( ULONG ) );
|
||
}
|
||
|
||
Hash::~Hash()
|
||
{
|
||
delete[] pHashArr;
|
||
delete[] pDataArr;
|
||
}
|
||
|
||
void Hash::CalcHashValue( CompareData& rData )
|
||
{
|
||
if( pHashArr )
|
||
{
|
||
for( ULONG n = 0; n < rData.GetLineCount(); ++n )
|
||
{
|
||
const CompareLine* pLine = rData.GetLine( n );
|
||
ASSERT( pLine, "wo ist die Line?" );
|
||
ULONG nH = pLine->GetHashValue();
|
||
|
||
ULONG* pFound = &pHashArr[ nH % nPrime ];
|
||
ULONG i;
|
||
for( i = *pFound; ; i = pDataArr[i].nNext )
|
||
if( !i )
|
||
{
|
||
i = nCount++;
|
||
pDataArr[i].nNext = *pFound;
|
||
pDataArr[i].nHash = nH;
|
||
pDataArr[i].pLine = pLine;
|
||
*pFound = i;
|
||
break;
|
||
}
|
||
else if( pDataArr[i].nHash == nH &&
|
||
pDataArr[i].pLine->Compare( *pLine ))
|
||
break;
|
||
|
||
rData.SetIndex( n, i );
|
||
}
|
||
}
|
||
}
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
Compare::Compare( ULONG nDiff, CompareData& rData1, CompareData& rData2 )
|
||
{
|
||
MovedData *pMD1, *pMD2;
|
||
// Suche die unterschiedlichen Lines
|
||
{
|
||
sal_Char* pDiscard1 = new sal_Char[ rData1.GetLineCount() ];
|
||
sal_Char* pDiscard2 = new sal_Char[ rData2.GetLineCount() ];
|
||
|
||
ULONG* pCount1 = new ULONG[ nDiff ];
|
||
ULONG* pCount2 = new ULONG[ nDiff ];
|
||
memset( pCount1, 0, nDiff * sizeof( ULONG ));
|
||
memset( pCount2, 0, nDiff * sizeof( ULONG ));
|
||
|
||
// stelle fest, welche Indizies in den CompareData mehrfach vergeben wurden
|
||
CountDifference( rData1, pCount1 );
|
||
CountDifference( rData2, pCount2 );
|
||
|
||
// alle die jetzt nur einmal vorhanden sind, sind eingefuegt oder
|
||
// geloescht worden. Alle die im anderen auch vorhanden sind, sind
|
||
// verschoben worden
|
||
SetDiscard( rData1, pDiscard1, pCount2 );
|
||
SetDiscard( rData2, pDiscard2, pCount1 );
|
||
|
||
// die Arrays koennen wir wieder vergessen
|
||
delete pCount1; delete pCount2;
|
||
|
||
CheckDiscard( rData1.GetLineCount(), pDiscard1 );
|
||
CheckDiscard( rData2.GetLineCount(), pDiscard2 );
|
||
|
||
pMD1 = new MovedData( rData1, pDiscard1 );
|
||
pMD2 = new MovedData( rData2, pDiscard2 );
|
||
|
||
// die Arrays koennen wir wieder vergessen
|
||
delete pDiscard1; delete pDiscard2;
|
||
}
|
||
|
||
{
|
||
CompareSequence aTmp( rData1, rData2, *pMD1, *pMD2 );
|
||
}
|
||
|
||
ShiftBoundaries( rData1, rData2 );
|
||
|
||
delete pMD1;
|
||
delete pMD2;
|
||
}
|
||
|
||
|
||
|
||
void Compare::CountDifference( const CompareData& rData, ULONG* pCounts )
|
||
{
|
||
ULONG nLen = rData.GetLineCount();
|
||
for( ULONG n = 0; n < nLen; ++n )
|
||
{
|
||
ULONG nIdx = rData.GetIndex( n );
|
||
++pCounts[ nIdx ];
|
||
}
|
||
}
|
||
|
||
void Compare::SetDiscard( const CompareData& rData,
|
||
sal_Char* pDiscard, ULONG* pCounts )
|
||
{
|
||
ULONG nLen = rData.GetLineCount();
|
||
|
||
// berechne Max in Abhanegigkeit zur LineAnzahl
|
||
USHORT nMax = 5;
|
||
ULONG n;
|
||
|
||
for( n = nLen / 64; ( n = n >> 2 ) > 0; )
|
||
nMax <<= 1;
|
||
|
||
for( n = 0; n < nLen; ++n )
|
||
{
|
||
ULONG nIdx = rData.GetIndex( n );
|
||
if( nIdx )
|
||
{
|
||
nIdx = pCounts[ nIdx ];
|
||
pDiscard[ n ] = !nIdx ? 1 : nIdx > nMax ? 2 : 0;
|
||
}
|
||
else
|
||
pDiscard[ n ] = 0;
|
||
}
|
||
}
|
||
|
||
void Compare::CheckDiscard( ULONG nLen, sal_Char* pDiscard )
|
||
{
|
||
for( ULONG n = 0; n < nLen; ++n )
|
||
{
|
||
if( 2 == pDiscard[ n ] )
|
||
pDiscard[n] = 0;
|
||
else if( pDiscard[ n ] )
|
||
{
|
||
ULONG j;
|
||
ULONG length;
|
||
ULONG provisional = 0;
|
||
|
||
/* Find end of this run of discardable lines.
|
||
Count how many are provisionally discardable. */
|
||
for (j = n; j < nLen; j++)
|
||
{
|
||
if( !pDiscard[j] )
|
||
break;
|
||
if( 2 == pDiscard[j] )
|
||
++provisional;
|
||
}
|
||
|
||
/* Cancel provisional discards at end, and shrink the run. */
|
||
while( j > n && 2 == pDiscard[j - 1] )
|
||
pDiscard[ --j ] = 0, --provisional;
|
||
|
||
/* Now we have the length of a run of discardable lines
|
||
whose first and last are not provisional. */
|
||
length = j - n;
|
||
|
||
/* If 1/4 of the lines in the run are provisional,
|
||
cancel discarding of all provisional lines in the run. */
|
||
if (provisional * 4 > length)
|
||
{
|
||
while (j > n)
|
||
if (pDiscard[--j] == 2)
|
||
pDiscard[j] = 0;
|
||
}
|
||
else
|
||
{
|
||
ULONG consec;
|
||
ULONG minimum = 1;
|
||
ULONG tem = length / 4;
|
||
|
||
/* MINIMUM is approximate square root of LENGTH/4.
|
||
A subrun of two or more provisionals can stand
|
||
when LENGTH is at least 16.
|
||
A subrun of 4 or more can stand when LENGTH >= 64. */
|
||
while ((tem = tem >> 2) > 0)
|
||
minimum *= 2;
|
||
minimum++;
|
||
|
||
/* Cancel any subrun of MINIMUM or more provisionals
|
||
within the larger run. */
|
||
for (j = 0, consec = 0; j < length; j++)
|
||
if (pDiscard[n + j] != 2)
|
||
consec = 0;
|
||
else if (minimum == ++consec)
|
||
/* Back up to start of subrun, to cancel it all. */
|
||
j -= consec;
|
||
else if (minimum < consec)
|
||
pDiscard[n + j] = 0;
|
||
|
||
/* Scan from beginning of run
|
||
until we find 3 or more nonprovisionals in a row
|
||
or until the first nonprovisional at least 8 lines in.
|
||
Until that point, cancel any provisionals. */
|
||
for (j = 0, consec = 0; j < length; j++)
|
||
{
|
||
if (j >= 8 && pDiscard[n + j] == 1)
|
||
break;
|
||
if (pDiscard[n + j] == 2)
|
||
consec = 0, pDiscard[n + j] = 0;
|
||
else if (pDiscard[n + j] == 0)
|
||
consec = 0;
|
||
else
|
||
consec++;
|
||
if (consec == 3)
|
||
break;
|
||
}
|
||
|
||
/* I advances to the last line of the run. */
|
||
n += length - 1;
|
||
|
||
/* Same thing, from end. */
|
||
for (j = 0, consec = 0; j < length; j++)
|
||
{
|
||
if (j >= 8 && pDiscard[n - j] == 1)
|
||
break;
|
||
if (pDiscard[n - j] == 2)
|
||
consec = 0, pDiscard[n - j] = 0;
|
||
else if (pDiscard[n - j] == 0)
|
||
consec = 0;
|
||
else
|
||
consec++;
|
||
if (consec == 3)
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
Compare::MovedData::MovedData( CompareData& rData, sal_Char* pDiscard )
|
||
: pIndex( 0 ), pLineNum( 0 ), nCount( 0 )
|
||
{
|
||
ULONG nLen = rData.GetLineCount();
|
||
ULONG n;
|
||
|
||
for( n = 0; n < nLen; ++n )
|
||
if( pDiscard[ n ] )
|
||
rData.SetChanged( n );
|
||
else
|
||
++nCount;
|
||
|
||
if( nCount )
|
||
{
|
||
pIndex = new ULONG[ nCount ];
|
||
pLineNum = new ULONG[ nCount ];
|
||
|
||
for( n = 0, nCount = 0; n < nLen; ++n )
|
||
if( !pDiscard[ n ] )
|
||
{
|
||
pIndex[ nCount ] = rData.GetIndex( n );
|
||
pLineNum[ nCount++ ] = n;
|
||
}
|
||
}
|
||
}
|
||
|
||
Compare::MovedData::~MovedData()
|
||
{
|
||
delete pIndex;
|
||
delete pLineNum;
|
||
}
|
||
|
||
// ----------------------------------------------------------------------
|
||
|
||
// Suche die verschobenen Lines
|
||
Compare::CompareSequence::CompareSequence(
|
||
CompareData& rD1, CompareData& rD2,
|
||
const MovedData& rMD1, const MovedData& rMD2 )
|
||
: rData1( rD1 ), rData2( rD2 ), rMoved1( rMD1 ), rMoved2( rMD2 )
|
||
{
|
||
ULONG nSize = rMD1.GetCount() + rMD2.GetCount() + 3;
|
||
pMemory = new long[ nSize * 2 ];
|
||
pFDiag = pMemory + ( rMD2.GetCount() + 1 );
|
||
pBDiag = pMemory + ( nSize + rMD2.GetCount() + 1 );
|
||
|
||
Compare( 0, rMD1.GetCount(), 0, rMD2.GetCount() );
|
||
}
|
||
|
||
Compare::CompareSequence::~CompareSequence()
|
||
{
|
||
delete pMemory;
|
||
}
|
||
|
||
void Compare::CompareSequence::Compare( ULONG nStt1, ULONG nEnd1,
|
||
ULONG nStt2, ULONG nEnd2 )
|
||
{
|
||
/* Slide down the bottom initial diagonal. */
|
||
while( nStt1 < nEnd1 && nStt2 < nEnd2 &&
|
||
rMoved1.GetIndex( nStt1 ) == rMoved2.GetIndex( nStt2 ))
|
||
++nStt1, ++nStt2;
|
||
|
||
/* Slide up the top initial diagonal. */
|
||
while( nEnd1 > nStt1 && nEnd2 > nStt2 &&
|
||
rMoved1.GetIndex( nEnd1 - 1 ) == rMoved2.GetIndex( nEnd2 - 1 ))
|
||
--nEnd1, --nEnd2;
|
||
|
||
/* Handle simple cases. */
|
||
if( nStt1 == nEnd1 )
|
||
while( nStt2 < nEnd2 )
|
||
rData2.SetChanged( rMoved2.GetLineNum( nStt2++ ));
|
||
|
||
else if (nStt2 == nEnd2)
|
||
while (nStt1 < nEnd1)
|
||
rData1.SetChanged( rMoved1.GetLineNum( nStt1++ ));
|
||
|
||
else
|
||
{
|
||
ULONG c, d, b;
|
||
|
||
/* Find a point of correspondence in the middle of the files. */
|
||
|
||
d = CheckDiag( nStt1, nEnd1, nStt2, nEnd2, &c );
|
||
b = pBDiag[ d ];
|
||
|
||
if( 1 != c )
|
||
{
|
||
/* Use that point to split this problem into two subproblems. */
|
||
Compare( nStt1, b, nStt2, b - d );
|
||
/* This used to use f instead of b,
|
||
but that is incorrect!
|
||
It is not necessarily the case that diagonal d
|
||
has a snake from b to f. */
|
||
Compare( b, nEnd1, b - d, nEnd2 );
|
||
}
|
||
}
|
||
}
|
||
|
||
ULONG Compare::CompareSequence::CheckDiag( ULONG nStt1, ULONG nEnd1,
|
||
ULONG nStt2, ULONG nEnd2, ULONG* pCost )
|
||
{
|
||
const long dmin = nStt1 - nEnd2; /* Minimum valid diagonal. */
|
||
const long dmax = nEnd1 - nStt2; /* Maximum valid diagonal. */
|
||
const long fmid = nStt1 - nStt2; /* Center diagonal of top-down search. */
|
||
const long bmid = nEnd1 - nEnd2; /* Center diagonal of bottom-up search. */
|
||
|
||
long fmin = fmid, fmax = fmid; /* Limits of top-down search. */
|
||
long bmin = bmid, bmax = bmid; /* Limits of bottom-up search. */
|
||
|
||
long c; /* Cost. */
|
||
long odd = (fmid - bmid) & 1; /* True if southeast corner is on an odd
|
||
diagonal with respect to the northwest. */
|
||
|
||
pFDiag[fmid] = nStt1;
|
||
pBDiag[bmid] = nEnd1;
|
||
|
||
for (c = 1;; ++c)
|
||
{
|
||
long d; /* Active diagonal. */
|
||
long big_snake = 0;
|
||
|
||
/* Extend the top-down search by an edit step in each diagonal. */
|
||
fmin > dmin ? pFDiag[--fmin - 1] = -1 : ++fmin;
|
||
fmax < dmax ? pFDiag[++fmax + 1] = -1 : --fmax;
|
||
for (d = fmax; d >= fmin; d -= 2)
|
||
{
|
||
long x, y, oldx, tlo = pFDiag[d - 1], thi = pFDiag[d + 1];
|
||
|
||
if (tlo >= thi)
|
||
x = tlo + 1;
|
||
else
|
||
x = thi;
|
||
oldx = x;
|
||
y = x - d;
|
||
while( ULONG(x) < nEnd1 && ULONG(y) < nEnd2 &&
|
||
rMoved1.GetIndex( x ) == rMoved2.GetIndex( y ))
|
||
++x, ++y;
|
||
if (x - oldx > 20)
|
||
big_snake = 1;
|
||
pFDiag[d] = x;
|
||
if( odd && bmin <= d && d <= bmax && pBDiag[d] <= pFDiag[d] )
|
||
{
|
||
*pCost = 2 * c - 1;
|
||
return d;
|
||
}
|
||
}
|
||
|
||
/* Similar extend the bottom-up search. */
|
||
bmin > dmin ? pBDiag[--bmin - 1] = INT_MAX : ++bmin;
|
||
bmax < dmax ? pBDiag[++bmax + 1] = INT_MAX : --bmax;
|
||
for (d = bmax; d >= bmin; d -= 2)
|
||
{
|
||
long x, y, oldx, tlo = pBDiag[d - 1], thi = pBDiag[d + 1];
|
||
|
||
if (tlo < thi)
|
||
x = tlo;
|
||
else
|
||
x = thi - 1;
|
||
oldx = x;
|
||
y = x - d;
|
||
while( ULONG(x) > nStt1 && ULONG(y) > nStt2 &&
|
||
rMoved1.GetIndex( x - 1 ) == rMoved2.GetIndex( y - 1 ))
|
||
--x, --y;
|
||
if (oldx - x > 20)
|
||
big_snake = 1;
|
||
pBDiag[d] = x;
|
||
if (!odd && fmin <= d && d <= fmax && pBDiag[d] <= pFDiag[d])
|
||
{
|
||
*pCost = 2 * c;
|
||
return d;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void Compare::ShiftBoundaries( CompareData& rData1, CompareData& rData2 )
|
||
{
|
||
for( int iz = 0; iz < 2; ++iz )
|
||
{
|
||
CompareData* pData = &rData1;
|
||
CompareData* pOtherData = &rData2;
|
||
|
||
ULONG i = 0;
|
||
ULONG j = 0;
|
||
ULONG i_end = pData->GetLineCount();
|
||
ULONG preceding = ULONG_MAX;
|
||
ULONG other_preceding = ULONG_MAX;
|
||
|
||
while (1)
|
||
{
|
||
ULONG start, other_start;
|
||
|
||
/* Scan forwards to find beginning of another run of changes.
|
||
Also keep track of the corresponding point in the other file. */
|
||
|
||
while( i < i_end && !pData->GetChanged( i ) )
|
||
{
|
||
while( pOtherData->GetChanged( j++ ))
|
||
/* Non-corresponding lines in the other file
|
||
will count as the preceding batch of changes. */
|
||
other_preceding = j;
|
||
i++;
|
||
}
|
||
|
||
if (i == i_end)
|
||
break;
|
||
|
||
start = i;
|
||
other_start = j;
|
||
|
||
while (1)
|
||
{
|
||
/* Now find the end of this run of changes. */
|
||
|
||
while( pData->GetChanged( ++i ))
|
||
;
|
||
|
||
/* If the first changed line matches the following unchanged one,
|
||
and this run does not follow right after a previous run,
|
||
and there are no lines deleted from the other file here,
|
||
then classify the first changed line as unchanged
|
||
and the following line as changed in its place. */
|
||
|
||
/* You might ask, how could this run follow right after another?
|
||
Only because the previous run was shifted here. */
|
||
|
||
if( i != i_end &&
|
||
pData->GetIndex( start ) == pData->GetIndex( i ) &&
|
||
!pOtherData->GetChanged( j ) &&
|
||
!( start == preceding || other_start == other_preceding ))
|
||
{
|
||
pData->SetChanged( start++, 0 );
|
||
pData->SetChanged( i );
|
||
/* Since one line-that-matches is now before this run
|
||
instead of after, we must advance in the other file
|
||
to keep in synch. */
|
||
++j;
|
||
}
|
||
else
|
||
break;
|
||
}
|
||
|
||
preceding = i;
|
||
other_preceding = j;
|
||
}
|
||
|
||
pData = &rData2;
|
||
pOtherData = &rData1;
|
||
}
|
||
}
|
||
|
||
/* */
|
||
|
||
class SwCompareLine : public CompareLine
|
||
{
|
||
const SwNode& rNode;
|
||
public:
|
||
SwCompareLine( const SwNode& rNd );
|
||
virtual ~SwCompareLine();
|
||
|
||
virtual ULONG GetHashValue() const;
|
||
virtual BOOL Compare( const CompareLine& rLine ) const;
|
||
|
||
static ULONG GetTxtNodeHashValue( const SwTxtNode& rNd, ULONG nVal );
|
||
static BOOL CompareNode( const SwNode& rDstNd, const SwNode& rSrcNd );
|
||
static BOOL CompareTxtNd( const SwTxtNode& rDstNd,
|
||
const SwTxtNode& rSrcNd );
|
||
|
||
BOOL ChangesInLine( const SwCompareLine& rLine,
|
||
SwPaM *& rpInsRing, SwPaM*& rpDelRing ) const;
|
||
|
||
const SwNode& GetNode() const { return rNode; }
|
||
|
||
const SwNode& GetEndNode() const;
|
||
|
||
// fuers Debugging!
|
||
String GetText() const;
|
||
};
|
||
|
||
class SwCompareData : public CompareData
|
||
{
|
||
SwDoc& rDoc;
|
||
SwPaM *pInsRing, *pDelRing;
|
||
|
||
ULONG PrevIdx( const SwNode* pNd );
|
||
ULONG NextIdx( const SwNode* pNd );
|
||
|
||
virtual void CheckRanges( CompareData& );
|
||
virtual void ShowInsert( ULONG nStt, ULONG nEnd );
|
||
virtual void ShowDelete( const CompareData& rData, ULONG nStt,
|
||
ULONG nEnd, ULONG nInsPos );
|
||
|
||
virtual void CheckForChangesInLine( const CompareData& rData,
|
||
ULONG& nStt, ULONG& nEnd,
|
||
ULONG& nThisStt, ULONG& nThisEnd );
|
||
|
||
public:
|
||
SwCompareData( SwDoc& rD ) : rDoc( rD ), pInsRing(0), pDelRing(0) {}
|
||
virtual ~SwCompareData();
|
||
|
||
void SetRedlinesToDoc( BOOL bUseDocInfo );
|
||
};
|
||
|
||
// ----------------------------------------------------------------
|
||
|
||
SwCompareLine::SwCompareLine( const SwNode& rNd )
|
||
: rNode( rNd )
|
||
{
|
||
}
|
||
|
||
SwCompareLine::~SwCompareLine()
|
||
{
|
||
}
|
||
|
||
ULONG SwCompareLine::GetHashValue() const
|
||
{
|
||
ULONG nRet = 0;
|
||
switch( rNode.GetNodeType() )
|
||
{
|
||
case ND_TEXTNODE:
|
||
nRet = GetTxtNodeHashValue( (SwTxtNode&)rNode, nRet );
|
||
break;
|
||
|
||
case ND_TABLENODE:
|
||
{
|
||
const SwNode* pEndNd = rNode.EndOfSectionNode();
|
||
SwNodeIndex aIdx( rNode );
|
||
while( &aIdx.GetNode() != pEndNd )
|
||
{
|
||
if( aIdx.GetNode().IsTxtNode() )
|
||
nRet = GetTxtNodeHashValue( (SwTxtNode&)aIdx.GetNode(), nRet );
|
||
aIdx++;
|
||
}
|
||
}
|
||
break;
|
||
|
||
case ND_SECTIONNODE:
|
||
{
|
||
String sStr( GetText() );
|
||
for( xub_StrLen n = 0; n < sStr.Len(); ++n )
|
||
( nRet <<= 1 ) += sStr.GetChar( n );
|
||
}
|
||
break;
|
||
|
||
case ND_GRFNODE:
|
||
case ND_OLENODE:
|
||
// feste Id ? sollte aber nie auftauchen
|
||
break;
|
||
}
|
||
return nRet;
|
||
}
|
||
|
||
const SwNode& SwCompareLine::GetEndNode() const
|
||
{
|
||
const SwNode* pNd = &rNode;
|
||
switch( rNode.GetNodeType() )
|
||
{
|
||
case ND_TABLENODE:
|
||
pNd = rNode.EndOfSectionNode();
|
||
break;
|
||
|
||
case ND_SECTIONNODE:
|
||
{
|
||
const SwSectionNode& rSNd = (SwSectionNode&)rNode;
|
||
const SwSection& rSect = rSNd.GetSection();
|
||
if( CONTENT_SECTION != rSect.GetType() || rSect.IsProtect() )
|
||
pNd = rNode.EndOfSectionNode();
|
||
}
|
||
break;
|
||
}
|
||
return *pNd;
|
||
}
|
||
|
||
BOOL SwCompareLine::Compare( const CompareLine& rLine ) const
|
||
{
|
||
return CompareNode( rNode, ((SwCompareLine&)rLine).rNode );
|
||
}
|
||
|
||
BOOL SwCompareLine::CompareNode( const SwNode& rDstNd, const SwNode& rSrcNd )
|
||
{
|
||
if( rSrcNd.GetNodeType() != rDstNd.GetNodeType() )
|
||
return FALSE;
|
||
|
||
BOOL bRet = FALSE;
|
||
|
||
switch( rDstNd.GetNodeType() )
|
||
{
|
||
case ND_TEXTNODE:
|
||
bRet = CompareTxtNd( (SwTxtNode&)rDstNd, (SwTxtNode&)rSrcNd );
|
||
break;
|
||
|
||
case ND_TABLENODE:
|
||
{
|
||
const SwTableNode& rTSrcNd = (SwTableNode&)rSrcNd;
|
||
const SwTableNode& rTDstNd = (SwTableNode&)rDstNd;
|
||
|
||
bRet = ( rTSrcNd.EndOfSectionIndex() - rTSrcNd.GetIndex() ) ==
|
||
( rTDstNd.EndOfSectionIndex() - rTDstNd.GetIndex() );
|
||
}
|
||
break;
|
||
|
||
case ND_SECTIONNODE:
|
||
{
|
||
const SwSectionNode& rSSrcNd = (SwSectionNode&)rSrcNd,
|
||
& rSDstNd = (SwSectionNode&)rDstNd;
|
||
const SwSection& rSrcSect = rSSrcNd.GetSection(),
|
||
& rDstSect = rSDstNd.GetSection();
|
||
SectionType eSrcSectType = rSrcSect.GetType(),
|
||
eDstSectType = rDstSect.GetType();
|
||
switch( eSrcSectType )
|
||
{
|
||
case CONTENT_SECTION:
|
||
bRet = CONTENT_SECTION == eDstSectType &&
|
||
rSrcSect.IsProtect() == rDstSect.IsProtect();
|
||
if( bRet && rSrcSect.IsProtect() )
|
||
{
|
||
// the only have they both the same size
|
||
bRet = ( rSSrcNd.EndOfSectionIndex() - rSSrcNd.GetIndex() ) ==
|
||
( rSDstNd.EndOfSectionIndex() - rSDstNd.GetIndex() );
|
||
}
|
||
break;
|
||
|
||
case TOX_HEADER_SECTION:
|
||
case TOX_CONTENT_SECTION:
|
||
if( TOX_HEADER_SECTION == eDstSectType ||
|
||
TOX_CONTENT_SECTION == eDstSectType )
|
||
{
|
||
// the same type of TOX?
|
||
const SwTOXBase* pSrcTOX = rSrcSect.GetTOXBase();
|
||
const SwTOXBase* pDstTOX = rDstSect.GetTOXBase();
|
||
bRet = pSrcTOX && pDstTOX
|
||
&& pSrcTOX->GetType() == pDstTOX->GetType()
|
||
&& pSrcTOX->GetTitle() == pDstTOX->GetTitle()
|
||
&& pSrcTOX->GetTypeName() == pDstTOX->GetTypeName()
|
||
// && pSrcTOX->GetTOXName() == pDstTOX->GetTOXName()
|
||
;
|
||
}
|
||
break;
|
||
|
||
case DDE_LINK_SECTION:
|
||
case FILE_LINK_SECTION:
|
||
bRet = eSrcSectType == eDstSectType &&
|
||
rSrcSect.GetLinkFileName() ==
|
||
rDstSect.GetLinkFileName();
|
||
break;
|
||
}
|
||
}
|
||
break;
|
||
|
||
case ND_ENDNODE:
|
||
bRet = rSrcNd.StartOfSectionNode()->GetNodeType() ==
|
||
rDstNd.StartOfSectionNode()->GetNodeType();
|
||
break;
|
||
}
|
||
return bRet;
|
||
}
|
||
|
||
String SwCompareLine::GetText() const
|
||
{
|
||
String sRet;
|
||
switch( rNode.GetNodeType() )
|
||
{
|
||
case ND_TEXTNODE:
|
||
sRet = ((SwTxtNode&)rNode).GetExpandTxt();
|
||
break;
|
||
|
||
case ND_TABLENODE:
|
||
{
|
||
const SwNode* pEndNd = rNode.EndOfSectionNode();
|
||
SwNodeIndex aIdx( rNode );
|
||
while( &aIdx.GetNode() != pEndNd )
|
||
{
|
||
if( aIdx.GetNode().IsTxtNode() )
|
||
{
|
||
if( sRet.Len() )
|
||
sRet.Append( '\n' );
|
||
sRet.Append( ((SwTxtNode&)rNode).GetExpandTxt() );
|
||
}
|
||
aIdx++;
|
||
}
|
||
sRet.InsertAscii( "Tabelle: ", 0 );
|
||
}
|
||
break;
|
||
|
||
case ND_SECTIONNODE:
|
||
{
|
||
sRet.AssignAscii( RTL_CONSTASCII_STRINGPARAM( "Section - Node:" ));
|
||
|
||
const SwSectionNode& rSNd = (SwSectionNode&)rNode;
|
||
const SwSection& rSect = rSNd.GetSection();
|
||
switch( rSect.GetType() )
|
||
{
|
||
case CONTENT_SECTION:
|
||
if( rSect.IsProtect() )
|
||
sRet.Append( String::CreateFromInt32(
|
||
rSNd.EndOfSectionIndex() - rSNd.GetIndex() ));
|
||
break;
|
||
|
||
case TOX_HEADER_SECTION:
|
||
case TOX_CONTENT_SECTION:
|
||
{
|
||
const SwTOXBase* pTOX = rSect.GetTOXBase();
|
||
if( pTOX )
|
||
sRet.Append( pTOX->GetTitle() )
|
||
.Append( pTOX->GetTypeName() )
|
||
// .Append( pTOX->GetTOXName() )
|
||
.Append( String::CreateFromInt32( pTOX->GetType() ));
|
||
}
|
||
break;
|
||
|
||
case DDE_LINK_SECTION:
|
||
case FILE_LINK_SECTION:
|
||
sRet += rSect.GetLinkFileName();
|
||
break;
|
||
}
|
||
}
|
||
break;
|
||
|
||
case ND_GRFNODE:
|
||
sRet.AssignAscii( RTL_CONSTASCII_STRINGPARAM( "Grafik - Node:" ));
|
||
break;
|
||
case ND_OLENODE:
|
||
sRet.AssignAscii( RTL_CONSTASCII_STRINGPARAM( "OLE - Node:" ));
|
||
break;
|
||
}
|
||
return sRet;
|
||
}
|
||
|
||
ULONG SwCompareLine::GetTxtNodeHashValue( const SwTxtNode& rNd, ULONG nVal )
|
||
{
|
||
String sStr( rNd.GetExpandTxt() );
|
||
for( xub_StrLen n = 0; n < sStr.Len(); ++n )
|
||
( nVal <<= 1 ) += sStr.GetChar( n );
|
||
return nVal;
|
||
}
|
||
|
||
BOOL SwCompareLine::CompareTxtNd( const SwTxtNode& rDstNd,
|
||
const SwTxtNode& rSrcNd )
|
||
{
|
||
BOOL bRet = FALSE;
|
||
// erstmal ganz einfach!
|
||
if( rDstNd.GetTxt() == rSrcNd.GetTxt() )
|
||
{
|
||
// der Text ist gleich, aber sind die "Sonderattribute" (0xFF) auch
|
||
// dieselben??
|
||
bRet = TRUE;
|
||
}
|
||
return bRet;
|
||
}
|
||
|
||
BOOL SwCompareLine::ChangesInLine( const SwCompareLine& rLine,
|
||
SwPaM *& rpInsRing, SwPaM*& rpDelRing ) const
|
||
{
|
||
BOOL bRet = FALSE;
|
||
if( ND_TEXTNODE == rNode.GetNodeType() &&
|
||
ND_TEXTNODE == rLine.GetNode().GetNodeType() )
|
||
{
|
||
SwTxtNode& rDestNd = *(SwTxtNode*)rNode.GetTxtNode();
|
||
const SwTxtNode& rSrcNd = *rLine.GetNode().GetTxtNode();
|
||
|
||
xub_StrLen nDEnd = rDestNd.GetTxt().Len(), nSEnd = rSrcNd.GetTxt().Len();
|
||
xub_StrLen nStt;
|
||
xub_StrLen nEnd;
|
||
|
||
for( nStt = 0, nEnd = Min( nDEnd, nSEnd ); nStt < nEnd; ++nStt )
|
||
if( rDestNd.GetTxt().GetChar( nStt ) !=
|
||
rSrcNd.GetTxt().GetChar( nStt ) )
|
||
break;
|
||
|
||
while( nStt < nDEnd && nStt < nSEnd )
|
||
{
|
||
--nDEnd, --nSEnd;
|
||
if( rDestNd.GetTxt().GetChar( nDEnd ) !=
|
||
rSrcNd.GetTxt().GetChar( nSEnd ) )
|
||
{
|
||
++nDEnd, ++nSEnd;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if( nStt || !nDEnd || !nSEnd || nDEnd < rDestNd.GetTxt().Len() ||
|
||
nSEnd < rSrcNd.GetTxt().Len() )
|
||
{
|
||
// jetzt ist zwischen nStt bis nDEnd das neu eingefuegte
|
||
// und zwischen nStt und nSEnd das geloeschte
|
||
SwDoc* pDoc = rDestNd.GetDoc();
|
||
SwPaM aPam( rDestNd, nDEnd );
|
||
if( nStt != nDEnd )
|
||
{
|
||
SwPaM* pTmp = new SwPaM( *aPam.GetPoint(), rpInsRing );
|
||
if( !rpInsRing )
|
||
rpInsRing = pTmp;
|
||
|
||
pTmp->SetMark();
|
||
pTmp->GetMark()->nContent = nStt;
|
||
}
|
||
|
||
if( nStt != nSEnd )
|
||
{
|
||
{
|
||
BOOL bUndo = pDoc->DoesUndo();
|
||
pDoc->DoUndo( FALSE );
|
||
SwPaM aCpyPam( rSrcNd, nStt );
|
||
aCpyPam.SetMark();
|
||
aCpyPam.GetPoint()->nContent = nSEnd;
|
||
aCpyPam.GetDoc()->Copy( aCpyPam, *aPam.GetPoint(), false );
|
||
pDoc->DoUndo( bUndo );
|
||
}
|
||
|
||
SwPaM* pTmp = new SwPaM( *aPam.GetPoint(), rpDelRing );
|
||
if( !rpDelRing )
|
||
rpDelRing = pTmp;
|
||
|
||
pTmp->SetMark();
|
||
pTmp->GetMark()->nContent = nDEnd;
|
||
|
||
if( rpInsRing )
|
||
{
|
||
SwPaM* pCorr = (SwPaM*)rpInsRing->GetPrev();
|
||
if( *pCorr->GetPoint() == *pTmp->GetPoint() )
|
||
*pCorr->GetPoint() = *pTmp->GetMark();
|
||
}
|
||
}
|
||
bRet = TRUE;
|
||
}
|
||
}
|
||
return bRet;
|
||
}
|
||
|
||
// ----------------------------------------------------------------
|
||
|
||
SwCompareData::~SwCompareData()
|
||
{
|
||
if( pDelRing )
|
||
{
|
||
while( pDelRing->GetNext() != pDelRing )
|
||
delete pDelRing->GetNext();
|
||
delete pDelRing;
|
||
}
|
||
if( pInsRing )
|
||
{
|
||
while( pInsRing->GetNext() != pInsRing )
|
||
delete pInsRing->GetNext();
|
||
delete pInsRing;
|
||
}
|
||
}
|
||
|
||
ULONG SwCompareData::NextIdx( const SwNode* pNd )
|
||
{
|
||
if( pNd->IsStartNode() )
|
||
{
|
||
const SwSectionNode* pSNd;
|
||
if( pNd->IsTableNode() ||
|
||
( 0 != (pSNd = pNd->GetSectionNode() ) &&
|
||
( CONTENT_SECTION != pSNd->GetSection().GetType() ||
|
||
pSNd->GetSection().IsProtect() ) ) )
|
||
pNd = pNd->EndOfSectionNode();
|
||
}
|
||
return pNd->GetIndex() + 1;
|
||
}
|
||
|
||
ULONG SwCompareData::PrevIdx( const SwNode* pNd )
|
||
{
|
||
if( pNd->IsEndNode() )
|
||
{
|
||
const SwSectionNode* pSNd;
|
||
if( pNd->StartOfSectionNode()->IsTableNode() ||
|
||
( 0 != (pSNd = pNd->StartOfSectionNode()->GetSectionNode() ) &&
|
||
( CONTENT_SECTION != pSNd->GetSection().GetType() ||
|
||
pSNd->GetSection().IsProtect() ) ) )
|
||
pNd = pNd->StartOfSectionNode();
|
||
}
|
||
return pNd->GetIndex() - 1;
|
||
}
|
||
|
||
|
||
void SwCompareData::CheckRanges( CompareData& rData )
|
||
{
|
||
const SwNodes& rSrcNds = ((SwCompareData&)rData).rDoc.GetNodes();
|
||
const SwNodes& rDstNds = rDoc.GetNodes();
|
||
|
||
const SwNode& rSrcEndNd = rSrcNds.GetEndOfContent();
|
||
const SwNode& rDstEndNd = rDstNds.GetEndOfContent();
|
||
|
||
ULONG nSrcSttIdx = NextIdx( rSrcEndNd.StartOfSectionNode() );
|
||
ULONG nSrcEndIdx = rSrcEndNd.GetIndex();
|
||
|
||
ULONG nDstSttIdx = NextIdx( rDstEndNd.StartOfSectionNode() );
|
||
ULONG nDstEndIdx = rDstEndNd.GetIndex();
|
||
|
||
while( nSrcSttIdx < nSrcEndIdx && nDstSttIdx < nDstEndIdx )
|
||
{
|
||
const SwNode* pSrcNd = rSrcNds[ nSrcSttIdx ];
|
||
const SwNode* pDstNd = rDstNds[ nDstSttIdx ];
|
||
if( !SwCompareLine::CompareNode( *pSrcNd, *pDstNd ))
|
||
break;
|
||
|
||
nSrcSttIdx = NextIdx( pSrcNd );
|
||
nDstSttIdx = NextIdx( pDstNd );
|
||
}
|
||
|
||
nSrcEndIdx = PrevIdx( &rSrcEndNd );
|
||
nDstEndIdx = PrevIdx( &rDstEndNd );
|
||
while( nSrcSttIdx < nSrcEndIdx && nDstSttIdx < nDstEndIdx )
|
||
{
|
||
const SwNode* pSrcNd = rSrcNds[ nSrcEndIdx ];
|
||
const SwNode* pDstNd = rDstNds[ nDstEndIdx ];
|
||
if( !SwCompareLine::CompareNode( *pSrcNd, *pDstNd ))
|
||
break;
|
||
|
||
nSrcEndIdx = PrevIdx( pSrcNd );
|
||
nDstEndIdx = PrevIdx( pDstNd );
|
||
}
|
||
|
||
while( nSrcSttIdx <= nSrcEndIdx )
|
||
{
|
||
const SwNode* pNd = rSrcNds[ nSrcSttIdx ];
|
||
rData.InsertLine( new SwCompareLine( *pNd ) );
|
||
nSrcSttIdx = NextIdx( pNd );
|
||
}
|
||
|
||
while( nDstSttIdx <= nDstEndIdx )
|
||
{
|
||
const SwNode* pNd = rDstNds[ nDstSttIdx ];
|
||
InsertLine( new SwCompareLine( *pNd ) );
|
||
nDstSttIdx = NextIdx( pNd );
|
||
}
|
||
}
|
||
|
||
|
||
void SwCompareData::ShowInsert( ULONG nStt, ULONG nEnd )
|
||
{
|
||
SwPaM* pTmp = new SwPaM( ((SwCompareLine*)GetLine( nStt ))->GetNode(), 0,
|
||
((SwCompareLine*)GetLine( nEnd-1 ))->GetEndNode(), 0,
|
||
pInsRing );
|
||
if( !pInsRing )
|
||
pInsRing = pTmp;
|
||
|
||
// #i65201#: These SwPaMs are calculated smaller than needed, see comment below
|
||
|
||
}
|
||
|
||
void SwCompareData::ShowDelete( const CompareData& rData, ULONG nStt,
|
||
ULONG nEnd, ULONG nInsPos )
|
||
{
|
||
SwNodeRange aRg(
|
||
((SwCompareLine*)rData.GetLine( nStt ))->GetNode(), 0,
|
||
((SwCompareLine*)rData.GetLine( nEnd-1 ))->GetEndNode(), 1 );
|
||
|
||
USHORT nOffset = 0;
|
||
const CompareLine* pLine;
|
||
if( GetLineCount() == nInsPos )
|
||
{
|
||
pLine = GetLine( nInsPos-1 );
|
||
nOffset = 1;
|
||
}
|
||
else
|
||
pLine = GetLine( nInsPos );
|
||
|
||
const SwNode* pLineNd;
|
||
if( pLine )
|
||
{
|
||
if( nOffset )
|
||
pLineNd = &((SwCompareLine*)pLine)->GetEndNode();
|
||
else
|
||
pLineNd = &((SwCompareLine*)pLine)->GetNode();
|
||
}
|
||
else
|
||
{
|
||
pLineNd = &rDoc.GetNodes().GetEndOfContent();
|
||
nOffset = 0;
|
||
}
|
||
|
||
SwNodeIndex aInsPos( *pLineNd, nOffset );
|
||
SwNodeIndex aSavePos( aInsPos, -1 );
|
||
|
||
((SwCompareData&)rData).rDoc.CopyWithFlyInFly( aRg, 0, aInsPos );
|
||
rDoc.SetModified();
|
||
aSavePos++;
|
||
|
||
// #i65201#: These SwPaMs are calculated when the (old) delete-redlines are hidden,
|
||
// they will be inserted when the delete-redlines are shown again.
|
||
// To avoid unwanted insertions of delete-redlines into these new redlines, what happens
|
||
// especially at the end of the document, I reduce the SwPaM by one node.
|
||
// Before the new redlines are inserted, they have to expand again.
|
||
SwPaM* pTmp = new SwPaM( aSavePos.GetNode(), aInsPos.GetNode(), 0, -1, pDelRing );
|
||
if( !pDelRing )
|
||
pDelRing = pTmp;
|
||
|
||
if( pInsRing )
|
||
{
|
||
SwPaM* pCorr = (SwPaM*)pInsRing->GetPrev();
|
||
if( *pCorr->GetPoint() == *pTmp->GetPoint() )
|
||
{
|
||
SwNodeIndex aTmpPos( pTmp->GetMark()->nNode, -1 );
|
||
*pCorr->GetPoint() = SwPosition( aTmpPos, 0 );
|
||
}
|
||
}
|
||
}
|
||
|
||
void SwCompareData::CheckForChangesInLine( const CompareData& rData,
|
||
ULONG& rStt, ULONG& rEnd,
|
||
ULONG& rThisStt, ULONG& rThisEnd )
|
||
{
|
||
while( rStt < rEnd && rThisStt < rThisEnd )
|
||
{
|
||
SwCompareLine* pDstLn = (SwCompareLine*)GetLine( rThisStt );
|
||
SwCompareLine* pSrcLn = (SwCompareLine*)rData.GetLine( rStt );
|
||
if( !pDstLn->ChangesInLine( *pSrcLn, pInsRing, pDelRing ) )
|
||
break;
|
||
|
||
++rStt;
|
||
++rThisStt;
|
||
}
|
||
}
|
||
|
||
void SwCompareData::SetRedlinesToDoc( BOOL bUseDocInfo )
|
||
{
|
||
SwPaM* pTmp = pDelRing;
|
||
|
||
// Bug #83296#: get the Author / TimeStamp from the "other"
|
||
// document info
|
||
USHORT nAuthor = rDoc.GetRedlineAuthor();
|
||
DateTime aTimeStamp;
|
||
SwDocShell *pDocShell(rDoc.GetDocShell());
|
||
DBG_ASSERT(pDocShell, "no SwDocShell");
|
||
if (pDocShell) {
|
||
uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
|
||
pDocShell->GetModel(), uno::UNO_QUERY_THROW);
|
||
uno::Reference<document::XDocumentProperties> xDocProps(
|
||
xDPS->getDocumentProperties());
|
||
DBG_ASSERT(xDocProps.is(), "Doc has no DocumentProperties");
|
||
|
||
if( bUseDocInfo && xDocProps.is() ) {
|
||
String aTmp( 1 == xDocProps->getEditingCycles()
|
||
? xDocProps->getAuthor()
|
||
: xDocProps->getModifiedBy() );
|
||
util::DateTime uDT( 1 == xDocProps->getEditingCycles()
|
||
? xDocProps->getCreationDate()
|
||
: xDocProps->getModificationDate() );
|
||
Date d(uDT.Day, uDT.Month, uDT.Year);
|
||
Time t(uDT.Hours, uDT.Minutes, uDT.Seconds, uDT.HundredthSeconds);
|
||
DateTime aDT(d,t);
|
||
|
||
if( aTmp.Len() )
|
||
{
|
||
nAuthor = rDoc.InsertRedlineAuthor( aTmp );
|
||
aTimeStamp = aDT;
|
||
}
|
||
}
|
||
}
|
||
|
||
if( pTmp )
|
||
{
|
||
SwRedlineData aRedlnData( nsRedlineType_t::REDLINE_DELETE, nAuthor, aTimeStamp,
|
||
aEmptyStr, 0, 0 );
|
||
do {
|
||
// #i65201#: Expand again, see comment above.
|
||
if( pTmp->GetPoint()->nContent == 0 )
|
||
{
|
||
pTmp->GetPoint()->nNode++;
|
||
pTmp->GetPoint()->nContent.Assign( pTmp->GetCntntNode(), 0 );
|
||
}
|
||
|
||
rDoc.DeleteRedline( *pTmp, false, USHRT_MAX );
|
||
|
||
if( rDoc.DoesUndo() )
|
||
rDoc.AppendUndo( new SwUndoCompDoc( *pTmp, FALSE ));
|
||
rDoc.AppendRedline( new SwRedline( aRedlnData, *pTmp ), true );
|
||
|
||
} while( pDelRing != ( pTmp = (SwPaM*)pTmp->GetNext() ));
|
||
}
|
||
|
||
pTmp = pInsRing;
|
||
if( pTmp )
|
||
{
|
||
do {
|
||
if( pTmp->GetPoint()->nContent == 0 )
|
||
{
|
||
pTmp->GetPoint()->nNode++;
|
||
pTmp->GetPoint()->nContent.Assign( pTmp->GetCntntNode(), 0 );
|
||
}
|
||
} while( pInsRing != ( pTmp = (SwPaM*)pTmp->GetNext() ));
|
||
SwRedlineData aRedlnData( nsRedlineType_t::REDLINE_INSERT, nAuthor, aTimeStamp,
|
||
aEmptyStr, 0, 0 );
|
||
|
||
// zusammenhaengende zusammenfassen
|
||
if( pTmp->GetNext() != pInsRing )
|
||
{
|
||
const SwCntntNode* pCNd;
|
||
do {
|
||
SwPosition& rSttEnd = *pTmp->End(),
|
||
& rEndStt = *((SwPaM*)pTmp->GetNext())->Start();
|
||
if( rSttEnd == rEndStt ||
|
||
(!rEndStt.nContent.GetIndex() &&
|
||
rEndStt.nNode.GetIndex() - 1 == rSttEnd.nNode.GetIndex() &&
|
||
0 != ( pCNd = rSttEnd.nNode.GetNode().GetCntntNode() )
|
||
? rSttEnd.nContent.GetIndex() == pCNd->Len()
|
||
: 0 ))
|
||
{
|
||
if( pTmp->GetNext() == pInsRing )
|
||
{
|
||
// liegen hintereinander also zusammen fassen
|
||
rEndStt = *pTmp->Start();
|
||
delete pTmp;
|
||
pTmp = pInsRing;
|
||
}
|
||
else
|
||
{
|
||
// liegen hintereinander also zusammen fassen
|
||
rSttEnd = *((SwPaM*)pTmp->GetNext())->End();
|
||
delete pTmp->GetNext();
|
||
}
|
||
}
|
||
else
|
||
pTmp = (SwPaM*)pTmp->GetNext();
|
||
} while( pInsRing != pTmp );
|
||
}
|
||
|
||
do {
|
||
if( rDoc.AppendRedline( new SwRedline( aRedlnData, *pTmp ), true) &&
|
||
rDoc.DoesUndo() )
|
||
rDoc.AppendUndo( new SwUndoCompDoc( *pTmp, TRUE ));
|
||
} while( pInsRing != ( pTmp = (SwPaM*)pTmp->GetNext() ));
|
||
}
|
||
}
|
||
|
||
/* */
|
||
|
||
|
||
|
||
// returnt (?die Anzahl der Unterschiede?) ob etwas unterschiedlich ist
|
||
long SwDoc::CompareDoc( const SwDoc& rDoc )
|
||
{
|
||
if( &rDoc == this )
|
||
return 0;
|
||
|
||
long nRet = 0;
|
||
|
||
StartUndo(UNDO_EMPTY, NULL);
|
||
BOOL bDocWasModified = IsModified();
|
||
SwDoc& rSrcDoc = (SwDoc&)rDoc;
|
||
BOOL bSrcModified = rSrcDoc.IsModified();
|
||
|
||
RedlineMode_t eSrcRedlMode = rSrcDoc.GetRedlineMode();
|
||
rSrcDoc.SetRedlineMode( nsRedlineMode_t::REDLINE_SHOW_INSERT );
|
||
SetRedlineMode((RedlineMode_t)(nsRedlineMode_t::REDLINE_ON | nsRedlineMode_t::REDLINE_SHOW_INSERT));
|
||
|
||
SwCompareData aD0( rSrcDoc );
|
||
SwCompareData aD1( *this );
|
||
|
||
aD1.CompareLines( aD0 );
|
||
|
||
nRet = aD1.ShowDiffs( aD0 );
|
||
|
||
if( nRet )
|
||
{
|
||
SetRedlineMode((RedlineMode_t)(nsRedlineMode_t::REDLINE_ON |
|
||
nsRedlineMode_t::REDLINE_SHOW_INSERT | nsRedlineMode_t::REDLINE_SHOW_DELETE));
|
||
|
||
aD1.SetRedlinesToDoc( !bDocWasModified );
|
||
SetModified();
|
||
}
|
||
|
||
rSrcDoc.SetRedlineMode( eSrcRedlMode );
|
||
SetRedlineMode((RedlineMode_t)(nsRedlineMode_t::REDLINE_SHOW_INSERT | nsRedlineMode_t::REDLINE_SHOW_DELETE));
|
||
|
||
if( !bSrcModified )
|
||
rSrcDoc.ResetModified();
|
||
|
||
EndUndo(UNDO_EMPTY, NULL);
|
||
|
||
return nRet;
|
||
}
|
||
|
||
|
||
typedef void (SwDoc::*FNInsUndo)( SwUndo* );
|
||
|
||
class _SaveMergeRedlines : public Ring
|
||
{
|
||
const SwRedline* pSrcRedl;
|
||
SwRedline* pDestRedl;
|
||
public:
|
||
_SaveMergeRedlines( const SwNode& rDstNd,
|
||
const SwRedline& rSrcRedl, Ring* pRing );
|
||
USHORT InsertRedline( FNInsUndo pFn );
|
||
|
||
SwRedline* GetDestRedline() { return pDestRedl; }
|
||
};
|
||
|
||
_SaveMergeRedlines::_SaveMergeRedlines( const SwNode& rDstNd,
|
||
const SwRedline& rSrcRedl, Ring* pRing )
|
||
: Ring( pRing ), pSrcRedl( &rSrcRedl )
|
||
{
|
||
SwPosition aPos( rDstNd );
|
||
|
||
const SwPosition* pStt = rSrcRedl.Start();
|
||
if( rDstNd.IsCntntNode() )
|
||
aPos.nContent.Assign( ((SwCntntNode*)&rDstNd), pStt->nContent.GetIndex() );
|
||
pDestRedl = new SwRedline( rSrcRedl.GetRedlineData(), aPos );
|
||
|
||
if( nsRedlineType_t::REDLINE_DELETE == pDestRedl->GetType() )
|
||
{
|
||
// den Bereich als geloescht kennzeichnen
|
||
const SwPosition* pEnd = pStt == rSrcRedl.GetPoint()
|
||
? rSrcRedl.GetMark()
|
||
: rSrcRedl.GetPoint();
|
||
|
||
pDestRedl->SetMark();
|
||
pDestRedl->GetPoint()->nNode += pEnd->nNode.GetIndex() -
|
||
pStt->nNode.GetIndex();
|
||
pDestRedl->GetPoint()->nContent.Assign( pDestRedl->GetCntntNode(),
|
||
pEnd->nContent.GetIndex() );
|
||
}
|
||
}
|
||
|
||
USHORT _SaveMergeRedlines::InsertRedline( FNInsUndo pFn )
|
||
{
|
||
USHORT nIns = 0;
|
||
SwDoc* pDoc = pDestRedl->GetDoc();
|
||
|
||
if( nsRedlineType_t::REDLINE_INSERT == pDestRedl->GetType() )
|
||
{
|
||
// der Teil wurde eingefuegt, also kopiere ihn aus dem SourceDoc
|
||
BOOL bUndo = pDoc->DoesUndo();
|
||
pDoc->DoUndo( FALSE );
|
||
|
||
SwNodeIndex aSaveNd( pDestRedl->GetPoint()->nNode, -1 );
|
||
xub_StrLen nSaveCnt = pDestRedl->GetPoint()->nContent.GetIndex();
|
||
|
||
RedlineMode_t eOld = pDoc->GetRedlineMode();
|
||
pDoc->SetRedlineMode_intern((RedlineMode_t)(eOld | nsRedlineMode_t::REDLINE_IGNORE));
|
||
|
||
pSrcRedl->GetDoc()->Copy( *(SwPaM*)pSrcRedl, *pDestRedl->GetPoint(), false );
|
||
|
||
pDoc->SetRedlineMode_intern( eOld );
|
||
pDoc->DoUndo( bUndo );
|
||
|
||
pDestRedl->SetMark();
|
||
aSaveNd++;
|
||
pDestRedl->GetMark()->nNode = aSaveNd;
|
||
pDestRedl->GetMark()->nContent.Assign( aSaveNd.GetNode().GetCntntNode(),
|
||
nSaveCnt );
|
||
|
||
if( GetPrev() != this )
|
||
{
|
||
SwPaM* pTmpPrev = ((_SaveMergeRedlines*)GetPrev())->pDestRedl;
|
||
if( pTmpPrev && *pTmpPrev->GetPoint() == *pDestRedl->GetPoint() )
|
||
*pTmpPrev->GetPoint() = *pDestRedl->GetMark();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//JP 21.09.98: Bug 55909
|
||
// falls im Doc auf gleicher Pos aber schon ein geloeschter oder
|
||
// eingefuegter ist, dann muss dieser gesplittet werden!
|
||
SwPosition* pDStt = pDestRedl->GetMark(),
|
||
* pDEnd = pDestRedl->GetPoint();
|
||
USHORT n = 0;
|
||
|
||
// zur StartPos das erste Redline suchen
|
||
if( !pDoc->GetRedline( *pDStt, &n ) && n )
|
||
--n;
|
||
|
||
const SwRedlineTbl& rRedlineTbl = pDoc->GetRedlineTbl();
|
||
for( ; n < rRedlineTbl.Count(); ++n )
|
||
{
|
||
SwRedline* pRedl = rRedlineTbl[ n ];
|
||
SwPosition* pRStt = pRedl->Start(),
|
||
* pREnd = pRStt == pRedl->GetPoint() ? pRedl->GetMark()
|
||
: pRedl->GetPoint();
|
||
if( nsRedlineType_t::REDLINE_DELETE == pRedl->GetType() ||
|
||
nsRedlineType_t::REDLINE_INSERT == pRedl->GetType() )
|
||
{
|
||
SwComparePosition eCmpPos = ComparePosition( *pDStt, *pDEnd, *pRStt, *pREnd );
|
||
switch( eCmpPos )
|
||
{
|
||
case POS_COLLIDE_START:
|
||
case POS_BEHIND:
|
||
break;
|
||
|
||
case POS_INSIDE:
|
||
case POS_EQUAL:
|
||
delete pDestRedl, pDestRedl = 0;
|
||
// break; -> kein break !!!!
|
||
|
||
case POS_COLLIDE_END:
|
||
case POS_BEFORE:
|
||
n = rRedlineTbl.Count();
|
||
break;
|
||
|
||
case POS_OUTSIDE:
|
||
{
|
||
SwRedline* pCpyRedl = new SwRedline(
|
||
pDestRedl->GetRedlineData(), *pDStt );
|
||
pCpyRedl->SetMark();
|
||
*pCpyRedl->GetPoint() = *pRStt;
|
||
|
||
SwUndoCompDoc* pUndo = pDoc->DoesUndo()
|
||
? new SwUndoCompDoc( *pCpyRedl ) : 0;
|
||
|
||
// now modify doc: append redline, undo (and count)
|
||
pDoc->AppendRedline( pCpyRedl, true );
|
||
if( pUndo )
|
||
(pDoc->*pFn)( pUndo );
|
||
++nIns;
|
||
|
||
*pDStt = *pREnd;
|
||
|
||
// dann solle man neu anfangen
|
||
n = USHRT_MAX;
|
||
}
|
||
break;
|
||
|
||
case POS_OVERLAP_BEFORE:
|
||
*pDEnd = *pRStt;
|
||
break;
|
||
|
||
case POS_OVERLAP_BEHIND:
|
||
*pDStt = *pREnd;
|
||
break;
|
||
}
|
||
}
|
||
else if( *pDEnd <= *pRStt )
|
||
break;
|
||
}
|
||
|
||
}
|
||
|
||
if( pDestRedl )
|
||
{
|
||
SwUndoCompDoc* pUndo = pDoc->DoesUndo() ? new SwUndoCompDoc( *pDestRedl ) : 0;
|
||
|
||
// now modify doc: append redline, undo (and count)
|
||
bool bRedlineAccepted = pDoc->AppendRedline( pDestRedl, true );
|
||
if( pUndo )
|
||
(pDoc->*pFn)( pUndo );
|
||
++nIns;
|
||
|
||
// if AppendRedline has deleted our redline, we may not keep a
|
||
// reference to it
|
||
if( ! bRedlineAccepted )
|
||
pDestRedl = NULL;
|
||
}
|
||
return nIns;
|
||
}
|
||
|
||
// merge zweier Dokumente
|
||
long SwDoc::MergeDoc( const SwDoc& rDoc )
|
||
{
|
||
if( &rDoc == this )
|
||
return 0;
|
||
|
||
long nRet = 0;
|
||
|
||
StartUndo(UNDO_EMPTY, NULL);
|
||
|
||
SwDoc& rSrcDoc = (SwDoc&)rDoc;
|
||
BOOL bSrcModified = rSrcDoc.IsModified();
|
||
|
||
RedlineMode_t eSrcRedlMode = rSrcDoc.GetRedlineMode();
|
||
rSrcDoc.SetRedlineMode( nsRedlineMode_t::REDLINE_SHOW_DELETE );
|
||
SetRedlineMode( nsRedlineMode_t::REDLINE_SHOW_DELETE );
|
||
|
||
SwCompareData aD0( rSrcDoc );
|
||
SwCompareData aD1( *this );
|
||
|
||
aD1.CompareLines( aD0 );
|
||
|
||
if( !aD1.HasDiffs( aD0 ) )
|
||
{
|
||
// jetzt wollen wir alle Redlines aus dem SourceDoc zu uns bekommen
|
||
|
||
// suche alle Insert - Redlines aus dem SourceDoc und bestimme
|
||
// deren Position im DestDoc
|
||
_SaveMergeRedlines* pRing = 0;
|
||
const SwRedlineTbl& rSrcRedlTbl = rSrcDoc.GetRedlineTbl();
|
||
ULONG nEndOfExtra = rSrcDoc.GetNodes().GetEndOfExtras().GetIndex();
|
||
ULONG nMyEndOfExtra = GetNodes().GetEndOfExtras().GetIndex();
|
||
for( USHORT n = 0; n < rSrcRedlTbl.Count(); ++n )
|
||
{
|
||
const SwRedline* pRedl = rSrcRedlTbl[ n ];
|
||
ULONG nNd = pRedl->GetPoint()->nNode.GetIndex();
|
||
RedlineType_t eType = pRedl->GetType();
|
||
if( nEndOfExtra < nNd &&
|
||
( nsRedlineType_t::REDLINE_INSERT == eType || nsRedlineType_t::REDLINE_DELETE == eType ))
|
||
{
|
||
const SwNode* pDstNd = GetNodes()[
|
||
nMyEndOfExtra + nNd - nEndOfExtra ];
|
||
|
||
// Position gefunden. Dann muss im DestDoc auch
|
||
// in der Line das Redline eingefuegt werden
|
||
_SaveMergeRedlines* pTmp = new _SaveMergeRedlines(
|
||
*pDstNd, *pRedl, pRing );
|
||
if( !pRing )
|
||
pRing = pTmp;
|
||
}
|
||
}
|
||
|
||
if( pRing )
|
||
{
|
||
// dann alle ins DestDoc ueber nehmen
|
||
rSrcDoc.SetRedlineMode((RedlineMode_t)(nsRedlineMode_t::REDLINE_SHOW_INSERT | nsRedlineMode_t::REDLINE_SHOW_DELETE));
|
||
|
||
SetRedlineMode((RedlineMode_t)(
|
||
nsRedlineMode_t::REDLINE_ON |
|
||
nsRedlineMode_t::REDLINE_SHOW_INSERT |
|
||
nsRedlineMode_t::REDLINE_SHOW_DELETE));
|
||
|
||
_SaveMergeRedlines* pTmp = pRing;
|
||
|
||
do {
|
||
nRet += pTmp->InsertRedline( &SwDoc::AppendUndo );
|
||
} while( pRing != ( pTmp = (_SaveMergeRedlines*)pTmp->GetNext() ));
|
||
|
||
while( pRing != pRing->GetNext() )
|
||
delete pRing->GetNext();
|
||
delete pRing;
|
||
}
|
||
}
|
||
|
||
rSrcDoc.SetRedlineMode( eSrcRedlMode );
|
||
if( !bSrcModified )
|
||
rSrcDoc.ResetModified();
|
||
|
||
SetRedlineMode((RedlineMode_t)(nsRedlineMode_t::REDLINE_SHOW_INSERT | nsRedlineMode_t::REDLINE_SHOW_DELETE));
|
||
|
||
EndUndo(UNDO_EMPTY, NULL);
|
||
|
||
return nRet;
|
||
}
|
||
|
||
|