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 6297 : ScMarkData::ScMarkData() :
29 : maTabMarked(),
30 6297 : pMultiSel( NULL )
31 : {
32 6297 : ResetMark();
33 6297 : }
34 :
35 14055 : ScMarkData::ScMarkData(const ScMarkData& rData) :
36 : maTabMarked( rData.maTabMarked ),
37 : aMarkRange( rData.aMarkRange ),
38 : aMultiRange( rData.aMultiRange ),
39 14055 : pMultiSel( NULL )
40 : {
41 14055 : bMarked = rData.bMarked;
42 14055 : bMultiMarked = rData.bMultiMarked;
43 14055 : bMarking = rData.bMarking;
44 14055 : bMarkIsNeg = rData.bMarkIsNeg;
45 :
46 14055 : if (rData.pMultiSel)
47 : {
48 327 : pMultiSel = new ScMarkArray[MAXCOLCOUNT];
49 335175 : for (SCCOL j=0; j<MAXCOLCOUNT; j++)
50 334848 : rData.pMultiSel[j].CopyMarksTo( pMultiSel[j] );
51 : }
52 14055 : }
53 :
54 166 : ScMarkData& ScMarkData::operator=(const ScMarkData& rData)
55 : {
56 166 : if ( &rData == this )
57 0 : return *this;
58 :
59 166 : delete[] pMultiSel;
60 166 : pMultiSel = NULL;
61 :
62 166 : aMarkRange = rData.aMarkRange;
63 166 : aMultiRange = rData.aMultiRange;
64 166 : bMarked = rData.bMarked;
65 166 : bMultiMarked = rData.bMultiMarked;
66 166 : bMarking = rData.bMarking;
67 166 : bMarkIsNeg = rData.bMarkIsNeg;
68 :
69 166 : maTabMarked = rData.maTabMarked;
70 :
71 166 : 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 166 : return *this;
79 : }
80 :
81 40394 : ScMarkData::~ScMarkData()
82 : {
83 20197 : delete[] pMultiSel;
84 20197 : }
85 :
86 6513 : void ScMarkData::ResetMark()
87 : {
88 6513 : delete[] pMultiSel;
89 6513 : pMultiSel = NULL;
90 :
91 6513 : bMarked = bMultiMarked = false;
92 6513 : bMarking = bMarkIsNeg = false;
93 6513 : }
94 :
95 10699 : void ScMarkData::SetMarkArea( const ScRange& rRange )
96 : {
97 10699 : aMarkRange = rRange;
98 10699 : aMarkRange.Justify();
99 10699 : 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 10677 : if ( !GetSelectCount() )
105 5533 : maTabMarked.insert( aMarkRange.aStart.Tab() );
106 10677 : bMarked = true;
107 : }
108 10699 : }
109 :
110 14458 : void ScMarkData::GetMarkArea( ScRange& rRange ) const
111 : {
112 14458 : rRange = aMarkRange; //! inline ?
113 14458 : }
114 :
115 674 : void ScMarkData::GetMultiMarkArea( ScRange& rRange ) const
116 : {
117 674 : rRange = aMultiRange;
118 674 : }
119 :
120 2563 : void ScMarkData::SetMultiMarkArea( const ScRange& rRange, bool bMark )
121 : {
122 2563 : if (!pMultiSel)
123 : {
124 649 : pMultiSel = new ScMarkArray[MAXCOL+1];
125 :
126 : // if simple mark range is set, copy to multi marks
127 649 : if ( bMarked && !bMarkIsNeg )
128 : {
129 492 : bMarked = false;
130 492 : SetMultiMarkArea( aMarkRange, true );
131 : }
132 : }
133 :
134 2563 : SCCOL nStartCol = rRange.aStart.Col();
135 2563 : SCROW nStartRow = rRange.aStart.Row();
136 2563 : SCCOL nEndCol = rRange.aEnd.Col();
137 2563 : SCROW nEndRow = rRange.aEnd.Row();
138 2563 : PutInOrder( nStartRow, nEndRow );
139 2563 : PutInOrder( nStartCol, nEndCol );
140 :
141 : SCCOL nCol;
142 31997 : for (nCol=nStartCol; nCol<=nEndCol; nCol++)
143 29434 : pMultiSel[nCol].SetMarkArea( nStartRow, nEndRow, bMark );
144 :
145 2563 : if ( bMultiMarked ) // aMultiRange updaten
146 : {
147 1914 : if ( nStartCol < aMultiRange.aStart.Col() )
148 43 : aMultiRange.aStart.SetCol( nStartCol );
149 1914 : if ( nStartRow < aMultiRange.aStart.Row() )
150 5 : aMultiRange.aStart.SetRow( nStartRow );
151 1914 : if ( nEndCol > aMultiRange.aEnd.Col() )
152 199 : aMultiRange.aEnd.SetCol( nEndCol );
153 1914 : if ( nEndRow > aMultiRange.aEnd.Row() )
154 493 : aMultiRange.aEnd.SetRow( nEndRow );
155 : }
156 : else
157 : {
158 649 : aMultiRange = rRange; // neu
159 649 : bMultiMarked = true;
160 : }
161 2563 : }
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 7137 : void ScMarkData::SelectTable( SCTAB nTab, bool bNew )
172 : {
173 7137 : if ( bNew )
174 : {
175 7112 : maTabMarked.insert( nTab );
176 : }
177 : else
178 : {
179 25 : maTabMarked.erase( nTab );
180 : }
181 7137 : }
182 :
183 6734 : bool ScMarkData::GetTableSelect( SCTAB nTab ) const
184 : {
185 6734 : return (maTabMarked.find( nTab ) != maTabMarked.end());
186 : }
187 :
188 337 : void ScMarkData::SelectOneTable( SCTAB nTab )
189 : {
190 337 : maTabMarked.clear();
191 337 : maTabMarked.insert( nTab );
192 337 : }
193 :
194 13692 : SCTAB ScMarkData::GetSelectCount() const
195 : {
196 13692 : return static_cast<SCTAB> ( maTabMarked.size() );
197 : }
198 :
199 337 : SCTAB ScMarkData::GetFirstSelected() const
200 : {
201 337 : if (maTabMarked.size() > 0)
202 337 : return (*maTabMarked.begin());
203 :
204 : OSL_FAIL("GetFirstSelected: nothing selected");
205 0 : return 0;
206 : }
207 :
208 35 : SCTAB ScMarkData::GetLastSelected() const
209 : {
210 35 : if (maTabMarked.size() > 0)
211 35 : return (*maTabMarked.rbegin());
212 :
213 : OSL_FAIL("GetLastSelected: nothing selected");
214 0 : return 0;
215 : }
216 :
217 8 : const ScMarkData::MarkedTabsType& ScMarkData::GetSelectedTabs() const
218 : {
219 8 : 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 2296 : void ScMarkData::MarkToMulti()
229 : {
230 2296 : if ( bMarked && !bMarking )
231 : {
232 472 : SetMultiMarkArea( aMarkRange, !bMarkIsNeg );
233 472 : bMarked = false;
234 :
235 : // check if all multi mark ranges have been removed
236 472 : if ( bMarkIsNeg && !HasAnyMultiMarks() )
237 0 : ResetMark();
238 : }
239 2296 : }
240 :
241 310 : void ScMarkData::MarkToSimple()
242 : {
243 310 : if ( bMarking )
244 310 : return;
245 :
246 310 : if ( bMultiMarked && bMarked )
247 0 : MarkToMulti(); // may result in bMarked and bMultiMarked reset
248 :
249 310 : if ( bMultiMarked )
250 : {
251 : OSL_ENSURE(pMultiSel, "bMultiMarked, but pMultiSel == 0");
252 :
253 157 : ScRange aNew = aMultiRange;
254 :
255 157 : bool bOk = false;
256 157 : SCCOL nStartCol = aNew.aStart.Col();
257 157 : SCCOL nEndCol = aNew.aEnd.Col();
258 :
259 314 : while ( nStartCol < nEndCol && !pMultiSel[nStartCol].HasMarks() )
260 0 : ++nStartCol;
261 314 : while ( nStartCol < nEndCol && !pMultiSel[nEndCol].HasMarks() )
262 0 : --nEndCol;
263 :
264 : // Zeilen werden nur aus MarkArray genommen
265 : SCROW nStartRow, nEndRow;
266 157 : if ( pMultiSel[nStartCol].HasOneMark( nStartRow, nEndRow ) )
267 : {
268 157 : bOk = true;
269 : SCROW nCmpStart, nCmpEnd;
270 705 : for (SCCOL nCol=nStartCol+1; nCol<=nEndCol && bOk; nCol++)
271 1096 : if ( !pMultiSel[nCol].HasOneMark( nCmpStart, nCmpEnd )
272 548 : || nCmpStart != nStartRow || nCmpEnd != nEndRow )
273 38 : bOk = false;
274 : }
275 :
276 157 : if (bOk)
277 : {
278 119 : aNew.aStart.SetCol(nStartCol);
279 119 : aNew.aStart.SetRow(nStartRow);
280 119 : aNew.aEnd.SetCol(nEndCol);
281 119 : aNew.aEnd.SetRow(nEndRow);
282 :
283 119 : ResetMark();
284 119 : aMarkRange = aNew;
285 119 : bMarked = true;
286 119 : bMarkIsNeg = false;
287 : }
288 : }
289 : }
290 :
291 14400 : bool ScMarkData::IsCellMarked( SCCOL nCol, SCROW nRow, bool bNoSimple ) const
292 : {
293 14400 : if ( bMarked && !bNoSimple && !bMarkIsNeg )
294 36459 : if ( aMarkRange.aStart.Col() <= nCol && aMarkRange.aEnd.Col() >= nCol &&
295 16892 : aMarkRange.aStart.Row() <= nRow && aMarkRange.aEnd.Row() >= nRow )
296 1107 : return true;
297 :
298 13293 : if (bMultiMarked)
299 : {
300 : //! hier auf negative Markierung testen ?
301 :
302 : OSL_ENSURE(pMultiSel, "bMultiMarked, but pMultiSel == 0");
303 2791 : return pMultiSel[nCol].GetMark( nRow );
304 : }
305 :
306 10502 : 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, but 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 5533 : void ScMarkData::MarkFromRangeList( const ScRangeList& rList, bool bReset )
348 : {
349 5533 : if (bReset)
350 : {
351 3 : maTabMarked.clear();
352 3 : ResetMark();
353 : }
354 :
355 5533 : size_t nCount = rList.size();
356 5533 : if ( nCount == 1 && !bMarked && !bMultiMarked )
357 : {
358 5400 : const ScRange& rRange = *rList[ 0 ];
359 5400 : SetMarkArea( rRange );
360 5400 : SelectTable( rRange.aStart.Tab(), true );
361 : }
362 : else
363 : {
364 1365 : for (size_t i=0; i < nCount; i++)
365 : {
366 1232 : const ScRange& rRange = *rList[ i ];
367 1232 : SetMultiMarkArea( rRange, true );
368 1232 : SelectTable( rRange.aStart.Tab(), true );
369 : }
370 : }
371 5533 : }
372 :
373 72949 : void ScMarkData::FillRangeListWithMarks( ScRangeList* pList, bool bClear ) const
374 : {
375 72949 : if (!pList)
376 72949 : return;
377 :
378 72949 : if (bClear)
379 9 : pList->RemoveAll();
380 :
381 : //! bei mehreren selektierten Tabellen mehrere Ranges eintragen !!!
382 :
383 72949 : if ( bMultiMarked )
384 : {
385 : OSL_ENSURE(pMultiSel, "bMultiMarked, but pMultiSel == 0");
386 :
387 72936 : SCTAB nTab = aMultiRange.aStart.Tab();
388 :
389 72936 : SCCOL nStartCol = aMultiRange.aStart.Col();
390 72936 : SCCOL nEndCol = aMultiRange.aEnd.Col();
391 595247 : for (SCCOL nCol=nStartCol; nCol<=nEndCol; nCol++)
392 522311 : if (pMultiSel[nCol].HasMarks())
393 : {
394 : SCROW nTop, nBottom;
395 508832 : ScRange aRange( nCol, 0, nTab );
396 508832 : ScMarkArrayIter aMarkIter( &pMultiSel[nCol] );
397 1526522 : while ( aMarkIter.Next( nTop, nBottom ) )
398 : {
399 508858 : aRange.aStart.SetRow( nTop );
400 508858 : aRange.aEnd.SetRow( nBottom );
401 508858 : pList->Join( aRange );
402 508832 : }
403 : }
404 : }
405 :
406 72949 : if ( bMarked )
407 10 : 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 72774 : ScRangeList ScMarkData::GetMarkedRanges() const
430 : {
431 72774 : ScRangeList aRet;
432 72774 : FillRangeListWithMarks(&aRet, false);
433 72774 : return aRet;
434 : }
435 :
436 0 : SCCOLROW ScMarkData::GetMarkColumnRanges( SCCOLROW* pRanges )
437 : {
438 0 : if (bMarked)
439 0 : MarkToMulti();
440 :
441 0 : if (!bMultiMarked)
442 0 : return 0;
443 :
444 : OSL_ENSURE(pMultiSel, "bMultiMarked, but pMultiSel == 0");
445 :
446 0 : const SCCOLROW nMultiStart = aMultiRange.aStart.Col();
447 0 : const SCCOLROW nMultiEnd = aMultiRange.aEnd.Col();
448 0 : if (nMultiStart == 0 && nMultiEnd == MAXCOL)
449 : {
450 : // One or more entire rows.
451 0 : pRanges[0] = 0;
452 0 : pRanges[1] = MAXCOL;
453 0 : return 1;
454 : }
455 :
456 0 : SCCOLROW nRangeCnt = 0;
457 0 : SCCOLROW nStart = nMultiStart;
458 0 : while (nStart <= nMultiEnd)
459 : {
460 0 : while (nStart < nMultiEnd && !pMultiSel[nStart].HasMarks())
461 0 : ++nStart;
462 0 : if (pMultiSel[nStart].HasMarks())
463 : {
464 0 : SCCOLROW nEnd = nStart;
465 0 : while (nEnd < nMultiEnd && pMultiSel[nEnd].HasMarks())
466 0 : ++nEnd;
467 0 : if (!pMultiSel[nEnd].HasMarks())
468 0 : --nEnd;
469 0 : pRanges[2*nRangeCnt ] = nStart;
470 0 : pRanges[2*nRangeCnt+1] = nEnd;
471 0 : ++nRangeCnt;
472 0 : nStart = nEnd+1;
473 : }
474 : else
475 0 : nStart = nMultiEnd+1;
476 : }
477 :
478 0 : return nRangeCnt;
479 : }
480 :
481 167 : SCCOLROW ScMarkData::GetMarkRowRanges( SCCOLROW* pRanges )
482 : {
483 167 : if (bMarked)
484 167 : MarkToMulti();
485 :
486 167 : if (!bMultiMarked)
487 0 : return 0;
488 :
489 : OSL_ENSURE(pMultiSel, "bMultiMarked, but pMultiSel == 0");
490 :
491 : // Which rows are marked?
492 :
493 : // Optimized to not loop over MAXCOL*MAXROW as worst case, i.e. Ctrl+A
494 :
495 167 : const SCCOLROW nMultiStart = aMultiRange.aStart.Row();
496 167 : const SCCOLROW nMultiEnd = aMultiRange.aEnd.Row();
497 :
498 167 : bool* bRowMarked = new bool[MAXROWCOUNT];
499 167 : memset( bRowMarked, 0, sizeof(bool) * MAXROWCOUNT);
500 : SCROW nRow;
501 : SCCOL nCol;
502 :
503 167 : SCROW nTop = -1, nBottom = -1;
504 167 : for (nCol = aMultiRange.aStart.Col(); nCol <= aMultiRange.aEnd.Col(); ++nCol)
505 : {
506 167 : ScMarkArrayIter aMarkIter( &pMultiSel[nCol] );
507 501 : while (aMarkIter.Next( nTop, nBottom ))
508 354 : for (nRow=nTop; nRow<=nBottom; nRow++)
509 187 : bRowMarked[nRow] = true;
510 167 : if (nTop == nMultiStart && nBottom == nMultiEnd)
511 167 : break; // for, all relevant rows marked
512 0 : }
513 :
514 167 : if (nTop == nMultiStart && nBottom == nMultiEnd)
515 : {
516 167 : pRanges[0] = nTop;
517 167 : pRanges[1] = nBottom;
518 167 : delete[] bRowMarked;
519 167 : return 1;
520 : }
521 :
522 : // Combine to ranges of rows.
523 :
524 0 : SCCOLROW nRangeCnt = 0;
525 0 : SCCOLROW nStart = nMultiStart;
526 0 : while (nStart <= nMultiEnd)
527 : {
528 0 : while (nStart < nMultiEnd && !bRowMarked[nStart])
529 0 : ++nStart;
530 0 : if (bRowMarked[nStart])
531 : {
532 0 : SCCOLROW nEnd = nStart;
533 0 : while (nEnd < nMultiEnd && bRowMarked[nEnd])
534 0 : ++nEnd;
535 0 : if (!bRowMarked[nEnd])
536 0 : --nEnd;
537 0 : pRanges[2*nRangeCnt ] = nStart;
538 0 : pRanges[2*nRangeCnt+1] = nEnd;
539 0 : ++nRangeCnt;
540 0 : nStart = nEnd+1;
541 : }
542 : else
543 0 : nStart = nMultiEnd+1;
544 : }
545 :
546 0 : delete[] bRowMarked;
547 0 : return nRangeCnt;
548 : }
549 :
550 33 : bool ScMarkData::IsAllMarked( const ScRange& rRange ) const
551 : {
552 33 : if ( !bMultiMarked )
553 19 : return false;
554 :
555 : OSL_ENSURE(pMultiSel, "bMultiMarked, but pMultiSel == 0");
556 :
557 14 : SCCOL nStartCol = rRange.aStart.Col();
558 14 : SCROW nStartRow = rRange.aStart.Row();
559 14 : SCCOL nEndCol = rRange.aEnd.Col();
560 14 : SCROW nEndRow = rRange.aEnd.Row();
561 14 : bool bOk = true;
562 50 : for (SCCOL nCol=nStartCol; nCol<=nEndCol && bOk; nCol++)
563 36 : if ( !pMultiSel[nCol].IsAllMarked( nStartRow, nEndRow ) )
564 0 : bOk = false;
565 :
566 14 : return bOk;
567 : }
568 :
569 0 : SCsROW ScMarkData::GetNextMarked( SCCOL nCol, SCsROW nRow, bool bUp ) const
570 : {
571 0 : if ( !bMultiMarked )
572 0 : return nRow;
573 :
574 : OSL_ENSURE(pMultiSel, "bMultiMarked, but pMultiSel == 0");
575 :
576 0 : return pMultiSel[nCol].GetNextMarked( nRow, bUp );
577 : }
578 :
579 22528 : bool ScMarkData::HasMultiMarks( SCCOL nCol ) const
580 : {
581 22528 : if ( !bMultiMarked )
582 0 : return false;
583 :
584 : OSL_ENSURE(pMultiSel, "bMultiMarked, but pMultiSel == 0");
585 :
586 22528 : return pMultiSel[nCol].HasMarks();
587 : }
588 :
589 0 : bool ScMarkData::HasAnyMultiMarks() const
590 : {
591 0 : if ( !bMultiMarked )
592 0 : return false;
593 :
594 : OSL_ENSURE(pMultiSel, "bMultiMarked, but pMultiSel == 0");
595 :
596 0 : for (SCCOL nCol=0; nCol<=MAXCOL; nCol++)
597 0 : if ( pMultiSel[nCol].HasMarks() )
598 0 : return true;
599 :
600 0 : return false; // nix
601 : }
602 :
603 37 : void ScMarkData::InsertTab( SCTAB nTab )
604 : {
605 37 : std::set<SCTAB> tabMarked(maTabMarked.begin(), maTabMarked.upper_bound(nTab));
606 37 : std::set<SCTAB>::iterator it = maTabMarked.upper_bound(nTab);
607 37 : for (; it != maTabMarked.end(); ++it)
608 0 : tabMarked.insert(*it + 1);
609 37 : maTabMarked.swap(tabMarked);
610 37 : }
611 :
612 18 : void ScMarkData::DeleteTab( SCTAB nTab )
613 : {
614 18 : std::set<SCTAB> tabMarked(maTabMarked.begin(), maTabMarked.find(nTab));
615 18 : tabMarked.erase( nTab );
616 18 : std::set<SCTAB>::iterator it = maTabMarked.find(nTab);
617 35 : for (; it != maTabMarked.end(); ++it)
618 17 : tabMarked.insert(*it + 1);
619 18 : maTabMarked.swap(tabMarked);
620 18 : }
621 :
622 : //iterators
623 460 : ScMarkData::iterator ScMarkData::begin()
624 : {
625 460 : return maTabMarked.begin();
626 : }
627 :
628 395 : ScMarkData::iterator ScMarkData::end()
629 : {
630 395 : return maTabMarked.end();
631 : }
632 :
633 13063 : ScMarkData::const_iterator ScMarkData::begin() const
634 : {
635 13063 : return maTabMarked.begin();
636 : }
637 :
638 12961 : ScMarkData::const_iterator ScMarkData::end() const
639 : {
640 12961 : return maTabMarked.end();
641 : }
642 :
643 :
644 :
645 :
646 :
647 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
