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 0 : void ScTable::UpdatePageBreaks( const ScRange* pUserArea )
60 : {
61 0 : if ( pDocument->IsImportingXML() )
62 0 : return;
63 :
64 : // pUserArea != NULL -> print area is specified. We need to force-update
65 : // the page breaks.
66 :
67 0 : if (!pUserArea)
68 : {
69 0 : if (!bPageSizeValid)
70 0 : return;
71 :
72 : // Always update breaks if force breaks option has changed
73 0 : if (mbPageBreaksValid && mbForceBreaks == SC_MOD()->GetPrintOptions().GetForceBreaks())
74 0 : return;
75 : }
76 :
77 0 : SfxStyleSheetBase* pStyle = pDocument->GetStyleSheetPool()->
78 0 : Find( aPageStyle, SFX_STYLE_FAMILY_PAGE );
79 0 : if ( !pStyle )
80 : {
81 : OSL_FAIL("UpdatePageBreaks: Style not found");
82 0 : return;
83 : }
84 0 : SfxItemSet* pStyleSet = &pStyle->GetItemSet();
85 : const SfxPoolItem* pItem;
86 :
87 : SCCOL nX;
88 0 : SCCOL nStartCol = 0;
89 0 : SCROW nStartRow = 0;
90 0 : SCCOL nEndCol = MAXCOL;
91 0 : SCROW nEndRow = MAXROW;
92 0 : if (pUserArea)
93 : {
94 0 : nStartCol = pUserArea->aStart.Col();
95 0 : nStartRow = pUserArea->aStart.Row();
96 0 : nEndCol = pUserArea->aEnd.Col();
97 0 : nEndRow = pUserArea->aEnd.Row();
98 : }
99 : else
100 : {
101 0 : sal_uInt16 nAreaCount = GetPrintRangeCount();
102 0 : 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 0 : else if ( nAreaCount == 1 )
114 : {
115 0 : const ScRange* pArea = GetPrintRange( 0 );
116 0 : if (pArea)
117 : {
118 0 : nStartCol = pArea->aStart.Col();
119 0 : nStartRow = pArea->aStart.Row();
120 0 : nEndCol = pArea->aEnd.Col();
121 0 : 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 0 : mbForceBreaks = SC_MOD()->GetPrintOptions().GetForceBreaks();
130 0 : bool bSkipColBreaks = false;
131 0 : bool bSkipRowBreaks = false;
132 :
133 0 : if (!mbForceBreaks)
134 : {
135 0 : 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 0 : 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 0 : long nPageSizeX = aPageSizeTwips.Width();
153 0 : long nPageSizeY = aPageSizeTwips.Height();
154 :
155 : // Anfang: Breaks loeschen
156 :
157 0 : for (nX=0; nX<nStartCol; nX++)
158 0 : RemoveColBreak(nX, true, false);
159 0 : RemoveRowPageBreaks(0, nStartRow-1);
160 :
161 0 : if (nStartCol > 0)
162 0 : SetColBreak(nStartCol, true, false); // AREABREAK
163 0 : if (nStartRow > 0)
164 0 : SetRowBreak(nStartRow, true, false); // AREABREAK
165 :
166 : // Mittelteil: Breaks verteilen
167 :
168 0 : bool bRepeatCol = ( nRepeatStartX != SCCOL_REPEAT_NONE );
169 0 : bool bColFound = false;
170 0 : long nSizeX = 0;
171 0 : for (nX=nStartCol; nX<=nEndCol; nX++)
172 : {
173 0 : bool bStartOfPage = false;
174 0 : long nThisX = ColHidden(nX) ? 0 : pColWidth[nX];
175 0 : bool bManualBreak = HasColManualBreak(nX);
176 0 : if ( (nSizeX+nThisX > nPageSizeX) || (bManualBreak && !bSkipColBreaks) )
177 : {
178 0 : SetColBreak(nX, true, false);
179 0 : nSizeX = 0;
180 0 : bStartOfPage = true;
181 : }
182 0 : else if (nX != nStartCol)
183 0 : RemoveColBreak(nX, true, false);
184 : else
185 0 : bStartOfPage = true;
186 :
187 0 : if ( bStartOfPage && bRepeatCol && nX>nRepeatStartX && !bColFound )
188 : {
189 : // subtract size of repeat columns from page size
190 0 : for (SCCOL i=nRepeatStartX; i<=nRepeatEndX; i++)
191 0 : nPageSizeX -= ColHidden(i) ? 0 : pColWidth[i];
192 0 : while (nX<=nRepeatEndX)
193 0 : RemoveColBreak(++nX, true, false);
194 0 : bColFound = true;
195 : }
196 :
197 0 : nSizeX += nThisX;
198 : }
199 :
200 : // Remove all page breaks in range.
201 0 : RemoveRowPageBreaks(nStartRow+1, nEndRow);
202 :
203 : // And set new page breaks.
204 0 : bool bRepeatRow = ( nRepeatStartY != SCROW_REPEAT_NONE );
205 0 : bool bRowFound = false;
206 0 : long nSizeY = 0;
207 0 : ScFlatBoolRowSegments::ForwardIterator aIterHidden(*mpHiddenRows);
208 0 : ScFlatUInt16RowSegments::ForwardIterator aIterHeights(*mpRowHeights);
209 0 : SCROW nNextManualBreak = GetNextManualBreak(nStartRow); // -1 => no more manual breaks
210 0 : for (SCROW nY = nStartRow; nY <= nEndRow; ++nY)
211 : {
212 0 : bool bStartOfPage = false;
213 0 : bool bThisRowHidden = false;
214 0 : aIterHidden.getValue(nY, bThisRowHidden);
215 0 : long nThisY = 0;
216 0 : if (!bThisRowHidden)
217 : {
218 : sal_uInt16 nTmp;
219 0 : aIterHeights.getValue(nY, nTmp);
220 0 : nThisY = static_cast<long>(nTmp);
221 : }
222 :
223 0 : bool bManualBreak = false;
224 0 : if (nNextManualBreak >= 0)
225 : {
226 0 : bManualBreak = (nY == nNextManualBreak);
227 0 : if (nY >= nNextManualBreak)
228 : // Query the next menual break position.
229 0 : nNextManualBreak = GetNextManualBreak(nY+1);
230 : }
231 :
232 0 : if ( (nSizeY+nThisY > nPageSizeY) || (bManualBreak && !bSkipRowBreaks) )
233 : {
234 0 : SetRowBreak(nY, true, false);
235 0 : nSizeY = 0;
236 0 : bStartOfPage = true;
237 : }
238 0 : else if (nY != nStartRow)
239 : ; // page break already removed
240 : else
241 0 : bStartOfPage = true;
242 :
243 0 : if ( bStartOfPage && bRepeatRow && nY>nRepeatStartY && !bRowFound )
244 : {
245 : // subtract size of repeat rows from page size
246 0 : 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 0 : nPageSizeY -= nHeights;
252 0 : if (nY <= nRepeatEndY)
253 0 : RemoveRowPageBreaks(nY, nRepeatEndY);
254 0 : bRowFound = true;
255 : }
256 :
257 0 : if (bThisRowHidden)
258 : {
259 : // Hidden row range. Skip them unless there is a manual break.
260 0 : SCROW nLastCommon = aIterHidden.getLastPos();
261 0 : if (nNextManualBreak >= 0)
262 0 : nLastCommon = ::std::min(nLastCommon, nNextManualBreak-1);
263 0 : nY = nLastCommon;
264 : }
265 : else
266 : {
267 : // Visible row range.
268 :
269 0 : SCROW nLastHidden = aIterHidden.getLastPos();
270 0 : SCROW nLastHeight = aIterHeights.getLastPos();
271 0 : SCROW nLastCommon = ::std::min(nLastHidden, nLastHeight);
272 0 : if (nNextManualBreak >= 0)
273 0 : nLastCommon = ::std::min(nLastCommon, nNextManualBreak-1);
274 :
275 0 : if (nLastCommon > nY)
276 : {
277 0 : long nMaxMultiple = static_cast<long>(nLastCommon - nY);
278 0 : long nMultiple = (nPageSizeY - nSizeY) / nThisY;
279 0 : if (nMultiple > nMaxMultiple)
280 0 : nMultiple = nMaxMultiple;
281 0 : if (nMultiple > 1)
282 : {
283 0 : nSizeY += nThisY * (nMultiple - 1);
284 0 : nY += nMultiple - 1;
285 : }
286 : }
287 : }
288 :
289 0 : nSizeY += nThisY;
290 : }
291 :
292 : // Ende: Breaks loeschen
293 :
294 0 : if (nEndCol < MAXCOL)
295 : {
296 0 : SetColBreak(nEndCol+1, true, false); // AREABREAK
297 0 : for (nX=nEndCol+2; nX<=MAXCOL; nX++)
298 0 : RemoveColBreak(nX, true, false);
299 : }
300 0 : if (nEndRow < MAXROW)
301 : {
302 0 : SetRowBreak(nEndRow+1, true, false); // AREABREAK
303 0 : if (nEndRow+2 <= MAXROW)
304 0 : RemoveRowPageBreaks(nEndRow+2, MAXROW);
305 : }
306 0 : 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 0 : void ScTable::SetRowManualBreaks( const ::std::set<SCROW>& rBreaks )
325 : {
326 0 : maRowManualBreaks = rBreaks;
327 0 : InvalidatePageBreaks();
328 0 : if (IsStreamValid())
329 0 : SetStreamValid(false);
330 0 : }
331 :
332 0 : void ScTable::SetColManualBreaks( const ::std::set<SCCOL>& rBreaks )
333 : {
334 0 : maColManualBreaks = rBreaks;
335 0 : InvalidatePageBreaks();
336 0 : if (IsStreamValid())
337 0 : SetStreamValid(false);
338 0 : }
339 :
340 0 : void ScTable::GetAllRowBreaks(set<SCROW>& rBreaks, bool bPage, bool bManual) const
341 : {
342 0 : if (bPage)
343 0 : rBreaks = maRowPageBreaks;
344 :
345 0 : if (bManual)
346 : {
347 : using namespace std;
348 0 : copy(maRowManualBreaks.begin(), maRowManualBreaks.end(), inserter(rBreaks, rBreaks.begin()));
349 : }
350 0 : }
351 :
352 0 : void ScTable::GetAllColBreaks(set<SCCOL>& rBreaks, bool bPage, bool bManual) const
353 : {
354 0 : if (bPage)
355 0 : rBreaks = maColPageBreaks;
356 :
357 0 : if (bManual)
358 : {
359 : using namespace std;
360 0 : copy(maColManualBreaks.begin(), maColManualBreaks.end(), inserter(rBreaks, rBreaks.begin()));
361 : }
362 0 : }
363 :
364 0 : bool ScTable::HasRowPageBreak(SCROW nRow) const
365 : {
366 0 : if (!ValidRow(nRow))
367 0 : return false;
368 :
369 0 : return maRowPageBreaks.find(nRow) != maRowPageBreaks.end();
370 : }
371 :
372 0 : bool ScTable::HasColPageBreak(SCCOL nCol) const
373 : {
374 0 : if (!ValidCol(nCol))
375 0 : return false;
376 :
377 0 : return maColPageBreaks.find(nCol) != maColPageBreaks.end();
378 : }
379 :
380 0 : bool ScTable::HasRowManualBreak(SCROW nRow) const
381 : {
382 0 : if (!ValidRow(nRow))
383 0 : return false;
384 :
385 0 : return maRowManualBreaks.find(nRow) != maRowManualBreaks.end();
386 : }
387 :
388 0 : bool ScTable::HasColManualBreak(SCCOL nCol) const
389 : {
390 0 : if (!ValidCol(nCol))
391 0 : return false;
392 :
393 0 : return maColManualBreaks.find(nCol) != maColManualBreaks.end();
394 : }
395 :
396 0 : SCROW ScTable::GetNextManualBreak(SCROW nRow) const
397 : {
398 0 : set<SCROW>::const_iterator itr = maRowManualBreaks.lower_bound(nRow);
399 0 : return itr == maRowManualBreaks.end() ? -1 : *itr;
400 : }
401 :
402 0 : void ScTable::RemoveRowPageBreaks(SCROW nStartRow, SCROW nEndRow)
403 : {
404 : using namespace std;
405 :
406 0 : if (!ValidRow(nStartRow) || !ValidRow(nEndRow))
407 0 : return;
408 :
409 0 : set<SCROW>::iterator low = maRowPageBreaks.lower_bound(nStartRow);
410 0 : set<SCROW>::iterator high = maRowPageBreaks.upper_bound(nEndRow);
411 0 : maRowPageBreaks.erase(low, high);
412 : }
413 :
414 0 : void ScTable::RemoveRowBreak(SCROW nRow, bool bPage, bool bManual)
415 : {
416 0 : if (!ValidRow(nRow))
417 0 : return;
418 :
419 0 : if (bPage)
420 0 : maRowPageBreaks.erase(nRow);
421 :
422 0 : if (bManual)
423 : {
424 0 : maRowManualBreaks.erase(nRow);
425 0 : InvalidatePageBreaks();
426 : }
427 : }
428 :
429 0 : void ScTable::RemoveColBreak(SCCOL nCol, bool bPage, bool bManual)
430 : {
431 0 : if (!ValidCol(nCol))
432 0 : return;
433 :
434 0 : if (bPage)
435 0 : maColPageBreaks.erase(nCol);
436 :
437 0 : if (bManual)
438 : {
439 0 : maColManualBreaks.erase(nCol);
440 0 : InvalidatePageBreaks();
441 : }
442 : }
443 :
444 0 : void ScTable::SetRowBreak(SCROW nRow, bool bPage, bool bManual)
445 : {
446 0 : if (!ValidRow(nRow))
447 0 : return;
448 :
449 0 : if (bPage)
450 0 : maRowPageBreaks.insert(nRow);
451 :
452 0 : if (bManual)
453 : {
454 0 : maRowManualBreaks.insert(nRow);
455 0 : InvalidatePageBreaks();
456 : }
457 : }
458 :
459 0 : void ScTable::SetColBreak(SCCOL nCol, bool bPage, bool bManual)
460 : {
461 0 : if (!ValidCol(nCol))
462 0 : return;
463 :
464 0 : if (bPage)
465 0 : maColPageBreaks.insert(nCol);
466 :
467 0 : if (bManual)
468 : {
469 0 : maColManualBreaks.insert(nCol);
470 0 : InvalidatePageBreaks();
471 : }
472 : }
473 :
474 0 : Sequence<TablePageBreakData> ScTable::GetRowBreakData() const
475 : {
476 : using ::std::copy;
477 : using ::std::inserter;
478 :
479 0 : set<SCROW> aRowBreaks = maRowPageBreaks;
480 0 : copy(maRowManualBreaks.begin(), maRowManualBreaks.end(), inserter(aRowBreaks, aRowBreaks.begin()));
481 :
482 0 : set<SCROW>::const_iterator itr = aRowBreaks.begin(), itrEnd = aRowBreaks.end();
483 0 : Sequence<TablePageBreakData> aSeq(aRowBreaks.size());
484 :
485 0 : for (sal_Int32 i = 0; itr != itrEnd; ++itr, ++i)
486 : {
487 0 : SCROW nRow = *itr;
488 0 : TablePageBreakData aData;
489 0 : aData.Position = nRow;
490 0 : aData.ManualBreak = HasRowManualBreak(nRow);
491 0 : aSeq[i] = aData;
492 : }
493 :
494 0 : return aSeq;
495 : }
496 :
497 0 : bool ScTable::RowHidden(SCROW nRow, SCROW* pFirstRow, SCROW* pLastRow) const
498 : {
499 0 : if (!ValidRow(nRow))
500 : {
501 0 : if (pFirstRow)
502 0 : *pFirstRow = nRow;
503 0 : if (pLastRow)
504 0 : *pLastRow = nRow;
505 0 : return true;
506 : }
507 :
508 : ScFlatBoolRowSegments::RangeData aData;
509 0 : 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 0 : if (pFirstRow)
520 0 : *pFirstRow = aData.mnRow1;
521 0 : if (pLastRow)
522 0 : *pLastRow = aData.mnRow2;
523 :
524 0 : return aData.mbValue;
525 : }
526 :
527 0 : bool ScTable::RowHiddenLeaf(SCROW nRow, SCROW* pFirstRow, SCROW* pLastRow) const
528 : {
529 0 : 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 0 : 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 0 : if (pFirstRow)
550 0 : *pFirstRow = aData.mnRow1;
551 0 : if (pLastRow)
552 0 : *pLastRow = aData.mnRow2;
553 :
554 0 : 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 0 : bool ScTable::ColHidden(SCCOL nCol, SCCOL* pFirstCol, SCCOL* pLastCol) const
573 : {
574 0 : if (!ValidCol(nCol))
575 0 : return true;
576 :
577 : ScFlatBoolColSegments::RangeData aData;
578 0 : if (!mpHiddenCols->getRangeData(nCol, aData))
579 0 : return true;
580 :
581 0 : if (pFirstCol)
582 0 : *pFirstCol = aData.mnCol1;
583 0 : if (pLastCol)
584 0 : *pLastCol = aData.mnCol2;
585 :
586 0 : return aData.mbValue;
587 : }
588 :
589 0 : bool ScTable::SetRowHidden(SCROW nStartRow, SCROW nEndRow, bool bHidden)
590 : {
591 0 : bool bChanged = false;
592 0 : if (bHidden)
593 0 : bChanged = mpHiddenRows->setTrue(nStartRow, nEndRow);
594 : else
595 0 : bChanged = mpHiddenRows->setFalse(nStartRow, nEndRow);
596 :
597 0 : if (bChanged)
598 : {
599 0 : if (IsStreamValid())
600 0 : SetStreamValid(false);
601 : }
602 :
603 0 : return bChanged;
604 : }
605 :
606 0 : bool ScTable::SetColHidden(SCCOL nStartCol, SCCOL nEndCol, bool bHidden)
607 : {
608 0 : bool bChanged = false;
609 0 : if (bHidden)
610 0 : bChanged = mpHiddenCols->setTrue(nStartCol, nEndCol);
611 : else
612 0 : bChanged = mpHiddenCols->setFalse(nStartCol, nEndCol);
613 :
614 0 : if (bChanged)
615 : {
616 0 : if (IsStreamValid())
617 0 : SetStreamValid(false);
618 : }
619 :
620 0 : return bChanged;
621 : }
622 :
623 0 : void ScTable::CopyColHidden(ScTable& rTable, SCCOL nStartCol, SCCOL nEndCol)
624 : {
625 0 : SCCOL nCol = nStartCol;
626 0 : while (nCol <= nEndCol)
627 : {
628 : SCCOL nLastCol;
629 0 : bool bHidden = rTable.ColHidden(nCol, NULL, &nLastCol);
630 0 : if (nLastCol > nEndCol)
631 0 : nLastCol = nEndCol;
632 :
633 0 : SetColHidden(nCol, nLastCol, bHidden);
634 0 : nCol = nLastCol + 1;
635 : }
636 0 : }
637 :
638 0 : void ScTable::CopyRowHidden(ScTable& rTable, SCROW nStartRow, SCROW nEndRow)
639 : {
640 0 : SCROW nRow = nStartRow;
641 0 : while (nRow <= nEndRow)
642 : {
643 0 : SCROW nLastRow = -1;
644 0 : bool bHidden = rTable.RowHidden(nRow, NULL, &nLastRow);
645 0 : if (nLastRow > nEndRow)
646 0 : nLastRow = nEndRow;
647 0 : SetRowHidden(nRow, nLastRow, bHidden);
648 0 : nRow = nLastRow + 1;
649 : }
650 0 : }
651 :
652 0 : void ScTable::CopyRowHeight(ScTable& rSrcTable, SCROW nStartRow, SCROW nEndRow, SCROW nSrcOffset)
653 : {
654 0 : SCROW nRow = nStartRow;
655 : ScFlatUInt16RowSegments::RangeData aSrcData;
656 0 : while (nRow <= nEndRow)
657 : {
658 0 : if (!rSrcTable.mpRowHeights->getRangeData(nRow + nSrcOffset, aSrcData))
659 : // Something is wrong !
660 0 : return;
661 :
662 0 : SCROW nLastRow = aSrcData.mnRow2 - nSrcOffset;
663 0 : if (nLastRow > nEndRow)
664 0 : nLastRow = nEndRow;
665 :
666 0 : mpRowHeights->setValue(nRow, nLastRow, aSrcData.mnValue);
667 0 : nRow = nLastRow + 1;
668 : }
669 : }
670 :
671 0 : SCROW ScTable::FirstVisibleRow(SCROW nStartRow, SCROW nEndRow) const
672 : {
673 0 : SCROW nRow = nStartRow;
674 : ScFlatBoolRowSegments::RangeData aData;
675 0 : while (nRow <= nEndRow)
676 : {
677 0 : if (!ValidRow(nRow))
678 0 : break;
679 :
680 0 : if (!mpHiddenRows->getRangeData(nRow, aData))
681 : // failed to get range data.
682 0 : break;
683 :
684 0 : if (!aData.mbValue)
685 : // visible row found
686 0 : return nRow;
687 :
688 0 : 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 0 : SCROW ScTable::CountVisibleRows(SCROW nStartRow, SCROW nEndRow) const
718 : {
719 0 : SCROW nCount = 0;
720 0 : SCROW nRow = nStartRow;
721 : ScFlatBoolRowSegments::RangeData aData;
722 0 : while (nRow <= nEndRow)
723 : {
724 0 : if (!mpHiddenRows->getRangeData(nRow, aData))
725 0 : break;
726 :
727 0 : if (aData.mnRow2 > nEndRow)
728 0 : aData.mnRow2 = nEndRow;
729 :
730 0 : if (!aData.mbValue)
731 0 : nCount += aData.mnRow2 - nRow + 1;
732 :
733 0 : nRow = aData.mnRow2 + 1;
734 : }
735 0 : return nCount;
736 : }
737 :
738 0 : sal_uInt32 ScTable::GetTotalRowHeight(SCROW nStartRow, SCROW nEndRow, bool bHiddenAsZero ) const
739 : {
740 0 : sal_uInt32 nHeight = 0;
741 0 : SCROW nRow = nStartRow;
742 : ScFlatBoolRowSegments::RangeData aData;
743 0 : while (nRow <= nEndRow)
744 : {
745 0 : if (!mpHiddenRows->getRangeData(nRow, aData))
746 0 : break;
747 :
748 0 : if (aData.mnRow2 > nEndRow)
749 0 : aData.mnRow2 = nEndRow;
750 :
751 0 : if ( !( bHiddenAsZero && aData.mbValue ) )
752 : // visible row range.
753 0 : nHeight += mpRowHeights->getSumValue(nRow, aData.mnRow2);
754 :
755 0 : nRow = aData.mnRow2 + 1;
756 : }
757 :
758 0 : 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 0 : bool ScTable::RowFiltered(SCROW nRow, SCROW* pFirstRow, SCROW* pLastRow) const
786 : {
787 0 : if (!ValidRow(nRow))
788 0 : return false;
789 :
790 : ScFlatBoolRowSegments::RangeData aData;
791 0 : if (!mpFilteredRows->getRangeData(nRow, aData))
792 : // search failed.
793 0 : return false;
794 :
795 0 : if (pFirstRow)
796 0 : *pFirstRow = aData.mnRow1;
797 0 : if (pLastRow)
798 0 : *pLastRow = aData.mnRow2;
799 :
800 0 : return aData.mbValue;
801 : }
802 :
803 0 : bool ScTable::ColFiltered(SCCOL nCol, SCCOL* pFirstCol, SCCOL* pLastCol) const
804 : {
805 0 : if (!ValidCol(nCol))
806 0 : return false;
807 :
808 : ScFlatBoolColSegments::RangeData aData;
809 0 : if (!mpFilteredCols->getRangeData(nCol, aData))
810 : // search failed.
811 0 : return false;
812 :
813 0 : if (pFirstCol)
814 0 : *pFirstCol = aData.mnCol1;
815 0 : if (pLastCol)
816 0 : *pLastCol = aData.mnCol2;
817 :
818 0 : return aData.mbValue;
819 : }
820 :
821 0 : bool ScTable::HasFilteredRows(SCROW nStartRow, SCROW nEndRow) const
822 : {
823 0 : SCROW nRow = nStartRow;
824 0 : while (nRow <= nEndRow)
825 : {
826 0 : SCROW nLastRow = nRow;
827 0 : bool bFiltered = RowFiltered(nRow, NULL, &nLastRow);
828 0 : if (bFiltered)
829 0 : return true;
830 :
831 0 : nRow = nLastRow + 1;
832 : }
833 0 : return false;
834 : }
835 :
836 0 : void ScTable::CopyColFiltered(ScTable& rTable, SCCOL nStartCol, SCCOL nEndCol)
837 : {
838 0 : SCCOL nCol = nStartCol;
839 0 : while (nCol <= nEndCol)
840 : {
841 : SCCOL nLastCol;
842 0 : bool bFiltered = rTable.ColFiltered(nCol, NULL, &nLastCol);
843 0 : if (nLastCol > nEndCol)
844 0 : nLastCol = nEndCol;
845 :
846 0 : SetColFiltered(nCol, nLastCol, bFiltered);
847 0 : nCol = nLastCol + 1;
848 : }
849 0 : }
850 :
851 0 : void ScTable::CopyRowFiltered(ScTable& rTable, SCROW nStartRow, SCROW nEndRow)
852 : {
853 0 : SCROW nRow = nStartRow;
854 0 : while (nRow <= nEndRow)
855 : {
856 0 : SCROW nLastRow = -1;
857 0 : bool bFiltered = rTable.RowFiltered(nRow, NULL, &nLastRow);
858 0 : if (nLastRow > nEndRow)
859 0 : nLastRow = nEndRow;
860 0 : SetRowFiltered(nRow, nLastRow, bFiltered);
861 0 : nRow = nLastRow + 1;
862 : }
863 0 : }
864 :
865 0 : void ScTable::SetRowFiltered(SCROW nStartRow, SCROW nEndRow, bool bFiltered)
866 : {
867 0 : if (bFiltered)
868 0 : mpFilteredRows->setTrue(nStartRow, nEndRow);
869 : else
870 0 : mpFilteredRows->setFalse(nStartRow, nEndRow);
871 0 : }
872 :
873 0 : void ScTable::SetColFiltered(SCCOL nStartCol, SCCOL nEndCol, bool bFiltered)
874 : {
875 0 : if (bFiltered)
876 0 : mpFilteredCols->setTrue(nStartCol, nEndCol);
877 : else
878 0 : mpFilteredCols->setFalse(nStartCol, nEndCol);
879 0 : }
880 :
881 0 : SCROW ScTable::FirstNonFilteredRow(SCROW nStartRow, SCROW nEndRow) const
882 : {
883 0 : SCROW nRow = nStartRow;
884 : ScFlatBoolRowSegments::RangeData aData;
885 0 : while (nRow <= nEndRow)
886 : {
887 0 : if (!ValidRow(nRow))
888 0 : break;
889 :
890 0 : if (!mpFilteredRows->getRangeData(nRow, aData))
891 : // failed to get range data.
892 0 : break;
893 :
894 0 : if (!aData.mbValue)
895 : // non-filtered row found
896 0 : 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 0 : SCROW ScTable::CountNonFilteredRows(SCROW nStartRow, SCROW nEndRow) const
928 : {
929 0 : SCROW nCount = 0;
930 0 : SCROW nRow = nStartRow;
931 : ScFlatBoolRowSegments::RangeData aData;
932 0 : while (nRow <= nEndRow)
933 : {
934 0 : if (!mpFilteredRows->getRangeData(nRow, aData))
935 0 : break;
936 :
937 0 : if (aData.mnRow2 > nEndRow)
938 0 : aData.mnRow2 = nEndRow;
939 :
940 0 : if (!aData.mbValue)
941 0 : nCount += aData.mnRow2 - nRow + 1;
942 :
943 0 : nRow = aData.mnRow2 + 1;
944 : }
945 0 : return nCount;
946 : }
947 :
948 0 : bool ScTable::IsManualRowHeight(SCROW nRow) const
949 : {
950 0 : return (pRowFlags->GetValue(nRow) & CR_MANUALSIZE) != 0;
951 : }
952 :
953 : namespace {
954 :
955 0 : 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 0 : sal_uInt8 nFlagMaskComplement = static_int_cast<sal_uInt8>(~nFlagMask);
961 :
962 0 : pRowFlags->AndValue(0, MAXROW, nFlagMaskComplement);
963 0 : for (SCCOL i = 0; i <= MAXCOL; ++i)
964 0 : pColFlags[i] &= nFlagMaskComplement;
965 :
966 : {
967 : // row hidden flags.
968 :
969 0 : SCROW nRow = 0;
970 : ScFlatBoolRowSegments::RangeData aData;
971 0 : while (nRow <= MAXROW)
972 : {
973 0 : if (!rRowSegments.getRangeData(nRow, aData))
974 0 : break;
975 :
976 0 : if (aData.mbValue)
977 0 : pRowFlags->OrValue(nRow, aData.mnRow2, nFlagMask);
978 :
979 0 : nRow = aData.mnRow2 + 1;
980 : }
981 : }
982 :
983 : {
984 : // column hidden flags.
985 :
986 0 : SCCOL nCol = 0;
987 : ScFlatBoolColSegments::RangeData aData;
988 0 : while (nCol <= MAXCOL)
989 : {
990 0 : if (!rColSegments.getRangeData(nCol, aData))
991 0 : break;
992 :
993 0 : if (aData.mbValue)
994 : {
995 0 : for (SCCOL i = nCol; i <= aData.mnCol2; ++i)
996 0 : pColFlags[i] |= nFlagMask;
997 : }
998 :
999 0 : nCol = aData.mnCol2 + 1;
1000 : }
1001 : }
1002 0 : }
1003 :
1004 : }
1005 :
1006 0 : void ScTable::SyncColRowFlags()
1007 : {
1008 : using ::sal::static_int_cast;
1009 :
1010 0 : sal_uInt8 nManualBreakComplement = static_int_cast<sal_uInt8>(~CR_MANUALBREAK);
1011 :
1012 : // Manual breaks.
1013 0 : pRowFlags->AndValue(0, MAXROW, nManualBreakComplement);
1014 0 : for (SCCOL i = 0; i <= MAXCOL; ++i)
1015 0 : pColFlags[i] &= nManualBreakComplement;
1016 :
1017 0 : 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 0 : 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 0 : lcl_syncFlags(*mpHiddenCols, *mpHiddenRows, pColFlags, pRowFlags, CR_HIDDEN);
1033 0 : lcl_syncFlags(*mpFilteredCols, *mpFilteredRows, pColFlags, pRowFlags, CR_FILTERED);
1034 0 : }
1035 :
1036 0 : void ScTable::SetPageSize( const Size& rSize )
1037 : {
1038 0 : if ( rSize.Width() != 0 && rSize.Height() != 0 )
1039 : {
1040 0 : if (aPageSizeTwips != rSize)
1041 0 : InvalidatePageBreaks();
1042 :
1043 0 : bPageSizeValid = true;
1044 0 : aPageSizeTwips = rSize;
1045 : }
1046 : else
1047 0 : bPageSizeValid = false;
1048 0 : }
1049 :
1050 0 : bool ScTable::IsProtected() const
1051 : {
1052 0 : return pTabProtection.get() && pTabProtection->isProtected();
1053 : }
1054 :
1055 0 : void ScTable::SetProtection(const ScTableProtection* pProtect)
1056 : {
1057 0 : if (pProtect)
1058 0 : pTabProtection.reset(new ScTableProtection(*pProtect));
1059 : else
1060 0 : pTabProtection.reset();
1061 :
1062 0 : if (IsStreamValid())
1063 0 : SetStreamValid(false);
1064 0 : }
1065 :
1066 0 : ScTableProtection* ScTable::GetProtection()
1067 : {
1068 0 : return pTabProtection.get();
1069 : }
1070 :
1071 0 : Size ScTable::GetPageSize() const
1072 : {
1073 0 : if ( bPageSizeValid )
1074 0 : return aPageSizeTwips;
1075 : else
1076 0 : return Size(); // leer
1077 : }
1078 :
1079 0 : 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 0 : if ( nStartCol != nRepeatStartX || nEndCol != nRepeatEndX || nStartRow != nRepeatStartY || nEndRow != nRepeatEndY )
1083 0 : InvalidatePageBreaks();
1084 :
1085 0 : nRepeatStartX = nStartCol;
1086 0 : nRepeatEndX = nEndCol;
1087 0 : nRepeatStartY = nStartRow;
1088 0 : nRepeatEndY = nEndRow;
1089 0 : }
1090 :
1091 0 : void ScTable::StartListening( const ScAddress& rAddress, SvtListener* pListener )
1092 : {
1093 0 : if (!ValidCol(rAddress.Col()))
1094 0 : return;
1095 :
1096 0 : aCol[rAddress.Col()].StartListening( *pListener, rAddress.Row() );
1097 : }
1098 :
1099 0 : void ScTable::EndListening( const ScAddress& rAddress, SvtListener* pListener )
1100 : {
1101 0 : if (!ValidCol(rAddress.Col()))
1102 0 : return;
1103 :
1104 0 : aCol[rAddress.Col()].EndListening( *pListener, rAddress.Row() );
1105 : }
1106 :
1107 0 : void ScTable::StartListening( sc::StartListeningContext& rCxt, SCCOL nCol, SCROW nRow, SvtListener& rListener )
1108 : {
1109 0 : if (!ValidCol(nCol))
1110 0 : return;
1111 :
1112 0 : aCol[nCol].StartListening(rCxt, nRow, rListener);
1113 : }
1114 :
1115 0 : void ScTable::EndListening( sc::EndListeningContext& rCxt, SCCOL nCol, SCROW nRow, SvtListener& rListener )
1116 : {
1117 0 : if (!ValidCol(nCol))
1118 0 : return;
1119 :
1120 0 : aCol[nCol].EndListening(rCxt, nRow, rListener);
1121 : }
1122 :
1123 0 : void ScTable::SetPageStyle( const OUString& rName )
1124 : {
1125 0 : if ( aPageStyle != rName )
1126 : {
1127 0 : OUString aStrNew = rName;
1128 0 : SfxStyleSheetBasePool* pStylePool = pDocument->GetStyleSheetPool();
1129 0 : SfxStyleSheetBase* pNewStyle = pStylePool->Find( aStrNew, SFX_STYLE_FAMILY_PAGE );
1130 :
1131 0 : if ( !pNewStyle )
1132 : {
1133 0 : aStrNew = ScGlobal::GetRscString(STR_STYLENAME_STANDARD);
1134 0 : pNewStyle = pStylePool->Find( aStrNew, SFX_STYLE_FAMILY_PAGE );
1135 : }
1136 :
1137 0 : if ( aPageStyle != aStrNew )
1138 : {
1139 0 : SfxStyleSheetBase* pOldStyle = pStylePool->Find( aPageStyle, SFX_STYLE_FAMILY_PAGE );
1140 :
1141 0 : if ( pOldStyle && pNewStyle )
1142 : {
1143 0 : SfxItemSet& rOldSet = pOldStyle->GetItemSet();
1144 0 : SfxItemSet& rNewSet = pNewStyle->GetItemSet();
1145 0 : const sal_uInt16 nOldScale = GET_SCALEVALUE(rOldSet,ATTR_PAGE_SCALE);
1146 0 : const sal_uInt16 nOldScaleToPages = GET_SCALEVALUE(rOldSet,ATTR_PAGE_SCALETOPAGES);
1147 0 : const sal_uInt16 nNewScale = GET_SCALEVALUE(rNewSet,ATTR_PAGE_SCALE);
1148 0 : const sal_uInt16 nNewScaleToPages = GET_SCALEVALUE(rNewSet,ATTR_PAGE_SCALETOPAGES);
1149 :
1150 0 : if ( (nOldScale != nNewScale) || (nOldScaleToPages != nNewScaleToPages) )
1151 0 : InvalidateTextWidth(NULL, NULL, false, false);
1152 : }
1153 :
1154 0 : if ( pNewStyle ) // auch ohne den alten (fuer UpdateStdNames)
1155 0 : aPageStyle = aStrNew;
1156 :
1157 0 : if (IsStreamValid())
1158 0 : SetStreamValid(false);
1159 0 : }
1160 : }
1161 0 : }
1162 :
1163 0 : void ScTable::PageStyleModified( const OUString& rNewName )
1164 : {
1165 0 : aPageStyle = rNewName;
1166 0 : InvalidateTextWidth(NULL, NULL, false, false); // don't know what was in the style before
1167 0 : }
1168 :
1169 0 : void ScTable::InvalidateTextWidth( const ScAddress* pAdrFrom, const ScAddress* pAdrTo,
1170 : bool bNumFormatChanged, bool bBroadcast )
1171 : {
1172 0 : 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 0 : const SCCOL nCol1 = pAdrFrom ? pAdrFrom->Col() : 0;
1208 0 : const SCROW nRow1 = pAdrFrom ? pAdrFrom->Row() : 0;
1209 0 : const SCCOL nCol2 = pAdrTo ? pAdrTo->Col() : MAXCOL;
1210 0 : const SCROW nRow2 = pAdrTo ? pAdrTo->Row() : MAXROW;
1211 :
1212 0 : for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
1213 : {
1214 0 : ScColumnTextWidthIterator aIter(aCol[nCol], nRow1, nRow2);
1215 :
1216 0 : for (; aIter.hasCell(); aIter.next())
1217 : {
1218 0 : SCROW nRow = aIter.getPos();
1219 0 : aIter.setValue(TEXTWIDTH_DIRTY);
1220 0 : ScRefCellValue aCell = aCol[nCol].GetCellValue(nRow);
1221 0 : if (aCell.isEmpty())
1222 0 : continue;
1223 :
1224 0 : if ( bNumFormatChanged )
1225 0 : aCol[nCol].SetScriptType(nRow, SC_SCRIPTTYPE_UNKNOWN);
1226 :
1227 0 : 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 0 : }
1244 : }
1245 0 : }
1246 :
1247 :
1248 :
1249 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
