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 "markdata.hxx"
21 : #include "markarr.hxx"
22 : #include "rangelst.hxx"
23 :
24 : // STATIC DATA -----------------------------------------------------------
25 :
26 : //------------------------------------------------------------------------
27 :
28 357 : ScMarkData::ScMarkData() :
29 : maTabMarked(),
30 357 : pMultiSel( NULL )
31 : {
32 357 : ResetMark();
33 357 : }
34 :
35 4 : ScMarkData::ScMarkData(const ScMarkData& rData) :
36 : maTabMarked( rData.maTabMarked ),
37 : aMarkRange( rData.aMarkRange ),
38 : aMultiRange( rData.aMultiRange ),
39 4 : pMultiSel( NULL )
40 : {
41 4 : bMarked = rData.bMarked;
42 4 : bMultiMarked = rData.bMultiMarked;
43 4 : bMarking = rData.bMarking;
44 4 : bMarkIsNeg = rData.bMarkIsNeg;
45 :
46 4 : if (rData.pMultiSel)
47 : {
48 0 : pMultiSel = new ScMarkArray[MAXCOLCOUNT];
49 0 : for (SCCOL j=0; j<MAXCOLCOUNT; j++)
50 0 : rData.pMultiSel[j].CopyMarksTo( pMultiSel[j] );
51 : }
52 4 : }
53 :
54 1 : ScMarkData& ScMarkData::operator=(const ScMarkData& rData)
55 : {
56 1 : if ( &rData == this )
57 0 : return *this;
58 :
59 1 : delete[] pMultiSel;
60 1 : pMultiSel = NULL;
61 :
62 1 : aMarkRange = rData.aMarkRange;
63 1 : aMultiRange = rData.aMultiRange;
64 1 : bMarked = rData.bMarked;
65 1 : bMultiMarked = rData.bMultiMarked;
66 1 : bMarking = rData.bMarking;
67 1 : bMarkIsNeg = rData.bMarkIsNeg;
68 :
69 1 : maTabMarked = rData.maTabMarked;
70 :
71 1 : if (rData.pMultiSel)
72 : {
73 0 : pMultiSel = new ScMarkArray[MAXCOLCOUNT];
74 0 : for (SCCOL j=0; j<MAXCOLCOUNT; j++)
75 0 : rData.pMultiSel[j].CopyMarksTo( pMultiSel[j] );
76 : }
77 :
78 1 : return *this;
79 : }
80 :
81 720 : ScMarkData::~ScMarkData()
82 : {
83 360 : delete[] pMultiSel;
84 360 : }
85 :
86 359 : void ScMarkData::ResetMark()
87 : {
88 359 : delete[] pMultiSel;
89 359 : pMultiSel = NULL;
90 :
91 359 : bMarked = bMultiMarked = false;
92 359 : bMarking = bMarkIsNeg = false;
93 359 : }
94 :
95 280 : void ScMarkData::SetMarkArea( const ScRange& rRange )
96 : {
97 280 : aMarkRange = rRange;
98 280 : aMarkRange.Justify();
99 280 : if ( !bMarked )
100 : {
101 : // Upon creation of a document ScFormatShell GetTextAttrState
102 : // may query (default) attributes although no sheet is marked yet.
103 : // => mark that one.
104 280 : if ( !GetSelectCount() )
105 278 : maTabMarked.insert( aMarkRange.aStart.Tab() );
106 280 : bMarked = true;
107 : }
108 280 : }
109 :
110 850 : void ScMarkData::GetMarkArea( ScRange& rRange ) const
111 : {
112 850 : rRange = aMarkRange; //! inline ?
113 850 : }
114 :
115 70 : void ScMarkData::GetMultiMarkArea( ScRange& rRange ) const
116 : {
117 70 : rRange = aMultiRange;
118 70 : }
119 :
120 405 : void ScMarkData::SetMultiMarkArea( const ScRange& rRange, bool bMark )
121 : {
122 405 : if (!pMultiSel)
123 : {
124 78 : pMultiSel = new ScMarkArray[MAXCOL+1];
125 :
126 : // if simple mark range is set, copy to multi marks
127 78 : if ( bMarked && !bMarkIsNeg )
128 : {
129 11 : bMarked = false;
130 11 : SetMultiMarkArea( aMarkRange, true );
131 : }
132 : }
133 :
134 405 : SCCOL nStartCol = rRange.aStart.Col();
135 405 : SCROW nStartRow = rRange.aStart.Row();
136 405 : SCCOL nEndCol = rRange.aEnd.Col();
137 405 : SCROW nEndRow = rRange.aEnd.Row();
138 405 : PutInOrder( nStartRow, nEndRow );
139 405 : PutInOrder( nStartCol, nEndCol );
140 :
141 : SCCOL nCol;
142 1834 : for (nCol=nStartCol; nCol<=nEndCol; nCol++)
143 1429 : pMultiSel[nCol].SetMarkArea( nStartRow, nEndRow, bMark );
144 :
145 405 : if ( bMultiMarked ) // aMultiRange updaten
146 : {
147 327 : if ( nStartCol < aMultiRange.aStart.Col() )
148 17 : aMultiRange.aStart.SetCol( nStartCol );
149 327 : if ( nStartRow < aMultiRange.aStart.Row() )
150 0 : aMultiRange.aStart.SetRow( nStartRow );
151 327 : if ( nEndCol > aMultiRange.aEnd.Col() )
152 43 : aMultiRange.aEnd.SetCol( nEndCol );
153 327 : if ( nEndRow > aMultiRange.aEnd.Row() )
154 236 : aMultiRange.aEnd.SetRow( nEndRow );
155 : }
156 : else
157 : {
158 78 : aMultiRange = rRange; // neu
159 78 : bMultiMarked = true;
160 : }
161 405 : }
162 :
163 0 : void ScMarkData::SetAreaTab( SCTAB nTab )
164 : {
165 0 : aMarkRange.aStart.SetTab(nTab);
166 0 : aMarkRange.aEnd.SetTab(nTab);
167 0 : aMultiRange.aStart.SetTab(nTab);
168 0 : aMultiRange.aEnd.SetTab(nTab);
169 0 : }
170 :
171 635 : void ScMarkData::SelectTable( SCTAB nTab, bool bNew )
172 : {
173 635 : if ( bNew )
174 : {
175 635 : maTabMarked.insert( nTab );
176 : }
177 : else
178 : {
179 0 : maTabMarked.erase( nTab );
180 : }
181 635 : }
182 :
183 50 : bool ScMarkData::GetTableSelect( SCTAB nTab ) const
184 : {
185 50 : return (maTabMarked.find( nTab ) != maTabMarked.end());
186 : }
187 :
188 4 : void ScMarkData::SelectOneTable( SCTAB nTab )
189 : {
190 4 : maTabMarked.clear();
191 4 : maTabMarked.insert( nTab );
192 4 : }
193 :
194 281 : SCTAB ScMarkData::GetSelectCount() const
195 : {
196 281 : return static_cast<SCTAB> ( maTabMarked.size() );
197 : }
198 :
199 4 : SCTAB ScMarkData::GetFirstSelected() const
200 : {
201 4 : if (maTabMarked.size() > 0)
202 4 : return (*maTabMarked.begin());
203 :
204 : OSL_FAIL("GetFirstSelected: keine markiert");
205 0 : return 0;
206 : }
207 :
208 3 : SCTAB ScMarkData::GetLastSelected() const
209 : {
210 3 : if (maTabMarked.size() > 0)
211 3 : return (*maTabMarked.rbegin());
212 :
213 : OSL_FAIL("GetLastSelected: keine markiert");
214 0 : return 0;
215 : }
216 :
217 0 : const ScMarkData::MarkedTabsType& ScMarkData::GetSelectedTabs() const
218 : {
219 0 : return maTabMarked;
220 : }
221 :
222 0 : void ScMarkData::SetSelectedTabs(const MarkedTabsType& rTabs)
223 : {
224 0 : MarkedTabsType aTabs(rTabs.begin(), rTabs.end());
225 0 : maTabMarked.swap(aTabs);
226 0 : }
227 :
228 11 : void ScMarkData::MarkToMulti()
229 : {
230 11 : if ( bMarked && !bMarking )
231 : {
232 11 : SetMultiMarkArea( aMarkRange, !bMarkIsNeg );
233 11 : bMarked = false;
234 :
235 : // check if all multi mark ranges have been removed
236 11 : if ( bMarkIsNeg && !HasAnyMultiMarks() )
237 0 : ResetMark();
238 : }
239 11 : }
240 :
241 4 : void ScMarkData::MarkToSimple()
242 : {
243 4 : if ( bMarking )
244 4 : return;
245 :
246 4 : if ( bMultiMarked && bMarked )
247 0 : MarkToMulti(); // may result in bMarked and bMultiMarked reset
248 :
249 4 : if ( bMultiMarked )
250 : {
251 : OSL_ENSURE(pMultiSel, "bMultiMarked, aber pMultiSel == 0");
252 :
253 2 : ScRange aNew = aMultiRange;
254 :
255 2 : bool bOk = false;
256 2 : SCCOL nStartCol = aNew.aStart.Col();
257 2 : SCCOL nEndCol = aNew.aEnd.Col();
258 :
259 4 : while ( nStartCol < nEndCol && !pMultiSel[nStartCol].HasMarks() )
260 0 : ++nStartCol;
261 4 : while ( nStartCol < nEndCol && !pMultiSel[nEndCol].HasMarks() )
262 0 : --nEndCol;
263 :
264 : // Zeilen werden nur aus MarkArray genommen
265 : SCROW nStartRow, nEndRow;
266 2 : if ( pMultiSel[nStartCol].HasOneMark( nStartRow, nEndRow ) )
267 : {
268 2 : bOk = true;
269 : SCROW nCmpStart, nCmpEnd;
270 6 : for (SCCOL nCol=nStartCol+1; nCol<=nEndCol && bOk; nCol++)
271 4 : if ( !pMultiSel[nCol].HasOneMark( nCmpStart, nCmpEnd )
272 : || nCmpStart != nStartRow || nCmpEnd != nEndRow )
273 0 : bOk = false;
274 : }
275 :
276 2 : if (bOk)
277 : {
278 2 : aNew.aStart.SetCol(nStartCol);
279 2 : aNew.aStart.SetRow(nStartRow);
280 2 : aNew.aEnd.SetCol(nEndCol);
281 2 : aNew.aEnd.SetRow(nEndRow);
282 :
283 2 : ResetMark();
284 2 : aMarkRange = aNew;
285 2 : bMarked = true;
286 2 : bMarkIsNeg = false;
287 : }
288 : }
289 : }
290 :
291 0 : bool ScMarkData::IsCellMarked( SCCOL nCol, SCROW nRow, bool bNoSimple ) const
292 : {
293 0 : if ( bMarked && !bNoSimple && !bMarkIsNeg )
294 0 : if ( aMarkRange.aStart.Col() <= nCol && aMarkRange.aEnd.Col() >= nCol &&
295 0 : aMarkRange.aStart.Row() <= nRow && aMarkRange.aEnd.Row() >= nRow )
296 0 : return true;
297 :
298 0 : if (bMultiMarked)
299 : {
300 : //! hier auf negative Markierung testen ?
301 :
302 : OSL_ENSURE(pMultiSel, "bMultiMarked, aber pMultiSel == 0");
303 0 : return pMultiSel[nCol].GetMark( nRow );
304 : }
305 :
306 0 : return false;
307 : }
308 :
309 0 : bool ScMarkData::IsColumnMarked( SCCOL nCol ) const
310 : {
311 : // bMarkIsNeg inzwischen auch fuer Spaltenkoepfe
312 : //! GetMarkColumnRanges fuer komplett markierte Spalten
313 :
314 0 : if ( bMarked && !bMarkIsNeg &&
315 0 : aMarkRange.aStart.Col() <= nCol && aMarkRange.aEnd.Col() >= nCol &&
316 0 : aMarkRange.aStart.Row() == 0 && aMarkRange.aEnd.Row() == MAXROW )
317 0 : return true;
318 :
319 0 : if ( bMultiMarked && pMultiSel[nCol].IsAllMarked(0,MAXROW) )
320 0 : return true;
321 :
322 0 : return false;
323 : }
324 :
325 0 : bool ScMarkData::IsRowMarked( SCROW nRow ) const
326 : {
327 : // bMarkIsNeg inzwischen auch fuer Zeilenkoepfe
328 : //! GetMarkRowRanges fuer komplett markierte Zeilen
329 :
330 0 : if ( bMarked && !bMarkIsNeg &&
331 0 : aMarkRange.aStart.Col() == 0 && aMarkRange.aEnd.Col() == MAXCOL &&
332 0 : aMarkRange.aStart.Row() <= nRow && aMarkRange.aEnd.Row() >= nRow )
333 0 : return true;
334 :
335 0 : if ( bMultiMarked )
336 : {
337 : OSL_ENSURE(pMultiSel, "bMultiMarked, aber pMultiSel == 0");
338 0 : for (SCCOL nCol=0; nCol<=MAXCOL; nCol++)
339 0 : if (!pMultiSel[nCol].GetMark(nRow))
340 0 : return false;
341 0 : return true;
342 : }
343 :
344 0 : return false;
345 : }
346 :
347 293 : void ScMarkData::MarkFromRangeList( const ScRangeList& rList, bool bReset )
348 : {
349 293 : if (bReset)
350 : {
351 0 : maTabMarked.clear();
352 0 : ResetMark();
353 : }
354 :
355 293 : size_t nCount = rList.size();
356 293 : if ( nCount == 1 && !bMarked && !bMultiMarked )
357 : {
358 224 : ScRange aRange = *rList[ 0 ];
359 224 : SetMarkArea( aRange );
360 224 : SelectTable( aRange.aStart.Tab(), true );
361 : }
362 : else
363 : {
364 452 : for (size_t i=0; i < nCount; i++)
365 : {
366 383 : ScRange aRange = *rList[ i ];
367 383 : SetMultiMarkArea( aRange, true );
368 383 : SelectTable( aRange.aStart.Tab(), true );
369 : }
370 : }
371 293 : }
372 :
373 2 : void ScMarkData::FillRangeListWithMarks( ScRangeList* pList, bool bClear ) const
374 : {
375 2 : if (!pList)
376 2 : return;
377 :
378 2 : if (bClear)
379 0 : pList->RemoveAll();
380 :
381 : //! bei mehreren selektierten Tabellen mehrere Ranges eintragen !!!
382 :
383 2 : if ( bMultiMarked )
384 : {
385 : OSL_ENSURE(pMultiSel, "bMultiMarked, aber pMultiSel == 0");
386 :
387 2 : SCTAB nTab = aMultiRange.aStart.Tab();
388 :
389 2 : SCCOL nStartCol = aMultiRange.aStart.Col();
390 2 : SCCOL nEndCol = aMultiRange.aEnd.Col();
391 8 : for (SCCOL nCol=nStartCol; nCol<=nEndCol; nCol++)
392 6 : if (pMultiSel[nCol].HasMarks())
393 : {
394 : SCROW nTop, nBottom;
395 6 : ScRange aRange( nCol, 0, nTab );
396 6 : ScMarkArrayIter aMarkIter( &pMultiSel[nCol] );
397 18 : while ( aMarkIter.Next( nTop, nBottom ) )
398 : {
399 6 : aRange.aStart.SetRow( nTop );
400 6 : aRange.aEnd.SetRow( nBottom );
401 6 : pList->Join( aRange );
402 6 : }
403 : }
404 : }
405 :
406 2 : if ( bMarked )
407 0 : pList->Append( aMarkRange );
408 : }
409 :
410 0 : void ScMarkData::ExtendRangeListTables( ScRangeList* pList ) const
411 : {
412 0 : if (!pList)
413 0 : return;
414 :
415 0 : ScRangeList aOldList(*pList);
416 0 : pList->RemoveAll(); //! oder die vorhandenen unten weglassen
417 :
418 0 : std::set<SCTAB>::const_iterator it = maTabMarked.begin();
419 0 : for (; it != maTabMarked.end(); ++it)
420 0 : for ( size_t i=0, nCount = aOldList.size(); i<nCount; i++)
421 : {
422 0 : ScRange aRange = *aOldList[ i ];
423 0 : aRange.aStart.SetTab(*it);
424 0 : aRange.aEnd.SetTab(*it);
425 0 : pList->Append( aRange );
426 0 : }
427 : }
428 :
429 0 : SCCOLROW ScMarkData::GetMarkColumnRanges( SCCOLROW* pRanges )
430 : {
431 0 : if (bMarked)
432 0 : MarkToMulti();
433 :
434 0 : if (!bMultiMarked)
435 0 : return 0;
436 :
437 : OSL_ENSURE(pMultiSel, "bMultiMarked, but pMultiSel == 0");
438 :
439 0 : const SCCOLROW nMultiStart = aMultiRange.aStart.Col();
440 0 : const SCCOLROW nMultiEnd = aMultiRange.aEnd.Col();
441 0 : if (nMultiStart == 0 && nMultiEnd == MAXCOL)
442 : {
443 : // One or more entire rows.
444 0 : pRanges[0] = 0;
445 0 : pRanges[1] = MAXCOL;
446 0 : return 1;
447 : }
448 :
449 0 : SCCOLROW nRangeCnt = 0;
450 0 : SCCOLROW nStart = nMultiStart;
451 0 : while (nStart <= nMultiEnd)
452 : {
453 0 : while (nStart < nMultiEnd && !pMultiSel[nStart].HasMarks())
454 0 : ++nStart;
455 0 : if (pMultiSel[nStart].HasMarks())
456 : {
457 0 : SCCOLROW nEnd = nStart;
458 0 : while (nEnd < nMultiEnd && pMultiSel[nEnd].HasMarks())
459 0 : ++nEnd;
460 0 : if (!pMultiSel[nEnd].HasMarks())
461 0 : --nEnd;
462 0 : pRanges[2*nRangeCnt ] = nStart;
463 0 : pRanges[2*nRangeCnt+1] = nEnd;
464 0 : ++nRangeCnt;
465 0 : nStart = nEnd+1;
466 : }
467 : else
468 0 : nStart = nMultiEnd+1;
469 : }
470 :
471 0 : return nRangeCnt;
472 : }
473 :
474 0 : SCCOLROW ScMarkData::GetMarkRowRanges( SCCOLROW* pRanges )
475 : {
476 0 : if (bMarked)
477 0 : MarkToMulti();
478 :
479 0 : if (!bMultiMarked)
480 0 : return 0;
481 :
482 : OSL_ENSURE(pMultiSel, "bMultiMarked, but pMultiSel == 0");
483 :
484 : // Which rows are marked?
485 :
486 : // Optimized to not loop over MAXCOL*MAXROW as worst case, i.e. Ctrl+A
487 :
488 0 : const SCCOLROW nMultiStart = aMultiRange.aStart.Row();
489 0 : const SCCOLROW nMultiEnd = aMultiRange.aEnd.Row();
490 :
491 0 : bool* bRowMarked = new bool[MAXROWCOUNT];
492 0 : memset( bRowMarked, 0, sizeof(bool) * MAXROWCOUNT);
493 : SCROW nRow;
494 : SCCOL nCol;
495 :
496 0 : SCROW nTop = -1, nBottom = -1;
497 0 : for (nCol = aMultiRange.aStart.Col(); nCol <= aMultiRange.aEnd.Col(); ++nCol)
498 : {
499 0 : ScMarkArrayIter aMarkIter( &pMultiSel[nCol] );
500 0 : while (aMarkIter.Next( nTop, nBottom ))
501 0 : for (nRow=nTop; nRow<=nBottom; nRow++)
502 0 : bRowMarked[nRow] = true;
503 0 : if (nTop == nMultiStart && nBottom == nMultiEnd)
504 : break; // for, all relevant rows marked
505 0 : }
506 :
507 0 : if (nTop == nMultiStart && nBottom == nMultiEnd)
508 : {
509 0 : pRanges[0] = nTop;
510 0 : pRanges[1] = nBottom;
511 0 : delete[] bRowMarked;
512 0 : return 1;
513 : }
514 :
515 : // Combine to ranges of rows.
516 :
517 0 : SCCOLROW nRangeCnt = 0;
518 0 : SCCOLROW nStart = nMultiStart;
519 0 : while (nStart <= nMultiEnd)
520 : {
521 0 : while (nStart < nMultiEnd && !bRowMarked[nStart])
522 0 : ++nStart;
523 0 : if (bRowMarked[nStart])
524 : {
525 0 : SCCOLROW nEnd = nStart;
526 0 : while (nEnd < nMultiEnd && bRowMarked[nEnd])
527 0 : ++nEnd;
528 0 : if (!bRowMarked[nEnd])
529 0 : --nEnd;
530 0 : pRanges[2*nRangeCnt ] = nStart;
531 0 : pRanges[2*nRangeCnt+1] = nEnd;
532 0 : ++nRangeCnt;
533 0 : nStart = nEnd+1;
534 : }
535 : else
536 0 : nStart = nMultiEnd+1;
537 : }
538 :
539 0 : delete[] bRowMarked;
540 0 : return nRangeCnt;
541 : }
542 :
543 0 : bool ScMarkData::IsAllMarked( const ScRange& rRange ) const
544 : {
545 0 : if ( !bMultiMarked )
546 0 : return false;
547 :
548 : OSL_ENSURE(pMultiSel, "bMultiMarked, aber pMultiSel == 0");
549 :
550 0 : SCCOL nStartCol = rRange.aStart.Col();
551 0 : SCROW nStartRow = rRange.aStart.Row();
552 0 : SCCOL nEndCol = rRange.aEnd.Col();
553 0 : SCROW nEndRow = rRange.aEnd.Row();
554 0 : bool bOk = true;
555 0 : for (SCCOL nCol=nStartCol; nCol<=nEndCol && bOk; nCol++)
556 0 : if ( !pMultiSel[nCol].IsAllMarked( nStartRow, nEndRow ) )
557 0 : bOk = false;
558 :
559 0 : return bOk;
560 : }
561 :
562 0 : SCsROW ScMarkData::GetNextMarked( SCCOL nCol, SCsROW nRow, bool bUp ) const
563 : {
564 0 : if ( !bMultiMarked )
565 0 : return nRow;
566 :
567 : OSL_ENSURE(pMultiSel, "bMultiMarked, aber pMultiSel == 0");
568 :
569 0 : return pMultiSel[nCol].GetNextMarked( nRow, bUp );
570 : }
571 :
572 0 : bool ScMarkData::HasMultiMarks( SCCOL nCol ) const
573 : {
574 0 : if ( !bMultiMarked )
575 0 : return false;
576 :
577 : OSL_ENSURE(pMultiSel, "bMultiMarked, aber pMultiSel == 0");
578 :
579 0 : return pMultiSel[nCol].HasMarks();
580 : }
581 :
582 0 : bool ScMarkData::HasAnyMultiMarks() const
583 : {
584 0 : if ( !bMultiMarked )
585 0 : return false;
586 :
587 : OSL_ENSURE(pMultiSel, "bMultiMarked, aber pMultiSel == 0");
588 :
589 0 : for (SCCOL nCol=0; nCol<=MAXCOL; nCol++)
590 0 : if ( pMultiSel[nCol].HasMarks() )
591 0 : return true;
592 :
593 0 : return false; // nix
594 : }
595 :
596 0 : void ScMarkData::InsertTab( SCTAB nTab )
597 : {
598 0 : std::set<SCTAB> tabMarked(maTabMarked.begin(), maTabMarked.upper_bound(nTab));
599 0 : std::set<SCTAB>::iterator it = maTabMarked.upper_bound(nTab);
600 0 : for (; it != maTabMarked.end(); ++it)
601 0 : tabMarked.insert(*it + 1);
602 0 : maTabMarked.swap(tabMarked);
603 0 : }
604 :
605 0 : void ScMarkData::DeleteTab( SCTAB nTab )
606 : {
607 0 : std::set<SCTAB> tabMarked(maTabMarked.begin(), maTabMarked.find(nTab));
608 0 : tabMarked.erase( nTab );
609 0 : std::set<SCTAB>::iterator it = maTabMarked.find(nTab);
610 0 : for (; it != maTabMarked.end(); ++it)
611 0 : tabMarked.insert(*it + 1);
612 0 : maTabMarked.swap(tabMarked);
613 0 : }
614 :
615 : //iterators
616 6 : ScMarkData::iterator ScMarkData::begin()
617 : {
618 6 : return maTabMarked.begin();
619 : }
620 :
621 3 : ScMarkData::iterator ScMarkData::end()
622 : {
623 3 : return maTabMarked.end();
624 : }
625 :
626 790 : ScMarkData::const_iterator ScMarkData::begin() const
627 : {
628 790 : return maTabMarked.begin();
629 : }
630 :
631 731 : ScMarkData::const_iterator ScMarkData::end() const
632 : {
633 731 : return maTabMarked.end();
634 : }
635 :
636 :
637 :
638 :
639 :
640 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
