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