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 <textdoc.hxx>
21 :
22 : #include <stdlib.h>
23 :
24 :
25 :
26 : // Vergleichmethode wird von QuickSort gerufen...
27 :
28 0 : static bool CompareStart( const TextCharAttrib* pFirst, const TextCharAttrib* pSecond )
29 : {
30 0 : return pFirst->GetStart() < pSecond->GetStart();
31 : }
32 :
33 : // -------------------------------------------------------------------------
34 : // (+) class TextCharAttrib
35 : // -------------------------------------------------------------------------
36 0 : TextCharAttrib::TextCharAttrib( const TextAttrib& rAttr, sal_uInt16 nStart, sal_uInt16 nEnd )
37 : {
38 0 : mpAttr = rAttr.Clone();
39 : mnStart = nStart,
40 0 : mnEnd = nEnd;
41 0 : }
42 :
43 0 : TextCharAttrib::TextCharAttrib( const TextCharAttrib& rTextCharAttrib )
44 : {
45 0 : mpAttr = rTextCharAttrib.GetAttr().Clone();
46 0 : mnStart = rTextCharAttrib.mnStart;
47 0 : mnEnd = rTextCharAttrib.mnEnd;
48 0 : }
49 :
50 0 : TextCharAttrib::~TextCharAttrib()
51 : {
52 0 : delete mpAttr;
53 0 : }
54 :
55 : // -------------------------------------------------------------------------
56 : // (+) class TextCharAttribList
57 : // -------------------------------------------------------------------------
58 :
59 0 : TextCharAttribList::TextCharAttribList()
60 : {
61 0 : mbHasEmptyAttribs = sal_False;
62 0 : }
63 :
64 0 : TextCharAttribList::~TextCharAttribList()
65 : {
66 : // PTRARR_DEL
67 0 : }
68 :
69 0 : void TextCharAttribList::Clear( sal_Bool bDestroyAttribs )
70 : {
71 0 : if ( bDestroyAttribs )
72 0 : for(iterator it = begin(); it != end(); ++it)
73 0 : delete *it;
74 0 : TextCharAttribs::clear();
75 0 : }
76 :
77 :
78 0 : void TextCharAttribList::InsertAttrib( TextCharAttrib* pAttrib )
79 : {
80 0 : if ( pAttrib->IsEmpty() )
81 0 : mbHasEmptyAttribs = sal_True;
82 :
83 0 : const sal_uInt16 nCount = size();
84 0 : const sal_uInt16 nStart = pAttrib->GetStart(); // vielleicht besser fuer Comp.Opt.
85 0 : sal_Bool bInserted = sal_False;
86 0 : for ( sal_uInt16 x = 0; x < nCount; x++ )
87 : {
88 0 : TextCharAttrib* pCurAttrib = GetAttrib( x );
89 0 : if ( pCurAttrib->GetStart() > nStart )
90 : {
91 0 : insert( begin() + x, pAttrib );
92 0 : bInserted = sal_True;
93 0 : break;
94 : }
95 : }
96 0 : if ( !bInserted )
97 0 : push_back( pAttrib );
98 0 : }
99 :
100 0 : void TextCharAttribList::ResortAttribs()
101 : {
102 0 : if ( !empty() )
103 0 : std::sort( begin(), end(), CompareStart );
104 0 : }
105 :
106 0 : TextCharAttrib* TextCharAttribList::FindAttrib( sal_uInt16 nWhich, sal_uInt16 nPos )
107 : {
108 : // Rueckwaerts, falls eins dort endet, das naechste startet.
109 : // => Das startende gilt...
110 :
111 0 : for ( sal_uInt16 nAttr = size(); nAttr; )
112 : {
113 0 : TextCharAttrib* pAttr = GetAttrib( --nAttr );
114 :
115 0 : if ( pAttr->GetEnd() < nPos )
116 0 : return 0;
117 :
118 0 : if ( ( pAttr->Which() == nWhich ) && pAttr->IsIn(nPos) )
119 0 : return pAttr;
120 : }
121 0 : return NULL;
122 : }
123 :
124 0 : TextCharAttrib* TextCharAttribList::FindNextAttrib( sal_uInt16 nWhich, sal_uInt16 nFromPos, sal_uInt16 nMaxPos ) const
125 : {
126 : DBG_ASSERT( nWhich, "FindNextAttrib: Which?" );
127 0 : const sal_uInt16 nAttribs = size();
128 0 : for ( sal_uInt16 nAttr = 0; nAttr < nAttribs; nAttr++ )
129 : {
130 0 : TextCharAttrib* pAttr = GetAttrib( nAttr );
131 0 : if ( ( pAttr->GetStart() >= nFromPos ) &&
132 0 : ( pAttr->GetEnd() <= nMaxPos ) &&
133 0 : ( pAttr->Which() == nWhich ) )
134 0 : return pAttr;
135 : }
136 0 : return NULL;
137 : }
138 :
139 0 : sal_Bool TextCharAttribList::HasAttrib( sal_uInt16 nWhich ) const
140 : {
141 0 : for ( sal_uInt16 nAttr = size(); nAttr; )
142 : {
143 0 : const TextCharAttrib* pAttr = GetAttrib( --nAttr );
144 0 : if ( pAttr->Which() == nWhich )
145 0 : return sal_True;
146 : }
147 0 : return sal_False;
148 : }
149 :
150 0 : sal_Bool TextCharAttribList::HasBoundingAttrib( sal_uInt16 nBound )
151 : {
152 : // Rueckwaerts, falls eins dort endet, das naechste startet.
153 : // => Das startende gilt...
154 0 : for ( sal_uInt16 nAttr = size(); nAttr; )
155 : {
156 0 : TextCharAttrib* pAttr = GetAttrib( --nAttr );
157 :
158 0 : if ( pAttr->GetEnd() < nBound )
159 0 : return sal_False;
160 :
161 0 : if ( ( pAttr->GetStart() == nBound ) || ( pAttr->GetEnd() == nBound ) )
162 0 : return sal_True;
163 : }
164 0 : return sal_False;
165 : }
166 :
167 0 : TextCharAttrib* TextCharAttribList::FindEmptyAttrib( sal_uInt16 nWhich, sal_uInt16 nPos )
168 : {
169 0 : if ( !mbHasEmptyAttribs )
170 0 : return 0;
171 :
172 0 : const sal_uInt16 nAttribs = size();
173 0 : for ( sal_uInt16 nAttr = 0; nAttr < nAttribs; nAttr++ )
174 : {
175 0 : TextCharAttrib* pAttr = GetAttrib( nAttr );
176 0 : if ( pAttr->GetStart() > nPos )
177 0 : return 0;
178 :
179 0 : if ( ( pAttr->GetStart() == nPos ) && ( pAttr->GetEnd() == nPos ) && ( pAttr->Which() == nWhich ) )
180 0 : return pAttr;
181 : }
182 0 : return 0;
183 : }
184 :
185 0 : void TextCharAttribList::DeleteEmptyAttribs()
186 : {
187 0 : for ( sal_uInt16 nAttr = 0; nAttr < size(); nAttr++ )
188 : {
189 0 : TextCharAttrib* pAttr = GetAttrib( nAttr );
190 0 : if ( pAttr->IsEmpty() )
191 : {
192 0 : erase( begin() + nAttr );
193 0 : delete pAttr;
194 0 : nAttr--;
195 : }
196 : }
197 0 : mbHasEmptyAttribs = sal_False;
198 0 : }
199 :
200 : // -------------------------------------------------------------------------
201 : // (+) class TextNode
202 : // -------------------------------------------------------------------------
203 :
204 0 : TextNode::TextNode( const String& rText ) :
205 0 : maText( rText )
206 : {
207 0 : }
208 :
209 0 : void TextNode::ExpandAttribs( sal_uInt16 nIndex, sal_uInt16 nNew )
210 : {
211 0 : if ( !nNew )
212 0 : return;
213 :
214 0 : sal_Bool bResort = sal_False;
215 0 : sal_uInt16 nAttribs = maCharAttribs.Count();
216 0 : for ( sal_uInt16 nAttr = 0; nAttr < nAttribs; nAttr++ )
217 : {
218 0 : TextCharAttrib* pAttrib = maCharAttribs.GetAttrib( nAttr );
219 0 : if ( pAttrib->GetEnd() >= nIndex )
220 : {
221 : // Alle Attribute hinter der Einfuegeposition verschieben...
222 0 : if ( pAttrib->GetStart() > nIndex )
223 : {
224 0 : pAttrib->MoveForward( nNew );
225 : }
226 : // 0: Leeres Attribut expandieren, wenn an Einfuegestelle
227 0 : else if ( pAttrib->IsEmpty() )
228 : {
229 : // Index nicht pruefen, leeres durfte nur dort liegen.
230 : // Wenn spaeter doch Ueberpruefung:
231 : // Spezialfall: Start == 0; AbsLen == 1, nNew = 1 => Expand, weil durch Absatzumbruch!
232 : // Start <= nIndex, End >= nIndex => Start=End=nIndex!
233 : // if ( pAttrib->GetStart() == nIndex )
234 0 : pAttrib->Expand( nNew );
235 : }
236 : // 1: Attribut startet davor, geht bis Index...
237 0 : else if ( pAttrib->GetEnd() == nIndex ) // Start muss davor liegen
238 : {
239 : // Nur expandieren, wenn kein Feature,
240 : // und wenn nicht in ExcludeListe!
241 : // Sonst geht z.B. ein UL bis zum neuen ULDB, beide expandieren
242 0 : if ( !maCharAttribs.FindEmptyAttrib( pAttrib->Which(), nIndex ) )
243 : {
244 0 : pAttrib->Expand( nNew );
245 : }
246 : else
247 0 : bResort = sal_True;
248 : }
249 : // 2: Attribut startet davor, geht hinter Index...
250 0 : else if ( ( pAttrib->GetStart() < nIndex ) && ( pAttrib->GetEnd() > nIndex ) )
251 : {
252 0 : pAttrib->Expand( nNew );
253 : }
254 : // 3: Attribut startet auf Index...
255 0 : else if ( pAttrib->GetStart() == nIndex )
256 : {
257 0 : if ( nIndex == 0 )
258 : {
259 0 : pAttrib->Expand( nNew );
260 : // bResort = sal_True; // es gibt ja keine Features mehr...
261 : }
262 : else
263 0 : pAttrib->MoveForward( nNew );
264 : }
265 : }
266 :
267 : DBG_ASSERT( pAttrib->GetStart() <= pAttrib->GetEnd(), "Expand: Attribut verdreht!" );
268 : DBG_ASSERT( ( pAttrib->GetEnd() <= maText.Len() ), "Expand: Attrib groesser als Absatz!" );
269 : DBG_ASSERT( !pAttrib->IsEmpty(), "Leeres Attribut nach ExpandAttribs?" );
270 : }
271 :
272 0 : if ( bResort )
273 0 : maCharAttribs.ResortAttribs();
274 : }
275 :
276 0 : void TextNode::CollapsAttribs( sal_uInt16 nIndex, sal_uInt16 nDeleted )
277 : {
278 0 : if ( !nDeleted )
279 0 : return;
280 :
281 0 : sal_Bool bResort = sal_False;
282 0 : sal_uInt16 nEndChanges = nIndex+nDeleted;
283 :
284 0 : for ( sal_uInt16 nAttr = 0; nAttr < maCharAttribs.Count(); nAttr++ )
285 : {
286 0 : TextCharAttrib* pAttrib = maCharAttribs.GetAttrib( nAttr );
287 0 : sal_Bool bDelAttr = sal_False;
288 0 : if ( pAttrib->GetEnd() >= nIndex )
289 : {
290 : // Alles Attribute hinter der Einfuegeposition verschieben...
291 0 : if ( pAttrib->GetStart() >= nEndChanges )
292 : {
293 0 : pAttrib->MoveBackward( nDeleted );
294 : }
295 : // 1. Innenliegende Attribute loeschen...
296 0 : else if ( ( pAttrib->GetStart() >= nIndex ) && ( pAttrib->GetEnd() <= nEndChanges ) )
297 : {
298 : // Spezialfall: Attrubt deckt genau den Bereich ab
299 : // => als leeres Attribut behalten.
300 0 : if ( ( pAttrib->GetStart() == nIndex ) && ( pAttrib->GetEnd() == nEndChanges ) )
301 0 : pAttrib->GetEnd() = nIndex; // leer
302 : else
303 0 : bDelAttr = sal_True;
304 : }
305 : // 2. Attribut beginnt davor, endet drinnen oder dahinter...
306 0 : else if ( ( pAttrib->GetStart() <= nIndex ) && ( pAttrib->GetEnd() > nIndex ) )
307 : {
308 0 : if ( pAttrib->GetEnd() <= nEndChanges ) // endet drinnen
309 0 : pAttrib->GetEnd() = nIndex;
310 : else
311 0 : pAttrib->Collaps( nDeleted ); // endet dahinter
312 : }
313 : // 3. Attribut beginnt drinnen, endet dahinter...
314 0 : else if ( ( pAttrib->GetStart() >= nIndex ) && ( pAttrib->GetEnd() > nEndChanges ) )
315 : {
316 : // Features duerfen nicht expandieren!
317 0 : pAttrib->GetStart() = nEndChanges;
318 0 : pAttrib->MoveBackward( nDeleted );
319 : }
320 : }
321 :
322 : DBG_ASSERT( pAttrib->GetStart() <= pAttrib->GetEnd(), "Collaps: Attribut verdreht!" );
323 : DBG_ASSERT( ( pAttrib->GetEnd() <= maText.Len()) || bDelAttr, "Collaps: Attrib groesser als Absatz!" );
324 0 : if ( bDelAttr /* || pAttrib->IsEmpty() */ )
325 : {
326 0 : bResort = sal_True;
327 0 : maCharAttribs.RemoveAttrib( nAttr );
328 0 : delete pAttrib;
329 0 : nAttr--;
330 : }
331 0 : else if ( pAttrib->IsEmpty() )
332 0 : maCharAttribs.HasEmptyAttribs() = sal_True;
333 : }
334 :
335 0 : if ( bResort )
336 0 : maCharAttribs.ResortAttribs();
337 : }
338 :
339 0 : void TextNode::InsertText( sal_uInt16 nPos, const String& rText )
340 : {
341 0 : maText.Insert( rText, nPos );
342 0 : ExpandAttribs( nPos, rText.Len() );
343 0 : }
344 :
345 0 : void TextNode::InsertText( sal_uInt16 nPos, sal_Unicode c )
346 : {
347 0 : maText.Insert( c, nPos );
348 0 : ExpandAttribs( nPos, 1 );
349 0 : }
350 :
351 0 : void TextNode::RemoveText( sal_uInt16 nPos, sal_uInt16 nChars )
352 : {
353 0 : maText.Erase( nPos, nChars );
354 0 : CollapsAttribs( nPos, nChars );
355 0 : }
356 :
357 0 : TextNode* TextNode::Split( sal_uInt16 nPos, sal_Bool bKeepEndingAttribs )
358 : {
359 0 : String aNewText;
360 0 : if ( nPos < maText.Len() )
361 : {
362 0 : aNewText = maText.Copy( nPos );
363 0 : maText.Erase( nPos );
364 : }
365 0 : TextNode* pNew = new TextNode( aNewText );
366 :
367 0 : for ( sal_uInt16 nAttr = 0; nAttr < maCharAttribs.Count(); nAttr++ )
368 : {
369 0 : TextCharAttrib* pAttrib = maCharAttribs.GetAttrib( nAttr );
370 0 : if ( pAttrib->GetEnd() < nPos )
371 : {
372 : // bleiben unveraendert....
373 : ;
374 : }
375 0 : else if ( pAttrib->GetEnd() == nPos )
376 : {
377 : // muessen als leeres Attribut kopiert werden.
378 : // !FindAttrib nur sinnvoll, wenn Rueckwaerts durch Liste!
379 0 : if ( bKeepEndingAttribs && !pNew->maCharAttribs.FindAttrib( pAttrib->Which(), 0 ) )
380 : {
381 0 : TextCharAttrib* pNewAttrib = new TextCharAttrib( *pAttrib );
382 0 : pNewAttrib->GetStart() = 0;
383 0 : pNewAttrib->GetEnd() = 0;
384 0 : pNew->maCharAttribs.InsertAttrib( pNewAttrib );
385 : }
386 : }
387 0 : else if ( pAttrib->IsInside( nPos ) || ( !nPos && !pAttrib->GetStart() ) )
388 : {
389 : // Wenn ganz vorne gecuttet wird, muss das Attribut erhalten bleiben!
390 : // muessen kopiert und geaendert werden
391 0 : TextCharAttrib* pNewAttrib = new TextCharAttrib( *pAttrib );
392 0 : pNewAttrib->GetStart() = 0;
393 0 : pNewAttrib->GetEnd() = pAttrib->GetEnd()-nPos;
394 0 : pNew->maCharAttribs.InsertAttrib( pNewAttrib );
395 : // stutzen:
396 0 : pAttrib->GetEnd() = nPos;
397 : }
398 : else
399 : {
400 : DBG_ASSERT( pAttrib->GetStart() >= nPos, "Start < nPos!" );
401 : DBG_ASSERT( pAttrib->GetEnd() >= nPos, "End < nPos!" );
402 : // alle dahinter verschieben in den neuen Node (this)
403 0 : maCharAttribs.RemoveAttrib( nAttr );
404 0 : pNew->maCharAttribs.InsertAttrib( pAttrib );
405 0 : pAttrib->GetStart() = pAttrib->GetStart() - nPos;
406 0 : pAttrib->GetEnd() = pAttrib->GetEnd() - nPos;
407 0 : nAttr--;
408 : }
409 : }
410 0 : return pNew;
411 : }
412 :
413 0 : void TextNode::Append( const TextNode& rNode )
414 : {
415 0 : sal_uInt16 nOldLen = maText.Len();
416 :
417 0 : maText += rNode.GetText();
418 :
419 0 : const sal_uInt16 nAttribs = rNode.GetCharAttribs().Count();
420 0 : for ( sal_uInt16 nAttr = 0; nAttr < nAttribs; nAttr++ )
421 : {
422 0 : TextCharAttrib* pAttrib = rNode.GetCharAttribs().GetAttrib( nAttr );
423 0 : sal_Bool bMelted = sal_False;
424 0 : if ( pAttrib->GetStart() == 0 )
425 : {
426 : // Evtl koennen Attribute zusammengefasst werden:
427 0 : sal_uInt16 nTmpAttribs = maCharAttribs.Count();
428 0 : for ( sal_uInt16 nTmpAttr = 0; nTmpAttr < nTmpAttribs; nTmpAttr++ )
429 : {
430 0 : TextCharAttrib* pTmpAttrib = maCharAttribs.GetAttrib( nTmpAttr );
431 :
432 0 : if ( pTmpAttrib->GetEnd() == nOldLen )
433 : {
434 0 : if ( ( pTmpAttrib->Which() == pAttrib->Which() ) &&
435 0 : ( pTmpAttrib->GetAttr() == pAttrib->GetAttr() ) )
436 : {
437 0 : pTmpAttrib->GetEnd() =
438 0 : pTmpAttrib->GetEnd() + pAttrib->GetLen();
439 0 : bMelted = sal_True;
440 0 : break; // es kann nur eins von der Sorte an der Stelle geben
441 : }
442 : }
443 : }
444 : }
445 :
446 0 : if ( !bMelted )
447 : {
448 0 : TextCharAttrib* pNewAttrib = new TextCharAttrib( *pAttrib );
449 0 : pNewAttrib->GetStart() = pNewAttrib->GetStart() + nOldLen;
450 0 : pNewAttrib->GetEnd() = pNewAttrib->GetEnd() + nOldLen;
451 0 : maCharAttribs.InsertAttrib( pNewAttrib );
452 : }
453 : }
454 0 : }
455 :
456 : // -------------------------------------------------------------------------
457 : // (+) class TextDoc
458 : // -------------------------------------------------------------------------
459 :
460 0 : TextDoc::TextDoc()
461 : {
462 0 : mnLeftMargin = 0;
463 0 : };
464 :
465 0 : TextDoc::~TextDoc()
466 : {
467 0 : DestroyTextNodes();
468 0 : }
469 :
470 0 : void TextDoc::Clear()
471 : {
472 0 : DestroyTextNodes();
473 0 : }
474 :
475 0 : void TextDoc::DestroyTextNodes()
476 : {
477 0 : for ( sal_uLong nNode = 0; nNode < maTextNodes.Count(); nNode++ )
478 0 : delete maTextNodes.GetObject( nNode );
479 0 : maTextNodes.clear();
480 0 : }
481 :
482 0 : String TextDoc::GetText( const sal_Unicode* pSep ) const
483 : {
484 0 : sal_uLong nLen = GetTextLen( pSep );
485 0 : sal_uLong nNodes = maTextNodes.Count();
486 :
487 0 : if ( nLen > STRING_MAXLEN )
488 : {
489 : OSL_FAIL( "Text zu gross fuer String" );
490 0 : return String();
491 : }
492 :
493 0 : String aASCIIText;
494 0 : sal_uLong nLastNode = nNodes-1;
495 0 : for ( sal_uLong nNode = 0; nNode < nNodes; nNode++ )
496 : {
497 0 : TextNode* pNode = maTextNodes.GetObject( nNode );
498 0 : String aTmp( pNode->GetText() );
499 0 : aASCIIText += aTmp;
500 0 : if ( pSep && ( nNode != nLastNode ) )
501 0 : aASCIIText += pSep;
502 0 : }
503 :
504 0 : return aASCIIText;
505 : }
506 :
507 0 : XubString TextDoc::GetText( sal_uLong nPara ) const
508 : {
509 0 : XubString aText;
510 0 : TextNode* pNode = ( nPara < maTextNodes.Count() ) ? maTextNodes.GetObject( nPara ) : 0;
511 0 : if ( pNode )
512 0 : aText = pNode->GetText();
513 :
514 0 : return aText;
515 : }
516 :
517 :
518 0 : sal_uLong TextDoc::GetTextLen( const sal_Unicode* pSep, const TextSelection* pSel ) const
519 : {
520 0 : sal_uLong nLen = 0;
521 0 : sal_uLong nNodes = maTextNodes.Count();
522 0 : if ( nNodes )
523 : {
524 0 : sal_uLong nStartNode = 0;
525 0 : sal_uLong nEndNode = nNodes-1;
526 0 : if ( pSel )
527 : {
528 0 : nStartNode = pSel->GetStart().GetPara();
529 0 : nEndNode = pSel->GetEnd().GetPara();
530 : }
531 :
532 0 : for ( sal_uLong nNode = nStartNode; nNode <= nEndNode; nNode++ )
533 : {
534 0 : TextNode* pNode = maTextNodes.GetObject( nNode );
535 :
536 0 : sal_uInt16 nS = 0;
537 0 : sal_uLong nE = pNode->GetText().Len();
538 0 : if ( pSel && ( nNode == pSel->GetStart().GetPara() ) )
539 0 : nS = pSel->GetStart().GetIndex();
540 0 : if ( pSel && ( nNode == pSel->GetEnd().GetPara() ) )
541 0 : nE = pSel->GetEnd().GetIndex();
542 :
543 0 : nLen += ( nE - nS );
544 : }
545 :
546 0 : if ( pSep )
547 0 : nLen += (nEndNode-nStartNode) * rtl_ustr_getLength(pSep);
548 : }
549 :
550 0 : return nLen;
551 : }
552 :
553 0 : TextPaM TextDoc::InsertText( const TextPaM& rPaM, sal_Unicode c )
554 : {
555 : DBG_ASSERT( c != 0x0A, "TextDoc::InsertText: Zeilentrenner in Absatz nicht erlaubt!" );
556 : DBG_ASSERT( c != 0x0D, "TextDoc::InsertText: Zeilentrenner in Absatz nicht erlaubt!" );
557 :
558 0 : TextNode* pNode = maTextNodes.GetObject( rPaM.GetPara() );
559 0 : pNode->InsertText( rPaM.GetIndex(), c );
560 :
561 0 : TextPaM aPaM( rPaM.GetPara(), rPaM.GetIndex()+1 );
562 0 : return aPaM;
563 : }
564 :
565 0 : TextPaM TextDoc::InsertText( const TextPaM& rPaM, const XubString& rStr )
566 : {
567 : DBG_ASSERT( rStr.Search( 0x0A ) == STRING_NOTFOUND, "TextDoc::InsertText: Zeilentrenner in Absatz nicht erlaubt!" );
568 : DBG_ASSERT( rStr.Search( 0x0D ) == STRING_NOTFOUND, "TextDoc::InsertText: Zeilentrenner in Absatz nicht erlaubt!" );
569 :
570 0 : TextNode* pNode = maTextNodes.GetObject( rPaM.GetPara() );
571 0 : pNode->InsertText( rPaM.GetIndex(), rStr );
572 :
573 0 : TextPaM aPaM( rPaM.GetPara(), rPaM.GetIndex()+rStr.Len() );
574 0 : return aPaM;
575 : }
576 :
577 0 : TextPaM TextDoc::InsertParaBreak( const TextPaM& rPaM, sal_Bool bKeepEndingAttribs )
578 : {
579 0 : TextNode* pNode = maTextNodes.GetObject( rPaM.GetPara() );
580 0 : TextNode* pNew = pNode->Split( rPaM.GetIndex(), bKeepEndingAttribs );
581 :
582 0 : maTextNodes.Insert( pNew, rPaM.GetPara()+1 );
583 :
584 0 : TextPaM aPaM( rPaM.GetPara()+1, 0 );
585 0 : return aPaM;
586 : }
587 :
588 0 : TextPaM TextDoc::ConnectParagraphs( TextNode* pLeft, TextNode* pRight )
589 : {
590 0 : sal_uInt16 nPrevLen = pLeft->GetText().Len();
591 0 : pLeft->Append( *pRight );
592 :
593 : // der rechte verschwindet.
594 0 : sal_uLong nRight = maTextNodes.GetPos( pRight );
595 0 : maTextNodes.Remove( nRight );
596 0 : delete pRight;
597 :
598 0 : sal_uLong nLeft = maTextNodes.GetPos( pLeft );
599 0 : TextPaM aPaM( nLeft, nPrevLen );
600 0 : return aPaM;
601 : }
602 :
603 0 : TextPaM TextDoc::RemoveChars( const TextPaM& rPaM, sal_uInt16 nChars )
604 : {
605 0 : TextNode* pNode = maTextNodes.GetObject( rPaM.GetPara() );
606 0 : pNode->RemoveText( rPaM.GetIndex(), nChars );
607 :
608 0 : return rPaM;
609 : }
610 :
611 0 : sal_Bool TextDoc::IsValidPaM( const TextPaM& rPaM )
612 : {
613 0 : if ( rPaM.GetPara() >= maTextNodes.Count() )
614 : {
615 : OSL_FAIL( "PaM: Para out of range" );
616 0 : return sal_False;
617 : }
618 0 : TextNode * pNode = maTextNodes.GetObject( rPaM.GetPara() );
619 0 : if ( rPaM.GetIndex() > pNode->GetText().Len() )
620 : {
621 : OSL_FAIL( "PaM: Index out of range" );
622 0 : return sal_False;
623 : }
624 0 : return sal_True;
625 : }
626 :
627 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
