24#include <document.hxx>
36#include <tokenarray.hxx>
40#include <progress.hxx>
73#define SC_ROT_BREAK_FACTOR 6
78 return ( nScript != SvtScriptType::LATIN &&
79 nScript != SvtScriptType::ASIAN &&
80 nScript != SvtScriptType::COMPLEX );
89 const ScPatternAttr** ppPatternChange,
bool bInPrintTwips )
const
98 std::pair<sc::CellStoreType::const_iterator,size_t> aPos =
maCells.position(nRow);
99 sc::CellStoreType::const_iterator it = aPos.first;
108 auto conditionalScaleFunc = [bInPrintTwips](
tools::Long nMeasure,
double fScale) {
109 return bInPrintTwips ? nMeasure :
static_cast<tools::Long>(nMeasure * fScale);
146 *ppPatternChange = pPattern;
153 eHorJust = pCondItem->GetValue();
158 if ( eHorJust == SvxCellHorJustify::Block )
161 bBreak = pLineBreakCell->
GetValue();
166 sal_uInt32 nFormat = pPattern->
GetNumberFormat( pFormatter, pCondSet );
177 bCellIsValue = pFCell->
IsValue();
183 *ppPatternChange = pPattern;
189 if (bBreak && bCellIsValue && (pFormatter->
GetType(nFormat) == SvNumFormatType::NUMBER))
198 if (bMayInvalidatePattern)
202 *ppPatternChange = pPattern;
206 if (!bMayInvalidatePattern || pPattern == pOldPattern)
211 if (pFormatter->
GetType(nFormat) == SvNumFormatType::NUMBER)
220 bool bAsianVertical = ( eOrient == SvxCellOrientation::Stacked &&
222 if ( bAsianVertical )
225 if ( bWidth && bBreak )
230 if ( eOrient == SvxCellOrientation::Standard )
235 nRotate = pRotateValueItem->
GetValue();
243 eRotMode = pRotateModeItem->GetValue();
247 if ( nRotate == 18000_deg100 )
252 if ( eHorJust == SvxCellHorJustify::Repeat )
255 eOrient = SvxCellOrientation::Standard;
257 bAsianVertical =
false;
266 sal_uInt16 nIndent = 0;
267 if ( eHorJust == SvxCellHorJustify::Left )
284 Fraction aFontZoom = ( eOrient == SvxCellOrientation::Standard ) ? rZoomX : rZoomY;
291 bool bAddMargin =
true;
295 eOrient == SvxCellOrientation::Stacked ||
303 aCell, nFormat, &pColor, *pFormatter, rDocument,
true, rOptions.
bFormula);
305 if (!aValStr.isEmpty())
310 if ( eOrient != SvxCellOrientation::Standard )
321 double nCosAbs = fabs( cos( nRealOrient ) );
322 double nSinAbs = fabs( sin( nRealOrient ) );
335 (bInPrintTwips ? 1.0 : nPPT) * nCosAbs / nSinAbs );
344 if ( nHeight > nCmp )
348 aSize =
Size( nWidth, nHeight );
359 nValue += conditionalScaleFunc(nIndent, nPPT);
368 if ( bBreak && !bWidth )
376 nDocSize = (nDocSize * 9) / 10;
377 if ( aSize.
Width() > nDocSize )
388 MapMode aHMMMode( MapUnit::Map100thMM,
Point(), rZoomX, rZoomY );
393 const bool bPrevUpdateLayout = pEngine->SetUpdateLayout(
false );
397 nCtrl |= EEControlBits::FORMAT100;
400 pEngine->SetControlWord( nCtrl );
403 pEngine->SetRefDevice( pDev );
405 SfxItemSet aSet( pEngine->GetEmptyItemSet() );
423 pEngine->SetHyphenator( xXHyphenator );
426 Size aPaper( 1000000, 1000000 );
427 if ( eOrient==SvxCellOrientation::Stacked && !bAsianVertical )
431 double fWidthFactor = bInPrintTwips ? 1.0 :
nPPTX;
445 for (
SCCOL nColAdd=1; nColAdd<nColMerge; nColAdd++)
451 nDocWidth -=
static_cast<tools::Long>( nIndent * fWidthFactor );
464 aPaper = bInPrintTwips ?
469 pEngine->SetPaperSize(aPaper);
473 pEngine->SetTextNewDefaults(*aCell.
getEditText(), std::move(aSet));
479 aCell, nFormat, &pColor, *pFormatter, rDocument,
true,
482 if (!aString.isEmpty())
483 pEngine->SetTextNewDefaults(aString, std::move(aSet));
485 pEngine->SetDefaults(std::move(aSet));
488 bool bEngineVertical = pEngine->IsEffectivelyVertical();
489 pEngine->SetVertical( bAsianVertical );
490 pEngine->SetUpdateLayout( bPrevUpdateLayout );
492 bool bEdWidth = bWidth;
493 if ( eOrient != SvxCellOrientation::Standard && eOrient != SvxCellOrientation::Stacked )
494 bEdWidth = !bEdWidth;
499 Size aSize( pEngine->CalcTextWidth(), pEngine->GetTextHeight() );
501 double nCosAbs = fabs( cos( nRealOrient ) );
502 double nSinAbs = fabs( sin( nRealOrient ) );
513 (bInPrintTwips ? 1.0 : nPPT) * nCosAbs / nSinAbs );
517 aSize =
Size( nWidth, nHeight );
519 Size aTextSize = bInPrintTwips ?
544 sal_uInt32 aTextSize(pEngine->CalcTextWidth());
552 sal_uInt32 aTextSize(pEngine->GetTextHeight());
559 ( pEngine->GetParagraphCount() > 1 || ( bBreak && pEngine->GetLineCount(0) > 1 ) ) )
561 pEngine->SetControlWord( nCtrl | EEControlBits::FORMAT100 );
562 pEngine->QuickFormatDoc(
true );
563 aTextSize = pEngine->GetTextHeight();
567 if ( nSecondValue >
nValue )
572 if (
nValue && bAddMargin )
579 nValue += conditionalScaleFunc(nIndent, nPPT);
590 nValue += conditionalScaleFunc(
598 pEngine->SetVertical( bEngineVertical );
628 OUString maMaxLenStr;
632 void checkLineBreak(
const OUString& aStrVal)
634 sal_Int32 nFromIndex = 0;
635 sal_Int32 nToIndex = aStrVal.indexOf(
'\n', nFromIndex);
639 mnMaxLen = aStrVal.getLength();
640 maMaxLenStr = aStrVal;
644 sal_Int32 nMaxLen = 0;
646 while (nToIndex != -1)
648 if (nMaxLen < nToIndex - nFromIndex)
650 nMaxLen = nToIndex - nFromIndex;
652 nFromIndex = nToIndex + 1;
653 nToIndex = aStrVal.indexOf(
'\n', nFromIndex);
656 nToIndex = aStrVal.getLength() - nFromIndex;
657 if (nMaxLen < nToIndex)
662 if (mnMaxLen < nMaxLen)
665 maMaxLenStr = aStrVal.subView(nFromIndex);
676 if (aValStr.getLength() <= mnMaxLen)
683 mnMaxLen = aValStr.getLength();
684 maMaxLenStr = aValStr;
690 checkLineBreak(aValStr);
695 MaxStrLenFinder(
ScDocument& rDoc, sal_uInt32 nFormat) :
696 mrDoc(rDoc), mnFormat(nFormat), mnMaxLen(0) {}
698 void operator() (
size_t ,
double f)
724 const OUString& getMaxLenStr()
const {
return maMaxLenStr; }
746 aMarkedSpans.emplace_back(0,
GetDoc().MaxRow());
748 sal_uInt16 nWidth =
static_cast<sal_uInt16
>(nOldWidth*
nPPTX);
775 if (pNextPattern != pPattern)
784 aCell, nFormat, &pColor, *pFormatter, rDocument);
789 MaxStrLenFinder aFunc(rDocument, nFormat);
790 sc::CellStoreType::const_iterator itPos =
maCells.begin();
791 for (
const auto& rMarkedSpan : aMarkedSpans)
794 aLongStr = aFunc.getMaxLenStr();
797 if (!aLongStr.isEmpty())
799 nWidth = pDev->
GetTextWidth(aLongStr) +
static_cast<sal_uInt16
>(nMargin);
810 sc::CellStoreType::const_iterator itPos =
maCells.begin();
812 for (
auto [ nRow, nRow2 ] : aMarkedSpans)
814 while (nRow <= nRow2)
817 std::tie(itPos, nOffset) =
maCells.position(itPos, nRow);
821 nRow += itPos->size - nOffset;
825 for (; nOffset < itPos->size && nRow <= nRow2; ++nOffset, ++nRow)
828 if (nScript == SvtScriptType::NONE)
833 aOptions.
bGetFont = (pPattern != pOldPattern || nScript != SvtScriptType::NONE);
834 pOldPattern = pPattern;
836 nRow, pDev,
nPPTX,
nPPTY, rZoomX, rZoomY,
true, aOptions, &pOldPattern));
837 if (nThis && (nThis > nWidth || !bFound))
850 sal_uInt16 nTwips =
static_cast<sal_uInt16
>(
851 std::min(nWidth /
nPPTX, std::numeric_limits<sal_uInt16>::max() / 2.0));
863 sal_uInt16 nHeight = rFontHeight.
GetHeight();
870 nHeight += nHeight / 4;
918 bool bStdOnly =
false;
923 SvxCellHorJustify::Block);
940 bool bHasEditCells =
HasEditCells(nStart,nEnd,nEditPos);
947 pPattern = aIter.
Resync( nStart, nStart, nEnd);
948 if (bHasEditCells && nEnd < nEditPos)
949 bHasEditCells =
false;
952 if (nEditPos == nStart)
969 aSpanSet.
scan(*
this, nStart, nEnd);
975 sal_uInt16 nLatHeight = 0;
976 sal_uInt16 nCjkHeight = 0;
977 sal_uInt16 nCtlHeight = 0;
978 sal_uInt16 nDefHeight;
980 if ( nDefScript == SvtScriptType::ASIAN )
982 else if ( nDefScript == SvtScriptType::COMPLEX )
989 SCROW nStdEnd = nEnd;
990 if ( nDefHeight <= nMinHeight && nStdEnd >= nMinStart )
991 nStdEnd = (nMinStart>0) ? nMinStart-1 : 0;
993 if (nStart <= nStdEnd)
1000 sal_uInt16 nRangeHeight = rHeights.
GetValue(nRow,
nIndex, nRangeEnd);
1001 if (nRangeHeight < nDefHeight)
1002 rHeights.
SetValue(nRow, std::min(nRangeEnd, nStdEnd), nDefHeight);
1003 nRow = nRangeEnd + 1;
1014 sc::CellStoreType::iterator itCells =
maCells.begin();
1015 for (
const auto& rSpan : aSpans)
1017 for (
SCROW nRow = rSpan.mnRow1; nRow <= rSpan.mnRow2; ++nRow)
1020 if (nScript == nDefScript)
1023 if ( nScript == SvtScriptType::ASIAN )
1025 if ( nCjkHeight == 0 )
1027 if (nCjkHeight > rHeights.
GetValue(nRow))
1028 rHeights.
SetValue(nRow, nRow, nCjkHeight);
1030 else if ( nScript == SvtScriptType::COMPLEX )
1032 if ( nCtlHeight == 0 )
1034 if (nCtlHeight > rHeights.
GetValue(nRow))
1035 rHeights.
SetValue(nRow, nRow, nCtlHeight);
1039 if ( nLatHeight == 0 )
1041 if (nLatHeight > rHeights.
GetValue(nRow))
1042 rHeights.
SetValue(nRow, nRow, nLatHeight);
1053 for (
const auto& rSpan : aSpans)
1055 for (
SCROW nRow = rSpan.mnRow1; nRow <= rSpan.mnRow2; ++nRow)
1063 sal_uInt16 nHeight =
static_cast<sal_uInt16
>(
1068 double(std::numeric_limits<sal_uInt16>::max())));
1069 if (nHeight > rHeights.
GetValue(nRow))
1070 rHeights.
SetValue(nRow, nRow, nHeight);
1072 if (pPattern != pOldPattern)
1074 pPattern = aIter.
Resync( nRow, nStart, nEnd);
1090 pPattern = aIter.
Next(nStart,nEnd);
1097 sc::CellStoreType::const_iterator it =
maCells.position(nRow).first;
1098 mdds::mtv::element_t
eType = it->type;
1112 if (!rDocument.
ValidRow(nRow) || nRow > lastDataPos )
1119 it =
maCells.position(it, nRow).first;
1134 it =
maCells.position(it, nRow).first;
1163 std::vector<StrEntry> maStrEntries;
1169 void commitStrings()
1172 sc::CellStoreType::iterator it =
mrCells.begin();
1173 for (
const auto& rStrEntry : maStrEntries)
1174 it =
mrCells.set(it, rStrEntry.mnRow, rPool.
intern(rStrEntry.maStr));
1178class RemoveEditAttribsHandler :
public StrEntries
1180 std::unique_ptr<ScFieldEditEngine> mpEngine;
1197 mpEngine->SetControlWord(mpEngine->GetControlWord() | EEControlBits::ONLINESPELLING);
1200 mpEngine->SetTextCurrentDefaults(*pObj);
1201 sal_Int32 nParCount = mpEngine->GetParagraphCount();
1202 for (sal_Int32 nPar=0; nPar<nParCount; nPar++)
1204 mpEngine->RemoveCharAttribs(nPar);
1205 const SfxItemSet& rOld = mpEngine->GetParaAttribs(nPar);
1209 mpEngine->SetParaAttribs( nPar, aNew );
1213 mpEngine->RemoveFields();
1215 bool bSpellErrors = mpEngine->HasOnlineSpellErrors();
1216 bool bNeedObject = bSpellErrors || nParCount>1;
1222 EEControlBits nWantBig = bSpellErrors ? EEControlBits::ALLOWBIGOBJS : EEControlBits::NONE;
1223 if ( ( nCtrl & EEControlBits::ALLOWBIGOBJS ) != nWantBig )
1224 mpEngine->SetControlWord( (nCtrl & ~EEControlBits::ALLOWBIGOBJS) | nWantBig );
1228 pObj = mpEngine->CreateTextObject().release();
1234 maStrEntries.emplace_back(nRow, aText);
1239class TestTabRefAbsHandler
1244 explicit TestTabRefAbsHandler(
SCTAB nTab) : mnTab(nTab), mbTestResult(false) {}
1248 if (
const_cast<ScFormulaCell*
>(pCell)->TestTabRefAbs(mnTab))
1249 mbTestResult =
true;
1252 bool getTestResult()
const {
return mbTestResult; }
1264 aFunc.commitStrings();
1269 TestTabRefAbsHandler aFunc(nTable);
1271 return aFunc.getTestResult();
1288 const sc::CellStoreType::value_type& node,
size_t ,
size_t nDataSize)
1296 size_t getCount()
const {
return mnCount; }
1305 return aFunc.getCount();
1310 std::pair<sc::CellStoreType::const_iterator,size_t> aPos =
maCells.position(nRow);
1311 sc::CellStoreType::const_iterator it = aPos.first;
1321 std::pair<sc::CellStoreType::const_iterator,size_t> aPos =
maCells.position(nStartRow);
1322 sc::CellStoreType::const_iterator it = aPos.first;
1332 SCROW nNextRow = nStartRow + it->size - aPos.second;
1333 return nEndRow < nNextRow;
1338 std::pair<sc::CellNoteStoreType::const_iterator,size_t> aPos =
maCellNotes.position(nStartRow);
1339 sc::CellNoteStoreType::const_iterator it = aPos.first;
1349 SCROW nNextRow = nStartRow + it->size - aPos.second;
1350 return nEndRow < nNextRow;
1361 size_t nLength = nEndRow - nStartRow + 1;
1362 std::pair<sc::CellStoreType::const_iterator,size_t> aPos =
maCells.position(nStartRow);
1363 sc::CellStoreType::const_iterator it = aPos.first;
1369 size_t nThisLen = it->size - aPos.second;
1370 return std::min(nThisLen,
nLength);
1376 size_t nLength = nEndRow - nStartRow + 1;
1377 std::pair<sc::CellStoreType::const_iterator,size_t> aPos =
maCells.position(nEndRow);
1378 sc::CellStoreType::const_iterator it = aPos.first;
1384 size_t nThisLen = aPos.second + 1;
1385 return std::min(nThisLen,
nLength);
1400 sc::CellStoreType::const_iterator it =
maCells.begin();
1412 sc::CellStoreType::const_reverse_iterator it =
maCells.rbegin();
1421 nLastRow = std::min( nLastRow,
GetDoc().MaxRow());
1423 if (pDataAreaExtras && pDataAreaExtras->
mnEndRow < nLastRow)
1429 pDataAreaExtras->
mnEndRow = nLastRow;
1432 sc::CellStoreType::const_position_type aPos =
maCells.position(nLastRow);
1437 if (aPos.first ==
maCells.begin())
1441 return static_cast<SCROW>(aPos.first->position - 1);
1446 std::pair<sc::CellStoreType::const_iterator,size_t> aPos =
maCells.position(rRow);
1447 sc::CellStoreType::const_iterator it = aPos.first;
1457 rRow -= aPos.second + 1;
1492 std::pair<sc::CellStoreType::const_iterator,size_t> aPos = maCells.position(rRow);
1493 sc::CellStoreType::const_iterator it = aPos.first;
1494 if (it == maCells.end())
1500 rRow += it->size - aPos.second;
1502 if (it == maCells.end())
1510 if (aPos.second < it->size - 1)
1518 rRow += it->size - aPos.second;
1520 if (it == maCells.end())
1529 if (it == maCells.end())
1538 assert(rRowStart <= rRowEnd);
1539 SCROW nRowStartNew = rRowStart, nRowEndNew = rRowEnd;
1542 std::pair<sc::CellStoreType::const_iterator,size_t> aPos =
maCells.position(rRowStart);
1543 sc::CellStoreType::const_iterator it = aPos.first;
1550 nRowStartNew += it->size - aPos.second;
1551 if (nRowStartNew > rRowEnd)
1560 aPos =
maCells.position(rRowEnd);
1564 rRowStart = nRowStartNew;
1571 assert(it !=
maCells.begin());
1573 nRowEndNew -= aPos.second + 1;
1574 assert(nRowStartNew <= nRowEndNew);
1577 rRowStart = nRowStartNew;
1578 rRowEnd = nRowEndNew;
1590 return std::min<SCROW>(
GetDoc().MaxRow(), nEndRow + 1);
1600 return std::max<SCROW>(0, nStartRow - 1);
1607 sc::CellStoreType::const_iterator& itPos,
SCROW nRow,
bool bForward)
const
1616 bool bHidden = rDocument.
RowHidden(nRow,
nTab,
nullptr, &nEndRow);
1620 if(nRow >=
GetDoc().MaxRow())
1624 std::pair<sc::CellStoreType::const_iterator,size_t> aPos =
maCells.position(itPos, nRow);
1634 nRow += itPos->size - aPos.second - 1;
1636 while (nRow <
GetDoc().MaxRow());
1648 nRow = nStartRow - 1;
1653 std::pair<sc::CellStoreType::const_iterator,size_t> aPos =
maCells.position(itPos, nRow);
1663 nRow -= aPos.second;
1679 assert(sal::static_int_cast<SCROW>(
maCells.size()) ==
GetDoc().GetMaxRowCount()
1680 &&
"Size of the cell array is incorrect." );
1683 &&
"Size of the cell text attribute array is incorrect.");
1686 &&
"Size of the broadcaster array is incorrect.");
1688#if DEBUG_COLUMN_STORAGE
1692 auto itCell = std::find_if(
maCells.begin(),
maCells.end(), lIsEmptyType);
1695 while (itCell !=
maCells.end())
1697 if (itCell->position != itAttr->position || itCell->size != itAttr->size)
1699 cout <<
"ScColumn::CellStorageModified: Cell array and cell text attribute array are out of sync." <<
endl;
1700 cout <<
"-- cell array" <<
endl;
1702 cout <<
"-- attribute array" <<
endl;
1710 itCell = std::find_if(itCell,
maCells.end(), lIsEmptyType);
1718#if DUMP_COLUMN_STORAGE
1722#define DUMP_FORMULA_RESULTS 0
1724struct ColumnStorageDumper
1728 ColumnStorageDumper(
const ScDocument& rDoc ) : mrDoc(rDoc) {}
1730 void operator() (
const sc::CellStoreType::value_type& rNode)
const
1735 cout <<
" * numeric block (pos=" << rNode.position <<
", length=" << rNode.size <<
")" <<
endl;
1738 cout <<
" * string block (pos=" << rNode.position <<
", length=" << rNode.size <<
")" <<
endl;
1741 cout <<
" * edit-text block (pos=" << rNode.position <<
", length=" << rNode.size <<
")" <<
endl;
1744 dumpFormulaBlock(rNode);
1747 cout <<
" * empty block (pos=" << rNode.position <<
", length=" << rNode.size <<
")" <<
endl;
1750 cout <<
" * unknown block" <<
endl;
1754 void dumpFormulaBlock(
const sc::CellStoreType::value_type& rNode)
const
1756 cout <<
" * formula block (pos=" << rNode.position <<
", length=" << rNode.size <<
")" <<
endl;
1757 sc::formula_block::const_iterator it = sc::formula_block::begin(*rNode.data);
1758 sc::formula_block::const_iterator itEnd = sc::formula_block::end(*rNode.data);
1760 for (; it != itEnd; ++it)
1765 cout <<
" * row " << pCell->
aPos.
Row() <<
" not shared" <<
endl;
1766 printFormula(pCell);
1773 cout <<
" * row " << pCell->
aPos.
Row() <<
" shared with top row "
1780 cout <<
" * group: start=" << pCell->
aPos.
Row() <<
", length=" << nLen <<
endl;
1781 printFormula(pCell);
1786 for (
SCROW i = 0;
i < nLen-1; ++
i, ++it)
1799 cout <<
" * formula: " << aFormula <<
endl;
1802#if DUMP_FORMULA_RESULTS
1806 cout <<
" * result: ";
1810 cout << aRes.
mfValue <<
" (type: value)";
1816 cout <<
"error (" <<
static_cast<int>(aRes.
mnError) <<
")";
1837 cout <<
"-- table: " <<
nTab <<
"; column: " <<
nCol <<
endl;
1839 cout <<
"--" <<
endl;
1850 size_t nBlockStart = 0, nRowPos =
static_cast<size_t>(nRow1);
1851 itBlk = std::find_if(itBlk, itBlkEnd, [&nRowPos, &nBlockStart](
const auto& rAttr) {
1852 return nBlockStart <= nRowPos && nRowPos < nBlockStart + rAttr.size; });
1854 if (itBlk == itBlkEnd)
1859 size_t nOffsetInBlock = nRowPos - nBlockStart;
1861 nRowPos =
static_cast<size_t>(nRow2);
1864 sc::celltextattr_block::const_iterator itData, itDataEnd;
1865 for (; itBlk != itBlkEnd; ++itBlk, nBlockStart = nBlockEnd, nOffsetInBlock = 0)
1867 nBlockEnd = nBlockStart + itBlk->size;
1871 if (nBlockStart <= nRowPos && nRowPos < nBlockEnd)
1873 rDestCol.
maCellTextAttrs.set_empty(nBlockStart + nOffsetInBlock, nRowPos);
1875 rDestCol.
maCellTextAttrs.set_empty(nBlockStart + nOffsetInBlock, nBlockEnd-1);
1881 itData = sc::celltextattr_block::begin(*itBlk->data);
1882 itDataEnd = sc::celltextattr_block::end(*itBlk->data);
1883 std::advance(itData, nOffsetInBlock);
1885 if (nBlockStart <= nRowPos && nRowPos < nBlockEnd)
1888 size_t nOffset = nRowPos - nBlockStart + 1;
1889 itDataEnd = sc::celltextattr_block::begin(*itBlk->data);
1890 std::advance(itDataEnd, nOffset);
1892 rDestCol.
maCellTextAttrs.set(nBlockStart + nOffsetInBlock, itData, itDataEnd);
1896 rDestCol.
maCellTextAttrs.set(nBlockStart + nOffsetInBlock, itData, itDataEnd);
1902class CopyCellNotesHandler
1906 sc::CellNoteStoreType::iterator miPos;
1912 bool mbCloneCaption;
1915 CopyCellNotesHandler(
const ScColumn& rSrcCol,
ScColumn& rDestCol,
SCROW nDestOffset,
bool bCloneCaption ) :
1916 mrDestCol(rDestCol),
1917 mrDestNotes(rDestCol.GetCellNoteStore()),
1918 miPos(mrDestNotes.
begin()),
1919 mnSrcTab(rSrcCol.GetTab()),
1920 mnSrcCol(rSrcCol.GetCol()),
1921 mnDestTab(rDestCol.GetTab()),
1922 mnDestCol(rDestCol.GetCol()),
1923 mnDestOffset(nDestOffset),
1924 mbCloneCaption(bCloneCaption) {}
1926 void operator() (
size_t nRow,
const ScPostIt* p )
1928 SCROW nDestRow = nRow + mnDestOffset;
1929 ScAddress aSrcPos(mnSrcCol, nRow, mnSrcTab);
1930 ScAddress aDestPos(mnDestCol, nDestRow, mnDestTab);
1931 ScPostIt* pNew =
p->Clone(aSrcPos, mrDestCol.
GetDoc(), aDestPos, mbCloneCaption).release();
1932 miPos = mrDestNotes.set(miPos, nDestRow, pNew);
1948 bool bWasLocked = bool();
1953 bWasLocked = pDrawLayer->
isLocked();
1956 CopyCellNotesHandler aFunc(*
this, rDestCol, nRowOffsetDest, bCloneCaption);
1959 pDrawLayer->
setLock(bWasLocked);
1963 bool bCloneCaption,
SCROW nRowOffsetDest )
const
1991 sc::broadcaster_block::iterator it = sc::broadcaster_block::begin(*rBroadcaster.data);
1992 sc::broadcaster_block::iterator itEnd = sc::broadcaster_block::end(*rBroadcaster.data);
1993 for (; it != itEnd; ++it)
1994 (*it)->PrepareForDestruction();
2001struct BroadcasterNoListenersPredicate
2016 BroadcasterNoListenersPredicate predicate;
2017 sc::SetElementsToEmpty1<sc::broadcaster_block>(
maBroadcasters, predicate );
2026class DeletingSparklinesHandler
2033 : m_rDocument(rDocument)
2060 DeletingSparklinesHandler aFunction(
GetDoc(),
nTab);
2071 DeletingSparklinesHandler aFunction(
GetDoc(),
nTab);
2080 std::pair<sc::SparklineStoreType::const_iterator,size_t> aPos =
maSparklines.position(nStartRow);
2081 sc::SparklineStoreType::const_iterator it = aPos.first;
2089 SCROW nNextRow = nStartRow + it->size - aPos.second;
2090 return nEndRow < nNextRow;
2096class CopySparklinesHandler
2100 sc::SparklineStoreType::iterator miDestPosition;
2104 CopySparklinesHandler(
ScColumn& rDestColumn,
SCROW nDestOffset)
2105 : mrDestColumn(rDestColumn)
2106 , mrDestSparkline(mrDestColumn.GetSparklineStore())
2107 , miDestPosition(mrDestSparkline.
begin())
2108 , mnDestOffset(nDestOffset)
2113 SCROW nDestRow = nRow + mnDestOffset;
2118 auto& rDestDoc = mrDestColumn.
GetDoc();
2120 if (!pDestinationGroup)
2121 pDestinationGroup = std::make_shared<sc::SparklineGroup>(*pGroup);
2122 auto pNewSparkline = std::make_shared<sc::Sparkline>(mrDestColumn.
GetCol(), nDestRow, pDestinationGroup);
2123 pNewSparkline->setInputRange(pSparkline->getInputRange());
2125 auto* pList = rDestDoc.GetSparklineList(mrDestColumn.
GetTab());
2126 pList->addSparkline(pNewSparkline);
2128 miDestPosition = mrDestSparkline.set(miDestPosition, nDestRow,
new sc::SparklineCell(pNewSparkline));
2140 CopySparklinesHandler aFunctor(rDestCol, nRowOffsetDest);
2164 maxRow = rSparkline.position + rSparkline.size - 1;
2173 [](
const auto& rSparkline)
2175 return rSparkline.type == sc::element_type_sparkline;
2178 minRow = it->position;
2202 return sc::cellnote_block::at(*aPos.first->data, aPos.second);
2217 class CellNoteHandler
2221 const bool m_bForgetCaptionOwnership;
2224 CellNoteHandler(
const ScDocument* pDocument,
const ScAddress& rPos,
bool bForgetCaptionOwnership) :
2225 m_pDocument(pDocument),
2227 m_bForgetCaptionOwnership(bForgetCaptionOwnership) {}
2229 void operator() (
size_t nRow,
ScPostIt* p )
2231 if (m_bForgetCaptionOwnership)
2246 CellNoteHandler aFunc(&
GetDoc(), aAddr, bForgetCaptionOwnership);
2272 maxRow = rCellNote.position + rCellNote.size -1;
2281 [](
const auto& rCellNote) { return rCellNote.type == sc::element_type_cellnote; });
2283 minRow = it->position;
2294 sc::CellTextAttrStoreType::position_type aPos =
maCellTextAttrs.position(nRow);
2299 sc::celltextattr_block::at(*aPos.first->data, aPos.second).mnTextWidth = nWidth;
2306 return SvtScriptType::NONE;
2312 sc::CellTextAttrStoreType::iterator& itPos,
SCROW nRow1,
SCROW nRow2,
const sc::CellStoreType::iterator& itrCells_ )
2315 return SvtScriptType::NONE;
2318 std::pair<sc::CellTextAttrStoreType::iterator,size_t> aRet =
2322 sc::CellStoreType::iterator itrCells = itrCells_;
2325 bool bUpdated =
false;
2328 sc::celltextattr_block::iterator it = sc::celltextattr_block::begin(*itPos->data);
2329 sc::celltextattr_block::iterator itEnd = sc::celltextattr_block::end(*itPos->data);
2330 std::advance(it, aRet.second);
2331 for (; it != itEnd; ++it, ++nRow)
2345 nRow += itPos->size - aRet.second;
2348 while (nRow <= nRow2)
2357 nRow += itPos->size;
2361 sc::celltextattr_block::iterator it = sc::celltextattr_block::begin(*itPos->data);
2362 sc::celltextattr_block::iterator itEnd = sc::celltextattr_block::end(*itPos->data);
2363 for (; it != itEnd; ++it, ++nRow)
2387 sc::CellTextAttrStoreType::position_type aPos =
maCellTextAttrs.position(nRow);
2392 sc::celltextattr_block::at(*aPos.first->data, aPos.second).mnScriptType =
nType;
2398 std::pair<sc::CellStoreType::iterator,size_t> aPos =
maCells.position(nRow);
2399 sc::CellStoreType::iterator it = aPos.first;
2408 double fVal = sc::numeric_block::at(*it->data, aPos.second);
2413 ScFormulaCell*
p = sc::formula_block::at(*it->data, aPos.second);
2426 const EditTextObject* pText = sc::edittext_block::at(*it->data, aPos.second);
2440class ToMatrixHandler
2449 mrMat(rMat), mnMatCol(nMatCol), mnTopRow(nTopRow),
2450 mpDoc(pDoc), mrStrPool(pDoc->GetSharedStringPool()) {}
2452 void operator() (
size_t nRow,
double fVal)
2454 mrMat.
PutDouble(fVal, mnMatCol, nRow - mnTopRow);
2469 mrMat.
PutString(rSS, mnMatCol, nRow - mnTopRow);
2485 ToMatrixHandler aFunc(rMat, nMatCol, nRow1, &
GetDoc());
2498 std::vector<double> maNumVals;
2499 std::vector<svl::SharedString> maStrVals;
2501 CellBucket() : mnEmpValStart(0), mnNumValStart(0), mnStrValStart(0), mnEmpValCount(0) {}
2510 else if (!maNumVals.empty())
2512 const double*
p = maNumVals.data();
2513 rMat.
PutDouble(p, maNumVals.size(), nCol, mnNumValStart);
2516 else if (!maStrVals.empty())
2519 rMat.
PutString(p, maStrVals.size(), nCol, mnStrValStart);
2526 mnEmpValStart = mnNumValStart = mnStrValStart = 0;
2533class FillMatrixHandler
2545 mrMat(rMat), mnMatCol(nMatCol), mnTopRow(nTopRow),
2546 mpDoc(pDoc), mrPool(pDoc->GetSharedStringPool()), mpPool(pPool) {}
2548 void operator() (
const sc::CellStoreType::value_type& node,
size_t nOffset,
size_t nDataSize)
2550 size_t nMatRow = node.position + nOffset - mnTopRow;
2556 const double*
p = &sc::numeric_block::at(*node.data, nOffset);
2557 mrMat.
PutDouble(p, nDataSize, mnMatCol, nMatRow);
2565 mrMat.
PutString(p, nDataSize, mnMatCol, nMatRow);
2569 std::vector<svl::SharedString> aStrings;
2570 aStrings.reserve(nDataSize);
2572 for (
size_t i = 0;
i < nDataSize; ++
i)
2574 aStrings.push_back(mpPool->
intern(p[i].getString()));
2576 mrMat.
PutString(aStrings.data(), aStrings.size(), mnMatCol, nMatRow);
2582 std::vector<svl::SharedString> aSSs;
2583 aSSs.reserve(nDataSize);
2584 sc::edittext_block::const_iterator it = sc::edittext_block::begin(*node.data);
2585 std::advance(it, nOffset);
2586 sc::edittext_block::const_iterator itEnd = it;
2587 std::advance(itEnd, nDataSize);
2588 for (; it != itEnd; ++it)
2592 aSSs.push_back(mrPool.
intern(aStr));
2594 aSSs.push_back(mpPool->
intern(aStr));
2598 mrMat.
PutString(p, nDataSize, mnMatCol, nMatRow);
2604 sc::formula_block::const_iterator it = sc::formula_block::begin(*node.data);
2605 std::advance(it, nOffset);
2606 sc::formula_block::const_iterator itEnd = it;
2607 std::advance(itEnd, nDataSize);
2609 size_t nPrevRow = 0, nThisRow = node.position + nOffset;
2610 for (; it != itEnd; ++it, nPrevRow = nThisRow, ++nThisRow)
2616 if (aBucket.mnEmpValCount && nThisRow == nPrevRow + 1)
2619 ++aBucket.mnEmpValCount;
2624 aBucket.flush(mrMat, mnMatCol);
2625 aBucket.mnEmpValStart = nThisRow - mnTopRow;
2626 ++aBucket.mnEmpValCount;
2635 if (nErr != FormulaError::NONE)
2638 if (!aBucket.maNumVals.empty() && nThisRow == nPrevRow + 1)
2641 aBucket.maNumVals.push_back(fVal);
2646 aBucket.flush(mrMat, mnMatCol);
2647 aBucket.mnNumValStart = nThisRow - mnTopRow;
2648 aBucket.maNumVals.push_back(fVal);
2656 if (!aBucket.maStrVals.empty() && nThisRow == nPrevRow + 1)
2659 aBucket.maStrVals.push_back(aStr);
2664 aBucket.flush(mrMat, mnMatCol);
2665 aBucket.mnStrValStart = nThisRow - mnTopRow;
2666 aBucket.maStrVals.push_back(aStr);
2670 aBucket.flush(mrMat, mnMatCol);
2683 FillMatrixHandler aFunc(rMat, nMatCol, nRow1, &
GetDoc(), pPool);
2689template<
typename Blk>
2690void getBlockIterators(
2691 const sc::CellStoreType::iterator& it,
size_t& rLenRemain,
2692 typename Blk::iterator& rData,
typename Blk::iterator& rDataEnd )
2694 rData = Blk::begin(*it->data);
2695 if (rLenRemain >= it->size)
2698 rDataEnd = Blk::end(*it->data);
2699 rLenRemain -= it->size;
2704 std::advance(rDataEnd, rLenRemain);
2711 size_t nPos,
size_t nArrayLen,
const sc::CellStoreType::iterator& _it,
const sc::CellStoreType::iterator& itEnd )
2714 size_t nLenRemain = nArrayLen -
nPos;
2716 for (sc::CellStoreType::iterator it = _it; it != itEnd; ++it)
2722 sc::string_block::iterator itData, itDataEnd;
2723 getBlockIterators<sc::string_block>(it, nLenRemain, itData, itDataEnd);
2726 for (; itData != itDataEnd; ++itData, ++
nPos)
2732 sc::edittext_block::iterator itData, itDataEnd;
2733 getBlockIterators<sc::edittext_block>(it, nLenRemain, itData, itDataEnd);
2736 for (; itData != itDataEnd; ++itData, ++
nPos)
2745 sc::formula_block::iterator itData, itDataEnd;
2746 getBlockIterators<sc::formula_block>(it, nLenRemain, itData, itDataEnd);
2755 bool bTempDisableProgress = pProgress && pProgress->
Enabled();
2756 if (bTempDisableProgress)
2759 for (; itData != itDataEnd; ++itData, ++
nPos)
2767 if (aRes.
mnError == FormulaError::CircularReference)
2788 if (bTempDisableProgress)
2794 if (nLenRemain > it->size)
2797 nLenRemain -= it->size;
2808 sc::numeric_block::iterator itData, itDataEnd;
2809 getBlockIterators<sc::numeric_block>(it, nLenRemain, itData, itDataEnd);
2812 for (; itData != itDataEnd; ++itData, ++
nPos)
2827void copyFirstStringBlock(
2830 sc::FormulaGroupContext::StrArrayType::iterator itArray = rArray.begin();
2832 switch (itBlk->type)
2836 sc::string_block::iterator it = sc::string_block::begin(*itBlk->data);
2837 sc::string_block::iterator itEnd = it;
2838 std::advance(itEnd, nLen);
2839 for (; it != itEnd; ++it, ++itArray)
2840 *itArray = it->getData();
2845 sc::edittext_block::iterator it = sc::edittext_block::begin(*itBlk->data);
2846 sc::edittext_block::iterator itEnd = it;
2847 std::advance(itEnd, nLen);
2850 for (; it != itEnd; ++it, ++itArray)
2864copyFirstFormulaBlock(
2868 size_t nLen = std::min(itBlk->size, nArrayLen);
2870 sc::formula_block::iterator it = sc::formula_block::begin(*itBlk->data);
2871 sc::formula_block::iterator itEnd;
2877 std::advance(itEnd, nLen);
2879 for (; it != itEnd; ++it, ++
nPos)
2885 if (aRes.
mnError == FormulaError::CircularReference)
2899 std::make_unique<sc::FormulaGroupContext::NumArrayType>(nArrayLen,
2900 std::numeric_limits<double>::quiet_NaN()));
2911 std::make_unique<sc::FormulaGroupContext::StrArrayType>(nArrayLen,
nullptr));
2919 if (!pNumArray && !pStrArray)
2926struct NonNullStringFinder
2928 bool operator() (
const rtl_uString* p)
const {
return p !=
nullptr; }
2934 sc::FormulaGroupContext::StrArrayType::const_iterator it = rArray.begin();
2935 std::advance(it, nRow1);
2936 sc::FormulaGroupContext::StrArrayType::const_iterator itEnd = it;
2937 std::advance(itEnd, nRow2-nRow1+1);
2938 return std::any_of(it, itEnd, NonNullStringFinder());
2941struct ProtectFormulaGroupContext
2944 : doc(
d ) { doc->BlockFormulaGroupContextDiscard(
true ); }
2945 ~ProtectFormulaGroupContext()
2946 { doc->BlockFormulaGroupContextDiscard(
false ); }
2963 const double* pNum =
nullptr;
2967 rtl_uString** pStr =
nullptr;
2978 ProtectFormulaGroupContext protectContext(&
GetDoc());
2981 sc::CellStoreType::iterator itBlk =
maCells.begin();
2982 switch (itBlk->type)
2989 const double*
p = &sc::numeric_block::at(*itBlk->data, nRow1);
2994 sc::numeric_block::const_iterator it = sc::numeric_block::begin(*itBlk->data);
2995 sc::numeric_block::const_iterator itEnd = sc::numeric_block::end(*itBlk->data);
2997 std::make_unique<sc::FormulaGroupContext::NumArrayType>(it, itEnd));
3000 rArray.resize(nRow2+1, std::numeric_limits<double>::quiet_NaN());
3008 size_t nPos = itBlk->size;
3010 if (!appendToBlock(&rDocument, rCxt, *pColArray,
nPos, nRow2+1, itBlk,
maCells.end()))
3016 rtl_uString** pStr =
nullptr;
3027 std::make_unique<sc::FormulaGroupContext::StrArrayType>(nRow2+1,
nullptr));
3037 copyFirstStringBlock(rDocument, rArray, nRow2+1, itBlk);
3041 copyFirstStringBlock(rDocument, rArray, itBlk->size, itBlk);
3044 size_t nPos = itBlk->size;
3046 if (!appendToBlock(&rDocument, rCxt, *pColArray,
nPos, nRow2+1, itBlk,
maCells.end()))
3054 rtl_uString** pStr =
nullptr;
3055 if (hasNonEmpty(*pColArray->
mpStrArray, nRow1, nRow2))
3070 pColArray = copyFirstFormulaBlock(rCxt, itBlk, nRow2+1,
nTab,
nCol);
3075 const double* pNum =
nullptr;
3076 rtl_uString** pStr =
nullptr;
3085 pColArray = copyFirstFormulaBlock(rCxt, itBlk, nRow2+1,
nTab,
nCol);
3092 size_t nPos = itBlk->size;
3094 if (!appendToBlock(&rDocument, rCxt, *pColArray,
nPos, nRow2+1, itBlk,
maCells.end()))
3100 const double* pNum =
nullptr;
3101 rtl_uString** pStr =
nullptr;
3114 std::make_unique<sc::FormulaGroupContext::NumArrayType>(nRow2+1,
3115 std::numeric_limits<double>::quiet_NaN()));
3126 size_t nPos = itBlk->size;
3128 if (!appendToBlock(&rDocument, rCxt, *pColArray,
nPos, nRow2+1, itBlk,
maCells.end()))
3149 size_t nOffset,
size_t nDataSize )
3155 sc::formula_block::const_iterator it = sc::formula_block::begin(*node.data);
3156 std::advance(it, nOffset);
3157 sc::formula_block::const_iterator itEnd = it;
3158 std::advance(itEnd, nDataSize);
3159 for (; it != itEnd; ++it)
3170 assert(nRow2 >= nRow1);
3177 sc::CellStoreType::position_type aPos =
maCells.position(nRow);
3178 sc::CellStoreType::iterator it = aPos.first;
3186 size_t nBlockLen = it->size - aPos.second;
3187 if (nBlockLen < nLen)
3194 sc::formula_block::iterator itCell = sc::formula_block::begin(*it->data);
3195 std::advance(itCell, aPos.second);
3197 const double* pResEnd = pResults + nLen;
3198 for (; pResults != pResEnd; ++pResults, ++itCell)
3202 if (nErr != FormulaError::NONE)
3212 unsigned nThisThread,
unsigned nThreadsTotal)
3214 assert(
GetDoc().IsThreadedGroupCalcInProgress());
3216 sc::CellStoreType::position_type aPos =
maCells.position(nRow);
3217 sc::CellStoreType::iterator it = aPos.first;
3225 size_t nBlockLen = it->size - aPos.second;
3226 if (nBlockLen < nLen)
3233 sc::formula_block::iterator itCell = sc::formula_block::begin(*it->data);
3234 std::advance(itCell, aPos.second);
3236 for (
size_t i = 0;
i < nLen; ++
i, ++itCell)
3238 if (nThreadsTotal > 0 && ((
i + nOffset) % nThreadsTotal) != nThisThread)
3252 sc::CellStoreType::position_type aPos =
maCells.position(nRow);
3253 sc::CellStoreType::iterator it = aPos.first;
3261 size_t nBlockLen = it->size - aPos.second;
3262 if (nBlockLen < nLen)
3269 sc::formula_block::iterator itCell = sc::formula_block::begin(*it->data);
3270 std::advance(itCell, aPos.second);
3272 for (
size_t i = 0;
i < nLen; ++
i, ++itCell)
3292 std::pair<sc::CellStoreType::const_iterator,size_t> aPos =
maCells.position(nRow);
3293 sc::CellStoreType::const_iterator it = aPos.first;
3307 rBlockSize = it->size;
3308 return &sc::formula_block::at(*it->data, aPos.second);
3313 size_t nBlockSize = 0;
3315 return pp ? *pp :
nullptr;
3324 std::pair<sc::CellStoreType::const_iterator,size_t> aPos =
maCells.position(rRow);
3325 sc::CellStoreType::const_iterator it = aPos.first;
3339 aPos =
maCells.position(it, nNextRow);
3349 SCROW nLastRow = nNextRow;
3353 if (nNextRow == nLastRow)
3356 aPos =
maCells.position(it, nNextRow);
3359 nLastRow = nNextRow;
3368 if (pDataAreaExtras)
3377 if (pDataAreaExtras)
3380 std::pair<sc::CellStoreType::const_iterator,size_t> aPos =
maCells.position(rBlockPos.
miCellPos, nRow);
3381 if (aPos.first ==
maCells.end())
3390 if (pDataAreaExtras)
3393 std::pair<sc::CellStoreType::iterator,size_t> aPos =
maCells.position(rBlockPos.
miCellPos, nRow);
3394 if (aPos.first ==
maCells.end())
3412 if (rDataAreaExtras.
mnEndRow < nRow)
3419class FindUsedRowsHandler
3421 typedef mdds::flat_segment_tree<SCROW,bool> UsedRowsType;
3422 UsedRowsType& mrUsed;
3423 UsedRowsType::const_iterator miUsed;
3425 explicit FindUsedRowsHandler(UsedRowsType& rUsed) : mrUsed(rUsed), miUsed(rUsed.
begin()) {}
3427 void operator() (
const sc::CellStoreType::value_type& node,
size_t nOffset,
size_t nDataSize)
3432 SCROW nRow1 = node.position + nOffset;
3433 SCROW nRow2 = nRow1 + nDataSize - 1;
3434 miUsed = mrUsed.insert(miUsed, nRow1, nRow2+1,
true).first;
3442 FindUsedRowsHandler aFunc(rUsed);
3452 switch (itBlockPos->type)
3457 SvtBroadcaster* pBC = sc::broadcaster_block::at(*itBlockPos->data, nElemPos);
3466 itBlockPos = rStore.set(itBlockPos, nRow, pBC);
3470 assert(
false &&
"wrong block type encountered in the broadcaster storage.");
3478 std::pair<sc::BroadcasterStoreType::iterator,size_t> aPos =
maBroadcasters.position(nRow);
3479 startListening(
maBroadcasters, aPos.first, aPos.second, nRow, rLst);
3491 if(
GetDoc().IsDelayedDeletingBroadcasters())
3507 sc::BroadcasterStoreType::iterator& it =
p->miBroadcasterPos;
3508 std::pair<sc::BroadcasterStoreType::iterator,size_t> aPos =
maBroadcasters.position(it, rAddress.
Row());
3519 sc::BroadcasterStoreType::iterator& it =
p->miBroadcasterPos;
3520 std::pair<sc::BroadcasterStoreType::iterator,size_t> aPos =
maBroadcasters.position(it, rAddress.
Row());
3525 SvtBroadcaster* pBC = sc::broadcaster_block::at(*it->data, aPos.second);
3536class CompileDBFormulaHandler
3546 p->CompileDBFormula(mrCxt);
3550struct CompileColRowNameFormulaHandler
3558 p->CompileColRowNameFormula(mrCxt);
3566 CompileDBFormulaHandler aFunc(rCxt);
3573 CompileColRowNameFormulaHandler aFunc(rCxt);
3580class UpdateSubTotalHandler
3584 void update(
double fVal,
bool bVal)
3589 switch (
mrData.getFunc())
3603 void operator() (
size_t ,
double fVal)
3625 if (pCell->
GetErrCode() != FormulaError::NONE)
3651 if (aSpanSet.
empty())
3657 while (nRow <=
GetDoc().MaxRow())
3664 aSpanSet.
set(nRow, aRange.
mnRow2,
false);
3666 nRow = aRange.
mnRow2 + 1;
3677 for (
const auto& rSpan : aSpans)
3678 rData.
update( rSpan.mnRow2 - rSpan.mnRow1 + 1);
3684 sc::CellStoreType::const_iterator itCellPos =
maCells.begin();
3685 UpdateSubTotalHandler aFunc(rData);
3686 for (
const auto& rSpan : aSpans)
3689 itCellPos,
maCells, rSpan.mnRow1, rSpan.mnRow2, aFunc);
3696 sc::CellStoreType::const_iterator itCellPos =
maCells.begin();
3697 UpdateSubTotalHandler aFunc(rData);
3698 for (
const auto& rSpan : aSpans)
3701 itCellPos,
maCells, rSpan.mnRow1, rSpan.mnRow2, aFunc);
3709class WeightedCounter
3713 WeightedCounter() :
mnCount(0) {}
3715 void operator() (
const sc::CellStoreType::value_type& node)
3720 static sal_uLong getWeight(
const sc::CellStoreType::value_type& node)
3730 return std::accumulate(sc::formula_block::begin(*node.data), sc::formula_block::end(*node.data),
size_t(0),
3731 [](
const size_t& rCount,
const ScFormulaCell* p) { return rCount + 5 + p->GetCode()->GetCodeLen(); });
3735 return node.size * 50;
3744class WeightedCounterWithRows
3746 const SCROW mnStartRow;
3747 const SCROW mnEndRow;
3751 WeightedCounterWithRows(
SCROW nStartRow,
SCROW nEndRow)
3752 : mnStartRow(nStartRow)
3758 void operator() (
const sc::CellStoreType::value_type& node)
3760 const SCROW nRow1 = node.position;
3761 const SCROW nRow2 = nRow1 + 1;
3763 if ((nRow2 >= mnStartRow) && (nRow1 <= mnEndRow))
3765 mnCount += WeightedCounter::getWeight(node);
3776 const WeightedCounter aFunc = std::for_each(
maCells.begin(),
maCells.end(),
3778 return aFunc.getCount();
3783 const WeightedCounterWithRows aFunc = std::for_each(
maCells.begin(),
maCells.end(),
3784 WeightedCounterWithRows(nStartRow, nEndRow));
3785 return aFunc.getCount();
3798 mnCount +=
p->GetCode()->GetCodeLen();
3801 sal_uInt64 getCount()
const {
return mnCount; }
3810 return aFunc.getCount();
size_t SCSIZE
size_t typedef to be able to find places where code was changed from USHORT to size_t and is used to ...
bool ValidRow(SCROW nRow, SCROW nMaxRow)
sal_uInt16 GetValue() const
sal_Int32 GetNumerator() const
sal_Int32 GetDenominator() const
static css::uno::Reference< css::linguistic2::XHyphenator > GetHyphenator()
MapUnit GetMapUnit() const
const vcl::Font & GetFont() const
void SetFont(const vcl::Font &rNewFont)
SAL_WARN_UNUSED_RESULT Point PixelToLogic(const Point &rDevicePt) const
tools::Long GetTextWidth(const OUString &rStr, sal_Int32 nIndex=0, sal_Int32 nLen=-1, vcl::text::TextLayoutCache const *=nullptr, SalLayoutGlyphs const *const pLayoutCache=nullptr) const
SAL_WARN_UNUSED_RESULT Point LogicToPixel(const Point &rLogicPt) const
const MapMode & GetMapMode() const
tools::Long GetTextHeight() const
OutDevType GetOutDevType() const
const ScPatternAttr * Next(SCROW &rTop, SCROW &rBottom)
const ScPatternAttr * Resync(SCROW nRow, SCROW &rTop, SCROW &rBottom)
std::unique_ptr< ScAttrArray > pAttrArray
bool HasAttrib(SCROW nRow1, SCROW nRow2, HasAttrFlags nMask) const
void DeleteCellNotes(sc::ColumnBlockPosition &rBlockPos, SCROW nRow1, SCROW nRow2, bool bForgetCaptionOwnership)
void DeleteBroadcasters(sc::ColumnBlockPosition &rBlockPos, SCROW nRow1, SCROW nRow2)
void CreateSparklineCell(SCROW nRow, std::shared_ptr< sc::Sparkline > const &pSparkline)
SCROW GetFirstDataPos() const
void CellStorageModified()
Called whenever the state of cell array gets modified i.e.
void CopyCellTextAttrsToDocument(SCROW nRow1, SCROW nRow2, ScColumn &rDestCol) const
void UpdateSelectionFunction(const ScRangeList &rRanges, ScFunctionData &rData, const ScFlatBoolRowSegments &rHiddenRows)
bool IsNotesEmptyBlock(SCROW nStartRow, SCROW nEndRow) const
sc::CellTextAttrStoreType maCellTextAttrs
const ScPatternAttr * GetPattern(SCROW nRow) const
void DuplicateNotes(SCROW nStartRow, size_t nDataSize, ScColumn &rDestCol, sc::ColumnBlockPosition &rDestBlockPos, bool bCloneCaption, SCROW nRowOffsetDest=0) const
bool HasVisibleDataAt(SCROW nRow) const
bool mbEmptyBroadcastersPending
void RegroupFormulaCells(std::vector< ScAddress > *pGroupPos=nullptr)
Regroup formula cells for the entire column.
SCROW FindNextVisibleRowWithContent(sc::CellStoreType::const_iterator &itPos, SCROW nRow, bool bForward) const
ScPostIt * GetCellNote(SCROW nRow)
bool TestTabRefAbs(SCTAB nTable) const
void CompileColRowNameFormula(sc::CompileFormulaContext &rCxt)
SCROW GetSparklinesMinRow() const
SCSIZE VisibleCount(SCROW nStartRow, SCROW nEndRow) const
void DumpColumnStorage() const
void CopyCellSparklinesToDocument(SCROW nRow1, SCROW nRow2, ScColumn &rDestCol, SCROW nRowOffsetDest=0) const
SvtScriptType GetRangeScriptType(sc::CellTextAttrStoreType::iterator &itPos, SCROW nRow1, SCROW nRow2, const sc::CellStoreType::iterator &itr)
Get combined script types of the specified range.
void DuplicateSparklines(SCROW nStartRow, size_t nDataSize, ScColumn &rDestCol, sc::ColumnBlockPosition &rDestBlockPos, SCROW nRowOffsetDest=0) const
void RemoveEditAttribs(sc::ColumnBlockPosition &rBlockPos, SCROW nStartRow, SCROW nEndRow)
sc::CellNoteStoreType maCellNotes
SvtScriptType GetScriptType(SCROW nRow) const
void EndListening(SvtListener &rLst, SCROW nRow)
void FindDataAreaPos(SCROW &rRow, bool bDown) const
bool TrimEmptyBlocks(SCROW &rRowStart, SCROW &rRowEnd) const
void CellNotesDeleting(SCROW nRow1, SCROW nRow2, bool bForgetCaptionOwnership)
void SetNumberFormat(SCROW nRow, sal_uInt32 nNumberFormat)
void AssertNoInterpretNeeded(SCROW nRow1, SCROW nRow2)
void ApplyAttr(SCROW nRow, const SfxPoolItem &rAttr)
void GetOptimalHeight(sc::RowHeightContext &rCxt, SCROW nStartRow, SCROW nEndRow, sal_uInt16 nMinHeight, SCROW nMinStart)
bool HasEditCells(SCROW nStartRow, SCROW nEndRow, SCROW &rFirst)
sal_uInt64 GetWeightedCount() const
void SetFormulaResults(SCROW nRow, const double *pResults, size_t nLen)
void GetDataExtrasAt(SCROW nRow, ScDataAreaExtras &rDataAreaExtras) const
void CompileDBFormula(sc::CompileFormulaContext &rCxt)
tools::Long GetNeededSize(SCROW nRow, OutputDevice *pDev, double nPPTX, double nPPTY, const Fraction &rZoomX, const Fraction &rZoomY, bool bWidth, const ScNeededSizeOptions &rOptions, const ScPatternAttr **pPatternChange, bool bInPrintTwips=false) const
bool HasCellNotes() const
SCROW GetCellNotesMaxRow() const
bool HasSparklines() const
SCROW FindNextVisibleRow(SCROW nRow, bool bForward) const
void CalculateInThread(ScInterpreterContext &rContext, SCROW nRow, size_t nLen, size_t nOffset, unsigned nThisThread, unsigned nThreadsTotal)
bool GetNextDataPos(SCROW &rRow) const
sc::CellStoreType maCells
ScRefCellValue GetCellValue(SCROW nRow) const
formula::VectorRefArray FetchVectorRefArray(SCROW nRow1, SCROW nRow2)
bool UpdateScriptType(sc::CellTextAttr &rAttr, SCROW nRow, sc::CellStoreType::iterator &itr)
bool DeleteSparkline(SCROW nRow)
sal_uInt16 GetOptimalColWidth(OutputDevice *pDev, double nPPTX, double nPPTY, const Fraction &rZoomX, const Fraction &rZoomY, bool bFormula, sal_uInt16 nOldWidth, const ScMarkData *pMarkData, const ScColWidthParam *pParam) const
void CopyCellNotesToDocument(SCROW nRow1, SCROW nRow2, ScColumn &rDestCol, bool bCloneCaption=true, SCROW nRowOffsetDest=0) const
void FillMatrix(ScMatrix &rMat, size_t nMatCol, SCROW nRow1, SCROW nRow2, svl::SharedStringPool *pPool) const
bool IsDrawObjectsEmptyBlock(SCROW nStartRow, SCROW nEndRow) const
void SetCellNote(SCROW nRow, std::unique_ptr< ScPostIt > pNote)
bool GetNextSpellingCell(SCROW &nRow, bool bInSel, const ScMarkData &rData) const
sal_uInt64 GetCodeCount() const
void PrepareBroadcastersForDestruction()
SCROW GetCellNotesMinRow() const
void DeleteEmptyBroadcasters()
void FindUsed(SCROW nStartRow, SCROW nEndRow, mdds::flat_segment_tree< SCROW, bool > &rUsed) const
void DeleteSparklineCells(sc::ColumnBlockPosition &rBlockPos, SCROW nRow1, SCROW nRow2)
bool GetPrevDataPos(SCROW &rRow) const
bool HasVisibleAttrIn(SCROW nStartRow, SCROW nEndRow) const
sc::SparklineCell * GetSparklineCell(SCROW nRow)
formula::FormulaTokenRef ResolveStaticReference(SCROW nRow)
sc::BroadcasterStoreType maBroadcasters
SCROW GetLastDataPos() const
const ScFormulaCell * FetchFormulaCell(SCROW nRow) const
void SetScriptType(SCROW nRow, SvtScriptType nType)
SCROW GetSparklinesMaxRow() const
ScDocument & GetDoc() const
void HandleStuffAfterParallelCalculation(SCROW nRow, size_t nLen, ScInterpreter *pInterpreter)
ScFormulaCell *const * GetFormulaCellBlockAddress(SCROW nRow, size_t &rBlockSize) const
SvtBroadcaster * GetBroadcaster(SCROW nRow)
sc::SparklineStoreType maSparklines
bool HasDataAt(SCROW nRow, ScDataAreaExtras *pDataAreaExtras=nullptr) const
void SetTextWidth(SCROW nRow, sal_uInt16 nWidth)
bool IsSparklinesEmptyBlock(SCROW nStartRow, SCROW nEndRow) const
void StartListening(SvtListener &rLst, SCROW nRow)
sal_uInt16 GetTextWidth(SCROW nRow) const
SCSIZE GetEmptyLinesInBlock(SCROW nStartRow, SCROW nEndRow, ScDirection eDir) const
void SetValue(A nPos, const D &rValue)
const D & GetValue(A nPos) const
static void LOKCommentNotify(LOKCommentNotificationType nType, const ScDocument *pDocument, const ScAddress &rPos, const ScPostIt *pNote)
SC_DLLPUBLIC sal_uInt16 GetRowHeight(SCROW nRow, SCTAB nTab, bool bHiddenAsZero=true) const
SC_DLLPUBLIC sal_uInt16 GetColWidth(SCCOL nCol, SCTAB nTab, bool bHiddenAsZero=true) const
SC_DLLPUBLIC ScPatternAttr * GetDefPattern() const
bool ValidRow(SCROW nRow) const
SC_DLLPUBLIC bool IsTabProtected(SCTAB nTab) const
void DiscardFormulaGroupContext()
SC_DLLPUBLIC SCROW MaxRow() const
std::shared_ptr< sc::FormulaGroupContext > & GetFormulaGroupContext()
SC_DLLPUBLIC SfxItemPool * GetEditPool() const
std::unique_ptr< ScFieldEditEngine > CreateFieldEditEngine()
SC_DLLPUBLIC ScDrawLayer * GetDrawLayer()
SC_DLLPUBLIC bool RowHidden(SCROW nRow, SCTAB nTab, SCROW *pFirstRow=nullptr, SCROW *pLastRow=nullptr) const
SC_DLLPUBLIC CRFlags GetRowFlags(SCROW nRow, SCTAB nTab) const
SC_DLLPUBLIC std::shared_ptr< sc::SparklineGroup > SearchSparklineGroup(tools::Guid const &rGuid)
void DisposeFieldEditEngine(std::unique_ptr< ScFieldEditEngine > &rpEditEngine)
SC_DLLPUBLIC formula::FormulaGrammar::Grammar GetGrammar() const
SC_DLLPUBLIC svl::SharedStringPool & GetSharedStringPool()
void ApplyAsianEditSettings(ScEditEngineDefaulter &rEngine)
SC_DLLPUBLIC SvtScriptType GetScriptType(SCCOL nCol, SCROW nRow, SCTAB nTab, const ScRefCellValue *pCell=nullptr)
SC_DLLPUBLIC sc::SparklineList * GetSparklineList(SCTAB nTab)
SfxItemSet * GetPreviewFont()
SC_DLLPUBLIC SvNumberFormatter * GetFormatTable() const
SC_DLLPUBLIC sal_uInt16 GetOriginalWidth(SCCOL nCol, SCTAB nTab) const
ScStyleSheet * GetPreviewCellStyle()
SC_DLLPUBLIC const SfxItemSet * GetCondResult(SCCOL nCol, SCROW nRow, SCTAB nTab, ScRefCellValue *pCell=nullptr) const
static OUString GetSpaceDelimitedString(const EditEngine &rEngine)
Retrieves string with paragraphs delimited by spaces.
static SC_DLLPUBLIC OUString GetString(const EditTextObject &rEditText, const ScDocument *pDoc)
Retrieves string with paragraphs delimited by new lines (' ').
bool getRangeData(SCROW nRow, RangeData &rData) const
To calculate a single subtotal function.
ScSubTotalFunc getFunc() const
void update(double fNewVal)
static SC_DLLPUBLIC sal_uInt16 nStdRowHeight
static SC_DLLPUBLIC SvtScriptType GetDefaultScriptType()
todo: It should be possible to have MarkArrays for each table, in order to enable "search all" across...
SCROW GetNextMarked(SCCOL nCol, SCROW nRow, bool bUp) const
May return -1.
bool IsMultiMarked() const
Matrix data type that can store values of mixed types.
void PutString(const svl::SharedString &rStr, SCSIZE nC, SCSIZE nR)
void PutEmptyResultVector(SCSIZE nCount, SCSIZE nC, SCSIZE nR)
Put a column vector of empty results, starting at row nR, must fit into dimensions.
void PutDouble(double fVal, SCSIZE nC, SCSIZE nR)
SCCOL GetColMerge() const
SCROW GetRowMerge() const
bool HasAutoFilter() const
bool IsHorOverlapped() const
bool IsOverlapped() const
bool IsVerOverlapped() const
void SetStyleSheet(ScStyleSheet *pNewStyle, bool bClearDirectFormat=true)
sal_uInt32 GetNumberFormat(SvNumberFormatter *) const
ScRotateDir GetRotateDir(const SfxItemSet *pCondSet) const
static void GetFont(vcl::Font &rFont, const SfxItemSet &rItemSet, ScAutoFontColorMode eAutoMode, const OutputDevice *pOutDev=nullptr, const Fraction *pScale=nullptr, const SfxItemSet *pCondSet=nullptr, SvtScriptType nScript=SvtScriptType::NONE, const Color *pBackConfigColor=nullptr, const Color *pTextConfigColor=nullptr)
Static helper function to fill a font object from the passed item set.
const SfxPoolItem & GetItem(sal_uInt16 nWhichP) const
void FillEditItemSet(SfxItemSet *pEditSet, const SfxItemSet *pCondSet=nullptr) const
Converts all Calc items contained in the own item set to edit engine items and puts them into pEditSe...
static SvxCellOrientation GetCellOrientation(const SfxItemSet &rItemSet, const SfxItemSet *pCondSet)
Additional class containing cell annotation data.
static ScProgress * GetInterpretProgress()
OUString CreateString(sc::TokenStringContext &rCxt, const ScAddress &rPos) const
Create a string representation of formula token array without modifying the internal state of the tok...
Degree100 GetValue() const
const WhichRangesContainer & GetRanges() const
SfxItemPool * GetPool() const
const T * GetItemIfSet(TypedWhichId< T > nWhich, bool bSrchInParent=true) const
const SfxPoolItem & Get(sal_uInt16 nWhich, bool bSrchInParent=true) const
constexpr tools::Long Height() const
void setWidth(tools::Long nWidth)
void setHeight(tools::Long nHeight)
constexpr tools::Long Width() const
bool HasListeners() const
bool StartListening(SvtBroadcaster &rBroadcaster)
void EndListening(SvtBroadcaster &rBroadcaster)
sal_uInt32 GetHeight() const
sal_Int16 GetRightMargin() const
sal_Int16 GetTopMargin() const
sal_Int16 GetBottomMargin() const
sal_Int16 GetLeftMargin() const
void addEmptyBroadcasterPosition(SCTAB nTab, SCCOL nCol, SCROW nRow)
ColumnBlockPosition * getBlockPosition(SCTAB nTab, SCCOL nCol)
RowHeightsArray & getHeightArray()
const Fraction & getZoomX() const
OutputDevice * getOutputDevice()
const Fraction & getZoomY() const
bool isForceAutoSize() const
Keep track of spans in a single column only.
void scan(const ScColumn &rColumn)
Scan an entire column and tag all non-empty cell positions.
std::vector< RowSpan > SpansType
void getSpans(SpansType &rSpans) const
bool empty() const
Whether there isn't any row tagged.
void set(SCROW nRow1, SCROW nRow2, bool bVal)
Holder of a sparkline, that is connected to a cell specific.
std::shared_ptr< Sparkline > const & getSparkline() const
std::shared_ptr< SparklineGroup > const & getSparklineGroup() const
void removeSparkline(std::shared_ptr< Sparkline > const &pSparkline)
void addSparkline(std::shared_ptr< Sparkline > const &pSparkline)
ColumnBlockPosition * getBlockPosition(SCTAB nTab, SCCOL nCol)
SharedString intern(const OUString &rStr)
const OUString & getString() const
sal_Int32 getLength() const
const Size & GetFontSize() const
static void assertNoInterpretNeededHelper(const sc::CellStoreType::value_type &node, size_t nOffset, size_t nDataSize)
static sal_uInt16 lcl_GetAttribHeight(const ScPatternAttr &rPattern, sal_uInt16 nFontHeightId)
#define SC_ROT_BREAK_FACTOR
static bool IsAmbiguousScript(SvtScriptType nScript)
constexpr TypedWhichId< SfxBoolItem > EE_PARA_HYPHENATE(EE_PARA_START+6)
double CreateDoubleError(FormulaError nErr)
FormulaError GetDoubleErrorValue(double fVal)
@ SUBTOTAL_FUNC_SELECTION_COUNT
#define STD_ROWHEIGHT_DIFF
constexpr std::enable_if_t< std::is_signed_v< T >, std::make_unsigned_t< T > > make_unsigned(T value)
constexpr auto toTwips(N number, Length from)
constexpr Point convert(const Point &rPoint, o3tl::Length eFrom, o3tl::Length eTo)
enumrange< T >::Iterator begin(enumrange< T >)
CellStoreType::const_iterator ParseAllNonEmpty(const typename CellStoreType::const_iterator &itPos, const CellStoreType &rCells, SCROW nRow1, SCROW nRow2, Func &rFunc)
SparklineStoreType::const_iterator ParseSparkline(const SparklineStoreType::const_iterator &itPos, const SparklineStoreType &rStore, SCROW nStart, SCROW nEnd, Functor &rFunctor)
CellNoteStoreType::const_iterator ParseNote(const CellNoteStoreType::const_iterator &itPos, const CellNoteStoreType &rStore, SCROW nStart, SCROW nEnd, Func &rFunc)
StoreT::const_iterator ParseBlock(const typename StoreT::const_iterator &itPos, const StoreT &rStore, Func &rFunc, typename StoreT::size_type nStart, typename StoreT::size_type nEnd)
Generic algorithm to parse blocks of multi_type_vector either partially or fully.
const mdds::mtv::element_t element_type_celltextattr
const mdds::mtv::element_t element_type_edittext
CellStoreType::iterator ProcessFormula(const CellStoreType::iterator &it, CellStoreType &rStore, SCROW nRow1, SCROW nRow2, std::function< void(size_t, ScFormulaCell *)> aFuncElem)
Process formula cells found within specified row range.
mdds::mtv::soa::multi_type_vector< CellNodeTraits > CellNoteStoreType
Cell note container.
mdds::mtv::soa::multi_type_vector< SparklineTraits > SparklineStoreType
Sparkline container.
const mdds::mtv::element_t element_type_formula
void ParseFormula(const CellStoreType &rStore, Func &rFunc)
mdds::mtv::soa::multi_type_vector< CellStoreTraits > CellStoreType
Cell container.
const mdds::mtv::element_t element_type_sparkline
const mdds::mtv::element_t element_type_numeric
Mapped standard element types (for convenience).
CellStoreType::const_iterator ParseFormulaNumeric(const CellStoreType::const_iterator &itPos, const CellStoreType &rCells, SCROW nRow1, SCROW nRow2, Func &rFunc)
CellStoreType::iterator ProcessEditText(const CellStoreType::iterator &itPos, CellStoreType &rStore, SCROW nRow1, SCROW nRow2, Func &rFunc)
mdds::mtv::soa::multi_type_vector< BroadcasterTraits > BroadcasterStoreType
Broadcaster storage container.
const mdds::mtv::element_t element_type_string
const mdds::mtv::element_t element_type_cellnote
const mdds::mtv::element_t element_type_empty
const mdds::mtv::element_t element_type_broadcaster
Custom element type IDs for multi_type_vector.
@ SC_AUTOCOL_BLACK
always use black
const sc::CellStoreType & mrCells
constexpr TypedWhichId< ScIndentItem > ATTR_INDENT(131)
constexpr TypedWhichId< SvxFontHeightItem > ATTR_FONT_HEIGHT(101)
constexpr TypedWhichId< SfxBoolItem > ATTR_VERTICAL_ASIAN(137)
constexpr TypedWhichId< ScMergeFlagAttr > ATTR_MERGE_FLAG(145)
constexpr TypedWhichId< SvxFontHeightItem > ATTR_CJK_FONT_HEIGHT(112)
constexpr TypedWhichId< SvxEmphasisMarkItem > ATTR_FONT_EMPHASISMARK(121)
constexpr TypedWhichId< ScMergeAttr > ATTR_MERGE(144)
constexpr TypedWhichId< ScRotateValueItem > ATTR_ROTATE_VALUE(135)
constexpr TypedWhichId< SvxHorJustifyItem > ATTR_HOR_JUSTIFY(129)
constexpr TypedWhichId< SvxRotateModeItem > ATTR_ROTATE_MODE(136)
constexpr TypedWhichId< SfxUInt32Item > ATTR_VALUE_FORMAT(146)
constexpr TypedWhichId< SvxMarginItem > ATTR_MARGIN(143)
constexpr TypedWhichId< ScLineBreakCell > ATTR_LINEBREAK(139)
constexpr TypedWhichId< SvxFontHeightItem > ATTR_CTL_FONT_HEIGHT(117)
constexpr TypedWhichId< ScCondFormatItem > ATTR_CONDITIONAL(154)
TOOLS_DLLPUBLIC SvStream & endl(SvStream &rStr)
const ScPatternAttr * pPattern
This is very similar to ScCellValue, except that it references the original value instead of copying ...
ScFormulaCell * getFormula() const
const EditTextObject * getEditText() const
SvtScriptType mnScriptType
CellNoteStoreType::const_iterator miCellNotePos
CellStoreType::const_iterator miCellPos
Store position data for column array storage.
SparklineStoreType::iterator miSparklinePos
BroadcasterStoreType::iterator miBroadcasterPos
CellStoreType::iterator miCellPos
CellNoteStoreType::iterator miCellNotePos
StrArrayType * mpStrArray
NumArrayType * mpNumArray
std::vector< rtl_uString * > StrArrayType
std::vector< double, DoubleAllocType > NumArrayType
StrArrayStoreType m_StrArrays
manage life cycle of numeric arrays.
void ensureNumArray(ColArray &rColArray, size_t nArrayLen)
void discardCachedColArray(SCTAB nTab, SCCOL nCol)
ColArray * setCachedColArray(SCTAB nTab, SCCOL nCol, NumArrayType *pNumArray, StrArrayType *pStrArray)
ColArray * getCachedColArray(SCTAB nTab, SCCOL nCol, size_t nSize)
keep track of longest array for each column.
NumArrayStoreType m_NumArrays
void ensureStrArray(ColArray &rColArray, size_t nArrayLen)
Context for creating string from an array of formula tokens, used in ScTokenArray::CreateString().
#define SV_COUNTRY_LANGUAGE_OFFSET