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