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