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 "cell.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 <com/sun/star/sheet/TablePageBreakData.hpp>
40 :
41 : #include <algorithm>
42 : #include <limits>
43 :
44 : using ::com::sun::star::uno::Sequence;
45 : using ::com::sun::star::sheet::TablePageBreakData;
46 : using ::std::set;
47 :
48 : // STATIC DATA -----------------------------------------------------------
49 :
50 : #define GET_SCALEVALUE(set,id) ((const SfxUInt16Item&)(set.Get( id ))).GetValue()
51 :
52 :
53 360 : void ScTable::UpdatePageBreaks( const ScRange* pUserArea )
54 : {
55 360 : if ( pDocument->IsImportingXML() )
56 : return;
57 :
58 : // pUserArea != NULL -> print area is specified. We need to force-update
59 : // the page breaks.
60 :
61 150 : if (!pUserArea)
62 : {
63 150 : if (!bPageSizeValid)
64 : return;
65 :
66 149 : if (mbPageBreaksValid)
67 : return;
68 : }
69 :
70 120 : SfxStyleSheetBase* pStyle = pDocument->GetStyleSheetPool()->
71 120 : Find( aPageStyle, SFX_STYLE_FAMILY_PAGE );
72 120 : if ( !pStyle )
73 : {
74 : OSL_FAIL("UpdatePageBreaks: Style nicht gefunden");
75 : return;
76 : }
77 120 : SfxItemSet* pStyleSet = &pStyle->GetItemSet();
78 : const SfxPoolItem* pItem;
79 :
80 : SCCOL nX;
81 120 : SCCOL nStartCol = 0;
82 120 : SCROW nStartRow = 0;
83 120 : SCCOL nEndCol = MAXCOL;
84 120 : SCROW nEndRow = MAXROW;
85 120 : if (pUserArea)
86 : {
87 0 : nStartCol = pUserArea->aStart.Col();
88 0 : nStartRow = pUserArea->aStart.Row();
89 0 : nEndCol = pUserArea->aEnd.Col();
90 0 : nEndRow = pUserArea->aEnd.Row();
91 : }
92 : else
93 : {
94 120 : sal_uInt16 nAreaCount = GetPrintRangeCount();
95 120 : if ( nAreaCount > 1 )
96 : {
97 : // bei mehreren Bereichen nichts anzeigen:
98 :
99 0 : for (nX=0; nX<MAXCOL; nX++)
100 0 : RemoveColBreak(nX, true, false);
101 :
102 0 : RemoveRowPageBreaks(0, MAXROW-1);
103 :
104 : return;
105 : }
106 120 : else if ( nAreaCount == 1 )
107 : {
108 0 : const ScRange* pArea = GetPrintRange( 0 );
109 0 : if (pArea)
110 : {
111 0 : nStartCol = pArea->aStart.Col();
112 0 : nStartRow = pArea->aStart.Row();
113 0 : nEndCol = pArea->aEnd.Col();
114 0 : nEndRow = pArea->aEnd.Row();
115 : }
116 : } // sonst alles
117 : }
118 :
119 : // get bSkipColBreaks/bSkipRowBreaks flags:
120 :
121 120 : bool bSkipColBreaks = false;
122 120 : bool bSkipRowBreaks = false;
123 120 : bool bSkipBreaks = false;
124 :
125 120 : if ( pStyleSet->GetItemState( ATTR_PAGE_SCALETOPAGES, false, &pItem ) == SFX_ITEM_SET )
126 : {
127 : OSL_ENSURE( pItem->ISA(SfxUInt16Item), "falsches Item" );
128 0 : bSkipColBreaks = bSkipRowBreaks = ( ((const SfxUInt16Item*)pItem)->GetValue() > 0 );
129 : }
130 :
131 120 : if ( !bSkipColBreaks && pStyleSet->GetItemState(ATTR_PAGE_SCALETO, false, &pItem) == SFX_ITEM_SET )
132 : {
133 : // #i54993# when fitting to width or height, ignore only manual breaks in that direction
134 0 : const ScPageScaleToItem* pScaleToItem = static_cast<const ScPageScaleToItem*>(pItem);
135 0 : if ( pScaleToItem->GetWidth() > 0 )
136 0 : bSkipColBreaks = true;
137 0 : if ( pScaleToItem->GetHeight() > 0 )
138 0 : bSkipRowBreaks = true;
139 : }
140 :
141 120 : if (!bSkipBreaks && pStyleSet->GetItemState(ATTR_PAGE_SCALETO, false, &pItem) == SFX_ITEM_SET)
142 : {
143 : const ScPageScaleToItem& rScaleToItem = static_cast<const ScPageScaleToItem&>(
144 0 : pStyleSet->Get(ATTR_PAGE_SCALETO));
145 0 : if (rScaleToItem.GetWidth() > 0 || rScaleToItem.GetHeight() > 0)
146 : // when fitting to a fixed width x height, ignore manual breaks.
147 0 : bSkipBreaks = true;
148 : }
149 :
150 : //--------------------------------------------------------------------------
151 :
152 120 : long nPageSizeX = aPageSizeTwips.Width();
153 120 : long nPageSizeY = aPageSizeTwips.Height();
154 :
155 : // Anfang: Breaks loeschen
156 :
157 120 : for (nX=0; nX<nStartCol; nX++)
158 0 : RemoveColBreak(nX, true, false);
159 120 : RemoveRowPageBreaks(0, nStartRow-1);
160 :
161 120 : if (nStartCol > 0)
162 0 : SetColBreak(nStartCol, true, false); // AREABREAK
163 120 : if (nStartRow > 0)
164 0 : SetRowBreak(nStartRow, true, false); // AREABREAK
165 :
166 : // Mittelteil: Breaks verteilen
167 :
168 120 : bool bRepeatCol = ( nRepeatStartX != SCCOL_REPEAT_NONE );
169 120 : bool bColFound = false;
170 120 : long nSizeX = 0;
171 123000 : for (nX=nStartCol; nX<=nEndCol; nX++)
172 : {
173 122880 : bool bStartOfPage = false;
174 122880 : long nThisX = ColHidden(nX) ? 0 : pColWidth[nX];
175 122880 : bool bManualBreak = HasColManualBreak(nX);
176 122880 : if ( (nSizeX+nThisX > nPageSizeX) || (bManualBreak && !bSkipColBreaks) )
177 : {
178 15130 : SetColBreak(nX, true, false);
179 15130 : nSizeX = 0;
180 15130 : bStartOfPage = true;
181 : }
182 107750 : else if (nX != nStartCol)
183 107630 : RemoveColBreak(nX, true, false);
184 : else
185 120 : bStartOfPage = true;
186 :
187 122880 : 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 122880 : nSizeX += nThisX;
198 : }
199 :
200 : // Remove all page breaks in range.
201 120 : RemoveRowPageBreaks(nStartRow+1, nEndRow);
202 :
203 : // And set new page breaks.
204 120 : bool bRepeatRow = ( nRepeatStartY != SCROW_REPEAT_NONE );
205 120 : bool bRowFound = false;
206 120 : long nSizeY = 0;
207 120 : ScFlatBoolRowSegments::ForwardIterator aIterHidden(*mpHiddenRows);
208 120 : ScFlatUInt16RowSegments::ForwardIterator aIterHeights(*mpRowHeights);
209 120 : SCROW nNextManualBreak = GetNextManualBreak(nStartRow); // -1 => no more manual breaks
210 2329233 : for (SCROW nY = nStartRow; nY <= nEndRow; ++nY)
211 : {
212 2329113 : bool bStartOfPage = false;
213 2329113 : bool bThisRowHidden = false;
214 2329113 : aIterHidden.getValue(nY, bThisRowHidden);
215 2329113 : long nThisY = 0;
216 2329113 : if (!bThisRowHidden)
217 : {
218 : sal_uInt16 nTmp;
219 2329113 : aIterHeights.getValue(nY, nTmp);
220 2329113 : nThisY = static_cast<long>(nTmp);
221 : }
222 :
223 2329113 : bool bManualBreak = false;
224 2329113 : 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 2329113 : if ( (nSizeY+nThisY > nPageSizeY) || (bManualBreak && !bSkipRowBreaks) )
233 : {
234 2328429 : SetRowBreak(nY, true, false);
235 2328429 : nSizeY = 0;
236 2328429 : bStartOfPage = true;
237 : }
238 684 : else if (nY != nStartRow)
239 : ; // page break already removed
240 : else
241 120 : bStartOfPage = true;
242 :
243 2329113 : 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 2329113 : 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 2329113 : SCROW nLastHidden = aIterHidden.getLastPos();
270 2329113 : SCROW nLastHeight = aIterHeights.getLastPos();
271 2329113 : SCROW nLastCommon = ::std::min(nLastHidden, nLastHeight);
272 2329113 : if (nNextManualBreak >= 0)
273 0 : nLastCommon = ::std::min(nLastCommon, nNextManualBreak-1);
274 :
275 2329113 : if (nLastCommon > nY)
276 : {
277 2328608 : long nMaxMultiple = static_cast<long>(nLastCommon - nY);
278 2328608 : long nMultiple = (nPageSizeY - nSizeY) / nThisY;
279 2328608 : if (nMultiple > nMaxMultiple)
280 179 : nMultiple = nMaxMultiple;
281 2328608 : if (nMultiple > 1)
282 : {
283 2328571 : nSizeY += nThisY * (nMultiple - 1);
284 2328571 : nY += nMultiple - 1;
285 : }
286 : }
287 : }
288 :
289 2329113 : nSizeY += nThisY;
290 : }
291 :
292 : // Ende: Breaks loeschen
293 :
294 120 : 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 120 : 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 120 : 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 3 : void ScTable::SetRowManualBreaks( const ::std::set<SCROW>& rBreaks )
325 : {
326 3 : maRowManualBreaks = rBreaks;
327 3 : InvalidatePageBreaks();
328 3 : if (IsStreamValid())
329 0 : SetStreamValid(false);
330 3 : }
331 :
332 3 : void ScTable::SetColManualBreaks( const ::std::set<SCCOL>& rBreaks )
333 : {
334 3 : maColManualBreaks = rBreaks;
335 3 : InvalidatePageBreaks();
336 3 : if (IsStreamValid())
337 0 : SetStreamValid(false);
338 3 : }
339 :
340 1 : void ScTable::GetAllRowBreaks(set<SCROW>& rBreaks, bool bPage, bool bManual) const
341 : {
342 1 : if (bPage)
343 0 : rBreaks = maRowPageBreaks;
344 :
345 1 : if (bManual)
346 : {
347 : using namespace std;
348 1 : copy(maRowManualBreaks.begin(), maRowManualBreaks.end(), inserter(rBreaks, rBreaks.begin()));
349 : }
350 1 : }
351 :
352 1 : void ScTable::GetAllColBreaks(set<SCCOL>& rBreaks, bool bPage, bool bManual) const
353 : {
354 1 : if (bPage)
355 0 : rBreaks = maColPageBreaks;
356 :
357 1 : if (bManual)
358 : {
359 : using namespace std;
360 1 : copy(maColManualBreaks.begin(), maColManualBreaks.end(), inserter(rBreaks, rBreaks.begin()));
361 : }
362 1 : }
363 :
364 2 : bool ScTable::HasRowPageBreak(SCROW nRow) const
365 : {
366 2 : if (!ValidRow(nRow))
367 0 : return false;
368 :
369 2 : return maRowPageBreaks.find(nRow) != maRowPageBreaks.end();
370 : }
371 :
372 496 : bool ScTable::HasColPageBreak(SCCOL nCol) const
373 : {
374 496 : if (!ValidCol(nCol))
375 0 : return false;
376 :
377 496 : return maColPageBreaks.find(nCol) != maColPageBreaks.end();
378 : }
379 :
380 2 : bool ScTable::HasRowManualBreak(SCROW nRow) const
381 : {
382 2 : if (!ValidRow(nRow))
383 0 : return false;
384 :
385 2 : return maRowManualBreaks.find(nRow) != maRowManualBreaks.end();
386 : }
387 :
388 123376 : bool ScTable::HasColManualBreak(SCCOL nCol) const
389 : {
390 123376 : if (!ValidCol(nCol))
391 0 : return false;
392 :
393 123376 : return maColManualBreaks.find(nCol) != maColManualBreaks.end();
394 : }
395 :
396 120 : SCROW ScTable::GetNextManualBreak(SCROW nRow) const
397 : {
398 120 : set<SCROW>::const_iterator itr = maRowManualBreaks.lower_bound(nRow);
399 120 : return itr == maRowManualBreaks.end() ? -1 : *itr;
400 : }
401 :
402 240 : void ScTable::RemoveRowPageBreaks(SCROW nStartRow, SCROW nEndRow)
403 : {
404 : using namespace std;
405 :
406 240 : if (!ValidRow(nStartRow) || !ValidRow(nEndRow))
407 240 : return;
408 :
409 120 : set<SCROW>::iterator low = maRowPageBreaks.lower_bound(nStartRow);
410 120 : set<SCROW>::iterator high = maRowPageBreaks.upper_bound(nEndRow);
411 120 : 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 107630 : void ScTable::RemoveColBreak(SCCOL nCol, bool bPage, bool bManual)
430 : {
431 107630 : if (!ValidCol(nCol))
432 107630 : return;
433 :
434 107630 : if (bPage)
435 107630 : maColPageBreaks.erase(nCol);
436 :
437 107630 : if (bManual)
438 : {
439 0 : maColManualBreaks.erase(nCol);
440 0 : InvalidatePageBreaks();
441 : }
442 : }
443 :
444 2328429 : void ScTable::SetRowBreak(SCROW nRow, bool bPage, bool bManual)
445 : {
446 2328429 : if (!ValidRow(nRow))
447 2328429 : return;
448 :
449 2328429 : if (bPage)
450 2328429 : maRowPageBreaks.insert(nRow);
451 :
452 2328429 : if (bManual)
453 : {
454 0 : maRowManualBreaks.insert(nRow);
455 0 : InvalidatePageBreaks();
456 : }
457 : }
458 :
459 15130 : void ScTable::SetColBreak(SCCOL nCol, bool bPage, bool bManual)
460 : {
461 15130 : if (!ValidCol(nCol))
462 15130 : return;
463 :
464 15130 : if (bPage)
465 15130 : maColPageBreaks.insert(nCol);
466 :
467 15130 : 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 6603 : bool ScTable::RowHidden(SCROW nRow, SCROW* pFirstRow, SCROW* pLastRow) const
498 : {
499 6603 : 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 6603 : 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 6603 : if (pFirstRow)
520 45 : *pFirstRow = aData.mnRow1;
521 6603 : if (pLastRow)
522 3319 : *pLastRow = aData.mnRow2;
523 :
524 6603 : return aData.mbValue;
525 : }
526 :
527 20 : bool ScTable::RowHiddenLeaf(SCROW nRow, SCROW* pFirstRow, SCROW* pLastRow) const
528 : {
529 20 : 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 20 : 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 20 : if (pFirstRow)
550 0 : *pFirstRow = aData.mnRow1;
551 20 : if (pLastRow)
552 20 : *pLastRow = aData.mnRow2;
553 :
554 20 : 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 346474 : bool ScTable::ColHidden(SCCOL nCol, SCCOL* pFirstCol, SCCOL* pLastCol) const
573 : {
574 346474 : if (!ValidCol(nCol))
575 0 : return true;
576 :
577 : ScFlatBoolColSegments::RangeData aData;
578 346474 : if (!mpHiddenCols->getRangeData(nCol, aData))
579 0 : return true;
580 :
581 346474 : if (pFirstCol)
582 0 : *pFirstCol = aData.mnCol1;
583 346474 : if (pLastCol)
584 1108 : *pLastCol = aData.mnCol2;
585 :
586 346474 : return aData.mbValue;
587 : }
588 :
589 65 : bool ScTable::SetRowHidden(SCROW nStartRow, SCROW nEndRow, bool bHidden)
590 : {
591 65 : bool bChanged = false;
592 65 : if (bHidden)
593 47 : bChanged = mpHiddenRows->setTrue(nStartRow, nEndRow);
594 : else
595 18 : bChanged = mpHiddenRows->setFalse(nStartRow, nEndRow);
596 :
597 65 : if (bChanged)
598 : {
599 47 : if (IsStreamValid())
600 0 : SetStreamValid(false);
601 : }
602 :
603 65 : return bChanged;
604 : }
605 :
606 3077 : bool ScTable::SetColHidden(SCCOL nStartCol, SCCOL nEndCol, bool bHidden)
607 : {
608 3077 : bool bChanged = false;
609 3077 : if (bHidden)
610 2 : bChanged = mpHiddenCols->setTrue(nStartCol, nEndCol);
611 : else
612 3075 : bChanged = mpHiddenCols->setFalse(nStartCol, nEndCol);
613 :
614 3077 : if (bChanged)
615 : {
616 2 : if (IsStreamValid())
617 0 : SetStreamValid(false);
618 : }
619 :
620 3077 : return bChanged;
621 : }
622 :
623 3 : void ScTable::CopyColHidden(ScTable& rTable, SCCOL nStartCol, SCCOL nEndCol)
624 : {
625 3 : SCCOL nCol = nStartCol;
626 9 : while (nCol <= nEndCol)
627 : {
628 : SCCOL nLastCol;
629 3 : bool bHidden = rTable.ColHidden(nCol, NULL, &nLastCol);
630 3 : if (nLastCol > nEndCol)
631 3 : nLastCol = nEndCol;
632 :
633 3 : SetColHidden(nCol, nLastCol, bHidden);
634 3 : nCol = nLastCol + 1;
635 : }
636 3 : }
637 :
638 3 : void ScTable::CopyRowHidden(ScTable& rTable, SCROW nStartRow, SCROW nEndRow)
639 : {
640 3 : SCROW nRow = nStartRow;
641 9 : while (nRow <= nEndRow)
642 : {
643 3 : SCROW nLastRow = -1;
644 3 : bool bHidden = rTable.RowHidden(nRow, NULL, &nLastRow);
645 3 : if (nLastRow > nEndRow)
646 3 : nLastRow = nEndRow;
647 3 : SetRowHidden(nRow, nLastRow, bHidden);
648 3 : nRow = nLastRow + 1;
649 : }
650 3 : }
651 :
652 6 : void ScTable::CopyRowHeight(ScTable& rSrcTable, SCROW nStartRow, SCROW nEndRow, SCROW nSrcOffset)
653 : {
654 6 : SCROW nRow = nStartRow;
655 : ScFlatUInt16RowSegments::RangeData aSrcData;
656 18 : while (nRow <= nEndRow)
657 : {
658 6 : if (!rSrcTable.mpRowHeights->getRangeData(nRow + nSrcOffset, aSrcData))
659 : // Something is wrong !
660 6 : return;
661 :
662 6 : SCROW nLastRow = aSrcData.mnRow2 - nSrcOffset;
663 6 : if (nLastRow > nEndRow)
664 3 : nLastRow = nEndRow;
665 :
666 6 : mpRowHeights->setValue(nRow, nLastRow, aSrcData.mnValue);
667 6 : 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 301 : sal_uInt32 ScTable::GetTotalRowHeight(SCROW nStartRow, SCROW nEndRow) const
739 : {
740 301 : sal_uInt32 nHeight = 0;
741 301 : SCROW nRow = nStartRow;
742 : ScFlatBoolRowSegments::RangeData aData;
743 1000 : while (nRow <= nEndRow)
744 : {
745 398 : if (!mpHiddenRows->getRangeData(nRow, aData))
746 0 : break;
747 :
748 398 : if (aData.mnRow2 > nEndRow)
749 120 : aData.mnRow2 = nEndRow;
750 :
751 398 : if (!aData.mbValue)
752 : // visible row range.
753 348 : nHeight += mpRowHeights->getSumValue(nRow, aData.mnRow2);
754 :
755 398 : nRow = aData.mnRow2 + 1;
756 : }
757 :
758 301 : 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 10 : bool ScTable::RowFiltered(SCROW nRow, SCROW* pFirstRow, SCROW* pLastRow) const
786 : {
787 10 : if (!ValidRow(nRow))
788 0 : return false;
789 :
790 : ScFlatBoolRowSegments::RangeData aData;
791 10 : if (!mpFilteredRows->getRangeData(nRow, aData))
792 : // search failed.
793 0 : return false;
794 :
795 10 : if (pFirstRow)
796 2 : *pFirstRow = aData.mnRow1;
797 10 : if (pLastRow)
798 10 : *pLastRow = aData.mnRow2;
799 :
800 10 : return aData.mbValue;
801 : }
802 :
803 3 : bool ScTable::ColFiltered(SCCOL nCol, SCCOL* pFirstCol, SCCOL* pLastCol) const
804 : {
805 3 : if (!ValidCol(nCol))
806 0 : return false;
807 :
808 : ScFlatBoolColSegments::RangeData aData;
809 3 : if (!mpFilteredCols->getRangeData(nCol, aData))
810 : // search failed.
811 0 : return false;
812 :
813 3 : if (pFirstCol)
814 0 : *pFirstCol = aData.mnCol1;
815 3 : if (pLastCol)
816 3 : *pLastCol = aData.mnCol2;
817 :
818 3 : return aData.mbValue;
819 : }
820 :
821 1 : bool ScTable::HasFilteredRows(SCROW nStartRow, SCROW nEndRow) const
822 : {
823 1 : SCROW nRow = nStartRow;
824 3 : while (nRow <= nEndRow)
825 : {
826 1 : SCROW nLastRow = nRow;
827 1 : bool bFiltered = RowFiltered(nRow, NULL, &nLastRow);
828 1 : if (bFiltered)
829 0 : return true;
830 :
831 1 : nRow = nLastRow + 1;
832 : }
833 1 : return false;
834 : }
835 :
836 3 : void ScTable::CopyColFiltered(ScTable& rTable, SCCOL nStartCol, SCCOL nEndCol)
837 : {
838 3 : SCCOL nCol = nStartCol;
839 9 : while (nCol <= nEndCol)
840 : {
841 : SCCOL nLastCol;
842 3 : bool bFiltered = rTable.ColFiltered(nCol, NULL, &nLastCol);
843 3 : if (nLastCol > nEndCol)
844 3 : nLastCol = nEndCol;
845 :
846 3 : SetColFiltered(nCol, nLastCol, bFiltered);
847 3 : nCol = nLastCol + 1;
848 : }
849 3 : }
850 :
851 3 : void ScTable::CopyRowFiltered(ScTable& rTable, SCROW nStartRow, SCROW nEndRow)
852 : {
853 3 : SCROW nRow = nStartRow;
854 9 : while (nRow <= nEndRow)
855 : {
856 3 : SCROW nLastRow = -1;
857 3 : bool bFiltered = rTable.RowFiltered(nRow, NULL, &nLastRow);
858 3 : if (nLastRow > nEndRow)
859 3 : nLastRow = nEndRow;
860 3 : SetRowFiltered(nRow, nLastRow, bFiltered);
861 3 : nRow = nLastRow + 1;
862 : }
863 3 : }
864 :
865 50 : void ScTable::SetRowFiltered(SCROW nStartRow, SCROW nEndRow, bool bFiltered)
866 : {
867 50 : if (bFiltered)
868 33 : mpFilteredRows->setTrue(nStartRow, nEndRow);
869 : else
870 17 : mpFilteredRows->setFalse(nStartRow, nEndRow);
871 50 : }
872 :
873 3 : void ScTable::SetColFiltered(SCCOL nStartCol, SCCOL nEndCol, bool bFiltered)
874 : {
875 3 : if (bFiltered)
876 0 : mpFilteredCols->setTrue(nStartCol, nEndCol);
877 : else
878 3 : mpFilteredCols->setFalse(nStartCol, nEndCol);
879 3 : }
880 :
881 1 : SCROW ScTable::FirstNonFilteredRow(SCROW nStartRow, SCROW nEndRow) const
882 : {
883 1 : SCROW nRow = nStartRow;
884 : ScFlatBoolRowSegments::RangeData aData;
885 2 : while (nRow <= nEndRow)
886 : {
887 1 : if (!ValidRow(nRow))
888 0 : break;
889 :
890 1 : if (!mpFilteredRows->getRangeData(nRow, aData))
891 : // failed to get range data.
892 0 : break;
893 :
894 1 : if (!aData.mbValue)
895 : // non-filtered row found
896 1 : 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 2 : SCROW ScTable::CountNonFilteredRows(SCROW nStartRow, SCROW nEndRow) const
928 : {
929 2 : SCROW nCount = 0;
930 2 : SCROW nRow = nStartRow;
931 : ScFlatBoolRowSegments::RangeData aData;
932 6 : while (nRow <= nEndRow)
933 : {
934 2 : if (!mpFilteredRows->getRangeData(nRow, aData))
935 0 : break;
936 :
937 2 : if (aData.mnRow2 > nEndRow)
938 2 : aData.mnRow2 = nEndRow;
939 :
940 2 : if (!aData.mbValue)
941 2 : nCount += aData.mnRow2 - nRow + 1;
942 :
943 2 : nRow = aData.mnRow2 + 1;
944 : }
945 2 : 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 4 : 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 4 : sal_uInt8 nFlagMaskComplement = static_int_cast<sal_uInt8>(~nFlagMask);
961 :
962 4 : pRowFlags->AndValue(0, MAXROW, nFlagMaskComplement);
963 4100 : for (SCCOL i = 0; i <= MAXCOL; ++i)
964 4096 : pColFlags[i] &= nFlagMaskComplement;
965 :
966 : {
967 : // row hidden flags.
968 :
969 4 : SCROW nRow = 0;
970 : ScFlatBoolRowSegments::RangeData aData;
971 12 : while (nRow <= MAXROW)
972 : {
973 4 : if (!rRowSegments.getRangeData(nRow, aData))
974 0 : break;
975 :
976 4 : if (aData.mbValue)
977 0 : pRowFlags->OrValue(nRow, aData.mnRow2, nFlagMask);
978 :
979 4 : nRow = aData.mnRow2 + 1;
980 : }
981 : }
982 :
983 : {
984 : // column hidden flags.
985 :
986 4 : SCCOL nCol = 0;
987 : ScFlatBoolColSegments::RangeData aData;
988 12 : while (nCol <= MAXCOL)
989 : {
990 4 : if (!rColSegments.getRangeData(nCol, aData))
991 0 : break;
992 :
993 4 : if (aData.mbValue)
994 : {
995 0 : for (SCCOL i = nCol; i <= aData.mnCol2; ++i)
996 0 : pColFlags[i] |= nFlagMask;
997 : }
998 :
999 4 : nCol = aData.mnCol2 + 1;
1000 : }
1001 : }
1002 4 : }
1003 :
1004 : }
1005 :
1006 2 : void ScTable::SyncColRowFlags()
1007 : {
1008 : using ::sal::static_int_cast;
1009 :
1010 2 : sal_uInt8 nManualBreakComplement = static_int_cast<sal_uInt8>(~CR_MANUALBREAK);
1011 :
1012 : // Manual breaks.
1013 2 : pRowFlags->AndValue(0, MAXROW, nManualBreakComplement);
1014 2050 : for (SCCOL i = 0; i <= MAXCOL; ++i)
1015 2048 : pColFlags[i] &= nManualBreakComplement;
1016 :
1017 2 : 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 2 : 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 2 : lcl_syncFlags(*mpHiddenCols, *mpHiddenRows, pColFlags, pRowFlags, CR_HIDDEN);
1033 2 : lcl_syncFlags(*mpFilteredCols, *mpFilteredRows, pColFlags, pRowFlags, CR_FILTERED);
1034 2 : }
1035 :
1036 86 : void ScTable::SetPageSize( const Size& rSize )
1037 : {
1038 86 : if ( rSize.Width() != 0 && rSize.Height() != 0 )
1039 : {
1040 86 : if (aPageSizeTwips != rSize)
1041 47 : InvalidatePageBreaks();
1042 :
1043 86 : bPageSizeValid = true;
1044 86 : aPageSizeTwips = rSize;
1045 : }
1046 : else
1047 0 : bPageSizeValid = false;
1048 86 : }
1049 :
1050 2986 : bool ScTable::IsProtected() const
1051 : {
1052 2986 : return pTabProtection.get() && pTabProtection->isProtected();
1053 : }
1054 :
1055 11 : void ScTable::SetProtection(const ScTableProtection* pProtect)
1056 : {
1057 11 : if (pProtect)
1058 11 : pTabProtection.reset(new ScTableProtection(*pProtect));
1059 : else
1060 0 : pTabProtection.reset(NULL);
1061 :
1062 11 : if (IsStreamValid())
1063 0 : SetStreamValid(false);
1064 11 : }
1065 :
1066 2 : ScTableProtection* ScTable::GetProtection()
1067 : {
1068 2 : return pTabProtection.get();
1069 : }
1070 :
1071 374 : Size ScTable::GetPageSize() const
1072 : {
1073 374 : if ( bPageSizeValid )
1074 22 : return aPageSizeTwips;
1075 : else
1076 352 : return Size(); // leer
1077 : }
1078 :
1079 86 : 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 86 : if ( nStartCol != nRepeatStartX || nEndCol != nRepeatEndX || nStartRow != nRepeatStartY || nEndRow != nRepeatEndY )
1083 0 : InvalidatePageBreaks();
1084 :
1085 86 : nRepeatStartX = nStartCol;
1086 86 : nRepeatEndX = nEndCol;
1087 86 : nRepeatStartY = nStartRow;
1088 86 : nRepeatEndY = nEndRow;
1089 86 : }
1090 :
1091 5028 : void ScTable::StartListening( const ScAddress& rAddress, SvtListener* pListener )
1092 : {
1093 5028 : if (!ValidCol(rAddress.Col()))
1094 5028 : return;
1095 :
1096 5028 : aCol[rAddress.Col()].StartListening( *pListener, rAddress.Row() );
1097 : }
1098 :
1099 176 : void ScTable::EndListening( const ScAddress& rAddress, SvtListener* pListener )
1100 : {
1101 176 : if (!ValidCol(rAddress.Col()))
1102 176 : return;
1103 :
1104 176 : aCol[rAddress.Col()].EndListening( *pListener, rAddress.Row() );
1105 : }
1106 :
1107 103 : void ScTable::SetPageStyle( const rtl::OUString& rName )
1108 : {
1109 103 : if ( aPageStyle != rName )
1110 : {
1111 100 : rtl::OUString aStrNew = rName;
1112 100 : SfxStyleSheetBasePool* pStylePool = pDocument->GetStyleSheetPool();
1113 100 : SfxStyleSheetBase* pNewStyle = pStylePool->Find( aStrNew, SFX_STYLE_FAMILY_PAGE );
1114 :
1115 100 : if ( !pNewStyle )
1116 : {
1117 0 : aStrNew = ScGlobal::GetRscString(STR_STYLENAME_STANDARD);
1118 0 : pNewStyle = pStylePool->Find( aStrNew, SFX_STYLE_FAMILY_PAGE );
1119 : }
1120 :
1121 100 : if ( aPageStyle != aStrNew )
1122 : {
1123 100 : SfxStyleSheetBase* pOldStyle = pStylePool->Find( aPageStyle, SFX_STYLE_FAMILY_PAGE );
1124 :
1125 100 : if ( pOldStyle && pNewStyle )
1126 : {
1127 100 : SfxItemSet& rOldSet = pOldStyle->GetItemSet();
1128 100 : SfxItemSet& rNewSet = pNewStyle->GetItemSet();
1129 100 : const sal_uInt16 nOldScale = GET_SCALEVALUE(rOldSet,ATTR_PAGE_SCALE);
1130 100 : const sal_uInt16 nOldScaleToPages = GET_SCALEVALUE(rOldSet,ATTR_PAGE_SCALETOPAGES);
1131 100 : const sal_uInt16 nNewScale = GET_SCALEVALUE(rNewSet,ATTR_PAGE_SCALE);
1132 100 : const sal_uInt16 nNewScaleToPages = GET_SCALEVALUE(rNewSet,ATTR_PAGE_SCALETOPAGES);
1133 :
1134 100 : if ( (nOldScale != nNewScale) || (nOldScaleToPages != nNewScaleToPages) )
1135 0 : InvalidateTextWidth(NULL, NULL, false, false);
1136 : }
1137 :
1138 100 : if ( pNewStyle ) // auch ohne den alten (fuer UpdateStdNames)
1139 100 : aPageStyle = aStrNew;
1140 :
1141 100 : if (IsStreamValid())
1142 0 : SetStreamValid(false);
1143 100 : }
1144 : }
1145 103 : }
1146 :
1147 22 : void ScTable::PageStyleModified( const String& rNewName )
1148 : {
1149 22 : aPageStyle = rNewName;
1150 22 : InvalidateTextWidth(NULL, NULL, false, false); // don't know what was in the style before
1151 22 : }
1152 :
1153 426 : void ScTable::InvalidateTextWidth( const ScAddress* pAdrFrom, const ScAddress* pAdrTo,
1154 : bool bNumFormatChanged, bool bBroadcast )
1155 : {
1156 426 : if ( pAdrFrom && !pAdrTo )
1157 : {
1158 0 : ScBaseCell* pCell = aCol[pAdrFrom->Col()].GetCell( pAdrFrom->Row() );
1159 0 : if ( pCell )
1160 : {
1161 0 : pCell->SetTextWidth( TEXTWIDTH_DIRTY );
1162 0 : if ( bNumFormatChanged )
1163 0 : pCell->SetScriptType( SC_SCRIPTTYPE_UNKNOWN );
1164 0 : if ( bBroadcast )
1165 : { // nur bei CalcAsShown
1166 0 : switch ( pCell->GetCellType() )
1167 : {
1168 : case CELLTYPE_VALUE :
1169 : pDocument->Broadcast( SC_HINT_DATACHANGED,
1170 0 : ScAddress( pAdrFrom->Col(), pAdrFrom->Row(), nTab ),
1171 0 : pCell );
1172 0 : break;
1173 : case CELLTYPE_FORMULA :
1174 0 : ((ScFormulaCell*)pCell)->SetDirty();
1175 0 : break;
1176 : default:
1177 : {
1178 : // added to avoid warnings
1179 : }
1180 : }
1181 : }
1182 0 : }
1183 : }
1184 : else
1185 : {
1186 426 : const SCCOL nColStart = pAdrFrom ? pAdrFrom->Col() : 0;
1187 426 : const SCROW nRowStart = pAdrFrom ? pAdrFrom->Row() : 0;
1188 426 : const SCCOL nColEnd = pAdrTo ? pAdrTo->Col() : MAXCOL;
1189 426 : const SCROW nRowEnd = pAdrTo ? pAdrTo->Row() : MAXROW;
1190 :
1191 24381 : for ( SCCOL nCol=nColStart; nCol<=nColEnd; nCol++ )
1192 : {
1193 23955 : ScColumnIterator aIter( &aCol[nCol], nRowStart, nRowEnd );
1194 23955 : ScBaseCell* pCell = NULL;
1195 23955 : SCROW nRow = nRowStart;
1196 :
1197 48210 : while ( aIter.Next( nRow, pCell ) )
1198 : {
1199 300 : pCell->SetTextWidth( TEXTWIDTH_DIRTY );
1200 300 : if ( bNumFormatChanged )
1201 168 : pCell->SetScriptType( SC_SCRIPTTYPE_UNKNOWN );
1202 300 : if ( bBroadcast )
1203 : { // nur bei CalcAsShown
1204 0 : switch ( pCell->GetCellType() )
1205 : {
1206 : case CELLTYPE_VALUE :
1207 : pDocument->Broadcast( SC_HINT_DATACHANGED,
1208 0 : ScAddress( nCol, nRow, nTab ), pCell );
1209 0 : break;
1210 : case CELLTYPE_FORMULA :
1211 0 : ((ScFormulaCell*)pCell)->SetDirty();
1212 0 : break;
1213 : default:
1214 : {
1215 : // added to avoid warnings
1216 : }
1217 : }
1218 : }
1219 : }
1220 23955 : }
1221 : }
1222 426 : }
1223 :
1224 :
1225 :
1226 :
1227 :
1228 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
