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 "swtypes.hxx"
21 : #include "txttypes.hxx"
22 :
23 : #include "SwGrammarMarkUp.hxx"
24 :
25 0 : SwWrongArea::SwWrongArea( const rtl::OUString& rType, WrongListType listType,
26 : com::sun::star::uno::Reference< com::sun::star::container::XStringKeyMap > xPropertyBag,
27 : sal_Int32 nPos,
28 : sal_Int32 nLen)
29 0 : : maType(rType), mxPropertyBag(xPropertyBag), mnPos(nPos), mnLen(nLen), mpSubList(0)
30 : {
31 0 : mColor = getWrongAreaColor(listType, xPropertyBag);
32 0 : mLineType = getWrongAreaLineType(listType, xPropertyBag);
33 0 : }
34 :
35 0 : SwWrongArea::SwWrongArea( const rtl::OUString& rType,
36 : com::sun::star::uno::Reference< com::sun::star::container::XStringKeyMap > xPropertyBag,
37 : sal_Int32 nPos,
38 : sal_Int32 nLen,
39 : SwWrongList* pSubList)
40 0 : : maType(rType), mxPropertyBag(xPropertyBag), mnPos(nPos), mnLen(nLen), mpSubList(pSubList), mLineType(WRONGAREA_NONE)
41 : {
42 0 : if (pSubList != 0)
43 : {
44 0 : mColor = getWrongAreaColor(pSubList->GetWrongListType(), xPropertyBag);
45 0 : mLineType = getWrongAreaLineType(pSubList->GetWrongListType(), xPropertyBag);
46 : }
47 0 : }
48 :
49 0 : SwWrongList::SwWrongList( WrongListType eType ) :
50 : meType (eType),
51 : nBeginInvalid(COMPLETE_STRING), // everything correct... (the invalid area starts beyond the string)
52 0 : nEndInvalid (COMPLETE_STRING)
53 : {
54 0 : maList.reserve( 5 );
55 0 : }
56 :
57 0 : SwWrongList::~SwWrongList()
58 : {
59 0 : ClearList();
60 0 : }
61 :
62 0 : SwWrongList* SwWrongList::Clone()
63 : {
64 0 : SwWrongList* pClone = new SwWrongList( meType );
65 0 : pClone->CopyFrom( *this );
66 0 : return pClone;
67 : }
68 :
69 0 : void SwWrongList::CopyFrom( const SwWrongList& rCopy )
70 : {
71 0 : maList = rCopy.maList;
72 0 : meType = rCopy.meType;
73 0 : nBeginInvalid = rCopy.nBeginInvalid;
74 0 : nEndInvalid = rCopy.nEndInvalid;
75 0 : for( size_t i = 0; i < maList.size(); ++i )
76 : {
77 0 : if( maList[i].mpSubList )
78 0 : maList[i].mpSubList = maList[i].mpSubList->Clone();
79 : }
80 0 : }
81 :
82 0 : void SwWrongList::ClearList()
83 : {
84 0 : for ( size_t i = 0; i < maList.size(); ++i)
85 : {
86 0 : if (maList[i].mpSubList)
87 0 : delete maList[i].mpSubList;
88 0 : maList[i].mpSubList = NULL;
89 : }
90 0 : maList.clear();
91 0 : }
92 :
93 : /** If a word is incorrectly selected, this method returns begin and length of it.
94 :
95 : @param[in,out] rChk starting position of the word to check
96 : @param[out] rLn length of the word
97 :
98 : @return <true> if incorrectly selected, <false> otherwise
99 : */
100 0 : bool SwWrongList::InWrongWord( sal_Int32 &rChk, sal_Int32 &rLn ) const
101 : {
102 0 : const MSHORT nPos = GetWrongPos( rChk );
103 0 : if ( nPos >= Count() )
104 0 : return false;
105 0 : const sal_Int32 nWrPos = Pos( nPos );
106 0 : if ( nWrPos <= rChk )
107 : {
108 0 : rLn = Len( nPos );
109 0 : if( nWrPos + rLn <= rChk )
110 0 : return false;
111 0 : rChk = nWrPos;
112 0 : return true;
113 : }
114 0 : return false;
115 : }
116 :
117 : /** Calculate first incorrectly selected area.
118 :
119 : @param[in,out] rChk starting position of the word to check
120 : @param[in,out] rLn length of the word
121 :
122 : @return <true> if incorrectly selected area was found, <false> otherwise
123 : */
124 0 : bool SwWrongList::Check( sal_Int32 &rChk, sal_Int32 &rLn ) const
125 : {
126 0 : MSHORT nPos = GetWrongPos( rChk );
127 0 : rLn += rChk;
128 :
129 0 : if( nPos == Count() )
130 0 : return false;
131 :
132 0 : sal_Int32 nWrPos = Pos( nPos );
133 0 : sal_Int32 nEnd = nWrPos + Len( nPos );
134 0 : if( nEnd == rChk )
135 : {
136 0 : ++nPos;
137 0 : if( nPos == Count() )
138 0 : return false;
139 :
140 0 : nWrPos = Pos( nPos );
141 0 : nEnd = nWrPos + Len( nPos );
142 : }
143 0 : if( nEnd > rChk && nWrPos < rLn )
144 : {
145 0 : if( nWrPos > rChk )
146 0 : rChk = nWrPos;
147 0 : if( nEnd < rLn )
148 0 : rLn = nEnd;
149 0 : rLn -= rChk;
150 0 : return 0 != rLn;
151 : }
152 0 : return false;
153 : }
154 :
155 : /** Find next incorrectly selected position.
156 :
157 : @param[in] rChk starting position of the word to check
158 :
159 : @return starting position of incorrectly selected area, <COMPLETE_STRING> otherwise
160 : */
161 0 : sal_Int32 SwWrongList::NextWrong( sal_Int32 nChk ) const
162 : {
163 0 : sal_Int32 nRet = COMPLETE_STRING;
164 0 : sal_uInt16 nPos = GetWrongPos( nChk );
165 0 : if( nPos < Count() )
166 : {
167 0 : nRet = Pos( nPos );
168 0 : if( nRet < nChk && nRet + Len( nPos ) <= nChk )
169 : {
170 0 : if( ++nPos < Count() )
171 0 : nRet = Pos( nPos );
172 : else
173 0 : nRet = COMPLETE_STRING;
174 : }
175 : }
176 0 : if( nRet > GetBeginInv() && nChk < GetEndInv() )
177 0 : nRet = nChk > GetBeginInv() ? nChk : GetBeginInv();
178 0 : return nRet;
179 : }
180 :
181 : /** Find the first position that is greater or equal to the given value.
182 :
183 : @note Resulting position might be behind the last element of the array.
184 : @param[in] nValue value for comparison
185 :
186 : @return first position that is greater or equal to the given value
187 : */
188 0 : sal_uInt16 SwWrongList::GetWrongPos( sal_Int32 nValue ) const
189 : {
190 0 : sal_uInt16 nMax = Count();
191 0 : sal_uInt16 nMin = 0;
192 :
193 0 : if( nMax > 0 )
194 : {
195 : // For smart tag lists, we may not use a binary search. We return the
196 : // position of the first smart tag which coveres nValue
197 0 : if ( !maList[0].maType.isEmpty() || maList[0].mpSubList )
198 : {
199 0 : for (std::vector<SwWrongArea>::const_iterator aIter(maList.begin()), aEnd(maList.end()); aIter != aEnd; ++aIter)
200 : {
201 0 : const sal_Int32 nSTPos = (*aIter).mnPos;
202 0 : const sal_Int32 nSTLen = (*aIter).mnLen;
203 0 : if ( nSTPos <= nValue && nValue < nSTPos + nSTLen )
204 0 : break;
205 0 : if ( nSTPos > nValue )
206 0 : break;
207 :
208 0 : ++nMin;
209 : }
210 0 : return nMin;
211 : }
212 :
213 0 : --nMax;
214 0 : sal_uInt16 nMid = 0;
215 0 : while( nMin <= nMax )
216 : {
217 0 : nMid = nMin + ( nMax - nMin ) / 2;
218 0 : const sal_Int32 nTmp = Pos( nMid );
219 0 : if( nTmp == nValue )
220 : {
221 0 : nMin = nMid;
222 0 : break;
223 : }
224 0 : else if( nTmp < nValue )
225 : {
226 0 : if( nTmp + Len( nMid ) >= nValue )
227 : {
228 0 : nMin = nMid;
229 0 : break;
230 : }
231 0 : nMin = nMid + 1;
232 : }
233 0 : else if( nMid == 0 )
234 : {
235 0 : break;
236 : }
237 : else
238 0 : nMax = nMid - 1;
239 : }
240 : }
241 :
242 : // nMin now points to an index i into the wrong list which
243 : // 1. nValue is inside [ Area[i].pos, Area[i].pos + Area[i].len ] (inclusive!!!)
244 : // 2. nValue < Area[i].pos
245 :
246 0 : return nMin;
247 : }
248 :
249 0 : void SwWrongList::_Invalidate( sal_Int32 nBegin, sal_Int32 nEnd )
250 : {
251 0 : if ( nBegin < GetBeginInv() )
252 0 : nBeginInvalid = nBegin;
253 0 : if ( nEnd > GetEndInv() )
254 0 : nEndInvalid = nEnd;
255 0 : }
256 :
257 0 : void SwWrongList::SetInvalid( sal_Int32 nBegin, sal_Int32 nEnd )
258 : {
259 0 : nBeginInvalid = nBegin;
260 0 : nEndInvalid = nEnd;
261 0 : }
262 :
263 : /** Change all values after the given postion.
264 :
265 : Needed after insert/deletion of characters.
266 :
267 : @param nPos position after that everything should be changed
268 : @param nDiff amount how much the positions should be moved
269 : */
270 0 : void SwWrongList::Move( sal_Int32 nPos, sal_Int32 nDiff )
271 : {
272 0 : MSHORT i = GetWrongPos( nPos );
273 0 : if( nDiff < 0 )
274 : {
275 0 : const sal_Int32 nEnd = nPos - nDiff;
276 0 : MSHORT nLst = i;
277 0 : bool bJump = false;
278 0 : while( nLst < Count() && Pos( nLst ) < nEnd )
279 0 : ++nLst;
280 0 : if( nLst > i )
281 : {
282 0 : const sal_Int32 nWrPos = Pos( nLst - 1 );
283 0 : if ( nWrPos <= nPos )
284 : {
285 0 : sal_Int32 nWrLen = Len( nLst - 1 );
286 : // calculate new length of word
287 0 : nWrLen = ( nEnd > nWrPos + nWrLen ) ?
288 : nPos - nWrPos :
289 0 : nWrLen + nDiff;
290 0 : if( nWrLen )
291 : {
292 0 : maList[--nLst].mnLen = nWrLen;
293 0 : bJump = true;
294 : }
295 : }
296 : }
297 0 : Remove( i, nLst - i );
298 :
299 0 : if ( bJump )
300 0 : ++i;
301 0 : if( COMPLETE_STRING == GetBeginInv() )
302 0 : SetInvalid( nPos ? nPos - 1 : nPos, nPos + 1 );
303 : else
304 : {
305 0 : ShiftLeft( nBeginInvalid, nPos, nEnd );
306 0 : ShiftLeft( nEndInvalid, nPos, nEnd );
307 0 : _Invalidate( nPos ? nPos - 1 : nPos, nPos + 1 );
308 : }
309 : }
310 : else
311 : {
312 0 : const sal_Int32 nEnd = nPos + nDiff;
313 0 : if( COMPLETE_STRING != GetBeginInv() )
314 : {
315 0 : if( nBeginInvalid > nPos )
316 0 : nBeginInvalid += nDiff;
317 0 : if( nEndInvalid >= nPos )
318 0 : nEndInvalid += nDiff;
319 : }
320 : // If the pointer is in the middle of a wrong word,
321 : // invalidation must happen from the beginning of that word.
322 0 : if( i < Count() )
323 : {
324 0 : const sal_Int32 nWrPos = Pos( i );
325 0 : if (nPos >= nWrPos)
326 : {
327 0 : Invalidate( nWrPos, nEnd );
328 0 : const sal_Int32 nWrLen = Len( i ) + nDiff;
329 0 : maList[i++].mnLen = nWrLen;
330 0 : Invalidate( nWrPos, nWrPos + nWrLen );
331 : }
332 : }
333 : else
334 0 : Invalidate( nPos, nEnd );
335 : }
336 0 : while( i < Count() )
337 : {
338 0 : maList[i++].mnPos += nDiff;
339 : }
340 0 : }
341 :
342 : // TODO: Complete documentation
343 : /** Remove given range of entries
344 :
345 : For a given range [nPos, nPos + nLen[ and an index nIndex, this function
346 : basically counts the number of SwWrongArea entries starting with nIndex
347 : up to nPos + nLen. All these entries are removed.
348 :
349 : @param rStart ???
350 : @param rEnd ???
351 : @param nPos starting position of the range
352 : @param nLen length of the range
353 : @param nIndex index to start lookup at
354 : @param nCursorPos ???
355 :
356 : @return <true> if ???
357 : */
358 0 : bool SwWrongList::Fresh( sal_Int32 &rStart, sal_Int32 &rEnd, sal_Int32 nPos,
359 : sal_Int32 nLen, MSHORT nIndex, sal_Int32 nCursorPos )
360 : {
361 : // length of word must be greater than 0 and cursor position must be outside the word
362 0 : bool bRet = nLen && ( nCursorPos > nPos + nLen || nCursorPos < nPos );
363 :
364 0 : sal_Int32 nWrPos = 0;
365 0 : sal_Int32 nWrEnd = rEnd;
366 0 : MSHORT nCnt = nIndex;
367 0 : if( nCnt < Count() )
368 : {
369 0 : nWrPos = Pos( nCnt );
370 0 : if( nWrPos < nPos && rStart > nWrPos )
371 0 : rStart = nWrPos;
372 : }
373 :
374 0 : while( nCnt < Count() )
375 : {
376 0 : nWrPos = Pos( nCnt );
377 0 : if ( nWrPos >= nPos )
378 0 : break;
379 0 : nWrEnd = nWrPos + Len( nCnt++ );
380 : }
381 :
382 0 : if( nCnt < Count() && nWrPos == nPos && Len( nCnt ) == nLen )
383 : {
384 0 : ++nCnt;
385 0 : bRet = true;
386 : }
387 : else
388 : {
389 0 : if( bRet )
390 : {
391 0 : if( rStart > nPos )
392 0 : rStart = nPos;
393 0 : nWrEnd = nPos + nLen;
394 : }
395 : }
396 :
397 0 : nPos += nLen;
398 :
399 0 : if( nCnt < Count() )
400 : {
401 0 : nWrPos = Pos( nCnt );
402 0 : if( nWrPos < nPos && rStart > nWrPos )
403 0 : rStart = nWrPos;
404 : }
405 :
406 0 : while( nCnt < Count() )
407 : {
408 0 : nWrPos = Pos( nCnt );
409 0 : if ( nWrPos >= nPos )
410 0 : break;
411 0 : nWrEnd = nWrPos + Len( nCnt++ );
412 : }
413 :
414 0 : if( rEnd < nWrEnd )
415 0 : rEnd = nWrEnd;
416 :
417 0 : Remove( nIndex, nCnt - nIndex );
418 :
419 0 : return bRet;
420 : }
421 :
422 0 : void SwWrongList::Invalidate( sal_Int32 nBegin, sal_Int32 nEnd )
423 : {
424 0 : if (COMPLETE_STRING == GetBeginInv())
425 0 : SetInvalid( nBegin, nEnd );
426 : else
427 0 : _Invalidate( nBegin, nEnd );
428 0 : }
429 :
430 0 : bool SwWrongList::InvalidateWrong( )
431 : {
432 0 : if( Count() )
433 : {
434 0 : const sal_Int32 nFirst = Pos( 0 );
435 0 : const sal_Int32 nLast = Pos( Count() - 1 ) + Len( Count() - 1 );
436 0 : Invalidate( nFirst, nLast );
437 0 : return true;
438 : }
439 0 : return false;
440 : }
441 :
442 0 : SwWrongList* SwWrongList::SplitList( sal_Int32 nSplitPos )
443 : {
444 0 : SwWrongList *pRet = NULL;
445 0 : MSHORT nLst = 0;
446 0 : while( nLst < Count() && Pos( nLst ) < nSplitPos )
447 0 : ++nLst;
448 0 : if( nLst )
449 : {
450 0 : sal_Int32 nWrPos = Pos( nLst - 1 );
451 0 : sal_Int32 nWrLen = Len( nLst - 1 );
452 0 : if ( nWrPos+nWrLen > nSplitPos )
453 : {
454 0 : nWrLen += nWrPos - nSplitPos;
455 0 : maList[--nLst].mnPos = nSplitPos;
456 0 : maList[nLst].mnLen = nWrLen;
457 : }
458 : }
459 0 : if( nLst )
460 : {
461 0 : if( WRONGLIST_GRAMMAR == GetWrongListType() )
462 0 : pRet = new SwGrammarMarkUp();
463 : else
464 0 : pRet = new SwWrongList( GetWrongListType() );
465 0 : pRet->Insert(0, maList.begin(), ( nLst >= maList.size() ? maList.end() : maList.begin() + nLst ) );
466 0 : pRet->SetInvalid( GetBeginInv(), GetEndInv() );
467 0 : pRet->_Invalidate( nSplitPos ? nSplitPos - 1 : nSplitPos, nSplitPos );
468 0 : Remove( 0, nLst );
469 : }
470 0 : if( COMPLETE_STRING == GetBeginInv() )
471 0 : SetInvalid( 0, 1 );
472 : else
473 : {
474 0 : ShiftLeft( nBeginInvalid, 0, nSplitPos );
475 0 : ShiftLeft( nEndInvalid, 0, nSplitPos );
476 0 : _Invalidate( 0, 1 );
477 : }
478 0 : for (nLst = 0; nLst < Count(); ++nLst )
479 : {
480 0 : maList[nLst].mnPos -= nSplitPos;
481 : }
482 0 : return pRet;
483 : }
484 :
485 0 : void SwWrongList::JoinList( SwWrongList* pNext, sal_Int32 nInsertPos )
486 : {
487 : if (pNext)
488 : {
489 : OSL_ENSURE( GetWrongListType() == pNext->GetWrongListType(), "type mismatch with next list" );
490 : }
491 0 : if( pNext )
492 : {
493 0 : sal_uInt16 nCnt = Count();
494 0 : pNext->Move( 0, nInsertPos );
495 0 : Insert(nCnt, pNext->maList.begin(), pNext->maList.end());
496 :
497 0 : Invalidate( pNext->GetBeginInv(), pNext->GetEndInv() );
498 0 : if( nCnt && Count() > nCnt )
499 : {
500 0 : sal_Int32 nWrPos = Pos( nCnt );
501 0 : sal_Int32 nWrLen = Len( nCnt );
502 0 : if( !nWrPos )
503 : {
504 0 : nWrPos += nInsertPos;
505 0 : nWrLen -= nInsertPos;
506 0 : maList[nCnt].mnPos = nWrPos;
507 0 : maList[nCnt].mnLen = nWrLen;
508 : }
509 0 : if( nWrPos == Pos( nCnt - 1 ) + Len( nCnt - 1 ) )
510 : {
511 0 : nWrLen += Len( nCnt - 1 );
512 0 : maList[nCnt - 1].mnLen = nWrLen;
513 0 : Remove( nCnt, 1 );
514 : }
515 : }
516 : }
517 0 : Invalidate( nInsertPos ? nInsertPos - 1 : nInsertPos, nInsertPos + 1 );
518 0 : }
519 :
520 0 : void SwWrongList::InsertSubList( sal_Int32 nNewPos, sal_Int32 nNewLen, sal_uInt16 nWhere, SwWrongList* pSubList )
521 : {
522 : if (pSubList)
523 : {
524 : OSL_ENSURE( GetWrongListType() == pSubList->GetWrongListType(), "type mismatch with sub list" );
525 : }
526 0 : std::vector<SwWrongArea>::iterator i = maList.begin();
527 0 : if ( nWhere >= maList.size() )
528 0 : i = maList.end(); // robust
529 : else
530 0 : i += nWhere;
531 0 : maList.insert(i, SwWrongArea( OUString(), 0, nNewPos, nNewLen, pSubList ) );
532 0 : }
533 :
534 : // New functions: Necessary because SwWrongList has been changed to use std::vector
535 0 : void SwWrongList::Insert(sal_uInt16 nWhere, std::vector<SwWrongArea>::iterator startPos, std::vector<SwWrongArea>::iterator endPos)
536 : {
537 0 : std::vector<SwWrongArea>::iterator i = maList.begin();
538 0 : if ( nWhere >= maList.size() )
539 0 : i = maList.end(); // robust
540 : else
541 0 : i += nWhere;
542 0 : maList.insert(i, startPos, endPos); // insert [startPos, endPos[ before i
543 :
544 : // ownership of the sublist is passed to maList, therefore we have to set the
545 : // pSubList-Pointers to 0
546 0 : while ( startPos != endPos )
547 : {
548 0 : (*startPos).mpSubList = 0;
549 0 : ++startPos;
550 : }
551 0 : }
552 :
553 0 : void SwWrongList::Remove(sal_uInt16 nIdx, sal_uInt16 nLen )
554 : {
555 0 : if ( nIdx >= maList.size() ) return;
556 0 : std::vector<SwWrongArea>::iterator i1 = maList.begin();
557 0 : i1 += nIdx;
558 :
559 0 : std::vector<SwWrongArea>::iterator i2 = i1;
560 0 : if ( nIdx + nLen >= static_cast<sal_uInt16>(maList.size()) )
561 0 : i2 = maList.end(); // robust
562 : else
563 0 : i2 += nLen;
564 :
565 0 : std::vector<SwWrongArea>::iterator iLoop = i1;
566 0 : while ( iLoop != i2 )
567 : {
568 0 : if ( (*iLoop).mpSubList )
569 0 : delete (*iLoop).mpSubList;
570 0 : ++iLoop;
571 : }
572 :
573 : #if OSL_DEBUG_LEVEL > 0
574 : const int nOldSize = Count();
575 : (void) nOldSize;
576 : #endif
577 :
578 0 : maList.erase(i1, i2);
579 :
580 : #if OSL_DEBUG_LEVEL > 0
581 : OSL_ENSURE( Count() + nLen == nOldSize, "SwWrongList::Remove() trouble" );
582 : #endif
583 : }
584 :
585 0 : void SwWrongList::RemoveEntry( sal_Int32 nBegin, sal_Int32 nEnd ) {
586 0 : sal_uInt16 nDelPos = 0;
587 0 : sal_uInt16 nDel = 0;
588 0 : std::vector<SwWrongArea>::const_iterator aIter(maList.begin()), aEnd(maList.end());
589 0 : while( aIter != aEnd && (*aIter).mnPos < nBegin )
590 : {
591 0 : ++aIter;
592 0 : ++nDelPos;
593 : }
594 0 : if( WRONGLIST_GRAMMAR == GetWrongListType() )
595 : {
596 0 : while( aIter != aEnd && nBegin < nEnd && nEnd > (*aIter).mnPos )
597 : {
598 0 : ++aIter;
599 0 : ++nDel;
600 : }
601 : }
602 : else
603 : {
604 0 : while( aIter != aEnd && nBegin == (*aIter).mnPos && nEnd == (*aIter).mnPos +(*aIter).mnLen )
605 : {
606 0 : ++aIter;
607 0 : ++nDel;
608 : }
609 : }
610 0 : if( nDel )
611 0 : Remove( nDelPos, nDel );
612 0 : }
613 :
614 0 : bool SwWrongList::LookForEntry( sal_Int32 nBegin, sal_Int32 nEnd ) {
615 0 : std::vector<SwWrongArea>::iterator aIter = maList.begin();
616 0 : while( aIter != maList.end() && (*aIter).mnPos < nBegin )
617 0 : ++aIter;
618 0 : if( aIter != maList.end() && nBegin == (*aIter).mnPos && nEnd == (*aIter).mnPos +(*aIter).mnLen )
619 0 : return true;
620 0 : return false;
621 : }
622 :
623 0 : void SwWrongList::Insert( const OUString& rType,
624 : com::sun::star::uno::Reference< com::sun::star::container::XStringKeyMap > xPropertyBag,
625 : sal_Int32 nNewPos, sal_Int32 nNewLen )
626 : {
627 0 : std::vector<SwWrongArea>::iterator aIter = maList.begin();
628 :
629 0 : while ( aIter != maList.end() )
630 : {
631 0 : const sal_Int32 nSTPos = (*aIter).mnPos;
632 :
633 0 : if ( nNewPos < nSTPos )
634 : {
635 : // insert at current position
636 0 : break;
637 : }
638 0 : else if ( nNewPos == nSTPos )
639 : {
640 0 : while ( aIter != maList.end() && (*aIter).mnPos == nSTPos )
641 : {
642 0 : if ( nNewLen < (*aIter).mnLen )
643 : {
644 : // insert at current position
645 0 : break;
646 : }
647 0 : ++aIter;
648 : }
649 0 : break;
650 : }
651 0 : ++aIter;
652 : }
653 :
654 0 : maList.insert(aIter, SwWrongArea( rType, meType, xPropertyBag, nNewPos, nNewLen) );
655 0 : }
656 :
657 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
