?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
tdf#130857 qt weld: Implement QtInstanceWidget::strip_mnemonic
[LibreOffice.git] / sc / source / core / data / table1.cxx
blobcf22133056cf11c4740ab1bbb3bf61f5c8ee5c57
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 <sal/types.h>
21 #include <scitems.hxx>
22 #include <editeng/justifyitem.hxx>
23 #include <o3tl/safeint.hxx>
24 #include <o3tl/unit_conversion.hxx>
25 #include <unotools/textsearch.hxx>
26 #include <unotools/charclass.hxx>
27 #include <osl/diagnose.h>
28
29 #include <patattr.hxx>
30 #include <table.hxx>
31 #include <document.hxx>
32 #include <docsh.hxx>
33 #include <drwlayer.hxx>
34 #include <olinetab.hxx>
35 #include <global.hxx>
36 #include <globstr.hrc>
37 #include <scresid.hxx>
38 #include <refupdat.hxx>
39 #include <markdata.hxx>
40 #include <progress.hxx>
41 #include <prnsave.hxx>
42 #include <printopt.hxx>
43 #include <scmod.hxx>
44 #include <tabprotection.hxx>
45 #include <sheetevents.hxx>
46 #include <segmenttree.hxx>
47 #include <dbdata.hxx>
48 #include <conditio.hxx>
49 #include <globalnames.hxx>
50 #include <cellvalue.hxx>
51 #include <scmatrix.hxx>
52 #include <refupdatecontext.hxx>
53 #include <rowheightcontext.hxx>
54 #include <compressedarray.hxx>
55 #include <tabvwsh.hxx>
56 #include <vcl/svapp.hxx>
57
58 #include <formula/vectortoken.hxx>
59 #include <token.hxx>
60
61 #include <vector>
62 #include <memory>
63
64 using ::std::vector;
65
66 namespace {
67
68 ScProgress* GetProgressBar(
69 SCSIZE nCount, SCSIZE nTotalCount, ScProgress* pOuterProgress, const ScDocument* pDoc)
70 {
71 if (nTotalCount < 1000)
72 {
73 // if the total number of rows is less than 1000, don't even bother
74 // with the progress bar because drawing progress bar can be very
75 // expensive especially in GTK.
76 return nullptr;
77 }
78
79 if (pOuterProgress)
80 return pOuterProgress;
81
82 if (nCount > 1)
83 return new ScProgress(
84 pDoc->GetDocumentShell(), ScResId(STR_PROGRESS_HEIGHTING), nTotalCount, true);
85
86 return nullptr;
87 }
88
89 void GetOptimalHeightsInColumn(
90 sc::RowHeightContext& rCxt, ScColContainer& rCol, SCROW nStartRow, SCROW nEndRow,
91 ScProgress* pProgress, sal_uLong nProgressStart )
92 {
93 assert(nStartRow <= nEndRow);
94
95 // first, one time over the whole range
96 // (with the last column in the hope that they most likely still are
97 // on standard format)
98
99
100 rCol.back().GetOptimalHeight(rCxt, nStartRow, nEndRow, 0, 0);
101
102 // from there search for the standard height that is in use in the lower part
103
104 RowHeightsArray& rHeights = rCxt.getHeightArray();
105 sal_uInt16 nMinHeight = rHeights.GetValue(nEndRow);
106 SCSIZE nPos = nEndRow - 1;
107 while ( nPos )
108 {
109 auto aRangeData = rHeights.GetRangeData(nPos-1);
110 if (aRangeData.maValue < nMinHeight)
111 break;
112 nPos = std::max<SCSIZE>(0, aRangeData.mnRow1);
113 }
114
115 const SCROW nMinStart = nPos;
116
117 sal_uInt64 nWeightedCount = nProgressStart + rCol.back().GetWeightedCount(nStartRow, nEndRow);
118 const SCCOL maxCol = rCol.size() - 1; // last col done already above
119 for (SCCOL nCol=0; nCol<maxCol; nCol++)
120 {
121 rCol[nCol].GetOptimalHeight(rCxt, nStartRow, nEndRow, nMinHeight, nMinStart);
122
123 if (pProgress)
124 {
125 nWeightedCount += rCol[nCol].GetWeightedCount(nStartRow, nEndRow);
126 pProgress->SetState( nWeightedCount );
127 }
128 }
129 }
130
131 struct OptimalHeightsFuncObjBase
132 {
133 virtual ~OptimalHeightsFuncObjBase() {}
134 virtual bool operator() (SCROW nStartRow, SCROW nEndRow, sal_uInt16 nHeight, bool bApi) = 0;
135 };
136
137 struct SetRowHeightOnlyFunc : public OptimalHeightsFuncObjBase
138 {
139 ScTable* mpTab;
140 explicit SetRowHeightOnlyFunc(ScTable* pTab) :
141 mpTab(pTab)
142 {}
143
144 virtual bool operator() (SCROW nStartRow, SCROW nEndRow, sal_uInt16 nHeight, bool /* bApi */) override
145 {
146 mpTab->SetRowHeightOnly(nStartRow, nEndRow, nHeight);
147 return false;
148 }
149 };
150
151 struct SetRowHeightRangeFunc : public OptimalHeightsFuncObjBase
152 {
153 ScTable* mpTab;
154 double mnPPTY;
155
156 SetRowHeightRangeFunc(ScTable* pTab, double nPPTY) :
157 mpTab(pTab),
158 mnPPTY(nPPTY)
159 {}
160
161 virtual bool operator() (SCROW nStartRow, SCROW nEndRow, sal_uInt16 nHeight, bool bApi) override
162 {
163 return mpTab->SetRowHeightRange(nStartRow, nEndRow, nHeight, mnPPTY, bApi);
164 }
165 };
166
167 bool SetOptimalHeightsToRows(
168 sc::RowHeightContext& rCxt,
169 OptimalHeightsFuncObjBase& rFuncObj,
170 ScBitMaskCompressedArray<SCROW, CRFlags>* pRowFlags, SCROW nStartRow, SCROW nEndRow,
171 bool bApi )
172 {
173 bool bChanged = false;
174 SCROW nRngStart = 0;
175 SCROW nRngEnd = 0;
176 sal_uInt16 nLast = 0;
177 sal_uInt16 nExtraHeight = rCxt.getExtraHeight();
178 for (SCSIZE i = nStartRow; i <= o3tl::make_unsigned(nEndRow); i++)
179 {
180 size_t nIndex;
181 SCROW nRegionEndRow;
182 CRFlags nRowFlag = pRowFlags->GetValue( i, nIndex, nRegionEndRow );
183 if ( nRegionEndRow > nEndRow )
184 nRegionEndRow = nEndRow;
185 SCSIZE nMoreRows = nRegionEndRow - i; // additional equal rows after first
186
187 bool bAutoSize = !(nRowFlag & CRFlags::ManualSize);
188 if (bAutoSize || rCxt.isForceAutoSize())
189 {
190 if (nExtraHeight)
191 {
192 if (bAutoSize)
193 pRowFlags->SetValue( i, nRegionEndRow, nRowFlag | CRFlags::ManualSize);
194 }
195 else if (!bAutoSize)
196 pRowFlags->SetValue( i, nRegionEndRow, nRowFlag & ~CRFlags::ManualSize);
197
198 for (SCSIZE nInner = i; nInner <= i + nMoreRows; ++nInner)
199 {
200 if (nLast)
201 {
202 SCROW nRangeRowEnd;
203 size_t nTmp;
204 sal_uInt16 nRangeValue = rCxt.getHeightArray().GetValue(nInner, nTmp, nRangeRowEnd);
205 if (nRangeValue + nExtraHeight == nLast)
206 {
207 nRngEnd = std::min<SCSIZE>(i + nMoreRows, nRangeRowEnd);
208 nInner = nRangeRowEnd;
209 }
210 else
211 {
212 bChanged |= rFuncObj(nRngStart, nRngEnd, nLast, bApi);
213 nLast = 0;
214 }
215 }
216 if (!nLast)
217 {
218 nLast = rCxt.getHeightArray().GetValue(nInner) + rCxt.getExtraHeight();
219 nRngStart = nInner;
220 nRngEnd = nInner;
221 }
222 }
223 }
224 else
225 {
226 if (nLast)
227 bChanged |= rFuncObj(nRngStart, nRngEnd, nLast, bApi);
228 nLast = 0;
229 }
230 i += nMoreRows; // already handled - skip
231 }
232 if (nLast)
233 bChanged |= rFuncObj(nRngStart, nRngEnd, nLast, bApi);
234
235 return bChanged;
236 }
237
238 }
239
240 ScTable::ScTable( ScDocument& rDoc, SCTAB nNewTab, const OUString& rNewName,
241 bool bColInfo, bool bRowInfo ) :
242 aCol( rDoc.GetSheetLimits(), INITIALCOLCOUNT ),
243 aName( rNewName ),
244 aCodeName( rNewName ),
245 nLinkRefreshDelay( 0 ),
246 nLinkMode( ScLinkMode::NONE ),
247 aPageStyle( ScResId(STR_STYLENAME_STANDARD) ),
248 nRepeatStartX( SCCOL_REPEAT_NONE ),
249 nRepeatEndX( SCCOL_REPEAT_NONE ),
250 nRepeatStartY( SCROW_REPEAT_NONE ),
251 nRepeatEndY( SCROW_REPEAT_NONE ),
252 mnOptimalMinRowHeight(0),
253 mpRowHeights( static_cast<ScFlatUInt16RowSegments*>(nullptr) ),
254 mpHiddenCols(new ScFlatBoolColSegments(rDoc.MaxCol())),
255 mpHiddenRows(new ScFlatBoolRowSegments(rDoc.MaxRow())),
256 mpFilteredCols(new ScFlatBoolColSegments(rDoc.MaxCol())),
257 mpFilteredRows(new ScFlatBoolRowSegments(rDoc.MaxRow())),
258 nTableAreaX( 0 ),
259 nTableAreaY( 0 ),
260 nTableAreaVisibleX( 0 ),
261 nTableAreaVisibleY( 0 ),
262 nTab( nNewTab ),
263 rDocument( rDoc ),
264 pSortCollator( nullptr ),
265 nLockCount( 0 ),
266 aScenarioColor( COL_LIGHTGRAY ),
267 aTabBgColor( COL_AUTO ),
268 nScenarioFlags(ScScenarioFlags::NONE),
269 mpCondFormatList( new ScConditionalFormatList() ),
270 maLOKFreezeCell(-1, -1, nNewTab),
271 bScenario(false),
272 bLayoutRTL(false),
273 bLoadingRTL(false),
274 bPageSizeValid(false),
275 bTableAreaValid(false),
276 bTableAreaVisibleValid(false),
277 bVisible(true),
278 bPendingRowHeights(false),
279 bCalcNotification(false),
280 bGlobalKeepQuery(false),
281 bPrintEntireSheet(true),
282 bActiveScenario(false),
283 mbPageBreaksValid(false),
284 mbForceBreaks(false),
285 mbTotalsRowBelow(true),
286 bStreamValid(false)
287 {
288 aDefaultColData.InitAttrArray(new ScAttrArray(static_cast<SCCOL>(-1), nNewTab, rDoc, nullptr));
289 if (bColInfo)
290 {
291 mpColWidth.reset( new ScCompressedArray<SCCOL, sal_uInt16>( rDocument.MaxCol()+1, STD_COL_WIDTH ) );
292 mpColFlags.reset( new ScBitMaskCompressedArray<SCCOL, CRFlags>( rDocument.MaxCol()+1, CRFlags::NONE ) );
293 }
294
295 if (bRowInfo)
296 {
297 mpRowHeights.reset(new ScFlatUInt16RowSegments(rDocument.MaxRow(), GetOptimalMinRowHeight()));
298 pRowFlags.reset(new ScBitMaskCompressedArray<SCROW, CRFlags>( rDocument.MaxRow(), CRFlags::NONE));
299 }
300
301 if ( rDocument.IsDocVisible() )
302 {
303 // when a sheet is added to a visible document,
304 // initialize its RTL flag from the system locale
305 bLayoutRTL = ScGlobal::IsSystemRTL();
306 }
307
308 ScDrawLayer* pDrawLayer = rDocument.GetDrawLayer();
309 if (pDrawLayer)
310 {
311 if ( pDrawLayer->ScAddPage( nTab ) ) // sal_False (not inserted) during Undo
312 {
313 pDrawLayer->ScRenamePage( nTab, aName );
314 sal_uLong const nx = o3tl::convert((rDocument.MaxCol()+1) * STD_COL_WIDTH, o3tl::Length::twip, o3tl::Length::mm100);
315 sal_uLong ny = o3tl::convert((rDocument.MaxRow() + 1) * GetOptimalMinRowHeight(),
316 o3tl::Length::twip, o3tl::Length::mm10);
317 pDrawLayer->SetPageSize( static_cast<sal_uInt16>(nTab), Size( nx, ny ), false );
318 }
319 }
320
321 for (SCCOL k=0; k < aCol.size(); k++)
322 aCol[k].Init( k, nTab, rDocument, true );
323 }
324
325 ScTable::~ScTable() COVERITY_NOEXCEPT_FALSE
326 {
327 if (!rDocument.IsInDtorClear())
328 {
329 for (SCCOL nCol = 0; nCol < aCol.size(); ++nCol)
330 {
331 aCol[nCol].FreeNotes();
332 }
333 // In the dtor, don't delete the pages in the wrong order.
334 // (or else nTab does not reflect the page number!)
335 // In ScDocument::Clear is afterwards used from Clear at the Draw Layer to delete everything.
336
337 ScDrawLayer* pDrawLayer = rDocument.GetDrawLayer();
338 if (pDrawLayer)
339 pDrawLayer->ScRemovePage( nTab );
340 }
341
342 pRowFlags.reset();
343 pSheetEvents.reset();
344 pOutlineTable.reset();
345 pSearchText.reset();
346 moRepeatColRange.reset();
347 moRepeatRowRange.reset();
348 pScenarioRanges.reset();
349 mpRangeName.reset();
350 pDBDataNoName.reset();
351 DestroySortCollator();
352 }
353
354 sal_Int64 ScTable::GetHashCode() const
355 {
356 return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(this));
357 }
358
359 void ScTable::SetName( const OUString& rNewName )
360 {
361 aName = rNewName;
362 aUpperName.clear(); // invalidated if the name is changed
363
364 // SetStreamValid is handled in ScDocument::RenameTab
365 }
366
367 const OUString& ScTable::GetUpperName() const
368 {
369 if (aUpperName.isEmpty() && !aName.isEmpty())
370 aUpperName = ScGlobal::getCharClass().uppercase(aName);
371 return aUpperName;
372 }
373
374 void ScTable::SetVisible( bool bVis )
375 {
376 if (bVisible != bVis)
377 SetStreamValid(false);
378
379 bVisible = bVis;
380 }
381
382 void ScTable::SetStreamValid( bool bSet, bool bIgnoreLock )
383 {
384 if (!bStreamValid && !bSet)
385 return; // shortcut
386 if ( bIgnoreLock || !rDocument.IsStreamValidLocked() )
387 bStreamValid = bSet;
388 }
389
390 void ScTable::SetPendingRowHeights( bool bSet )
391 {
392 bPendingRowHeights = bSet;
393 }
394
395 void ScTable::SetLayoutRTL( bool bSet )
396 {
397 bLayoutRTL = bSet;
398 }
399
400 void ScTable::SetLoadingRTL( bool bSet )
401 {
402 bLoadingRTL = bSet;
403 }
404
405 void ScTable::SetTabBgColor(const Color& rColor)
406 {
407 if (aTabBgColor != rColor)
408 {
409 // The tab color has changed. Set this table 'modified'.
410 aTabBgColor = rColor;
411 SetStreamValid(false);
412 }
413 }
414
415 void ScTable::SetScenario( bool bFlag )
416 {
417 bScenario = bFlag;
418 }
419
420 void ScTable::SetLink( ScLinkMode nMode,
421 const OUString& rDoc, const OUString& rFlt, const OUString& rOpt,
422 const OUString& rTab, sal_Int32 nRefreshDelay )
423 {
424 nLinkMode = nMode;
425 aLinkDoc = rDoc; // File
426 aLinkFlt = rFlt; // Filter
427 aLinkOpt = rOpt; // Filter options
428 aLinkTab = rTab; // Sheet name in source file
429 nLinkRefreshDelay = nRefreshDelay; // refresh delay in seconds, 0==off
430
431 SetStreamValid(false);
432 }
433
434 sal_uInt16 ScTable::GetOptimalColWidth( SCCOL nCol, OutputDevice* pDev,
435 double nPPTX, double nPPTY,
436 const Fraction& rZoomX, const Fraction& rZoomY,
437 bool bFormula, const ScMarkData* pMarkData,
438 const ScColWidthParam* pParam )
439 {
440 if ( nCol >= aCol.size() )
441 return ( STD_COL_WIDTH - STD_EXTRA_WIDTH );
442
443 return aCol[nCol].GetOptimalColWidth( pDev, nPPTX, nPPTY, rZoomX, rZoomY,
444 bFormula, STD_COL_WIDTH - STD_EXTRA_WIDTH, pMarkData, pParam );
445 }
446
447 tools::Long ScTable::GetNeededSize( SCCOL nCol, SCROW nRow,
448 OutputDevice* pDev,
449 double nPPTX, double nPPTY,
450 const Fraction& rZoomX, const Fraction& rZoomY,
451 bool bWidth, bool bTotalSize, bool bInPrintTwips )
452 {
453 if ( nCol >= aCol.size() )
454 return 0;
455
456 ScNeededSizeOptions aOptions;
457 aOptions.bSkipMerged = false; // count merged cells
458 aOptions.bTotalSize = bTotalSize;
459
460 return aCol[nCol].GetNeededSize
461 ( nRow, pDev, nPPTX, nPPTY, rZoomX, rZoomY, bWidth, aOptions, nullptr, bInPrintTwips );
462 }
463
464 bool ScTable::SetOptimalHeight(
465 sc::RowHeightContext& rCxt, SCROW nStartRow, SCROW nEndRow, bool bApi,
466 ScProgress* pOuterProgress, sal_uInt64 nProgressStart )
467 {
468 assert(nStartRow <= nEndRow);
469
470 OSL_ENSURE( rCxt.getExtraHeight() == 0 || rCxt.isForceAutoSize(),
471 "automatic OptimalHeight with Extra" );
472
473 if ( rDocument.IsAdjustHeightLocked() )
474 {
475 return false;
476 }
477
478 if (!rCxt.isForceAutoSize())
479 {
480 // Optimize - exit early if all rows have defined height: super expensive GetOptimalHeight
481 size_t nIndex;
482 SCROW nRow;
483 CRFlags nRowFlags = pRowFlags->GetValue(nStartRow, nIndex, nRow); // changes nIndex, nRow
484 if (nRowFlags & CRFlags::ManualSize) // first block of rows is manual - are all the rest?
485 {
486 bool bAllRowsAreManualHeight = true;
487 while (nRow < nEndRow)
488 {
489 nRowFlags = pRowFlags->GetNextValue(nIndex, nRow);
490 if (!(nRowFlags & CRFlags::ManualSize))
491 {
492 bAllRowsAreManualHeight = false;
493 break;
494 }
495 }
496 if (bAllRowsAreManualHeight)
497 return false;
498 }
499 }
500
501 SCSIZE nCount = static_cast<SCSIZE>(nEndRow-nStartRow+1);
502
503 ScProgress* pProgress = GetProgressBar(nCount, GetWeightedCount(), pOuterProgress, &rDocument);
504
505 mpRowHeights->enableTreeSearch(false);
506
507 GetOptimalHeightsInColumn(rCxt, aCol, nStartRow, nEndRow, pProgress, nProgressStart);
508
509 SetRowHeightRangeFunc aFunc(this, rCxt.getPPTY());
510 bool bChanged = SetOptimalHeightsToRows(rCxt, aFunc, pRowFlags.get(), nStartRow, nEndRow, bApi);
511
512 if ( pProgress != pOuterProgress )
513 delete pProgress;
514
515 mpRowHeights->enableTreeSearch(true);
516
517 if (bChanged)
518 {
519 if (ScViewData* pViewData = ScDocShell::GetViewData())
520 {
521 ScTabViewShell::notifyAllViewsSheetGeomInvalidation(
522 pViewData->GetViewShell(),
523 false /* bColsAffected */, true /* bRowsAffected */,
524 true /* bSizes*/, false /* bHidden */, false /* bFiltered */,
525 false /* bGroups */, nTab);
526 }
527 }
528
529 return bChanged;
530 }
531
532 void ScTable::SetOptimalHeightOnly(
533 sc::RowHeightContext& rCxt, SCROW nStartRow, SCROW nEndRow,
534 ScProgress* pOuterProgress, sal_uInt64 nProgressStart )
535 {
536 OSL_ENSURE( rCxt.getExtraHeight() == 0 || rCxt.isForceAutoSize(),
537 "automatic OptimalHeight with Extra" );
538
539 if ( rDocument.IsAdjustHeightLocked() )
540 return;
541
542 SCSIZE nCount = static_cast<SCSIZE>(nEndRow-nStartRow+1);
543
544 ScProgress* pProgress = GetProgressBar(nCount, GetWeightedCount(), pOuterProgress, &rDocument);
545
546 GetOptimalHeightsInColumn(rCxt, aCol, nStartRow, nEndRow, pProgress, nProgressStart);
547
548 SetRowHeightOnlyFunc aFunc(this);
549
550 bool bChanged = SetOptimalHeightsToRows(rCxt, aFunc, pRowFlags.get(), nStartRow, nEndRow, true);
551
552 if ( pProgress != pOuterProgress )
553 delete pProgress;
554
555 if (bChanged)
556 {
557 if (ScViewData* pViewData = ScDocShell::GetViewData())
558 {
559 ScTabViewShell::notifyAllViewsSheetGeomInvalidation(
560 pViewData->GetViewShell(),
561 false /* bColsAffected */, true /* bRowsAffected */,
562 true /* bSizes*/, false /* bHidden */, false /* bFiltered */,
563 false /* bGroups */, nTab);
564 }
565 }
566 }
567
568 bool ScTable::GetCellArea( SCCOL& rEndCol, SCROW& rEndRow ) const
569 {
570 bool bFound = false;
571 SCCOL nMaxX = 0;
572 SCROW nMaxY = 0;
573 for (SCCOL i=0; i<aCol.size(); i++)
574 {
575 if (!aCol[i].IsEmptyData())
576 {
577 bFound = true;
578 nMaxX = i;
579 SCROW nRow = aCol[i].GetLastDataPos();
580 if (nRow > nMaxY)
581 nMaxY = nRow;
582 }
583 if ( aCol[i].HasCellNotes() )
584 {
585 SCROW maxNoteRow = aCol[i].GetCellNotesMaxRow();
586 if (maxNoteRow >= nMaxY)
587 {
588 bFound = true;
589 nMaxY = maxNoteRow;
590 }
591 if (i>nMaxX)
592 {
593 bFound = true;
594 nMaxX = i;
595 }
596 }
597 if (aCol[i].HasSparklines())
598 {
599 SCROW maxSparklineRow = aCol[i].GetSparklinesMaxRow();
600 if (maxSparklineRow >= nMaxY)
601 {
602 bFound = true;
603 nMaxY = maxSparklineRow;
604 }
605 if (i > nMaxX)
606 {
607 bFound = true;
608 nMaxX = i;
609 }
610 }
611 }
612
613 rEndCol = nMaxX;
614 rEndRow = nMaxY;
615 return bFound;
616 }
617
618 bool ScTable::GetTableArea( SCCOL& rEndCol, SCROW& rEndRow, bool bCalcHiddens) const
619 {
620 bool bRet = true; //TODO: remember?
621 if (bCalcHiddens)
622 {
623 if (!bTableAreaValid)
624 {
625 bRet = GetPrintArea(nTableAreaX, nTableAreaY, true, bCalcHiddens);
626 bTableAreaValid = true;
627 }
628 rEndCol = nTableAreaX;
629 rEndRow = nTableAreaY;
630 }
631 else
632 {
633 if (!bTableAreaVisibleValid)
634 {
635 bRet = GetPrintArea(nTableAreaVisibleX, nTableAreaVisibleY, true, bCalcHiddens);
636 bTableAreaVisibleValid = true;
637 }
638 rEndCol = nTableAreaVisibleX;
639 rEndRow = nTableAreaVisibleY;
640 }
641 return bRet;
642 }
643
644 const SCCOL SC_COLUMNS_STOP = 30;
645
646 bool ScTable::GetPrintArea( SCCOL& rEndCol, SCROW& rEndRow, bool bNotes, bool bCalcHiddens ) const
647 {
648 bool bFound = false;
649 SCCOL nMaxX = 0;
650 SCROW nMaxY = 0;
651 SCCOL i;
652
653 bool bSkipEmpty = ScModule::get()->GetPrintOptions().GetSkipEmpty();
654
655 for (i=0; i<aCol.size(); i++) // Test data
656 {
657 if (bCalcHiddens || !rDocument.ColHidden(i, nTab))
658 {
659 if (!aCol[i].IsEmptyData())
660 {
661 bFound = true;
662 if (i>nMaxX)
663 nMaxX = i;
664 SCROW nColY = aCol[i].GetLastDataPos();
665 if (nColY > nMaxY)
666 nMaxY = nColY;
667 }
668 if (bNotes && aCol[i].HasCellNotes() )
669 {
670 SCROW maxNoteRow = aCol[i].GetCellNotesMaxRow();
671 if (maxNoteRow >= nMaxY)
672 {
673 bFound = true;
674 nMaxY = maxNoteRow;
675 }
676 if (i>nMaxX)
677 {
678 bFound = true;
679 nMaxX = i;
680 }
681 }
682 if (aCol[i].HasSparklines())
683 {
684 SCROW maxSparklineRow = aCol[i].GetSparklinesMaxRow();
685 if (maxSparklineRow >= nMaxY)
686 {
687 bFound = true;
688 nMaxY = maxSparklineRow;
689 }
690 if (i > nMaxX)
691 {
692 bFound = true;
693 nMaxX = i;
694 }
695 }
696 }
697 }
698
699 SCCOL nMaxDataX = nMaxX;
700
701 for (i=0; i<aCol.size(); i++) // Test attribute
702 {
703 if (bCalcHiddens || !rDocument.ColHidden(i, nTab))
704 {
705 SCROW nLastRow;
706 if (aCol[i].GetLastVisibleAttr( nLastRow, bSkipEmpty ))
707 {
708 bFound = true;
709 nMaxX = i;
710 if (nLastRow > nMaxY)
711 nMaxY = nLastRow;
712 }
713 }
714 }
715
716 if (nMaxX == rDocument.MaxCol()) // omit attribute at the right
717 {
718 --nMaxX;
719 while ( nMaxX>0 && aCol[nMaxX].IsVisibleAttrEqual(aCol[nMaxX+1], 0, rDocument.MaxRow()) )
720 --nMaxX;
721 }
722
723 if ( nMaxX < nMaxDataX )
724 {
725 nMaxX = nMaxDataX;
726 }
727 else if ( nMaxX > nMaxDataX )
728 {
729 SCCOL nAttrStartX = nMaxDataX + 1;
730 while ( nAttrStartX < (aCol.size()-1) )
731 {
732 SCCOL nAttrEndX = nAttrStartX;
733 while ( nAttrEndX < (aCol.size()-1) && aCol[nAttrStartX].IsVisibleAttrEqual(aCol[nAttrEndX+1], 0, rDocument.MaxRow()) )
734 ++nAttrEndX;
735 if ( nAttrEndX + 1 - nAttrStartX >= SC_COLUMNS_STOP )
736 {
737 // found equally-formatted columns behind data -> stop before these columns
738 nMaxX = nAttrStartX - 1;
739
740 // also don't include default-formatted columns before that
741 SCROW nDummyRow;
742 while ( nMaxX > nMaxDataX && !aCol[nMaxX].GetLastVisibleAttr( nDummyRow, bSkipEmpty ) )
743 --nMaxX;
744 break;
745 }
746 nAttrStartX = nAttrEndX + 1;
747 }
748 }
749
750 rEndCol = nMaxX;
751 rEndRow = nMaxY;
752 return bFound;
753 }
754
755 bool ScTable::GetPrintAreaHor( SCROW nStartRow, SCROW nEndRow,
756 SCCOL& rEndCol ) const
757 {
758 bool bFound = false;
759 SCCOL nMaxX = 0;
760 SCCOL i;
761
762 for (i=0; i<aCol.size(); i++) // Test attribute
763 {
764 if (aCol[i].HasVisibleAttrIn( nStartRow, nEndRow ))
765 {
766 bFound = true;
767 nMaxX = i;
768 }
769 }
770
771 if (nMaxX == rDocument.MaxCol()) // omit attribute at the right
772 {
773 --nMaxX;
774 while ( nMaxX>0 && aCol[nMaxX].IsVisibleAttrEqual(aCol[nMaxX+1], nStartRow, nEndRow) )
775 --nMaxX;
776 }
777
778 for (i=0; i<aCol.size(); i++) // test the data
779 {
780 if (!aCol[i].IsEmptyData( nStartRow, nEndRow )) //TODO: bNotes ??????
781 {
782 bFound = true;
783 if (i > nMaxX)
784 nMaxX = i;
785 }
786 else if (aCol[i].HasSparklines())
787 {
788 if (i > nMaxX)
789 {
790 bFound = true;
791 nMaxX = i;
792 }
793 }
794 }
795
796 rEndCol = nMaxX;
797 return bFound;
798 }
799
800 bool ScTable::GetPrintAreaVer( SCCOL nStartCol, SCCOL nEndCol,
801 SCROW& rEndRow, bool bNotes ) const
802 {
803 bool bFound = false;
804 SCROW nMaxY = 0;
805 SCCOL i;
806
807 bool bSkipEmpty = ScModule::get()->GetPrintOptions().GetSkipEmpty();
808
809 for (i=nStartCol; i<=nEndCol && i < aCol.size(); i++) // Test attribute
810 {
811 SCROW nLastRow;
812 if (aCol[i].GetLastVisibleAttr( nLastRow, bSkipEmpty ))
813 {
814 bFound = true;
815 if (nLastRow > nMaxY)
816 nMaxY = nLastRow;
817 }
818 }
819
820 for (i=nStartCol; i<=nEndCol && i < aCol.size(); i++) // Test data
821 {
822 if (!aCol[i].IsEmptyData())
823 {
824 bFound = true;
825 SCROW nColY = aCol[i].GetLastDataPos();
826 if (nColY > nMaxY)
827 nMaxY = nColY;
828 }
829 if (bNotes && aCol[i].HasCellNotes() )
830 {
831 SCROW maxNoteRow =aCol[i].GetCellNotesMaxRow();
832 if (maxNoteRow > nMaxY)
833 {
834 bFound = true;
835 nMaxY = maxNoteRow;
836 }
837 }
838 if (aCol[i].HasSparklines())
839 {
840 SCROW maxNoteRow = aCol[i].GetSparklinesMaxRow();
841 if (maxNoteRow > nMaxY)
842 {
843 bFound = true;
844 nMaxY = maxNoteRow;
845 }
846 }
847 }
848
849 rEndRow = nMaxY;
850 return bFound;
851 }
852
853 bool ScTable::GetDataStart( SCCOL& rStartCol, SCROW& rStartRow ) const
854 {
855 bool bFound = false;
856 SCCOL nMinX = aCol.size()-1;
857 SCROW nMinY = rDocument.MaxRow();
858 SCCOL i;
859
860 for (i=0; i<aCol.size(); i++) // Test attribute
861 {
862 SCROW nFirstRow;
863 if (aCol[i].GetFirstVisibleAttr( nFirstRow ))
864 {
865 if (!bFound)
866 nMinX = i;
867 bFound = true;
868 if (nFirstRow < nMinY)
869 nMinY = nFirstRow;
870 }
871 }
872
873 if (nMinX == 0) // omit attribute at the right
874 {
875 if ( aCol.size() > 1 && aCol[0].IsVisibleAttrEqual(aCol[1], 0, rDocument.MaxRow())) // no single ones
876 {
877 ++nMinX;
878 while ( nMinX<(aCol.size()-1) && aCol[nMinX].IsVisibleAttrEqual(aCol[nMinX-1], 0, rDocument.MaxRow()))
879 ++nMinX;
880 }
881 }
882
883 bool bDatFound = false;
884 for (i=0; i<aCol.size(); i++) // Test data
885 {
886 if (!aCol[i].IsEmptyData())
887 {
888 if (!bDatFound && i<nMinX)
889 nMinX = i;
890 bFound = bDatFound = true;
891 SCROW nRow = aCol[i].GetFirstDataPos();
892 if (nRow < nMinY)
893 nMinY = nRow;
894 }
895 if ( aCol[i].HasCellNotes() )
896 {
897 SCROW minNoteRow = aCol[i].GetCellNotesMinRow();
898 if (minNoteRow <= nMinY)
899 {
900 bFound = true;
901 nMinY = minNoteRow;
902 }
903 if (i<nMinX)
904 {
905 bFound = true;
906 nMinX = i;
907 }
908 }
909 if (aCol[i].HasSparklines())
910 {
911 SCROW minSparkline = aCol[i].GetSparklinesMinRow();
912 if (minSparkline <= nMinY)
913 {
914 bFound = true;
915 nMinY = minSparkline;
916 }
917 if (i < nMinX)
918 {
919 bFound = true;
920 nMinX = i;
921 }
922 }
923 }
924 rStartCol = nMinX;
925 rStartRow = nMinY;
926 return bFound;
927 }
928
929 void ScTable::GetDataArea( SCCOL& rStartCol, SCROW& rStartRow, SCCOL& rEndCol, SCROW& rEndRow,
930 bool bIncludeOld, bool bOnlyDown ) const
931 {
932 // return the smallest area containing at least all contiguous cells having data. This area
933 // is a square containing also empty cells. It may shrink or extend the area given as input
934 // Flags as modifiers:
935 //
936 // bIncludeOld = true ensure that the returned area contains at least the initial area,
937 // independently of the emptiness of rows / columns (i.e. does not allow shrinking)
938 // bOnlyDown = true means extend / shrink the inputted area only down, i.e modify only rEndRow
939
940 rStartCol = std::min<SCCOL>( rStartCol, aCol.size()-1 );
941 rEndCol = std::min<SCCOL>( rEndCol, aCol.size()-1 );
942
943 bool bLeft = false;
944 bool bRight = false;
945 bool bTop = false;
946 bool bBottom = false;
947 bool bChanged = false;
948
949 // We need to cache sc::ColumnBlockConstPosition per each column.
950 std::vector< sc::ColumnBlockConstPosition > blockPos( rEndCol + 1 );
951 for( SCCOL i = 0; i <= rEndCol; ++i )
952 aCol[ i ].InitBlockPosition( blockPos[ i ] );
953
954 do
955 {
956 bChanged = false;
957
958 if (!bOnlyDown)
959 {
960 SCROW nStart = rStartRow;
961 SCROW nEnd = rEndRow;
962 if (nStart>0) --nStart;
963 if (nEnd<rDocument.MaxRow()) ++nEnd;
964
965 if (rEndCol < (aCol.size()-1))
966 if (!aCol[rEndCol+1].IsEmptyData(nStart,nEnd))
967 {
968 assert( int( blockPos.size()) == rEndCol + 1 );
969 ++rEndCol;
970 blockPos.resize( blockPos.size() + 1 );
971 aCol[ rEndCol ].InitBlockPosition( blockPos[ rEndCol ] );
972 bChanged = true;
973 bRight = true;
974 }
975
976 if (rStartCol > 0)
977 if (!aCol[rStartCol-1].IsEmptyData(nStart,nEnd))
978 {
979 --rStartCol;
980 bChanged = true;
981 bLeft = true;
982 }
983
984 if (rStartRow > 0)
985 {
986 SCROW nTest = rStartRow-1;
987 bool needExtend = false;
988 for ( SCCOL i = rStartCol; i<=rEndCol && !needExtend; i++)
989 if (aCol[i].HasDataAt(blockPos[i], nTest))
990 needExtend = true;
991 if (needExtend)
992 {
993 --rStartRow;
994 bChanged = true;
995 bTop = true;
996 }
997 }
998 }
999
1000 if (rEndRow < rDocument.MaxRow())
1001 {
1002 SCROW nTest = rEndRow+1;
1003 bool needExtend = false;
1004 for ( SCCOL i = rStartCol; i<=rEndCol && !needExtend; i++)
1005 if (aCol[i].HasDataAt(blockPos[ i ], nTest))
1006 needExtend = true;
1007 if (needExtend)
1008 {
1009 ++rEndRow;
1010 bChanged = true;
1011 bBottom = true;
1012 }
1013 }
1014 }
1015 while( bChanged );
1016
1017 if ( !bIncludeOld && !bOnlyDown )
1018 {
1019 if ( !bLeft )
1020 while ( rStartCol < rEndCol && rStartCol < (aCol.size()-1) && aCol[rStartCol].IsEmptyData(rStartRow,rEndRow) )
1021 ++rStartCol;
1022
1023 if ( !bRight )
1024 while ( rEndCol > 0 && rStartCol < rEndCol && aCol[rEndCol].IsEmptyData(rStartRow,rEndRow) )
1025 --rEndCol;
1026
1027 if ( !bTop && rStartRow < rDocument.MaxRow() && rStartRow < rEndRow )
1028 {
1029 bool bShrink = true;
1030 do
1031 {
1032 for ( SCCOL i = rStartCol; i<=rEndCol && bShrink; i++)
1033 if (aCol[i].HasDataAt(rStartRow))
1034 bShrink = false;
1035 if (bShrink)
1036 ++rStartRow;
1037 } while (bShrink && rStartRow < rDocument.MaxRow() && rStartRow < rEndRow);
1038 }
1039 }
1040
1041 if ( !bIncludeOld )
1042 {
1043 if ( !bBottom && rEndRow > 0 && rStartRow < rEndRow )
1044 {
1045 SCROW nLastDataRow = GetLastDataRow( rStartCol, rEndCol, rEndRow);
1046 if (nLastDataRow < rEndRow)
1047 rEndRow = std::max( rStartRow, nLastDataRow);
1048 }
1049 }
1050 }
1051
1052 bool ScTable::GetDataAreaSubrange( ScRange& rRange ) const
1053 {
1054 SCCOL nCol1 = rRange.aStart.Col(), nCol2 = rRange.aEnd.Col();
1055
1056 if ( nCol1 >= aCol.size() )
1057 return false;
1058
1059 nCol2 = std::min<SCCOL>( nCol2, aCol.size()-1 );
1060
1061 SCROW nRow1 = rRange.aStart.Row(), nRow2 = rRange.aEnd.Row();
1062
1063 SCCOL nFirstNonEmptyCol = -1, nLastNonEmptyCol = -1;
1064 SCROW nRowStart = nRow2, nRowEnd = nRow1;
1065
1066 for ( SCCOL nCol = nCol1; nCol <= nCol2; ++nCol )
1067 {
1068 SCROW nRowStartThis = nRow1, nRowEndThis = nRow2;
1069 bool bTrimmed = aCol[nCol].TrimEmptyBlocks(nRowStartThis, nRowEndThis);
1070 if ( bTrimmed )
1071 {
1072 if ( nFirstNonEmptyCol == -1 )
1073 nFirstNonEmptyCol = nCol;
1074 nLastNonEmptyCol = nCol;
1075
1076 nRowStart = std::min<SCROW>(nRowStart, nRowStartThis);
1077 nRowEnd = std::max<SCROW>(nRowEnd, nRowEndThis);
1078 }
1079 }
1080
1081 if ( nFirstNonEmptyCol == -1 )
1082 return false;
1083
1084 assert(nFirstNonEmptyCol <= nLastNonEmptyCol);
1085 assert(nRowStart <= nRowEnd);
1086
1087 rRange.aStart.Set(nFirstNonEmptyCol, nRowStart, rRange.aStart.Tab());
1088 rRange.aEnd.Set(nLastNonEmptyCol, nRowEnd, rRange.aEnd.Tab());
1089
1090 return true;
1091 }
1092
1093 bool ScTable::ShrinkToUsedDataArea( bool& o_bShrunk, SCCOL& rStartCol, SCROW& rStartRow,
1094 SCCOL& rEndCol, SCROW& rEndRow, bool bColumnsOnly, bool bStickyTopRow, bool bStickyLeftCol,
1095 ScDataAreaExtras* pDataAreaExtras ) const
1096 {
1097 rStartCol = std::min<SCCOL>( rStartCol, aCol.size()-1 );
1098 // check for rEndCol is done below.
1099
1100 o_bShrunk = false;
1101
1102 PutInOrder( rStartCol, rEndCol);
1103 PutInOrder( rStartRow, rEndRow);
1104 if (rStartCol < 0)
1105 {
1106 rStartCol = 0;
1107 o_bShrunk = true;
1108 }
1109 if (rStartRow < 0)
1110 {
1111 rStartRow = 0;
1112 o_bShrunk = true;
1113 }
1114 if (rEndCol >= aCol.size())
1115 {
1116 rEndCol = aCol.size()-1;
1117 o_bShrunk = true;
1118 }
1119 if (rEndRow > rDocument.MaxRow())
1120 {
1121 rEndRow = rDocument.MaxRow();
1122 o_bShrunk = true;
1123 }
1124
1125 while (rStartCol < rEndCol)
1126 {
1127 if (aCol[rEndCol].IsEmptyData( rStartRow, rEndRow))
1128 {
1129 if (pDataAreaExtras && pDataAreaExtras->mnEndCol < rEndCol)
1130 {
1131 // Check in order of likeliness.
1132 if ( (pDataAreaExtras->mbCellFormats
1133 && aCol[rEndCol].GetPatternCount( rStartRow, rEndRow) > 1
1134 && aCol[rEndCol].HasVisibleAttrIn( rStartRow, rEndRow)) ||
1135 (pDataAreaExtras->mbCellNotes
1136 && !aCol[rEndCol].IsNotesEmptyBlock( rStartRow, rEndRow)) ||
1137 (pDataAreaExtras->mbCellDrawObjects
1138 && !aCol[rEndCol].IsDrawObjectsEmptyBlock( rStartRow, rEndRow)))
1139 pDataAreaExtras->mnEndCol = rEndCol;
1140 }
1141
1142 --rEndCol;
1143 o_bShrunk = true;
1144 }
1145 else
1146 break; // while
1147 }
1148
1149 if (!bStickyLeftCol)
1150 {
1151 while (rStartCol < rEndCol)
1152 {
1153 if (aCol[rStartCol].IsEmptyData( rStartRow, rEndRow))
1154 {
1155 if (pDataAreaExtras && pDataAreaExtras->mnStartCol > rStartCol)
1156 {
1157 // Check in order of likeliness.
1158 if ( (pDataAreaExtras->mbCellFormats
1159 && aCol[rStartCol].GetPatternCount( rStartRow, rEndRow) > 1
1160 && aCol[rStartCol].HasVisibleAttrIn( rStartRow, rEndRow)) ||
1161 (pDataAreaExtras->mbCellNotes
1162 && !aCol[rStartCol].IsNotesEmptyBlock( rStartRow, rEndRow)) ||
1163 (pDataAreaExtras->mbCellDrawObjects
1164 && !aCol[rStartCol].IsDrawObjectsEmptyBlock( rStartRow, rEndRow)))
1165 pDataAreaExtras->mnStartCol = rStartCol;
1166 }
1167
1168 ++rStartCol;
1169 o_bShrunk = true;
1170 }
1171 else
1172 break; // while
1173 }
1174 }
1175
1176 if (!bColumnsOnly)
1177 {
1178 while (rStartRow < rEndRow)
1179 {
1180 SCROW nLastDataRow = GetLastDataRow(rStartCol, rEndCol, rEndRow, pDataAreaExtras);
1181 if (0 <= nLastDataRow && nLastDataRow < rEndRow)
1182 {
1183 rEndRow = std::max( rStartRow, nLastDataRow);
1184 o_bShrunk = true;
1185 }
1186 else
1187 break; // while
1188 }
1189
1190 if (!bStickyTopRow)
1191 {
1192 while (rStartRow < rEndRow)
1193 {
1194 bool bFound = false;
1195 for (SCCOL i=rStartCol; i<=rEndCol && !bFound; i++)
1196 {
1197 if (aCol[i].HasDataAt(rStartRow, pDataAreaExtras))
1198 bFound = true;
1199 }
1200 if (!bFound)
1201 {
1202 ++rStartRow;
1203 o_bShrunk = true;
1204 }
1205 else
1206 break; // while
1207 }
1208 }
1209 }
1210
1211 return rStartCol != rEndCol || (bColumnsOnly ?
1212 !aCol[rStartCol].IsEmptyData( rStartRow, rEndRow) :
1213 (rStartRow != rEndRow ||
1214 aCol[rStartCol].HasDataAt( rStartRow, pDataAreaExtras)));
1215 }
1216
1217 SCROW ScTable::GetLastDataRow( SCCOL nCol1, SCCOL nCol2, SCROW nLastRow, ScDataAreaExtras* pDataAreaExtras ) const
1218 {
1219 if ( !IsColValid( nCol1 ) || !ValidCol( nCol2 ) )
1220 return -1;
1221
1222 nCol2 = std::min<SCCOL>( nCol2, aCol.size() - 1 );
1223
1224 SCROW nNewLastRow = 0;
1225 for (SCCOL i = nCol1; i <= nCol2; ++i)
1226 {
1227 SCROW nThis = aCol[i].GetLastDataPos(nLastRow, pDataAreaExtras);
1228 if (nNewLastRow < nThis)
1229 nNewLastRow = nThis;
1230 }
1231
1232 return nNewLastRow;
1233 }
1234
1235 bool ScTable::IsEmptyData( SCCOL nStartCol, SCROW nStartRow,
1236 SCCOL nEndCol, SCROW nEndRow ) const
1237 {
1238 for( SCCOL col : GetAllocatedColumnsRange( nStartCol, nEndCol ))
1239 if( !aCol[col].IsEmptyData( nStartRow, nEndRow ))
1240 return false;
1241 return true;
1242 }
1243
1244 SCSIZE ScTable::GetEmptyLinesInBlock( SCCOL nStartCol, SCROW nStartRow,
1245 SCCOL nEndCol, SCROW nEndRow, ScDirection eDir ) const
1246 {
1247 SCCOL nStartColOrig = nStartCol;
1248 SCCOL nEndColOrig = nEndCol;
1249 nStartCol = std::min<SCCOL>( nStartCol, aCol.size()-1 );
1250 nEndCol = std::min<SCCOL>( nEndCol, aCol.size()-1 );
1251
1252 // The region is not allocated and does not contain any data.
1253 if ( nStartColOrig != nStartCol )
1254 return ( ((eDir == DIR_BOTTOM) || (eDir == DIR_TOP)) ?
1255 static_cast<SCSIZE>(nEndRow - nStartRow + 1) :
1256 static_cast<SCSIZE>(nEndColOrig - nStartColOrig + 1) );
1257
1258 SCSIZE nGapRight = static_cast<SCSIZE>(nEndColOrig - nEndCol);
1259 SCSIZE nCount = 0;
1260 SCCOL nCol;
1261 if ((eDir == DIR_BOTTOM) || (eDir == DIR_TOP))
1262 {
1263 nCount = static_cast<SCSIZE>(nEndRow - nStartRow + 1);
1264 for (nCol = nStartCol; nCol <= nEndCol; nCol++)
1265 nCount = std::min(nCount, aCol[nCol].GetEmptyLinesInBlock(nStartRow, nEndRow, eDir));
1266 }
1267 else if (eDir == DIR_RIGHT)
1268 {
1269 nCol = nEndCol;
1270 while ((nCol >= nStartCol) &&
1271 aCol[nCol].IsEmptyData(nStartRow, nEndRow))
1272 {
1273 nCount++;
1274 nCol--;
1275 }
1276 nCount += nGapRight;
1277 }
1278 else
1279 {
1280 nCol = nStartCol;
1281 while ((nCol <= nEndCol) && aCol[nCol].IsEmptyData(nStartRow, nEndRow))
1282 {
1283 nCount++;
1284 nCol++;
1285 }
1286
1287 // If the area between nStartCol and nEndCol are empty,
1288 // add the count of unallocated columns on the right.
1289 if ( nCol > nEndCol )
1290 nCount += nGapRight;
1291 }
1292 return nCount;
1293 }
1294
1295 bool ScTable::IsEmptyLine( SCROW nRow, SCCOL nStartCol, SCCOL nEndCol ) const
1296 {
1297 // The range of columns are unallocated hence empty.
1298 if ( nStartCol >= aCol.size() )
1299 return true;
1300
1301 nEndCol = std::min<SCCOL>( nEndCol, aCol.size()-1 );
1302
1303 for (SCCOL i=nStartCol; i<=nEndCol; i++)
1304 if (aCol[i].HasDataAt(nRow))
1305 return false;
1306 return true;
1307 }
1308
1309 void ScTable::LimitChartArea( SCCOL& rStartCol, SCROW& rStartRow, SCCOL& rEndCol, SCROW& rEndRow ) const
1310 {
1311 rStartCol = std::min<SCCOL>( rStartCol, aCol.size()-1 );
1312 rEndCol = std::min<SCCOL>( rEndCol, aCol.size()-1 );
1313
1314 while ( rStartCol<rEndCol && aCol[rStartCol].IsEmptyData(rStartRow,rEndRow) )
1315 ++rStartCol;
1316
1317 while ( rStartCol<rEndCol && aCol[rEndCol].IsEmptyData(rStartRow,rEndRow) )
1318 --rEndCol;
1319
1320 while ( rStartRow<rEndRow && IsEmptyLine(rStartRow, rStartCol, rEndCol) )
1321 ++rStartRow;
1322
1323 // Optimised loop for finding the bottom of the area, can be costly in large
1324 // spreadsheets.
1325 SCROW lastDataPos = 0;
1326 for (SCCOL i=rStartCol; i<=rEndCol; i++)
1327 lastDataPos = std::max(lastDataPos, aCol[i].GetLastDataPos());
1328 // reduce EndRow to the last row with data
1329 rEndRow = std::min(rEndRow, lastDataPos);
1330 // but make sure EndRow is >= StartRow
1331 rEndRow = std::max(rStartRow, rEndRow);
1332 }
1333
1334 SCCOL ScTable::FindNextVisibleCol( SCCOL nCol, bool bRight ) const
1335 {
1336 if(bRight)
1337 {
1338 nCol++;
1339 SCCOL nEnd = 0;
1340 bool bHidden = rDocument.ColHidden(nCol, nTab, nullptr, &nEnd);
1341 if(bHidden)
1342 nCol = nEnd +1;
1343
1344 return std::min<SCCOL>(rDocument.MaxCol(), nCol);
1345 }
1346 else
1347 {
1348 nCol--;
1349 SCCOL nStart = rDocument.MaxCol();
1350 bool bHidden = rDocument.ColHidden(nCol, nTab, &nStart);
1351 if(bHidden)
1352 nCol = nStart - 1;
1353
1354 return std::max<SCCOL>(0, nCol);
1355 }
1356 }
1357
1358 SCCOL ScTable::FindNextVisibleColWithContent( SCCOL nCol, bool bRight, SCROW nRow ) const
1359 {
1360 const SCCOL nLastCol = aCol.size() - 1;
1361 if(bRight)
1362 {
1363 // If nCol is the last allocated column index, there won't be any content to its right.
1364 // To maintain the original return behaviour, return rDocument.MaxCol().
1365 if(nCol >= nLastCol)
1366 return rDocument.MaxCol();
1367
1368 do
1369 {
1370 nCol++;
1371 SCCOL nEndCol = 0;
1372 bool bHidden = rDocument.ColHidden( nCol, nTab, nullptr, &nEndCol );
1373 if(bHidden)
1374 {
1375 nCol = nEndCol +1;
1376 // Can end search early as there is no data after nLastCol.
1377 // For nCol == nLastCol, it may still have data so don't want to return rDocument.MaxCol().
1378 if(nCol > nLastCol)
1379 return rDocument.MaxCol();
1380 }
1381
1382 if(aCol[nCol].HasVisibleDataAt(nRow))
1383 return nCol;
1384 }
1385 while(nCol < nLastCol); // Stop search as soon as the last allocated column is searched.
1386
1387 return rDocument.MaxCol();
1388 }
1389 else
1390 {
1391 if(nCol == 0)
1392 return 0;
1393
1394 // If nCol is in the unallocated range [nLastCol+1, rDocument.MaxCol()], then move it directly after nLastCol
1395 // as there is no data in the unallocated range. This also makes the search faster and avoids
1396 // the need for more range checks in the loop below.
1397 if ( nCol > nLastCol )
1398 nCol = nLastCol + 1;
1399
1400 do
1401 {
1402 nCol--;
1403 SCCOL nStartCol = rDocument.MaxCol();
1404 bool bHidden = rDocument.ColHidden( nCol, nTab, &nStartCol );
1405 if(bHidden)
1406 {
1407 nCol = nStartCol -1;
1408 if(nCol <= 0)
1409 return 0;
1410 }
1411
1412 if(aCol[nCol].HasVisibleDataAt(nRow))
1413 return nCol;
1414 }
1415 while(nCol > 0);
1416
1417 return 0;
1418 }
1419 }
1420
1421 void ScTable::FindAreaPos( SCCOL& rCol, SCROW& rRow, ScMoveDirection eDirection ) const
1422 {
1423 const SCCOL nLastCol = aCol.size() - 1;
1424
1425 if (eDirection == SC_MOVE_LEFT || eDirection == SC_MOVE_RIGHT)
1426 {
1427 SCCOL nNewCol = rCol;
1428 bool bThere = ( nNewCol <= nLastCol ) && aCol[nNewCol].HasVisibleDataAt(rRow);
1429 bool bRight = (eDirection == SC_MOVE_RIGHT);
1430 if (bThere)
1431 {
1432 if(nNewCol >= rDocument.MaxCol() && eDirection == SC_MOVE_RIGHT)
1433 return;
1434 else if(nNewCol == 0 && eDirection == SC_MOVE_LEFT)
1435 return;
1436
1437 SCCOL nNextCol = FindNextVisibleCol( nNewCol, bRight );
1438
1439 if( nNextCol <= nLastCol && aCol[nNextCol].HasVisibleDataAt(rRow) )
1440 {
1441 bool bFound = false;
1442 nNewCol = nNextCol;
1443 do
1444 {
1445 nNextCol = FindNextVisibleCol( nNewCol, bRight );
1446 if( nNextCol <= nLastCol && aCol[nNextCol].HasVisibleDataAt(rRow) )
1447 nNewCol = nNextCol;
1448 else
1449 bFound = true;
1450 }
1451 while(!bFound && nNextCol > 0 && nNextCol < rDocument.MaxCol());
1452 }
1453 else
1454 {
1455 nNewCol = FindNextVisibleColWithContent(nNewCol, bRight, rRow);
1456 }
1457 }
1458 else
1459 {
1460 nNewCol = FindNextVisibleColWithContent(nNewCol, bRight, rRow);
1461 }
1462
1463 if (nNewCol<0)
1464 nNewCol=0;
1465 if (nNewCol>rDocument.MaxCol())
1466 nNewCol=rDocument.MaxCol();
1467 rCol = nNewCol;
1468 }
1469 else
1470 {
1471 if ( rCol <= nLastCol )
1472 aCol[rCol].FindDataAreaPos(rRow,eDirection == SC_MOVE_DOWN);
1473 else
1474 {
1475 // The cell (rCol, rRow) is equivalent to an empty cell (although not allocated).
1476 // Set rRow to 0 or rDocument.MaxRow() depending on eDirection to maintain the behaviour of
1477 // ScColumn::FindDataAreaPos() when the given column is empty.
1478 rRow = ( eDirection == SC_MOVE_DOWN ) ? rDocument.MaxRow() : 0;
1479 }
1480 }
1481 }
1482
1483 bool ScTable::ValidNextPos( SCCOL nCol, SCROW nRow, const ScMarkData& rMark,
1484 bool bMarked, bool bUnprotected ) const
1485 {
1486 if (!ValidCol(nCol) || !ValidRow(nRow))
1487 return false;
1488
1489 if (rDocument.HasAttrib(nCol, nRow, nTab, nCol, nRow, nTab, HasAttrFlags::Overlapped))
1490 // Skip an overlapped cell.
1491 return false;
1492
1493 if (bMarked && !rMark.IsCellMarked(nCol,nRow))
1494 return false;
1495
1496 /* TODO: for cursor movement *only* this should even take the protection
1497 * options (select locked, select unlocked) into account, see
1498 * ScTabView::SkipCursorHorizontal() and ScTabView::SkipCursorVertical(). */
1499 if (bUnprotected && rDocument.HasAttrib(nCol, nRow, nTab, nCol, nRow, nTab, HasAttrFlags::Protected))
1500 return false;
1501
1502 if (bMarked || bUnprotected) //TODO: also in other case ???
1503 {
1504 // Hidden cells must be skipped, as the cursor would end up on the next cell
1505 // even if it is protected or not marked.
1506 //TODO: control per Extra-Parameter, only for Cursor movement ???
1507
1508 if (RowHidden(nRow))
1509 return false;
1510
1511 if (ColHidden(nCol))
1512 return false;
1513 }
1514
1515 return true;
1516 }
1517
1518 // Skips the current cell if it is Hidden, Overlapped or Protected and Sheet is Protected
1519 bool ScTable::SkipRow( const SCCOL nCol, SCROW& rRow, const SCROW nMovY,
1520 const ScMarkData& rMark, const bool bUp, const SCROW nUsedY,
1521 const bool bMarked, const bool bSheetProtected ) const
1522 {
1523 if ( !ValidRow( rRow ))
1524 return false;
1525
1526 if (bSheetProtected && rDocument.HasAttrib( nCol, rRow, nTab, nCol, rRow, nTab, HasAttrFlags::Protected))
1527 {
1528 if ( rRow > nUsedY )
1529 rRow = (bUp ? nUsedY : rDocument.MaxRow() + nMovY);
1530 else
1531 rRow += nMovY;
1532
1533 if (bMarked)
1534 rRow = rMark.GetNextMarked( nCol, rRow, bUp );
1535
1536 return true;
1537 }
1538 else
1539 {
1540 bool bRowHidden = RowHidden( rRow );
1541 bool bOverlapped = rDocument.HasAttrib( nCol, rRow, nTab, nCol, rRow, nTab, HasAttrFlags::Overlapped );
1542
1543 if ( bRowHidden || bOverlapped )
1544 {
1545 rRow += nMovY;
1546 if (bMarked)
1547 rRow = rMark.GetNextMarked( nCol, rRow, bUp );
1548
1549 return true;
1550 }
1551 }
1552
1553 return false;
1554 }
1555
1556 void ScTable::GetNextPos( SCCOL& rCol, SCROW& rRow, SCCOL nMovX, SCROW nMovY,
1557 bool bMarked, bool bUnprotected, const ScMarkData& rMark, SCCOL nTabStartCol ) const
1558 {
1559 // Ensure bMarked is set only if there is a mark.
1560 assert( !bMarked || rMark.IsMarked() || rMark.IsMultiMarked());
1561
1562 const bool bSheetProtected = IsProtected();
1563
1564 if ( bUnprotected && !bSheetProtected ) // Is sheet really protected?
1565 bUnprotected = false;
1566
1567 SCCOL nCol = rCol + nMovX;
1568 SCROW nRow = rRow + nMovY;
1569
1570 SCCOL nStartCol, nEndCol;
1571 SCROW nStartRow, nEndRow;
1572 if (bMarked)
1573 {
1574 ScRange aRange( ScAddress::UNINITIALIZED);
1575 if (rMark.IsMarked())
1576 aRange = rMark.GetMarkArea();
1577 else if (rMark.IsMultiMarked())
1578 aRange = rMark.GetMultiMarkArea();
1579 else
1580 {
1581 // Covered by assert() above, but for NDEBUG build.
1582 if (ValidColRow(nCol,nRow))
1583 {
1584 rCol = nCol;
1585 rRow = nRow;
1586 }
1587 return;
1588 }
1589 nStartCol = aRange.aStart.Col();
1590 nStartRow = aRange.aStart.Row();
1591 nEndCol = aRange.aEnd.Col();
1592 nEndRow = aRange.aEnd.Row();
1593 }
1594 else if (bUnprotected)
1595 {
1596 nStartCol = 0;
1597 nStartRow = 0;
1598 nEndCol = rCol;
1599 nEndRow = rRow;
1600 rDocument.GetPrintArea( nTab, nEndCol, nEndRow, true );
1601 // Add some cols/rows to the print area (which is "content or
1602 // visually different from empty") to enable travelling through
1603 // protected forms with empty cells and no visual indicator.
1604 // 42 might be good enough and not too much...
1605 nEndCol = std::min<SCCOL>( nEndCol+42, rDocument.MaxCol());
1606 nEndRow = std::min<SCROW>( nEndRow+42, rDocument.MaxRow());
1607 }
1608 else
1609 {
1610 // Invalid values show up for instance for Tab, when nothing is
1611 // selected and not protected (left / right edge), then leave values
1612 // unchanged.
1613 if (ValidColRow(nCol,nRow))
1614 {
1615 rCol = nCol;
1616 rRow = nRow;
1617 }
1618
1619 // Caller ensures actually moving nMovY to jump to prev/next row's
1620 // start col.
1621 if (nTabStartCol != SC_TABSTART_NONE)
1622 rCol = nTabStartCol;
1623
1624 return;
1625 }
1626
1627 if ( nMovY && (bMarked || bUnprotected))
1628 {
1629 do
1630 {
1631 const bool bUp = (nMovY < 0);
1632 const SCCOL nColAdd = (bUp ? -1 : 1);
1633
1634 if (bMarked)
1635 nRow = rMark.GetNextMarked( nCol, nRow, bUp );
1636
1637 if (nTabStartCol != SC_TABSTART_NONE)
1638 {
1639 /* NOTE: If current rCol < nTabStartCol when going down, there
1640 * is no way to detect if the previous Tab wrapped around to
1641 * the next row or if it was a Shift+Tab going backwards. The
1642 * result after a wrap is an odd jump to the next row's
1643 * nTabStartCol, which is logical though and always has been
1644 * the case. Similar for rCol > nTabStartCol when going up.
1645 * Related, it would be nice to limit advancing the position
1646 * within bounds even if another wrap would occur, but again we
1647 * can't tell if previously Tab or Shift+Tab was used, so we
1648 * don't know if it would be nTabStartCol to nEndCol (for Tab)
1649 * or nStartCol to nTabStartCol (for Shift+Tab). */
1650
1651 // Continue moving horizontally.
1652 nMovX = nColAdd;
1653 nCol = nTabStartCol;
1654 break; // do
1655 }
1656
1657 while ( SkipRow( nCol, nRow, nMovY, rMark, bUp, nEndRow, bMarked, bSheetProtected ))
1658 ;
1659
1660 sal_uInt16 nWrap = 0;
1661 while ( nRow < nStartRow || nRow > nEndRow )
1662 {
1663 nCol += nColAdd;
1664
1665 while (nStartCol <= nCol && nCol <= nEndCol && ValidCol(nCol) && ColHidden(nCol))
1666 nCol += nColAdd; // skip hidden cols
1667
1668 if (nCol < nStartCol)
1669 {
1670 nCol = nEndCol;
1671
1672 if (++nWrap >= 2)
1673 return;
1674 }
1675 else if (nCol > nEndCol)
1676 {
1677 nCol = nStartCol;
1678
1679 if (++nWrap >= 2)
1680 return;
1681 }
1682 if (nRow < nStartRow)
1683 nRow = nEndRow;
1684 else if (nRow > nEndRow)
1685 nRow = nStartRow;
1686
1687 if (bMarked)
1688 nRow = rMark.GetNextMarked( nCol, nRow, bUp );
1689
1690 while ( SkipRow( nCol, nRow, nMovY, rMark, bUp, nEndRow, bMarked, bSheetProtected ))
1691 ;
1692 }
1693 } while (false);
1694 }
1695
1696 if ( nMovX && ( bMarked || bUnprotected ) )
1697 {
1698 // wrap initial skip counting:
1699 if (nCol < nStartCol)
1700 {
1701 nCol = nEndCol;
1702 --nRow;
1703 if (nRow < nStartRow)
1704 nRow = nEndRow;
1705 }
1706 if (nCol > nEndCol)
1707 {
1708 nCol = nStartCol;
1709 ++nRow;
1710 if (nRow > nEndRow)
1711 nRow = nStartRow;
1712 }
1713
1714 if ( !ValidNextPos(nCol, nRow, rMark, bMarked, bUnprotected) )
1715 {
1716 const SCCOL nColCount = nEndCol - nStartCol + 1;
1717 std::unique_ptr<SCROW[]> pNextRows( new SCROW[nColCount]);
1718 const SCCOL nLastCol = aCol.size() - 1;
1719 const bool bUp = (nMovX < 0); // Moving left also means moving up in rows.
1720 const SCROW nRowAdd = (bUp ? -1 : 1);
1721 sal_uInt16 nWrap = 0;
1722
1723 if (bUp)
1724 {
1725 for (SCCOL i = 0; i < nColCount; ++i)
1726 pNextRows[i] = (i + nStartCol > nCol) ? (nRow + nRowAdd) : nRow;
1727 }
1728 else
1729 {
1730 for (SCCOL i = 0; i < nColCount; ++i)
1731 pNextRows[i] = (i + nStartCol < nCol) ? (nRow + nRowAdd) : nRow;
1732 }
1733 do
1734 {
1735 SCROW nNextRow = pNextRows[nCol - nStartCol] + nRowAdd;
1736 if ( bMarked )
1737 nNextRow = rMark.GetNextMarked( nCol, nNextRow, bUp );
1738 if ( bUnprotected )
1739 nNextRow = ( nCol <= nLastCol ) ? aCol[nCol].GetNextUnprotected( nNextRow, bUp ) :
1740 aDefaultColData.GetNextUnprotected( nNextRow, bUp );
1741 pNextRows[nCol - nStartCol] = nNextRow;
1742
1743 if (bUp)
1744 {
1745 SCROW nMaxRow = nStartRow - 1;
1746 for (SCCOL i = 0; i < nColCount; ++i)
1747 {
1748 if (pNextRows[i] >= nMaxRow) // when two equal the right one
1749 {
1750 nMaxRow = pNextRows[i];
1751 nCol = i + nStartCol;
1752 }
1753 }
1754 nRow = nMaxRow;
1755
1756 if ( nRow < nStartRow )
1757 {
1758 if (++nWrap >= 2)
1759 return;
1760 nCol = nEndCol;
1761 nRow = nEndRow;
1762 for (SCCOL i = 0; i < nColCount; ++i)
1763 pNextRows[i] = nEndRow; // do it all over again
1764 }
1765 }
1766 else
1767 {
1768 SCROW nMinRow = nEndRow + 1;
1769 for (SCCOL i = 0; i < nColCount; ++i)
1770 {
1771 if (pNextRows[i] < nMinRow) // when two equal the left one
1772 {
1773 nMinRow = pNextRows[i];
1774 nCol = i + nStartCol;
1775 }
1776 }
1777 nRow = nMinRow;
1778
1779 if ( nRow > nEndRow )
1780 {
1781 if (++nWrap >= 2)
1782 return;
1783 nCol = nStartCol;
1784 nRow = nStartRow;
1785 for (SCCOL i = 0; i < nColCount; ++i)
1786 pNextRows[i] = nStartRow; // do it all over again
1787 }
1788 }
1789 }
1790 while ( !ValidNextPos(nCol, nRow, rMark, bMarked, bUnprotected) );
1791 }
1792 }
1793
1794 if (ValidColRow(nCol,nRow))
1795 {
1796 rCol = nCol;
1797 rRow = nRow;
1798 }
1799 }
1800
1801 bool ScTable::GetNextMarkedCell( SCCOL& rCol, SCROW& rRow, const ScMarkData& rMark ) const
1802 {
1803 ++rRow; // next row
1804
1805 while ( rCol < aCol.size() )
1806 {
1807 ScMarkArray aArray( rMark.GetMarkArray( rCol ) );
1808 while ( rRow <= rDocument.MaxRow() )
1809 {
1810 SCROW nStart = aArray.GetNextMarked( rRow, false );
1811 if ( nStart <= rDocument.MaxRow() )
1812 {
1813 SCROW nEnd = aArray.GetMarkEnd( nStart, false );
1814
1815 const sc::CellStoreType& rCells = aCol[rCol].maCells;
1816 std::pair<sc::CellStoreType::const_iterator,size_t> aPos = rCells.position(nStart);
1817 sc::CellStoreType::const_iterator it = aPos.first;
1818 SCROW nTestRow = nStart;
1819 if (it->type == sc::element_type_empty)
1820 {
1821 // Skip the empty block.
1822 nTestRow += it->size - aPos.second;
1823 ++it;
1824 if (it == rCells.end())
1825 {
1826 // No more block. Move on to the next column.
1827 rRow = rDocument.MaxRow() + 1;
1828 continue;
1829 }
1830 }
1831
1832 if (nTestRow <= nEnd)
1833 {
1834 // Cell found.
1835 rRow = nTestRow;
1836 return true;
1837 }
1838
1839 rRow = nEnd + 1; // Search for next selected range
1840 }
1841 else
1842 rRow = rDocument.MaxRow() + 1; // End of column
1843 }
1844 rRow = 0;
1845 ++rCol; // test next column
1846 }
1847
1848 // Though searched only the allocated columns, it is equivalent to a search till rDocument.MaxCol().
1849 rCol = rDocument.MaxCol() + 1;
1850 return false; // Through all columns
1851 }
1852
1853 void ScTable::UpdateDrawRef( UpdateRefMode eUpdateRefMode, SCCOL nCol1, SCROW nRow1, SCTAB nTab1,
1854 SCCOL nCol2, SCROW nRow2, SCTAB nTab2,
1855 SCCOL nDx, SCROW nDy, SCTAB nDz, bool bUpdateNoteCaptionPos )
1856 {
1857 if ( !(nTab >= nTab1 && nTab <= nTab2 && nDz == 0) ) // only within the table
1858 return;
1859
1860 ScDrawLayer* pDrawLayer = rDocument.GetDrawLayer();
1861 if ( eUpdateRefMode != URM_COPY && pDrawLayer )
1862 {
1863 if ( eUpdateRefMode == URM_MOVE )
1864 { // source range
1865 nCol1 = sal::static_int_cast<SCCOL>( nCol1 - nDx );
1866 nRow1 = sal::static_int_cast<SCROW>( nRow1 - nDy );
1867 nCol2 = sal::static_int_cast<SCCOL>( nCol2 - nDx );
1868 nRow2 = sal::static_int_cast<SCROW>( nRow2 - nDy );
1869 }
1870 pDrawLayer->MoveArea( nTab, nCol1,nRow1, nCol2,nRow2, nDx,nDy,
1871 (eUpdateRefMode == URM_INSDEL), bUpdateNoteCaptionPos );
1872 }
1873 }
1874
1875 void ScTable::UpdateReference(
1876 sc::RefUpdateContext& rCxt, ScDocument* pUndoDoc, bool bIncludeDraw, bool bUpdateNoteCaptionPos )
1877 {
1878 bool bUpdated = false;
1879 UpdateRefMode eUpdateRefMode = rCxt.meMode;
1880 SCCOL nDx = rCxt.mnColDelta;
1881 SCROW nDy = rCxt.mnRowDelta;
1882 SCTAB nDz = rCxt.mnTabDelta;
1883 SCCOL nCol1 = rCxt.maRange.aStart.Col(), nCol2 = rCxt.maRange.aEnd.Col();
1884 SCROW nRow1 = rCxt.maRange.aStart.Row(), nRow2 = rCxt.maRange.aEnd.Row();
1885 SCTAB nTab1 = rCxt.maRange.aStart.Tab(), nTab2 = rCxt.maRange.aEnd.Tab();
1886
1887 // Named expressions need to be updated before formulas accessing them.
1888 if (mpRangeName)
1889 mpRangeName->UpdateReference(rCxt, nTab);
1890
1891 if (rCxt.meMode == URM_COPY )
1892 {
1893 for( SCCOL col : GetAllocatedColumnsRange( rCxt.maRange.aStart.Col(), rCxt.maRange.aEnd.Col()))
1894 bUpdated |= aCol[col].UpdateReference(rCxt, pUndoDoc);
1895 }
1896 else
1897 {
1898 for (SCCOL col : GetAllocatedColumnsRange(0, rDocument.MaxCol()))
1899 bUpdated |= aCol[col].UpdateReference(rCxt, pUndoDoc);
1900 // When deleting row(s), delete same row from the default attribute
1901 if (nDy < 0)
1902 aDefaultColData.DeleteRow(nRow1+nDy, -nDy);
1903 }
1904
1905 if ( bIncludeDraw )
1906 UpdateDrawRef( eUpdateRefMode, nCol1, nRow1, nTab1, nCol2, nRow2, nTab2, nDx, nDy, nDz, bUpdateNoteCaptionPos );
1907
1908 if ( nTab >= nTab1 && nTab <= nTab2 && nDz == 0 ) // print ranges: only within the table
1909 {
1910 SCTAB nSTab = nTab;
1911 SCTAB nETab = nTab;
1912 SCCOL nSCol = 0;
1913 SCROW nSRow = 0;
1914 SCCOL nECol = 0;
1915 SCROW nERow = 0;
1916 bool bRecalcPages = false;
1917
1918 for ( auto& rPrintRange : aPrintRanges )
1919 {
1920 nSCol = rPrintRange.aStart.Col();
1921 nSRow = rPrintRange.aStart.Row();
1922 nECol = rPrintRange.aEnd.Col();
1923 nERow = rPrintRange.aEnd.Row();
1924
1925 // do not try to modify sheet index of print range
1926 if ( ScRefUpdate::Update( &rDocument, eUpdateRefMode,
1927 nCol1,nRow1,nTab, nCol2,nRow2,nTab,
1928 nDx,nDy,0,
1929 nSCol,nSRow,nSTab, nECol,nERow,nETab ) )
1930 {
1931 rPrintRange = ScRange( nSCol, nSRow, 0, nECol, nERow, 0 );
1932 bRecalcPages = true;
1933 }
1934 }
1935
1936 if ( moRepeatColRange )
1937 {
1938 nSCol = moRepeatColRange->aStart.Col();
1939 nSRow = moRepeatColRange->aStart.Row();
1940 nECol = moRepeatColRange->aEnd.Col();
1941 nERow = moRepeatColRange->aEnd.Row();
1942
1943 // do not try to modify sheet index of repeat range
1944 if ( ScRefUpdate::Update( &rDocument, eUpdateRefMode,
1945 nCol1,nRow1,nTab, nCol2,nRow2,nTab,
1946 nDx,nDy,0,
1947 nSCol,nSRow,nSTab, nECol,nERow,nETab ) )
1948 {
1949 *moRepeatColRange = ScRange( nSCol, nSRow, 0, nECol, nERow, 0 );
1950 bRecalcPages = true;
1951 nRepeatStartX = nSCol; // for UpdatePageBreaks
1952 nRepeatEndX = nECol;
1953 }
1954 }
1955
1956 if ( moRepeatRowRange )
1957 {
1958 nSCol = moRepeatRowRange->aStart.Col();
1959 nSRow = moRepeatRowRange->aStart.Row();
1960 nECol = moRepeatRowRange->aEnd.Col();
1961 nERow = moRepeatRowRange->aEnd.Row();
1962
1963 // do not try to modify sheet index of repeat range
1964 if ( ScRefUpdate::Update( &rDocument, eUpdateRefMode,
1965 nCol1,nRow1,nTab, nCol2,nRow2,nTab,
1966 nDx,nDy,0,
1967 nSCol,nSRow,nSTab, nECol,nERow,nETab ) )
1968 {
1969 *moRepeatRowRange = ScRange( nSCol, nSRow, 0, nECol, nERow, 0 );
1970 bRecalcPages = true;
1971 nRepeatStartY = nSRow; // for UpdatePageBreaks
1972 nRepeatEndY = nERow;
1973 }
1974 }
1975
1976 // updating print ranges is not necessary with multiple print ranges
1977 if ( bRecalcPages && GetPrintRangeCount() <= 1 )
1978 {
1979 UpdatePageBreaks(nullptr);
1980
1981 rDocument.RepaintRange( ScRange(0,0,nTab,rDocument.MaxCol(),rDocument.MaxRow(),nTab) );
1982 }
1983 }
1984
1985 if (bUpdated)
1986 SetStreamValid(false);
1987
1988 if(mpCondFormatList)
1989 mpCondFormatList->UpdateReference(rCxt);
1990
1991 if (pTabProtection)
1992 pTabProtection->updateReference( eUpdateRefMode, rDocument, rCxt.maRange, nDx, nDy, nDz);
1993 }
1994
1995 void ScTable::UpdateTranspose( const ScRange& rSource, const ScAddress& rDest,
1996 ScDocument* pUndoDoc )
1997 {
1998 for (auto const & rpCol : aCol)
1999 rpCol->UpdateTranspose( rSource, rDest, pUndoDoc );
2000 }
2001
2002 void ScTable::UpdateGrow( const ScRange& rArea, SCCOL nGrowX, SCROW nGrowY )
2003 {
2004 for (auto const & rpCol : aCol)
2005 rpCol->UpdateGrow( rArea, nGrowX, nGrowY );
2006 }
2007
2008 void ScTable::UpdateInsertTab( sc::RefUpdateInsertTabContext& rCxt )
2009 {
2010 // Store the old tab number in sc::UpdatedRangeNames for
2011 // ScTokenArray::AdjustReferenceOnInsertedTab() to check with
2012 // isNameModified()
2013 if (mpRangeName)
2014 mpRangeName->UpdateInsertTab(rCxt, nTab);
2015
2016 if (nTab >= rCxt.mnInsertPos)
2017 {
2018 nTab += rCxt.mnSheets;
2019 if (pDBDataNoName)
2020 pDBDataNoName->UpdateMoveTab(nTab - 1 ,nTab);
2021 }
2022
2023 if (mpCondFormatList)
2024 mpCondFormatList->UpdateInsertTab(rCxt);
2025
2026 if (pTabProtection)
2027 pTabProtection->updateReference( URM_INSDEL, rDocument,
2028 ScRange( 0, 0, rCxt.mnInsertPos, rDocument.MaxCol(), rDocument.MaxRow(), MAXTAB),
2029 0, 0, rCxt.mnSheets);
2030
2031 for (SCCOL i=0; i < aCol.size(); i++)
2032 aCol[i].UpdateInsertTab(rCxt);
2033
2034 SetStreamValid(false);
2035 }
2036
2037 void ScTable::UpdateDeleteTab( sc::RefUpdateDeleteTabContext& rCxt )
2038 {
2039 // Store the old tab number in sc::UpdatedRangeNames for
2040 // ScTokenArray::AdjustReferenceOnDeletedTab() to check with
2041 // isNameModified()
2042 if (mpRangeName)
2043 mpRangeName->UpdateDeleteTab(rCxt, nTab);
2044
2045 if (nTab > rCxt.mnDeletePos)
2046 {
2047 nTab -= rCxt.mnSheets;
2048 if (pDBDataNoName)
2049 pDBDataNoName->UpdateMoveTab(nTab + 1,nTab);
2050 }
2051
2052 if (mpCondFormatList)
2053 mpCondFormatList->UpdateDeleteTab(rCxt);
2054
2055 if (pTabProtection)
2056 pTabProtection->updateReference( URM_INSDEL, rDocument,
2057 ScRange( 0, 0, rCxt.mnDeletePos, rDocument.MaxCol(), rDocument.MaxRow(), MAXTAB),
2058 0, 0, -rCxt.mnSheets);
2059
2060 for (SCCOL i = 0; i < aCol.size(); ++i)
2061 aCol[i].UpdateDeleteTab(rCxt);
2062
2063 SetStreamValid(false);
2064 }
2065
2066 void ScTable::UpdateMoveTab(
2067 sc::RefUpdateMoveTabContext& rCxt, SCTAB nTabNo, ScProgress* pProgress )
2068 {
2069 nTab = nTabNo;
2070 if (mpRangeName)
2071 mpRangeName->UpdateMoveTab(rCxt, nTab);
2072
2073 if (pDBDataNoName)
2074 pDBDataNoName->UpdateMoveTab(rCxt.mnOldPos, rCxt.mnNewPos);
2075
2076 if(mpCondFormatList)
2077 mpCondFormatList->UpdateMoveTab(rCxt);
2078
2079 if (pTabProtection)
2080 pTabProtection->updateReference( URM_REORDER, rDocument,
2081 ScRange( 0, 0, rCxt.mnOldPos, rDocument.MaxCol(), rDocument.MaxRow(), MAXTAB),
2082 0, 0, rCxt.mnNewPos - rCxt.mnOldPos);
2083
2084 for ( SCCOL i=0; i < aCol.size(); i++ )
2085 {
2086 aCol[i].UpdateMoveTab(rCxt, nTabNo);
2087 if (pProgress)
2088 pProgress->SetState(pProgress->GetState() + aCol[i].GetCodeCount());
2089 }
2090
2091 SetStreamValid(false);
2092 }
2093
2094 void ScTable::UpdateCompile( bool bForceIfNameInUse )
2095 {
2096 for (SCCOL i=0; i < aCol.size(); i++)
2097 {
2098 aCol[i].UpdateCompile( bForceIfNameInUse );
2099 }
2100 }
2101
2102 void ScTable::SetTabNo(SCTAB nNewTab)
2103 {
2104 nTab = nNewTab;
2105 for (SCCOL i=0; i < aCol.size(); i++)
2106 aCol[i].SetTabNo(nNewTab);
2107 }
2108
2109 void ScTable::FindRangeNamesInUse(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
2110 sc::UpdatedRangeNames& rIndexes) const
2111 {
2112 for (SCCOL i = nCol1; i <= nCol2 && IsColValid( i ); i++)
2113 aCol[i].FindRangeNamesInUse(nRow1, nRow2, rIndexes);
2114 }
2115
2116 void ScTable::ExtendPrintArea( OutputDevice* pDev,
2117 SCCOL /* nStartCol */, SCROW nStartRow, SCCOL& rEndCol, SCROW nEndRow )
2118 {
2119 if ( !mpColFlags || !pRowFlags )
2120 {
2121 OSL_FAIL("ExtendPrintArea: No ColInfo or RowInfo");
2122 return;
2123 }
2124
2125 Point aPix1000 = pDev->LogicToPixel(Point(1000,1000), MapMode(MapUnit::MapTwip));
2126 double nPPTX = aPix1000.X() / 1000.0;
2127 double nPPTY = aPix1000.Y() / 1000.0;
2128
2129 // First, mark those columns that we need to skip i.e. hidden and empty columns.
2130
2131 ScFlatBoolColSegments aSkipCols(rDocument.MaxCol());
2132 aSkipCols.setFalse(0, rDocument.MaxCol());
2133 for (SCCOL i = 0; i <= rDocument.MaxCol(); ++i)
2134 {
2135 SCCOL nLastCol = i;
2136 if (ColHidden(i, nullptr, &nLastCol))
2137 {
2138 // Columns are hidden in this range.
2139 aSkipCols.setTrue(i, nLastCol);
2140 }
2141 else
2142 {
2143 // These columns are visible. Check for empty columns.
2144 SCCOL nEmptyCount = 0;
2145 SCCOL j = i;
2146 for (; j <= nLastCol; ++j)
2147 {
2148 if ( j >= aCol.size() )
2149 break;
2150 if (aCol[j].IsCellCountZero()) // empty
2151 nEmptyCount++;
2152 }
2153 if (nEmptyCount)
2154 aSkipCols.setTrue(i,i+nEmptyCount);
2155 if ( j >= aCol.size() )
2156 aSkipCols.setTrue( j, rDocument.MaxCol() );
2157 }
2158 i = nLastCol;
2159 }
2160
2161 ScFlatBoolColSegments::RangeData aColData;
2162 for (SCCOL nCol = rEndCol; nCol >= 0; --nCol)
2163 {
2164 if (!aSkipCols.getRangeData(nCol, aColData))
2165 // Failed to get the data. This should never happen!
2166 return;
2167
2168 if (aColData.mbValue)
2169 {
2170 // Skip these columns.
2171 nCol = aColData.mnCol1; // move toward 0.
2172 continue;
2173 }
2174
2175 // These are visible and non-empty columns.
2176 for (SCCOL nDataCol = nCol; 0 <= nDataCol && nDataCol >= aColData.mnCol1; --nDataCol)
2177 {
2178 SCCOL nPrintCol = nDataCol;
2179 VisibleDataCellIterator aIter(rDocument, *mpHiddenRows, aCol[nDataCol]);
2180 ScRefCellValue aCell = aIter.reset(nStartRow);
2181 if (aCell.isEmpty())
2182 // No visible cells found in this column. Skip it.
2183 continue;
2184
2185 while (!aCell.isEmpty())
2186 {
2187 SCCOL nNewCol = nDataCol;
2188 SCROW nRow = aIter.getRow();
2189 if (nRow > nEndRow)
2190 // Went past the last row position. Bail out.
2191 break;
2192
2193 MaybeAddExtraColumn(nNewCol, nRow, pDev, nPPTX, nPPTY);
2194 if (nNewCol > nPrintCol)
2195 nPrintCol = nNewCol;
2196 aCell = aIter.next();
2197 }
2198
2199 if (nPrintCol > rEndCol)
2200 // Make sure we don't shrink the print area.
2201 rEndCol = nPrintCol;
2202 }
2203 nCol = aColData.mnCol1; // move toward 0.
2204 }
2205 }
2206
2207 void ScTable::MaybeAddExtraColumn(SCCOL& rCol, SCROW nRow, OutputDevice* pDev, double nPPTX, double nPPTY)
2208 {
2209 // tdf#128873 we do not need to calculate text width (heavy operation)
2210 // when we for sure know that an additional column will not be added
2211 if (GetAllocatedColumnsCount() > rCol + 1)
2212 {
2213 ScRefCellValue aNextCell = aCol[rCol + 1].GetCellValue(nRow);
2214 if (!aNextCell.isEmpty())
2215 {
2216 // return rCol as is
2217 return;
2218 }
2219 }
2220
2221 ScColumn& rColumn = aCol[rCol];
2222 ScRefCellValue aCell = rColumn.GetCellValue(nRow);
2223 if (!aCell.hasString())
2224 return;
2225
2226 tools::Long nPixel = rColumn.GetTextWidth(nRow);
2227
2228 // Width already calculated in Idle-Handler ?
2229 if ( TEXTWIDTH_DIRTY == nPixel )
2230 {
2231 ScNeededSizeOptions aOptions;
2232 aOptions.bTotalSize = true;
2233 aOptions.bFormula = false; //TODO: pass as parameter
2234 aOptions.bSkipMerged = false;
2235
2236 Fraction aZoom(1,1);
2237 nPixel = rColumn.GetNeededSize(
2238 nRow, pDev, nPPTX, nPPTY, aZoom, aZoom, true, aOptions, nullptr );
2239
2240 rColumn.SetTextWidth(nRow, static_cast<sal_uInt16>(nPixel));
2241 }
2242
2243 tools::Long nTwips = static_cast<tools::Long>(nPixel / nPPTX);
2244 tools::Long nDocW = GetColWidth( rCol );
2245
2246 tools::Long nMissing = nTwips - nDocW;
2247 if ( nMissing > 0 )
2248 {
2249 // look at alignment
2250
2251 const ScPatternAttr* pPattern = GetPattern( rCol, nRow );
2252 const SfxItemSet* pCondSet = rDocument.GetCondResult( rCol, nRow, nTab );
2253
2254 SvxCellHorJustify eHorJust =
2255 pPattern->GetItem( ATTR_HOR_JUSTIFY, pCondSet ).GetValue();
2256 if ( eHorJust == SvxCellHorJustify::Center )
2257 nMissing /= 2; // distributed into both directions
2258 else
2259 {
2260 // STANDARD is LEFT (only text is handled here)
2261 bool bRight = ( eHorJust == SvxCellHorJustify::Right );
2262 if ( IsLayoutRTL() )
2263 bRight = !bRight;
2264 if ( bRight )
2265 nMissing = 0; // extended only to the left (logical)
2266 }
2267 }
2268
2269 SCCOL nNewCol = rCol;
2270 while (nMissing > 0 && nNewCol < rDocument.MaxCol())
2271 {
2272 auto nNextCol = nNewCol + 1;
2273 bool bNextEmpty = true;
2274 if (GetAllocatedColumnsCount() > nNextCol)
2275 {
2276 ScRefCellValue aNextCell = aCol[nNextCol].GetCellValue(nRow);
2277 bNextEmpty = aNextCell.isEmpty();
2278 }
2279 if (!bNextEmpty)
2280 {
2281 // Cell content in a next column ends display of this string.
2282 nMissing = 0;
2283 }
2284 else
2285 nMissing -= GetColWidth(++nNewCol);
2286 }
2287 rCol = nNewCol;
2288 }
2289
2290 namespace {
2291
2292 class SetTableIndex
2293 {
2294 SCTAB mnTab;
2295 public:
2296 explicit SetTableIndex(SCTAB nTab) : mnTab(nTab) {}
2297
2298 void operator() (ScRange& rRange) const
2299 {
2300 rRange.aStart.SetTab(mnTab);
2301 rRange.aEnd.SetTab(mnTab);
2302 }
2303 };
2304
2305 }
2306
2307 void ScTable::CopyPrintRange(const ScTable& rTable)
2308 {
2309 // The table index shouldn't be used when the print range is used, but
2310 // just in case set the correct table index.
2311
2312 aPrintRanges = rTable.aPrintRanges;
2313 ::std::for_each(aPrintRanges.begin(), aPrintRanges.end(), SetTableIndex(nTab));
2314
2315 bPrintEntireSheet = rTable.bPrintEntireSheet;
2316
2317 moRepeatColRange.reset();
2318 if (rTable.moRepeatColRange)
2319 {
2320 moRepeatColRange.emplace(*rTable.moRepeatColRange);
2321 moRepeatColRange->aStart.SetTab(nTab);
2322 moRepeatColRange->aEnd.SetTab(nTab);
2323 }
2324
2325 moRepeatRowRange.reset();
2326 if (rTable.moRepeatRowRange)
2327 {
2328 moRepeatRowRange.emplace(*rTable.moRepeatRowRange);
2329 moRepeatRowRange->aStart.SetTab(nTab);
2330 moRepeatRowRange->aEnd.SetTab(nTab);
2331 }
2332 }
2333
2334 void ScTable::SetRepeatColRange( std::optional<ScRange> oNew )
2335 {
2336 moRepeatColRange = std::move(oNew);
2337
2338 SetStreamValid(false);
2339
2340 InvalidatePageBreaks();
2341 }
2342
2343 void ScTable::SetRepeatRowRange( std::optional<ScRange> oNew )
2344 {
2345 moRepeatRowRange = std::move(oNew);
2346
2347 SetStreamValid(false);
2348
2349 InvalidatePageBreaks();
2350 }
2351
2352 void ScTable::ClearPrintRanges()
2353 {
2354 aPrintRanges.clear();
2355 bPrintEntireSheet = false;
2356
2357 SetStreamValid(false);
2358
2359 InvalidatePageBreaks(); // #i117952# forget page breaks for an old print range
2360 }
2361
2362 void ScTable::ClearPrintNamedRanges()
2363 {
2364 // tdf#100034 Clearing print ranges also requires to remove all print named ranges
2365 // Iterate over all named ranges to determine which are print areas to be removed
2366 if (mpRangeName)
2367 {
2368 std::vector<ScRangeData*> aRangesToRemove;
2369 for (auto it = mpRangeName->begin(); it != mpRangeName->end(); it++)
2370 {
2371 ScRangeData* pData = it->second.get();
2372 if (pData->HasType(ScRangeData::Type::PrintArea))
2373 aRangesToRemove.push_back(pData);
2374 }
2375
2376 // Effectively remove all named ranges that refer to print ranges
2377 for (auto pItem : aRangesToRemove)
2378 mpRangeName->erase(*pItem);
2379 }
2380 }
2381
2382 void ScTable::AddPrintRange( const ScRange& rNew )
2383 {
2384 bPrintEntireSheet = false;
2385 if( aPrintRanges.size() < 0xFFFF )
2386 aPrintRanges.push_back( rNew );
2387
2388 SetStreamValid(false);
2389
2390 InvalidatePageBreaks();
2391 }
2392
2393 void ScTable::SetPrintEntireSheet()
2394 {
2395 if( !IsPrintEntireSheet() )
2396 {
2397 ClearPrintRanges();
2398 bPrintEntireSheet = true;
2399 }
2400 }
2401
2402 const ScRange* ScTable::GetPrintRange(sal_uInt16 nPos) const
2403 {
2404 return (nPos < GetPrintRangeCount()) ? &aPrintRanges[ nPos ] : nullptr;
2405 }
2406
2407 void ScTable::FillPrintSaver( ScPrintSaverTab& rSaveTab ) const
2408 {
2409 rSaveTab.SetAreas( std::vector(aPrintRanges), bPrintEntireSheet );
2410 rSaveTab.SetRepeat( moRepeatColRange, moRepeatRowRange );
2411 }
2412
2413 void ScTable::RestorePrintRanges( const ScPrintSaverTab& rSaveTab )
2414 {
2415 aPrintRanges = rSaveTab.GetPrintRanges();
2416 bPrintEntireSheet = rSaveTab.IsEntireSheet();
2417 SetRepeatColRange( rSaveTab.GetRepeatCol() );
2418 SetRepeatRowRange( rSaveTab.GetRepeatRow() );
2419
2420 InvalidatePageBreaks(); // #i117952# forget page breaks for an old print range
2421 UpdatePageBreaks(nullptr);
2422 }
2423
2424 ScTable::VisibleDataCellIterator::VisibleDataCellIterator(const ScDocument& rDoc, ScFlatBoolRowSegments& rRowSegs, ScColumn& rColumn) :
2425 mrDocument(rDoc),
2426 mrRowSegs(rRowSegs),
2427 mrColumn(rColumn),
2428 mnCurRow(ROW_NOT_FOUND),
2429 mnUBound(ROW_NOT_FOUND)
2430 {
2431 }
2432
2433 ScRefCellValue ScTable::VisibleDataCellIterator::reset(SCROW nRow)
2434 {
2435 if (nRow > mrDocument.MaxRow())
2436 {
2437 mnCurRow = ROW_NOT_FOUND;
2438 return ScRefCellValue();
2439 }
2440
2441 ScFlatBoolRowSegments::RangeData aData;
2442 if (!mrRowSegs.getRangeData(nRow, aData))
2443 {
2444 mnCurRow = ROW_NOT_FOUND;
2445 return ScRefCellValue();
2446 }
2447
2448 if (!aData.mbValue)
2449 {
2450 // specified row is visible. Take it.
2451 mnCurRow = nRow;
2452 mnUBound = aData.mnRow2;
2453 }
2454 else
2455 {
2456 // specified row is not-visible. The first visible row is the start of
2457 // the next segment.
2458 mnCurRow = aData.mnRow2 + 1;
2459 mnUBound = mnCurRow; // get range data on the next iteration.
2460 if (mnCurRow > mrDocument.MaxRow())
2461 {
2462 // Make sure the row doesn't exceed our current limit.
2463 mnCurRow = ROW_NOT_FOUND;
2464 return ScRefCellValue();
2465 }
2466 }
2467
2468 maCell = mrColumn.GetCellValue(mnCurRow);
2469 if (!maCell.isEmpty())
2470 // First visible cell found.
2471 return maCell;
2472
2473 // Find a first visible cell below this row (if any).
2474 return next();
2475 }
2476
2477 ScRefCellValue ScTable::VisibleDataCellIterator::next()
2478 {
2479 if (mnCurRow == ROW_NOT_FOUND)
2480 return ScRefCellValue();
2481
2482 while (mrColumn.GetNextDataPos(mnCurRow))
2483 {
2484 if (mnCurRow > mnUBound)
2485 {
2486 // We don't know the visibility of this row range. Query it.
2487 ScFlatBoolRowSegments::RangeData aData;
2488 if (!mrRowSegs.getRangeData(mnCurRow, aData))
2489 {
2490 mnCurRow = ROW_NOT_FOUND;
2491 return ScRefCellValue();
2492 }
2493
2494 if (aData.mbValue)
2495 {
2496 // This row is invisible. Skip to the last invisible row and
2497 // try again.
2498 mnCurRow = mnUBound = aData.mnRow2;
2499 continue;
2500 }
2501
2502 // This row is visible.
2503 mnUBound = aData.mnRow2;
2504 }
2505
2506 maCell = mrColumn.GetCellValue(mnCurRow);
2507 if (!maCell.isEmpty())
2508 return maCell;
2509 }
2510
2511 mnCurRow = ROW_NOT_FOUND;
2512 return ScRefCellValue();
2513 }
2514
2515 void ScTable::SetAnonymousDBData(std::unique_ptr<ScDBData> pDBData)
2516 {
2517 pDBDataNoName = std::move(pDBData);
2518 }
2519
2520 sal_uInt32 ScTable::AddCondFormat( std::unique_ptr<ScConditionalFormat> pNew )
2521 {
2522 if(!mpCondFormatList)
2523 mpCondFormatList.reset(new ScConditionalFormatList());
2524
2525 sal_uInt32 nMax = mpCondFormatList->getMaxKey();
2526
2527 pNew->SetKey(nMax+1);
2528 mpCondFormatList->InsertNew(std::move(pNew));
2529
2530 return nMax + 1;
2531 }
2532
2533 SvtScriptType ScTable::GetScriptType( SCCOL nCol, SCROW nRow ) const
2534 {
2535 if ( !IsColValid( nCol ) )
2536 return SvtScriptType::NONE;
2537
2538 return aCol[nCol].GetScriptType(nRow);
2539 }
2540
2541 void ScTable::SetScriptType( SCCOL nCol, SCROW nRow, SvtScriptType nType )
2542 {
2543 if (!ValidCol(nCol))
2544 return;
2545
2546 aCol[nCol].SetScriptType(nRow, nType);
2547 }
2548
2549 SvtScriptType ScTable::GetRangeScriptType(
2550 sc::ColumnBlockPosition& rBlockPos, SCCOL nCol, SCROW nRow1, SCROW nRow2 )
2551 {
2552 if ( !IsColValid( nCol ) )
2553 return SvtScriptType::NONE;
2554
2555 sc::CellStoreType::iterator itr = aCol[nCol].maCells.begin();
2556 return aCol[nCol].GetRangeScriptType(rBlockPos.miCellTextAttrPos, nRow1, nRow2, itr);
2557 }
2558
2559 formula::FormulaTokenRef ScTable::ResolveStaticReference( SCCOL nCol, SCROW nRow )
2560 {
2561 if ( !ValidCol( nCol ) || !ValidRow( nRow ) )
2562 return formula::FormulaTokenRef();
2563 if ( nCol >= aCol.size() )
2564 // Return a value of 0.0 if column not exists
2565 return formula::FormulaTokenRef(new formula::FormulaDoubleToken(0.0));
2566 return aCol[nCol].ResolveStaticReference(nRow);
2567 }
2568
2569 formula::FormulaTokenRef ScTable::ResolveStaticReference( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 )
2570 {
2571 if (nCol2 < nCol1 || nRow2 < nRow1)
2572 return formula::FormulaTokenRef();
2573
2574 if ( !ValidCol( nCol1 ) || !ValidCol( nCol2 ) || !ValidRow( nRow1 ) || !ValidRow( nRow2 ) )
2575 return formula::FormulaTokenRef();
2576
2577 SCCOL nMaxCol;
2578 if ( nCol2 >= aCol.size() )
2579 nMaxCol = aCol.size() - 1;
2580 else
2581 nMaxCol = nCol2;
2582
2583 ScMatrixRef pMat(new ScMatrix(nCol2-nCol1+1, nRow2-nRow1+1, 0.0));
2584 for (SCCOL nCol = nCol1; nCol <= nMaxCol; ++nCol)
2585 {
2586 if (!aCol[nCol].ResolveStaticReference(*pMat, nCol2-nCol1, nRow1, nRow2))
2587 // Column contains non-static cell. Failed.
2588 return formula::FormulaTokenRef();
2589 }
2590
2591 return formula::FormulaTokenRef(new ScMatrixToken(std::move(pMat)));
2592 }
2593
2594 formula::VectorRefArray ScTable::FetchVectorRefArray( SCCOL nCol, SCROW nRow1, SCROW nRow2 )
2595 {
2596 if (nRow2 < nRow1)
2597 return formula::VectorRefArray();
2598
2599 if ( !IsColValid( nCol ) || !ValidRow( nRow1 ) || !ValidRow( nRow2 ) )
2600 return formula::VectorRefArray();
2601
2602 return aCol[nCol].FetchVectorRefArray(nRow1, nRow2);
2603 }
2604
2605 #ifdef DBG_UTIL
2606 void ScTable::AssertNoInterpretNeeded( SCCOL nCol, SCROW nRow1, SCROW nRow2 )
2607 {
2608 assert( nRow2 >= nRow1 );
2609 assert( IsColValid( nCol ) && ValidRow( nRow1 ) && ValidRow( nRow2 ) );
2610 return aCol[nCol].AssertNoInterpretNeeded(nRow1, nRow2);
2611 }
2612 #endif
2613
2614 bool ScTable::HandleRefArrayForParallelism( SCCOL nCol, SCROW nRow1, SCROW nRow2, const ScFormulaCellGroupRef& mxGroup, ScAddress* pDirtiedAddress )
2615 {
2616 if (nRow2 < nRow1)
2617 return false;
2618
2619 if ( !IsColValid( nCol ) || !ValidRow( nRow1 ) || !ValidRow( nRow2 ) )
2620 return false;
2621
2622 mpHiddenCols->makeReady();
2623 mpHiddenRows->makeReady();
2624 mpFilteredCols->makeReady();
2625 mpFilteredRows->makeReady();
2626
2627 return aCol[nCol].HandleRefArrayForParallelism(nRow1, nRow2, mxGroup, pDirtiedAddress);
2628 }
2629
2630 ScRefCellValue ScTable::GetRefCellValue( SCCOL nCol, SCROW nRow )
2631 {
2632 if ( !IsColRowValid( nCol, nRow ) )
2633 return ScRefCellValue();
2634
2635 return aCol[nCol].GetCellValue(nRow);
2636 }
2637
2638 ScRefCellValue ScTable::GetRefCellValue( SCCOL nCol, SCROW nRow, sc::ColumnBlockPosition& rBlockPos )
2639 {
2640 if ( !IsColRowValid( nCol, nRow ) )
2641 return ScRefCellValue();
2642
2643 return aCol[nCol].GetCellValue(rBlockPos, nRow);
2644 }
2645
2646 SvtBroadcaster* ScTable::GetBroadcaster( SCCOL nCol, SCROW nRow )
2647 {
2648 if ( !IsColRowValid( nCol, nRow ) )
2649 return nullptr;
2650
2651 return aCol[nCol].GetBroadcaster(nRow);
2652 }
2653
2654 void ScTable::DeleteBroadcasters(
2655 sc::ColumnBlockPosition& rBlockPos, SCCOL nCol, SCROW nRow1, SCROW nRow2 )
2656 {
2657 if ( !IsColValid( nCol ) )
2658 return;
2659
2660 aCol[nCol].DeleteBroadcasters(rBlockPos, nRow1, nRow2);
2661 }
2662
2663 void ScTable::DeleteEmptyBroadcasters()
2664 {
2665 for( auto& col : aCol )
2666 col->DeleteEmptyBroadcasters();
2667 }
2668
2669 void ScTable::FillMatrix( ScMatrix& rMat, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, svl::SharedStringPool* pPool ) const
2670 {
2671 size_t nMatCol = 0;
2672 nCol2 = ClampToAllocatedColumns(nCol2);
2673 for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol, ++nMatCol)
2674 aCol[nCol].FillMatrix(rMat, nMatCol, nRow1, nRow2, pPool);
2675 }
2676
2677 void ScTable::InterpretDirtyCells( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 )
2678 {
2679 nCol2 = ClampToAllocatedColumns(nCol2);
2680 for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
2681 aCol[nCol].InterpretDirtyCells(nRow1, nRow2);
2682 }
2683
2684 bool ScTable::InterpretCellsIfNeeded( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 )
2685 {
2686 nCol2 = ClampToAllocatedColumns(nCol2);
2687 bool allInterpreted = true;
2688 for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
2689 if(!aCol[nCol].InterpretCellsIfNeeded(nRow1, nRow2))
2690 allInterpreted = false;
2691 return allInterpreted;
2692 }
2693
2694 void ScTable::SetFormulaResults( SCCOL nCol, SCROW nRow, const double* pResults, size_t nLen )
2695 {
2696 if (!ValidCol(nCol))
2697 return;
2698
2699 aCol[nCol].SetFormulaResults(nRow, pResults, nLen);
2700 }
2701
2702 void ScTable::CalculateInColumnInThread( ScInterpreterContext& rContext,
2703 SCCOL nColStart, SCCOL nColEnd,
2704 SCROW nRowStart, SCROW nRowEnd,
2705 unsigned nThisThread, unsigned nThreadsTotal)
2706 {
2707 if (!ValidCol(nColStart) || !ValidCol(nColEnd))
2708 return;
2709
2710 size_t nLen = nRowEnd - nRowStart + 1;
2711 size_t nOffset = 0;
2712 for (SCCOL nCurrCol = nColStart; nCurrCol <= nColEnd; ++nCurrCol)
2713 {
2714 aCol[nCurrCol].CalculateInThread( rContext, nRowStart, nLen, nOffset, nThisThread, nThreadsTotal );
2715 nOffset += nLen;
2716 }
2717 }
2718
2719 void ScTable::HandleStuffAfterParallelCalculation( SCCOL nColStart, SCCOL nColEnd, SCROW nRow, size_t nLen,
2720 ScInterpreter* pInterpreter)
2721 {
2722 assert(ValidCol(nColStart) && ValidCol(nColEnd));
2723
2724 for (SCCOL nCurrCol = nColStart; nCurrCol <= nColEnd; ++nCurrCol)
2725 aCol[nCurrCol].HandleStuffAfterParallelCalculation( nRow, nLen, pInterpreter );
2726 }
2727
2728 #if DUMP_COLUMN_STORAGE
2729 void ScTable::DumpColumnStorage( SCCOL nCol ) const
2730 {
2731 if ( !IsColValid( nCol ) )
2732 return;
2733
2734 aCol[nCol].DumpColumnStorage();
2735 }
2736 #endif
2737
2738 const SvtBroadcaster* ScTable::GetBroadcaster( SCCOL nCol, SCROW nRow ) const
2739 {
2740 if ( !IsColRowValid( nCol, nRow ) )
2741 return nullptr;
2742
2743 return aCol[nCol].GetBroadcaster(nRow);
2744 }
2745
2746 void ScTable::DeleteConditionalFormat( sal_uLong nIndex )
2747 {
2748 mpCondFormatList->erase(nIndex);
2749 }
2750
2751 void ScTable::SetCondFormList( ScConditionalFormatList* pNew )
2752 {
2753 mpCondFormatList.reset( pNew );
2754 }
2755
2756 ScConditionalFormatList* ScTable::GetCondFormList()
2757 {
2758 if(!mpCondFormatList)
2759 mpCondFormatList.reset( new ScConditionalFormatList() );
2760
2761 return mpCondFormatList.get();
2762 }
2763
2764 const ScConditionalFormatList* ScTable::GetCondFormList() const
2765 {
2766 return mpCondFormatList.get();
2767 }
2768
2769 ScColumnsRange ScTable::GetWritableColumnsRange(SCCOL nColBegin, SCCOL nColEnd)
2770 {
2771 // because the range is inclusive, some code will pass nColEnd<nColBegin to indicate an empty range
2772 if (nColEnd < nColBegin)
2773 return ScColumnsRange(-1, -1);
2774 assert( nColEnd >= 0 && nColEnd <= GetDoc().MaxCol());
2775 CreateColumnIfNotExists(nColEnd);
2776 return GetColumnsRange(nColBegin, nColEnd);
2777 }
2778
2779 ScColumnsRange ScTable::GetAllocatedColumnsRange(SCCOL nColBegin, SCCOL nColEnd) const
2780 {
2781 if (nColBegin >= aCol.size())
2782 return ScColumnsRange(-1, -1);
2783 // clamp end of range to available columns
2784 if (nColEnd >= aCol.size())
2785 nColEnd = aCol.size() - 1;
2786 return GetColumnsRange(nColBegin, nColEnd);
2787 }
2788
2789 ScColumnsRange ScTable::GetColumnsRange(SCCOL nColBegin, SCCOL nColEnd) const
2790 {
2791 // because the range is inclusive, some code will pass nColEnd<nColBegin to indicate an empty range
2792 if (nColEnd < nColBegin)
2793 return ScColumnsRange(-1, -1);
2794 assert( nColBegin >= 0 && nColBegin <= GetDoc().MaxCol());
2795 assert( nColEnd >= 0 && nColEnd <= GetDoc().MaxCol());
2796 return ScColumnsRange(nColBegin, nColEnd + 1); // change inclusive end to past-end
2797 }
2798
2799 // out-of-line the cold part of the CreateColumnIfNotExists function
2800 void ScTable::CreateColumnIfNotExistsImpl( const SCCOL nScCol )
2801 {
2802 // When doing multi-threaded load of, e.g. XLS files, we can hit this, which calls
2803 // into SfxItemPool::Put, in parallel with other code that calls into SfxItemPool::Put,
2804 // which is bad since that code is not thread-safe.
2805 SolarMutexGuard aGuard;
2806 const SCCOL aOldColSize = aCol.size();
2807 aCol.resize( rDocument.GetSheetLimits(), static_cast< size_t >( nScCol + 1 ) );
2808 for (SCCOL i = aOldColSize; i <= nScCol; i++)
2809 aCol[i].Init( i, nTab, rDocument, false );
2810 }
2811 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE