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