1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sw.hxx"
26
27
28 #include <tools/string.hxx>
29 #include <tools/debug.hxx>
30 #include "errhdl.hxx"
31 #include "swtypes.hxx"
32 #include "txttypes.hxx"
33
34 #include "SwGrammarMarkUp.hxx"
35
36 /*************************************************************************
37 *SwWrongArea::SwWrongArea
38 *************************************************************************/
39
SwWrongArea(const rtl::OUString & rType,WrongListType listType,com::sun::star::uno::Reference<com::sun::star::container::XStringKeyMap> xPropertyBag,xub_StrLen nPos,xub_StrLen nLen)40 SwWrongArea::SwWrongArea( const rtl::OUString& rType, WrongListType listType,
41 com::sun::star::uno::Reference< com::sun::star::container::XStringKeyMap > xPropertyBag,
42 xub_StrLen nPos,
43 xub_StrLen nLen)
44 : maType(rType), mxPropertyBag(xPropertyBag), mnPos(nPos), mnLen(nLen), mpSubList(0)
45 {
46 mColor = getWrongAreaColor(listType, xPropertyBag);
47 mLineType = getWrongAreaLineType(listType, xPropertyBag);
48 }
49
SwWrongArea(const rtl::OUString & rType,com::sun::star::uno::Reference<com::sun::star::container::XStringKeyMap> xPropertyBag,xub_StrLen nPos,xub_StrLen nLen,SwWrongList * pSubList)50 SwWrongArea::SwWrongArea( const rtl::OUString& rType,
51 com::sun::star::uno::Reference< com::sun::star::container::XStringKeyMap > xPropertyBag,
52 xub_StrLen nPos,
53 xub_StrLen nLen,
54 SwWrongList* pSubList)
55 : maType(rType), mxPropertyBag(xPropertyBag), mnPos(nPos), mnLen(nLen), mpSubList(pSubList), mLineType(WRONGAREA_NONE)
56 {
57 if (pSubList != 0)
58 {
59 mColor = getWrongAreaColor(pSubList->GetWrongListType(), xPropertyBag);
60 mLineType = getWrongAreaLineType(pSubList->GetWrongListType(), xPropertyBag);
61 }
62 }
63
64 /*************************************************************************
65 * SwWrongList::SwWrongList()
66 *************************************************************************/
SwWrongList(WrongListType eType)67 SwWrongList::SwWrongList( WrongListType eType ) :
68 meType (eType),
69 nBeginInvalid(STRING_LEN), // everything correct... (the invalid area starts beyond the string)
70 nEndInvalid (STRING_LEN)
71 {
72 maList.reserve( 5 );
73 }
74
~SwWrongList()75 SwWrongList::~SwWrongList()
76 {
77 ClearList();
78 }
79
80 /*************************************************************************
81 * SwWrongList* SwWrongList::Clone()
82 *************************************************************************/
83
Clone()84 SwWrongList* SwWrongList::Clone()
85 {
86 SwWrongList* pClone = new SwWrongList( meType );
87 pClone->CopyFrom( *this );
88 return pClone;
89 }
90
91 /*************************************************************************
92 * void SwWrongList::CopyFrom( const SwWrongList& rCopy )
93 *************************************************************************/
94
CopyFrom(const SwWrongList & rCopy)95 void SwWrongList::CopyFrom( const SwWrongList& rCopy )
96 {
97 maList = rCopy.maList;
98 meType = rCopy.meType;
99 nBeginInvalid = rCopy.nBeginInvalid;
100 nEndInvalid = rCopy.nEndInvalid;
101 for( size_t i = 0; i < maList.size(); ++i )
102 {
103 if( maList[i].mpSubList )
104 maList[i].mpSubList = maList[i].mpSubList->Clone();
105 }
106 }
107
108 /*************************************************************************
109 * SwWrongList::ClearList()
110 *************************************************************************/
ClearList()111 void SwWrongList::ClearList()
112 {
113 for ( size_t i = 0; i < maList.size(); ++i)
114 {
115 if (maList[i].mpSubList)
116 delete maList[i].mpSubList;
117 maList[i].mpSubList = NULL;
118 }
119 maList.clear();
120 }
121
122 /*************************************************************************
123 * sal_Bool SwWrongList::InWrongWord() gibt den Anfang und die Laenge des
124 * Wortes zurueck, wenn es als falsch markiert ist.
125 *************************************************************************/
InWrongWord(xub_StrLen & rChk,xub_StrLen & rLn) const126 sal_Bool SwWrongList::InWrongWord( xub_StrLen &rChk, xub_StrLen &rLn ) const
127 {
128 MSHORT nPos = GetWrongPos( rChk );
129 xub_StrLen nWrPos;
130 if( nPos < Count() && ( nWrPos = Pos( nPos ) ) <= rChk )
131 {
132 rLn = Len( nPos );
133 if( nWrPos + rLn <= rChk )
134 return sal_False;
135 rChk = nWrPos;
136 return sal_True;
137 }
138 return sal_False;
139 }
140
141 /*************************************************************************
142 * sal_Bool SwWrongList::Check() liefert den ersten falschen Bereich
143 *************************************************************************/
Check(xub_StrLen & rChk,xub_StrLen & rLn) const144 sal_Bool SwWrongList::Check( xub_StrLen &rChk, xub_StrLen &rLn ) const
145 {
146 MSHORT nPos = GetWrongPos( rChk );
147 rLn = rLn + rChk;
148 xub_StrLen nWrPos;
149
150 if( nPos == Count() )
151 return sal_False;
152
153 xub_StrLen nEnd = Len( nPos );
154 nEnd = nEnd + ( nWrPos = Pos( nPos ) );
155 if( nEnd == rChk )
156 {
157 ++nPos;
158 if( nPos == Count() )
159 return sal_False;
160 else
161 {
162 nEnd = Len( nPos );
163 nEnd = nEnd + ( nWrPos = Pos( nPos ) );
164 }
165 }
166 if( nEnd > rChk && nWrPos < rLn )
167 {
168 if( nWrPos > rChk )
169 rChk = nWrPos;
170 if( nEnd < rLn )
171 rLn = nEnd;
172 rLn = rLn - rChk;
173 return 0 != rLn;
174 }
175 return sal_False;
176 }
177
178 /*************************************************************************
179 * xub_StrLen SwWrongList::NextWrong() liefert die naechste Fehlerposition
180 *************************************************************************/
181
NextWrong(xub_StrLen nChk) const182 xub_StrLen SwWrongList::NextWrong( xub_StrLen nChk ) const
183 {
184 xub_StrLen nRet;
185 xub_StrLen nPos = GetWrongPos( nChk );
186 if( nPos < Count() )
187 {
188 nRet = Pos( nPos );
189 if( nRet < nChk && nRet + Len( nPos ) <= nChk )
190 {
191 if( ++nPos < Count() )
192 nRet = Pos( nPos );
193 else
194 nRet = STRING_LEN;
195 }
196 }
197 else
198 nRet = STRING_LEN;
199 if( nRet > GetBeginInv() && nChk < GetEndInv() )
200 nRet = nChk > GetBeginInv() ? nChk : GetBeginInv();
201 return nRet;
202 }
203
204 /*************************************************************************
205 * MSHORT SwWrongList::GetWrongPos( xub_StrLen nValue )
206 * sucht die erste Position im Array, die groessergleich nValue ist,
207 * dies kann natuerlich auch hinter dem letzten Element sein!
208 *************************************************************************/
209
GetWrongPos(xub_StrLen nValue) const210 MSHORT SwWrongList::GetWrongPos( xub_StrLen nValue ) const
211 {
212 MSHORT nOben = Count(), nMitte = 0, nUnten = 0;
213
214 if( nOben > 0 )
215 {
216 // For smart tag lists, we may not use a binary search. We return the
217 // position of the first smart tag which coveres nValue
218 if ( 0 != maList[0].maType.getLength() || maList[0].mpSubList )
219 {
220 std::vector<SwWrongArea>::const_iterator aIter = maList.begin();
221 while ( aIter != maList.end() )
222 {
223 const xub_StrLen nSTPos = (*aIter).mnPos;
224 const xub_StrLen nSTLen = (*aIter).mnLen;
225 if ( nSTPos <= nValue && nValue < nSTPos + nSTLen )
226 break;
227 else if ( nSTPos > nValue )
228 break;
229
230 ++aIter;
231 ++nUnten;
232 }
233 return nUnten;
234 }
235
236 --nOben;
237 while( nUnten <= nOben )
238 {
239 nMitte = nUnten + ( nOben - nUnten ) / 2;
240 xub_StrLen nTmp = Pos( nMitte );
241 if( nTmp == nValue )
242 {
243 nUnten = nMitte;
244 break;
245 }
246 else if( nTmp < nValue )
247 {
248 if( nTmp + Len( nMitte ) >= nValue )
249 {
250 nUnten = nMitte;
251 break;
252 }
253 nUnten = nMitte + 1;
254 }
255 else if( nMitte == 0 )
256 {
257 break;
258 }
259 else
260 nOben = nMitte - 1;
261 }
262 }
263
264 // nUnten now points to an index i into the wrong list which
265 // 1. nValue is inside [ Area[i].pos, Area[i].pos + Area[i].len ] (inkl!!!)
266 // 2. nValue < Area[i].pos
267
268 return nUnten;
269 }
270
271 /*************************************************************************
272 * void SwWrongList::_Invalidate()
273 *************************************************************************/
274
_Invalidate(xub_StrLen nBegin,xub_StrLen nEnd)275 void SwWrongList::_Invalidate( xub_StrLen nBegin, xub_StrLen nEnd )
276 {
277 if ( nBegin < GetBeginInv() )
278 nBeginInvalid = nBegin;
279 if ( nEnd > GetEndInv() )
280 nEndInvalid = nEnd;
281 }
282
SetInvalid(xub_StrLen nBegin,xub_StrLen nEnd)283 void SwWrongList::SetInvalid( xub_StrLen nBegin, xub_StrLen nEnd )
284 {
285 nBeginInvalid = nBegin;
286 nEndInvalid = nEnd;
287 }
288
289
290 /*************************************************************************
291 * SwWrongList::Move( xub_StrLen nPos, long nDiff )
292 * veraendert alle Positionen ab nPos um den angegebenen Wert,
293 * wird nach Einfuegen oder Loeschen von Buchstaben benoetigt.
294 *************************************************************************/
295
Move(xub_StrLen nPos,long nDiff)296 void SwWrongList::Move( xub_StrLen nPos, long nDiff )
297 {
298 MSHORT i = GetWrongPos( nPos );
299 if( nDiff < 0 )
300 {
301 xub_StrLen nEnd = nPos + xub_StrLen( -nDiff );
302 MSHORT nLst = i;
303 xub_StrLen nWrPos;
304 xub_StrLen nWrLen;
305 sal_Bool bJump = sal_False;
306 while( nLst < Count() && Pos( nLst ) < nEnd )
307 ++nLst;
308 if( nLst > i && ( nWrPos = Pos( nLst - 1 ) ) <= nPos )
309 {
310 nWrLen = Len( nLst - 1 );
311 // calculate new length of word
312 nWrLen = ( nEnd > nWrPos + nWrLen ) ?
313 nPos - nWrPos :
314 static_cast<xub_StrLen>(nWrLen + nDiff);
315 if( nWrLen )
316 {
317 maList[--nLst].mnLen = nWrLen;
318 bJump = sal_True;
319 }
320 }
321 Remove( i, nLst - i );
322
323 if ( bJump )
324 ++i;
325 if( STRING_LEN == GetBeginInv() )
326 SetInvalid( nPos ? nPos - 1 : nPos, nPos + 1 );
327 else
328 {
329 ShiftLeft( nBeginInvalid, nPos, nEnd );
330 ShiftLeft( nEndInvalid, nPos, nEnd );
331 _Invalidate( nPos ? nPos - 1 : nPos, nPos + 1 );
332 }
333 }
334 else
335 {
336 xub_StrLen nWrPos;
337 xub_StrLen nEnd = nPos + xub_StrLen( nDiff );
338 if( STRING_LEN != GetBeginInv() )
339 {
340 if( nBeginInvalid > nPos )
341 nBeginInvalid = nBeginInvalid + xub_StrLen( nDiff );
342 if( nEndInvalid >= nPos )
343 nEndInvalid = nEndInvalid + xub_StrLen( nDiff );
344 }
345 // Wenn wir mitten in einem falschen Wort stehen, muss vom Wortanfang
346 // invalidiert werden.
347 if( i < Count() && nPos >= ( nWrPos = Pos( i ) ) )
348 {
349 Invalidate( nWrPos, nEnd );
350 xub_StrLen nWrLen = Len( i ) + xub_StrLen( nDiff );
351 maList[i++].mnLen = nWrLen;
352 nWrLen = nWrLen + nWrPos;
353 Invalidate( nWrPos, nWrLen );
354 }
355 else
356 Invalidate( nPos, nEnd );
357 }
358 while( i < Count() )
359 {
360 const xub_StrLen nTmp = static_cast<xub_StrLen>(nDiff + maList[i].mnPos);
361 maList[i++].mnPos = nTmp;
362 }
363 }
364
365 /*************************************************************************
366 * SwWrongList::Fresh
367 *
368 * For a given range [nPos, nPos + nLen[ and an index nIndex, this function
369 * basically counts the number of SwWrongArea entries starting with nIndex
370 * up to nPos + nLen. All these entries are removed.
371 *************************************************************************/
Fresh(xub_StrLen & rStart,xub_StrLen & rEnd,xub_StrLen nPos,xub_StrLen nLen,MSHORT nIndex,xub_StrLen nCursorPos)372 sal_Bool SwWrongList::Fresh( xub_StrLen &rStart, xub_StrLen &rEnd, xub_StrLen nPos,
373 xub_StrLen nLen, MSHORT nIndex, xub_StrLen nCursorPos )
374 {
375 // length of word must be greater than 0 and cursor position must be outside the word
376 sal_Bool bRet = nLen && ( nCursorPos > nPos + nLen || nCursorPos < nPos );
377
378 xub_StrLen nWrPos = 0;
379 xub_StrLen nWrEnd = rEnd;
380 MSHORT nCnt = nIndex;
381 if( nCnt < Count() && ( nWrPos = Pos( nIndex ) ) < nPos )
382 {
383 if( rStart > nWrPos )
384 rStart = nWrPos;
385 }
386
387 while( nCnt < Count() && ( nWrPos = Pos( nCnt ) ) < nPos )
388 nWrEnd = nWrPos + Len( nCnt++ );
389
390 if( nCnt < Count() && nWrPos == nPos && Len( nCnt ) == nLen )
391 {
392 ++nCnt;
393 bRet = sal_True;
394 }
395 else
396 {
397 if( bRet )
398 {
399 if( rStart > nPos )
400 rStart = nPos;
401 nWrEnd = nPos + nLen;
402 }
403 }
404
405 nPos = nPos + nLen;
406
407 if( nCnt < Count() && ( nWrPos = Pos( nCnt ) ) < nPos )
408 {
409 if( rStart > nWrPos )
410 rStart = nWrPos;
411 }
412
413 while( nCnt < Count() && ( nWrPos = Pos( nCnt ) ) < nPos )
414 nWrEnd = nWrPos + Len( nCnt++ );
415
416 if( rEnd < nWrEnd )
417 rEnd = nWrEnd;
418
419 Remove( nIndex, nCnt - nIndex );
420
421 return bRet;
422 }
423
Invalidate(xub_StrLen nBegin,xub_StrLen nEnd)424 void SwWrongList::Invalidate( xub_StrLen nBegin, xub_StrLen nEnd )
425 {
426 if (STRING_LEN == GetBeginInv())
427 SetInvalid( nBegin, nEnd );
428 else
429 _Invalidate( nBegin, nEnd );
430 }
431
InvalidateWrong()432 sal_Bool SwWrongList::InvalidateWrong( )
433 {
434 if( Count() )
435 {
436 xub_StrLen nFirst = Pos( 0 );
437 xub_StrLen nLast = Pos( Count() - 1 ) + Len( Count() - 1 );
438 Invalidate( nFirst, nLast );
439 return sal_True;
440 }
441 else
442 return sal_False;
443 }
444
SplitList(xub_StrLen nSplitPos)445 SwWrongList* SwWrongList::SplitList( xub_StrLen nSplitPos )
446 {
447 SwWrongList *pRet = NULL;
448 MSHORT nLst = 0;
449 xub_StrLen nWrPos;
450 xub_StrLen nWrLen;
451 while( nLst < Count() && Pos( nLst ) < nSplitPos )
452 ++nLst;
453 if( nLst && ( nWrPos = Pos( nLst - 1 ) )
454 + ( nWrLen = Len( nLst - 1 ) ) > nSplitPos )
455 {
456 nWrLen += nWrPos - nSplitPos;
457 maList[--nLst].mnPos = nSplitPos;
458 maList[nLst].mnLen = nWrLen;
459 }
460 if( nLst )
461 {
462 if( WRONGLIST_GRAMMAR == GetWrongListType() )
463 pRet = new SwGrammarMarkUp();
464 else
465 pRet = new SwWrongList( GetWrongListType() );
466 pRet->Insert(0, maList.begin(), ( nLst >= maList.size() ? maList.end() : maList.begin() + nLst ) );
467 pRet->SetInvalid( GetBeginInv(), GetEndInv() );
468 pRet->_Invalidate( nSplitPos ? nSplitPos - 1 : nSplitPos, nSplitPos );
469 Remove( 0, nLst );
470 }
471 if( STRING_LEN == GetBeginInv() )
472 SetInvalid( 0, 1 );
473 else
474 {
475 ShiftLeft( nBeginInvalid, 0, nSplitPos );
476 ShiftLeft( nEndInvalid, 0, nSplitPos );
477 _Invalidate( 0, 1 );
478 }
479 nLst = 0;
480 while( nLst < Count() )
481 {
482 nWrPos = maList[nLst].mnPos - nSplitPos;
483 maList[nLst++].mnPos = nWrPos;
484 }
485 return pRet;
486 }
487
JoinList(SwWrongList * pNext,xub_StrLen nInsertPos)488 void SwWrongList::JoinList( SwWrongList* pNext, xub_StrLen nInsertPos )
489 {
490 if (pNext)
491 {
492 DBG_ASSERT( GetWrongListType() == pNext->GetWrongListType(), "type mismatch with next list" );
493 }
494 if( pNext )
495 {
496 sal_uInt16 nCnt = Count();
497 pNext->Move( 0, nInsertPos );
498 Insert(nCnt, pNext->maList.begin(), pNext->maList.end());
499
500 Invalidate( pNext->GetBeginInv(), pNext->GetEndInv() );
501 if( nCnt && Count() > nCnt )
502 {
503 xub_StrLen nWrPos = Pos( nCnt );
504 xub_StrLen nWrLen = Len( nCnt );
505 if( !nWrPos )
506 {
507 nWrPos = nWrPos + nInsertPos;
508 nWrLen = nWrLen - nInsertPos;
509 maList[nCnt].mnPos = nWrPos;
510 maList[nCnt].mnLen = nWrLen;
511 }
512 if( nWrPos == Pos( nCnt - 1 ) + Len( nCnt - 1 ) )
513 {
514 nWrLen = nWrLen + Len( nCnt - 1 );
515 maList[nCnt - 1].mnLen = nWrLen;
516 Remove( nCnt, 1 );
517 }
518 }
519 }
520 Invalidate( nInsertPos ? nInsertPos - 1 : nInsertPos, nInsertPos + 1 );
521 }
522
523
InsertSubList(xub_StrLen nNewPos,xub_StrLen nNewLen,sal_uInt16 nWhere,SwWrongList * pSubList)524 void SwWrongList::InsertSubList( xub_StrLen nNewPos, xub_StrLen nNewLen, sal_uInt16 nWhere, SwWrongList* pSubList )
525 {
526 if (pSubList)
527 {
528 DBG_ASSERT( GetWrongListType() == pSubList->GetWrongListType(), "type mismatch with sub list" );
529 }
530 std::vector<SwWrongArea>::iterator i = maList.begin();
531 if ( nWhere >= maList.size() )
532 i = maList.end(); // robust
533 else
534 i += nWhere;
535 maList.insert(i, SwWrongArea( rtl::OUString(), 0, nNewPos, nNewLen, pSubList ) );
536 }
537
538
539 // New functions: Necessary because SwWrongList has been changed to use std::vector
Insert(sal_uInt16 nWhere,std::vector<SwWrongArea>::iterator startPos,std::vector<SwWrongArea>::iterator endPos)540 void SwWrongList::Insert(sal_uInt16 nWhere, std::vector<SwWrongArea>::iterator startPos, std::vector<SwWrongArea>::iterator endPos)
541 {
542 std::vector<SwWrongArea>::iterator i = maList.begin();
543 if ( nWhere >= maList.size() )
544 i = maList.end(); // robust
545 else
546 i += nWhere;
547 maList.insert(i, startPos, endPos); // insert [startPos, endPos[ before i
548
549 // ownership of the sublist is passed to maList, therefore we have to set the
550 // pSubList-Pointers to 0
551 while ( startPos != endPos )
552 {
553 (*startPos).mpSubList = 0;
554 ++startPos;
555 }
556 }
557
Remove(sal_uInt16 nIdx,sal_uInt16 nLen)558 void SwWrongList::Remove(sal_uInt16 nIdx, sal_uInt16 nLen )
559 {
560 if ( nIdx >= maList.size() ) return;
561 std::vector<SwWrongArea>::iterator i1 = maList.begin();
562 i1 += nIdx;
563
564 std::vector<SwWrongArea>::iterator i2 = i1;
565 if ( nIdx + nLen >= static_cast<sal_uInt16>(maList.size()) )
566 i2 = maList.end(); // robust
567 else
568 i2 += nLen;
569
570 std::vector<SwWrongArea>::iterator iLoop = i1;
571 while ( iLoop != i2 )
572 {
573 if ( (*iLoop).mpSubList )
574 delete (*iLoop).mpSubList;
575 ++iLoop;
576 }
577
578 #if OSL_DEBUG_LEVEL > 1
579 const int nOldSize = Count();
580 (void) nOldSize;
581 #endif
582
583 maList.erase(i1, i2);
584
585 #if OSL_DEBUG_LEVEL > 1
586 ASSERT( Count() + nLen == nOldSize, "SwWrongList::Remove() trouble" )
587 #endif
588 }
589
RemoveEntry(xub_StrLen nBegin,xub_StrLen nEnd)590 void SwWrongList::RemoveEntry( xub_StrLen nBegin, xub_StrLen nEnd ) {
591 sal_uInt16 nDelPos = 0;
592 sal_uInt16 nDel = 0;
593 std::vector<SwWrongArea>::iterator aIter = maList.begin();
594 while( aIter != maList.end() && (*aIter).mnPos < nBegin )
595 {
596 ++aIter;
597 ++nDelPos;
598 }
599 if( WRONGLIST_GRAMMAR == GetWrongListType() )
600 {
601 while( aIter != maList.end() && nBegin < nEnd && nEnd > (*aIter).mnPos )
602 {
603 ++aIter;
604 ++nDel;
605 }
606 }
607 else
608 {
609 while( aIter != maList.end() && nBegin == (*aIter).mnPos && nEnd == (*aIter).mnPos +(*aIter).mnLen )
610 {
611 ++aIter;
612 ++nDel;
613 }
614 }
615 if( nDel )
616 Remove( nDelPos, nDel );
617 }
618
LookForEntry(xub_StrLen nBegin,xub_StrLen nEnd)619 bool SwWrongList::LookForEntry( xub_StrLen nBegin, xub_StrLen nEnd ) {
620 std::vector<SwWrongArea>::iterator aIter = maList.begin();
621 while( aIter != maList.end() && (*aIter).mnPos < nBegin )
622 ++aIter;
623 if( aIter != maList.end() && nBegin == (*aIter).mnPos && nEnd == (*aIter).mnPos +(*aIter).mnLen )
624 return true;
625 return false;
626 }
627
Insert(const rtl::OUString & rType,com::sun::star::uno::Reference<com::sun::star::container::XStringKeyMap> xPropertyBag,xub_StrLen nNewPos,xub_StrLen nNewLen)628 void SwWrongList::Insert( const rtl::OUString& rType,
629 com::sun::star::uno::Reference< com::sun::star::container::XStringKeyMap > xPropertyBag,
630 xub_StrLen nNewPos, xub_StrLen nNewLen )
631 {
632 std::vector<SwWrongArea>::iterator aIter = maList.begin();
633
634 while ( aIter != maList.end() )
635 {
636 const xub_StrLen nSTPos = (*aIter).mnPos;
637
638 if ( nNewPos < nSTPos )
639 {
640 // insert at current position
641 break;
642 }
643 else if ( nNewPos == nSTPos )
644 {
645 while ( aIter != maList.end() && (*aIter).mnPos == nSTPos )
646 {
647 const xub_StrLen nSTLen = (*aIter).mnLen;
648
649 if ( nNewLen < nSTLen )
650 {
651 // insert at current position
652 break;
653 }
654
655 ++aIter;
656 }
657
658 break;
659 }
660
661 ++aIter;
662 }
663
664 maList.insert(aIter, SwWrongArea( rType, meType, xPropertyBag, nNewPos, nNewLen) );
665 }
666
667
668