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_tools.hxx"
26
27 #define _SV_MULTISEL_CXX
28
29 #ifdef MI_DEBUG
30 #define private public
31 #include <stdio.h>
32 #endif
33
34 #include <tools/debug.hxx>
35 #include <tools/multisel.hxx>
36
37 #include "rtl/ustrbuf.hxx"
38
39 #ifdef MI_DEBUG
40 #define DBG(x) x
41 #else
42 #define DBG(x)
43 #endif
44
45 using namespace rtl;
46
47 //==================================================================
48
49 #ifdef MI_DEBUG
50
Print(const MultiSelection * pSel)51 static void Print( const MultiSelection* pSel )
52 {
53 DbgOutf( "TotRange: %4ld-%4ld\n",
54 pSel->aTotRange.Min(), pSel->aTotRange.Max() );
55 if ( pSel->bCurValid )
56 {
57 DbgOutf( "CurSubSel: %4ld\n", pSel->nCurSubSel );
58 DbgOutf( "CurIndex: %4ld\n", pSel->nCurIndex );
59 }
60 DbgOutf( "SelCount: %4ld\n", pSel->nSelCount );
61 DbgOutf( "SubCount: %4ld\n", pSel->aSels.Count() );
62 for ( sal_uIntPtr nPos = 0; nPos < pSel->aSels.Count(); ++nPos )
63 {
64 DbgOutf( "SubSel #%2ld: %4ld-%4ld\n", nPos,
65 pSel->aSels.GetObject(nPos)->Min(),
66 pSel->aSels.GetObject(nPos)->Max() );
67 }
68 DbgOutf( "\n" );
69 fclose( pFile );
70 }
71
72 #endif
73
74 // -----------------------------------------------------------------------
75
ImplClear()76 void MultiSelection::ImplClear()
77 {
78 // no selected indexes
79 nSelCount = 0;
80
81 Range* pRange = aSels.First();
82 while ( pRange )
83 {
84 delete pRange;
85 pRange = aSels.Next();
86 }
87 aSels.Clear();
88 }
89
90 // -----------------------------------------------------------------------
91
ImplFindSubSelection(long nIndex) const92 sal_uIntPtr MultiSelection::ImplFindSubSelection( long nIndex ) const
93 {
94 // iterate through the sub selections
95 sal_uIntPtr n = 0;
96 for ( ;
97 n < aSels.Count() && nIndex > aSels.GetObject(n)->Max();
98 ++n ) {} /* empty loop */
99 return n;
100 }
101
102 // -----------------------------------------------------------------------
103
ImplMergeSubSelections(sal_uIntPtr nPos1,sal_uIntPtr nPos2)104 sal_Bool MultiSelection::ImplMergeSubSelections( sal_uIntPtr nPos1, sal_uIntPtr nPos2 )
105 {
106 // didn't a sub selection at nPos2 exist?
107 if ( nPos2 >= aSels.Count() )
108 return sal_False;
109
110 // did the sub selections touch each other?
111 if ( (aSels.GetObject(nPos1)->Max() + 1) == aSels.GetObject(nPos2)->Min() )
112 {
113 // merge them
114 aSels.GetObject(nPos1)->Max() = aSels.GetObject(nPos2)->Max();
115 delete aSels.Remove(nPos2);
116 return sal_True;
117 }
118
119 return sal_False;
120 }
121
122 // -----------------------------------------------------------------------
123
MultiSelection()124 MultiSelection::MultiSelection():
125 aTotRange( 0, -1 ),
126 nCurSubSel(0),
127 nSelCount(0),
128 bCurValid(sal_False),
129 bSelectNew(sal_False)
130 {
131 }
132
133 // -----------------------------------------------------------------------
134
MultiSelection(const UniString & rString,sal_Unicode cRange,sal_Unicode cSep)135 MultiSelection::MultiSelection( const UniString& rString, sal_Unicode cRange, sal_Unicode cSep ):
136 aTotRange(0,RANGE_MAX),
137 nCurSubSel(0),
138 nSelCount(0),
139 bCurValid(sal_False),
140 bSelectNew(sal_False)
141 {
142 // Dies ist nur ein Schnellschuss und sollte bald optimiert,
143 // an die verschiedenen Systeme (UNIX etc.)
144 // und die gewuenschte Eingabe-Syntax angepasst werden.
145
146 UniString aStr( rString );
147 sal_Unicode* pStr = aStr.GetBufferAccess();
148 sal_Unicode* pOld = pStr;
149 sal_Bool bReady = sal_False;
150 sal_Bool bUntil = sal_False;
151 xub_StrLen nCut = 0;
152
153 // Hier normieren wir den String, sodass nur Ziffern,
154 // Semikola als Trenn- und Minus als VonBis-Zeichen
155 // uebrigbleiben, z.B. "99-117;55;34;-17;37-43"
156 while ( *pOld )
157 {
158 switch( *pOld )
159 {
160 case '0':
161 case '1':
162 case '2':
163 case '3':
164 case '4':
165 case '5':
166 case '6':
167 case '7':
168 case '8':
169 case '9':
170 DBG_ASSERT( *pOld != cRange, "digit for range char not allowed" );
171 DBG_ASSERT( *pOld != cSep, "digit for separator not allowed" );
172 if( bReady )
173 {
174 *pStr++ = ';';
175 nCut++;
176 bReady = sal_False;
177 }
178 *pStr++ = *pOld;
179 nCut++;
180 bUntil = sal_False;
181 break;
182
183 case '-':
184 case ':':
185 case '/':
186 if ( *pOld != cSep )
187 {
188 if ( !bUntil )
189 {
190 *pStr++ = '-';
191 nCut++;
192 bUntil = sal_True;
193 }
194 bReady = sal_False;
195 }
196 else
197 bReady = sal_True;
198 break;
199
200 case ' ':
201 DBG_ASSERT( *pOld != cRange, "SPACE for range char not allowed" );
202 DBG_ASSERT( *pOld != cSep, "SPACE for separator not allowed" );
203 bReady = !bUntil;
204 break;
205
206 default:
207 if ( *pOld == cRange )
208 {
209 if ( !bUntil )
210 {
211 *pStr++ = '-';
212 nCut++;
213 bUntil = sal_True;
214 }
215 bReady = sal_False;
216 }
217 else
218 bReady = sal_True;
219 break;
220 }
221
222 pOld++;
223 }
224 aStr.ReleaseBufferAccess( nCut );
225
226 // Jetzt wird der normierte String ausgewertet ..
227 UniString aNumStr;
228 Range aRg( 1, RANGE_MAX );
229 const sal_Unicode* pCStr = aStr.GetBuffer();
230 long nPage = 1;
231 long nNum = 1;
232 bUntil = sal_False;
233 while ( *pCStr )
234 {
235 switch ( *pCStr )
236 {
237 case '0':
238 case '1':
239 case '2':
240 case '3':
241 case '4':
242 case '5':
243 case '6':
244 case '7':
245 case '8':
246 case '9':
247 aNumStr += *pCStr;
248 break;
249 case ';':
250 nNum = aNumStr.ToInt32();
251 if ( bUntil )
252 {
253 if ( !aNumStr.Len() )
254 nNum = RANGE_MAX;
255 aRg.Min() = nPage;
256 aRg.Max() = nNum;
257 aRg.Justify();
258 Select( aRg );
259 }
260 else
261 Select( nNum );
262 nPage = 0;
263 aNumStr.Erase();
264 bUntil = sal_False;
265 break;
266
267 case '-':
268 nPage = aNumStr.ToInt32();
269 aNumStr.Erase();
270 bUntil = sal_True;
271 break;
272 }
273
274 pCStr++;
275 }
276
277 nNum = aNumStr.ToInt32();
278 if ( bUntil )
279 {
280 if ( !aNumStr.Len() )
281 nNum = RANGE_MAX;
282 aRg.Min() = nPage;
283 aRg.Max() = nNum;
284 aRg.Justify();
285 Select( aRg );
286 }
287 else
288 Select( nNum );
289 }
290
291 // -----------------------------------------------------------------------
292
MultiSelection(const MultiSelection & rOrig)293 MultiSelection::MultiSelection( const MultiSelection& rOrig ) :
294 aTotRange(rOrig.aTotRange),
295 nSelCount(rOrig.nSelCount),
296 bCurValid(rOrig.bCurValid),
297 bSelectNew(sal_False)
298 {
299 if ( bCurValid )
300 {
301 nCurSubSel = rOrig.nCurSubSel;
302 nCurIndex = rOrig.nCurIndex;
303 }
304
305 // copy the sub selections
306 for ( sal_uIntPtr n = 0; n < rOrig.aSels.Count(); ++n )
307 aSels.Insert( new Range( *rOrig.aSels.GetObject(n) ), LIST_APPEND );
308 }
309
310 // -----------------------------------------------------------------------
311
MultiSelection(const Range & rRange)312 MultiSelection::MultiSelection( const Range& rRange ):
313 aTotRange(rRange),
314 nCurSubSel(0),
315 nSelCount(0),
316 bCurValid(sal_False),
317 bSelectNew(sal_False)
318 {
319 }
320
321 // -----------------------------------------------------------------------
322
~MultiSelection()323 MultiSelection::~MultiSelection()
324 {
325 Range* pRange = aSels.First();
326 while ( pRange )
327 {
328 delete pRange;
329 pRange = aSels.Next();
330 }
331 }
332
333 // -----------------------------------------------------------------------
334
operator =(const MultiSelection & rOrig)335 MultiSelection& MultiSelection::operator= ( const MultiSelection& rOrig )
336 {
337 aTotRange = rOrig.aTotRange;
338 bCurValid = rOrig.bCurValid;
339 if ( bCurValid )
340 {
341 nCurSubSel = rOrig.nCurSubSel;
342 nCurIndex = rOrig.nCurIndex;
343 }
344
345 // clear the old and copy the sub selections
346 ImplClear();
347 for ( sal_uIntPtr n = 0; n < rOrig.aSels.Count(); ++n )
348 aSels.Insert( new Range( *rOrig.aSels.GetObject(n) ), LIST_APPEND );
349 nSelCount = rOrig.nSelCount;
350
351 return *this;
352 }
353
354 // -----------------------------------------------------------------------
355
operator ==(MultiSelection & rWith)356 sal_Bool MultiSelection::operator== ( MultiSelection& rWith )
357 {
358 if ( aTotRange != rWith.aTotRange || nSelCount != rWith.nSelCount ||
359 aSels.Count() != rWith.aSels.Count() )
360 return sal_False;
361
362 // compare the sub seletions
363 for ( sal_uIntPtr n = 0; n < aSels.Count(); ++n )
364 if ( *aSels.GetObject(n) != *rWith.aSels.GetObject(n) )
365 return sal_False;
366 return sal_True;
367 }
368
369 // -----------------------------------------------------------------------
370
SelectAll(sal_Bool bSelect)371 void MultiSelection::SelectAll( sal_Bool bSelect )
372 {
373 DBG(DbgOutf( "::SelectAll(%s)\n", bSelect ? "sal_True" : "sal_False" ));
374
375 ImplClear();
376 if ( bSelect )
377 {
378 aSels.Insert( new Range(aTotRange), LIST_APPEND );
379 nSelCount = aTotRange.Len();
380 }
381
382 DBG(Print( this ));
383 }
384
385 // -----------------------------------------------------------------------
386
Select(long nIndex,sal_Bool bSelect)387 sal_Bool MultiSelection::Select( long nIndex, sal_Bool bSelect )
388 {
389 DBG_ASSERT( aTotRange.IsInside(nIndex), "selected index out of range" );
390
391 // out of range?
392 if ( !aTotRange.IsInside(nIndex) )
393 return sal_False;
394
395 // find the virtual target position
396 sal_uIntPtr nSubSelPos = ImplFindSubSelection( nIndex );
397
398 if ( bSelect )
399 {
400 // is it included in the found sub selection?
401 if ( nSubSelPos < aSels.Count() &&
402 aSels.GetObject(nSubSelPos)->IsInside( nIndex ) )
403 // already selected, nothing to do
404 return sal_False;
405
406 // it will become selected
407 ++nSelCount;
408
409 // is it at the end of the previous sub selection
410 if ( nSubSelPos > 0 &&
411 aSels.GetObject(nSubSelPos-1)->Max() == (nIndex-1) )
412 {
413 // expand the previous sub selection
414 aSels.GetObject(nSubSelPos-1)->Max() = nIndex;
415
416 // try to merge the previous sub selection
417 ImplMergeSubSelections( nSubSelPos-1, nSubSelPos );
418 }
419 // is is at the beginning of the found sub selection
420 else if ( nSubSelPos < aSels.Count() &&
421 aSels.GetObject(nSubSelPos)->Min() == (nIndex+1) )
422 // expand the found sub selection
423 aSels.GetObject(nSubSelPos)->Min() = nIndex;
424 else
425 {
426 // create a new sub selection
427 aSels.Insert( new Range( nIndex, nIndex ), nSubSelPos );
428 if ( bCurValid && nCurSubSel >= nSubSelPos )
429 ++nCurSubSel;
430 }
431 }
432 else
433 {
434 // is it excluded from the found sub selection?
435 if ( nSubSelPos >= aSels.Count() ||
436 !aSels.GetObject(nSubSelPos)->IsInside( nIndex ) )
437 {
438 // not selected, nothing to do
439 DBG(Print( this ));
440 return sal_False;
441 }
442
443 // it will become deselected
444 --nSelCount;
445
446 // is it the only index in the found sub selection?
447 if ( aSels.GetObject(nSubSelPos)->Len() == 1 )
448 {
449 // remove the complete sub selection
450 delete aSels.Remove( nSubSelPos );
451 DBG(Print( this ));
452 return sal_True;
453 }
454
455 // is it at the beginning of the found sub selection?
456 if ( aSels.GetObject(nSubSelPos)->Min() == nIndex )
457 ++aSels.GetObject(nSubSelPos)->Min();
458 // is it at the end of the found sub selection?
459 else if ( aSels.GetObject(nSubSelPos)->Max() == nIndex )
460 --aSels.GetObject(nSubSelPos)->Max();
461 // it is in the middle of the found sub selection?
462 else
463 {
464 // split the sub selection
465 aSels.Insert(
466 new Range( aSels.GetObject(nSubSelPos)->Min(), nIndex-1 ),
467 nSubSelPos );
468 aSels.GetObject(nSubSelPos+1)->Min() = nIndex + 1;
469 }
470 }
471
472 DBG(Print( this ));
473
474 return sal_True;
475 }
476
477 // -----------------------------------------------------------------------
478
Select(const Range & rIndexRange,sal_Bool bSelect)479 void MultiSelection::Select( const Range& rIndexRange, sal_Bool bSelect )
480 {
481 Range* pRange;
482 long nOld;
483
484 sal_uIntPtr nTmpMin = rIndexRange.Min();
485 sal_uIntPtr nTmpMax = rIndexRange.Max();
486 sal_uIntPtr nCurMin = FirstSelected();
487 sal_uIntPtr nCurMax = LastSelected();
488 DBG_ASSERT(aTotRange.IsInside(nTmpMax), "selected index out of range" );
489 DBG_ASSERT(aTotRange.IsInside(nTmpMin), "selected index out of range" );
490
491 // gesamte Selektion ersetzen ?
492 if( nTmpMin <= nCurMin && nTmpMax >= nCurMax )
493 {
494 ImplClear();
495 if ( bSelect )
496 {
497 aSels.Insert( new Range(rIndexRange), LIST_APPEND );
498 nSelCount = rIndexRange.Len();
499 }
500 return;
501 }
502 // links erweitern ?
503 if( nTmpMax < nCurMin )
504 {
505 if( bSelect )
506 {
507 // ersten Range erweitern ?
508 if( nCurMin > (nTmpMax+1) )
509 {
510 pRange = new Range( rIndexRange );
511 aSels.Insert( pRange, (sal_uIntPtr)0 );
512 nSelCount += pRange->Len();
513 }
514 else
515 {
516 pRange = aSels.First();
517 nOld = pRange->Min();
518 pRange->Min() = (long)nTmpMin;
519 nSelCount += ( nOld - nTmpMin );
520 }
521 bCurValid = sal_False;
522 }
523 return;
524 }
525 // rechts erweitern ?
526 else if( nTmpMin > nCurMax )
527 {
528 if( bSelect )
529 {
530 // letzten Range erweitern ?
531 if( nTmpMin > (nCurMax+1) )
532 {
533 pRange = new Range( rIndexRange );
534 aSels.Insert( pRange, LIST_APPEND );
535 nSelCount += pRange->Len();
536 }
537 else
538 {
539 pRange = aSels.Last();
540 nOld = pRange->Max();
541 pRange->Max() = (long)nTmpMax;
542 nSelCount += ( nTmpMax - nOld );
543 }
544 bCurValid = sal_False;
545 }
546 return;
547 }
548
549 //HACK(Hier muss noch optimiert werden)
550 while( nTmpMin <= nTmpMax )
551 {
552 Select( nTmpMin, bSelect );
553 nTmpMin++;
554 }
555 }
556
557 // -----------------------------------------------------------------------
558
IsSelected(long nIndex) const559 sal_Bool MultiSelection::IsSelected( long nIndex ) const
560 {
561 // find the virtual target position
562 sal_uIntPtr nSubSelPos = ImplFindSubSelection( nIndex );
563
564 return nSubSelPos < aSels.Count() &&
565 aSels.GetObject(nSubSelPos)->IsInside(nIndex);
566 }
567
568 // -----------------------------------------------------------------------
569
Insert(long nIndex,long nCount)570 void MultiSelection::Insert( long nIndex, long nCount )
571 {
572 DBG(DbgOutf( "::Insert(%ld, %ld)\n", nIndex, nCount ));
573
574 // find the virtual target position
575 sal_uIntPtr nSubSelPos = ImplFindSubSelection( nIndex );
576
577 // did we need to shift the sub selections?
578 if ( nSubSelPos < aSels.Count() )
579 {
580 // did we insert an unselected into an existing sub selection?
581 if ( !bSelectNew && aSels.GetObject(nSubSelPos)->Min() != nIndex &&
582 aSels.GetObject(nSubSelPos)->IsInside(nIndex) )
583 {
584 // split the sub selection
585 aSels.Insert(
586 new Range( aSels.GetObject(nSubSelPos)->Min(), nIndex-1 ),
587 nSubSelPos );
588 ++nSubSelPos;
589 aSels.GetObject(nSubSelPos)->Min() = nIndex;
590 }
591
592 // did we append an selected to an existing sub selection?
593 else if ( bSelectNew && nSubSelPos > 0 &&
594 aSels.GetObject(nSubSelPos)->Max() == nIndex-1 )
595 // expand the previous sub selection
596 aSels.GetObject(nSubSelPos-1)->Max() += nCount;
597
598 // did we insert an selected into an existing sub selection?
599 else if ( bSelectNew && aSels.GetObject(nSubSelPos)->Min() == nIndex )
600 {
601 // expand the sub selection
602 aSels.GetObject(nSubSelPos)->Max() += nCount;
603 ++nSubSelPos;
604 }
605
606 // shift the sub selections behind the inserting position
607 for ( sal_uIntPtr nPos = nSubSelPos; nPos < aSels.Count(); ++nPos )
608 {
609 aSels.GetObject(nPos)->Min() += nCount;
610 aSels.GetObject(nPos)->Max() += nCount;
611 }
612 }
613
614 bCurValid = sal_False;
615 aTotRange.Max() += nCount;
616 if ( bSelectNew )
617 nSelCount += nCount;
618
619 DBG(Print( this ));
620 }
621
622 // -----------------------------------------------------------------------
623
Remove(long nIndex)624 void MultiSelection::Remove( long nIndex )
625 {
626 DBG(DbgOutf( "::Remove(%ld)\n", nIndex ));
627
628 // find the virtual target position
629 sal_uIntPtr nSubSelPos = ImplFindSubSelection( nIndex );
630
631 // did we remove from an existing sub selection?
632 if ( nSubSelPos < aSels.Count() &&
633 aSels.GetObject(nSubSelPos)->IsInside(nIndex) )
634 {
635 // does this sub selection only contain the index to be deleted
636 if ( aSels.GetObject(nSubSelPos)->Len() == 1 )
637 // completely remove the sub selection
638 aSels.Remove(nSubSelPos);
639 else
640 // shorten this sub selection
641 --( aSels.GetObject(nSubSelPos++)->Max() );
642
643 // adjust the selected counter
644 --nSelCount;
645 }
646
647 // shift the sub selections behind the removed index
648 for ( sal_uIntPtr nPos = nSubSelPos; nPos < aSels.Count(); ++nPos )
649 {
650 --( aSels.GetObject(nPos)->Min() );
651 --( aSels.GetObject(nPos)->Max() );
652 }
653
654 bCurValid = sal_False;
655 aTotRange.Max() -= 1;
656
657 DBG(Print( this ));
658 }
659
660 // -----------------------------------------------------------------------
661
Append(long nCount)662 void MultiSelection::Append( long nCount )
663 {
664 long nPrevLast = aTotRange.Max();
665 aTotRange.Max() += nCount;
666 if ( bSelectNew )
667 {
668 nSelCount += nCount;
669 aSels.Insert( new Range( nPrevLast+1, nPrevLast + nCount ),
670 LIST_APPEND );
671 if ( aSels.Count() > 1 )
672 ImplMergeSubSelections( aSels.Count() - 2, aSels.Count() );
673 }
674 }
675
676 // -----------------------------------------------------------------------
677
ImplFwdUnselected()678 long MultiSelection::ImplFwdUnselected()
679 {
680 if ( !bCurValid )
681 return SFX_ENDOFSELECTION;
682
683 if ( ( nCurSubSel < aSels.Count() ) &&
684 ( aSels.GetObject(nCurSubSel)->Min() <= nCurIndex ) )
685 nCurIndex = aSels.GetObject(nCurSubSel++)->Max() + 1;
686
687 if ( nCurIndex <= aTotRange.Max() )
688 return nCurIndex;
689 else
690 return SFX_ENDOFSELECTION;
691 }
692
693 // -----------------------------------------------------------------------
694
ImplBwdUnselected()695 long MultiSelection::ImplBwdUnselected()
696 {
697 if ( !bCurValid )
698 return SFX_ENDOFSELECTION;
699
700 if ( aSels.GetObject(nCurSubSel)->Max() < nCurIndex )
701 return nCurIndex;
702
703 nCurIndex = aSels.GetObject(nCurSubSel--)->Min() - 1;
704 if ( nCurIndex >= 0 )
705 return nCurIndex;
706 else
707 return SFX_ENDOFSELECTION;
708 }
709
710 // -----------------------------------------------------------------------
711
FirstSelected(sal_Bool bInverse)712 long MultiSelection::FirstSelected( sal_Bool bInverse )
713 {
714 bInverseCur = bInverse;
715 nCurSubSel = 0;
716
717 if ( bInverseCur )
718 {
719 bCurValid = nSelCount < sal_uIntPtr(aTotRange.Len());
720 if ( bCurValid )
721 {
722 nCurIndex = 0;
723 return ImplFwdUnselected();
724 }
725 }
726 else
727 {
728 bCurValid = aSels.Count() > 0;
729 if ( bCurValid )
730 return nCurIndex = aSels.GetObject(0)->Min();
731 }
732
733 return SFX_ENDOFSELECTION;
734 }
735
736 // -----------------------------------------------------------------------
737
LastSelected()738 long MultiSelection::LastSelected()
739 {
740 nCurSubSel = aSels.Count() - 1;
741 bCurValid = aSels.Count() > 0;
742
743 if ( bCurValid )
744 return nCurIndex = aSels.GetObject(nCurSubSel)->Max();
745
746 return SFX_ENDOFSELECTION;
747 }
748
749 // -----------------------------------------------------------------------
750
NextSelected()751 long MultiSelection::NextSelected()
752 {
753 if ( !bCurValid )
754 return SFX_ENDOFSELECTION;
755
756 if ( bInverseCur )
757 {
758 ++nCurIndex;
759 return ImplFwdUnselected();
760 }
761 else
762 {
763 // is the next index in the current sub selection too?
764 if ( nCurIndex < aSels.GetObject(nCurSubSel)->Max() )
765 return ++nCurIndex;
766
767 // are there further sub selections?
768 if ( ++nCurSubSel < aSels.Count() )
769 return nCurIndex = aSels.GetObject(nCurSubSel)->Min();
770
771 // we are at the end!
772 return SFX_ENDOFSELECTION;
773 }
774 }
775
776 // -----------------------------------------------------------------------
777
PrevSelected()778 long MultiSelection::PrevSelected()
779 {
780 if ( !bCurValid )
781 return SFX_ENDOFSELECTION;
782
783 if ( bInverseCur )
784 {
785 --nCurIndex;
786 return ImplBwdUnselected();
787 }
788 else
789 {
790 // is the previous index in the current sub selection too?
791 if ( nCurIndex > aSels.GetObject(nCurSubSel)->Min() )
792 return --nCurIndex;
793
794 // are there previous sub selections?
795 if ( nCurSubSel > 0 )
796 {
797 --nCurSubSel;
798 return nCurIndex = aSels.GetObject(nCurSubSel)->Max();
799 }
800
801 // we are at the beginning!
802 return SFX_ENDOFSELECTION;
803 }
804 }
805
806 // -----------------------------------------------------------------------
807
SetTotalRange(const Range & rTotRange)808 void MultiSelection::SetTotalRange( const Range& rTotRange )
809 {
810 aTotRange = rTotRange;
811
812 // die untere Bereichsgrenze anpassen
813 Range* pRange = aSels.GetObject( 0 );
814 while( pRange )
815 {
816 if( pRange->Max() < aTotRange.Min() )
817 {
818 delete pRange;
819 aSels.Remove( (sal_uIntPtr)0 );
820 }
821 else if( pRange->Min() < aTotRange.Min() )
822 {
823 pRange->Min() = aTotRange.Min();
824 break;
825 }
826 else
827 break;
828
829 pRange = aSels.GetObject( 0 );
830 }
831
832 // die obere Bereichsgrenze anpassen
833 sal_uIntPtr nCount = aSels.Count();
834 while( nCount )
835 {
836 pRange = aSels.GetObject( nCount - 1 );
837 if( pRange->Min() > aTotRange.Max() )
838 {
839 delete pRange;
840 aSels.Remove( (sal_uIntPtr)(nCount - 1) );
841 }
842 else if( pRange->Max() > aTotRange.Max() )
843 {
844 pRange->Max() = aTotRange.Max();
845 break;
846 }
847 else
848 break;
849
850 nCount = aSels.Count();
851 }
852
853 // Selection-Count neu berechnen
854 nSelCount = 0;
855 pRange = aSels.First();
856 while( pRange )
857 {
858 nSelCount += pRange->Len();
859 pRange = aSels.Next();
860 }
861
862 bCurValid = sal_False;
863 nCurIndex = 0;
864 }
865
866 // -----------------------------------------------------------------------
867 //
868 // StringRangeEnumerator
869 //
870 // -----------------------------------------------------------------------
StringRangeEnumerator(const rtl::OUString & i_rInput,sal_Int32 i_nMinNumber,sal_Int32 i_nMaxNumber,sal_Int32 i_nLogicalOffset)871 StringRangeEnumerator::StringRangeEnumerator( const rtl::OUString& i_rInput,
872 sal_Int32 i_nMinNumber,
873 sal_Int32 i_nMaxNumber,
874 sal_Int32 i_nLogicalOffset
875 )
876 : mnCount( 0 )
877 , mnMin( i_nMinNumber )
878 , mnMax( i_nMaxNumber )
879 , mnOffset( i_nLogicalOffset )
880 {
881 setRange( i_rInput );
882 }
883
checkValue(sal_Int32 i_nValue,const std::set<sal_Int32> * i_pPossibleValues) const884 bool StringRangeEnumerator::checkValue( sal_Int32 i_nValue, const std::set< sal_Int32 >* i_pPossibleValues ) const
885 {
886 if( mnMin >= 0 && i_nValue < mnMin )
887 return false;
888 if( mnMax >= 0 && i_nValue > mnMax )
889 return false;
890 if( i_nValue < 0 )
891 return false;
892 if( i_pPossibleValues && i_pPossibleValues->find( i_nValue ) == i_pPossibleValues->end() )
893 return false;
894 return true;
895 }
896
insertRange(sal_Int32 i_nFirst,sal_Int32 i_nLast,bool bSequence,bool bMayAdjust)897 bool StringRangeEnumerator::insertRange( sal_Int32 i_nFirst, sal_Int32 i_nLast, bool bSequence, bool bMayAdjust )
898 {
899 bool bSuccess = true;
900 if( bSequence )
901 {
902 if( i_nFirst == -1 )
903 i_nFirst = mnMin;
904 if( i_nLast == -1 )
905 i_nLast = mnMax;
906 if( bMayAdjust )
907 {
908 if( i_nFirst < mnMin )
909 i_nFirst = mnMin;
910 if( i_nFirst > mnMax )
911 i_nFirst = mnMax;
912 if( i_nLast < mnMin )
913 i_nLast = mnMin;
914 if( i_nLast > mnMax )
915 i_nLast = mnMax;
916 }
917 if( checkValue( i_nFirst ) && checkValue( i_nLast ) )
918 {
919 maSequence.push_back( Range( i_nFirst, i_nLast ) );
920 sal_Int32 nNumber = i_nLast - i_nFirst;
921 nNumber = nNumber < 0 ? -nNumber : nNumber;
922 mnCount += nNumber + 1;
923 }
924 else
925 bSuccess = false;
926 }
927 else
928 {
929 if( i_nFirst >= 0 )
930 {
931 if( checkValue( i_nFirst ) )
932 {
933 maSequence.push_back( Range( i_nFirst, i_nFirst ) );
934 mnCount++;
935 }
936 else
937 bSuccess = false;
938 }
939 if( i_nLast >= 0 )
940 {
941 if( checkValue( i_nLast ) )
942 {
943 maSequence.push_back( Range( i_nLast, i_nLast ) );
944 mnCount++;
945 }
946 else
947 bSuccess = false;
948 }
949 }
950
951 return bSuccess;
952 }
953
setRange(const rtl::OUString & i_rNewRange,bool i_bStrict)954 bool StringRangeEnumerator::setRange( const rtl::OUString& i_rNewRange, bool i_bStrict )
955 {
956 mnCount = 0;
957 maSequence.clear();
958
959 // we love special cases
960 if( i_rNewRange.getLength() == 0 )
961 {
962 if( mnMin >= 0 && mnMax >= 0 )
963 {
964 insertRange( mnMin, mnMax, mnMin != mnMax, ! i_bStrict );
965 }
966 return true;
967 }
968
969 const sal_Unicode* pInput = i_rNewRange.getStr();
970 rtl::OUStringBuffer aNumberBuf( 16 );
971 sal_Int32 nLastNumber = -1, nNumber = -1;
972 bool bSequence = false;
973 bool bSuccess = true;
974 while( *pInput )
975 {
976 while( *pInput >= sal_Unicode('0') && *pInput <= sal_Unicode('9') )
977 aNumberBuf.append( *pInput++ );
978 if( aNumberBuf.getLength() )
979 {
980 if( nNumber != -1 )
981 {
982 if( bSequence )
983 {
984 if( ! insertRange( nLastNumber, nNumber, true, ! i_bStrict ) && i_bStrict )
985 {
986 bSuccess = false;
987 break;
988 }
989 nLastNumber = -1;
990 }
991 else
992 {
993 if( ! insertRange( nNumber, nNumber, false, ! i_bStrict ) && i_bStrict )
994 {
995 bSuccess = false;
996 break;
997 }
998 }
999 }
1000 nNumber = aNumberBuf.makeStringAndClear().toInt32();
1001 nNumber += mnOffset;
1002 }
1003 bool bInsertRange = false;
1004 if( *pInput == sal_Unicode('-') )
1005 {
1006 nLastNumber = nNumber;
1007 nNumber = -1;
1008 bSequence = true;
1009 }
1010 else if( *pInput == ' ' )
1011 {
1012 }
1013 else if( *pInput == sal_Unicode(',') || *pInput == sal_Unicode(';') )
1014 bInsertRange = true;
1015 else if( *pInput )
1016 {
1017
1018 bSuccess = false;
1019 break; // parse error
1020 }
1021
1022 if( bInsertRange )
1023 {
1024 if( ! insertRange( nLastNumber, nNumber, bSequence, ! i_bStrict ) && i_bStrict )
1025 {
1026 bSuccess = false;
1027 break;
1028 }
1029 nNumber = nLastNumber = -1;
1030 bSequence = false;
1031 }
1032 if( *pInput )
1033 pInput++;
1034 }
1035 // insert last entries
1036 insertRange( nLastNumber, nNumber, bSequence, ! i_bStrict );
1037
1038 return bSuccess;
1039 }
1040
hasValue(sal_Int32 i_nValue,const std::set<sal_Int32> * i_pPossibleValues) const1041 bool StringRangeEnumerator::hasValue( sal_Int32 i_nValue, const std::set< sal_Int32 >* i_pPossibleValues ) const
1042 {
1043 if( i_pPossibleValues && i_pPossibleValues->find( i_nValue ) == i_pPossibleValues->end() )
1044 return false;
1045 size_t n = maSequence.size();
1046 for( size_t i= 0; i < n; ++i )
1047 {
1048 const StringRangeEnumerator::Range rRange( maSequence[i] );
1049 if( rRange.nFirst < rRange.nLast )
1050 {
1051 if( i_nValue >= rRange.nFirst && i_nValue <= rRange.nLast )
1052 return true;
1053 }
1054 else
1055 {
1056 if( i_nValue >= rRange.nLast && i_nValue <= rRange.nFirst )
1057 return true;
1058 }
1059 }
1060 return false;
1061 }
1062
operator ++()1063 StringRangeEnumerator::Iterator& StringRangeEnumerator::Iterator::operator++()
1064 {
1065 if( nRangeIndex >= 0 && nCurrent >= 0 && pEnumerator )
1066 {
1067 const StringRangeEnumerator::Range& rRange( pEnumerator->maSequence[nRangeIndex] );
1068 bool bRangeChange = false;
1069 if( rRange.nLast < rRange.nFirst )
1070 {
1071 // backward range
1072 if( nCurrent > rRange.nLast )
1073 nCurrent--;
1074 else
1075 bRangeChange = true;
1076 }
1077 else
1078 {
1079 // forward range
1080 if( nCurrent < rRange.nLast )
1081 nCurrent++;
1082 else
1083 bRangeChange = true;
1084 }
1085 if( bRangeChange )
1086 {
1087 nRangeIndex++;
1088 if( size_t(nRangeIndex) == pEnumerator->maSequence.size() )
1089 {
1090 // reached the end
1091 nRangeIndex = nCurrent = -1;
1092 }
1093 else
1094 nCurrent = pEnumerator->maSequence[nRangeIndex].nFirst;
1095 }
1096 if( nRangeIndex != -1 && nCurrent != -1 )
1097 {
1098 if( ! pEnumerator->checkValue( nCurrent, pPossibleValues ) )
1099 return ++(*this);
1100 }
1101 }
1102 return *this;
1103 }
1104
operator *() const1105 sal_Int32 StringRangeEnumerator::Iterator::operator*() const
1106 {
1107 return nCurrent;
1108 }
1109
operator ==(const Iterator & i_rCompare) const1110 bool StringRangeEnumerator::Iterator::operator==( const Iterator& i_rCompare ) const
1111 {
1112 return i_rCompare.pEnumerator == pEnumerator && i_rCompare.nRangeIndex == nRangeIndex && i_rCompare.nCurrent == nCurrent;
1113 }
1114
begin(const std::set<sal_Int32> * i_pPossibleValues) const1115 StringRangeEnumerator::Iterator StringRangeEnumerator::begin( const std::set< sal_Int32 >* i_pPossibleValues ) const
1116 {
1117 StringRangeEnumerator::Iterator it( this,
1118 i_pPossibleValues,
1119 maSequence.empty() ? -1 : 0,
1120 maSequence.empty() ? -1 : maSequence[0].nFirst );
1121 if( ! checkValue(*it, i_pPossibleValues ) )
1122 ++it;
1123 return it;
1124 }
1125
end(const std::set<sal_Int32> * i_pPossibleValues) const1126 StringRangeEnumerator::Iterator StringRangeEnumerator::end( const std::set< sal_Int32 >* i_pPossibleValues ) const
1127 {
1128 return StringRangeEnumerator::Iterator( this, i_pPossibleValues, -1, -1 );
1129 }
1130
getRangesFromString(const OUString & i_rPageRange,std::vector<sal_Int32> & o_rPageVector,sal_Int32 i_nMinNumber,sal_Int32 i_nMaxNumber,sal_Int32 i_nLogicalOffset,std::set<sal_Int32> * i_pPossibleValues)1131 bool StringRangeEnumerator::getRangesFromString( const OUString& i_rPageRange,
1132 std::vector< sal_Int32 >& o_rPageVector,
1133 sal_Int32 i_nMinNumber,
1134 sal_Int32 i_nMaxNumber,
1135 sal_Int32 i_nLogicalOffset,
1136 std::set< sal_Int32 >* i_pPossibleValues
1137 )
1138 {
1139 StringRangeEnumerator aEnum;
1140 aEnum.setMin( i_nMinNumber );
1141 aEnum.setMax( i_nMaxNumber );
1142 aEnum.setLogicalOffset( i_nLogicalOffset );
1143
1144 bool bRes = aEnum.setRange( i_rPageRange );
1145 if( bRes )
1146 {
1147 o_rPageVector.clear();
1148 o_rPageVector.reserve( aEnum.size() );
1149 for( StringRangeEnumerator::Iterator it = aEnum.begin( i_pPossibleValues );
1150 it != aEnum.end( i_pPossibleValues ); ++it )
1151 {
1152 o_rPageVector.push_back( *it );
1153 }
1154 }
1155
1156 return bRes;
1157 }
1158
1159