Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <hintids.hxx>
21 : #include <svl/itemiter.hxx>
22 : #include <sfx2/app.hxx>
23 : #include <editeng/colritem.hxx>
24 : #include <editeng/udlnitem.hxx>
25 : #include <editeng/crossedoutitem.hxx>
26 : #include <swmodule.hxx>
27 : #include <doc.hxx>
28 : #include <docredln.hxx>
29 : #include <IDocumentUndoRedo.hxx>
30 : #include <DocumentContentOperationsManager.hxx>
31 : #include <IDocumentRedlineAccess.hxx>
32 : #include <IDocumentState.hxx>
33 : #include <IDocumentLayoutAccess.hxx>
34 : #include <IDocumentStylePoolAccess.hxx>
35 : #include <docary.hxx>
36 : #include <ndtxt.hxx>
37 : #include <redline.hxx>
38 : #include <swundo.hxx>
39 : #include <UndoCore.hxx>
40 : #include <UndoRedline.hxx>
41 : #include <hints.hxx>
42 : #include <pamtyp.hxx>
43 : #include <poolfmt.hxx>
44 : #include <viewsh.hxx>
45 : #include <rootfrm.hxx>
46 :
47 : #include <comcore.hrc>
48 :
49 : using namespace com::sun::star;
50 :
51 : #ifdef DBG_UTIL
52 :
53 : void sw_DebugRedline( const SwDoc* pDoc )
54 : {
55 : static sal_uInt16 nWatch = 0;
56 : const SwRedlineTbl& rTbl = pDoc->getIDocumentRedlineAccess().GetRedlineTbl();
57 : for( sal_uInt16 n = 0; n < rTbl.size(); ++n )
58 : {
59 : sal_uInt16 nDummy = 0;
60 : const SwRangeRedline* pCurrent = rTbl[ n ];
61 : const SwRangeRedline* pNext = n+1 < (sal_uInt16)rTbl.size() ? rTbl[ n+1 ] : 0;
62 : if( pCurrent == pNext )
63 : ++nDummy;
64 : if( n == nWatch )
65 : ++nDummy; // Possible debugger breakpoint
66 : }
67 : }
68 :
69 : #endif
70 :
71 :
72 10090 : SwExtraRedlineTbl::~SwExtraRedlineTbl()
73 : {
74 5045 : DeleteAndDestroyAll();
75 5045 : }
76 :
77 : #if OSL_DEBUG_LEVEL > 0
78 : bool CheckPosition( const SwPosition* pStt, const SwPosition* pEnd )
79 : {
80 : int nError = 0;
81 : SwNode* pSttNode = &pStt->nNode.GetNode();
82 : SwNode* pEndNode = &pEnd->nNode.GetNode();
83 : SwNode* pSttTab = pSttNode->StartOfSectionNode()->FindTableNode();
84 : SwNode* pEndTab = pEndNode->StartOfSectionNode()->FindTableNode();
85 : SwNode* pSttStart = pSttNode;
86 : while( pSttStart && (!pSttStart->IsStartNode() || pSttStart->IsSectionNode() ||
87 : pSttStart->IsTableNode() ) )
88 : pSttStart = pSttStart->StartOfSectionNode();
89 : SwNode* pEndStart = pEndNode;
90 : while( pEndStart && (!pEndStart->IsStartNode() || pEndStart->IsSectionNode() ||
91 : pEndStart->IsTableNode() ) )
92 : pEndStart = pEndStart->StartOfSectionNode();
93 : if( pSttTab != pEndTab )
94 : nError = 1;
95 : if( !pSttTab && pSttStart != pEndStart )
96 : nError |= 2;
97 : if( nError )
98 : nError += 10;
99 : return nError != 0;
100 : }
101 : #endif
102 :
103 1826 : bool SwExtraRedlineTbl::DeleteAllTableRedlines( SwDoc* pDoc, const SwTable& rTable, bool bSaveInUndo, sal_uInt16 nRedlineTypeToDelete )
104 : {
105 1826 : if( nsRedlineMode_t::REDLINE_IGNOREDELETE_REDLINES & pDoc->getIDocumentRedlineAccess().GetRedlineMode() )
106 0 : return false;
107 :
108 1826 : bool bChg = false;
109 :
110 1826 : if (bSaveInUndo && pDoc->GetIDocumentUndoRedo().DoesUndo())
111 : {
112 : // #TODO - Add 'Undo' support for deleting 'Table Cell' redlines
113 : /*
114 : SwUndoRedline* pUndo = new SwUndoRedline( UNDO_REDLINE, rRange );
115 : if( pUndo->GetRedlSaveCount() )
116 : {
117 : GetIDocumentUndoRedo().AppendUndo(pUndo);
118 : }
119 : else
120 : delete pUndo;
121 : */
122 : }
123 :
124 1826 : for(sal_uInt16 nCurRedlinePos = 0; nCurRedlinePos < GetSize(); ++nCurRedlinePos )
125 : {
126 0 : SwExtraRedline* pExtraRedline = GetRedline(nCurRedlinePos);
127 0 : const SwTableCellRedline* pTableCellRedline = dynamic_cast<const SwTableCellRedline*>(pExtraRedline);
128 0 : if (pTableCellRedline)
129 : {
130 0 : const SwTableBox *pRedTabBox = &pTableCellRedline->GetTableBox();
131 0 : const SwTable& pRedTable = pRedTabBox->GetSttNd()->FindTableNode()->GetTable();
132 0 : if ( &pRedTable == &rTable )
133 : {
134 : // Redline for this table
135 0 : const SwRedlineData& aRedlineData = pTableCellRedline->GetRedlineData();
136 0 : sal_uInt16 nRedlineType = aRedlineData.GetType();
137 :
138 : // Check if this redline object type should be deleted
139 0 : if( USHRT_MAX != nRedlineTypeToDelete && nRedlineTypeToDelete != nRedlineType )
140 0 : continue;
141 :
142 0 : DeleteAndDestroy( nCurRedlinePos );
143 0 : bChg = true;
144 : }
145 : }
146 : else
147 : {
148 0 : const SwTableRowRedline* pTableRowRedline = dynamic_cast<const SwTableRowRedline*>(pExtraRedline);
149 0 : if (pTableRowRedline)
150 : {
151 0 : const SwTableLine *pRedTabLine = &pTableRowRedline->GetTableLine();
152 0 : const SwTableBoxes &pRedTabBoxes = pRedTabLine->GetTabBoxes();
153 0 : const SwTable& pRedTable = pRedTabBoxes[0]->GetSttNd()->FindTableNode()->GetTable();
154 0 : if ( &pRedTable == &rTable )
155 : {
156 : // Redline for this table
157 0 : const SwRedlineData& aRedlineData = pTableRowRedline->GetRedlineData();
158 0 : sal_uInt16 nRedlineType = aRedlineData.GetType();
159 :
160 : // Check if this redline object type should be deleted
161 0 : if( USHRT_MAX != nRedlineTypeToDelete && nRedlineTypeToDelete != nRedlineType )
162 0 : continue;
163 :
164 0 : DeleteAndDestroy( nCurRedlinePos );
165 0 : bChg = true;
166 : }
167 : }
168 : }
169 : }
170 :
171 1826 : if( bChg )
172 0 : pDoc->getIDocumentState().SetModified();
173 :
174 1826 : return bChg;
175 : }
176 :
177 4 : bool SwExtraRedlineTbl::DeleteTableRowRedline( SwDoc* pDoc, const SwTableLine& rTableLine, bool bSaveInUndo, sal_uInt16 nRedlineTypeToDelete )
178 : {
179 4 : if( nsRedlineMode_t::REDLINE_IGNOREDELETE_REDLINES & pDoc->getIDocumentRedlineAccess().GetRedlineMode() )
180 0 : return false;
181 :
182 4 : bool bChg = false;
183 :
184 4 : if (bSaveInUndo && pDoc->GetIDocumentUndoRedo().DoesUndo())
185 : {
186 : // #TODO - Add 'Undo' support for deleting 'Table Cell' redlines
187 : /*
188 : SwUndoRedline* pUndo = new SwUndoRedline( UNDO_REDLINE, rRange );
189 : if( pUndo->GetRedlSaveCount() )
190 : {
191 : GetIDocumentUndoRedo().AppendUndo(pUndo);
192 : }
193 : else
194 : delete pUndo;
195 : */
196 : }
197 :
198 4 : for(sal_uInt16 nCurRedlinePos = 0; nCurRedlinePos < GetSize(); ++nCurRedlinePos )
199 : {
200 0 : SwExtraRedline* pExtraRedline = GetRedline(nCurRedlinePos);
201 0 : const SwTableRowRedline* pTableRowRedline = dynamic_cast<const SwTableRowRedline*>(pExtraRedline);
202 0 : const SwTableLine *pRedTabLine = pTableRowRedline ? &pTableRowRedline->GetTableLine() : NULL;
203 0 : if ( pRedTabLine == &rTableLine )
204 : {
205 : // Redline for this table row
206 0 : const SwRedlineData& aRedlineData = pTableRowRedline->GetRedlineData();
207 0 : sal_uInt16 nRedlineType = aRedlineData.GetType();
208 :
209 : // Check if this redline object type should be deleted
210 0 : if( USHRT_MAX != nRedlineTypeToDelete && nRedlineTypeToDelete != nRedlineType )
211 0 : continue;
212 :
213 0 : DeleteAndDestroy( nCurRedlinePos );
214 0 : bChg = true;
215 : }
216 : }
217 :
218 4 : if( bChg )
219 0 : pDoc->getIDocumentState().SetModified();
220 :
221 4 : return bChg;
222 : }
223 :
224 14 : bool SwExtraRedlineTbl::DeleteTableCellRedline( SwDoc* pDoc, const SwTableBox& rTableBox, bool bSaveInUndo, sal_uInt16 nRedlineTypeToDelete )
225 : {
226 14 : if( nsRedlineMode_t::REDLINE_IGNOREDELETE_REDLINES & pDoc->getIDocumentRedlineAccess().GetRedlineMode() )
227 0 : return false;
228 :
229 14 : bool bChg = false;
230 :
231 14 : if (bSaveInUndo && pDoc->GetIDocumentUndoRedo().DoesUndo())
232 : {
233 : // #TODO - Add 'Undo' support for deleting 'Table Cell' redlines
234 : /*
235 : SwUndoRedline* pUndo = new SwUndoRedline( UNDO_REDLINE, rRange );
236 : if( pUndo->GetRedlSaveCount() )
237 : {
238 : GetIDocumentUndoRedo().AppendUndo(pUndo);
239 : }
240 : else
241 : delete pUndo;
242 : */
243 : }
244 :
245 14 : for(sal_uInt16 nCurRedlinePos = 0; nCurRedlinePos < GetSize(); ++nCurRedlinePos )
246 : {
247 0 : SwExtraRedline* pExtraRedline = GetRedline(nCurRedlinePos);
248 0 : const SwTableCellRedline* pTableCellRedline = dynamic_cast<const SwTableCellRedline*>(pExtraRedline);
249 0 : const SwTableBox *pRedTabBox = pTableCellRedline ? &pTableCellRedline->GetTableBox() : NULL;
250 0 : if ( pRedTabBox == &rTableBox )
251 : {
252 : // Redline for this table cell
253 0 : const SwRedlineData& aRedlineData = pTableCellRedline->GetRedlineData();
254 0 : sal_uInt16 nRedlineType = aRedlineData.GetType();
255 :
256 : // Check if this redline object type should be deleted
257 0 : if( USHRT_MAX != nRedlineTypeToDelete && nRedlineTypeToDelete != nRedlineType )
258 0 : continue;
259 :
260 0 : DeleteAndDestroy( nCurRedlinePos );
261 0 : bChg = true;
262 : }
263 : }
264 :
265 14 : if( bChg )
266 0 : pDoc->getIDocumentState().SetModified();
267 :
268 14 : return bChg;
269 : }
270 :
271 3725 : bool SwRedlineTbl::Insert( SwRangeRedline* p, bool bIns )
272 : {
273 3725 : bool bRet = false;
274 3725 : if( p->HasValidRange() )
275 : {
276 3725 : bRet = insert( p ).second;
277 3725 : p->CallDisplayFunc();
278 : }
279 0 : else if( bIns )
280 0 : bRet = InsertWithValidRanges( p );
281 : else
282 : {
283 : OSL_ENSURE( false, "Redline: wrong range" );
284 : }
285 3725 : return bRet;
286 : }
287 :
288 0 : bool SwRedlineTbl::Insert( SwRangeRedline* p, sal_uInt16& rP, bool bIns )
289 : {
290 0 : bool bRet = false;
291 0 : if( p->HasValidRange() )
292 : {
293 0 : std::pair<_SwRedlineTbl::const_iterator, bool> rv = insert( p );
294 0 : rP = rv.first - begin();
295 0 : bRet = rv.second;
296 0 : p->CallDisplayFunc();
297 : }
298 0 : else if( bIns )
299 0 : bRet = InsertWithValidRanges( p, &rP );
300 : else
301 : {
302 : OSL_ENSURE( false, "Redline: wrong range" );
303 : }
304 0 : return bRet;
305 : }
306 :
307 0 : bool SwRedlineTbl::InsertWithValidRanges( SwRangeRedline* p, sal_uInt16* pInsPos )
308 : {
309 : // Create valid "sub-ranges" from the Selection
310 0 : bool bAnyIns = false;
311 0 : SwPosition* pStt = p->Start(),
312 0 : * pEnd = pStt == p->GetPoint() ? p->GetMark() : p->GetPoint();
313 0 : SwPosition aNewStt( *pStt );
314 0 : SwNodes& rNds = aNewStt.nNode.GetNodes();
315 : SwCntntNode* pC;
316 :
317 0 : if( !aNewStt.nNode.GetNode().IsCntntNode() )
318 : {
319 0 : pC = rNds.GoNext( &aNewStt.nNode );
320 0 : if( pC )
321 0 : aNewStt.nContent.Assign( pC, 0 );
322 : else
323 0 : aNewStt.nNode = rNds.GetEndOfContent();
324 : }
325 :
326 0 : SwRangeRedline* pNew = 0;
327 : sal_uInt16 nInsPos;
328 :
329 0 : if( aNewStt < *pEnd )
330 0 : do {
331 0 : if( !pNew )
332 0 : pNew = new SwRangeRedline( p->GetRedlineData(), aNewStt );
333 : else
334 : {
335 0 : pNew->DeleteMark();
336 0 : *pNew->GetPoint() = aNewStt;
337 : }
338 :
339 0 : pNew->SetMark();
340 0 : GoEndSection( pNew->GetPoint() );
341 : // i60396: If the redlines starts before a table but the table is the last member
342 : // of the section, the GoEndSection will end inside the table.
343 : // This will result in an incorrect redline, so we've to go back
344 0 : SwNode* pTab = pNew->GetPoint()->nNode.GetNode().StartOfSectionNode()->FindTableNode();
345 : // We end in a table when pTab != 0
346 0 : if( pTab && !pNew->GetMark()->nNode.GetNode().StartOfSectionNode()->FindTableNode() )
347 : { // but our Mark was outside the table => Correction
348 0 : do
349 : {
350 : // We want to be before the table
351 0 : *pNew->GetPoint() = SwPosition(*pTab);
352 0 : pC = GoPreviousNds( &pNew->GetPoint()->nNode, false ); // here we are.
353 0 : if( pC )
354 0 : pNew->GetPoint()->nContent.Assign( pC, 0 );
355 0 : pTab = pNew->GetPoint()->nNode.GetNode().StartOfSectionNode()->FindTableNode();
356 : } while( pTab ); // If there is another table we have to repeat our step backwards
357 : }
358 :
359 0 : if( *pNew->GetPoint() > *pEnd )
360 : {
361 0 : pC = 0;
362 0 : if( aNewStt.nNode != pEnd->nNode )
363 0 : do {
364 0 : SwNode& rCurNd = aNewStt.nNode.GetNode();
365 0 : if( rCurNd.IsStartNode() )
366 : {
367 0 : if( rCurNd.EndOfSectionIndex() < pEnd->nNode.GetIndex() )
368 0 : aNewStt.nNode = *rCurNd.EndOfSectionNode();
369 : else
370 0 : break;
371 : }
372 0 : else if( rCurNd.IsCntntNode() )
373 0 : pC = rCurNd.GetCntntNode();
374 0 : aNewStt.nNode++;
375 0 : } while( aNewStt.nNode.GetIndex() < pEnd->nNode.GetIndex() );
376 :
377 0 : if( aNewStt.nNode == pEnd->nNode )
378 0 : aNewStt.nContent = pEnd->nContent;
379 0 : else if( pC )
380 : {
381 0 : aNewStt.nNode = *pC;
382 0 : aNewStt.nContent.Assign( pC, pC->Len() );
383 : }
384 :
385 0 : if( aNewStt <= *pEnd )
386 0 : *pNew->GetPoint() = aNewStt;
387 : }
388 : else
389 0 : aNewStt = *pNew->GetPoint();
390 : #if OSL_DEBUG_LEVEL > 0
391 : CheckPosition( pNew->GetPoint(), pNew->GetMark() );
392 : #endif
393 :
394 0 : if( *pNew->GetPoint() != *pNew->GetMark() &&
395 0 : pNew->HasValidRange() &&
396 0 : Insert( pNew, nInsPos ) )
397 : {
398 0 : pNew->CallDisplayFunc();
399 0 : bAnyIns = true;
400 0 : pNew = 0;
401 0 : if( pInsPos && *pInsPos < nInsPos )
402 0 : *pInsPos = nInsPos;
403 : }
404 :
405 0 : if( aNewStt >= *pEnd ||
406 : 0 == (pC = rNds.GoNext( &aNewStt.nNode )) )
407 0 : break;
408 :
409 0 : aNewStt.nContent.Assign( pC, 0 );
410 :
411 : } while( aNewStt < *pEnd );
412 :
413 0 : delete pNew;
414 0 : delete p, p = 0;
415 0 : return bAnyIns;
416 : }
417 :
418 21464 : bool CompareSwRedlineTbl::operator()(SwRangeRedline* const &lhs, SwRangeRedline* const &rhs) const
419 : {
420 21464 : return *lhs < *rhs;
421 : }
422 :
423 10090 : _SwRedlineTbl::~_SwRedlineTbl()
424 : {
425 5045 : DeleteAndDestroyAll();
426 5045 : }
427 :
428 12 : sal_uInt16 SwRedlineTbl::GetPos(const SwRangeRedline* p) const
429 : {
430 12 : const_iterator it = find(const_cast<SwRangeRedline* const>(p));
431 12 : if( it == end() )
432 0 : return USHRT_MAX;
433 12 : return it - begin();
434 : }
435 :
436 0 : bool SwRedlineTbl::Remove( const SwRangeRedline* p )
437 : {
438 0 : sal_uInt16 nPos = GetPos(p);
439 0 : if (nPos != USHRT_MAX)
440 0 : Remove(nPos);
441 0 : return nPos != USHRT_MAX;
442 : }
443 :
444 0 : void SwRedlineTbl::Remove( sal_uInt16 nP )
445 : {
446 0 : SwDoc* pDoc = 0;
447 0 : if( !nP && 1 == size() )
448 0 : pDoc = front()->GetDoc();
449 :
450 0 : erase( begin() + nP );
451 :
452 : SwViewShell* pSh;
453 0 : if( pDoc && !pDoc->IsInDtor() &&
454 0 : 0 != ( pSh = pDoc->getIDocumentLayoutAccess().GetCurrentViewShell()) )
455 0 : pSh->InvalidateWindows( SwRect( 0, 0, LONG_MAX, LONG_MAX ) );
456 0 : }
457 :
458 5083 : void SwRedlineTbl::DeleteAndDestroyAll()
459 : {
460 5083 : DeleteAndDestroy(0, size());
461 5083 : }
462 :
463 8193 : void SwRedlineTbl::DeleteAndDestroy( sal_uInt16 nP, sal_uInt16 nL )
464 : {
465 8193 : SwDoc* pDoc = 0;
466 8193 : if( !nP && nL && nL == size() )
467 246 : pDoc = front()->GetDoc();
468 :
469 11918 : for( const_iterator it = begin() + nP; it != begin() + nP + nL; ++it )
470 3725 : delete *it;
471 8193 : erase( begin() + nP, begin() + nP + nL );
472 :
473 : SwViewShell* pSh;
474 8299 : if( pDoc && !pDoc->IsInDtor() &&
475 106 : 0 != ( pSh = pDoc->getIDocumentLayoutAccess().GetCurrentViewShell() ) )
476 0 : pSh->InvalidateWindows( SwRect( 0, 0, LONG_MAX, LONG_MAX ) );
477 8193 : }
478 :
479 : /// Find the next or preceding Redline with the same seq.no.
480 : /// We can limit the search using look ahead.
481 : /// 0 or USHRT_MAX searches the whole array.
482 0 : sal_uInt16 SwRedlineTbl::FindNextOfSeqNo( sal_uInt16 nSttPos, sal_uInt16 nLookahead ) const
483 : {
484 0 : return nSttPos + 1 < (sal_uInt16)size()
485 0 : ? FindNextSeqNo( operator[]( nSttPos )->GetSeqNo(), nSttPos+1, nLookahead )
486 0 : : USHRT_MAX;
487 : }
488 :
489 0 : sal_uInt16 SwRedlineTbl::FindPrevOfSeqNo( sal_uInt16 nSttPos, sal_uInt16 nLookahead ) const
490 : {
491 0 : return nSttPos ? FindPrevSeqNo( operator[]( nSttPos )->GetSeqNo(), nSttPos-1, nLookahead )
492 0 : : USHRT_MAX;
493 : }
494 :
495 0 : sal_uInt16 SwRedlineTbl::FindNextSeqNo( sal_uInt16 nSeqNo, sal_uInt16 nSttPos,
496 : sal_uInt16 nLookahead ) const
497 : {
498 0 : sal_uInt16 nRet = USHRT_MAX, nEnd;
499 0 : if( nSeqNo && nSttPos < size() )
500 : {
501 0 : nEnd = size();
502 0 : if( nLookahead && USHRT_MAX != nLookahead &&
503 0 : static_cast<size_t>(nSttPos + nLookahead) < size() )
504 0 : nEnd = nSttPos + nLookahead;
505 :
506 0 : for( ; nSttPos < nEnd; ++nSttPos )
507 0 : if( nSeqNo == operator[]( nSttPos )->GetSeqNo() )
508 : {
509 0 : nRet = nSttPos;
510 0 : break;
511 : }
512 : }
513 0 : return nRet;
514 : }
515 :
516 0 : sal_uInt16 SwRedlineTbl::FindPrevSeqNo( sal_uInt16 nSeqNo, sal_uInt16 nSttPos,
517 : sal_uInt16 nLookahead ) const
518 : {
519 0 : sal_uInt16 nRet = USHRT_MAX, nEnd;
520 0 : if( nSeqNo && nSttPos < size() )
521 : {
522 0 : nEnd = 0;
523 0 : if( nLookahead && USHRT_MAX != nLookahead && nSttPos > nLookahead )
524 0 : nEnd = nSttPos - nLookahead;
525 :
526 0 : ++nSttPos;
527 0 : while( nSttPos > nEnd )
528 0 : if( nSeqNo == operator[]( --nSttPos )->GetSeqNo() )
529 : {
530 0 : nRet = nSttPos;
531 0 : break;
532 : }
533 : }
534 0 : return nRet;
535 : }
536 :
537 0 : const SwRangeRedline* SwRedlineTbl::FindAtPosition( const SwPosition& rSttPos,
538 : sal_uInt16& rPos,
539 : bool bNext ) const
540 : {
541 0 : const SwRangeRedline* pFnd = 0;
542 0 : for( ; rPos < size() ; ++rPos )
543 : {
544 0 : const SwRangeRedline* pTmp = (*this)[ rPos ];
545 0 : if( pTmp->HasMark() && pTmp->IsVisible() )
546 : {
547 0 : const SwPosition* pRStt = pTmp->Start(),
548 0 : * pREnd = pRStt == pTmp->GetPoint() ? pTmp->GetMark()
549 0 : : pTmp->GetPoint();
550 0 : if( bNext ? *pRStt <= rSttPos : *pRStt < rSttPos )
551 : {
552 0 : if( bNext ? *pREnd > rSttPos : *pREnd >= rSttPos )
553 : {
554 0 : pFnd = pTmp;
555 0 : break;
556 : }
557 : }
558 : else
559 0 : break;
560 : }
561 : }
562 0 : return pFnd;
563 : }
564 :
565 :
566 1614 : SwRedlineExtraData::~SwRedlineExtraData()
567 : {
568 1614 : }
569 :
570 0 : void SwRedlineExtraData::Accept( SwPaM& ) const
571 : {
572 0 : }
573 :
574 0 : void SwRedlineExtraData::Reject( SwPaM& ) const
575 : {
576 0 : }
577 :
578 0 : bool SwRedlineExtraData::operator == ( const SwRedlineExtraData& ) const
579 : {
580 0 : return false;
581 : }
582 :
583 0 : SwRedlineExtraData_FmtColl::SwRedlineExtraData_FmtColl( const OUString& rColl,
584 : sal_uInt16 nPoolFmtId,
585 : const SfxItemSet* pItemSet )
586 0 : : sFmtNm(rColl), pSet(0), nPoolId(nPoolFmtId)
587 : {
588 0 : if( pItemSet && pItemSet->Count() )
589 0 : pSet = new SfxItemSet( *pItemSet );
590 0 : }
591 :
592 0 : SwRedlineExtraData_FmtColl::~SwRedlineExtraData_FmtColl()
593 : {
594 0 : delete pSet;
595 0 : }
596 :
597 0 : SwRedlineExtraData* SwRedlineExtraData_FmtColl::CreateNew() const
598 : {
599 0 : return new SwRedlineExtraData_FmtColl( sFmtNm, nPoolId, pSet );
600 : }
601 :
602 0 : void SwRedlineExtraData_FmtColl::Reject( SwPaM& rPam ) const
603 : {
604 0 : SwDoc* pDoc = rPam.GetDoc();
605 :
606 : // What about Undo? Is it turned off?
607 0 : SwTxtFmtColl* pColl = USHRT_MAX == nPoolId
608 0 : ? pDoc->FindTxtFmtCollByName( sFmtNm )
609 0 : : pDoc->getIDocumentStylePoolAccess().GetTxtCollFromPool( nPoolId );
610 0 : if( pColl )
611 0 : pDoc->SetTxtFmtColl( rPam, pColl, false );
612 :
613 0 : if( pSet )
614 : {
615 0 : rPam.SetMark();
616 0 : SwPosition& rMark = *rPam.GetMark();
617 0 : SwTxtNode* pTNd = rMark.nNode.GetNode().GetTxtNode();
618 0 : if( pTNd )
619 : {
620 0 : rMark.nContent.Assign(pTNd, pTNd->GetTxt().getLength());
621 :
622 0 : if( pTNd->HasSwAttrSet() )
623 : {
624 : // Only set those that are not there anymore. Others
625 : // could have changed, but we don't touch these.
626 0 : SfxItemSet aTmp( *pSet );
627 0 : aTmp.Differentiate( *pTNd->GetpSwAttrSet() );
628 0 : pDoc->getIDocumentContentOperations().InsertItemSet( rPam, aTmp, 0 );
629 : }
630 : else
631 : {
632 0 : pDoc->getIDocumentContentOperations().InsertItemSet( rPam, *pSet, 0 );
633 : }
634 : }
635 0 : rPam.DeleteMark();
636 : }
637 0 : }
638 :
639 0 : bool SwRedlineExtraData_FmtColl::operator == ( const SwRedlineExtraData& r) const
640 : {
641 0 : const SwRedlineExtraData_FmtColl& rCmp = (SwRedlineExtraData_FmtColl&)r;
642 0 : return sFmtNm == rCmp.sFmtNm && nPoolId == rCmp.nPoolId &&
643 0 : ( ( !pSet && !rCmp.pSet ) ||
644 0 : ( pSet && rCmp.pSet && *pSet == *rCmp.pSet ) );
645 : }
646 :
647 0 : void SwRedlineExtraData_FmtColl::SetItemSet( const SfxItemSet& rSet )
648 : {
649 0 : delete pSet;
650 0 : if( rSet.Count() )
651 0 : pSet = new SfxItemSet( rSet );
652 : else
653 0 : pSet = 0;
654 0 : }
655 :
656 0 : SwRedlineExtraData_Format::SwRedlineExtraData_Format( const SfxItemSet& rSet )
657 : {
658 0 : SfxItemIter aIter( rSet );
659 0 : const SfxPoolItem* pItem = aIter.FirstItem();
660 : while( true )
661 : {
662 0 : aWhichIds.push_back( pItem->Which() );
663 0 : if( aIter.IsAtEnd() )
664 0 : break;
665 0 : pItem = aIter.NextItem();
666 0 : }
667 0 : }
668 :
669 0 : SwRedlineExtraData_Format::SwRedlineExtraData_Format(
670 : const SwRedlineExtraData_Format& rCpy )
671 0 : : SwRedlineExtraData()
672 : {
673 0 : aWhichIds.insert( aWhichIds.begin(), rCpy.aWhichIds.begin(), rCpy.aWhichIds.end() );
674 0 : }
675 :
676 0 : SwRedlineExtraData_Format::~SwRedlineExtraData_Format()
677 : {
678 0 : }
679 :
680 0 : SwRedlineExtraData* SwRedlineExtraData_Format::CreateNew() const
681 : {
682 0 : return new SwRedlineExtraData_Format( *this );
683 : }
684 :
685 0 : void SwRedlineExtraData_Format::Reject( SwPaM& rPam ) const
686 : {
687 0 : SwDoc* pDoc = rPam.GetDoc();
688 :
689 0 : RedlineMode_t eOld = pDoc->getIDocumentRedlineAccess().GetRedlineMode();
690 0 : pDoc->getIDocumentRedlineAccess().SetRedlineMode_intern((RedlineMode_t)(eOld & ~(nsRedlineMode_t::REDLINE_ON | nsRedlineMode_t::REDLINE_IGNORE)));
691 :
692 : // Actually we need to reset the Attribute here!
693 0 : std::vector<sal_uInt16>::const_iterator it;
694 0 : for( it = aWhichIds.begin(); it != aWhichIds.end(); ++it )
695 : {
696 0 : pDoc->getIDocumentContentOperations().InsertPoolItem( rPam, *GetDfltAttr( *it ),
697 0 : nsSetAttrMode::SETATTR_DONTEXPAND );
698 : }
699 :
700 0 : pDoc->getIDocumentRedlineAccess().SetRedlineMode_intern( eOld );
701 0 : }
702 :
703 0 : bool SwRedlineExtraData_Format::operator == ( const SwRedlineExtraData& rCmp ) const
704 : {
705 0 : bool nRet = true;
706 0 : size_t nEnd = aWhichIds.size();
707 0 : if( nEnd != ((SwRedlineExtraData_Format&)rCmp).aWhichIds.size() )
708 0 : nRet = false;
709 : else
710 0 : for( size_t n = 0; n < nEnd; ++n )
711 0 : if( ((SwRedlineExtraData_Format&)rCmp).aWhichIds[n] != aWhichIds[n])
712 : {
713 0 : nRet = false;
714 0 : break;
715 : }
716 0 : return nRet;
717 : }
718 :
719 1614 : SwRedlineExtraData_FormattingChanges::SwRedlineExtraData_FormattingChanges( const SfxItemSet* pItemSet )
720 1614 : : pSet(0)
721 : {
722 1614 : if( pItemSet && pItemSet->Count() )
723 1612 : pSet = new SfxItemSet( *pItemSet );
724 1614 : }
725 :
726 1614 : SwRedlineExtraData_FormattingChanges::SwRedlineExtraData_FormattingChanges( const SwRedlineExtraData_FormattingChanges& rCpy )
727 1614 : : SwRedlineExtraData()
728 : {
729 : // Checking pointer pSet before accessing it for Count
730 1614 : if( rCpy.pSet && rCpy.pSet->Count() )
731 : {
732 1612 : pSet = new SfxItemSet( *(rCpy.pSet) );
733 : }
734 : else
735 : {
736 2 : pSet = 0;
737 : }
738 1614 : }
739 :
740 4842 : SwRedlineExtraData_FormattingChanges::~SwRedlineExtraData_FormattingChanges()
741 : {
742 1614 : delete pSet;
743 3228 : }
744 :
745 1614 : SwRedlineExtraData* SwRedlineExtraData_FormattingChanges::CreateNew() const
746 : {
747 1614 : return new SwRedlineExtraData_FormattingChanges( *this );
748 : }
749 :
750 0 : void SwRedlineExtraData_FormattingChanges::Reject( SwPaM& rPam ) const
751 : {
752 0 : rPam.GetDoc(); // This is here just to prevent build 'warning'
753 :
754 : // ToDo: Add 'Reject' logic
755 0 : }
756 :
757 1342 : bool SwRedlineExtraData_FormattingChanges::operator == ( const SwRedlineExtraData& rExtraData ) const
758 : {
759 1342 : const SwRedlineExtraData_FormattingChanges& rCmp = (SwRedlineExtraData_FormattingChanges&)rExtraData;
760 :
761 1342 : if ( !pSet && !rCmp.pSet )
762 : {
763 : // Both SfxItemSet are null
764 0 : return true;
765 : }
766 1342 : else if ( pSet && rCmp.pSet && *pSet == *rCmp.pSet )
767 : {
768 : // Both SfxItemSet exist and are equal
769 874 : return true;
770 : }
771 468 : return false;
772 : }
773 :
774 5108 : SwRedlineData::SwRedlineData( RedlineType_t eT, sal_uInt16 nAut )
775 : : pNext( 0 ), pExtraData( 0 ),
776 : aStamp( DateTime::SYSTEM ),
777 5108 : eType( eT ), nAuthor( nAut ), nSeqNo( 0 )
778 : {
779 5108 : aStamp.SetSec( 0 );
780 5108 : aStamp.SetNanoSec( 0 );
781 5108 : }
782 :
783 2966 : SwRedlineData::SwRedlineData(
784 : const SwRedlineData& rCpy,
785 : bool bCpyNext )
786 2962 : : pNext( ( bCpyNext && rCpy.pNext ) ? new SwRedlineData( *rCpy.pNext ) : 0 )
787 0 : , pExtraData( rCpy.pExtraData ? rCpy.pExtraData->CreateNew() : 0 )
788 : , sComment( rCpy.sComment )
789 : , aStamp( rCpy.aStamp )
790 : , eType( rCpy.eType )
791 : , nAuthor( rCpy.nAuthor )
792 2966 : , nSeqNo( rCpy.nSeqNo )
793 : {
794 2966 : }
795 :
796 : // For sw3io: We now own pNext!
797 30 : SwRedlineData::SwRedlineData(RedlineType_t eT, sal_uInt16 nAut, const DateTime& rDT,
798 : const OUString& rCmnt, SwRedlineData *pNxt, SwRedlineExtraData* pData)
799 : : pNext(pNxt), pExtraData(pData), sComment(rCmnt), aStamp(rDT),
800 30 : eType(eT), nAuthor(nAut), nSeqNo(0)
801 : {
802 30 : }
803 :
804 16208 : SwRedlineData::~SwRedlineData()
805 : {
806 8104 : delete pExtraData;
807 8104 : delete pNext;
808 8104 : }
809 :
810 : /// ExtraData is copied. The Pointer's ownership is thus NOT transferred
811 : /// to the Redline Object!
812 2944 : void SwRedlineData::SetExtraData( const SwRedlineExtraData* pData )
813 : {
814 2944 : delete pExtraData;
815 :
816 : // Check if there is data - and if so - delete it
817 2944 : if( pData )
818 1614 : pExtraData = pData->CreateNew();
819 : else
820 1330 : pExtraData = 0;
821 2944 : }
822 :
823 0 : OUString SwRedlineData::GetDescr() const
824 : {
825 0 : OUString aResult;
826 :
827 0 : aResult += SW_RES(STR_REDLINE_INSERT + GetType());
828 :
829 0 : return aResult;
830 : }
831 :
832 2164 : SwRangeRedline::SwRangeRedline(RedlineType_t eTyp, const SwPaM& rPam )
833 2164 : : SwPaM( *rPam.GetMark(), *rPam.GetPoint() ),
834 4328 : pRedlineData( new SwRedlineData( eTyp, GetDoc()->getIDocumentRedlineAccess().GetRedlineAuthor() ) ),
835 6492 : pCntntSect( 0 )
836 : {
837 2164 : bDelLastPara = bIsLastParaDelete = false;
838 2164 : bIsVisible = true;
839 2164 : if( !rPam.HasMark() )
840 0 : DeleteMark();
841 2164 : }
842 :
843 2890 : SwRangeRedline::SwRangeRedline( const SwRedlineData& rData, const SwPaM& rPam )
844 2890 : : SwPaM( *rPam.GetMark(), *rPam.GetPoint() ),
845 2890 : pRedlineData( new SwRedlineData( rData )),
846 5780 : pCntntSect( 0 )
847 : {
848 2890 : bDelLastPara = bIsLastParaDelete = false;
849 2890 : bIsVisible = true;
850 2890 : if( !rPam.HasMark() )
851 4 : DeleteMark();
852 2890 : }
853 :
854 0 : SwRangeRedline::SwRangeRedline( const SwRedlineData& rData, const SwPosition& rPos )
855 : : SwPaM( rPos ),
856 0 : pRedlineData( new SwRedlineData( rData )),
857 0 : pCntntSect( 0 )
858 : {
859 0 : bDelLastPara = bIsLastParaDelete = false;
860 0 : bIsVisible = true;
861 0 : }
862 :
863 0 : SwRangeRedline::SwRangeRedline( const SwRangeRedline& rCpy )
864 0 : : SwPaM( *rCpy.GetMark(), *rCpy.GetPoint() ),
865 0 : pRedlineData( new SwRedlineData( *rCpy.pRedlineData )),
866 0 : pCntntSect( 0 )
867 : {
868 0 : bDelLastPara = bIsLastParaDelete = false;
869 0 : bIsVisible = true;
870 0 : if( !rCpy.HasMark() )
871 0 : DeleteMark();
872 0 : }
873 :
874 15222 : SwRangeRedline::~SwRangeRedline()
875 : {
876 5074 : if( pCntntSect )
877 : {
878 : // delete the ContentSection
879 2 : if( !GetDoc()->IsInDtor() )
880 0 : GetDoc()->getIDocumentContentOperations().DeleteSection( &pCntntSect->GetNode() );
881 2 : delete pCntntSect;
882 : }
883 5074 : delete pRedlineData;
884 10148 : }
885 :
886 : /// Do we have a valid Selection?
887 4252 : bool SwRangeRedline::HasValidRange() const
888 : {
889 4252 : const SwNode* pPtNd = &GetPoint()->nNode.GetNode(),
890 4252 : * pMkNd = &GetMark()->nNode.GetNode();
891 12756 : if( pPtNd->StartOfSectionNode() == pMkNd->StartOfSectionNode() &&
892 12756 : !pPtNd->StartOfSectionNode()->IsTableNode() &&
893 : // invalid if points on the end of content
894 : // end-of-content only invalid if no content index exists
895 7888 : ( pPtNd != pMkNd || GetContentIdx() != NULL ||
896 3938 : pPtNd != &pPtNd->GetNodes().GetEndOfContent() )
897 : )
898 4252 : return true;
899 0 : return false;
900 : }
901 :
902 3725 : void SwRangeRedline::CallDisplayFunc( sal_uInt16 nLoop )
903 : {
904 3725 : switch( nsRedlineMode_t::REDLINE_SHOW_MASK & GetDoc()->getIDocumentRedlineAccess().GetRedlineMode() )
905 : {
906 : case nsRedlineMode_t::REDLINE_SHOW_INSERT | nsRedlineMode_t::REDLINE_SHOW_DELETE:
907 330 : Show( nLoop );
908 330 : break;
909 : case nsRedlineMode_t::REDLINE_SHOW_INSERT:
910 511 : Hide( nLoop );
911 511 : break;
912 : case nsRedlineMode_t::REDLINE_SHOW_DELETE:
913 0 : ShowOriginal( nLoop );
914 0 : break;
915 : }
916 3725 : }
917 :
918 3272 : void SwRangeRedline::Show( sal_uInt16 nLoop )
919 : {
920 3272 : if( 1 <= nLoop )
921 : {
922 40 : SwDoc* pDoc = GetDoc();
923 40 : RedlineMode_t eOld = pDoc->getIDocumentRedlineAccess().GetRedlineMode();
924 40 : pDoc->getIDocumentRedlineAccess().SetRedlineMode_intern((RedlineMode_t)(eOld | nsRedlineMode_t::REDLINE_IGNORE));
925 40 : ::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo());
926 :
927 40 : switch( GetType() )
928 : {
929 : case nsRedlineType_t::REDLINE_INSERT: // Content has been inserted
930 16 : bIsVisible = true;
931 16 : MoveFromSection();
932 16 : break;
933 :
934 : case nsRedlineType_t::REDLINE_DELETE: // Content has been deleted
935 24 : bIsVisible = true;
936 24 : MoveFromSection();
937 24 : break;
938 :
939 : case nsRedlineType_t::REDLINE_FORMAT: // Attributes have been applied
940 : case nsRedlineType_t::REDLINE_TABLE: // Table structure has been modified
941 0 : InvalidateRange();
942 0 : break;
943 : default:
944 0 : break;
945 : }
946 40 : pDoc->getIDocumentRedlineAccess().SetRedlineMode_intern( eOld );
947 : }
948 3272 : }
949 :
950 515 : void SwRangeRedline::Hide( sal_uInt16 nLoop )
951 : {
952 515 : SwDoc* pDoc = GetDoc();
953 515 : RedlineMode_t eOld = pDoc->getIDocumentRedlineAccess().GetRedlineMode();
954 515 : pDoc->getIDocumentRedlineAccess().SetRedlineMode_intern((RedlineMode_t)(eOld | nsRedlineMode_t::REDLINE_IGNORE));
955 515 : ::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo());
956 :
957 515 : switch( GetType() )
958 : {
959 : case nsRedlineType_t::REDLINE_INSERT: // Content has been inserted
960 511 : bIsVisible = true;
961 511 : if( 1 <= nLoop )
962 0 : MoveFromSection();
963 511 : break;
964 :
965 : case nsRedlineType_t::REDLINE_DELETE: // Content has been deleted
966 4 : bIsVisible = false;
967 4 : switch( nLoop )
968 : {
969 0 : case 0: MoveToSection(); break;
970 2 : case 1: CopyToSection(); break;
971 2 : case 2: DelCopyOfSection(); break;
972 : }
973 4 : break;
974 :
975 : case nsRedlineType_t::REDLINE_FORMAT: // Attributes have been applied
976 : case nsRedlineType_t::REDLINE_TABLE: // Table structure has been modified
977 0 : if( 1 <= nLoop )
978 0 : InvalidateRange();
979 0 : break;
980 : default:
981 0 : break;
982 : }
983 515 : pDoc->getIDocumentRedlineAccess().SetRedlineMode_intern( eOld );
984 515 : }
985 :
986 0 : void SwRangeRedline::ShowOriginal( sal_uInt16 nLoop )
987 : {
988 0 : SwDoc* pDoc = GetDoc();
989 0 : RedlineMode_t eOld = pDoc->getIDocumentRedlineAccess().GetRedlineMode();
990 : SwRedlineData* pCur;
991 :
992 0 : pDoc->getIDocumentRedlineAccess().SetRedlineMode_intern((RedlineMode_t)(eOld | nsRedlineMode_t::REDLINE_IGNORE));
993 0 : ::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo());
994 :
995 : // Determine the Type, it's the first on Stack
996 0 : for( pCur = pRedlineData; pCur->pNext; )
997 0 : pCur = pCur->pNext;
998 :
999 0 : switch( pCur->eType )
1000 : {
1001 : case nsRedlineType_t::REDLINE_INSERT: // Content has been inserted
1002 0 : bIsVisible = false;
1003 0 : switch( nLoop )
1004 : {
1005 0 : case 0: MoveToSection(); break;
1006 0 : case 1: CopyToSection(); break;
1007 0 : case 2: DelCopyOfSection(); break;
1008 : }
1009 0 : break;
1010 :
1011 : case nsRedlineType_t::REDLINE_DELETE: // Inhalt wurde eingefuegt
1012 0 : bIsVisible = true;
1013 0 : if( 1 <= nLoop )
1014 0 : MoveFromSection();
1015 0 : break;
1016 :
1017 : case nsRedlineType_t::REDLINE_FORMAT: // Attributes have been applied
1018 : case nsRedlineType_t::REDLINE_TABLE: // Table structure has been modified
1019 0 : if( 1 <= nLoop )
1020 0 : InvalidateRange();
1021 0 : break;
1022 : default:
1023 0 : break;
1024 : }
1025 0 : pDoc->getIDocumentRedlineAccess().SetRedlineMode_intern( eOld );
1026 0 : }
1027 :
1028 5231 : void SwRangeRedline::InvalidateRange() // trigger the Layout
1029 : {
1030 5231 : sal_uLong nSttNd = GetMark()->nNode.GetIndex(),
1031 5231 : nEndNd = GetPoint()->nNode.GetIndex();
1032 5231 : sal_Int32 nSttCnt = GetMark()->nContent.GetIndex();
1033 5231 : sal_Int32 nEndCnt = GetPoint()->nContent.GetIndex();
1034 :
1035 5231 : if( nSttNd > nEndNd || ( nSttNd == nEndNd && nSttCnt > nEndCnt ))
1036 : {
1037 2914 : sal_uLong nTmp = nSttNd; nSttNd = nEndNd; nEndNd = nTmp;
1038 2914 : sal_Int32 nTmp2 = nSttCnt; nSttCnt = nEndCnt; nEndCnt = nTmp2;
1039 : }
1040 :
1041 5231 : SwNodes& rNds = GetDoc()->GetNodes();
1042 10750 : for (sal_uLong n(nSttNd); n <= nEndNd; ++n)
1043 : {
1044 5519 : SwNode* pNode = rNds[n];
1045 :
1046 5519 : if (pNode && pNode->IsTxtNode())
1047 : {
1048 5517 : SwTxtNode* pNd = static_cast< SwTxtNode* >(pNode);
1049 : SwUpdateAttr aHt(
1050 : n == nSttNd ? nSttCnt : 0,
1051 286 : n == nEndNd ? nEndCnt : pNd->GetTxt().getLength(),
1052 5803 : RES_FMT_CHG);
1053 :
1054 5517 : pNd->ModifyNotification(&aHt, &aHt);
1055 : }
1056 : }
1057 5231 : }
1058 :
1059 : /** Calculates the start and end position of the intersection rTmp and
1060 : text node nNdIdx */
1061 20878 : void SwRangeRedline::CalcStartEnd( sal_uLong nNdIdx, sal_Int32& rStart, sal_Int32& rEnd ) const
1062 : {
1063 20878 : const SwPosition *pRStt = Start(), *pREnd = End();
1064 20878 : if( pRStt->nNode < nNdIdx )
1065 : {
1066 12318 : if( pREnd->nNode > nNdIdx )
1067 : {
1068 1526 : rStart = 0; // Paragraph is completely enclosed
1069 1526 : rEnd = COMPLETE_STRING;
1070 : }
1071 : else
1072 : {
1073 : OSL_ENSURE( pREnd->nNode == nNdIdx,
1074 : "SwRedlineItr::Seek: GetRedlinePos Error" );
1075 10792 : rStart = 0; // Paragraph is overlapped in the beginning
1076 10792 : rEnd = pREnd->nContent.GetIndex();
1077 : }
1078 : }
1079 8560 : else if( pRStt->nNode == nNdIdx )
1080 : {
1081 8508 : rStart = pRStt->nContent.GetIndex();
1082 8508 : if( pREnd->nNode == nNdIdx )
1083 7128 : rEnd = pREnd->nContent.GetIndex(); // Within the Paragraph
1084 : else
1085 1380 : rEnd = COMPLETE_STRING; // Paragraph is overlapped in the end
1086 : }
1087 : else
1088 : {
1089 52 : rStart = COMPLETE_STRING;
1090 52 : rEnd = COMPLETE_STRING;
1091 : }
1092 20878 : }
1093 :
1094 0 : void SwRangeRedline::MoveToSection()
1095 : {
1096 0 : if( !pCntntSect )
1097 : {
1098 0 : const SwPosition* pStt = Start(),
1099 0 : * pEnd = pStt == GetPoint() ? GetMark() : GetPoint();
1100 :
1101 0 : SwDoc* pDoc = GetDoc();
1102 0 : SwPaM aPam( *pStt, *pEnd );
1103 0 : SwCntntNode* pCSttNd = pStt->nNode.GetNode().GetCntntNode();
1104 0 : SwCntntNode* pCEndNd = pEnd->nNode.GetNode().GetCntntNode();
1105 :
1106 0 : if( !pCSttNd )
1107 : {
1108 : // In order to not move other Redlines' indices, we set them
1109 : // to the end (is exclusive)
1110 0 : const SwRedlineTbl& rTbl = pDoc->getIDocumentRedlineAccess().GetRedlineTbl();
1111 0 : for( sal_uInt16 n = 0; n < rTbl.size(); ++n )
1112 : {
1113 0 : SwRangeRedline* pRedl = rTbl[ n ];
1114 0 : if( pRedl->GetBound(true) == *pStt )
1115 0 : pRedl->GetBound(true) = *pEnd;
1116 0 : if( pRedl->GetBound(false) == *pStt )
1117 0 : pRedl->GetBound(false) = *pEnd;
1118 : }
1119 : }
1120 :
1121 : SwStartNode* pSttNd;
1122 0 : SwNodes& rNds = pDoc->GetNodes();
1123 0 : if( pCSttNd || pCEndNd )
1124 : {
1125 0 : SwTxtFmtColl* pColl = (pCSttNd && pCSttNd->IsTxtNode() )
1126 : ? ((SwTxtNode*)pCSttNd)->GetTxtColl()
1127 0 : : (pCEndNd && pCEndNd->IsTxtNode() )
1128 : ? ((SwTxtNode*)pCEndNd)->GetTxtColl()
1129 0 : : pDoc->getIDocumentStylePoolAccess().GetTxtCollFromPool(
1130 0 : RES_POOLCOLL_STANDARD );
1131 :
1132 0 : pSttNd = rNds.MakeTextSection( SwNodeIndex( rNds.GetEndOfRedlines() ),
1133 0 : SwNormalStartNode, pColl );
1134 0 : SwTxtNode* pTxtNd = rNds[ pSttNd->GetIndex() + 1 ]->GetTxtNode();
1135 :
1136 0 : SwNodeIndex aNdIdx( *pTxtNd );
1137 0 : SwPosition aPos( aNdIdx, SwIndex( pTxtNd ));
1138 0 : if( pCSttNd && pCEndNd )
1139 0 : pDoc->getIDocumentContentOperations().MoveAndJoin( aPam, aPos, IDocumentContentOperations::DOC_MOVEDEFAULT );
1140 : else
1141 : {
1142 0 : if( pCSttNd && !pCEndNd )
1143 0 : bDelLastPara = true;
1144 0 : pDoc->getIDocumentContentOperations().MoveRange( aPam, aPos,
1145 0 : IDocumentContentOperations::DOC_MOVEDEFAULT );
1146 0 : }
1147 : }
1148 : else
1149 : {
1150 0 : pSttNd = rNds.MakeEmptySection( SwNodeIndex( rNds.GetEndOfRedlines() ),
1151 0 : SwNormalStartNode );
1152 :
1153 0 : SwPosition aPos( *pSttNd->EndOfSectionNode() );
1154 0 : pDoc->getIDocumentContentOperations().MoveRange( aPam, aPos,
1155 0 : IDocumentContentOperations::DOC_MOVEDEFAULT );
1156 : }
1157 0 : pCntntSect = new SwNodeIndex( *pSttNd );
1158 :
1159 0 : if( pStt == GetPoint() )
1160 0 : Exchange();
1161 :
1162 0 : DeleteMark();
1163 : }
1164 : else
1165 0 : InvalidateRange();
1166 0 : }
1167 :
1168 2 : void SwRangeRedline::CopyToSection()
1169 : {
1170 2 : if( !pCntntSect )
1171 : {
1172 2 : const SwPosition* pStt = Start(),
1173 2 : * pEnd = pStt == GetPoint() ? GetMark() : GetPoint();
1174 :
1175 2 : SwCntntNode* pCSttNd = pStt->nNode.GetNode().GetCntntNode();
1176 2 : SwCntntNode* pCEndNd = pEnd->nNode.GetNode().GetCntntNode();
1177 :
1178 : SwStartNode* pSttNd;
1179 2 : SwDoc* pDoc = GetDoc();
1180 2 : SwNodes& rNds = pDoc->GetNodes();
1181 :
1182 2 : bool bSaveCopyFlag = pDoc->IsCopyIsMove(),
1183 2 : bSaveRdlMoveFlg = pDoc->getIDocumentRedlineAccess().IsRedlineMove();
1184 2 : pDoc->SetCopyIsMove( true );
1185 :
1186 : // The IsRedlineMove() flag causes the behaviour of the
1187 : // SwDoc::_CopyFlyInFly method to change, which will eventually be
1188 : // called by the pDoc->Copy line below (through SwDoc::_Copy,
1189 : // SwDoc::CopyWithFlyInFly). This rather obscure bugfix
1190 : // apparently never really worked.
1191 2 : pDoc->getIDocumentRedlineAccess().SetRedlineMove( pStt->nContent == 0 );
1192 :
1193 2 : if( pCSttNd )
1194 : {
1195 2 : SwTxtFmtColl* pColl = (pCSttNd && pCSttNd->IsTxtNode() )
1196 : ? ((SwTxtNode*)pCSttNd)->GetTxtColl()
1197 0 : : pDoc->getIDocumentStylePoolAccess().GetTxtCollFromPool(
1198 4 : RES_POOLCOLL_STANDARD );
1199 :
1200 2 : pSttNd = rNds.MakeTextSection( SwNodeIndex( rNds.GetEndOfRedlines() ),
1201 2 : SwNormalStartNode, pColl );
1202 :
1203 2 : SwNodeIndex aNdIdx( *pSttNd, 1 );
1204 2 : SwTxtNode* pTxtNd = aNdIdx.GetNode().GetTxtNode();
1205 4 : SwPosition aPos( aNdIdx, SwIndex( pTxtNd ));
1206 2 : pDoc->getIDocumentContentOperations().CopyRange( *this, aPos, false );
1207 :
1208 : // Take over the style from the EndNode if needed
1209 : // We don't want this in Doc::Copy
1210 2 : if( pCEndNd && pCEndNd != pCSttNd )
1211 : {
1212 0 : SwCntntNode* pDestNd = aPos.nNode.GetNode().GetCntntNode();
1213 0 : if( pDestNd )
1214 : {
1215 0 : if( pDestNd->IsTxtNode() && pCEndNd->IsTxtNode() )
1216 : ((SwTxtNode*)pCEndNd)->CopyCollFmt(
1217 0 : *(SwTxtNode*)pDestNd );
1218 : else
1219 0 : pDestNd->ChgFmtColl( pCEndNd->GetFmtColl() );
1220 : }
1221 2 : }
1222 : }
1223 : else
1224 : {
1225 0 : pSttNd = rNds.MakeEmptySection( SwNodeIndex( rNds.GetEndOfRedlines() ),
1226 0 : SwNormalStartNode );
1227 :
1228 0 : if( pCEndNd )
1229 : {
1230 0 : SwPosition aPos( *pSttNd->EndOfSectionNode() );
1231 0 : pDoc->getIDocumentContentOperations().CopyRange( *this, aPos, false );
1232 : }
1233 : else
1234 : {
1235 0 : SwNodeIndex aInsPos( *pSttNd->EndOfSectionNode() );
1236 0 : SwNodeRange aRg( pStt->nNode, 0, pEnd->nNode, 1 );
1237 0 : pDoc->GetDocumentContentOperationsManager().CopyWithFlyInFly( aRg, 0, aInsPos );
1238 : }
1239 : }
1240 2 : pCntntSect = new SwNodeIndex( *pSttNd );
1241 :
1242 2 : pDoc->SetCopyIsMove( bSaveCopyFlag );
1243 2 : pDoc->getIDocumentRedlineAccess().SetRedlineMove( bSaveRdlMoveFlg );
1244 : }
1245 2 : }
1246 :
1247 2 : void SwRangeRedline::DelCopyOfSection()
1248 : {
1249 2 : if( pCntntSect )
1250 : {
1251 2 : const SwPosition* pStt = Start(),
1252 2 : * pEnd = pStt == GetPoint() ? GetMark() : GetPoint();
1253 :
1254 2 : SwDoc* pDoc = GetDoc();
1255 2 : SwPaM aPam( *pStt, *pEnd );
1256 2 : SwCntntNode* pCSttNd = pStt->nNode.GetNode().GetCntntNode();
1257 2 : SwCntntNode* pCEndNd = pEnd->nNode.GetNode().GetCntntNode();
1258 :
1259 2 : if( !pCSttNd )
1260 : {
1261 : // In order to not move other Redlines' indices, we set them
1262 : // to the end (is exclusive)
1263 0 : const SwRedlineTbl& rTbl = pDoc->getIDocumentRedlineAccess().GetRedlineTbl();
1264 0 : for( sal_uInt16 n = 0; n < rTbl.size(); ++n )
1265 : {
1266 0 : SwRangeRedline* pRedl = rTbl[ n ];
1267 0 : if( pRedl->GetBound(true) == *pStt )
1268 0 : pRedl->GetBound(true) = *pEnd;
1269 0 : if( pRedl->GetBound(false) == *pStt )
1270 0 : pRedl->GetBound(false) = *pEnd;
1271 : }
1272 : }
1273 :
1274 2 : if( pCSttNd && pCEndNd )
1275 : {
1276 : // #i100466# - force a <join next> on <delete and join> operation
1277 2 : pDoc->getIDocumentContentOperations().DeleteAndJoin( aPam, true );
1278 : }
1279 0 : else if( pCSttNd || pCEndNd )
1280 : {
1281 0 : if( pCSttNd && !pCEndNd )
1282 0 : bDelLastPara = true;
1283 0 : pDoc->getIDocumentContentOperations().DeleteRange( aPam );
1284 :
1285 0 : if( bDelLastPara )
1286 : {
1287 : // To prevent dangling references to the paragraph to
1288 : // be deleted, redline that point into this paragraph should be
1289 : // moved to the new end position. Since redlines in the redline
1290 : // table are sorted and the pEnd position is an endnode (see
1291 : // bDelLastPara condition above), only redlines before the
1292 : // current ones can be affected.
1293 0 : const SwRedlineTbl& rTbl = pDoc->getIDocumentRedlineAccess().GetRedlineTbl();
1294 0 : sal_uInt16 n = rTbl.GetPos( this );
1295 : OSL_ENSURE( n != USHRT_MAX, "How strange. We don't exist!" );
1296 0 : for( bool bBreak = false; !bBreak && n > 0; )
1297 : {
1298 0 : --n;
1299 0 : bBreak = true;
1300 0 : if( rTbl[ n ]->GetBound(true) == *aPam.GetPoint() )
1301 : {
1302 0 : rTbl[ n ]->GetBound(true) = *pEnd;
1303 0 : bBreak = false;
1304 : }
1305 0 : if( rTbl[ n ]->GetBound(false) == *aPam.GetPoint() )
1306 : {
1307 0 : rTbl[ n ]->GetBound(false) = *pEnd;
1308 0 : bBreak = false;
1309 : }
1310 : }
1311 :
1312 0 : SwPosition aEnd( *pEnd );
1313 0 : *GetPoint() = *pEnd;
1314 0 : *GetMark() = *pEnd;
1315 0 : DeleteMark();
1316 :
1317 0 : aPam.GetBound( true ).nContent.Assign( 0, 0 );
1318 0 : aPam.GetBound( false ).nContent.Assign( 0, 0 );
1319 0 : aPam.DeleteMark();
1320 0 : pDoc->getIDocumentContentOperations().DelFullPara( aPam );
1321 0 : }
1322 : }
1323 : else
1324 : {
1325 0 : pDoc->getIDocumentContentOperations().DeleteRange( aPam );
1326 : }
1327 :
1328 2 : if( pStt == GetPoint() )
1329 2 : Exchange();
1330 :
1331 2 : DeleteMark();
1332 : }
1333 2 : }
1334 :
1335 40 : void SwRangeRedline::MoveFromSection()
1336 : {
1337 40 : if( pCntntSect )
1338 : {
1339 12 : SwDoc* pDoc = GetDoc();
1340 12 : const SwRedlineTbl& rTbl = pDoc->getIDocumentRedlineAccess().GetRedlineTbl();
1341 24 : std::vector<SwPosition*> aBeforeArr, aBehindArr;
1342 12 : sal_uInt16 nMyPos = rTbl.GetPos( this );
1343 : OSL_ENSURE( this, "this is not in the array?" );
1344 12 : bool bBreak = false;
1345 : sal_uInt16 n;
1346 :
1347 18 : for( n = nMyPos+1; !bBreak && n < rTbl.size(); ++n )
1348 : {
1349 6 : bBreak = true;
1350 6 : if( rTbl[ n ]->GetBound(true) == *GetPoint() )
1351 : {
1352 2 : aBehindArr.push_back( &rTbl[ n ]->GetBound(true) );
1353 2 : bBreak = false;
1354 : }
1355 6 : if( rTbl[ n ]->GetBound(false) == *GetPoint() )
1356 : {
1357 2 : aBehindArr.push_back( &rTbl[ n ]->GetBound(false) );
1358 2 : bBreak = false;
1359 : }
1360 : }
1361 26 : for( bBreak = false, n = nMyPos; !bBreak && n ; )
1362 : {
1363 2 : --n;
1364 2 : bBreak = true;
1365 2 : if( rTbl[ n ]->GetBound(true) == *GetPoint() )
1366 : {
1367 2 : aBeforeArr.push_back( &rTbl[ n ]->GetBound(true) );
1368 2 : bBreak = false;
1369 : }
1370 2 : if( rTbl[ n ]->GetBound(false) == *GetPoint() )
1371 : {
1372 0 : aBeforeArr.push_back( &rTbl[ n ]->GetBound(false) );
1373 0 : bBreak = false;
1374 : }
1375 : }
1376 :
1377 12 : const SwNode* pKeptCntntSectNode( &pCntntSect->GetNode() ); // #i95711#
1378 : {
1379 12 : SwPaM aPam( pCntntSect->GetNode(),
1380 12 : *pCntntSect->GetNode().EndOfSectionNode(), 1,
1381 36 : ( bDelLastPara ? -2 : -1 ) );
1382 12 : SwCntntNode* pCNd = aPam.GetCntntNode();
1383 12 : if( pCNd )
1384 12 : aPam.GetPoint()->nContent.Assign( pCNd, pCNd->Len() );
1385 : else
1386 0 : aPam.GetPoint()->nNode++;
1387 :
1388 20 : SwFmtColl* pColl = pCNd && pCNd->Len() && aPam.GetPoint()->nNode !=
1389 8 : aPam.GetMark()->nNode
1390 14 : ? pCNd->GetFmtColl() : 0;
1391 :
1392 24 : SwNodeIndex aNdIdx( GetPoint()->nNode, -1 );
1393 12 : const sal_Int32 nPos = GetPoint()->nContent.GetIndex();
1394 :
1395 24 : SwPosition aPos( *GetPoint() );
1396 12 : if( bDelLastPara && *aPam.GetPoint() == *aPam.GetMark() )
1397 : {
1398 0 : aPos.nNode--;
1399 :
1400 0 : pDoc->getIDocumentContentOperations().AppendTxtNode( aPos );
1401 : }
1402 : else
1403 : {
1404 12 : pDoc->getIDocumentContentOperations().MoveRange( aPam, aPos,
1405 12 : IDocumentContentOperations::DOC_MOVEALLFLYS );
1406 : }
1407 :
1408 12 : SetMark();
1409 12 : *GetPoint() = aPos;
1410 12 : GetMark()->nNode = aNdIdx.GetIndex() + 1;
1411 12 : pCNd = GetMark()->nNode.GetNode().GetCntntNode();
1412 12 : GetMark()->nContent.Assign( pCNd, nPos );
1413 :
1414 12 : if( bDelLastPara )
1415 : {
1416 0 : GetPoint()->nNode++;
1417 0 : GetPoint()->nContent.Assign( pCNd = GetCntntNode(), 0 );
1418 0 : bDelLastPara = false;
1419 : }
1420 12 : else if( pColl )
1421 2 : pCNd = GetCntntNode();
1422 :
1423 12 : if( pColl && pCNd )
1424 14 : pCNd->ChgFmtColl( pColl );
1425 : }
1426 : // #i95771#
1427 : // Under certain conditions the previous <SwDoc::Move(..)> has already
1428 : // removed the change tracking section of this <SwRangeRedline> instance from
1429 : // the change tracking nodes area.
1430 : // Thus, check if <pCntntSect> still points to the change tracking section
1431 : // by comparing it with the "indexed" <SwNode> instance copied before
1432 : // perform the intrinsic move.
1433 : // Note: Such condition is e.g. a "delete" change tracking only containing a table.
1434 12 : if ( &pCntntSect->GetNode() == pKeptCntntSectNode )
1435 : {
1436 12 : pDoc->getIDocumentContentOperations().DeleteSection( &pCntntSect->GetNode() );
1437 : }
1438 12 : delete pCntntSect, pCntntSect = 0;
1439 :
1440 : // adjustment of redline table positions must take start and
1441 : // end into account, not point and mark.
1442 14 : for( n = 0; n < aBeforeArr.size(); ++n )
1443 2 : *aBeforeArr[ n ] = *Start();
1444 16 : for( n = 0; n < aBehindArr.size(); ++n )
1445 16 : *aBehindArr[ n ] = *End();
1446 : }
1447 : else
1448 28 : InvalidateRange();
1449 40 : }
1450 :
1451 : // for Undo
1452 12 : void SwRangeRedline::SetContentIdx( const SwNodeIndex* pIdx )
1453 : {
1454 12 : if( pIdx && !pCntntSect )
1455 : {
1456 12 : pCntntSect = new SwNodeIndex( *pIdx );
1457 12 : bIsVisible = false;
1458 : }
1459 0 : else if( !pIdx && pCntntSect )
1460 : {
1461 0 : delete pCntntSect, pCntntSect = 0;
1462 0 : bIsVisible = false;
1463 : }
1464 : else
1465 : {
1466 : OSL_FAIL("SwRangeRedline::SetContentIdx: invalid state");
1467 : }
1468 12 : }
1469 :
1470 5662 : bool SwRangeRedline::CanCombine( const SwRangeRedline& rRedl ) const
1471 : {
1472 11280 : return IsVisible() && rRedl.IsVisible() &&
1473 11280 : pRedlineData->CanCombine( *rRedl.pRedlineData );
1474 : }
1475 :
1476 4 : void SwRangeRedline::PushData( const SwRangeRedline& rRedl, bool bOwnAsNext )
1477 : {
1478 4 : SwRedlineData* pNew = new SwRedlineData( *rRedl.pRedlineData, false );
1479 4 : if( bOwnAsNext )
1480 : {
1481 4 : pNew->pNext = pRedlineData;
1482 4 : pRedlineData = pNew;
1483 : }
1484 : else
1485 : {
1486 0 : pNew->pNext = pRedlineData->pNext;
1487 0 : pRedlineData->pNext = pNew;
1488 : }
1489 4 : }
1490 :
1491 0 : bool SwRangeRedline::PopData()
1492 : {
1493 0 : if( !pRedlineData->pNext )
1494 0 : return false;
1495 0 : SwRedlineData* pCur = pRedlineData;
1496 0 : pRedlineData = pCur->pNext;
1497 0 : pCur->pNext = 0;
1498 0 : delete pCur;
1499 0 : return true;
1500 : }
1501 :
1502 5392 : sal_uInt16 SwRangeRedline::GetStackCount() const
1503 : {
1504 5392 : sal_uInt16 nRet = 1;
1505 5430 : for( SwRedlineData* pCur = pRedlineData; pCur->pNext; ++nRet )
1506 38 : pCur = pCur->pNext;
1507 5392 : return nRet;
1508 : }
1509 :
1510 49042 : sal_uInt16 SwRangeRedline::GetAuthor( sal_uInt16 nPos ) const
1511 : {
1512 49042 : return GetRedlineData(nPos).nAuthor;
1513 : }
1514 :
1515 16 : OUString SwRangeRedline::GetAuthorString( sal_uInt16 nPos ) const
1516 : {
1517 16 : return SW_MOD()->GetRedlineAuthor(GetRedlineData(nPos).nAuthor);
1518 : }
1519 :
1520 10 : const DateTime& SwRangeRedline::GetTimeStamp( sal_uInt16 nPos ) const
1521 : {
1522 10 : return GetRedlineData(nPos).aStamp;
1523 : }
1524 :
1525 333803 : RedlineType_t SwRangeRedline::GetRealType( sal_uInt16 nPos ) const
1526 : {
1527 333803 : return GetRedlineData(nPos).eType;
1528 : }
1529 :
1530 4 : const OUString& SwRangeRedline::GetComment( sal_uInt16 nPos ) const
1531 : {
1532 4 : return GetRedlineData(nPos).sComment;
1533 : }
1534 :
1535 0 : bool SwRangeRedline::operator==( const SwRangeRedline& rCmp ) const
1536 : {
1537 0 : return this == &rCmp;
1538 : }
1539 :
1540 21464 : bool SwRangeRedline::operator<( const SwRangeRedline& rCmp ) const
1541 : {
1542 21464 : bool nResult = false;
1543 :
1544 21464 : if (*Start() < *rCmp.Start())
1545 19008 : nResult = true;
1546 2456 : else if (*Start() == *rCmp.Start())
1547 2158 : if (*End() < *rCmp.End())
1548 6 : nResult = true;
1549 :
1550 21464 : return nResult;
1551 : }
1552 :
1553 384167 : const SwRedlineData & SwRangeRedline::GetRedlineData(sal_uInt16 nPos) const
1554 : {
1555 384167 : SwRedlineData * pCur = pRedlineData;
1556 :
1557 768410 : while (nPos > 0 && NULL != pCur->pNext)
1558 : {
1559 76 : pCur = pCur->pNext;
1560 :
1561 76 : nPos--;
1562 : }
1563 :
1564 : OSL_ENSURE( 0 == nPos, "Pos is too big" );
1565 :
1566 384167 : return *pCur;
1567 : }
1568 :
1569 0 : OUString SwRangeRedline::GetDescr(sal_uInt16 nPos)
1570 : {
1571 0 : OUString aResult;
1572 :
1573 : // get description of redline data (e.g.: "insert $1")
1574 0 : aResult = GetRedlineData(nPos).GetDescr();
1575 :
1576 0 : SwPaM * pPaM = NULL;
1577 0 : bool bDeletePaM = false;
1578 :
1579 : // if this redline is visible the content is in this PaM
1580 0 : if (NULL == pCntntSect)
1581 : {
1582 0 : pPaM = this;
1583 : }
1584 : else // otherwise it is saved in pCntntSect
1585 : {
1586 0 : SwNodeIndex aTmpIdx( *pCntntSect->GetNode().EndOfSectionNode() );
1587 0 : pPaM = new SwPaM(*pCntntSect, aTmpIdx );
1588 0 : bDeletePaM = true;
1589 : }
1590 :
1591 : // replace $1 in description by description of the redlines text
1592 0 : OUString aTmpStr;
1593 0 : aTmpStr += SW_RES(STR_START_QUOTE);
1594 0 : aTmpStr += ShortenString(pPaM->GetTxt(), nUndoStringLength,
1595 0 : OUString(SW_RES(STR_LDOTS)));
1596 0 : aTmpStr += SW_RES(STR_END_QUOTE);
1597 :
1598 0 : SwRewriter aRewriter;
1599 0 : aRewriter.AddRule(UndoArg1, aTmpStr);
1600 :
1601 0 : aResult = aRewriter.Apply(aResult);
1602 :
1603 0 : if (bDeletePaM)
1604 0 : delete pPaM;
1605 :
1606 0 : return aResult;
1607 : }
1608 :
1609 68 : bool SwExtraRedlineTbl::Insert( SwExtraRedline* p )
1610 : {
1611 68 : m_aExtraRedlines.push_back( p );
1612 : //p->CallDisplayFunc();
1613 68 : return true;
1614 : }
1615 :
1616 10128 : void SwExtraRedlineTbl::DeleteAndDestroy( sal_uInt16 nPos, sal_uInt16 nLen )
1617 : {
1618 : /*
1619 : SwDoc* pDoc = 0;
1620 : if( !nP && nL && nL == size() )
1621 : pDoc = front()->GetDoc();
1622 : */
1623 :
1624 10196 : for( std::vector<SwExtraRedline*>::iterator it = m_aExtraRedlines.begin() + nPos; it != m_aExtraRedlines.begin() + nPos + nLen; ++it )
1625 68 : delete *it;
1626 :
1627 10128 : m_aExtraRedlines.erase( m_aExtraRedlines.begin() + nPos, m_aExtraRedlines.begin() + nPos + nLen );
1628 :
1629 : /*
1630 : SwViewShell* pSh;
1631 : if( pDoc && !pDoc->IsInDtor() &&
1632 : 0 != ( pSh = pDoc->getIDocumentLayoutAccess().GetCurrentViewShell() ) )
1633 : pSh->InvalidateWindows( SwRect( 0, 0, LONG_MAX, LONG_MAX ) );
1634 : */
1635 10128 : }
1636 :
1637 10128 : void SwExtraRedlineTbl::DeleteAndDestroyAll()
1638 : {
1639 10128 : DeleteAndDestroy(0, m_aExtraRedlines.size());
1640 10128 : }
1641 :
1642 68 : SwExtraRedline::~SwExtraRedline()
1643 : {
1644 68 : }
1645 :
1646 56 : SwTableRowRedline::SwTableRowRedline(const SwRedlineData& rData, const SwTableLine& rTableLine)
1647 : : m_aRedlineData(rData)
1648 56 : , m_rTableLine(rTableLine)
1649 : {
1650 56 : }
1651 :
1652 112 : SwTableRowRedline::~SwTableRowRedline()
1653 : {
1654 112 : }
1655 :
1656 12 : SwTableCellRedline::SwTableCellRedline(const SwRedlineData& rData, const SwTableBox& rTableBox)
1657 : : m_aRedlineData(rData)
1658 12 : , m_rTableBox(rTableBox)
1659 : {
1660 12 : }
1661 :
1662 24 : SwTableCellRedline::~SwTableCellRedline()
1663 : {
1664 294 : }
1665 :
1666 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
1667 :
|
