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 :
22 : #include "SwGrammarMarkUp.hxx"
23 : #include <osl/diagnose.h>
24 :
25 22553035 : SwWrongArea::SwWrongArea( const 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 22553035 : : maType(rType), mxPropertyBag(xPropertyBag), mnPos(nPos), mnLen(nLen), mpSubList(0)
30 : {
31 22553035 : mColor = getWrongAreaColor(listType, xPropertyBag);
32 22553035 : mLineType = getWrongAreaLineType(listType, xPropertyBag);
33 22553035 : }
34 :
35 0 : SwWrongArea::SwWrongArea( const 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 4096 : SwWrongList::SwWrongList( WrongListType eType ) :
50 : meType (eType),
51 : nBeginInvalid(COMPLETE_STRING), // everything correct... (the invalid area starts beyond the string)
52 4096 : nEndInvalid (COMPLETE_STRING)
53 : {
54 4096 : maList.reserve( 5 );
55 4096 : }
56 :
57 12279 : SwWrongList::~SwWrongList()
58 : {
59 4093 : ClearList();
60 8186 : }
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 4093 : void SwWrongList::ClearList()
83 : {
84 4239 : for ( size_t i = 0; i < maList.size(); ++i)
85 : {
86 146 : if (maList[i].mpSubList)
87 0 : delete maList[i].mpSubList;
88 146 : maList[i].mpSubList = NULL;
89 : }
90 4093 : maList.clear();
91 4093 : }
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 sal_uInt16 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 6407 : bool SwWrongList::Check( sal_Int32 &rChk, sal_Int32 &rLn ) const
125 : {
126 6407 : sal_uInt16 nPos = GetWrongPos( rChk );
127 6407 : rLn += rChk;
128 :
129 6407 : if( nPos == Count() )
130 5352 : return false;
131 :
132 1055 : sal_Int32 nWrPos = Pos( nPos );
133 1055 : sal_Int32 nEnd = nWrPos + Len( nPos );
134 1055 : if( nEnd == rChk )
135 : {
136 331 : ++nPos;
137 331 : if( nPos == Count() )
138 12 : return false;
139 :
140 319 : nWrPos = Pos( nPos );
141 319 : nEnd = nWrPos + Len( nPos );
142 : }
143 1043 : if( nEnd > rChk && nWrPos < rLn )
144 : {
145 967 : if( nWrPos > rChk )
146 784 : rChk = nWrPos;
147 967 : if( nEnd < rLn )
148 331 : rLn = nEnd;
149 967 : rLn -= rChk;
150 967 : return 0 != rLn;
151 : }
152 76 : 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 48523942 : sal_uInt16 SwWrongList::GetWrongPos( sal_Int32 nValue ) const
189 : {
190 48523942 : sal_uInt16 nMax = Count();
191 48523942 : sal_uInt16 nMin = 0;
192 :
193 48523942 : 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 22658737 : 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 22658737 : --nMax;
214 22658737 : sal_uInt16 nMid = 0;
215 161549038 : while( nMin <= nMax )
216 : {
217 138785987 : nMid = nMin + ( nMax - nMin ) / 2;
218 138785987 : const sal_Int32 nTmp = Pos( nMid );
219 138785987 : if( nTmp == nValue )
220 : {
221 22553909 : nMin = nMid;
222 22553909 : break;
223 : }
224 116232078 : else if( nTmp < nValue )
225 : {
226 116229614 : if( nTmp + Len( nMid ) >= nValue )
227 : {
228 378 : nMin = nMid;
229 378 : break;
230 : }
231 116229236 : nMin = nMid + 1;
232 : }
233 2464 : else if( nMid == 0 )
234 : {
235 136 : break;
236 : }
237 : else
238 2328 : 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 48523942 : return nMin;
247 : }
248 :
249 281 : void SwWrongList::_Invalidate( sal_Int32 nBegin, sal_Int32 nEnd )
250 : {
251 281 : if ( nBegin < GetBeginInv() )
252 15 : nBeginInvalid = nBegin;
253 281 : if ( nEnd > GetEndInv() || GetEndInv() == COMPLETE_STRING )
254 68 : nEndInvalid = nEnd;
255 281 : }
256 :
257 48520524 : void SwWrongList::SetInvalid( sal_Int32 nBegin, sal_Int32 nEnd )
258 : {
259 48520524 : nBeginInvalid = nBegin;
260 48520524 : nEndInvalid = nEnd;
261 48520524 : }
262 :
263 : /** Change all values after the given position.
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 278 : void SwWrongList::Move( sal_Int32 nPos, sal_Int32 nDiff )
271 : {
272 278 : sal_uInt16 i = GetWrongPos( nPos );
273 278 : if( nDiff < 0 )
274 : {
275 57 : const sal_Int32 nEnd = nPos - nDiff;
276 57 : sal_uInt16 nLst = i;
277 57 : bool bJump = false;
278 230 : while( nLst < Count() && Pos( nLst ) < nEnd )
279 116 : ++nLst;
280 57 : if( nLst > i )
281 : {
282 36 : const sal_Int32 nWrPos = Pos( nLst - 1 );
283 36 : if ( nWrPos <= nPos )
284 : {
285 26 : sal_Int32 nWrLen = Len( nLst - 1 );
286 : // calculate new length of word
287 26 : nWrLen = ( nEnd > nWrPos + nWrLen ) ?
288 : nPos - nWrPos :
289 26 : nWrLen + nDiff;
290 26 : if( nWrLen )
291 : {
292 10 : maList[--nLst].mnLen = nWrLen;
293 10 : bJump = true;
294 : }
295 : }
296 : }
297 57 : Remove( i, nLst - i );
298 :
299 57 : if ( bJump )
300 10 : ++i;
301 57 : if( COMPLETE_STRING == GetBeginInv() )
302 35 : SetInvalid( nPos ? nPos - 1 : nPos, nPos + 1 );
303 : else
304 : {
305 22 : ShiftLeft( nBeginInvalid, nPos, nEnd );
306 22 : if( nEndInvalid != COMPLETE_STRING )
307 22 : ShiftLeft( nEndInvalid, nPos, nEnd );
308 22 : _Invalidate( nPos ? nPos - 1 : nPos, nPos + 1 );
309 : }
310 : }
311 : else
312 : {
313 221 : const sal_Int32 nEnd = nPos + nDiff;
314 221 : if( COMPLETE_STRING != GetBeginInv() )
315 : {
316 163 : if( nBeginInvalid > nPos )
317 1 : nBeginInvalid += nDiff;
318 163 : if( nEndInvalid >= nPos && nEndInvalid != COMPLETE_STRING )
319 163 : nEndInvalid += nDiff;
320 : }
321 : // If the pointer is in the middle of a wrong word,
322 : // invalidation must happen from the beginning of that word.
323 221 : if( i < Count() )
324 : {
325 28 : const sal_Int32 nWrPos = Pos( i );
326 28 : if (nPos >= nWrPos)
327 : {
328 24 : Invalidate( nWrPos, nEnd );
329 24 : const sal_Int32 nWrLen = Len( i ) + nDiff;
330 24 : maList[i++].mnLen = nWrLen;
331 24 : Invalidate( nWrPos, nWrPos + nWrLen );
332 : }
333 : }
334 : else
335 193 : Invalidate( nPos, nEnd );
336 : }
337 575 : while( i < Count() )
338 : {
339 19 : maList[i++].mnPos += nDiff;
340 : }
341 278 : }
342 :
343 : // TODO: Complete documentation
344 : /** Remove given range of entries
345 :
346 : For a given range [nPos, nPos + nLen[ and an index nIndex, this function
347 : basically counts the number of SwWrongArea entries starting with nIndex
348 : up to nPos + nLen. All these entries are removed.
349 :
350 : @param rStart ???
351 : @param rEnd ???
352 : @param nPos starting position of the range
353 : @param nLen length of the range
354 : @param nIndex index to start lookup at
355 : @param nCursorPos ???
356 :
357 : @return <true> if ???
358 : */
359 119581478 : bool SwWrongList::Fresh( sal_Int32 &rStart, sal_Int32 &rEnd, sal_Int32 nPos,
360 : sal_Int32 nLen, sal_uInt16 nIndex, sal_Int32 nCursorPos )
361 : {
362 : // length of word must be greater than 0 and cursor position must be outside the word
363 119581478 : bool bRet = nLen && ( nCursorPos > nPos + nLen || nCursorPos < nPos );
364 :
365 119581478 : sal_Int32 nWrPos = 0;
366 119581478 : sal_Int32 nWrEnd = rEnd;
367 119581478 : sal_uInt16 nCnt = nIndex;
368 119581478 : if( nCnt < Count() )
369 : {
370 22552783 : nWrPos = Pos( nCnt );
371 22552783 : if( nWrPos < nPos && rStart > nWrPos )
372 8 : rStart = nWrPos;
373 : }
374 :
375 239162964 : while( nCnt < Count() )
376 : {
377 22552789 : nWrPos = Pos( nCnt );
378 22552789 : if ( nWrPos >= nPos )
379 22552781 : break;
380 8 : nWrEnd = nWrPos + Len( nCnt++ );
381 : }
382 :
383 119581478 : if( nCnt < Count() && nWrPos == nPos && Len( nCnt ) == nLen )
384 : {
385 22552766 : ++nCnt;
386 22552766 : bRet = true;
387 : }
388 : else
389 : {
390 97028712 : if( bRet )
391 : {
392 269 : if( rStart > nPos )
393 103 : rStart = nPos;
394 269 : nWrEnd = nPos + nLen;
395 : }
396 : }
397 :
398 119581478 : nPos += nLen;
399 :
400 119581478 : if( nCnt < Count() )
401 : {
402 29 : nWrPos = Pos( nCnt );
403 29 : if( nWrPos < nPos && rStart > nWrPos )
404 0 : rStart = nWrPos;
405 : }
406 :
407 239162962 : while( nCnt < Count() )
408 : {
409 32 : nWrPos = Pos( nCnt );
410 32 : if ( nWrPos >= nPos )
411 26 : break;
412 6 : nWrEnd = nWrPos + Len( nCnt++ );
413 : }
414 :
415 119581478 : if( rEnd < nWrEnd )
416 266 : rEnd = nWrEnd;
417 :
418 119581478 : Remove( nIndex, nCnt - nIndex );
419 :
420 119581478 : return bRet;
421 : }
422 :
423 327 : void SwWrongList::Invalidate( sal_Int32 nBegin, sal_Int32 nEnd )
424 : {
425 327 : if (COMPLETE_STRING == GetBeginInv())
426 73 : SetInvalid( nBegin, nEnd );
427 : else
428 254 : _Invalidate( nBegin, nEnd );
429 327 : }
430 :
431 0 : bool SwWrongList::InvalidateWrong( )
432 : {
433 0 : if( Count() )
434 : {
435 0 : const sal_Int32 nFirst = Pos( 0 );
436 0 : const sal_Int32 nLast = Pos( Count() - 1 ) + Len( Count() - 1 );
437 0 : Invalidate( nFirst, nLast );
438 0 : return true;
439 : }
440 0 : return false;
441 : }
442 :
443 10 : SwWrongList* SwWrongList::SplitList( sal_Int32 nSplitPos )
444 : {
445 10 : SwWrongList *pRet = NULL;
446 10 : sal_uInt16 nLst = 0;
447 54 : while( nLst < Count() && Pos( nLst ) < nSplitPos )
448 34 : ++nLst;
449 10 : if( nLst )
450 : {
451 7 : sal_Int32 nWrPos = Pos( nLst - 1 );
452 7 : sal_Int32 nWrLen = Len( nLst - 1 );
453 7 : if ( nWrPos+nWrLen > nSplitPos )
454 : {
455 3 : nWrLen += nWrPos - nSplitPos;
456 3 : maList[--nLst].mnPos = nSplitPos;
457 3 : maList[nLst].mnLen = nWrLen;
458 : }
459 : }
460 10 : if( nLst )
461 : {
462 4 : if( WRONGLIST_GRAMMAR == GetWrongListType() )
463 0 : pRet = new SwGrammarMarkUp();
464 : else
465 4 : pRet = new SwWrongList( GetWrongListType() );
466 4 : pRet->Insert(0, maList.begin(), ( nLst >= maList.size() ? maList.end() : maList.begin() + nLst ) );
467 4 : pRet->SetInvalid( GetBeginInv(), GetEndInv() );
468 4 : pRet->_Invalidate( nSplitPos ? nSplitPos - 1 : nSplitPos, nSplitPos );
469 4 : Remove( 0, nLst );
470 : }
471 10 : if( COMPLETE_STRING == GetBeginInv() )
472 9 : SetInvalid( 0, 1 );
473 : else
474 : {
475 1 : ShiftLeft( nBeginInvalid, 0, nSplitPos );
476 1 : if( nEndInvalid != COMPLETE_STRING )
477 1 : ShiftLeft( nEndInvalid, 0, nSplitPos );
478 1 : _Invalidate( 0, 1 );
479 : }
480 21 : for (nLst = 0; nLst < Count(); ++nLst )
481 : {
482 11 : maList[nLst].mnPos -= nSplitPos;
483 : }
484 10 : return pRet;
485 : }
486 :
487 10 : void SwWrongList::JoinList( SwWrongList* pNext, sal_Int32 nInsertPos )
488 : {
489 : if (pNext)
490 : {
491 : OSL_ENSURE( GetWrongListType() == pNext->GetWrongListType(), "type mismatch with next list" );
492 : }
493 10 : if( pNext )
494 : {
495 9 : sal_uInt16 nCnt = Count();
496 9 : pNext->Move( 0, nInsertPos );
497 9 : Insert(nCnt, pNext->maList.begin(), pNext->maList.end());
498 :
499 9 : Invalidate( pNext->GetBeginInv(), pNext->GetEndInv() );
500 9 : if( nCnt && Count() > nCnt )
501 : {
502 0 : sal_Int32 nWrPos = Pos( nCnt );
503 0 : sal_Int32 nWrLen = Len( nCnt );
504 0 : if( !nWrPos )
505 : {
506 0 : nWrPos += nInsertPos;
507 0 : nWrLen -= nInsertPos;
508 0 : maList[nCnt].mnPos = nWrPos;
509 0 : maList[nCnt].mnLen = nWrLen;
510 : }
511 0 : if( nWrPos == Pos( nCnt - 1 ) + Len( nCnt - 1 ) )
512 : {
513 0 : nWrLen += Len( nCnt - 1 );
514 0 : maList[nCnt - 1].mnLen = nWrLen;
515 0 : Remove( nCnt, 1 );
516 : }
517 : }
518 : }
519 10 : Invalidate( nInsertPos ? nInsertPos - 1 : nInsertPos, nInsertPos + 1 );
520 10 : }
521 :
522 0 : void SwWrongList::InsertSubList( sal_Int32 nNewPos, sal_Int32 nNewLen, sal_uInt16 nWhere, SwWrongList* pSubList )
523 : {
524 : if (pSubList)
525 : {
526 : OSL_ENSURE( GetWrongListType() == pSubList->GetWrongListType(), "type mismatch with sub list" );
527 : }
528 0 : std::vector<SwWrongArea>::iterator i = maList.begin();
529 0 : if ( nWhere >= maList.size() )
530 0 : i = maList.end(); // robust
531 : else
532 0 : i += nWhere;
533 0 : maList.insert(i, SwWrongArea( OUString(), 0, nNewPos, nNewLen, pSubList ) );
534 0 : }
535 :
536 : // New functions: Necessary because SwWrongList has been changed to use std::vector
537 13 : void SwWrongList::Insert(sal_uInt16 nWhere, std::vector<SwWrongArea>::iterator startPos, std::vector<SwWrongArea>::iterator endPos)
538 : {
539 13 : std::vector<SwWrongArea>::iterator i = maList.begin();
540 13 : if ( nWhere >= maList.size() )
541 13 : i = maList.end(); // robust
542 : else
543 0 : i += nWhere;
544 13 : maList.insert(i, startPos, endPos); // insert [startPos, endPos[ before i
545 :
546 : // ownership of the sublist is passed to maList, therefore we have to set the
547 : // pSubList-Pointers to 0
548 57 : while ( startPos != endPos )
549 : {
550 31 : (*startPos).mpSubList = 0;
551 31 : ++startPos;
552 : }
553 13 : }
554 :
555 119581539 : void SwWrongList::Remove(sal_uInt16 nIdx, sal_uInt16 nLen )
556 : {
557 239163078 : if ( nIdx >= maList.size() ) return;
558 22552823 : std::vector<SwWrongArea>::iterator i1 = maList.begin();
559 22552823 : i1 += nIdx;
560 :
561 22552823 : std::vector<SwWrongArea>::iterator i2 = i1;
562 22552823 : if ( nIdx + nLen >= static_cast<sal_uInt16>(maList.size()) )
563 22552787 : i2 = maList.end(); // robust
564 : else
565 36 : i2 += nLen;
566 :
567 22552823 : std::vector<SwWrongArea>::iterator iLoop = i1;
568 67658563 : while ( iLoop != i2 )
569 : {
570 22552917 : if ( (*iLoop).mpSubList )
571 0 : delete (*iLoop).mpSubList;
572 22552917 : ++iLoop;
573 : }
574 :
575 : #if OSL_DEBUG_LEVEL > 0
576 : const int nOldSize = Count();
577 : (void) nOldSize;
578 : #endif
579 :
580 22552823 : maList.erase(i1, i2);
581 :
582 : #if OSL_DEBUG_LEVEL > 0
583 : OSL_ENSURE( Count() + nLen == nOldSize, "SwWrongList::Remove() trouble" );
584 : #endif
585 : }
586 :
587 0 : void SwWrongList::RemoveEntry( sal_Int32 nBegin, sal_Int32 nEnd ) {
588 0 : sal_uInt16 nDelPos = 0;
589 0 : sal_uInt16 nDel = 0;
590 0 : std::vector<SwWrongArea>::const_iterator aIter(maList.begin()), aEnd(maList.end());
591 0 : while( aIter != aEnd && (*aIter).mnPos < nBegin )
592 : {
593 0 : ++aIter;
594 0 : ++nDelPos;
595 : }
596 0 : if( WRONGLIST_GRAMMAR == GetWrongListType() )
597 : {
598 0 : while( aIter != aEnd && nBegin < nEnd && nEnd > (*aIter).mnPos )
599 : {
600 0 : ++aIter;
601 0 : ++nDel;
602 : }
603 : }
604 : else
605 : {
606 0 : while( aIter != aEnd && nBegin == (*aIter).mnPos && nEnd == (*aIter).mnPos +(*aIter).mnLen )
607 : {
608 0 : ++aIter;
609 0 : ++nDel;
610 : }
611 : }
612 0 : if( nDel )
613 0 : Remove( nDelPos, nDel );
614 0 : }
615 :
616 0 : bool SwWrongList::LookForEntry( sal_Int32 nBegin, sal_Int32 nEnd ) {
617 0 : std::vector<SwWrongArea>::iterator aIter = maList.begin();
618 0 : while( aIter != maList.end() && (*aIter).mnPos < nBegin )
619 0 : ++aIter;
620 0 : if( aIter != maList.end() && nBegin == (*aIter).mnPos && nEnd == (*aIter).mnPos +(*aIter).mnLen )
621 0 : return true;
622 0 : return false;
623 : }
624 :
625 0 : void SwWrongList::Insert( const OUString& rType,
626 : com::sun::star::uno::Reference< com::sun::star::container::XStringKeyMap > xPropertyBag,
627 : sal_Int32 nNewPos, sal_Int32 nNewLen )
628 : {
629 0 : std::vector<SwWrongArea>::iterator aIter = maList.begin();
630 :
631 0 : while ( aIter != maList.end() )
632 : {
633 0 : const sal_Int32 nSTPos = (*aIter).mnPos;
634 :
635 0 : if ( nNewPos < nSTPos )
636 : {
637 : // insert at current position
638 0 : break;
639 : }
640 0 : else if ( nNewPos == nSTPos )
641 : {
642 0 : while ( aIter != maList.end() && (*aIter).mnPos == nSTPos )
643 : {
644 0 : if ( nNewLen < (*aIter).mnLen )
645 : {
646 : // insert at current position
647 0 : break;
648 : }
649 0 : ++aIter;
650 : }
651 0 : break;
652 : }
653 0 : ++aIter;
654 : }
655 :
656 0 : maList.insert(aIter, SwWrongArea( rType, meType, xPropertyBag, nNewPos, nNewLen) );
657 0 : }
658 :
659 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
