xref: /aoo41x/main/sw/source/core/doc/docredln.cxx (revision 641de097)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sw.hxx"
26 
27 
28 #include <hintids.hxx>
29 #include <tools/shl.hxx>
30 #include <svl/itemiter.hxx>
31 #include <sfx2/app.hxx>
32 #include <editeng/colritem.hxx>
33 #include <editeng/udlnitem.hxx>
34 #include <editeng/crsditem.hxx>
35 #include <swmodule.hxx>
36 #include <doc.hxx>
37 #include <IDocumentUndoRedo.hxx>
38 #include <docary.hxx>
39 #include <ndtxt.hxx>
40 #include <redline.hxx>
41 #include <swundo.hxx>
42 #include <UndoCore.hxx>
43 #include <UndoRedline.hxx>
44 #include <hints.hxx>
45 #include <pamtyp.hxx>
46 #include <poolfmt.hxx>
47 #include <viewsh.hxx>
48 #include <rootfrm.hxx>
49 
50 #include <comcore.hrc>
51 
52 using namespace com::sun::star;
53 
54 TYPEINIT1(SwRedlineHint, SfxHint);
55 
56 #ifndef DBG_UTIL
57 
58 	#define _CHECK_REDLINE( pDoc )
59     #define _DEBUG_REDLINE( pDoc )
60 
61 #else
62 
63 #define _ERROR_PREFIX "redline table corrupted: "
64 
65     // helper function for lcl_CheckRedline
66     // 1. make sure that pPos->nContent points into pPos->nNode
67     //    (or into the 'special' no-content-node-IndexReg)
68     // 2. check that position is valid and doesn't point behind text
lcl_CheckPosition(const SwPosition * pPos)69     void lcl_CheckPosition( const SwPosition* pPos )
70     {
71         SwPosition aComparePos( *pPos );
72         aComparePos.nContent.Assign(
73             aComparePos.nNode.GetNode().GetCntntNode(), 0 );
74         DBG_ASSERT( pPos->nContent.GetIdxReg() ==
75                     aComparePos.nContent.GetIdxReg(),
76                     _ERROR_PREFIX "illegal position" );
77 
78         SwTxtNode* pTxtNode = pPos->nNode.GetNode().GetTxtNode();
79         if( pTxtNode == NULL )
80         {
81             DBG_ASSERT( pPos->nContent == 0,
82                         _ERROR_PREFIX "non-text-node with content" );
83         }
84         else
85         {
86             DBG_ASSERT( pPos->nContent >= 0  &&
87                         pPos->nContent <= pTxtNode->Len(),
88                         _ERROR_PREFIX "index behind text" );
89         }
90     }
91 
lcl_CheckPam(const SwPaM * pPam)92     void lcl_CheckPam( const SwPaM* pPam )
93     {
94         DBG_ASSERT( pPam != NULL, _ERROR_PREFIX "illegal argument" );
95         lcl_CheckPosition( pPam->GetPoint() );
96         lcl_CheckPosition( pPam->GetMark() );
97     }
98 
99     // check validity of the redline table. Checks redline bounds, and make
100     // sure the redlines are sorted and non-overlapping.
lcl_CheckRedline(const SwDoc * pDoc)101 	void lcl_CheckRedline( const SwDoc* pDoc )
102 	{
103 		const SwRedlineTbl& rTbl = pDoc->GetRedlineTbl();
104 
105         // verify valid redline positions
106 		for( sal_uInt16 i = 0; i < rTbl.Count(); ++i )
107             lcl_CheckPam( rTbl[ i ] );
108 
109         for( sal_uInt16 j = 0; j < rTbl.Count(); ++j )
110         {
111             // check for empty redlines
112             DBG_ASSERT( ( *(rTbl[j]->GetPoint()) != *(rTbl[j]->GetMark()) ) ||
113                         ( rTbl[j]->GetContentIdx() != NULL ),
114                         _ERROR_PREFIX "empty redline" );
115  		}
116 
117         // verify proper redline sorting
118 		for( sal_uInt16 n = 1; n < rTbl.Count(); ++n )
119 		{
120 			const SwRedline* pPrev = rTbl[ n-1 ];
121             const SwRedline* pCurrent = rTbl[ n ];
122 
123             // check redline sorting
124             DBG_ASSERT( *pPrev->Start() <= *pCurrent->Start(),
125                         _ERROR_PREFIX "not sorted correctly" );
126 
127             // check for overlapping redlines
128             DBG_ASSERT( *pPrev->End() <= *pCurrent->Start(),
129                         _ERROR_PREFIX "overlapping redlines" );
130 		}
131 	}
132 
133 	#define _CHECK_REDLINE( pDoc ) lcl_CheckRedline( pDoc );
134 
lcl_DebugRedline(const SwDoc * pDoc)135 	void lcl_DebugRedline( const SwDoc* pDoc )
136 	{
137         static sal_uInt16 nWatch = 0;
138 		const SwRedlineTbl& rTbl = pDoc->GetRedlineTbl();
139 		for( sal_uInt16 n = 0; n < rTbl.Count(); ++n )
140 		{
141             sal_uInt16 nDummy = 0;
142             const SwRedline* pCurrent = rTbl[ n ];
143             const SwRedline* pNext = n+1 < rTbl.Count() ? rTbl[ n+1 ] : 0;
144             if( pCurrent == pNext )
145                 ++nDummy;
146             if( n == nWatch )
147                 ++nDummy; // Possible debugger breakpoint
148 		}
149     }
150 
151 	#define _DEBUG_REDLINE( pDoc ) lcl_DebugRedline( pDoc );
152 
153 #endif
154 
SV_IMPL_OP_PTRARR_SORT(_SwRedlineTbl,SwRedlinePtr)155 SV_IMPL_OP_PTRARR_SORT( _SwRedlineTbl, SwRedlinePtr )
156 
157 RedlineMode_t SwDoc::GetRedlineMode() const
158 {
159     return eRedlineMode;
160 }
161 
SetRedlineMode(RedlineMode_t eMode)162 void SwDoc::SetRedlineMode( RedlineMode_t eMode )
163 {
164 	if( eRedlineMode != eMode )
165 	{
166 		if( (nsRedlineMode_t::REDLINE_SHOW_MASK & eRedlineMode) != (nsRedlineMode_t::REDLINE_SHOW_MASK & eMode)
167 			|| 0 == (nsRedlineMode_t::REDLINE_SHOW_MASK & eMode) )
168 		{
169 			bool bSaveInXMLImportFlag = IsInXMLImport();
170 			SetInXMLImport( false );
171 			// und dann alles verstecken, anzeigen
172 			void (SwRedline::*pFnc)( sal_uInt16 ) = 0;
173 
174 			switch( nsRedlineMode_t::REDLINE_SHOW_MASK & eMode )
175 			{
176             case nsRedlineMode_t::REDLINE_SHOW_INSERT | nsRedlineMode_t::REDLINE_SHOW_DELETE :
177 				pFnc = &SwRedline::Show;
178 				break;
179 			case nsRedlineMode_t::REDLINE_SHOW_INSERT:
180 				pFnc = &SwRedline::Hide;
181 				break;
182 			case nsRedlineMode_t::REDLINE_SHOW_DELETE:
183 				pFnc = &SwRedline::ShowOriginal;
184 				break;
185 
186 			default:
187 				pFnc = &SwRedline::Hide;
188 				eMode = (RedlineMode_t)(eMode | nsRedlineMode_t::REDLINE_SHOW_INSERT);
189 				break;
190 			}
191 
192 			_CHECK_REDLINE( this )
193 
194 			if( pFnc )
195 				for( sal_uInt16 nLoop = 1; nLoop <= 2; ++nLoop )
196 					for( sal_uInt16 i = 0; i < pRedlineTbl->Count(); ++i )
197 						((*pRedlineTbl)[ i ]->*pFnc)( nLoop );
198 			_CHECK_REDLINE( this )
199 			SetInXMLImport( bSaveInXMLImportFlag );
200 		}
201 		eRedlineMode = eMode;
202         SetModified();
203 	}
204 }
205 
IsRedlineOn() const206 bool SwDoc::IsRedlineOn() const
207 {
208     return IDocumentRedlineAccess::IsRedlineOn(eRedlineMode);
209 }
210 
IsIgnoreRedline() const211 bool SwDoc::IsIgnoreRedline() const
212 {
213     return (nsRedlineMode_t::REDLINE_IGNORE & eRedlineMode);
214 }
215 
SetRedlineMode_intern(RedlineMode_t eMode)216 void SwDoc::SetRedlineMode_intern(RedlineMode_t eMode)
217 {
218     eRedlineMode = eMode;
219 }
220 
GetRedlineTbl() const221 const SwRedlineTbl& SwDoc::GetRedlineTbl() const
222 {
223     return *pRedlineTbl;
224 }
225 
IsRedlineMove() const226 bool SwDoc::IsRedlineMove() const
227 {
228     return mbIsRedlineMove;
229 }
230 
SetRedlineMove(bool bFlag)231 void SwDoc::SetRedlineMove(bool bFlag)
232 {
233     mbIsRedlineMove = bFlag;
234 }
235 
GetRedlinePassword() const236 const uno::Sequence <sal_Int8>& SwDoc::GetRedlinePassword() const
237 {
238     return aRedlinePasswd;
239 }
240 
IsPrevPos(const SwPosition rPos1,const SwPosition rPos2)241 inline bool IsPrevPos( const SwPosition rPos1, const SwPosition rPos2 )
242 {
243 	const SwCntntNode* pCNd;
244 	return 0 == rPos2.nContent.GetIndex() &&
245 			rPos2.nNode.GetIndex() - 1 == rPos1.nNode.GetIndex() &&
246 			0 != ( pCNd = rPos1.nNode.GetNode().GetCntntNode() )
247 				? rPos1.nContent.GetIndex() == pCNd->Len()
248 				: false;
249 }
250 
251 #ifdef DEBUG
CheckPosition(const SwPosition * pStt,const SwPosition * pEnd)252 bool CheckPosition( const SwPosition* pStt, const SwPosition* pEnd )
253 {
254     int nError = 0;
255     SwNode* pSttNode = &pStt->nNode.GetNode();
256     SwNode* pEndNode = &pEnd->nNode.GetNode();
257     SwNode* pSttTab = pSttNode->StartOfSectionNode()->FindTableNode();
258     SwNode* pEndTab = pEndNode->StartOfSectionNode()->FindTableNode();
259     SwNode* pSttStart = pSttNode;
260     while( pSttStart && (!pSttStart->IsStartNode() || pSttStart->IsSectionNode() ||
261         pSttStart->IsTableNode() ) )
262         pSttStart = pSttStart->StartOfSectionNode();
263     SwNode* pEndStart = pEndNode;
264     while( pEndStart && (!pEndStart->IsStartNode() || pEndStart->IsSectionNode() ||
265         pEndStart->IsTableNode() ) )
266         pEndStart = pEndStart->StartOfSectionNode();
267     if( pSttTab != pEndTab )
268         nError = 1;
269     if( !pSttTab && pSttStart != pEndStart )
270         nError |= 2;
271     if( nError )
272         nError += 10;
273     return nError != 0;
274 }
275 #endif
276 
277 /*
278 
279 Text heisst, nicht von Redline "verseuchter" Text.
280 
281 Verhalten von Insert-Redline:
282 	- im Text							- Redline Object einfuegen
283 	- im InsertRedline (eigenes)		- ignorieren, bestehendes wird
284 										  aufgespannt
285 	- im InsertRedline (andere)			- Insert Redline aufsplitten
286 										  Redline Object einfuegen
287 	- in DeleteRedline					- Delete Redline aufsplitten oder
288 										  am Ende/Anfang verschieben
289 
290 Verhalten von Delete-Redline:
291 	- im Text							- Redline Object einfuegen
292 	- im DeleteRedline (eigenes/andere)	- ignorieren
293 	- im InsertRedline (eigenes)		- ignorieren, Zeichen aber loeschen
294 	- im InsertRedline (andere)			- Insert Redline aufsplitten
295 										  Redline Object einfuegen
296 	- Ueberlappung von Text und 		- Text in eigenen Insert loeschen,
297 	  eigenem Insert					  im andereren Text aufspannen (bis
298 										  zum Insert!
299 	- Ueberlappung von Text und 		- Redline Object einfuegen, der
300 	  anderem Insert                      andere Insert wird vom Delete
301 										  ueberlappt
302 */
303 
AppendRedline(SwRedline * pNewRedl,bool bCallDelete)304 bool SwDoc::AppendRedline( SwRedline* pNewRedl, bool bCallDelete )
305 {
306 #if 0
307 // #i93179# disabled: ASSERT in ~SwIndexReg     #ifdef DBG_UTIL
308     SwRedline aCopy( *pNewRedl );
309 #endif
310     bool bError = true;
311 	_CHECK_REDLINE( this )
312 
313 	if( IsRedlineOn() && !IsShowOriginal( eRedlineMode ) &&
314 		 pNewRedl->GetAuthorString().Len() )
315 	{
316 		pNewRedl->InvalidateRange();
317 
318 		if( mbIsAutoFmtRedline )
319 		{
320 			pNewRedl->SetAutoFmtFlag();
321 			if( pAutoFmtRedlnComment && pAutoFmtRedlnComment->Len() )
322 			{
323 				pNewRedl->SetComment( *pAutoFmtRedlnComment );
324 				pNewRedl->SetSeqNo( nAutoFmtRedlnCommentNo );
325 			}
326 		}
327 
328 		SwPosition* pStt = pNewRedl->Start(),
329 				  * pEnd = pStt == pNewRedl->GetPoint() ? pNewRedl->GetMark()
330 														: pNewRedl->GetPoint();
331         {
332             SwTxtNode* pTxtNode = pStt->nNode.GetNode().GetTxtNode();
333             if( pTxtNode == NULL )
334             {
335                 if( pStt->nContent > 0 )
336                 {
337                     DBG_ASSERT( false, "Redline start: non-text-node with content" );
338                     pStt->nContent = 0;
339                 }
340             }
341             else
342             {
343                 if( pStt->nContent > pTxtNode->Len() )
344                 {
345                     DBG_ASSERT( false, "Redline start: index behind text" );
346                     pStt->nContent = pTxtNode->Len();
347                 }
348             }
349             pTxtNode = pEnd->nNode.GetNode().GetTxtNode();
350             if( pTxtNode == NULL )
351             {
352                 if( pEnd->nContent > 0 )
353                 {
354                     DBG_ASSERT( false, "Redline end: non-text-node with content" );
355                     pEnd->nContent = 0;
356                 }
357             }
358             else
359             {
360                 if( pEnd->nContent > pTxtNode->Len() )
361                 {
362                     DBG_ASSERT( false, "Redline end: index behind text" );
363                     pEnd->nContent = pTxtNode->Len();
364                 }
365             }
366         }
367         if( ( *pStt == *pEnd ) &&
368             ( pNewRedl->GetContentIdx() == NULL ) )
369         {   // Do not insert empty redlines
370             delete pNewRedl;
371             return sal_False;
372         }
373 		sal_Bool bCompress = sal_False;
374 		sal_uInt16 n = 0;
375 			// zur StartPos das erste Redline suchen
376 		if( !GetRedline( *pStt, &n ) && n )
377 			--n;
378         bool bDec = false;
379 
380 		for( ; pNewRedl && n < pRedlineTbl->Count(); bDec ? n : ++n )
381 		{
382             bDec = false;
383 #ifdef DVO_TEST
384 			_CHECK_REDLINE( this )
385 #endif
386 
387 			SwRedline* pRedl = (*pRedlineTbl)[ n ];
388 			SwPosition* pRStt = pRedl->Start(),
389 					  * pREnd = pRStt == pRedl->GetPoint() ? pRedl->GetMark()
390 														   : pRedl->GetPoint();
391 
392             // #i8518# remove empty redlines while we're at it
393             if( ( *pRStt == *pREnd ) &&
394                 ( pRedl->GetContentIdx() == NULL ) )
395             {
396                 pRedlineTbl->DeleteAndDestroy(n);
397                 continue;
398             }
399 
400 			SwComparePosition eCmpPos = ComparePosition( *pStt, *pEnd, *pRStt, *pREnd );
401 
402 			switch( pNewRedl->GetType() )
403 			{
404             case nsRedlineType_t::REDLINE_INSERT:
405 				switch( pRedl->GetType() )
406 				{
407                 case nsRedlineType_t::REDLINE_INSERT:
408 					if( pRedl->IsOwnRedline( *pNewRedl ) )
409 					{
410 						bool bDelete = false;
411 
412 						// ggfs. verschmelzen?
413 						if( (( POS_BEHIND == eCmpPos &&
414                                IsPrevPos( *pREnd, *pStt ) ) ||
415 							 ( POS_COLLIDE_START == eCmpPos ) ||
416                              ( POS_OVERLAP_BEHIND == eCmpPos ) ) &&
417 							pRedl->CanCombine( *pNewRedl ) &&
418 							( n+1 >= pRedlineTbl->Count() ||
419                              ( *(*pRedlineTbl)[ n+1 ]->Start() >= *pEnd &&
420 							 *(*pRedlineTbl)[ n+1 ]->Start() != *pREnd ) ) )
421 						{
422 							pRedl->SetEnd( *pEnd, pREnd );
423 							if( !pRedl->HasValidRange() )
424 							{
425 								// neu einsortieren
426 								pRedlineTbl->Remove( n );
427 								pRedlineTbl->Insert( pRedl );
428 							}
429 
430                             bError = false;
431 							bDelete = true;
432 						}
433 						else if( (( POS_BEFORE == eCmpPos &&
434 									IsPrevPos( *pEnd, *pRStt ) ) ||
435 							 	  ( POS_COLLIDE_END == eCmpPos ) ||
436                                   ( POS_OVERLAP_BEFORE == eCmpPos ) ) &&
437 							pRedl->CanCombine( *pNewRedl ) &&
438 							( !n ||
439 							 *(*pRedlineTbl)[ n-1 ]->End() != *pRStt ))
440 						{
441 							pRedl->SetStart( *pStt, pRStt );
442 							// neu einsortieren
443 							pRedlineTbl->Remove( n );
444 							pRedlineTbl->Insert( pRedl );
445 
446                             bError = false;
447 							bDelete = true;
448 						}
449 						else if ( POS_OUTSIDE == eCmpPos )
450 						{
451 							// #107164# own insert-over-insert
452 							// redlines: just scrap the inside ones
453 							pRedlineTbl->Remove( n );
454 							bDec = true;
455 						}
456 						// <- #107164#
457 						else if( POS_OVERLAP_BEHIND == eCmpPos )
458 						{
459 							*pStt = *pREnd;
460                             if( ( *pStt == *pEnd ) &&
461                                 ( pNewRedl->GetContentIdx() == NULL ) )
462                                 bDelete = true;
463                         }
464 						else if( POS_OVERLAP_BEFORE == eCmpPos )
465 						{
466 							*pEnd = *pRStt;
467                             if( ( *pStt == *pEnd ) &&
468                                 ( pNewRedl->GetContentIdx() == NULL ) )
469                                 bDelete = true;
470 						}
471 						else if( POS_INSIDE == eCmpPos || POS_EQUAL == eCmpPos)
472 							bDelete = true;
473 
474 						if( bDelete )
475 						{
476 							delete pNewRedl, pNewRedl = 0;
477 							bCompress = sal_True;
478 						}
479 					}
480 					else if( POS_INSIDE == eCmpPos )
481 					{
482 						// aufsplitten
483 						if( *pEnd != *pREnd )
484 						{
485 							SwRedline* pCpy = new SwRedline( *pRedl );
486 							pCpy->SetStart( *pEnd );
487 							pRedlineTbl->Insert( pCpy );
488 						}
489 						pRedl->SetEnd( *pStt, pREnd );
490                         if( ( *pStt == *pRStt ) &&
491                             ( pRedl->GetContentIdx() == NULL ) )
492                         {
493 							pRedlineTbl->DeleteAndDestroy( n );
494                             bDec = true;
495                         }
496 						else if( !pRedl->HasValidRange() )
497 						{
498 							// neu einsortieren
499 							pRedlineTbl->Remove( n );
500 							pRedlineTbl->Insert( pRedl );
501 						}
502 					}
503                     else if ( POS_OUTSIDE == eCmpPos )
504                     {
505                         // #102366# handle overlapping redlines in broken
506                         // documents
507 
508                         // split up the new redline, since it covers the
509                         // existing redline. Insert the first part, and
510                         // progress with the remainder as usual
511                         SwRedline* pSplit = new SwRedline( *pNewRedl );
512                         pSplit->SetEnd( *pRStt );
513                         pNewRedl->SetStart( *pREnd );
514                         pRedlineTbl->Insert( pSplit );
515                         if( *pStt == *pEnd && pNewRedl->GetContentIdx() == NULL )
516                         {
517                             delete pNewRedl;
518                             pNewRedl = 0;
519                             bCompress = true;
520                         }
521                     }
522                     else if ( POS_OVERLAP_BEHIND == eCmpPos )
523                     {
524                         // #107164# handle overlapping redlines in broken
525                         // documents
526                         pNewRedl->SetStart( *pREnd );
527                     }
528                     else if ( POS_OVERLAP_BEFORE == eCmpPos )
529                     {
530                         // #107164# handle overlapping redlines in broken
531                         // documents
532                         *pEnd = *pRStt;
533                         if( ( *pStt == *pEnd ) &&
534                             ( pNewRedl->GetContentIdx() == NULL ) )
535                         {
536                             delete pNewRedl;
537                             pNewRedl = 0;
538                             bCompress = true;
539                         }
540                     }
541 					break;
542                 case nsRedlineType_t::REDLINE_DELETE:
543 					if( POS_INSIDE == eCmpPos )
544 					{
545 						// aufsplitten
546 						if( *pEnd != *pREnd )
547 						{
548 							SwRedline* pCpy = new SwRedline( *pRedl );
549 							pCpy->SetStart( *pEnd );
550 							pRedlineTbl->Insert( pCpy );
551 						}
552 						pRedl->SetEnd( *pStt, pREnd );
553                         if( ( *pStt == *pRStt ) &&
554                             ( pRedl->GetContentIdx() == NULL ) )
555                         {
556 							pRedlineTbl->DeleteAndDestroy( n );
557                             bDec = true;
558                         }
559 						else if( !pRedl->HasValidRange() )
560 						{
561 							// neu einsortieren
562 							pRedlineTbl->Remove( n );
563 							pRedlineTbl->Insert( pRedl, n );
564 						}
565 					}
566                     else if ( POS_OUTSIDE == eCmpPos )
567                     {
568                         // #102366# handle overlapping redlines in broken
569                         // documents
570 
571                         // split up the new redline, since it covers the
572                         // existing redline. Insert the first part, and
573                         // progress with the remainder as usual
574                         SwRedline* pSplit = new SwRedline( *pNewRedl );
575                         pSplit->SetEnd( *pRStt );
576                         pNewRedl->SetStart( *pREnd );
577                         pRedlineTbl->Insert( pSplit );
578                         if( *pStt == *pEnd && pNewRedl->GetContentIdx() == NULL )
579                         {
580                             delete pNewRedl;
581                             pNewRedl = 0;
582                             bCompress = true;
583                         }
584                     }
585                     else if ( POS_EQUAL == eCmpPos )
586                     {
587                         // #112895# handle identical redlines in broken
588                         // documents - delete old (delete) redline
589                         pRedlineTbl->DeleteAndDestroy( n );
590                         bDec = true;
591                     }
592                     else if ( POS_OVERLAP_BEHIND == eCmpPos )
593                     {   // Another workaround for broken redlines (#107164#)
594                         pNewRedl->SetStart( *pREnd );
595                     }
596 					break;
597                 case nsRedlineType_t::REDLINE_FORMAT:
598 					switch( eCmpPos )
599 					{
600 					case POS_OVERLAP_BEFORE:
601 						pRedl->SetStart( *pEnd, pRStt );
602 						// neu einsortieren
603 						pRedlineTbl->Remove( n );
604 						pRedlineTbl->Insert( pRedl, n );
605                         bDec = true;
606 						break;
607 
608 					case POS_OVERLAP_BEHIND:
609 						pRedl->SetEnd( *pStt, pREnd );
610                         if( *pStt == *pRStt && pRedl->GetContentIdx() == NULL )
611                         {
612                             pRedlineTbl->DeleteAndDestroy( n );
613                             bDec = true;
614                         }
615 						break;
616 
617 					case POS_EQUAL:
618 					case POS_OUTSIDE:
619 						// ueberlappt den akt. komplett oder hat gleiche
620 						// Ausdehung, dann muss der alte geloescht werden
621 						pRedlineTbl->DeleteAndDestroy( n );
622                         bDec = true;
623 						break;
624 
625 					case POS_INSIDE:
626 						// ueberlappt den akt. komplett, dann muss
627 						// der neue gesplittet oder verkuertzt werden
628 						if( *pEnd != *pREnd )
629 						{
630                             if( *pEnd != *pRStt )
631                             {
632                                 SwRedline* pNew = new SwRedline( *pRedl );
633                                 pNew->SetStart( *pEnd );
634                                 pRedl->SetEnd( *pStt, pREnd );
635                                 if( *pStt == *pRStt && pRedl->GetContentIdx() == NULL )
636                                     pRedlineTbl->DeleteAndDestroy( n );
637                                 AppendRedline( pNew, bCallDelete );
638                                 n = 0;		// neu Aufsetzen
639                                 bDec = true;
640                             }
641 						}
642 						else
643 							pRedl->SetEnd( *pStt, pREnd );
644 						break;
645 					default:
646 						break;
647 					}
648 					break;
649 				default:
650 					break;
651 				}
652 				break;
653 
654             case nsRedlineType_t::REDLINE_DELETE:
655 				switch( pRedl->GetType() )
656 				{
657                 case nsRedlineType_t::REDLINE_DELETE:
658 					switch( eCmpPos )
659 					{
660 					case POS_OUTSIDE:
661 						{
662 							// ueberlappt den akt. komplett
663 							// dann muss der neue gesplittet werden
664 							if( *pEnd != *pREnd )
665 							{
666 								SwRedline* pNew = new SwRedline( *pNewRedl );
667 								pNew->SetStart( *pREnd );
668 								pNewRedl->SetEnd( *pRStt, pEnd );
669 								AppendRedline( pNew, bCallDelete );
670 								n = 0;		// neu Aufsetzen
671                                 bDec = true;
672 							}
673 							else
674 								pNewRedl->SetEnd( *pRStt, pEnd );
675 						}
676 						break;
677 
678 					case POS_INSIDE:
679 					case POS_EQUAL:
680 						delete pNewRedl, pNewRedl = 0;
681 						bCompress = sal_True;
682 						break;
683 
684 					case POS_OVERLAP_BEFORE:
685 					case POS_OVERLAP_BEHIND:
686 						if( pRedl->IsOwnRedline( *pNewRedl ) &&
687 //							1 == pRedl->GetStackCount() &&
688 							pRedl->CanCombine( *pNewRedl ))
689 						{
690 							// dann kann das zusammengefasst werden, sprich
691 							// der neue deckt das schon ab.
692 							if( POS_OVERLAP_BEHIND == eCmpPos )
693 								pNewRedl->SetStart( *pRStt, pStt );
694 							else
695 								pNewRedl->SetEnd( *pREnd, pEnd );
696 							pRedlineTbl->DeleteAndDestroy( n );
697                             bDec = true;
698 						}
699 						else if( POS_OVERLAP_BEHIND == eCmpPos )
700 							pNewRedl->SetStart( *pREnd, pStt );
701 						else
702 							pNewRedl->SetEnd( *pRStt, pEnd );
703 						break;
704 
705 					case POS_COLLIDE_START:
706 					case POS_COLLIDE_END:
707 						if( pRedl->IsOwnRedline( *pNewRedl ) &&
708 //							1 == pRedl->GetStackCount() &&
709 							pRedl->CanCombine( *pNewRedl ) )
710 						{
711 							if( IsHideChanges( eRedlineMode ))
712 							{
713 								// dann erstmal sichtbar machen, bevor
714 								// die zusammengefasst werden koennen!
715 								// Damit pNew auch beim Verschieben der
716 								// Indizies behandelt wird, erstmal
717 								// temporaer einfuegen
718 								pRedlineTbl->SavePtrInArr( pNewRedl );
719 								pRedl->Show();
720 								pRedlineTbl->Remove( pRedlineTbl->GetPos(pNewRedl ));
721 								pRStt = pRedl->Start();
722 								pREnd = pRedl->End();
723 							}
724 
725 							// dann kann das zusammengefasst werden, sprich
726 							// der neue deckt das schon ab.
727 							if( POS_COLLIDE_START == eCmpPos )
728 								pNewRedl->SetStart( *pRStt, pStt );
729 							else
730 								pNewRedl->SetEnd( *pREnd, pEnd );
731 
732                             // delete current (below), and restart process with
733                             // previous
734                             sal_uInt16 nToBeDeleted = n;
735                             bDec = true;
736 
737                             // #107359# Do it again, Sam!
738                             // If you can do it for them, you can do it for me.
739                             if( *(pNewRedl->Start()) <= *pREnd )
740                             {
741                                 // Whoooah, we just extended the new 'redline'
742                                 // beyond previous redlines, so better start
743                                 // again. Of course this is not supposed to
744                                 // happen, and in an ideal world it doesn't,
745                                 // but unfortunately this code is buggy and
746                                 // totally rotten so it does happen and we
747                                 // better fix it.
748                                 n = 0;
749                                 bDec = true;
750                             }
751 
752                             pRedlineTbl->DeleteAndDestroy( nToBeDeleted );
753 						}
754 						break;
755 					default:
756 						break;
757 					}
758 					break;
759 
760                 case nsRedlineType_t::REDLINE_INSERT:
761                 {
762                     // b62341295: Do not throw away redlines
763                     // even if they are not allowed to be combined
764                     RedlineMode_t eOld = eRedlineMode;
765                     if( !( eOld & nsRedlineMode_t::REDLINE_DONTCOMBINE_REDLINES ) &&
766                         pRedl->IsOwnRedline( *pNewRedl ) )
767                     {
768 
769 // auf NONE setzen, damit das Delete::Redo die RedlineDaten wieder richtig
770 // zusammen fasst! Der ShowMode muss erhalten bleiben!
771               eRedlineMode = (RedlineMode_t)(eOld & ~(nsRedlineMode_t::REDLINE_ON | nsRedlineMode_t::REDLINE_IGNORE));
772 						switch( eCmpPos )
773 						{
774 						case POS_EQUAL:
775 							bCompress = sal_True;
776 							pRedlineTbl->DeleteAndDestroy( n );
777                             bDec = true;
778 							// kein break!
779 
780 						case POS_INSIDE:
781 							if( bCallDelete )
782 							{
783                               eRedlineMode = (RedlineMode_t)(eRedlineMode | nsRedlineMode_t::REDLINE_IGNOREDELETE_REDLINES);
784 
785                                 // #98863# DeleteAndJoin does not yield the
786                                 // desired result if there is no paragraph to
787                                 // join with, i.e. at the end of the document.
788                                 // For this case, we completely delete the
789                                 // paragraphs (if, of course, we also start on
790                                 // a paragraph boundary).
791                                 if( (pStt->nContent == 0) &&
792                                     pEnd->nNode.GetNode().IsEndNode() )
793                                 {
794                                     pEnd->nNode--;
795                                     pEnd->nContent.Assign(
796                                         pEnd->nNode.GetNode().GetTxtNode(), 0);
797                                     DelFullPara( *pNewRedl );
798                                 }
799                                 else
800                                     DeleteAndJoin( *pNewRedl );
801 
802 								bCompress = sal_True;
803 							}
804 							delete pNewRedl, pNewRedl = 0;
805 							break;
806 
807 						case POS_OUTSIDE:
808 							{
809 								pRedlineTbl->Remove( n );
810                                 bDec = true;
811 								// damit pNew auch beim Verschieben der Indizies
812 								// behandelt wird, erstmal temp. einfuegen
813 								if( bCallDelete )
814 								{
815 									pRedlineTbl->SavePtrInArr( pNewRedl );
816 									DeleteAndJoin( *pRedl );
817 									sal_uInt16 nFnd = pRedlineTbl->GetPos(pNewRedl );
818 									if( USHRT_MAX != nFnd )
819 										pRedlineTbl->Remove( nFnd );
820 									else
821 										pNewRedl = 0;
822 								}
823 								delete pRedl;
824 							}
825 							break;
826 
827 						case POS_OVERLAP_BEFORE:
828 							{
829 								SwPaM aPam( *pRStt, *pEnd );
830 
831 								if( *pEnd == *pREnd )
832 									pRedlineTbl->DeleteAndDestroy( n );
833 								else
834 								{
835 									pRedl->SetStart( *pEnd, pRStt );
836 									// neu einsortieren
837 									pRedlineTbl->Remove( n );
838 									pRedlineTbl->Insert( pRedl, n );
839 								}
840 
841 								if( bCallDelete )
842 								{
843 									// damit pNew auch beim Verschieben der Indizies
844 									// behandelt wird, erstmal temp. einfuegen
845 									pRedlineTbl->SavePtrInArr( pNewRedl );
846 									DeleteAndJoin( aPam );
847 									sal_uInt16 nFnd = pRedlineTbl->GetPos(pNewRedl );
848 									if( USHRT_MAX != nFnd )
849 										pRedlineTbl->Remove( nFnd );
850 									else
851 										pNewRedl = 0;
852 									n = 0;		// neu Aufsetzen
853 								}
854                                 bDec = true;
855 							}
856 							break;
857 
858 						case POS_OVERLAP_BEHIND:
859 							{
860 								SwPaM aPam( *pStt, *pREnd );
861 
862 								if( *pStt == *pRStt )
863                                 {
864 									pRedlineTbl->DeleteAndDestroy( n );
865                                     bDec = true;
866                                 }
867 								else
868 									pRedl->SetEnd( *pStt, pREnd );
869 
870 								if( bCallDelete )
871 								{
872 									// damit pNew auch beim Verschieben der Indizies
873 									// behandelt wird, erstmal temp. einfuegen
874 									pRedlineTbl->SavePtrInArr( pNewRedl );
875 									DeleteAndJoin( aPam );
876 									sal_uInt16 nFnd = pRedlineTbl->GetPos(pNewRedl );
877 									if( USHRT_MAX != nFnd )
878 										pRedlineTbl->Remove( nFnd );
879 									else
880 										pNewRedl = 0;
881 									n = 0;		// neu Aufsetzen
882                                     bDec = true;
883 								}
884 							}
885 							break;
886 						default:
887 							break;
888 						}
889 
890 						eRedlineMode = eOld;
891 					}
892 					else
893 					{
894                         // it may be necessary to split the existing redline in
895                         // two. In this case, pRedl will be changed to cover
896                         // only part of it's former range, and pNew will cover
897                         // the remainder.
898 						SwRedline* pNew = 0;
899 
900 						switch( eCmpPos )
901 						{
902 						case POS_EQUAL:
903 							{
904 								pRedl->PushData( *pNewRedl );
905 								delete pNewRedl, pNewRedl = 0;
906 								if( IsHideChanges( eRedlineMode ))
907 									pRedl->Hide();
908 								bCompress = sal_True;
909 							}
910 							break;
911 
912 						case POS_INSIDE:
913 							{
914 								if( *pRStt == *pStt )
915 								{
916                                     // --> mst 2010-05-17 #i97421#
917                                     // redline w/out extent loops
918                                     if (*pStt != *pEnd)
919                                     // <--
920                                     {
921                                         pNewRedl->PushData( *pRedl, sal_False );
922                                         pRedl->SetStart( *pEnd, pRStt );
923                                         // re-insert
924                                         pRedlineTbl->Remove( n );
925                                         pRedlineTbl->Insert( pRedl, n );
926                                         bDec = true;
927                                     }
928                                 }
929                                 else
930                                 {
931                                     pNewRedl->PushData( *pRedl, sal_False );
932 									if( *pREnd != *pEnd )
933 									{
934 										pNew = new SwRedline( *pRedl );
935 										pNew->SetStart( *pEnd );
936 									}
937                                     pRedl->SetEnd( *pStt, pREnd );
938 									if( !pRedl->HasValidRange() )
939 									{
940 										// neu einsortieren
941 										pRedlineTbl->Remove( n );
942 										pRedlineTbl->Insert( pRedl, n );
943 									}
944 								}
945 							}
946 							break;
947 
948 						case POS_OUTSIDE:
949 							{
950 								pRedl->PushData( *pNewRedl );
951                                 if( *pEnd == *pREnd )
952 									pNewRedl->SetEnd( *pRStt, pEnd );
953                                 else
954                                 {
955                                     pNew = new SwRedline( *pNewRedl );
956                                     pNew->SetEnd( *pRStt );
957                                     pNewRedl->SetStart( *pREnd, pStt );
958                                 }
959 								bCompress = sal_True;
960 							}
961 							break;
962 
963 						case POS_OVERLAP_BEFORE:
964 							{
965 								if( *pEnd == *pREnd )
966 								{
967 									pRedl->PushData( *pNewRedl );
968 									pNewRedl->SetEnd( *pRStt, pEnd );
969 									if( IsHideChanges( eRedlineMode ))
970 									{
971 										pRedlineTbl->SavePtrInArr( pNewRedl );
972 										pRedl->Hide();
973 										pRedlineTbl->Remove(
974 											pRedlineTbl->GetPos(pNewRedl ));
975 									}
976 								}
977 								else
978 								{
979 									pNew = new SwRedline( *pRedl );
980 									pNew->PushData( *pNewRedl );
981 									pNew->SetEnd( *pEnd );
982 									pNewRedl->SetEnd( *pRStt, pEnd );
983 									pRedl->SetStart( *pNew->End(), pRStt ) ;
984 									// neu einsortieren
985 									pRedlineTbl->Remove( n );
986 									pRedlineTbl->Insert( pRedl );
987                                     bDec = true;
988 								}
989 							}
990 							break;
991 
992 						case POS_OVERLAP_BEHIND:
993 							{
994 								if( *pStt == *pRStt )
995 								{
996 									pRedl->PushData( *pNewRedl );
997 									pNewRedl->SetStart( *pREnd, pStt );
998 									if( IsHideChanges( eRedlineMode ))
999 									{
1000 										pRedlineTbl->SavePtrInArr( pNewRedl );
1001 										pRedl->Hide();
1002 										pRedlineTbl->Remove(
1003 											pRedlineTbl->GetPos(pNewRedl ));
1004 									}
1005 								}
1006 								else
1007 								{
1008 									pNew = new SwRedline( *pRedl );
1009 									pNew->PushData( *pNewRedl );
1010 									pNew->SetStart( *pStt );
1011 									pNewRedl->SetStart( *pREnd, pStt );
1012 									pRedl->SetEnd( *pNew->Start(), pREnd );
1013 									if( !pRedl->HasValidRange() )
1014 									{
1015 										// neu einsortieren
1016 										pRedlineTbl->Remove( n );
1017 										pRedlineTbl->Insert( pRedl );
1018 									}
1019 								}
1020 							}
1021 							break;
1022 						default:
1023 							break;
1024 						}
1025 
1026                         // insert the pNew part (if it exists)
1027 						if( pNew )
1028 						{
1029                             // AppendRedline( pNew, bCallDelete );
1030                             //sal_Bool bRet =
1031                             pRedlineTbl->Insert( pNew );
1032 
1033                             // pNew must be deleted if Insert() wasn't
1034                             // successful. But that can't happen, since pNew is
1035                             // part of the original pRedl redline.
1036                             // ASSERT( bRet, "Can't insert existing redline?" );
1037 
1038                             // restart (now with pRedl being split up)
1039 							n = 0;
1040                             bDec = true;
1041 						}
1042 					}
1043                 }
1044                 break;
1045 
1046                 case nsRedlineType_t::REDLINE_FORMAT:
1047 					switch( eCmpPos )
1048 					{
1049 					case POS_OVERLAP_BEFORE:
1050 						pRedl->SetStart( *pEnd, pRStt );
1051 						// neu einsortieren
1052 						pRedlineTbl->Remove( n );
1053 						pRedlineTbl->Insert( pRedl, n );
1054                         bDec = true;
1055 						break;
1056 
1057 					case POS_OVERLAP_BEHIND:
1058 						pRedl->SetEnd( *pStt, pREnd );
1059 						break;
1060 
1061 					case POS_EQUAL:
1062 					case POS_OUTSIDE:
1063 						// ueberlappt den akt. komplett oder hat gleiche
1064 						// Ausdehung, dann muss der alte geloescht werden
1065 						pRedlineTbl->DeleteAndDestroy( n );
1066                         bDec = true;
1067 						break;
1068 
1069 					case POS_INSIDE:
1070 						// ueberlappt den akt. komplett, dann muss
1071 						// der neue gesplittet oder verkuertzt werden
1072 						if( *pEnd != *pREnd )
1073 						{
1074                             if( *pEnd != *pRStt )
1075                             {
1076                                 SwRedline* pNew = new SwRedline( *pRedl );
1077                                 pNew->SetStart( *pEnd );
1078                                 pRedl->SetEnd( *pStt, pREnd );
1079                                 if( ( *pStt == *pRStt ) &&
1080                                     ( pRedl->GetContentIdx() == NULL ) )
1081                                     pRedlineTbl->DeleteAndDestroy( n );
1082                                 AppendRedline( pNew, bCallDelete );
1083                                 n = 0;		// neu Aufsetzen
1084                                 bDec = true;
1085                             }
1086 						}
1087 						else
1088 							pRedl->SetEnd( *pStt, pREnd );
1089 						break;
1090 					default:
1091 						break;
1092 					}
1093 					break;
1094 				default:
1095 					break;
1096 				}
1097 				break;
1098 
1099             case nsRedlineType_t::REDLINE_FORMAT:
1100 				switch( pRedl->GetType() )
1101 				{
1102                 case nsRedlineType_t::REDLINE_INSERT:
1103                 case nsRedlineType_t::REDLINE_DELETE:
1104 					switch( eCmpPos )
1105 					{
1106 					case POS_OVERLAP_BEFORE:
1107 						pNewRedl->SetEnd( *pRStt, pEnd );
1108 						break;
1109 
1110 					case POS_OVERLAP_BEHIND:
1111 						pNewRedl->SetStart( *pREnd, pStt );
1112 						break;
1113 
1114 					case POS_EQUAL:
1115 					case POS_INSIDE:
1116                         delete pNewRedl, pNewRedl = 0;
1117 						break;
1118 
1119 					case POS_OUTSIDE:
1120 						// ueberlappt den akt. komplett, dann muss
1121 						// der neue gesplittet oder verkuerzt werden
1122 						if( *pEnd != *pREnd )
1123 						{
1124                             if( *pEnd != *pRStt )
1125                             {
1126                                 SwRedline* pNew = new SwRedline( *pNewRedl );
1127                                 pNew->SetStart( *pREnd );
1128                                 pNewRedl->SetEnd( *pRStt, pEnd );
1129                                 AppendRedline( pNew, bCallDelete );
1130                                 n = 0;		// neu Aufsetzen
1131                                 bDec = true;
1132                             }
1133 						}
1134 						else
1135 							pNewRedl->SetEnd( *pRStt, pEnd );
1136 						break;
1137 					default:
1138 						break;
1139 					}
1140 					break;
1141                 case nsRedlineType_t::REDLINE_FORMAT:
1142 					switch( eCmpPos )
1143 					{
1144 					case POS_OUTSIDE:
1145 					case POS_EQUAL:
1146 						{
1147 							// ueberlappt den akt. komplett oder hat gleiche
1148 							// Ausdehnung, dann muss der alte geloescht werden
1149 							pRedlineTbl->DeleteAndDestroy( n );
1150                             bDec = true;
1151 						}
1152 						break;
1153 
1154 					case POS_INSIDE:
1155 						if( pRedl->IsOwnRedline( *pNewRedl ) &&
1156 							pRedl->CanCombine( *pNewRedl ))
1157 							// ein eigenes kann komplett ignoriert werden
1158 							delete pNewRedl, pNewRedl = 0;
1159 
1160 						else if( *pREnd == *pEnd )
1161 							// ansonsten nur den akt. verkuerzen
1162 							pRedl->SetEnd( *pStt, pREnd );
1163 						else if( *pRStt == *pStt )
1164 						{
1165 							// ansonsten nur den akt. verkuerzen
1166 							pRedl->SetStart( *pEnd, pRStt );
1167 							// neu einsortieren
1168 							pRedlineTbl->Remove( n );
1169 							pRedlineTbl->Insert( pRedl, n );
1170                             bDec = true;
1171 						}
1172 						else
1173 						{
1174 							// liegt komplett im akt.
1175 							// dann muss der gesplittet werden
1176 							SwRedline* pNew = new SwRedline( *pRedl );
1177 							pNew->SetStart( *pEnd );
1178 							pRedl->SetEnd( *pStt, pREnd );
1179 							AppendRedline( pNew, bCallDelete );
1180 							n = 0;		// neu Aufsetzen
1181                             bDec = true;
1182 						}
1183 						break;
1184 
1185 					case POS_OVERLAP_BEFORE:
1186 					case POS_OVERLAP_BEHIND:
1187 						if( pRedl->IsOwnRedline( *pNewRedl ) &&
1188 							pRedl->CanCombine( *pNewRedl ))
1189 						{
1190 							// dann kann das zusammengefasst werden, sprich
1191 							// der neue deckt das schon ab.
1192 							if( POS_OVERLAP_BEHIND == eCmpPos )
1193 								pNewRedl->SetStart( *pRStt, pStt );
1194 							else
1195 								pNewRedl->SetEnd( *pREnd, pEnd );
1196 							pRedlineTbl->DeleteAndDestroy( n );
1197                             bDec = 0;
1198 						}
1199 						else if( POS_OVERLAP_BEHIND == eCmpPos )
1200 							pNewRedl->SetStart( *pREnd, pStt );
1201 						else
1202 							pNewRedl->SetEnd( *pRStt, pEnd );
1203 						break;
1204 
1205 					case POS_COLLIDE_END:
1206 						if( pRedl->IsOwnRedline( *pNewRedl ) &&
1207 							pRedl->CanCombine( *pNewRedl ) && n &&
1208 							*(*pRedlineTbl)[ n-1 ]->End() < *pStt )
1209 						{
1210 							// dann kann das zusammengefasst werden, sprich
1211 							// der neue deckt das schon ab.
1212 							pNewRedl->SetEnd( *pREnd, pEnd );
1213 							pRedlineTbl->DeleteAndDestroy( n );
1214                             bDec = true;
1215 						}
1216 						break;
1217 					case POS_COLLIDE_START:
1218 						if( pRedl->IsOwnRedline( *pNewRedl ) &&
1219 							pRedl->CanCombine( *pNewRedl ) &&
1220 							n+1 < pRedlineTbl->Count() &&
1221 							*(*pRedlineTbl)[ n+1 ]->Start() < *pEnd )
1222 						{
1223 							// dann kann das zusammengefasst werden, sprich
1224 							// der neue deckt das schon ab.
1225 							pNewRedl->SetStart( *pRStt, pStt );
1226 							pRedlineTbl->DeleteAndDestroy( n );
1227                             bDec = true;
1228 						}
1229 						break;
1230 					default:
1231 						break;
1232 					}
1233 					break;
1234 				default:
1235 					break;
1236 				}
1237 				break;
1238 
1239 
1240             case nsRedlineType_t::REDLINE_FMTCOLL:
1241 				// wie soll das verhalten sein????
1242 				// erstmal so einfuegen
1243 				break;
1244 			default:
1245 				break;
1246 			}
1247 		}
1248 
1249 		if( pNewRedl )
1250         {
1251             if( ( *pStt == *pEnd ) &&
1252                 ( pNewRedl->GetContentIdx() == NULL ) )
1253             {   // Do not insert empty redlines
1254                 delete pNewRedl;
1255                 pNewRedl = 0;
1256             }
1257             else
1258                 pRedlineTbl->Insert( pNewRedl );
1259         }
1260 
1261 		if( bCompress )
1262 			CompressRedlines();
1263 	}
1264 	else
1265 	{
1266         if( bCallDelete && nsRedlineType_t::REDLINE_DELETE == pNewRedl->GetType() )
1267 		{
1268 			RedlineMode_t eOld = eRedlineMode;
1269 // auf NONE setzen, damit das Delete::Redo die RedlineDaten wieder richtig
1270 // zusammen fasst! Der ShowMode muss erhalten bleiben!
1271             eRedlineMode = (RedlineMode_t)(eOld & ~(nsRedlineMode_t::REDLINE_ON | nsRedlineMode_t::REDLINE_IGNORE));
1272 			DeleteAndJoin( *pNewRedl );
1273 			eRedlineMode = eOld;
1274 		}
1275 		delete pNewRedl, pNewRedl = 0;
1276 	}
1277 	_CHECK_REDLINE( this )
1278 
1279 	return ( 0 != pNewRedl ) || !bError;
1280 }
1281 
CompressRedlines()1282 void SwDoc::CompressRedlines()
1283 {
1284 	_CHECK_REDLINE( this )
1285 
1286 	void (SwRedline::*pFnc)(sal_uInt16) = 0;
1287     switch( nsRedlineMode_t::REDLINE_SHOW_MASK & eRedlineMode )
1288 	{
1289     case nsRedlineMode_t::REDLINE_SHOW_INSERT | nsRedlineMode_t::REDLINE_SHOW_DELETE:
1290 		pFnc = &SwRedline::Show;
1291 		break;
1292     case nsRedlineMode_t::REDLINE_SHOW_INSERT:
1293 		pFnc = &SwRedline::Hide;
1294 		break;
1295 	}
1296 
1297 	// versuche gleiche zusammenzufassen
1298 	for( sal_uInt16 n = 1; n < pRedlineTbl->Count(); ++n )
1299 	{
1300 		SwRedline* pPrev = (*pRedlineTbl)[ n-1 ],
1301 					* pCur = (*pRedlineTbl)[ n ];
1302 		const SwPosition* pPrevStt = pPrev->Start(),
1303 						* pPrevEnd = pPrevStt == pPrev->GetPoint()
1304 							? pPrev->GetMark() : pPrev->GetPoint();
1305 		const SwPosition* pCurStt = pCur->Start(),
1306 						* pCurEnd = pCurStt == pCur->GetPoint()
1307 							? pCur->GetMark() : pCur->GetPoint();
1308 		if( *pPrevEnd == *pCurStt && pPrev->CanCombine( *pCur ) &&
1309             pPrevStt->nNode.GetNode().StartOfSectionNode() ==
1310             pCurEnd->nNode.GetNode().StartOfSectionNode() &&
1311             !pCurEnd->nNode.GetNode().StartOfSectionNode()->IsTableNode() )
1312 		{
1313 			// dann koennen die zusammen gefasst werden
1314 			pPrev->Show();
1315 			pCur->Show();
1316 
1317 			pPrev->SetEnd( *pCur->End() );
1318 			pRedlineTbl->DeleteAndDestroy( n );
1319 			--n;
1320 			if( pFnc )
1321 				(pPrev->*pFnc)(0);
1322 		}
1323 	}
1324 	_CHECK_REDLINE( this )
1325 }
1326 
SplitRedline(const SwPaM & rRange)1327 bool SwDoc::SplitRedline( const SwPaM& rRange )
1328 {
1329 	sal_Bool bChg = sal_False;
1330 	sal_uInt16 n = 0;
1331 	const SwPosition* pStt = rRange.Start(),
1332 				  * pEnd = pStt == rRange.GetPoint() ? rRange.GetMark()
1333 													 : rRange.GetPoint();
1334 	GetRedline( *pStt, &n );
1335 	for( ; n < pRedlineTbl->Count() ; ++n )
1336 	{
1337 		SwRedline* pTmp = (*pRedlineTbl)[ n ];
1338 		SwPosition* pTStt = pTmp->Start(),
1339 				  * pTEnd = pTStt == pTmp->GetPoint() ? pTmp->GetMark()
1340 													  : pTmp->GetPoint();
1341 		if( *pTStt <= *pStt && *pStt <= *pTEnd &&
1342 			*pTStt <= *pEnd && *pEnd <= *pTEnd )
1343 		{
1344 			bChg = sal_True;
1345 			int nn = 0;
1346 			if( *pStt == *pTStt )
1347 				nn += 1;
1348 			if( *pEnd == *pTEnd )
1349 				nn += 2;
1350 
1351 			SwRedline* pNew = 0;
1352 			switch( nn )
1353 			{
1354 			case 0:
1355 				pNew = new SwRedline( *pTmp );
1356 				pTmp->SetEnd( *pStt, pTEnd );
1357 				pNew->SetStart( *pEnd );
1358 				break;
1359 
1360 			case 1:
1361 				*pTStt = *pEnd;
1362 				break;
1363 
1364 			case 2:
1365 				*pTEnd = *pStt;
1366 				break;
1367 
1368 			case 3:
1369 				pTmp->InvalidateRange();
1370 				pRedlineTbl->DeleteAndDestroy( n-- );
1371 				pTmp = 0;
1372 				break;
1373 			}
1374 			if( pTmp && !pTmp->HasValidRange() )
1375 			{
1376 				// neu einsortieren
1377 				pRedlineTbl->Remove( n );
1378 				pRedlineTbl->Insert( pTmp, n );
1379 			}
1380 			if( pNew )
1381 				pRedlineTbl->Insert( pNew, n );
1382 		}
1383 		else if( *pEnd < *pTStt )
1384 			break;
1385 	}
1386 	return bChg;
1387 }
1388 
DeleteRedline(const SwPaM & rRange,bool bSaveInUndo,sal_uInt16 nDelType)1389 bool SwDoc::DeleteRedline( const SwPaM& rRange, bool bSaveInUndo,
1390 							sal_uInt16 nDelType )
1391 {
1392     if( nsRedlineMode_t::REDLINE_IGNOREDELETE_REDLINES & eRedlineMode ||
1393 		!rRange.HasMark() || *rRange.GetMark() == *rRange.GetPoint() )
1394 		return sal_False;
1395 
1396 	sal_Bool bChg = sal_False;
1397 
1398     if (bSaveInUndo && GetIDocumentUndoRedo().DoesUndo())
1399     {
1400 		SwUndoRedline* pUndo = new SwUndoRedline( UNDO_REDLINE, rRange );
1401 		if( pUndo->GetRedlSaveCount() )
1402         {
1403             GetIDocumentUndoRedo().AppendUndo(pUndo);
1404         }
1405         else
1406 			delete pUndo;
1407 	}
1408 
1409 	const SwPosition* pStt = rRange.Start(),
1410 					* pEnd = pStt == rRange.GetPoint() ? rRange.GetMark()
1411 													   : rRange.GetPoint();
1412 	sal_uInt16 n = 0;
1413 	GetRedline( *pStt, &n );
1414 	for( ; n < pRedlineTbl->Count() ; ++n )
1415 	{
1416 		SwRedline* pRedl = (*pRedlineTbl)[ n ];
1417 		if( USHRT_MAX != nDelType && nDelType != pRedl->GetType() )
1418 			continue;
1419 
1420 		SwPosition* pRStt = pRedl->Start(),
1421 				  * pREnd = pRStt == pRedl->GetPoint() ? pRedl->GetMark()
1422 													   : pRedl->GetPoint();
1423 		sal_Bool bDel = sal_False;
1424 		switch( ComparePosition( *pStt, *pEnd, *pRStt, *pREnd ) )
1425 		{
1426 		case POS_EQUAL:
1427 		case POS_OUTSIDE:
1428 			bDel = sal_True;
1429 			break;
1430 
1431 		case POS_OVERLAP_BEFORE:
1432 			if( *pEnd == *pREnd )
1433 				bDel = sal_True;
1434 			else
1435 			{
1436 				pRedl->InvalidateRange();
1437 				pRedl->SetStart( *pEnd, pRStt );
1438 				// neu einsortieren
1439 				pRedlineTbl->Remove( n );
1440 				pRedlineTbl->Insert( pRedl );
1441 				--n;
1442 			}
1443 			break;
1444 
1445 		case POS_OVERLAP_BEHIND:
1446 			if( *pStt == *pRStt )
1447 				bDel = sal_True;
1448 			else
1449 			{
1450 				pRedl->InvalidateRange();
1451 				pRedl->SetEnd( *pStt, pREnd );
1452 				if( !pRedl->HasValidRange() )
1453 				{
1454 					// neu einsortieren
1455 					pRedlineTbl->Remove( n );
1456 					pRedlineTbl->Insert( pRedl );
1457 					--n;
1458 				}
1459 			}
1460 			break;
1461 
1462 		case POS_INSIDE:
1463 			{
1464 				// der muss gesplittet werden
1465 				pRedl->InvalidateRange();
1466 				if( *pRStt == *pStt )
1467 				{
1468 					pRedl->SetStart( *pEnd, pRStt );
1469 					// neu einsortieren
1470 					pRedlineTbl->Remove( n );
1471 					pRedlineTbl->Insert( pRedl );
1472 					--n;
1473 				}
1474 				else
1475 				{
1476 					SwRedline* pCpy;
1477 					if( *pREnd != *pEnd )
1478 					{
1479 						pCpy = new SwRedline( *pRedl );
1480 						pCpy->SetStart( *pEnd );
1481 					}
1482 					else
1483 						pCpy = 0;
1484 					pRedl->SetEnd( *pStt, pREnd );
1485 					if( !pRedl->HasValidRange() )
1486 					{
1487 						// neu einsortieren
1488 						pRedlineTbl->Remove( pRedlineTbl->GetPos( pRedl ));
1489 						pRedlineTbl->Insert( pRedl );
1490 						--n;
1491 					}
1492 					if( pCpy )
1493 						pRedlineTbl->Insert( pCpy );
1494 				}
1495 			}
1496 			break;
1497 
1498 		case POS_COLLIDE_END:
1499 		case POS_BEFORE:
1500 			n = pRedlineTbl->Count();
1501 			break;
1502 		default:
1503 			break;
1504 		}
1505 
1506 		if( bDel )
1507 		{
1508 			pRedl->InvalidateRange();
1509 			pRedlineTbl->DeleteAndDestroy( n-- );
1510 			bChg = sal_True;
1511 		}
1512 	}
1513 
1514 	if( bChg )
1515 		SetModified();
1516 
1517 	return bChg;
1518 }
1519 
DeleteRedline(const SwStartNode & rNode,bool bSaveInUndo,sal_uInt16 nDelType)1520 bool SwDoc::DeleteRedline( const SwStartNode& rNode, bool bSaveInUndo,
1521 							sal_uInt16 nDelType )
1522 {
1523 	SwPaM aTemp(*rNode.EndOfSectionNode(), rNode);
1524 	return DeleteRedline(aTemp, bSaveInUndo, nDelType);
1525 }
1526 
GetRedlinePos(const SwNode & rNd,sal_uInt16 nType) const1527 sal_uInt16 SwDoc::GetRedlinePos( const SwNode& rNd, sal_uInt16 nType ) const
1528 {
1529 	const sal_uLong nNdIdx = rNd.GetIndex();
1530 	for( sal_uInt16 n = 0; n < pRedlineTbl->Count() ; ++n )
1531 	{
1532 		const SwRedline* pTmp = (*pRedlineTbl)[ n ];
1533 		sal_uLong nPt = pTmp->GetPoint()->nNode.GetIndex(),
1534 			  nMk = pTmp->GetMark()->nNode.GetIndex();
1535 		if( nPt < nMk ) { long nTmp = nMk; nMk = nPt; nPt = nTmp; }
1536 
1537 		if( ( USHRT_MAX == nType || nType == pTmp->GetType()) &&
1538 			nMk <= nNdIdx && nNdIdx <= nPt )
1539 			return n;
1540 
1541 		if( nMk > nNdIdx )
1542 			break;
1543 	}
1544 	return USHRT_MAX;
1545 }
1546 
GetRedline(const SwPosition & rPos,sal_uInt16 * pFndPos) const1547 const SwRedline* SwDoc::GetRedline( const SwPosition& rPos,
1548 									sal_uInt16* pFndPos ) const
1549 {
1550 	sal_uInt16 nO = pRedlineTbl->Count(), nM, nU = 0;
1551 	if( nO > 0 )
1552 	{
1553 		nO--;
1554 		while( nU <= nO )
1555 		{
1556 			nM = nU + ( nO - nU ) / 2;
1557 			const SwRedline* pRedl = (*pRedlineTbl)[ nM ];
1558 			const SwPosition* pStt = pRedl->Start();
1559 			const SwPosition* pEnd = pStt == pRedl->GetPoint()
1560 										? pRedl->GetMark()
1561 										: pRedl->GetPoint();
1562 			if( pEnd == pStt
1563 					? *pStt == rPos
1564 					: ( *pStt <= rPos && rPos < *pEnd ) )
1565 			{
1566                 /* #107318# returned wrong redline ???*/
1567 				while( nM && rPos == *(*pRedlineTbl)[ nM - 1 ]->End() &&
1568                     rPos == *(*pRedlineTbl)[ nM - 1 ]->Start() )
1569 				{
1570 					--nM;
1571 					pRedl = (*pRedlineTbl)[ nM ];
1572 				}
1573 
1574 				if( pFndPos )
1575 					*pFndPos = nM;
1576 				return pRedl;
1577 			}
1578 			else if( *pEnd <= rPos )
1579 				nU = nM + 1;
1580 			else if( nM == 0 )
1581 			{
1582 				if( pFndPos )
1583 					*pFndPos = nU;
1584 				return 0;
1585 			}
1586 			else
1587 				nO = nM - 1;
1588 		}
1589 	}
1590 	if( pFndPos )
1591 		*pFndPos = nU;
1592 	return 0;
1593 }
1594 
1595 typedef sal_Bool (*Fn_AcceptReject)( SwRedlineTbl& rArr, sal_uInt16& rPos,
1596 						sal_Bool bCallDelete,
1597 						const SwPosition* pSttRng,
1598 						const SwPosition* pEndRng);
1599 
lcl_AcceptRedline(SwRedlineTbl & rArr,sal_uInt16 & rPos,sal_Bool bCallDelete,const SwPosition * pSttRng=0,const SwPosition * pEndRng=0)1600 sal_Bool lcl_AcceptRedline( SwRedlineTbl& rArr, sal_uInt16& rPos,
1601 						sal_Bool bCallDelete,
1602 						const SwPosition* pSttRng = 0,
1603 						const SwPosition* pEndRng = 0 )
1604 {
1605 	sal_Bool bRet = sal_True;
1606 	SwRedline* pRedl = rArr[ rPos ];
1607 	SwPosition *pRStt = 0, *pREnd = 0;
1608 	SwComparePosition eCmp = POS_OUTSIDE;
1609 	if( pSttRng && pEndRng )
1610 	{
1611 		pRStt = pRedl->Start();
1612 		pREnd = pRedl->End();
1613 		eCmp = ComparePosition( *pSttRng, *pEndRng, *pRStt, *pREnd );
1614 	}
1615 
1616 	pRedl->InvalidateRange();
1617 
1618 	switch( pRedl->GetType() )
1619 	{
1620 	case nsRedlineType_t::REDLINE_INSERT:
1621 	case nsRedlineType_t::REDLINE_FORMAT:
1622 		{
1623 			sal_Bool bCheck = sal_False, bReplace = sal_False;
1624 			switch( eCmp )
1625 			{
1626 			case POS_INSIDE:
1627 				if( *pSttRng == *pRStt )
1628 					pRedl->SetStart( *pEndRng, pRStt );
1629 				else
1630 				{
1631 					if( *pEndRng != *pREnd )
1632 					{
1633 						// aufsplitten
1634 						SwRedline* pNew = new SwRedline( *pRedl );
1635 						pNew->SetStart( *pEndRng );
1636 						rArr.Insert( pNew ); ++rPos;
1637 					}
1638 					pRedl->SetEnd( *pSttRng, pREnd );
1639 					bCheck = sal_True;
1640 				}
1641 				break;
1642 
1643 			case POS_OVERLAP_BEFORE:
1644 				pRedl->SetStart( *pEndRng, pRStt );
1645 				bReplace = sal_True;
1646 				break;
1647 
1648 			case POS_OVERLAP_BEHIND:
1649 				pRedl->SetEnd( *pSttRng, pREnd );
1650 				bCheck = sal_True;
1651 				break;
1652 
1653 			case POS_OUTSIDE:
1654 			case POS_EQUAL:
1655 				rArr.DeleteAndDestroy( rPos-- );
1656 				break;
1657 
1658 			default:
1659 				bRet = sal_False;
1660 			}
1661 
1662 			if( bReplace || ( bCheck && !pRedl->HasValidRange() ))
1663 			{
1664 				// neu einsortieren
1665 				rArr.Remove( rArr.GetPos( pRedl ));
1666 				rArr.Insert( pRedl );
1667 			}
1668 		}
1669 		break;
1670 	case nsRedlineType_t::REDLINE_DELETE:
1671 		{
1672 			SwDoc& rDoc = *pRedl->GetDoc();
1673 			const SwPosition *pDelStt = 0, *pDelEnd = 0;
1674 			sal_Bool bDelRedl = sal_False;
1675 			switch( eCmp )
1676 			{
1677 			case POS_INSIDE:
1678 				if( bCallDelete )
1679 				{
1680 					pDelStt = pSttRng;
1681 					pDelEnd = pEndRng;
1682 				}
1683 				break;
1684 
1685 			case POS_OVERLAP_BEFORE:
1686 				if( bCallDelete )
1687 				{
1688 					pDelStt = pRStt;
1689 					pDelEnd = pEndRng;
1690 				}
1691 				break;
1692 			case POS_OVERLAP_BEHIND:
1693 				if( bCallDelete )
1694 				{
1695 					pDelStt = pREnd;
1696 					pDelEnd = pSttRng;
1697 				}
1698 				break;
1699 
1700 			case POS_OUTSIDE:
1701 			case POS_EQUAL:
1702 				{
1703 					rArr.Remove( rPos-- );
1704 					bDelRedl = sal_True;
1705 					if( bCallDelete )
1706 					{
1707 						pDelStt = pRedl->Start();
1708 						pDelEnd = pRedl->End();
1709 					}
1710 				}
1711 				break;
1712 			default:
1713 				bRet = sal_False;
1714 			}
1715 
1716 			if( pDelStt && pDelEnd )
1717 			{
1718 				SwPaM aPam( *pDelStt, *pDelEnd );
1719 				SwCntntNode* pCSttNd = pDelStt->nNode.GetNode().GetCntntNode();
1720 				SwCntntNode* pCEndNd = pDelEnd->nNode.GetNode().GetCntntNode();
1721 
1722 				if( bDelRedl )
1723 					delete pRedl;
1724 
1725 				RedlineMode_t eOld = rDoc.GetRedlineMode();
1726 				rDoc.SetRedlineMode_intern( (RedlineMode_t)(eOld & ~(nsRedlineMode_t::REDLINE_ON | nsRedlineMode_t::REDLINE_IGNORE)));
1727 
1728 				if( pCSttNd && pCEndNd )
1729 					rDoc.DeleteAndJoin( aPam );
1730 				else
1731 				{
1732                     rDoc.DeleteRange( aPam );
1733 
1734 					if( pCSttNd && !pCEndNd )
1735 					{
1736 						aPam.GetBound( sal_True ).nContent.Assign( 0, 0 );
1737 						aPam.GetBound( sal_False ).nContent.Assign( 0, 0 );
1738 						aPam.DeleteMark();
1739 						rDoc.DelFullPara( aPam );
1740 					}
1741 				}
1742 				rDoc.SetRedlineMode_intern( eOld );
1743 			}
1744 			else if( bDelRedl )
1745 				delete pRedl;
1746 		}
1747 		break;
1748 
1749 	case nsRedlineType_t::REDLINE_FMTCOLL:
1750 		rArr.DeleteAndDestroy( rPos-- );
1751 		break;
1752 
1753 	default:
1754 		bRet = sal_False;
1755 	}
1756 	return bRet;
1757 }
1758 
lcl_RejectRedline(SwRedlineTbl & rArr,sal_uInt16 & rPos,sal_Bool bCallDelete,const SwPosition * pSttRng=0,const SwPosition * pEndRng=0)1759 sal_Bool lcl_RejectRedline( SwRedlineTbl& rArr, sal_uInt16& rPos,
1760 						sal_Bool bCallDelete,
1761 						const SwPosition* pSttRng = 0,
1762 						const SwPosition* pEndRng = 0 )
1763 {
1764 	sal_Bool bRet = sal_True;
1765 	SwRedline* pRedl = rArr[ rPos ];
1766 	SwPosition *pRStt = 0, *pREnd = 0;
1767 	SwComparePosition eCmp = POS_OUTSIDE;
1768 	if( pSttRng && pEndRng )
1769 	{
1770 		pRStt = pRedl->Start();
1771 		pREnd = pRedl->End();
1772 		eCmp = ComparePosition( *pSttRng, *pEndRng, *pRStt, *pREnd );
1773 	}
1774 
1775 	pRedl->InvalidateRange();
1776 
1777 	switch( pRedl->GetType() )
1778 	{
1779 	case nsRedlineType_t::REDLINE_INSERT:
1780 		{
1781 			SwDoc& rDoc = *pRedl->GetDoc();
1782 			const SwPosition *pDelStt = 0, *pDelEnd = 0;
1783 			sal_Bool bDelRedl = sal_False;
1784 			switch( eCmp )
1785 			{
1786 			case POS_INSIDE:
1787 				if( bCallDelete )
1788 				{
1789 					pDelStt = pSttRng;
1790 					pDelEnd = pEndRng;
1791 				}
1792 				break;
1793 
1794 			case POS_OVERLAP_BEFORE:
1795 				if( bCallDelete )
1796 				{
1797 					pDelStt = pRStt;
1798 					pDelEnd = pEndRng;
1799 				}
1800 				break;
1801 			case POS_OVERLAP_BEHIND:
1802 				if( bCallDelete )
1803 				{
1804 					pDelStt = pREnd;
1805 					pDelEnd = pSttRng;
1806 				}
1807 				break;
1808 			case POS_OUTSIDE:
1809 			case POS_EQUAL:
1810 				{
1811 					// dann den Bereich wieder loeschen
1812 					rArr.Remove( rPos-- );
1813 					bDelRedl = sal_True;
1814 					if( bCallDelete )
1815 					{
1816 						pDelStt = pRedl->Start();
1817 						pDelEnd = pRedl->End();
1818 					}
1819 				}
1820 				break;
1821 
1822 			default:
1823 				bRet = sal_False;
1824 			}
1825 			if( pDelStt && pDelEnd )
1826 			{
1827 				SwPaM aPam( *pDelStt, *pDelEnd );
1828 
1829 				SwCntntNode* pCSttNd = pDelStt->nNode.GetNode().GetCntntNode();
1830 				SwCntntNode* pCEndNd = pDelEnd->nNode.GetNode().GetCntntNode();
1831 
1832 				if( bDelRedl )
1833 					delete pRedl;
1834 
1835 				RedlineMode_t eOld = rDoc.GetRedlineMode();
1836 				rDoc.SetRedlineMode_intern( (RedlineMode_t)(eOld & ~(nsRedlineMode_t::REDLINE_ON | nsRedlineMode_t::REDLINE_IGNORE)));
1837 
1838 				if( pCSttNd && pCEndNd )
1839 					rDoc.DeleteAndJoin( aPam );
1840 				else
1841 				{
1842                     rDoc.DeleteRange( aPam );
1843 
1844 					if( pCSttNd && !pCEndNd )
1845 					{
1846 						aPam.GetBound( sal_True ).nContent.Assign( 0, 0 );
1847 						aPam.GetBound( sal_False ).nContent.Assign( 0, 0 );
1848 						aPam.DeleteMark();
1849 						rDoc.DelFullPara( aPam );
1850 					}
1851 				}
1852 				rDoc.SetRedlineMode_intern( eOld );
1853 			}
1854 			else if( bDelRedl )
1855 				delete pRedl;
1856 		}
1857 		break;
1858 	case nsRedlineType_t::REDLINE_DELETE:
1859 		{
1860 			SwRedline* pNew = 0;
1861 			sal_Bool bCheck = sal_False, bReplace = sal_False;
1862 
1863 			switch( eCmp )
1864 			{
1865 			case POS_INSIDE:
1866 				{
1867 					if( 1 < pRedl->GetStackCount() )
1868 					{
1869 						pNew = new SwRedline( *pRedl );
1870 						pNew->PopData();
1871 					}
1872 					if( *pSttRng == *pRStt )
1873 					{
1874 						pRedl->SetStart( *pEndRng, pRStt );
1875 						bReplace = sal_True;
1876 						if( pNew )
1877 							pNew->SetEnd( *pEndRng );
1878 					}
1879 					else
1880 					{
1881 						if( *pEndRng != *pREnd )
1882 						{
1883 							// aufsplitten
1884 							SwRedline* pCpy = new SwRedline( *pRedl );
1885 							pCpy->SetStart( *pEndRng );
1886 							rArr.Insert( pCpy ); ++rPos;
1887 							if( pNew )
1888 								pNew->SetEnd( *pEndRng );
1889 						}
1890 
1891 						pRedl->SetEnd( *pSttRng, pREnd );
1892 						bCheck = sal_True;
1893 						if( pNew )
1894 							pNew->SetStart( *pSttRng );
1895 					}
1896 				}
1897 				break;
1898 
1899 			case POS_OVERLAP_BEFORE:
1900 				if( 1 < pRedl->GetStackCount() )
1901 				{
1902 					pNew = new SwRedline( *pRedl );
1903 					pNew->PopData();
1904 				}
1905 				pRedl->SetStart( *pEndRng, pRStt );
1906 				bReplace = sal_True;
1907 				if( pNew )
1908 					pNew->SetEnd( *pEndRng );
1909 				break;
1910 
1911 			case POS_OVERLAP_BEHIND:
1912 				if( 1 < pRedl->GetStackCount() )
1913 				{
1914 					pNew = new SwRedline( *pRedl );
1915 					pNew->PopData();
1916 				}
1917 				pRedl->SetEnd( *pSttRng, pREnd );
1918 				bCheck = sal_True;
1919 				if( pNew )
1920 					pNew->SetStart( *pSttRng );
1921 				break;
1922 
1923 			case POS_OUTSIDE:
1924 			case POS_EQUAL:
1925 				if( !pRedl->PopData() )
1926 					// das RedlineObject loeschen reicht
1927 					rArr.DeleteAndDestroy( rPos-- );
1928 				break;
1929 
1930 			default:
1931 				bRet = sal_False;
1932 			}
1933 
1934 			if( pNew )
1935 			{
1936 				rArr.Insert( pNew ); ++rPos;
1937 			}
1938 
1939 			if( bReplace || ( bCheck && !pRedl->HasValidRange() ))
1940 			{
1941 				// neu einsortieren
1942 				rArr.Remove( rArr.GetPos( pRedl ));
1943 				rArr.Insert( pRedl );
1944 			}
1945 		}
1946 		break;
1947 
1948 	case nsRedlineType_t::REDLINE_FORMAT:
1949 	case nsRedlineType_t::REDLINE_FMTCOLL:
1950 		{
1951 			if( pRedl->GetExtraData() )
1952 				pRedl->GetExtraData()->Reject( *pRedl );
1953 			rArr.DeleteAndDestroy( rPos-- );
1954 		}
1955 		break;
1956 
1957 	default:
1958 		bRet = sal_False;
1959 	}
1960 	return bRet;
1961 }
1962 
1963 
lcl_FindCurrRedline(const SwPosition & rSttPos,sal_uInt16 & rPos,sal_Bool bNext=sal_True)1964 const SwRedline* lcl_FindCurrRedline( const SwPosition& rSttPos,
1965 										sal_uInt16& rPos,
1966 										sal_Bool bNext = sal_True )
1967 {
1968 	const SwRedline* pFnd = 0;
1969 	const SwRedlineTbl& rArr = rSttPos.nNode.GetNode().GetDoc()->GetRedlineTbl();
1970 	for( ; rPos < rArr.Count() ; ++rPos )
1971 	{
1972 		const SwRedline* pTmp = rArr[ rPos ];
1973 		if( pTmp->HasMark() && pTmp->IsVisible() )
1974 		{
1975 			const SwPosition* pRStt = pTmp->Start(),
1976 					  * pREnd = pRStt == pTmp->GetPoint() ? pTmp->GetMark()
1977 														  : pTmp->GetPoint();
1978 			if( bNext ? *pRStt <= rSttPos : *pRStt < rSttPos )
1979 			{
1980 				if( bNext ? *pREnd > rSttPos : *pREnd >= rSttPos )
1981 				{
1982 					pFnd = pTmp;
1983 					break;
1984 				}
1985 			}
1986 			else
1987 				break;
1988 		}
1989 	}
1990 	return pFnd;
1991 }
1992 
1993 // #111827#
lcl_AcceptRejectRedl(Fn_AcceptReject fn_AcceptReject,SwRedlineTbl & rArr,sal_Bool bCallDelete,const SwPaM & rPam)1994 int lcl_AcceptRejectRedl( Fn_AcceptReject fn_AcceptReject,
1995 							SwRedlineTbl& rArr, sal_Bool bCallDelete,
1996 							const SwPaM& rPam)
1997 {
1998 	sal_uInt16 n = 0;
1999     int nCount = 0; // #111827#
2000 
2001 	const SwPosition* pStt = rPam.Start(),
2002 					* pEnd = pStt == rPam.GetPoint() ? rPam.GetMark()
2003 													 : rPam.GetPoint();
2004 	const SwRedline* pFnd = lcl_FindCurrRedline( *pStt, n, sal_True );
2005 	if( pFnd &&		// neu ein Teil davon?
2006 		( *pFnd->Start() != *pStt || *pFnd->End() > *pEnd ))
2007 	{
2008 		// dann nur die TeilSelektion aufheben
2009 		if( (*fn_AcceptReject)( rArr, n, bCallDelete, pStt, pEnd ))
2010             nCount++; // #111827#
2011 		++n;
2012 	}
2013 
2014 	for( ; n < rArr.Count(); ++n )
2015 	{
2016 		SwRedline* pTmp = rArr[ n ];
2017 		if( pTmp->HasMark() && pTmp->IsVisible() )
2018 		{
2019 			if( *pTmp->End() <= *pEnd )
2020 			{
2021 				if( (*fn_AcceptReject)( rArr, n, bCallDelete, 0, 0 ))
2022 					nCount++; // #111827#
2023 			}
2024 			else
2025 			{
2026 				if( *pTmp->Start() < *pEnd )
2027 				{
2028 					// dann nur in der TeilSelektion aufheben
2029 					if( (*fn_AcceptReject)( rArr, n, bCallDelete, pStt, pEnd ))
2030 						nCount++; // #111827#
2031 				}
2032 				break;
2033 			}
2034 		}
2035 	}
2036 	return nCount; // #111827#
2037 }
2038 
lcl_AdjustRedlineRange(SwPaM & rPam)2039 void lcl_AdjustRedlineRange( SwPaM& rPam )
2040 {
2041 	// die Selektion steht nur im ContentBereich. Wenn es aber Redlines
2042 	// davor oder dahinter auf nicht ContentNodes stehen, dann erweiter die
2043 	// die Selection auf diese
2044 	SwPosition* pStt = rPam.Start(),
2045 			  * pEnd = pStt == rPam.GetPoint() ? rPam.GetMark()
2046 											   : rPam.GetPoint();
2047 	SwDoc* pDoc = rPam.GetDoc();
2048 	if( !pStt->nContent.GetIndex() &&
2049 		!pDoc->GetNodes()[ pStt->nNode.GetIndex() - 1 ]->IsCntntNode() )
2050 	{
2051 		const SwRedline* pRedl = pDoc->GetRedline( *pStt, 0 );
2052 		if( pRedl )
2053 		{
2054 			const SwPosition* pRStt = pRedl->Start();
2055 			if( !pRStt->nContent.GetIndex() && pRStt->nNode.GetIndex() ==
2056 				pStt->nNode.GetIndex() - 1 )
2057 				*pStt = *pRStt;
2058 		}
2059 	}
2060 	if( pEnd->nNode.GetNode().IsCntntNode() &&
2061 		!pDoc->GetNodes()[ pEnd->nNode.GetIndex() + 1 ]->IsCntntNode() &&
2062 		pEnd->nContent.GetIndex() == pEnd->nNode.GetNode().GetCntntNode()->Len()	)
2063 	{
2064 		const SwRedline* pRedl = pDoc->GetRedline( *pEnd, 0 );
2065 		if( pRedl )
2066 		{
2067 			const SwPosition* pREnd = pRedl->End();
2068 			if( !pREnd->nContent.GetIndex() && pREnd->nNode.GetIndex() ==
2069 				pEnd->nNode.GetIndex() + 1 )
2070 				*pEnd = *pREnd;
2071 		}
2072 	}
2073 }
2074 
2075 
AcceptRedline(sal_uInt16 nPos,bool bCallDelete)2076 bool SwDoc::AcceptRedline( sal_uInt16 nPos, bool bCallDelete )
2077 {
2078 	sal_Bool bRet = sal_False;
2079 
2080 	// aufjedenfall auf sichtbar umschalten
2081     if( (nsRedlineMode_t::REDLINE_SHOW_INSERT | nsRedlineMode_t::REDLINE_SHOW_DELETE) !=
2082         (nsRedlineMode_t::REDLINE_SHOW_MASK & eRedlineMode) )
2083       SetRedlineMode( (RedlineMode_t)(nsRedlineMode_t::REDLINE_SHOW_INSERT | nsRedlineMode_t::REDLINE_SHOW_DELETE | eRedlineMode));
2084 
2085 	SwRedline* pTmp = (*pRedlineTbl)[ nPos ];
2086 	if( pTmp->HasMark() && pTmp->IsVisible() )
2087 	{
2088         if (GetIDocumentUndoRedo().DoesUndo())
2089         {
2090             // #111827#
2091             SwRewriter aRewriter;
2092 
2093             aRewriter.AddRule(UNDO_ARG1, pTmp->GetDescr());
2094             GetIDocumentUndoRedo().StartUndo(UNDO_ACCEPT_REDLINE, &aRewriter);
2095         }
2096 
2097 		int nLoopCnt = 2;
2098 		sal_uInt16 nSeqNo = pTmp->GetSeqNo();
2099 
2100 		do {
2101 
2102             if (GetIDocumentUndoRedo().DoesUndo())
2103             {
2104                 SwUndo *const pUndo( new SwUndoAcceptRedline(*pTmp) );
2105                 GetIDocumentUndoRedo().AppendUndo(pUndo);
2106             }
2107 
2108 			bRet |= lcl_AcceptRedline( *pRedlineTbl, nPos, bCallDelete );
2109 
2110 			if( nSeqNo )
2111 			{
2112 				if( USHRT_MAX == nPos )
2113 					nPos = 0;
2114 				sal_uInt16 nFndPos = 2 == nLoopCnt
2115 									? pRedlineTbl->FindNextSeqNo( nSeqNo, nPos )
2116 									: pRedlineTbl->FindPrevSeqNo( nSeqNo, nPos );
2117 				if( USHRT_MAX != nFndPos || ( 0 != ( --nLoopCnt ) &&
2118 					USHRT_MAX != ( nFndPos =
2119 						pRedlineTbl->FindPrevSeqNo( nSeqNo, nPos ))) )
2120 					pTmp = (*pRedlineTbl)[ nPos = nFndPos ];
2121 				else
2122 					nLoopCnt = 0;
2123 			}
2124 			else
2125 				nLoopCnt = 0;
2126 
2127 		} while( nLoopCnt );
2128 
2129 		if( bRet )
2130 		{
2131 			CompressRedlines();
2132 			SetModified();
2133 		}
2134 
2135         if (GetIDocumentUndoRedo().DoesUndo())
2136         {
2137             GetIDocumentUndoRedo().EndUndo(UNDO_END, 0);
2138         }
2139 	}
2140 	return bRet;
2141 }
2142 
AcceptRedline(const SwPaM & rPam,bool bCallDelete)2143 bool SwDoc::AcceptRedline( const SwPaM& rPam, bool bCallDelete )
2144 {
2145 	// aufjedenfall auf sichtbar umschalten
2146     if( (nsRedlineMode_t::REDLINE_SHOW_INSERT | nsRedlineMode_t::REDLINE_SHOW_DELETE) !=
2147         (nsRedlineMode_t::REDLINE_SHOW_MASK & eRedlineMode) )
2148       SetRedlineMode( (RedlineMode_t)(nsRedlineMode_t::REDLINE_SHOW_INSERT | nsRedlineMode_t::REDLINE_SHOW_DELETE | eRedlineMode));
2149 
2150 	// die Selektion steht nur im ContentBereich. Wenn es aber Redlines
2151 	// davor oder dahinter auf nicht ContentNodes stehen, dann erweiter die
2152 	// die Selection auf diese
2153 	SwPaM aPam( *rPam.GetMark(), *rPam.GetPoint() );
2154 	lcl_AdjustRedlineRange( aPam );
2155 
2156     if (GetIDocumentUndoRedo().DoesUndo())
2157     {
2158         GetIDocumentUndoRedo().StartUndo( UNDO_ACCEPT_REDLINE, NULL );
2159         GetIDocumentUndoRedo().AppendUndo( new SwUndoAcceptRedline( aPam ));
2160     }
2161 
2162     // #111827#
2163 	int nRet = lcl_AcceptRejectRedl( lcl_AcceptRedline, *pRedlineTbl,
2164                                      bCallDelete, aPam );
2165 	if( nRet > 0 )
2166 	{
2167 		CompressRedlines();
2168 		SetModified();
2169 	}
2170     if (GetIDocumentUndoRedo().DoesUndo())
2171     {
2172         // #111827#
2173         String aTmpStr;
2174 
2175         {
2176             SwRewriter aRewriter;
2177             aRewriter.AddRule(UNDO_ARG1, String::CreateFromInt32(nRet));
2178             aTmpStr = aRewriter.Apply(String(SW_RES(STR_N_REDLINES)));
2179         }
2180 
2181         SwRewriter aRewriter;
2182         aRewriter.AddRule(UNDO_ARG1, aTmpStr);
2183 
2184         GetIDocumentUndoRedo().EndUndo( UNDO_ACCEPT_REDLINE, &aRewriter );
2185     }
2186 	return nRet != 0;
2187 }
2188 
RejectRedline(sal_uInt16 nPos,bool bCallDelete)2189 bool SwDoc::RejectRedline( sal_uInt16 nPos, bool bCallDelete )
2190 {
2191 	sal_Bool bRet = sal_False;
2192 
2193 	// aufjedenfall auf sichtbar umschalten
2194     if( (nsRedlineMode_t::REDLINE_SHOW_INSERT | nsRedlineMode_t::REDLINE_SHOW_DELETE) !=
2195         (nsRedlineMode_t::REDLINE_SHOW_MASK & eRedlineMode) )
2196       SetRedlineMode( (RedlineMode_t)(nsRedlineMode_t::REDLINE_SHOW_INSERT | nsRedlineMode_t::REDLINE_SHOW_DELETE | eRedlineMode));
2197 
2198 	SwRedline* pTmp = (*pRedlineTbl)[ nPos ];
2199 	if( pTmp->HasMark() && pTmp->IsVisible() )
2200 	{
2201         if (GetIDocumentUndoRedo().DoesUndo())
2202         {
2203             // #111827#
2204             SwRewriter aRewriter;
2205 
2206             aRewriter.AddRule(UNDO_ARG1, pTmp->GetDescr());
2207             GetIDocumentUndoRedo().StartUndo(UNDO_REJECT_REDLINE, &aRewriter);
2208         }
2209 
2210 		int nLoopCnt = 2;
2211 		sal_uInt16 nSeqNo = pTmp->GetSeqNo();
2212 
2213 		do {
2214 
2215             if (GetIDocumentUndoRedo().DoesUndo())
2216             {
2217                 SwUndo *const pUndo( new SwUndoRejectRedline( *pTmp ) );
2218                 GetIDocumentUndoRedo().AppendUndo(pUndo);
2219             }
2220 
2221 			bRet |= lcl_RejectRedline( *pRedlineTbl, nPos, bCallDelete );
2222 
2223 			if( nSeqNo )
2224 			{
2225 				if( USHRT_MAX == nPos )
2226 					nPos = 0;
2227 				sal_uInt16 nFndPos = 2 == nLoopCnt
2228 									? pRedlineTbl->FindNextSeqNo( nSeqNo, nPos )
2229 									: pRedlineTbl->FindPrevSeqNo( nSeqNo, nPos );
2230 				if( USHRT_MAX != nFndPos || ( 0 != ( --nLoopCnt ) &&
2231 					USHRT_MAX != ( nFndPos =
2232 							pRedlineTbl->FindPrevSeqNo( nSeqNo, nPos ))) )
2233 					pTmp = (*pRedlineTbl)[ nPos = nFndPos ];
2234 				else
2235 					nLoopCnt = 0;
2236 			}
2237 			else
2238 				nLoopCnt = 0;
2239 
2240 		} while( nLoopCnt );
2241 
2242 		if( bRet )
2243 		{
2244 			CompressRedlines();
2245 			SetModified();
2246 		}
2247 
2248         if (GetIDocumentUndoRedo().DoesUndo())
2249         {
2250             GetIDocumentUndoRedo().EndUndo(UNDO_END, 0);
2251         }
2252 	}
2253 	return bRet;
2254 }
2255 
RejectRedline(const SwPaM & rPam,bool bCallDelete)2256 bool SwDoc::RejectRedline( const SwPaM& rPam, bool bCallDelete )
2257 {
2258 	// aufjedenfall auf sichtbar umschalten
2259     if( (nsRedlineMode_t::REDLINE_SHOW_INSERT | nsRedlineMode_t::REDLINE_SHOW_DELETE) !=
2260         (nsRedlineMode_t::REDLINE_SHOW_MASK & eRedlineMode) )
2261       SetRedlineMode((RedlineMode_t)(nsRedlineMode_t::REDLINE_SHOW_INSERT | nsRedlineMode_t::REDLINE_SHOW_DELETE | eRedlineMode));
2262 
2263 	// die Selektion steht nur im ContentBereich. Wenn es aber Redlines
2264 	// davor oder dahinter auf nicht ContentNodes stehen, dann erweiter die
2265 	// die Selection auf diese
2266 	SwPaM aPam( *rPam.GetMark(), *rPam.GetPoint() );
2267 	lcl_AdjustRedlineRange( aPam );
2268 
2269     if (GetIDocumentUndoRedo().DoesUndo())
2270     {
2271         GetIDocumentUndoRedo().StartUndo( UNDO_REJECT_REDLINE, NULL );
2272         GetIDocumentUndoRedo().AppendUndo( new SwUndoRejectRedline(aPam) );
2273     }
2274 
2275     // #111827#
2276 	int nRet = lcl_AcceptRejectRedl( lcl_RejectRedline, *pRedlineTbl,
2277 										bCallDelete, aPam );
2278 	if( nRet > 0 )
2279 	{
2280 		CompressRedlines();
2281 		SetModified();
2282 	}
2283     if (GetIDocumentUndoRedo().DoesUndo())
2284     {
2285         // #111827#
2286         String aTmpStr;
2287 
2288         {
2289             SwRewriter aRewriter;
2290             aRewriter.AddRule(UNDO_ARG1, String::CreateFromInt32(nRet));
2291             aTmpStr = aRewriter.Apply(String(SW_RES(STR_N_REDLINES)));
2292         }
2293 
2294         SwRewriter aRewriter;
2295         aRewriter.AddRule(UNDO_ARG1, aTmpStr);
2296 
2297         GetIDocumentUndoRedo().EndUndo( UNDO_REJECT_REDLINE, &aRewriter );
2298     }
2299 
2300 	return nRet != 0;
2301 }
2302 
SelNextRedline(SwPaM & rPam) const2303 const SwRedline* SwDoc::SelNextRedline( SwPaM& rPam ) const
2304 {
2305 	rPam.DeleteMark();
2306 	rPam.SetMark();
2307 
2308 	SwPosition& rSttPos = *rPam.GetPoint();
2309 	SwPosition aSavePos( rSttPos );
2310 	sal_Bool bRestart;
2311 
2312 	// sollte die StartPos auf dem letzen gueligen ContentNode stehen,
2313 	// dann aufjedenfall das naechste Redline nehmen
2314 	sal_uInt16 n = 0;
2315 	const SwRedline* pFnd = lcl_FindCurrRedline( rSttPos, n, sal_True );
2316 	if( pFnd )
2317 	{
2318 		const SwPosition* pEnd = pFnd->End();
2319 		if( !pEnd->nNode.GetNode().IsCntntNode() )
2320 		{
2321 			SwNodeIndex aTmp( pEnd->nNode );
2322 			SwCntntNode* pCNd = GetNodes().GoPrevSection( &aTmp );
2323 			if( !pCNd || ( aTmp == rSttPos.nNode &&
2324 				pCNd->Len() == rSttPos.nContent.GetIndex() ))
2325 				pFnd = 0;
2326 		}
2327 		if( pFnd )
2328 			rSttPos = *pFnd->End();
2329 	}
2330 
2331 	do {
2332 		bRestart = sal_False;
2333 
2334 		for( ; !pFnd && n < pRedlineTbl->Count(); ++n )
2335 		{
2336 			pFnd = (*pRedlineTbl)[ n ];
2337 			if( pFnd->HasMark() && pFnd->IsVisible() )
2338 			{
2339 				*rPam.GetMark() = *pFnd->Start();
2340 				rSttPos = *pFnd->End();
2341 				break;
2342 			}
2343 			else
2344 				pFnd = 0;
2345 		}
2346 
2347 		if( pFnd )
2348 		{
2349 			// alle vom gleichen Typ und Author, die hinter einander liegen
2350 			// zu einer Selektion zusammenfassen.
2351 			const SwPosition* pPrevEnd = pFnd->End();
2352 			while( ++n < pRedlineTbl->Count() )
2353 			{
2354 				const SwRedline* pTmp = (*pRedlineTbl)[ n ];
2355 				if( pTmp->HasMark() && pTmp->IsVisible() )
2356 				{
2357 					const SwPosition *pRStt;
2358 					if( pFnd->GetType() == pTmp->GetType() &&
2359 						pFnd->GetAuthor() == pTmp->GetAuthor() &&
2360 						( *pPrevEnd == *( pRStt = pTmp->Start() ) ||
2361 						  IsPrevPos( *pPrevEnd, *pRStt )) )
2362 					{
2363 						pPrevEnd = pTmp->End();
2364 						rSttPos = *pPrevEnd;
2365 					}
2366 					else
2367 						break;
2368 				}
2369 			}
2370 		}
2371 
2372 		if( pFnd )
2373 		{
2374 			const SwRedline* pSaveFnd = pFnd;
2375 
2376 			SwCntntNode* pCNd;
2377 			SwNodeIndex* pIdx = &rPam.GetMark()->nNode;
2378 			if( !pIdx->GetNode().IsCntntNode() &&
2379 				0 != ( pCNd = GetNodes().GoNextSection( pIdx )) )
2380 			{
2381 				if( *pIdx <= rPam.GetPoint()->nNode )
2382 					rPam.GetMark()->nContent.Assign( pCNd, 0 );
2383 				else
2384 					pFnd = 0;
2385 			}
2386 
2387 			if( pFnd )
2388 			{
2389 				pIdx = &rPam.GetPoint()->nNode;
2390 				if( !pIdx->GetNode().IsCntntNode() &&
2391 					0 != ( pCNd = GetNodes().GoPrevSection( pIdx )) )
2392 				{
2393 					if( *pIdx >= rPam.GetMark()->nNode )
2394 						rPam.GetPoint()->nContent.Assign( pCNd, pCNd->Len() );
2395 					else
2396 						pFnd = 0;
2397 				}
2398 			}
2399 
2400 			if( !pFnd || *rPam.GetMark() == *rPam.GetPoint() )
2401 			{
2402 				if( n < pRedlineTbl->Count() )
2403 				{
2404 					bRestart = sal_True;
2405 					*rPam.GetPoint() = *pSaveFnd->End();
2406 				}
2407 				else
2408 				{
2409 					rPam.DeleteMark();
2410 					*rPam.GetPoint() = aSavePos;
2411 				}
2412 				pFnd = 0;
2413 			}
2414 		}
2415 	} while( bRestart );
2416 
2417 	return pFnd;
2418 }
2419 
SelPrevRedline(SwPaM & rPam) const2420 const SwRedline* SwDoc::SelPrevRedline( SwPaM& rPam ) const
2421 {
2422 	rPam.DeleteMark();
2423 	rPam.SetMark();
2424 
2425 	SwPosition& rSttPos = *rPam.GetPoint();
2426 	SwPosition aSavePos( rSttPos );
2427 	sal_Bool bRestart;
2428 
2429 	// sollte die StartPos auf dem ersten gueligen ContentNode stehen,
2430 	// dann aufjedenfall das vorherige Redline nehmen
2431 	sal_uInt16 n = 0;
2432 	const SwRedline* pFnd = lcl_FindCurrRedline( rSttPos, n, sal_False );
2433 	if( pFnd )
2434 	{
2435 		const SwPosition* pStt = pFnd->Start();
2436 		if( !pStt->nNode.GetNode().IsCntntNode() )
2437 		{
2438 			SwNodeIndex aTmp( pStt->nNode );
2439 			SwCntntNode* pCNd = GetNodes().GoNextSection( &aTmp );
2440 			if( !pCNd || ( aTmp == rSttPos.nNode &&
2441 				!rSttPos.nContent.GetIndex() ))
2442 				pFnd = 0;
2443 		}
2444 		if( pFnd )
2445 			rSttPos = *pFnd->Start();
2446 	}
2447 
2448 	do {
2449 		bRestart = sal_False;
2450 
2451 		while( !pFnd && 0 < n )
2452 		{
2453 			pFnd = (*pRedlineTbl)[ --n ];
2454 			if( pFnd->HasMark() && pFnd->IsVisible() )
2455 			{
2456 				*rPam.GetMark() = *pFnd->End();
2457 				rSttPos = *pFnd->Start();
2458 			}
2459 			else
2460 				pFnd = 0;
2461 		}
2462 
2463 		if( pFnd )
2464 		{
2465 			// alle vom gleichen Typ und Author, die hinter einander liegen
2466 			// zu einer Selektion zusammenfassen.
2467 			const SwPosition* pNextStt = pFnd->Start();
2468 			while( 0 < n )
2469 			{
2470 				const SwRedline* pTmp = (*pRedlineTbl)[ --n ];
2471 				if( pTmp->HasMark() && pTmp->IsVisible() )
2472 				{
2473 					const SwPosition *pREnd;
2474 					if( pFnd->GetType() == pTmp->GetType() &&
2475 						pFnd->GetAuthor() == pTmp->GetAuthor() &&
2476 						( *pNextStt == *( pREnd = pTmp->End() ) ||
2477 						  IsPrevPos( *pREnd, *pNextStt )) )
2478 					{
2479 						pNextStt = pTmp->Start();
2480 						rSttPos = *pNextStt;
2481 					}
2482 					else
2483 					{
2484 						++n;
2485 						break;
2486 					}
2487 				}
2488 			}
2489 		}
2490 
2491 		if( pFnd )
2492 		{
2493 			const SwRedline* pSaveFnd = pFnd;
2494 
2495 			SwCntntNode* pCNd;
2496 			SwNodeIndex* pIdx = &rPam.GetMark()->nNode;
2497 			if( !pIdx->GetNode().IsCntntNode() &&
2498 				0 != ( pCNd = GetNodes().GoPrevSection( pIdx )) )
2499 			{
2500 				if( *pIdx >= rPam.GetPoint()->nNode )
2501 					rPam.GetMark()->nContent.Assign( pCNd, pCNd->Len() );
2502 				else
2503 					pFnd = 0;
2504 			}
2505 
2506 			if( pFnd )
2507 			{
2508 				pIdx = &rPam.GetPoint()->nNode;
2509 				if( !pIdx->GetNode().IsCntntNode() &&
2510 					0 != ( pCNd = GetNodes().GoNextSection( pIdx )) )
2511 				{
2512 					if( *pIdx <= rPam.GetMark()->nNode )
2513 						rPam.GetPoint()->nContent.Assign( pCNd, 0 );
2514 					else
2515 						pFnd = 0;
2516 				}
2517 			}
2518 
2519 			if( !pFnd || *rPam.GetMark() == *rPam.GetPoint() )
2520 			{
2521 				if( n )
2522 				{
2523 					bRestart = sal_True;
2524 					*rPam.GetPoint() = *pSaveFnd->Start();
2525 				}
2526 				else
2527 				{
2528 					rPam.DeleteMark();
2529 					*rPam.GetPoint() = aSavePos;
2530 				}
2531 				pFnd = 0;
2532 			}
2533 		}
2534 	} while( bRestart );
2535 
2536 	return pFnd;
2537 }
2538 
2539 // Kommentar am Redline setzen
SetRedlineComment(const SwPaM & rPaM,const String & rS)2540 bool SwDoc::SetRedlineComment( const SwPaM& rPaM, const String& rS )
2541 {
2542 	sal_Bool bRet = sal_False;
2543 	const SwPosition* pStt = rPaM.Start(),
2544 					* pEnd = pStt == rPaM.GetPoint() ? rPaM.GetMark()
2545 													 : rPaM.GetPoint();
2546 	sal_uInt16 n = 0;
2547 	if( lcl_FindCurrRedline( *pStt, n, sal_True ) )
2548 	{
2549 		for( ; n < pRedlineTbl->Count(); ++n )
2550 		{
2551 			bRet = sal_True;
2552 			SwRedline* pTmp = (*pRedlineTbl)[ n ];
2553 			if( pStt != pEnd && *pTmp->Start() > *pEnd )
2554 				break;
2555 
2556 			pTmp->SetComment( rS );
2557 			if( *pTmp->End() >= *pEnd )
2558 				break;
2559 		}
2560 	}
2561 	if( bRet )
2562 		SetModified();
2563 
2564 	return bRet;
2565 }
2566 
2567 // legt gebenenfalls einen neuen Author an
GetRedlineAuthor()2568 sal_uInt16 SwDoc::GetRedlineAuthor()
2569 {
2570 	return SW_MOD()->GetRedlineAuthor();
2571 }
2572 
2573 	// fuer die Reader usw. - neuen Author in die Tabelle eintragen
InsertRedlineAuthor(const String & rNew)2574 sal_uInt16 SwDoc::InsertRedlineAuthor( const String& rNew )
2575 {
2576 	return SW_MOD()->InsertRedlineAuthor(rNew);
2577 }
2578 
UpdateRedlineAttr()2579 void SwDoc::UpdateRedlineAttr()
2580 {
2581 	const SwRedlineTbl& rTbl = GetRedlineTbl();
2582 	for( sal_uInt16 n = 0; n < rTbl.Count(); ++n )
2583 	{
2584 		SwRedline* pRedl = rTbl[ n ];
2585 		if( pRedl->IsVisible() )
2586 			pRedl->InvalidateRange();
2587 	}
2588 }
2589 
2590 	// setze Kommentar-Text fuers Redline, das dann per AppendRedline
2591 	// hereinkommt. Wird vom Autoformat benutzt. 0-Pointer setzt den Modus
2592 	// wieder zurueck. Pointer wird nicht kopiert, muss also gueltig bleiben!
SetAutoFmtRedlineComment(const String * pTxt,sal_uInt16 nSeqNo)2593 void SwDoc::SetAutoFmtRedlineComment( const String* pTxt, sal_uInt16 nSeqNo )
2594 {
2595 	mbIsAutoFmtRedline = 0 != pTxt;
2596 	if( pTxt )
2597 	{
2598 		if( !pAutoFmtRedlnComment )
2599 			pAutoFmtRedlnComment = new String( *pTxt );
2600 		else
2601 			*pAutoFmtRedlnComment = *pTxt;
2602 	}
2603 	else if( pAutoFmtRedlnComment )
2604 		delete pAutoFmtRedlnComment, pAutoFmtRedlnComment = 0;
2605 
2606 	nAutoFmtRedlnCommentNo = nSeqNo;
2607 }
2608 
SetRedlinePassword(const uno::Sequence<sal_Int8> & rNewPassword)2609 void SwDoc::SetRedlinePassword(
2610             /*[in]*/const uno::Sequence <sal_Int8>& rNewPassword)
2611 {
2612 	aRedlinePasswd = rNewPassword;
2613 	SetModified();
2614 }
2615 
2616 /*  */
2617 
Insert(SwRedlinePtr & p,sal_Bool bIns)2618 sal_Bool SwRedlineTbl::Insert( SwRedlinePtr& p, sal_Bool bIns )
2619 {
2620 	sal_Bool bRet = sal_False;
2621 	if( p->HasValidRange() )
2622 	{
2623 		bRet = _SwRedlineTbl::Insert( p );
2624 		p->CallDisplayFunc();
2625 	}
2626 	else if( bIns )
2627 		bRet = InsertWithValidRanges( p );
2628 	else
2629 	{
2630 		ASSERT( !this, "Redline: falscher Bereich" );
2631 	}
2632 	return bRet;
2633 }
2634 
Insert(SwRedlinePtr & p,sal_uInt16 & rP,sal_Bool bIns)2635 sal_Bool SwRedlineTbl::Insert( SwRedlinePtr& p, sal_uInt16& rP, sal_Bool bIns )
2636 {
2637 	sal_Bool bRet = sal_False;
2638 	if( p->HasValidRange() )
2639 	{
2640 		bRet = _SwRedlineTbl::Insert( p, rP );
2641 		p->CallDisplayFunc();
2642 	}
2643 	else if( bIns )
2644 		bRet = InsertWithValidRanges( p, &rP );
2645 	else
2646 	{
2647 		ASSERT( !this, "Redline: falscher Bereich" );
2648 	}
2649 	return bRet;
2650 }
2651 
InsertWithValidRanges(SwRedlinePtr & p,sal_uInt16 * pInsPos)2652 sal_Bool SwRedlineTbl::InsertWithValidRanges( SwRedlinePtr& p, sal_uInt16* pInsPos )
2653 {
2654 	// erzeuge aus den Selektion gueltige "Teilbereiche".
2655 	sal_Bool bAnyIns = sal_False;
2656 	SwPosition* pStt = p->Start(),
2657 			  * pEnd = pStt == p->GetPoint() ? p->GetMark() : p->GetPoint();
2658 	SwPosition aNewStt( *pStt );
2659 	SwNodes& rNds = aNewStt.nNode.GetNodes();
2660 	SwCntntNode* pC;
2661 
2662 	if( !aNewStt.nNode.GetNode().IsCntntNode() )
2663 	{
2664 		pC = rNds.GoNext( &aNewStt.nNode );
2665 		if( pC )
2666 			aNewStt.nContent.Assign( pC, 0 );
2667 		else
2668 			aNewStt.nNode = rNds.GetEndOfContent();
2669 	}
2670 
2671 	SwRedline* pNew = 0;
2672 	sal_uInt16 nInsPos;
2673 
2674 	if( aNewStt < *pEnd )
2675 		do {
2676 			if( !pNew )
2677 				pNew = new SwRedline( p->GetRedlineData(), aNewStt );
2678 			else
2679 			{
2680 				pNew->DeleteMark();
2681 				*pNew->GetPoint() = aNewStt;
2682 			}
2683 
2684 			pNew->SetMark();
2685 			GoEndSection( pNew->GetPoint() );
2686             // i60396: If the redlines starts before a table but the table is the last member
2687             // of the section, the GoEndSection will end inside the table.
2688             // This will result in an incorrect redline, so we've to go back
2689             SwNode* pTab = pNew->GetPoint()->nNode.GetNode().StartOfSectionNode()->FindTableNode();
2690             // We end in a table when pTab != 0
2691             if( pTab && !pNew->GetMark()->nNode.GetNode().StartOfSectionNode()->FindTableNode() )
2692             { // but our Mark was outside the table => Correction
2693                 do
2694                 {
2695                     // We want to be before the table
2696                     *pNew->GetPoint() = SwPosition(*pTab);
2697                     pC = GoPreviousNds( &pNew->GetPoint()->nNode, sal_False ); // here we are.
2698                     if( pC )
2699                         pNew->GetPoint()->nContent.Assign( pC, 0 );
2700                     pTab = pNew->GetPoint()->nNode.GetNode().StartOfSectionNode()->FindTableNode();
2701                 }while( pTab ); // If there is another table we have to repeat our step backwards
2702             }
2703 
2704 			if( *pNew->GetPoint() > *pEnd )
2705 			{
2706 				pC = 0;
2707 				if( aNewStt.nNode != pEnd->nNode )
2708 					do {
2709 						SwNode& rCurNd = aNewStt.nNode.GetNode();
2710 						if( rCurNd.IsStartNode() )
2711 						{
2712 							if( rCurNd.EndOfSectionIndex() < pEnd->nNode.GetIndex() )
2713 								aNewStt.nNode = *rCurNd.EndOfSectionNode();
2714 							else
2715 								break;
2716 						}
2717 						else if( rCurNd.IsCntntNode() )
2718 							pC = rCurNd.GetCntntNode();
2719 						aNewStt.nNode++;
2720 					} while( aNewStt.nNode.GetIndex() < pEnd->nNode.GetIndex() );
2721 
2722 				if( aNewStt.nNode == pEnd->nNode )
2723 					aNewStt.nContent = pEnd->nContent;
2724 				else if( pC )
2725 				{
2726 					aNewStt.nNode = *pC;
2727 					aNewStt.nContent.Assign( pC, pC->Len() );
2728 				}
2729 
2730 				if( aNewStt <= *pEnd )
2731 					*pNew->GetPoint() = aNewStt;
2732 			}
2733 			else
2734 				aNewStt = *pNew->GetPoint();
2735 #ifdef DEBUG
2736             CheckPosition( pNew->GetPoint(), pNew->GetMark() );
2737 #endif
2738 			if( *pNew->GetPoint() != *pNew->GetMark() &&
2739 				_SwRedlineTbl::Insert( pNew, nInsPos ) )
2740 			{
2741 				pNew->CallDisplayFunc();
2742 				bAnyIns = sal_True;
2743 				pNew = 0;
2744 				if( pInsPos && *pInsPos < nInsPos )
2745 					*pInsPos = nInsPos;
2746 			}
2747 
2748 			if( aNewStt >= *pEnd ||
2749 				0 == (pC = rNds.GoNext( &aNewStt.nNode )) )
2750 				break;
2751 
2752 			aNewStt.nContent.Assign( pC, 0 );
2753 
2754 		} while( aNewStt < *pEnd );
2755 
2756 	delete pNew;
2757 	delete p, p = 0;
2758 	return bAnyIns;
2759 }
2760 
Remove(sal_uInt16 nP,sal_uInt16 nL)2761 void SwRedlineTbl::Remove( sal_uInt16 nP, sal_uInt16 nL )
2762 {
2763 	SwDoc* pDoc = 0;
2764 	if( !nP && nL && nL == _SwRedlineTbl::Count() )
2765 		pDoc = _SwRedlineTbl::GetObject( 0 )->GetDoc();
2766 
2767 	_SwRedlineTbl::Remove( nP, nL );
2768 
2769 	ViewShell* pSh;
2770 	if( pDoc && !pDoc->IsInDtor() &&
2771 		0 != ( pSh = pDoc->GetCurrentViewShell()) )	//swmod 071108//swmod 071225
2772 		pSh->InvalidateWindows( SwRect( 0, 0, LONG_MAX, LONG_MAX ) );
2773 }
2774 
DeleteAndDestroy(sal_uInt16 nP,sal_uInt16 nL)2775 void SwRedlineTbl::DeleteAndDestroy( sal_uInt16 nP, sal_uInt16 nL )
2776 {
2777 	SwDoc* pDoc = 0;
2778 	if( !nP && nL && nL == _SwRedlineTbl::Count() )
2779 		pDoc = _SwRedlineTbl::GetObject( 0 )->GetDoc();
2780 
2781 	_SwRedlineTbl::DeleteAndDestroy( nP, nL );
2782 
2783 	ViewShell* pSh;
2784 	if( pDoc && !pDoc->IsInDtor() &&
2785 		0 != ( pSh = pDoc->GetCurrentViewShell() ) )	//swmod 071108//swmod 071225
2786 		pSh->InvalidateWindows( SwRect( 0, 0, LONG_MAX, LONG_MAX ) );
2787 }
2788 
2789 // suche den naechsten oder vorherigen Redline mit dergleichen Seq.No
2790 // Mit dem Lookahead kann die Suche eingeschraenkt werden. 0 oder
2791 // USHRT_MAX suchen im gesamten Array.
FindNextOfSeqNo(sal_uInt16 nSttPos,sal_uInt16 nLookahead) const2792 sal_uInt16 SwRedlineTbl::FindNextOfSeqNo( sal_uInt16 nSttPos, sal_uInt16 nLookahead ) const
2793 {
2794 	return nSttPos + 1 < _SwRedlineTbl::Count()
2795 				? FindNextSeqNo( _SwRedlineTbl::GetObject( nSttPos )
2796 									->GetSeqNo(), nSttPos+1, nLookahead )
2797 				: USHRT_MAX;
2798 }
2799 
FindPrevOfSeqNo(sal_uInt16 nSttPos,sal_uInt16 nLookahead) const2800 sal_uInt16 SwRedlineTbl::FindPrevOfSeqNo( sal_uInt16 nSttPos, sal_uInt16 nLookahead ) const
2801 {
2802 	return nSttPos ? FindPrevSeqNo( _SwRedlineTbl::GetObject(
2803 										nSttPos )->GetSeqNo(),
2804 									nSttPos-1, nLookahead )
2805 				   : USHRT_MAX;
2806 }
2807 
FindNextSeqNo(sal_uInt16 nSeqNo,sal_uInt16 nSttPos,sal_uInt16 nLookahead) const2808 sal_uInt16 SwRedlineTbl::FindNextSeqNo( sal_uInt16 nSeqNo, sal_uInt16 nSttPos,
2809 									sal_uInt16 nLookahead ) const
2810 {
2811 	sal_uInt16 nRet = USHRT_MAX, nEnd;
2812 	if( nSeqNo && nSttPos < _SwRedlineTbl::Count() )
2813 	{
2814 		nEnd = _SwRedlineTbl::Count();
2815 		if( nLookahead && USHRT_MAX != nLookahead &&
2816 			nSttPos + nLookahead < _SwRedlineTbl::Count() )
2817 			nEnd = nSttPos + nLookahead;
2818 
2819 		for( ; nSttPos < nEnd; ++nSttPos )
2820 			if( nSeqNo == _SwRedlineTbl::GetObject( nSttPos )->GetSeqNo() )
2821 			{
2822 				nRet = nSttPos;
2823 				break;
2824 			}
2825 	}
2826 	return nRet;
2827 }
2828 
FindPrevSeqNo(sal_uInt16 nSeqNo,sal_uInt16 nSttPos,sal_uInt16 nLookahead) const2829 sal_uInt16 SwRedlineTbl::FindPrevSeqNo( sal_uInt16 nSeqNo, sal_uInt16 nSttPos,
2830 									sal_uInt16 nLookahead ) const
2831 {
2832 	sal_uInt16 nRet = USHRT_MAX, nEnd;
2833 	if( nSeqNo && nSttPos < _SwRedlineTbl::Count() )
2834 	{
2835 		nEnd = 0;
2836 		if( nLookahead && USHRT_MAX != nLookahead && nSttPos > nLookahead )
2837 			nEnd = nSttPos - nLookahead;
2838 
2839 		++nSttPos;
2840 		while( nSttPos > nEnd )
2841 			if( nSeqNo == _SwRedlineTbl::GetObject( --nSttPos )->GetSeqNo() )
2842 			{
2843 				nRet = nSttPos;
2844 				break;
2845 			}
2846 	}
2847 	return nRet;
2848 }
2849 
2850 /*  */
2851 
~SwRedlineExtraData()2852 SwRedlineExtraData::~SwRedlineExtraData()
2853 {
2854 }
2855 
Accept(SwPaM &) const2856 void SwRedlineExtraData::Accept( SwPaM& ) const
2857 {
2858 }
2859 
Reject(SwPaM &) const2860 void SwRedlineExtraData::Reject( SwPaM& ) const
2861 {
2862 }
2863 
operator ==(const SwRedlineExtraData &) const2864 int SwRedlineExtraData::operator == ( const SwRedlineExtraData& ) const
2865 {
2866 	return sal_False;
2867 }
2868 
2869 
SwRedlineExtraData_FmtColl(const String & rColl,sal_uInt16 nPoolFmtId,const SfxItemSet * pItemSet)2870 SwRedlineExtraData_FmtColl::SwRedlineExtraData_FmtColl( const String& rColl,
2871 												sal_uInt16 nPoolFmtId,
2872 												const SfxItemSet* pItemSet )
2873 	: sFmtNm(rColl), pSet(0), nPoolId(nPoolFmtId)
2874 {
2875 	if( pItemSet && pItemSet->Count() )
2876 		pSet = new SfxItemSet( *pItemSet );
2877 }
2878 
~SwRedlineExtraData_FmtColl()2879 SwRedlineExtraData_FmtColl::~SwRedlineExtraData_FmtColl()
2880 {
2881 	delete pSet;
2882 }
2883 
CreateNew() const2884 SwRedlineExtraData* SwRedlineExtraData_FmtColl::CreateNew() const
2885 {
2886 	return new SwRedlineExtraData_FmtColl( sFmtNm, nPoolId, pSet );
2887 }
2888 
Reject(SwPaM & rPam) const2889 void SwRedlineExtraData_FmtColl::Reject( SwPaM& rPam ) const
2890 {
2891 	SwDoc* pDoc = rPam.GetDoc();
2892 
2893 // was ist mit Undo ? ist das abgeschaltet ??
2894 	SwTxtFmtColl* pColl = USHRT_MAX == nPoolId
2895 							? pDoc->FindTxtFmtCollByName( sFmtNm )
2896 							: pDoc->GetTxtCollFromPool( nPoolId );
2897 	if( pColl )
2898         pDoc->SetTxtFmtColl( rPam, pColl, false );
2899 
2900 	if( pSet )
2901 	{
2902 		rPam.SetMark();
2903 		SwPosition& rMark = *rPam.GetMark();
2904 		SwTxtNode* pTNd = rMark.nNode.GetNode().GetTxtNode();
2905 		if( pTNd )
2906 		{
2907 			rMark.nContent.Assign( pTNd, pTNd->GetTxt().Len() );
2908 
2909             if( pTNd->HasSwAttrSet() )
2910 			{
2911 				// nur die setzen, die nicht mehr vorhanden sind. Andere
2912 				// koennen jetzt veraendert drin stehen, aber die werden
2913 				// nicht angefasst.
2914 				SfxItemSet aTmp( *pSet );
2915 				aTmp.Differentiate( *pTNd->GetpSwAttrSet() );
2916                 pDoc->InsertItemSet( rPam, aTmp, 0 );
2917             }
2918             else
2919             {
2920                 pDoc->InsertItemSet( rPam, *pSet, 0 );
2921             }
2922         }
2923 		rPam.DeleteMark();
2924 	}
2925 }
2926 
operator ==(const SwRedlineExtraData & r) const2927 int SwRedlineExtraData_FmtColl::operator == ( const SwRedlineExtraData& r) const
2928 {
2929 	const SwRedlineExtraData_FmtColl& rCmp = (SwRedlineExtraData_FmtColl&)r;
2930 	return sFmtNm == rCmp.sFmtNm && nPoolId == rCmp.nPoolId &&
2931 			( ( !pSet && !rCmp.pSet ) ||
2932 			   ( pSet && rCmp.pSet && *pSet == *rCmp.pSet ) );
2933 }
2934 
SetItemSet(const SfxItemSet & rSet)2935 void SwRedlineExtraData_FmtColl::SetItemSet( const SfxItemSet& rSet )
2936 {
2937 	delete pSet;
2938 	if( rSet.Count() )
2939 		pSet = new SfxItemSet( rSet );
2940 	else
2941 		pSet = 0;
2942 }
2943 
2944 
SwRedlineExtraData_Format(const SfxItemSet & rSet)2945 SwRedlineExtraData_Format::SwRedlineExtraData_Format( const SfxItemSet& rSet )
2946 {
2947 	SfxItemIter aIter( rSet );
2948 	const SfxPoolItem* pItem = aIter.FirstItem();
2949 	while( sal_True )
2950 	{
2951 		aWhichIds.Insert( pItem->Which(), aWhichIds.Count() );
2952 		if( aIter.IsAtEnd() )
2953 			break;
2954 		pItem = aIter.NextItem();
2955 	}
2956 }
2957 
SwRedlineExtraData_Format(const SwRedlineExtraData_Format & rCpy)2958 SwRedlineExtraData_Format::SwRedlineExtraData_Format(
2959 		const SwRedlineExtraData_Format& rCpy )
2960 	: SwRedlineExtraData(), aWhichIds( (sal_uInt8)rCpy.aWhichIds.Count() )
2961 {
2962 	aWhichIds.Insert( &rCpy.aWhichIds, 0 );
2963 }
2964 
~SwRedlineExtraData_Format()2965 SwRedlineExtraData_Format::~SwRedlineExtraData_Format()
2966 {
2967 }
2968 
CreateNew() const2969 SwRedlineExtraData* SwRedlineExtraData_Format::CreateNew() const
2970 {
2971 	return new SwRedlineExtraData_Format( *this );
2972 }
2973 
Reject(SwPaM & rPam) const2974 void SwRedlineExtraData_Format::Reject( SwPaM& rPam ) const
2975 {
2976     SwDoc* pDoc = rPam.GetDoc();
2977 
2978     RedlineMode_t eOld = pDoc->GetRedlineMode();
2979     pDoc->SetRedlineMode_intern((RedlineMode_t)(eOld & ~(nsRedlineMode_t::REDLINE_ON | nsRedlineMode_t::REDLINE_IGNORE)));
2980 
2981     // eigentlich muesste hier das Attribut zurueck gesetzt werden!!!
2982     for( sal_uInt16 n = 0, nEnd = aWhichIds.Count(); n < nEnd; ++n )
2983     {
2984         pDoc->InsertPoolItem(
2985             rPam, *GetDfltAttr( aWhichIds[ n ] ), nsSetAttrMode::SETATTR_DONTEXPAND );
2986     }
2987 
2988     pDoc->SetRedlineMode_intern( eOld );
2989 }
2990 
operator ==(const SwRedlineExtraData & rCmp) const2991 int SwRedlineExtraData_Format::operator == ( const SwRedlineExtraData& rCmp ) const
2992 {
2993 	int nRet = 1;
2994 	sal_uInt16 n = 0, nEnd = aWhichIds.Count();
2995 	if( nEnd != ((SwRedlineExtraData_Format&)rCmp).aWhichIds.Count() )
2996 		nRet = 0;
2997 	else
2998 		for( ; n < nEnd; ++n )
2999 			if( ((SwRedlineExtraData_Format&)rCmp).aWhichIds[n] != aWhichIds[n])
3000 			{
3001 				nRet = 0;
3002 				break;
3003 			}
3004 	return nRet;
3005 }
3006 
3007 /*  */
3008 
SwRedlineData(RedlineType_t eT,sal_uInt16 nAut)3009 SwRedlineData::SwRedlineData( RedlineType_t eT, sal_uInt16 nAut )
3010 	: pNext( 0 ), pExtraData( 0 ), eType( eT ), nAuthor( nAut ), nSeqNo( 0 )
3011 {
3012 	aStamp.SetSec( 0 );
3013 	aStamp.Set100Sec( 0 );
3014 }
3015 
SwRedlineData(const SwRedlineData & rCpy,sal_Bool bCpyNext)3016 SwRedlineData::SwRedlineData(
3017     const SwRedlineData& rCpy,
3018     sal_Bool bCpyNext )
3019     : pNext( ( bCpyNext && rCpy.pNext ) ? new SwRedlineData( *rCpy.pNext ) : 0 )
3020     , pExtraData( rCpy.pExtraData ? rCpy.pExtraData->CreateNew() : 0 )
3021     , sComment( rCpy.sComment )
3022     , aStamp( rCpy.aStamp )
3023     , eType( rCpy.eType )
3024     , nAuthor( rCpy.nAuthor )
3025     , nSeqNo( rCpy.nSeqNo )
3026 {
3027 }
3028 
3029 	// fuer sw3io: pNext geht in eigenen Besitz ueber!
SwRedlineData(RedlineType_t eT,sal_uInt16 nAut,const DateTime & rDT,const String & rCmnt,SwRedlineData * pNxt,SwRedlineExtraData * pData)3030 SwRedlineData::SwRedlineData(RedlineType_t eT, sal_uInt16 nAut, const DateTime& rDT,
3031 	const String& rCmnt, SwRedlineData *pNxt, SwRedlineExtraData* pData)
3032 	: pNext(pNxt), pExtraData(pData), sComment(rCmnt), aStamp(rDT),
3033 	eType(eT), nAuthor(nAut), nSeqNo(0)
3034 {
3035 }
3036 
~SwRedlineData()3037 SwRedlineData::~SwRedlineData()
3038 {
3039 	delete pExtraData;
3040 	delete pNext;
3041 }
3042 
3043 	// ExtraData wird kopiert, der Pointer geht also NICHT in den Besitz
3044 	// des RedlineObjectes!
SetExtraData(const SwRedlineExtraData * pData)3045 void SwRedlineData::SetExtraData( const SwRedlineExtraData* pData )
3046 {
3047 	delete pExtraData;
3048 
3049 	if( pData )
3050 		pExtraData = pData->CreateNew();
3051 	else
3052 		pExtraData = 0;
3053 }
3054 
3055 // #111827#
GetDescr() const3056 String SwRedlineData::GetDescr() const
3057 {
3058     String aResult;
3059 
3060     aResult += String(SW_RES(STR_REDLINE_INSERT + GetType()));
3061 
3062     return aResult;
3063 }
3064 
3065 /*  */
3066 
SwRedline(RedlineType_t eTyp,const SwPaM & rPam)3067 SwRedline::SwRedline(RedlineType_t eTyp, const SwPaM& rPam )
3068 	: SwPaM( *rPam.GetMark(), *rPam.GetPoint() ),
3069 	pRedlineData( new SwRedlineData( eTyp, GetDoc()->GetRedlineAuthor() ) ),
3070 	pCntntSect( 0 )
3071 {
3072 	bDelLastPara = bIsLastParaDelete = sal_False;
3073 	bIsVisible = sal_True;
3074 	if( !rPam.HasMark() )
3075 		DeleteMark();
3076 }
3077 
SwRedline(const SwRedlineData & rData,const SwPaM & rPam)3078 SwRedline::SwRedline( const SwRedlineData& rData, const SwPaM& rPam )
3079 	: SwPaM( *rPam.GetMark(), *rPam.GetPoint() ),
3080 	pRedlineData( new SwRedlineData( rData )),
3081 	pCntntSect( 0 )
3082 {
3083 	bDelLastPara = bIsLastParaDelete = sal_False;
3084 	bIsVisible = sal_True;
3085 	if( !rPam.HasMark() )
3086 		DeleteMark();
3087 }
3088 
SwRedline(const SwRedlineData & rData,const SwPosition & rPos)3089 SwRedline::SwRedline( const SwRedlineData& rData, const SwPosition& rPos )
3090 	: SwPaM( rPos ),
3091 	pRedlineData( new SwRedlineData( rData )),
3092 	pCntntSect( 0 )
3093 {
3094 	bDelLastPara = bIsLastParaDelete = sal_False;
3095 	bIsVisible = sal_True;
3096 }
3097 
SwRedline(const SwRedline & rCpy)3098 SwRedline::SwRedline( const SwRedline& rCpy )
3099 	: SwPaM( *rCpy.GetMark(), *rCpy.GetPoint() ),
3100 	pRedlineData( new SwRedlineData( *rCpy.pRedlineData )),
3101 	pCntntSect( 0 )
3102 {
3103 	bDelLastPara = bIsLastParaDelete = sal_False;
3104 	bIsVisible = sal_True;
3105 	if( !rCpy.HasMark() )
3106 		DeleteMark();
3107 }
3108 
~SwRedline()3109 SwRedline::~SwRedline()
3110 {
3111 	if( pCntntSect )
3112 	{
3113 		// dann den Content Bereich loeschen
3114 		if( !GetDoc()->IsInDtor() )
3115 			GetDoc()->DeleteSection( &pCntntSect->GetNode() );
3116 		delete pCntntSect;
3117 	}
3118 	delete pRedlineData;
3119 }
3120 
3121 // liegt eine gueltige Selektion vor?
HasValidRange() const3122 sal_Bool SwRedline::HasValidRange() const
3123 {
3124 	const SwNode* pPtNd = &GetPoint()->nNode.GetNode(),
3125 				* pMkNd = &GetMark()->nNode.GetNode();
3126     if( pPtNd->StartOfSectionNode() == pMkNd->StartOfSectionNode() &&
3127         !pPtNd->StartOfSectionNode()->IsTableNode() &&
3128 		// JP 18.5.2001: Bug 87222 - invalid if points on the end of content
3129         // DVO 25.03.2002: #96530# end-of-content only invalid if no content
3130         //                 index exists
3131 		( pPtNd != pMkNd || GetContentIdx() != NULL ||
3132           pPtNd != &pPtNd->GetNodes().GetEndOfContent() )
3133 		)
3134 		return sal_True;
3135 	return sal_False;
3136 }
3137 
CallDisplayFunc(sal_uInt16 nLoop)3138 void SwRedline::CallDisplayFunc( sal_uInt16 nLoop )
3139 {
3140 	switch( nsRedlineMode_t::REDLINE_SHOW_MASK & GetDoc()->GetRedlineMode() )
3141 	{
3142 	case nsRedlineMode_t::REDLINE_SHOW_INSERT | nsRedlineMode_t::REDLINE_SHOW_DELETE:
3143 		Show( nLoop );
3144 		break;
3145 	case nsRedlineMode_t::REDLINE_SHOW_INSERT:
3146 		Hide( nLoop );
3147 		break;
3148 	case nsRedlineMode_t::REDLINE_SHOW_DELETE:
3149 		ShowOriginal( nLoop );
3150 		break;
3151 	}
3152 }
3153 
Show(sal_uInt16 nLoop)3154 void SwRedline::Show( sal_uInt16 nLoop )
3155 {
3156 	if( 1 <= nLoop )
3157 	{
3158 		SwDoc* pDoc = GetDoc();
3159 		RedlineMode_t eOld = pDoc->GetRedlineMode();
3160 		pDoc->SetRedlineMode_intern((RedlineMode_t)(eOld | nsRedlineMode_t::REDLINE_IGNORE));
3161         ::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo());
3162 
3163 		switch( GetType() )
3164 		{
3165 		case nsRedlineType_t::REDLINE_INSERT: 			// Inhalt wurde eingefuegt
3166 			bIsVisible = sal_True;
3167 			MoveFromSection();
3168 			break;
3169 
3170 		case nsRedlineType_t::REDLINE_DELETE: 			// Inhalt wurde geloescht
3171 			bIsVisible = sal_True;
3172 			MoveFromSection();
3173 			break;
3174 
3175 		case nsRedlineType_t::REDLINE_FORMAT:			// Attributierung wurde angewendet
3176 		case nsRedlineType_t::REDLINE_TABLE:				// TabellenStruktur wurde veraendert
3177 			InvalidateRange();
3178 			break;
3179 		default:
3180 			break;
3181 		}
3182 		pDoc->SetRedlineMode_intern( eOld );
3183     }
3184 }
3185 
Hide(sal_uInt16 nLoop)3186 void SwRedline::Hide( sal_uInt16 nLoop )
3187 {
3188 	SwDoc* pDoc = GetDoc();
3189 	RedlineMode_t eOld = pDoc->GetRedlineMode();
3190 	pDoc->SetRedlineMode_intern((RedlineMode_t)(eOld | nsRedlineMode_t::REDLINE_IGNORE));
3191     ::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo());
3192 
3193 	switch( GetType() )
3194 	{
3195 	case nsRedlineType_t::REDLINE_INSERT: 			// Inhalt wurde eingefuegt
3196 		bIsVisible = sal_True;
3197 		if( 1 <= nLoop )
3198 			MoveFromSection();
3199 		break;
3200 
3201 	case nsRedlineType_t::REDLINE_DELETE: 			// Inhalt wurde geloescht
3202 		bIsVisible = sal_False;
3203 		switch( nLoop )
3204 		{
3205 		case 0:	MoveToSection();	break;
3206 		case 1:	CopyToSection();	break;
3207 		case 2:	DelCopyOfSection();	break;
3208 		}
3209 		break;
3210 
3211 	case nsRedlineType_t::REDLINE_FORMAT:			// Attributierung wurde angewendet
3212 	case nsRedlineType_t::REDLINE_TABLE:				// TabellenStruktur wurde veraendert
3213 		if( 1 <= nLoop )
3214 			InvalidateRange();
3215 		break;
3216 	default:
3217 		break;
3218 	}
3219 	pDoc->SetRedlineMode_intern( eOld );
3220 }
3221 
ShowOriginal(sal_uInt16 nLoop)3222 void SwRedline::ShowOriginal( sal_uInt16 nLoop )
3223 {
3224 	SwDoc* pDoc = GetDoc();
3225 	RedlineMode_t eOld = pDoc->GetRedlineMode();
3226 	SwRedlineData* pCur;
3227 
3228 	pDoc->SetRedlineMode_intern((RedlineMode_t)(eOld | nsRedlineMode_t::REDLINE_IGNORE));
3229     ::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo());
3230 
3231 	// bestimme den Type, ist der erste auf Stack
3232 	for( pCur = pRedlineData; pCur->pNext; )
3233 		pCur = pCur->pNext;
3234 
3235 	switch( pCur->eType )
3236 	{
3237 	case nsRedlineType_t::REDLINE_INSERT: 			// Inhalt wurde eingefuegt
3238 		bIsVisible = sal_False;
3239 		switch( nLoop )
3240 		{
3241 		case 0:	MoveToSection();	break;
3242 		case 1:	CopyToSection();	break;
3243 		case 2:	DelCopyOfSection();	break;
3244 		}
3245 		break;
3246 
3247 	case nsRedlineType_t::REDLINE_DELETE: 			// Inhalt wurde geloescht
3248 		bIsVisible = sal_True;
3249 		if( 1 <= nLoop )
3250 			MoveFromSection();
3251 		break;
3252 
3253 	case nsRedlineType_t::REDLINE_FORMAT:			// Attributierung wurde angewendet
3254 	case nsRedlineType_t::REDLINE_TABLE:				// TabellenStruktur wurde veraendert
3255 		if( 1 <= nLoop )
3256 			InvalidateRange();
3257 		break;
3258 	default:
3259 		break;
3260 	}
3261 	pDoc->SetRedlineMode_intern( eOld );
3262 }
3263 
3264 
InvalidateRange()3265 void SwRedline::InvalidateRange()		// das Layout anstossen
3266 {
3267 	sal_uLong nSttNd = GetMark()->nNode.GetIndex(),
3268 			nEndNd = GetPoint()->nNode.GetIndex();
3269 	sal_uInt16 nSttCnt = GetMark()->nContent.GetIndex(),
3270 			nEndCnt = GetPoint()->nContent.GetIndex();
3271 
3272 	if( nSttNd > nEndNd || ( nSttNd == nEndNd && nSttCnt > nEndCnt ))
3273 	{
3274 		sal_uLong nTmp = nSttNd; nSttNd = nEndNd; nEndNd = nTmp;
3275 		nTmp = nSttCnt; nSttCnt = nEndCnt; nEndCnt = (sal_uInt16)nTmp;
3276 	}
3277 
3278 	SwUpdateAttr aHt( 0, 0, RES_FMT_CHG );
3279 	SwNodes& rNds = GetDoc()->GetNodes();
3280 	SwNode* pNd;
3281 	for( sal_uLong n = nSttNd; n <= nEndNd; ++n )
3282 		if( ND_TEXTNODE == ( pNd = rNds[ n ] )->GetNodeType() )
3283 		{
3284 			aHt.nStart = n == nSttNd ? nSttCnt : 0;
3285 			aHt.nEnd = n == nEndNd ? nEndCnt : ((SwTxtNode*)pNd)->GetTxt().Len();
3286 			((SwTxtNode*)pNd)->ModifyNotification( &aHt, &aHt );
3287 		}
3288 }
3289 
3290 /*************************************************************************
3291  *                      SwRedline::CalcStartEnd()
3292  * Calculates the start and end position of the intersection rTmp and
3293  * text node nNdIdx
3294  *************************************************************************/
3295 
CalcStartEnd(sal_uLong nNdIdx,sal_uInt16 & nStart,sal_uInt16 & nEnd) const3296 void SwRedline::CalcStartEnd( sal_uLong nNdIdx, sal_uInt16& nStart, sal_uInt16& nEnd ) const
3297 {
3298     const SwPosition *pRStt = Start(), *pREnd = End();
3299 	if( pRStt->nNode < nNdIdx )
3300 	{
3301 		if( pREnd->nNode > nNdIdx )
3302 		{
3303 			nStart = 0;				// Absatz ist komplett enthalten
3304 			nEnd = STRING_LEN;
3305 		}
3306 		else
3307 		{
3308 			ASSERT( pREnd->nNode == nNdIdx,
3309 				"SwRedlineItr::Seek: GetRedlinePos Error" );
3310 			nStart = 0;				// Absatz wird vorne ueberlappt
3311 			nEnd = pREnd->nContent.GetIndex();
3312 		}
3313 	}
3314 	else if( pRStt->nNode == nNdIdx )
3315 	{
3316 		nStart = pRStt->nContent.GetIndex();
3317 		if( pREnd->nNode == nNdIdx )
3318 			nEnd = pREnd->nContent.GetIndex(); // Innerhalb des Absatzes
3319 		else
3320 			nEnd = STRING_LEN;		// Absatz wird hinten ueberlappt
3321 	}
3322 	else
3323 	{
3324 		nStart = STRING_LEN;
3325 		nEnd = STRING_LEN;
3326 	}
3327 }
3328 
MoveToSection()3329 void SwRedline::MoveToSection()
3330 {
3331 	if( !pCntntSect )
3332 	{
3333 		const SwPosition* pStt = Start(),
3334 						* pEnd = pStt == GetPoint() ? GetMark() : GetPoint();
3335 
3336 		SwDoc* pDoc = GetDoc();
3337 		SwPaM aPam( *pStt, *pEnd );
3338 		SwCntntNode* pCSttNd = pStt->nNode.GetNode().GetCntntNode();
3339 		SwCntntNode* pCEndNd = pEnd->nNode.GetNode().GetCntntNode();
3340 
3341 		if( !pCSttNd )
3342 		{
3343 			// damit die Indizies der anderen Redlines nicht mitverschoben
3344 			// werden, diese aufs Ende setzen (ist exclusive).
3345 			const SwRedlineTbl& rTbl = pDoc->GetRedlineTbl();
3346 			for( sal_uInt16 n = 0; n < rTbl.Count(); ++n )
3347 			{
3348 				SwRedline* pRedl = rTbl[ n ];
3349 				if( pRedl->GetBound(sal_True) == *pStt )
3350 					pRedl->GetBound(sal_True) = *pEnd;
3351 				if( pRedl->GetBound(sal_False) == *pStt )
3352 					pRedl->GetBound(sal_False) = *pEnd;
3353 			}
3354 		}
3355 
3356 		SwStartNode* pSttNd;
3357 		SwNodes& rNds = pDoc->GetNodes();
3358 		if( pCSttNd || pCEndNd )
3359 		{
3360 			SwTxtFmtColl* pColl = (pCSttNd && pCSttNd->IsTxtNode() )
3361 									? ((SwTxtNode*)pCSttNd)->GetTxtColl()
3362 									: (pCEndNd && pCEndNd->IsTxtNode() )
3363 										? ((SwTxtNode*)pCEndNd)->GetTxtColl()
3364 										: pDoc->GetTxtCollFromPool(
3365 												RES_POOLCOLL_STANDARD );
3366 
3367 			pSttNd = rNds.MakeTextSection( SwNodeIndex( rNds.GetEndOfRedlines() ),
3368 											SwNormalStartNode, pColl );
3369 			SwTxtNode* pTxtNd = rNds[ pSttNd->GetIndex() + 1 ]->GetTxtNode();
3370 
3371 			SwNodeIndex aNdIdx( *pTxtNd );
3372 			SwPosition aPos( aNdIdx, SwIndex( pTxtNd ));
3373 			if( pCSttNd && pCEndNd )
3374 				pDoc->MoveAndJoin( aPam, aPos, IDocumentContentOperations::DOC_MOVEDEFAULT );
3375 			else
3376 			{
3377 				if( pCSttNd && !pCEndNd )
3378 					bDelLastPara = sal_True;
3379                 pDoc->MoveRange( aPam, aPos,
3380                     IDocumentContentOperations::DOC_MOVEDEFAULT );
3381 			}
3382 		}
3383 		else
3384 		{
3385 			pSttNd = rNds.MakeEmptySection( SwNodeIndex( rNds.GetEndOfRedlines() ),
3386 											SwNormalStartNode );
3387 
3388 			SwPosition aPos( *pSttNd->EndOfSectionNode() );
3389             pDoc->MoveRange( aPam, aPos,
3390                 IDocumentContentOperations::DOC_MOVEDEFAULT );
3391 		}
3392 		pCntntSect = new SwNodeIndex( *pSttNd );
3393 
3394 		if( pStt == GetPoint() )
3395 			Exchange();
3396 
3397 		DeleteMark();
3398 	}
3399 	else
3400 		InvalidateRange();
3401 }
3402 
CopyToSection()3403 void SwRedline::CopyToSection()
3404 {
3405 	if( !pCntntSect )
3406 	{
3407 		const SwPosition* pStt = Start(),
3408 						* pEnd = pStt == GetPoint() ? GetMark() : GetPoint();
3409 
3410 		SwCntntNode* pCSttNd = pStt->nNode.GetNode().GetCntntNode();
3411 		SwCntntNode* pCEndNd = pEnd->nNode.GetNode().GetCntntNode();
3412 
3413 		SwStartNode* pSttNd;
3414 		SwDoc* pDoc = GetDoc();
3415 		SwNodes& rNds = pDoc->GetNodes();
3416 
3417 		sal_Bool bSaveCopyFlag = pDoc->IsCopyIsMove(),
3418 			 bSaveRdlMoveFlg = pDoc->IsRedlineMove();
3419 		pDoc->SetCopyIsMove( sal_True );
3420 
3421         // #100619# The IsRedlineMove() flag causes the behaviour of the
3422         // SwDoc::_CopyFlyInFly method to change, which will eventually be
3423         // called by the pDoc->Copy line below (through SwDoc::_Copy,
3424         // SwDoc::CopyWithFlyInFly). This rather obscure bugfix was introduced
3425         // for #63198# and #64896#, and apparently never really worked.
3426 		pDoc->SetRedlineMove( pStt->nContent == 0 );
3427 
3428 		if( pCSttNd )
3429 		{
3430 			SwTxtFmtColl* pColl = (pCSttNd && pCSttNd->IsTxtNode() )
3431 									? ((SwTxtNode*)pCSttNd)->GetTxtColl()
3432 									: pDoc->GetTxtCollFromPool(
3433 												RES_POOLCOLL_STANDARD );
3434 
3435 			pSttNd = rNds.MakeTextSection( SwNodeIndex( rNds.GetEndOfRedlines() ),
3436 											SwNormalStartNode, pColl );
3437 
3438 			SwNodeIndex aNdIdx( *pSttNd, 1 );
3439 			SwTxtNode* pTxtNd = aNdIdx.GetNode().GetTxtNode();
3440 			SwPosition aPos( aNdIdx, SwIndex( pTxtNd ));
3441             pDoc->CopyRange( *this, aPos, false );
3442 
3443 			// JP 08.10.98: die Vorlage vom EndNode ggfs. mit uebernehmen
3444 			//				- ist im Doc::Copy nicht erwuenscht
3445 			if( pCEndNd && pCEndNd != pCSttNd )
3446 			{
3447 				SwCntntNode* pDestNd = aPos.nNode.GetNode().GetCntntNode();
3448 				if( pDestNd )
3449 				{
3450 					if( pDestNd->IsTxtNode() && pCEndNd->IsTxtNode() )
3451 						((SwTxtNode*)pCEndNd)->CopyCollFmt(
3452 											*(SwTxtNode*)pDestNd );
3453 					else
3454 						pDestNd->ChgFmtColl( pCEndNd->GetFmtColl() );
3455 				}
3456 			}
3457 		}
3458 		else
3459 		{
3460 			pSttNd = rNds.MakeEmptySection( SwNodeIndex( rNds.GetEndOfRedlines() ),
3461 											SwNormalStartNode );
3462 
3463 			if( pCEndNd )
3464 			{
3465 				SwPosition aPos( *pSttNd->EndOfSectionNode() );
3466                 pDoc->CopyRange( *this, aPos, false );
3467 			}
3468 			else
3469 			{
3470 				SwNodeIndex aInsPos( *pSttNd->EndOfSectionNode() );
3471 				SwNodeRange aRg( pStt->nNode, 0, pEnd->nNode, 1 );
3472                 pDoc->CopyWithFlyInFly( aRg, 0, aInsPos );
3473 			}
3474 		}
3475 		pCntntSect = new SwNodeIndex( *pSttNd );
3476 
3477 		pDoc->SetCopyIsMove( bSaveCopyFlag );
3478 		pDoc->SetRedlineMove( bSaveRdlMoveFlg );
3479 	}
3480 }
3481 
DelCopyOfSection()3482 void SwRedline::DelCopyOfSection()
3483 {
3484 	if( pCntntSect )
3485 	{
3486 		const SwPosition* pStt = Start(),
3487 						* pEnd = pStt == GetPoint() ? GetMark() : GetPoint();
3488 
3489 		SwDoc* pDoc = GetDoc();
3490 		SwPaM aPam( *pStt, *pEnd );
3491 		SwCntntNode* pCSttNd = pStt->nNode.GetNode().GetCntntNode();
3492 		SwCntntNode* pCEndNd = pEnd->nNode.GetNode().GetCntntNode();
3493 
3494 		if( !pCSttNd )
3495 		{
3496 			// damit die Indizies der anderen Redlines nicht mitverschoben
3497 			// werden, diese aufs Ende setzen (ist exclusive).
3498 			const SwRedlineTbl& rTbl = pDoc->GetRedlineTbl();
3499 			for( sal_uInt16 n = 0; n < rTbl.Count(); ++n )
3500 			{
3501 				SwRedline* pRedl = rTbl[ n ];
3502 				if( pRedl->GetBound(sal_True) == *pStt )
3503 					pRedl->GetBound(sal_True) = *pEnd;
3504 				if( pRedl->GetBound(sal_False) == *pStt )
3505 					pRedl->GetBound(sal_False) = *pEnd;
3506 			}
3507 		}
3508 
3509 		if( pCSttNd && pCEndNd )
3510         {
3511             // --> OD 2009-08-20 #i100466#
3512             // force a <join next> on <delete and join> operation
3513             pDoc->DeleteAndJoin( aPam, true );
3514             // <--
3515         }
3516 		else if( pCSttNd || pCEndNd )
3517 		{
3518 			if( pCSttNd && !pCEndNd )
3519 				bDelLastPara = sal_True;
3520             pDoc->DeleteRange( aPam );
3521 
3522 			if( bDelLastPara )
3523 			{
3524                 // #100611# To prevent dangling references to the paragraph to
3525                 // be deleted, redline that point into this paragraph should be
3526                 // moved to the new end position. Since redlines in the redline
3527                 // table are sorted and the pEnd position is an endnode (see
3528                 // bDelLastPara condition above), only redlines before the
3529                 // current ones can be affected.
3530 				const SwRedlineTbl& rTbl = pDoc->GetRedlineTbl();
3531 				sal_uInt16 n = rTbl.GetPos( this );
3532                 ASSERT( n != USHRT_MAX, "How strange. We don't exist!" );
3533 				for( sal_Bool bBreak = sal_False; !bBreak && n > 0; )
3534 				{
3535                     --n;
3536 					bBreak = sal_True;
3537 					if( rTbl[ n ]->GetBound(sal_True) == *aPam.GetPoint() )
3538 					{
3539 						rTbl[ n ]->GetBound(sal_True) = *pEnd;
3540 						bBreak = sal_False;
3541 					}
3542 					if( rTbl[ n ]->GetBound(sal_False) == *aPam.GetPoint() )
3543 					{
3544 						rTbl[ n ]->GetBound(sal_False) = *pEnd;
3545 						bBreak = sal_False;
3546 					}
3547 				}
3548 
3549 				SwPosition aEnd( *pEnd );
3550 				*GetPoint() = *pEnd;
3551 				*GetMark() = *pEnd;
3552 				DeleteMark();
3553 
3554 				aPam.GetBound( sal_True ).nContent.Assign( 0, 0 );
3555 				aPam.GetBound( sal_False ).nContent.Assign( 0, 0 );
3556 				aPam.DeleteMark();
3557 				pDoc->DelFullPara( aPam );
3558 			}
3559 		}
3560 		else
3561         {
3562             pDoc->DeleteRange( aPam );
3563         }
3564 
3565 		if( pStt == GetPoint() )
3566 			Exchange();
3567 
3568 		DeleteMark();
3569 	}
3570 }
3571 
MoveFromSection()3572 void SwRedline::MoveFromSection()
3573 {
3574 	if( pCntntSect )
3575 	{
3576 		SwDoc* pDoc = GetDoc();
3577 		const SwRedlineTbl& rTbl = pDoc->GetRedlineTbl();
3578 		SvPtrarr aBeforeArr( 16, 16 ), aBehindArr( 16, 16 );
3579 		sal_uInt16 nMyPos = rTbl.GetPos( this );
3580 		ASSERT( this, "this nicht im Array?" );
3581 		sal_Bool bBreak = sal_False;
3582 		sal_uInt16 n;
3583 
3584 		for( n = nMyPos+1; !bBreak && n < rTbl.Count(); ++n )
3585 		{
3586 			bBreak = sal_True;
3587 			if( rTbl[ n ]->GetBound(sal_True) == *GetPoint() )
3588 			{
3589 				void* pTmp = &rTbl[ n ]->GetBound(sal_True);
3590 				aBehindArr.Insert( pTmp, aBehindArr.Count());
3591 				bBreak = sal_False;
3592 			}
3593 			if( rTbl[ n ]->GetBound(sal_False) == *GetPoint() )
3594 			{
3595 				void* pTmp = &rTbl[ n ]->GetBound(sal_False);
3596 				aBehindArr.Insert( pTmp, aBehindArr.Count() );
3597 				bBreak = sal_False;
3598 			}
3599 		}
3600 		for( bBreak = sal_False, n = nMyPos; !bBreak && n ; )
3601 		{
3602 			--n;
3603 			bBreak = sal_True;
3604 			if( rTbl[ n ]->GetBound(sal_True) == *GetPoint() )
3605 			{
3606 				void* pTmp = &rTbl[ n ]->GetBound(sal_True);
3607 				aBeforeArr.Insert( pTmp, aBeforeArr.Count() );
3608 				bBreak = sal_False;
3609 			}
3610 			if( rTbl[ n ]->GetBound(sal_False) == *GetPoint() )
3611 			{
3612 				void* pTmp = &rTbl[ n ]->GetBound(sal_False);
3613 				aBeforeArr.Insert( pTmp, aBeforeArr.Count() );
3614 				bBreak = sal_False;
3615 			}
3616 		}
3617 
3618         // --> OD 2009-03-17 #i95711#
3619         const SwNode* pKeptCntntSectNode( &pCntntSect->GetNode() );
3620         // <--
3621 		{
3622 			SwPaM aPam( pCntntSect->GetNode(),
3623 						*pCntntSect->GetNode().EndOfSectionNode(), 1,
3624 						( bDelLastPara ? -2 : -1 ) );
3625 			SwCntntNode* pCNd = aPam.GetCntntNode();
3626 			if( pCNd )
3627 				aPam.GetPoint()->nContent.Assign( pCNd, pCNd->Len() );
3628 			else
3629 				aPam.GetPoint()->nNode++;
3630 
3631 			SwFmtColl* pColl = pCNd && pCNd->Len() && aPam.GetPoint()->nNode !=
3632 										aPam.GetMark()->nNode
3633 								? pCNd->GetFmtColl() : 0;
3634 
3635 			SwNodeIndex aNdIdx( GetPoint()->nNode, -1 );
3636 			sal_uInt16 nPos = GetPoint()->nContent.GetIndex();
3637 
3638 			SwPosition aPos( *GetPoint() );
3639 			if( bDelLastPara && *aPam.GetPoint() == *aPam.GetMark() )
3640 			{
3641 				aPos.nNode--;
3642 
3643 				pDoc->AppendTxtNode( aPos );
3644             }
3645             else
3646             {
3647                 pDoc->MoveRange( aPam, aPos,
3648                     IDocumentContentOperations::DOC_MOVEALLFLYS );
3649             }
3650 
3651 			SetMark();
3652 			*GetPoint() = aPos;
3653 			GetMark()->nNode = aNdIdx.GetIndex() + 1;
3654 			pCNd = GetMark()->nNode.GetNode().GetCntntNode();
3655 			GetMark()->nContent.Assign( pCNd, nPos );
3656 
3657 			if( bDelLastPara )
3658 			{
3659 				GetPoint()->nNode++;
3660 				GetPoint()->nContent.Assign( pCNd = GetCntntNode(), 0 );
3661 				bDelLastPara = sal_False;
3662 			}
3663 			else if( pColl )
3664 				pCNd = GetCntntNode();
3665 
3666 			if( pColl && pCNd )
3667 				pCNd->ChgFmtColl( pColl );
3668 		}
3669         // --> OD 2009-03-17 #i95771#
3670         // Under certain conditions the previous <SwDoc::Move(..)> has already
3671         // remove the change tracking section of this <SwRedline> instance from
3672         // the change tracking nodes area.
3673         // Thus, check, if <pCntntSect> still points to the change tracking section
3674         // by comparing it with the "indexed" <SwNode> instance copied before
3675         // perform the intrinsic move.
3676         // Note: Such condition is e.g. a "delete" change tracking only containing a table.
3677         if ( &pCntntSect->GetNode() == pKeptCntntSectNode )
3678         {
3679             pDoc->DeleteSection( &pCntntSect->GetNode() );
3680         }
3681         // <--
3682 		delete pCntntSect, pCntntSect = 0;
3683 
3684         // #100611# adjustment of redline table positions must take start and
3685         // end into account, not point and mark.
3686 		for( n = 0; n < aBeforeArr.Count(); ++n )
3687 			*(SwPosition*)aBeforeArr[ n ] = *Start();
3688 		for( n = 0; n < aBehindArr.Count(); ++n )
3689 			*(SwPosition*)aBehindArr[ n ] = *End();
3690 	}
3691 	else
3692 		InvalidateRange();
3693 }
3694 
3695 // fuers Undo
SetContentIdx(const SwNodeIndex * pIdx)3696 void SwRedline::SetContentIdx( const SwNodeIndex* pIdx )
3697 {
3698 	if( pIdx && !pCntntSect )
3699 	{
3700 		pCntntSect = new SwNodeIndex( *pIdx );
3701 		bIsVisible = sal_False;
3702 	}
3703 	else if( !pIdx && pCntntSect )
3704 	{
3705 		delete pCntntSect, pCntntSect = 0;
3706 		bIsVisible = sal_False;
3707 	}
3708 #ifdef DBG_UTIL
3709 	else
3710 		ASSERT( !this, "das ist keine gueltige Operation" );
3711 #endif
3712 }
3713 
CanCombine(const SwRedline & rRedl) const3714 sal_Bool SwRedline::CanCombine( const SwRedline& rRedl ) const
3715 {
3716 	return	IsVisible() && rRedl.IsVisible() &&
3717 			pRedlineData->CanCombine( *rRedl.pRedlineData );
3718 }
3719 
PushData(const SwRedline & rRedl,sal_Bool bOwnAsNext)3720 void SwRedline::PushData( const SwRedline& rRedl, sal_Bool bOwnAsNext )
3721 {
3722 //	SwRedlineData* pNew = new SwRedlineData( rRedl.GetType(),
3723 //											 rRedl.GetAuthor() );
3724 	SwRedlineData* pNew = new SwRedlineData( *rRedl.pRedlineData, sal_False );
3725 	if( bOwnAsNext )
3726 	{
3727 		pNew->pNext = pRedlineData;
3728 		pRedlineData = pNew;
3729 	}
3730 	else
3731 	{
3732 		pNew->pNext = pRedlineData->pNext;
3733 		pRedlineData->pNext = pNew;
3734 	}
3735 }
3736 
PopData()3737 sal_Bool SwRedline::PopData()
3738 {
3739 	if( !pRedlineData->pNext )
3740 		return sal_False;
3741 	SwRedlineData* pCur = pRedlineData;
3742 	pRedlineData = pCur->pNext;
3743 	pCur->pNext = 0;
3744 	delete pCur;
3745 	return sal_True;
3746 }
3747 
GetStackCount() const3748 sal_uInt16 SwRedline::GetStackCount() const
3749 {
3750 	sal_uInt16 nRet = 1;
3751 	for( SwRedlineData* pCur = pRedlineData; pCur->pNext; ++nRet )
3752 		pCur = pCur->pNext;
3753 	return nRet;
3754 }
3755 
3756 // -> #111827#
GetAuthor(sal_uInt16 nPos) const3757 sal_uInt16 SwRedline::GetAuthor( sal_uInt16 nPos ) const
3758 {
3759     return GetRedlineData(nPos).nAuthor;
3760 }
3761 
GetAuthorString(sal_uInt16 nPos) const3762 const String& SwRedline::GetAuthorString( sal_uInt16 nPos ) const
3763 {
3764     return SW_MOD()->GetRedlineAuthor(GetRedlineData(nPos).nAuthor);
3765 }
3766 
GetTimeStamp(sal_uInt16 nPos) const3767 const DateTime& SwRedline::GetTimeStamp( sal_uInt16 nPos ) const
3768 {
3769     return GetRedlineData(nPos).aStamp;
3770 }
3771 
GetRealType(sal_uInt16 nPos) const3772 RedlineType_t SwRedline::GetRealType( sal_uInt16 nPos ) const
3773 {
3774     return GetRedlineData(nPos).eType;
3775 }
3776 
GetComment(sal_uInt16 nPos) const3777 const String& SwRedline::GetComment( sal_uInt16 nPos ) const
3778 {
3779     return GetRedlineData(nPos).sComment;
3780 }
3781 // <- #111827#
3782 
operator ==(const SwRedline & rCmp) const3783 int SwRedline::operator==( const SwRedline& rCmp ) const
3784 {
3785 	return this == &rCmp;
3786 }
3787 
operator <(const SwRedline & rCmp) const3788 int SwRedline::operator<( const SwRedline& rCmp ) const
3789 {
3790     sal_Bool nResult = sal_False;
3791 
3792     if (*Start() < *rCmp.Start())
3793         nResult = sal_True;
3794     else if (*Start() == *rCmp.Start())
3795         if (*End() < *rCmp.End())
3796             nResult = sal_True;
3797 
3798     return nResult;
3799 }
3800 
3801 // -> #111827#
GetRedlineData(sal_uInt16 nPos) const3802 const SwRedlineData & SwRedline::GetRedlineData(sal_uInt16 nPos) const
3803 {
3804     SwRedlineData * pCur = pRedlineData;
3805 
3806     while (nPos > 0 && NULL != pCur->pNext)
3807     {
3808         pCur = pCur->pNext;
3809 
3810         nPos--;
3811     }
3812 
3813 	ASSERT( 0 == nPos, "Pos angabe ist zu gross" );
3814 
3815     return *pCur;
3816 }
3817 
GetDescr(sal_uInt16 nPos)3818 String SwRedline::GetDescr(sal_uInt16 nPos)
3819 {
3820     String aResult;
3821 
3822     // get description of redline data (e.g.: "insert $1")
3823     aResult = GetRedlineData(nPos).GetDescr();
3824 
3825     SwPaM * pPaM = NULL;
3826     bool bDeletePaM = false;
3827 
3828     // if this redline is visible the content is in this PaM
3829     if (NULL == pCntntSect)
3830     {
3831         pPaM = this;
3832     }
3833     else // otherwise it is saved in pCntntSect
3834     {
3835         SwNodeIndex aTmpIdx( *pCntntSect->GetNode().EndOfSectionNode() );
3836         pPaM = new SwPaM(*pCntntSect, aTmpIdx );
3837         bDeletePaM = true;
3838     }
3839 
3840     // replace $1 in description by description of the redlines text
3841     String aTmpStr;
3842     aTmpStr += String(SW_RES(STR_START_QUOTE));
3843     aTmpStr += ShortenString(pPaM->GetTxt(), nUndoStringLength,
3844                              String(SW_RES(STR_LDOTS)));
3845     aTmpStr += String(SW_RES(STR_END_QUOTE));
3846 
3847     SwRewriter aRewriter;
3848     aRewriter.AddRule(UNDO_ARG1, aTmpStr);
3849 
3850     aResult = aRewriter.Apply(aResult);
3851 
3852     if (bDeletePaM)
3853         delete pPaM;
3854 
3855     return aResult;
3856 }
3857 // <- #111827#
3858 
3859 
IsInRedlines(const SwNode & rNode) const3860 bool SwDoc::IsInRedlines(const SwNode & rNode) const
3861 {
3862     SwPosition aPos(rNode);
3863     SwNode & rEndOfRedlines = GetNodes().GetEndOfRedlines();
3864     SwPaM aPam(SwPosition(*rEndOfRedlines.StartOfSectionNode()),
3865                SwPosition(rEndOfRedlines));
3866 
3867     return aPam.ContainsPosition(aPos) ? true : false;
3868 }
3869