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 "scitems.hxx"
21 : #include "attrib.hxx"
22 : #include "patattr.hxx"
23 : #include "docpool.hxx"
24 : #include "formulacell.hxx"
25 : #include "table.hxx"
26 : #include "column.hxx"
27 : #include "document.hxx"
28 : #include "drwlayer.hxx"
29 : #include "olinetab.hxx"
30 : #include "userlist.hxx"
31 : #include "stlsheet.hxx"
32 : #include "global.hxx"
33 : #include "rechead.hxx"
34 : #include "stlpool.hxx"
35 : #include "brdcst.hxx"
36 : #include "tabprotection.hxx"
37 : #include "globstr.hrc"
38 : #include "segmenttree.hxx"
39 : #include "columniterator.hxx"
40 : #include "globalnames.hxx"
41 : #include "scmod.hxx"
42 : #include "printopt.hxx"
43 :
44 : #include <com/sun/star/sheet/TablePageBreakData.hpp>
45 :
46 : #include <algorithm>
47 : #include <limits>
48 : #include <iostream>
49 :
50 : using ::com::sun::star::uno::Sequence;
51 : using ::com::sun::star::sheet::TablePageBreakData;
52 : using ::std::set;
53 :
54 : // STATIC DATA -----------------------------------------------------------
55 :
56 : #define GET_SCALEVALUE(set,id) static_cast<const SfxUInt16Item&>(set.Get( id )).GetValue()
57 :
58 5660 : void ScTable::UpdatePageBreaks( const ScRange* pUserArea )
59 : {
60 5660 : if ( pDocument->IsImportingXML() )
61 10802 : return;
62 :
63 : // pUserArea != NULL -> print area is specified. We need to force-update
64 : // the page breaks.
65 :
66 438 : if (!pUserArea)
67 : {
68 434 : if (!bPageSizeValid)
69 158 : return;
70 :
71 : // Always update breaks if force breaks option has changed
72 276 : if (mbPageBreaksValid && mbForceBreaks == SC_MOD()->GetPrintOptions().GetForceBreaks())
73 200 : return;
74 : }
75 :
76 80 : SfxStyleSheetBase* pStyle = pDocument->GetStyleSheetPool()->
77 80 : Find( aPageStyle, SFX_STYLE_FAMILY_PAGE );
78 80 : if ( !pStyle )
79 : {
80 : OSL_FAIL("UpdatePageBreaks: Style not found");
81 0 : return;
82 : }
83 80 : SfxItemSet* pStyleSet = &pStyle->GetItemSet();
84 : const SfxPoolItem* pItem;
85 :
86 : SCCOL nX;
87 80 : SCCOL nStartCol = 0;
88 80 : SCROW nStartRow = 0;
89 80 : SCCOL nEndCol = MAXCOL;
90 80 : SCROW nEndRow = MAXROW;
91 80 : if (pUserArea)
92 : {
93 4 : nStartCol = pUserArea->aStart.Col();
94 4 : nStartRow = pUserArea->aStart.Row();
95 4 : nEndCol = pUserArea->aEnd.Col();
96 4 : nEndRow = pUserArea->aEnd.Row();
97 : }
98 : else
99 : {
100 76 : sal_uInt16 nAreaCount = GetPrintRangeCount();
101 76 : if ( nAreaCount > 1 )
102 : {
103 : // bei mehreren Bereichen nichts anzeigen:
104 :
105 0 : for (nX=0; nX<MAXCOL; nX++)
106 0 : RemoveColBreak(nX, true, false);
107 :
108 0 : RemoveRowPageBreaks(0, MAXROW-1);
109 :
110 0 : return;
111 : }
112 76 : else if ( nAreaCount == 1 )
113 : {
114 8 : const ScRange* pArea = GetPrintRange( 0 );
115 8 : if (pArea)
116 : {
117 8 : nStartCol = pArea->aStart.Col();
118 8 : nStartRow = pArea->aStart.Row();
119 8 : nEndCol = pArea->aEnd.Col();
120 8 : nEndRow = pArea->aEnd.Row();
121 : }
122 : } // sonst alles
123 : }
124 :
125 : // get bSkipColBreaks/bSkipRowBreaks flags:
126 : // fdo#40788 - print range scale settings can cause manual breaks to be
127 : // ignored (see below). This behaviour may now be set by the user.
128 80 : mbForceBreaks = SC_MOD()->GetPrintOptions().GetForceBreaks();
129 80 : bool bSkipColBreaks = false;
130 80 : bool bSkipRowBreaks = false;
131 :
132 80 : if (!mbForceBreaks)
133 : {
134 80 : if ( pStyleSet->GetItemState( ATTR_PAGE_SCALETOPAGES, false, &pItem ) == SfxItemState::SET )
135 : {
136 : OSL_ENSURE( pItem->ISA(SfxUInt16Item), "invalid Item" );
137 0 : bSkipColBreaks = bSkipRowBreaks = static_cast<const SfxUInt16Item*>(pItem)->GetValue() > 0;
138 : }
139 :
140 80 : if ( !bSkipColBreaks && pStyleSet->GetItemState(ATTR_PAGE_SCALETO, false, &pItem) == SfxItemState::SET )
141 : {
142 : // #i54993# when fitting to width or height, ignore only manual breaks in that direction
143 0 : const ScPageScaleToItem* pScaleToItem = static_cast<const ScPageScaleToItem*>(pItem);
144 0 : if ( pScaleToItem->GetWidth() > 0 )
145 0 : bSkipColBreaks = true;
146 0 : if ( pScaleToItem->GetHeight() > 0 )
147 0 : bSkipRowBreaks = true;
148 : }
149 : }
150 :
151 80 : long nPageSizeX = aPageSizeTwips.Width();
152 80 : long nPageSizeY = aPageSizeTwips.Height();
153 :
154 : // Anfang: Breaks loeschen
155 :
156 80 : for (nX=0; nX<nStartCol; nX++)
157 0 : RemoveColBreak(nX, true, false);
158 80 : RemoveRowPageBreaks(0, nStartRow-1);
159 :
160 80 : if (nStartCol > 0)
161 0 : SetColBreak(nStartCol, true, false); // AREABREAK
162 80 : if (nStartRow > 0)
163 0 : SetRowBreak(nStartRow, true, false); // AREABREAK
164 :
165 : // Mittelteil: Breaks verteilen
166 :
167 80 : bool bRepeatCol = ( nRepeatStartX != SCCOL_REPEAT_NONE );
168 80 : bool bColFound = false;
169 80 : long nSizeX = 0;
170 69888 : for (nX=nStartCol; nX<=nEndCol; nX++)
171 : {
172 69808 : bool bStartOfPage = false;
173 69808 : long nThisX = ColHidden(nX) ? 0 : pColWidth[nX];
174 69808 : bool bManualBreak = HasColManualBreak(nX);
175 69808 : if ( (nSizeX+nThisX > nPageSizeX) || (bManualBreak && !bSkipColBreaks) )
176 : {
177 9966 : SetColBreak(nX, true, false);
178 9966 : nSizeX = 0;
179 9966 : bStartOfPage = true;
180 : }
181 59842 : else if (nX != nStartCol)
182 59762 : RemoveColBreak(nX, true, false);
183 : else
184 80 : bStartOfPage = true;
185 :
186 69808 : if ( bStartOfPage && bRepeatCol && nX>nRepeatStartX && !bColFound )
187 : {
188 : // subtract size of repeat columns from page size
189 12 : for (SCCOL i=nRepeatStartX; i<=nRepeatEndX; i++)
190 6 : nPageSizeX -= ColHidden(i) ? 0 : pColWidth[i];
191 12 : while (nX<=nRepeatEndX)
192 0 : RemoveColBreak(++nX, true, false);
193 6 : bColFound = true;
194 : }
195 :
196 69808 : nSizeX += nThisX;
197 : }
198 :
199 : // Remove all page breaks in range.
200 80 : RemoveRowPageBreaks(nStartRow+1, nEndRow);
201 :
202 : // And set new page breaks.
203 80 : bool bRepeatRow = ( nRepeatStartY != SCROW_REPEAT_NONE );
204 80 : bool bRowFound = false;
205 80 : long nSizeY = 0;
206 80 : ScFlatBoolRowSegments::ForwardIterator aIterHidden(*mpHiddenRows);
207 80 : ScFlatUInt16RowSegments::ForwardIterator aIterHeights(*mpRowHeights);
208 80 : SCROW nNextManualBreak = GetNextManualBreak(nStartRow); // -1 => no more manual breaks
209 1421730 : for (SCROW nY = nStartRow; nY <= nEndRow; ++nY)
210 : {
211 1421650 : bool bStartOfPage = false;
212 1421650 : bool bThisRowHidden = false;
213 1421650 : aIterHidden.getValue(nY, bThisRowHidden);
214 1421650 : long nThisY = 0;
215 1421650 : if (!bThisRowHidden)
216 : {
217 : sal_uInt16 nTmp;
218 1421626 : aIterHeights.getValue(nY, nTmp);
219 1421626 : nThisY = static_cast<long>(nTmp);
220 : }
221 :
222 1421650 : bool bManualBreak = false;
223 1421650 : if (nNextManualBreak >= 0)
224 : {
225 16 : bManualBreak = (nY == nNextManualBreak);
226 16 : if (nY >= nNextManualBreak)
227 : // Query the next menual break position.
228 4 : nNextManualBreak = GetNextManualBreak(nY+1);
229 : }
230 :
231 1421650 : if ( (nSizeY+nThisY > nPageSizeY) || (bManualBreak && !bSkipRowBreaks) )
232 : {
233 1421350 : SetRowBreak(nY, true, false);
234 1421350 : nSizeY = 0;
235 1421350 : bStartOfPage = true;
236 : }
237 300 : else if (nY != nStartRow)
238 : ; // page break already removed
239 : else
240 80 : bStartOfPage = true;
241 :
242 1421650 : if ( bStartOfPage && bRepeatRow && nY>nRepeatStartY && !bRowFound )
243 : {
244 : // subtract size of repeat rows from page size
245 6 : unsigned long nHeights = GetTotalRowHeight(nRepeatStartY, nRepeatEndY);
246 : #if OSL_DEBUG_LEVEL > 0
247 : if (nHeights == ::std::numeric_limits<unsigned long>::max())
248 : OSL_FAIL("ScTable::UpdatePageBreaks: row heights overflow");
249 : #endif
250 6 : nPageSizeY -= nHeights;
251 6 : if (nY <= nRepeatEndY)
252 0 : RemoveRowPageBreaks(nY, nRepeatEndY);
253 6 : bRowFound = true;
254 : }
255 :
256 1421650 : if (bThisRowHidden)
257 : {
258 : // Hidden row range. Skip them unless there is a manual break.
259 24 : SCROW nLastCommon = aIterHidden.getLastPos();
260 24 : if (nNextManualBreak >= 0)
261 0 : nLastCommon = ::std::min(nLastCommon, nNextManualBreak-1);
262 24 : nY = nLastCommon;
263 : }
264 : else
265 : {
266 : // Visible row range.
267 :
268 1421626 : SCROW nLastHidden = aIterHidden.getLastPos();
269 1421626 : SCROW nLastHeight = aIterHeights.getLastPos();
270 1421626 : SCROW nLastCommon = ::std::min(nLastHidden, nLastHeight);
271 1421626 : if (nNextManualBreak >= 0)
272 12 : nLastCommon = ::std::min(nLastCommon, nNextManualBreak-1);
273 :
274 1421626 : if (nLastCommon > nY)
275 : {
276 1421482 : long nMaxMultiple = static_cast<long>(nLastCommon - nY);
277 1421482 : long nMultiple = (nPageSizeY - nSizeY) / nThisY;
278 1421482 : if (nMultiple > nMaxMultiple)
279 124 : nMultiple = nMaxMultiple;
280 1421482 : if (nMultiple > 1)
281 : {
282 1421478 : nSizeY += nThisY * (nMultiple - 1);
283 1421478 : nY += nMultiple - 1;
284 : }
285 : }
286 : }
287 :
288 1421650 : nSizeY += nThisY;
289 : }
290 :
291 : // Ende: Breaks loeschen
292 :
293 80 : if (nEndCol < MAXCOL)
294 : {
295 12 : SetColBreak(nEndCol+1, true, false); // AREABREAK
296 12112 : for (nX=nEndCol+2; nX<=MAXCOL; nX++)
297 12100 : RemoveColBreak(nX, true, false);
298 : }
299 80 : if (nEndRow < MAXROW)
300 : {
301 12 : SetRowBreak(nEndRow+1, true, false); // AREABREAK
302 12 : if (nEndRow+2 <= MAXROW)
303 12 : RemoveRowPageBreaks(nEndRow+2, MAXROW);
304 : }
305 80 : mbPageBreaksValid = !pUserArea; // #i116881# the valid flag can only apply to the "no user area" case
306 : }
307 :
308 0 : void ScTable::RemoveManualBreaks()
309 : {
310 0 : maRowManualBreaks.clear();
311 0 : maColManualBreaks.clear();
312 0 : InvalidatePageBreaks();
313 :
314 0 : if (IsStreamValid())
315 0 : SetStreamValid(false);
316 0 : }
317 :
318 0 : bool ScTable::HasManualBreaks() const
319 : {
320 0 : return !maRowManualBreaks.empty() || !maColManualBreaks.empty();
321 : }
322 :
323 246 : void ScTable::SetRowManualBreaks( const ::std::set<SCROW>& rBreaks )
324 : {
325 246 : maRowManualBreaks = rBreaks;
326 246 : InvalidatePageBreaks();
327 246 : if (IsStreamValid())
328 0 : SetStreamValid(false);
329 246 : }
330 :
331 216 : void ScTable::SetColManualBreaks( const ::std::set<SCCOL>& rBreaks )
332 : {
333 216 : maColManualBreaks = rBreaks;
334 216 : InvalidatePageBreaks();
335 216 : if (IsStreamValid())
336 0 : SetStreamValid(false);
337 216 : }
338 :
339 124 : void ScTable::GetAllRowBreaks(set<SCROW>& rBreaks, bool bPage, bool bManual) const
340 : {
341 124 : if (bPage)
342 0 : rBreaks = maRowPageBreaks;
343 :
344 124 : if (bManual)
345 : {
346 : using namespace std;
347 124 : copy(maRowManualBreaks.begin(), maRowManualBreaks.end(), inserter(rBreaks, rBreaks.begin()));
348 : }
349 124 : }
350 :
351 124 : void ScTable::GetAllColBreaks(set<SCCOL>& rBreaks, bool bPage, bool bManual) const
352 : {
353 124 : if (bPage)
354 0 : rBreaks = maColPageBreaks;
355 :
356 124 : if (bManual)
357 : {
358 : using namespace std;
359 124 : copy(maColManualBreaks.begin(), maColManualBreaks.end(), inserter(rBreaks, rBreaks.begin()));
360 : }
361 124 : }
362 :
363 22738 : bool ScTable::HasRowPageBreak(SCROW nRow) const
364 : {
365 22738 : if (!ValidRow(nRow))
366 0 : return false;
367 :
368 22738 : return maRowPageBreaks.find(nRow) != maRowPageBreaks.end();
369 : }
370 :
371 66324 : bool ScTable::HasColPageBreak(SCCOL nCol) const
372 : {
373 66324 : if (!ValidCol(nCol))
374 0 : return false;
375 :
376 66324 : return maColPageBreaks.find(nCol) != maColPageBreaks.end();
377 : }
378 :
379 22782 : bool ScTable::HasRowManualBreak(SCROW nRow) const
380 : {
381 22782 : if (!ValidRow(nRow))
382 0 : return false;
383 :
384 22782 : return maRowManualBreaks.find(nRow) != maRowManualBreaks.end();
385 : }
386 :
387 136132 : bool ScTable::HasColManualBreak(SCCOL nCol) const
388 : {
389 136132 : if (!ValidCol(nCol))
390 0 : return false;
391 :
392 136132 : return maColManualBreaks.find(nCol) != maColManualBreaks.end();
393 : }
394 :
395 84 : SCROW ScTable::GetNextManualBreak(SCROW nRow) const
396 : {
397 84 : set<SCROW>::const_iterator itr = maRowManualBreaks.lower_bound(nRow);
398 84 : return itr == maRowManualBreaks.end() ? -1 : *itr;
399 : }
400 :
401 172 : void ScTable::RemoveRowPageBreaks(SCROW nStartRow, SCROW nEndRow)
402 : {
403 : using namespace std;
404 :
405 172 : if (!ValidRow(nStartRow) || !ValidRow(nEndRow))
406 252 : return;
407 :
408 92 : set<SCROW>::iterator low = maRowPageBreaks.lower_bound(nStartRow);
409 92 : set<SCROW>::iterator high = maRowPageBreaks.upper_bound(nEndRow);
410 92 : maRowPageBreaks.erase(low, high);
411 : }
412 :
413 6 : void ScTable::RemoveRowBreak(SCROW nRow, bool bPage, bool bManual)
414 : {
415 6 : if (!ValidRow(nRow))
416 6 : return;
417 :
418 6 : if (bPage)
419 0 : maRowPageBreaks.erase(nRow);
420 :
421 6 : if (bManual)
422 : {
423 6 : maRowManualBreaks.erase(nRow);
424 6 : InvalidatePageBreaks();
425 : }
426 : }
427 :
428 71864 : void ScTable::RemoveColBreak(SCCOL nCol, bool bPage, bool bManual)
429 : {
430 71864 : if (!ValidCol(nCol))
431 71864 : return;
432 :
433 71864 : if (bPage)
434 71862 : maColPageBreaks.erase(nCol);
435 :
436 71864 : if (bManual)
437 : {
438 2 : maColManualBreaks.erase(nCol);
439 2 : InvalidatePageBreaks();
440 : }
441 : }
442 :
443 1421364 : void ScTable::SetRowBreak(SCROW nRow, bool bPage, bool bManual)
444 : {
445 1421364 : if (!ValidRow(nRow))
446 1421364 : return;
447 :
448 1421364 : if (bPage)
449 1421362 : maRowPageBreaks.insert(nRow);
450 :
451 1421364 : if (bManual)
452 : {
453 2 : maRowManualBreaks.insert(nRow);
454 2 : InvalidatePageBreaks();
455 : }
456 : }
457 :
458 9980 : void ScTable::SetColBreak(SCCOL nCol, bool bPage, bool bManual)
459 : {
460 9980 : if (!ValidCol(nCol))
461 9980 : return;
462 :
463 9980 : if (bPage)
464 9978 : maColPageBreaks.insert(nCol);
465 :
466 9980 : if (bManual)
467 : {
468 2 : maColManualBreaks.insert(nCol);
469 2 : InvalidatePageBreaks();
470 : }
471 : }
472 :
473 12 : Sequence<TablePageBreakData> ScTable::GetRowBreakData() const
474 : {
475 : using ::std::copy;
476 : using ::std::inserter;
477 :
478 12 : set<SCROW> aRowBreaks = maRowPageBreaks;
479 12 : copy(maRowManualBreaks.begin(), maRowManualBreaks.end(), inserter(aRowBreaks, aRowBreaks.begin()));
480 :
481 12 : set<SCROW>::const_iterator itr = aRowBreaks.begin(), itrEnd = aRowBreaks.end();
482 12 : Sequence<TablePageBreakData> aSeq(aRowBreaks.size());
483 :
484 56 : for (sal_Int32 i = 0; itr != itrEnd; ++itr, ++i)
485 : {
486 44 : SCROW nRow = *itr;
487 44 : TablePageBreakData aData;
488 44 : aData.Position = nRow;
489 44 : aData.ManualBreak = HasRowManualBreak(nRow);
490 44 : aSeq[i] = aData;
491 : }
492 :
493 12 : return aSeq;
494 : }
495 :
496 18959911 : bool ScTable::RowHidden(SCROW nRow, SCROW* pFirstRow, SCROW* pLastRow) const
497 : {
498 18959911 : if (!ValidRow(nRow))
499 : {
500 2 : if (pFirstRow)
501 2 : *pFirstRow = nRow;
502 2 : if (pLastRow)
503 0 : *pLastRow = nRow;
504 2 : return true;
505 : }
506 :
507 : ScFlatBoolRowSegments::RangeData aData;
508 18959909 : if (!mpHiddenRows->getRangeData(nRow, aData))
509 : {
510 : // search failed.
511 0 : if (pFirstRow)
512 0 : *pFirstRow = nRow;
513 0 : if (pLastRow)
514 0 : *pLastRow = nRow;
515 0 : return true;
516 : }
517 :
518 18959909 : if (pFirstRow)
519 12583406 : *pFirstRow = aData.mnRow1;
520 18959909 : if (pLastRow)
521 18339011 : *pLastRow = aData.mnRow2;
522 :
523 18959909 : return aData.mbValue;
524 : }
525 :
526 226 : bool ScTable::RowHiddenLeaf(SCROW nRow, SCROW* pFirstRow, SCROW* pLastRow) const
527 : {
528 226 : if (!ValidRow(nRow))
529 : {
530 0 : if (pFirstRow)
531 0 : *pFirstRow = nRow;
532 0 : if (pLastRow)
533 0 : *pLastRow = nRow;
534 0 : return true;
535 : }
536 :
537 : ScFlatBoolRowSegments::RangeData aData;
538 226 : if (!mpHiddenRows->getRangeDataLeaf(nRow, aData))
539 : {
540 : // search failed.
541 0 : if (pFirstRow)
542 0 : *pFirstRow = nRow;
543 0 : if (pLastRow)
544 0 : *pLastRow = nRow;
545 0 : return true;
546 : }
547 :
548 226 : if (pFirstRow)
549 0 : *pFirstRow = aData.mnRow1;
550 226 : if (pLastRow)
551 226 : *pLastRow = aData.mnRow2;
552 :
553 226 : return aData.mbValue;
554 : }
555 :
556 6 : bool ScTable::HasHiddenRows(SCROW nStartRow, SCROW nEndRow) const
557 : {
558 6 : SCROW nRow = nStartRow;
559 18 : while (nRow <= nEndRow)
560 : {
561 6 : SCROW nLastRow = -1;
562 6 : bool bHidden = RowHidden(nRow, NULL, &nLastRow);
563 6 : if (bHidden)
564 0 : return true;
565 :
566 6 : nRow = nLastRow + 1;
567 : }
568 6 : return false;
569 : }
570 :
571 8230218 : bool ScTable::ColHidden(SCCOL nCol, SCCOL* pFirstCol, SCCOL* pLastCol) const
572 : {
573 8230218 : if (!ValidCol(nCol))
574 0 : return true;
575 :
576 : ScFlatBoolColSegments::RangeData aData;
577 8230218 : if (!mpHiddenCols->getRangeData(nCol, aData))
578 0 : return true;
579 :
580 8230218 : if (pFirstCol)
581 20 : *pFirstCol = aData.mnCol1;
582 8230218 : if (pLastCol)
583 26219 : *pLastCol = aData.mnCol2;
584 :
585 8230218 : return aData.mbValue;
586 : }
587 :
588 872 : bool ScTable::SetRowHidden(SCROW nStartRow, SCROW nEndRow, bool bHidden)
589 : {
590 872 : bool bChanged = false;
591 872 : if (bHidden)
592 306 : bChanged = mpHiddenRows->setTrue(nStartRow, nEndRow);
593 : else
594 566 : bChanged = mpHiddenRows->setFalse(nStartRow, nEndRow);
595 :
596 872 : if (bChanged)
597 : {
598 278 : if (IsStreamValid())
599 0 : SetStreamValid(false);
600 : }
601 :
602 872 : return bChanged;
603 : }
604 :
605 109870 : bool ScTable::SetColHidden(SCCOL nStartCol, SCCOL nEndCol, bool bHidden)
606 : {
607 109870 : bool bChanged = false;
608 109870 : if (bHidden)
609 654 : bChanged = mpHiddenCols->setTrue(nStartCol, nEndCol);
610 : else
611 109216 : bChanged = mpHiddenCols->setFalse(nStartCol, nEndCol);
612 :
613 109870 : if (bChanged)
614 : {
615 834 : if (IsStreamValid())
616 2 : SetStreamValid(false);
617 : }
618 :
619 109870 : return bChanged;
620 : }
621 :
622 104 : void ScTable::CopyColHidden(ScTable& rTable, SCCOL nStartCol, SCCOL nEndCol)
623 : {
624 104 : SCCOL nCol = nStartCol;
625 312 : while (nCol <= nEndCol)
626 : {
627 : SCCOL nLastCol;
628 104 : bool bHidden = rTable.ColHidden(nCol, NULL, &nLastCol);
629 104 : if (nLastCol > nEndCol)
630 104 : nLastCol = nEndCol;
631 :
632 104 : SetColHidden(nCol, nLastCol, bHidden);
633 104 : nCol = nLastCol + 1;
634 : }
635 104 : }
636 :
637 104 : void ScTable::CopyRowHidden(ScTable& rTable, SCROW nStartRow, SCROW nEndRow)
638 : {
639 104 : SCROW nRow = nStartRow;
640 312 : while (nRow <= nEndRow)
641 : {
642 104 : SCROW nLastRow = -1;
643 104 : bool bHidden = rTable.RowHidden(nRow, NULL, &nLastRow);
644 104 : if (nLastRow > nEndRow)
645 104 : nLastRow = nEndRow;
646 104 : SetRowHidden(nRow, nLastRow, bHidden);
647 104 : nRow = nLastRow + 1;
648 : }
649 104 : }
650 :
651 350 : void ScTable::CopyRowHeight(ScTable& rSrcTable, SCROW nStartRow, SCROW nEndRow, SCROW nSrcOffset)
652 : {
653 350 : SCROW nRow = nStartRow;
654 : ScFlatUInt16RowSegments::RangeData aSrcData;
655 1312 : while (nRow <= nEndRow)
656 : {
657 612 : if (!rSrcTable.mpRowHeights->getRangeData(nRow + nSrcOffset, aSrcData))
658 : // Something is wrong !
659 0 : return;
660 :
661 612 : SCROW nLastRow = aSrcData.mnRow2 - nSrcOffset;
662 612 : if (nLastRow > nEndRow)
663 214 : nLastRow = nEndRow;
664 :
665 612 : mpRowHeights->setValue(nRow, nLastRow, aSrcData.mnValue);
666 612 : nRow = nLastRow + 1;
667 : }
668 : }
669 :
670 318 : SCROW ScTable::FirstVisibleRow(SCROW nStartRow, SCROW nEndRow) const
671 : {
672 318 : SCROW nRow = nStartRow;
673 : ScFlatBoolRowSegments::RangeData aData;
674 858 : while (nRow <= nEndRow)
675 : {
676 540 : if (!ValidRow(nRow))
677 0 : break;
678 :
679 540 : if (!mpHiddenRows->getRangeData(nRow, aData))
680 : // failed to get range data.
681 0 : break;
682 :
683 540 : if (!aData.mbValue)
684 : // visible row found
685 318 : return nRow;
686 :
687 222 : nRow = aData.mnRow2 + 1;
688 : }
689 :
690 0 : return ::std::numeric_limits<SCROW>::max();
691 : }
692 :
693 12 : SCROW ScTable::LastVisibleRow(SCROW nStartRow, SCROW nEndRow) const
694 : {
695 12 : SCROW nRow = nEndRow;
696 : ScFlatBoolRowSegments::RangeData aData;
697 24 : while (nRow >= nStartRow)
698 : {
699 12 : if (!ValidRow(nRow))
700 0 : break;
701 :
702 12 : if (!mpHiddenRows->getRangeData(nRow, aData))
703 : // failed to get range data.
704 0 : break;
705 :
706 12 : if (!aData.mbValue)
707 : // visible row found
708 12 : return nRow;
709 :
710 0 : nRow = aData.mnRow1 - 1;
711 : }
712 :
713 0 : return ::std::numeric_limits<SCROW>::max();
714 : }
715 :
716 76 : SCROW ScTable::CountVisibleRows(SCROW nStartRow, SCROW nEndRow) const
717 : {
718 76 : SCROW nCount = 0;
719 76 : SCROW nRow = nStartRow;
720 : ScFlatBoolRowSegments::RangeData aData;
721 228 : while (nRow <= nEndRow)
722 : {
723 76 : if (!mpHiddenRows->getRangeData(nRow, aData))
724 0 : break;
725 :
726 76 : if (aData.mnRow2 > nEndRow)
727 76 : aData.mnRow2 = nEndRow;
728 :
729 76 : if (!aData.mbValue)
730 76 : nCount += aData.mnRow2 - nRow + 1;
731 :
732 76 : nRow = aData.mnRow2 + 1;
733 : }
734 76 : return nCount;
735 : }
736 :
737 7034 : sal_uInt32 ScTable::GetTotalRowHeight(SCROW nStartRow, SCROW nEndRow, bool bHiddenAsZero ) const
738 : {
739 7034 : sal_uInt32 nHeight = 0;
740 7034 : SCROW nRow = nStartRow;
741 : ScFlatBoolRowSegments::RangeData aData;
742 21506 : while (nRow <= nEndRow)
743 : {
744 7438 : if (!mpHiddenRows->getRangeData(nRow, aData))
745 0 : break;
746 :
747 7438 : if (aData.mnRow2 > nEndRow)
748 1984 : aData.mnRow2 = nEndRow;
749 :
750 7438 : if ( !( bHiddenAsZero && aData.mbValue ) )
751 : // visible row range.
752 7192 : nHeight += mpRowHeights->getSumValue(nRow, aData.mnRow2);
753 :
754 7438 : nRow = aData.mnRow2 + 1;
755 : }
756 :
757 7034 : return nHeight;
758 : }
759 :
760 0 : SCCOLROW ScTable::LastHiddenColRow(SCCOLROW nPos, bool bCol) const
761 : {
762 0 : if (bCol)
763 : {
764 0 : SCCOL nCol = static_cast<SCCOL>(nPos);
765 0 : if (ColHidden(nCol))
766 : {
767 0 : for (SCCOL i = nCol+1; i <= MAXCOL; ++i)
768 : {
769 0 : if (!ColHidden(nCol))
770 0 : return nCol - 1;
771 : }
772 : }
773 : }
774 : else
775 : {
776 0 : SCROW nRow = static_cast<SCROW>(nPos);
777 : SCROW nLastRow;
778 0 : if (RowHidden(nRow, NULL, &nLastRow))
779 0 : return static_cast<SCCOLROW>(nLastRow);
780 : }
781 0 : return ::std::numeric_limits<SCCOLROW>::max();
782 : }
783 :
784 12588407 : bool ScTable::RowFiltered(SCROW nRow, SCROW* pFirstRow, SCROW* pLastRow) const
785 : {
786 12588407 : if (!ValidRow(nRow))
787 0 : return false;
788 :
789 : ScFlatBoolRowSegments::RangeData aData;
790 12588407 : if (!mpFilteredRows->getRangeData(nRow, aData))
791 : // search failed.
792 0 : return false;
793 :
794 12588407 : if (pFirstRow)
795 12583182 : *pFirstRow = aData.mnRow1;
796 12588407 : if (pLastRow)
797 12588331 : *pLastRow = aData.mnRow2;
798 :
799 12588407 : return aData.mbValue;
800 : }
801 :
802 146 : bool ScTable::ColFiltered(SCCOL nCol, SCCOL* pFirstCol, SCCOL* pLastCol) const
803 : {
804 146 : if (!ValidCol(nCol))
805 0 : return false;
806 :
807 : ScFlatBoolColSegments::RangeData aData;
808 146 : if (!mpFilteredCols->getRangeData(nCol, aData))
809 : // search failed.
810 0 : return false;
811 :
812 146 : if (pFirstCol)
813 0 : *pFirstCol = aData.mnCol1;
814 146 : if (pLastCol)
815 104 : *pLastCol = aData.mnCol2;
816 :
817 146 : return aData.mbValue;
818 : }
819 :
820 1797 : bool ScTable::HasFilteredRows(SCROW nStartRow, SCROW nEndRow) const
821 : {
822 1797 : SCROW nRow = nStartRow;
823 5391 : while (nRow <= nEndRow)
824 : {
825 1797 : SCROW nLastRow = nRow;
826 1797 : bool bFiltered = RowFiltered(nRow, NULL, &nLastRow);
827 1797 : if (bFiltered)
828 0 : return true;
829 :
830 1797 : nRow = nLastRow + 1;
831 : }
832 1797 : return false;
833 : }
834 :
835 104 : void ScTable::CopyColFiltered(ScTable& rTable, SCCOL nStartCol, SCCOL nEndCol)
836 : {
837 104 : SCCOL nCol = nStartCol;
838 312 : while (nCol <= nEndCol)
839 : {
840 104 : SCCOL nLastCol = -1;
841 104 : bool bFiltered = rTable.ColFiltered(nCol, NULL, &nLastCol);
842 104 : if (nLastCol > nEndCol)
843 104 : nLastCol = nEndCol;
844 :
845 104 : SetColFiltered(nCol, nLastCol, bFiltered);
846 104 : nCol = nLastCol + 1;
847 : }
848 104 : }
849 :
850 104 : void ScTable::CopyRowFiltered(ScTable& rTable, SCROW nStartRow, SCROW nEndRow)
851 : {
852 104 : SCROW nRow = nStartRow;
853 312 : while (nRow <= nEndRow)
854 : {
855 104 : SCROW nLastRow = -1;
856 104 : bool bFiltered = rTable.RowFiltered(nRow, NULL, &nLastRow);
857 104 : if (nLastRow > nEndRow)
858 104 : nLastRow = nEndRow;
859 104 : SetRowFiltered(nRow, nLastRow, bFiltered);
860 104 : nRow = nLastRow + 1;
861 : }
862 104 : }
863 :
864 748 : void ScTable::SetRowFiltered(SCROW nStartRow, SCROW nEndRow, bool bFiltered)
865 : {
866 748 : if (bFiltered)
867 178 : mpFilteredRows->setTrue(nStartRow, nEndRow);
868 : else
869 570 : mpFilteredRows->setFalse(nStartRow, nEndRow);
870 748 : }
871 :
872 104 : void ScTable::SetColFiltered(SCCOL nStartCol, SCCOL nEndCol, bool bFiltered)
873 : {
874 104 : if (bFiltered)
875 0 : mpFilteredCols->setTrue(nStartCol, nEndCol);
876 : else
877 104 : mpFilteredCols->setFalse(nStartCol, nEndCol);
878 104 : }
879 :
880 72 : SCROW ScTable::FirstNonFilteredRow(SCROW nStartRow, SCROW nEndRow) const
881 : {
882 72 : SCROW nRow = nStartRow;
883 : ScFlatBoolRowSegments::RangeData aData;
884 144 : while (nRow <= nEndRow)
885 : {
886 72 : if (!ValidRow(nRow))
887 0 : break;
888 :
889 72 : if (!mpFilteredRows->getRangeData(nRow, aData))
890 : // failed to get range data.
891 0 : break;
892 :
893 72 : if (!aData.mbValue)
894 : // non-filtered row found
895 72 : return nRow;
896 :
897 0 : nRow = aData.mnRow2 + 1;
898 : }
899 :
900 0 : return ::std::numeric_limits<SCROW>::max();
901 : }
902 :
903 0 : SCROW ScTable::LastNonFilteredRow(SCROW nStartRow, SCROW nEndRow) const
904 : {
905 0 : SCROW nRow = nEndRow;
906 : ScFlatBoolRowSegments::RangeData aData;
907 0 : while (nRow >= nStartRow)
908 : {
909 0 : if (!ValidRow(nRow))
910 0 : break;
911 :
912 0 : if (!mpFilteredRows->getRangeData(nRow, aData))
913 : // failed to get range data.
914 0 : break;
915 :
916 0 : if (!aData.mbValue)
917 : // non-filtered row found
918 0 : return nRow;
919 :
920 0 : nRow = aData.mnRow1 - 1;
921 : }
922 :
923 0 : return ::std::numeric_limits<SCROW>::max();
924 : }
925 :
926 142 : SCROW ScTable::CountNonFilteredRows(SCROW nStartRow, SCROW nEndRow) const
927 : {
928 142 : SCROW nCount = 0;
929 142 : SCROW nRow = nStartRow;
930 : ScFlatBoolRowSegments::RangeData aData;
931 426 : while (nRow <= nEndRow)
932 : {
933 142 : if (!mpFilteredRows->getRangeData(nRow, aData))
934 0 : break;
935 :
936 142 : if (aData.mnRow2 > nEndRow)
937 142 : aData.mnRow2 = nEndRow;
938 :
939 142 : if (!aData.mbValue)
940 142 : nCount += aData.mnRow2 - nRow + 1;
941 :
942 142 : nRow = aData.mnRow2 + 1;
943 : }
944 142 : return nCount;
945 : }
946 :
947 14 : bool ScTable::IsManualRowHeight(SCROW nRow) const
948 : {
949 14 : return (pRowFlags->GetValue(nRow) & CR_MANUALSIZE) != 0;
950 : }
951 :
952 : namespace {
953 :
954 152 : void lcl_syncFlags(ScFlatBoolColSegments& rColSegments, ScFlatBoolRowSegments& rRowSegments,
955 : sal_uInt8* pColFlags, ScBitMaskCompressedArray< SCROW, sal_uInt8>* pRowFlags, const sal_uInt8 nFlagMask)
956 : {
957 : using ::sal::static_int_cast;
958 :
959 152 : sal_uInt8 nFlagMaskComplement = static_int_cast<sal_uInt8>(~nFlagMask);
960 :
961 152 : pRowFlags->AndValue(0, MAXROW, nFlagMaskComplement);
962 155800 : for (SCCOL i = 0; i <= MAXCOL; ++i)
963 155648 : pColFlags[i] &= nFlagMaskComplement;
964 :
965 : {
966 : // row hidden flags.
967 :
968 152 : SCROW nRow = 0;
969 : ScFlatBoolRowSegments::RangeData aData;
970 456 : while (nRow <= MAXROW)
971 : {
972 152 : if (!rRowSegments.getRangeData(nRow, aData))
973 0 : break;
974 :
975 152 : if (aData.mbValue)
976 0 : pRowFlags->OrValue(nRow, aData.mnRow2, nFlagMask);
977 :
978 152 : nRow = aData.mnRow2 + 1;
979 : }
980 : }
981 :
982 : {
983 : // column hidden flags.
984 :
985 152 : SCCOL nCol = 0;
986 : ScFlatBoolColSegments::RangeData aData;
987 456 : while (nCol <= MAXCOL)
988 : {
989 152 : if (!rColSegments.getRangeData(nCol, aData))
990 0 : break;
991 :
992 152 : if (aData.mbValue)
993 : {
994 0 : for (SCCOL i = nCol; i <= aData.mnCol2; ++i)
995 0 : pColFlags[i] |= nFlagMask;
996 : }
997 :
998 152 : nCol = aData.mnCol2 + 1;
999 : }
1000 : }
1001 152 : }
1002 :
1003 : }
1004 :
1005 76 : void ScTable::SyncColRowFlags()
1006 : {
1007 : using ::sal::static_int_cast;
1008 :
1009 76 : sal_uInt8 nManualBreakComplement = static_int_cast<sal_uInt8>(~CR_MANUALBREAK);
1010 :
1011 : // Manual breaks.
1012 76 : pRowFlags->AndValue(0, MAXROW, nManualBreakComplement);
1013 77900 : for (SCCOL i = 0; i <= MAXCOL; ++i)
1014 77824 : pColFlags[i] &= nManualBreakComplement;
1015 :
1016 76 : if (!maRowManualBreaks.empty())
1017 : {
1018 0 : for (set<SCROW>::const_iterator itr = maRowManualBreaks.begin(), itrEnd = maRowManualBreaks.end();
1019 : itr != itrEnd; ++itr)
1020 0 : pRowFlags->OrValue(*itr, CR_MANUALBREAK);
1021 : }
1022 :
1023 76 : if (!maColManualBreaks.empty())
1024 : {
1025 0 : for (set<SCCOL>::const_iterator itr = maColManualBreaks.begin(), itrEnd = maColManualBreaks.end();
1026 : itr != itrEnd; ++itr)
1027 0 : pColFlags[*itr] |= CR_MANUALBREAK;
1028 : }
1029 :
1030 : // Hidden flags.
1031 76 : lcl_syncFlags(*mpHiddenCols, *mpHiddenRows, pColFlags, pRowFlags, CR_HIDDEN);
1032 76 : lcl_syncFlags(*mpFilteredCols, *mpFilteredRows, pColFlags, pRowFlags, CR_FILTERED);
1033 76 : }
1034 :
1035 720 : void ScTable::SetPageSize( const Size& rSize )
1036 : {
1037 720 : if ( rSize.Width() != 0 && rSize.Height() != 0 )
1038 : {
1039 720 : if (aPageSizeTwips != rSize)
1040 302 : InvalidatePageBreaks();
1041 :
1042 720 : bPageSizeValid = true;
1043 720 : aPageSizeTwips = rSize;
1044 : }
1045 : else
1046 0 : bPageSizeValid = false;
1047 720 : }
1048 :
1049 58217 : bool ScTable::IsProtected() const
1050 : {
1051 58217 : return pTabProtection.get() && pTabProtection->isProtected();
1052 : }
1053 :
1054 36 : void ScTable::SetProtection(const ScTableProtection* pProtect)
1055 : {
1056 36 : if (pProtect)
1057 36 : pTabProtection.reset(new ScTableProtection(*pProtect));
1058 : else
1059 0 : pTabProtection.reset();
1060 :
1061 36 : if (IsStreamValid())
1062 0 : SetStreamValid(false);
1063 36 : }
1064 :
1065 300 : ScTableProtection* ScTable::GetProtection()
1066 : {
1067 300 : return pTabProtection.get();
1068 : }
1069 :
1070 4720 : Size ScTable::GetPageSize() const
1071 : {
1072 4720 : if ( bPageSizeValid )
1073 292 : return aPageSizeTwips;
1074 : else
1075 4428 : return Size(); // leer
1076 : }
1077 :
1078 632 : void ScTable::SetRepeatArea( SCCOL nStartCol, SCCOL nEndCol, SCROW nStartRow, SCROW nEndRow )
1079 : {
1080 : // #i117952# page break calculation uses these values (set from ScPrintFunc), not pRepeatColRange/pRepeatRowRange
1081 632 : if ( nStartCol != nRepeatStartX || nEndCol != nRepeatEndX || nStartRow != nRepeatStartY || nEndRow != nRepeatEndY )
1082 24 : InvalidatePageBreaks();
1083 :
1084 632 : nRepeatStartX = nStartCol;
1085 632 : nRepeatEndX = nEndCol;
1086 632 : nRepeatStartY = nStartRow;
1087 632 : nRepeatEndY = nEndRow;
1088 632 : }
1089 :
1090 17478 : void ScTable::StartListening( const ScAddress& rAddress, SvtListener* pListener )
1091 : {
1092 17478 : if (!ValidCol(rAddress.Col()))
1093 17478 : return;
1094 :
1095 17478 : aCol[rAddress.Col()].StartListening( *pListener, rAddress.Row() );
1096 : }
1097 :
1098 1828 : void ScTable::EndListening( const ScAddress& rAddress, SvtListener* pListener )
1099 : {
1100 1828 : if (!ValidCol(rAddress.Col()))
1101 1828 : return;
1102 :
1103 1828 : aCol[rAddress.Col()].EndListening( *pListener, rAddress.Row() );
1104 : }
1105 :
1106 22946 : void ScTable::StartListening( sc::StartListeningContext& rCxt, SCCOL nCol, SCROW nRow, SvtListener& rListener )
1107 : {
1108 22946 : if (!ValidCol(nCol))
1109 22946 : return;
1110 :
1111 22946 : aCol[nCol].StartListening(rCxt, nRow, rListener);
1112 : }
1113 :
1114 528 : void ScTable::EndListening( sc::EndListeningContext& rCxt, SCCOL nCol, SCROW nRow, SvtListener& rListener )
1115 : {
1116 528 : if (!ValidCol(nCol))
1117 528 : return;
1118 :
1119 528 : aCol[nCol].EndListening(rCxt, nRow, rListener);
1120 : }
1121 :
1122 766 : void ScTable::SetPageStyle( const OUString& rName )
1123 : {
1124 766 : if ( aPageStyle != rName )
1125 : {
1126 754 : OUString aStrNew = rName;
1127 754 : SfxStyleSheetBasePool* pStylePool = pDocument->GetStyleSheetPool();
1128 754 : SfxStyleSheetBase* pNewStyle = pStylePool->Find( aStrNew, SFX_STYLE_FAMILY_PAGE );
1129 :
1130 754 : if ( !pNewStyle )
1131 : {
1132 0 : aStrNew = ScGlobal::GetRscString(STR_STYLENAME_STANDARD);
1133 0 : pNewStyle = pStylePool->Find( aStrNew, SFX_STYLE_FAMILY_PAGE );
1134 : }
1135 :
1136 754 : if ( aPageStyle != aStrNew )
1137 : {
1138 754 : SfxStyleSheetBase* pOldStyle = pStylePool->Find( aPageStyle, SFX_STYLE_FAMILY_PAGE );
1139 :
1140 754 : if ( pOldStyle && pNewStyle )
1141 : {
1142 754 : SfxItemSet& rOldSet = pOldStyle->GetItemSet();
1143 754 : SfxItemSet& rNewSet = pNewStyle->GetItemSet();
1144 754 : const sal_uInt16 nOldScale = GET_SCALEVALUE(rOldSet,ATTR_PAGE_SCALE);
1145 754 : const sal_uInt16 nOldScaleToPages = GET_SCALEVALUE(rOldSet,ATTR_PAGE_SCALETOPAGES);
1146 754 : const sal_uInt16 nNewScale = GET_SCALEVALUE(rNewSet,ATTR_PAGE_SCALE);
1147 754 : const sal_uInt16 nNewScaleToPages = GET_SCALEVALUE(rNewSet,ATTR_PAGE_SCALETOPAGES);
1148 :
1149 754 : if ( (nOldScale != nNewScale) || (nOldScaleToPages != nNewScaleToPages) )
1150 0 : InvalidateTextWidth(NULL, NULL, false, false);
1151 : }
1152 :
1153 754 : if ( pNewStyle ) // auch ohne den alten (fuer UpdateStdNames)
1154 754 : aPageStyle = aStrNew;
1155 :
1156 754 : if (IsStreamValid())
1157 0 : SetStreamValid(false);
1158 754 : }
1159 : }
1160 766 : }
1161 :
1162 266 : void ScTable::PageStyleModified( const OUString& rNewName )
1163 : {
1164 266 : aPageStyle = rNewName;
1165 266 : InvalidateTextWidth(NULL, NULL, false, false); // don't know what was in the style before
1166 266 : }
1167 :
1168 24830 : void ScTable::InvalidateTextWidth( const ScAddress* pAdrFrom, const ScAddress* pAdrTo,
1169 : bool bNumFormatChanged, bool bBroadcast )
1170 : {
1171 24830 : if ( pAdrFrom && !pAdrTo )
1172 : {
1173 : // Special case: only process the "from" cell.
1174 0 : SCCOL nCol = pAdrFrom->Col();
1175 0 : SCROW nRow = pAdrFrom->Row();
1176 0 : ScColumn& rCol = aCol[nCol];
1177 0 : ScRefCellValue aCell = rCol.GetCellValue(nRow);
1178 0 : if (aCell.isEmpty())
1179 0 : return;
1180 :
1181 0 : rCol.SetTextWidth(nRow, TEXTWIDTH_DIRTY);
1182 :
1183 0 : if ( bNumFormatChanged )
1184 0 : rCol.SetScriptType(nRow, SC_SCRIPTTYPE_UNKNOWN);
1185 :
1186 0 : if ( bBroadcast )
1187 : { // nur bei CalcAsShown
1188 0 : switch (aCell.meType)
1189 : {
1190 : case CELLTYPE_VALUE :
1191 0 : rCol.Broadcast(nRow);
1192 0 : break;
1193 : case CELLTYPE_FORMULA :
1194 0 : aCell.mpFormula->SetDirty();
1195 0 : break;
1196 : default:
1197 : {
1198 : // added to avoid warnings
1199 : }
1200 : }
1201 : }
1202 :
1203 0 : return;
1204 : }
1205 :
1206 24830 : const SCCOL nCol1 = pAdrFrom ? pAdrFrom->Col() : 0;
1207 24830 : const SCROW nRow1 = pAdrFrom ? pAdrFrom->Row() : 0;
1208 24830 : const SCCOL nCol2 = pAdrTo ? pAdrTo->Col() : MAXCOL;
1209 24830 : const SCROW nRow2 = pAdrTo ? pAdrTo->Row() : MAXROW;
1210 :
1211 485458 : for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
1212 : {
1213 460628 : ScColumnTextWidthIterator aIter(aCol[nCol], nRow1, nRow2);
1214 :
1215 464322 : for (; aIter.hasCell(); aIter.next())
1216 : {
1217 3694 : SCROW nRow = aIter.getPos();
1218 3694 : aIter.setValue(TEXTWIDTH_DIRTY);
1219 3694 : ScRefCellValue aCell = aCol[nCol].GetCellValue(nRow);
1220 3694 : if (aCell.isEmpty())
1221 0 : continue;
1222 :
1223 3694 : if ( bNumFormatChanged )
1224 282 : aCol[nCol].SetScriptType(nRow, SC_SCRIPTTYPE_UNKNOWN);
1225 :
1226 3694 : if ( bBroadcast )
1227 : { // nur bei CalcAsShown
1228 0 : switch (aCell.meType)
1229 : {
1230 : case CELLTYPE_VALUE :
1231 0 : aCol[nCol].Broadcast(nRow);
1232 0 : break;
1233 : case CELLTYPE_FORMULA :
1234 0 : aCell.mpFormula->SetDirty();
1235 0 : break;
1236 : default:
1237 : {
1238 : // added to avoid warnings
1239 : }
1240 : }
1241 : }
1242 3694 : }
1243 : }
1244 228 : }
1245 :
1246 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
