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