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