23 #include <document.hxx>
28 #include <compiler.hxx>
33 #include <tokenarray.hxx>
55 #include <osl/diagnose.h>
61 using ::editeng::SvxBorderLine;
69 return ( nScript != SvtScriptType::LATIN &&
70 nScript != SvtScriptType::ASIAN &&
71 nScript != SvtScriptType::COMPLEX &&
72 nScript != SvtScriptType::NONE );
78 pPattern(nullptr), bFormula(
false), bSkipMerged(true), bGetFont(true), bTotalSize(
false)
83 maCellTextAttrs(rSheetLimits.GetMaxRowCount()),
84 maCellNotes(rSheetLimits.GetMaxRowCount()),
85 maBroadcasters(rSheetLimits.GetMaxRowCount()),
86 maCells(
sc::CellStoreEvent(this)),
87 maSparklines(rSheetLimits.GetMaxRowCount()),
92 mbEmptyBroadcastersPending(
false )
106 if ( bEmptyAttrArray )
113 bool bNoMatrixAtAll )
const
118 return MatrixEdge::Nothing;
124 std::pair<sc::CellStoreType::const_iterator,size_t> aPos =
maCells.position(nRow1);
126 return MatrixEdge::Nothing;
128 const ScFormulaCell* pCell = sc::formula_block::at(*aPos.first->data, aPos.second);
130 return MatrixEdge::Nothing;
138 std::pair<sc::CellStoreType::const_iterator,size_t> aPos =
maCells.position(nRow1);
139 sc::CellStoreType::const_iterator it = aPos.first;
140 size_t nOffset = aPos.second;
142 for (;it !=
maCells.end() && nRow <= nRow2; ++it, nOffset = 0)
147 nRow += it->size - nOffset;
151 size_t nRowsToRead = nRow2 - nRow + 1;
152 size_t nEnd = std::min(it->size, nOffset+nRowsToRead);
153 sc::formula_block::const_iterator itCell = sc::formula_block::begin(*it->data);
154 std::advance(itCell, nOffset);
155 for (
size_t i = nOffset;
i < nEnd; ++itCell, ++
i)
163 if (nEdges == MatrixEdge::Nothing)
169 return MatrixEdge::Inside;
171 if (nEdges & MatrixEdge::Top)
174 return nEdges | MatrixEdge::Open;
175 else if (nEdges & MatrixEdge::Inside)
178 ((nMask & MatrixEdge::Left) && (nEdges & MatrixEdge::Right) && !(nEdges & MatrixEdge::Left)))
181 if (nEdges & MatrixEdge::Bottom)
185 nRow += nEnd - nOffset;
188 nEdges |= MatrixEdge::Open;
205 for (
size_t i = 0,
n = aRanges.
size();
i <
n; ++
i)
216 std::pair<sc::CellStoreType::const_iterator,size_t> aPos =
maCells.position(nRow);
217 sc::CellStoreType::const_iterator it = aPos.first;
218 size_t nOffset = aPos.second;
220 for (;it !=
maCells.end() && nRow <= nBottom; ++it, nOffset = 0)
225 nRow += it->size - nOffset;
230 size_t nRowsToRead = nBottom - nRow + 1;
231 size_t nEnd = std::min(it->size, nRowsToRead);
232 sc::formula_block::const_iterator itCell = sc::formula_block::begin(*it->data);
233 std::advance(itCell, nOffset);
234 for (
size_t j = nOffset; j < nEnd; ++itCell, ++j)
243 if (nEdges == MatrixEdge::Nothing)
248 if (nEdges & MatrixEdge::Top)
252 else if (nEdges & MatrixEdge::Inside)
259 if (nEdges & MatrixEdge::Bottom)
270 if (aCurOrigin != aOrigin)
272 aCurOrigin = aOrigin;
311 while (aMultiIter.Next( nTop, nBottom ) && !bFound)
313 if (
pAttrArray->HasAttrib( nTop, nBottom, nMask ))
332 while (aMultiIter.
Next( nTop, nBottom ))
333 pAttrArray->MergePatternArea( nTop, nBottom, rState, bDeep );
340 ::std::map< const ScPatternAttr*, size_t > aAttrMap;
342 size_t nMaxCount = 0;
346 SCROW nAttrRow1 = 0, nAttrRow2 = 0;
348 while( (pPattern = aAttrIter.Next( nAttrRow1, nAttrRow2 )) !=
nullptr )
350 size_t& rnCount = aAttrMap[ pPattern ];
351 rnCount += (nAttrRow2 - nAttrRow1 + 1);
352 if( rnCount > nMaxCount )
354 pMaxPattern = pPattern;
364 SCROW nPatStartRow, nPatEndRow;
367 while (nEndRow > nPatEndRow)
369 nStartRow = nPatEndRow + 1;
370 pPattern =
pAttrArray->GetPatternRange(nPatStartRow, nPatEndRow, nStartRow);
372 if (nFormat != nTmpFormat)
379 bool*
const pIsChanged )
394 while (aMultiIter.Next( nTop, nBottom ))
396 pAttrArray->ApplyCacheArea( nTop, nBottom, pCache, pDataArray, pIsChanged );
403 else if (nTop==0 && nBottom==
GetDoc().MaxRow())
417 while (aMultiIter.Next( nTop, nBottom ))
418 pAttrArray->ChangeIndent(nTop, nBottom, bIncrement);
437 while (aMultiIter.Next( nTop, nBottom ))
438 pAttrArray->ClearItems(nTop, nBottom, pWhich);
463 while (aMultiIter.Next( nTop, nBottom ))
464 DeleteArea(nTop, nBottom, nDelFlag, bBroadcast);
479 if (pNewPattern != pPattern)
488 pAttrArray->ApplyCacheArea( nStartRow, nEndRow, &aCache, pDataArray, pIsChanged );
502 nRow1, nRow2, nRow );
509 SCROW nNewRow1 = std::max( nRow1, nRow );
510 SCROW nNewRow2 = std::min( nRow2, nEndRow );
511 pAttrArray->ApplyCacheArea( nNewRow1, nNewRow2, &aCache );
520 std::unique_ptr<ScPatternAttr> pNewPattern(
new ScPatternAttr(*pPattern));
521 pNewPattern->SetStyleSheet(const_cast<ScStyleSheet*>(rStyle));
522 pAttrArray->SetPattern(nRow, std::move(pNewPattern),
true);
533 while (aMultiIter.Next( nTop, nBottom ))
534 pAttrArray->ApplyStyleArea(nTop, nBottom, rStyle);
539 const SvxBorderLine* pLine,
bool bColorOnly )
541 if ( bColorOnly && !pLine )
550 while (aMultiIter.Next( nTop, nBottom ))
551 pAttrArray->ApplyLineStyleArea(nTop, nBottom, pLine, bColorOnly );
560 OSL_FAIL(
"No selection in ScColumn::GetSelectionStyle");
573 while (bEqual && aMultiIter.Next( nTop, nBottom ))
580 const ScPatternAttr* pPattern = aAttrIter.Next( nRow, nDummy );
585 if ( !pNewStyle || ( pStyle && pNewStyle != pStyle ) )
591 return bEqual ? pStyle :
nullptr;
608 const ScPatternAttr* pPattern = aAttrIter.Next( nRow, nDummy );
613 if ( !pNewStyle || ( pStyle && pNewStyle != pStyle ) )
618 return bEqual ? pStyle :
nullptr;
633 if ( pNewPattern != pOldPattern )
636 pDocPool->
Remove( *pNewPattern );
641 std::pair<sc::CellStoreType::const_iterator,size_t> aPos =
maCells.position(nRow);
642 if (aPos.first ==
maCells.end())
650 std::pair<sc::CellStoreType::iterator,size_t> aPos =
maCells.position(rBlockPos.
miCellPos, nRow);
651 if (aPos.first ==
maCells.end())
660 std::pair<sc::CellStoreType::const_iterator,size_t> aPos =
maCells.position(rBlockPos.
miCellPos, nRow);
661 if (aPos.first ==
maCells.end())
675 aVal.
mfValue = sc::numeric_block::at(*itPos->data, nOffset);
680 aVal.
mpString = &sc::string_block::at(*itPos->data, nOffset);
685 aVal.
mpEditText = sc::edittext_block::at(*itPos->data, nOffset);
690 aVal.
mpFormula = sc::formula_block::at(*itPos->data, nOffset);
718 return &sc::celltextattr_block::at(*aPos.first->data, aPos.second);
727 std::pair<sc::CellStoreType::const_iterator,size_t> aPos =
maCells.position(nStartRow);
728 sc::CellStoreType::const_iterator it = aPos.first;
733 size_t nLen = it->size - aPos.second;
734 SCROW nNextNonEmptyRow = nStartRow + nLen;
735 if (nNextNonEmptyRow <= nEndRow)
747 std::pair<sc::CellStoreType::const_iterator,size_t> aPos =
maCells.position(nStartRow);
748 sc::CellStoreType::const_iterator it = aPos.first;
758 sc::CellStoreType::const_reverse_iterator it =
maCells.rbegin();
760 nLastNonEmptyRow -= it->size;
789 maCells.insert_empty(nStartRow, nSize);
800 class CopyToClipHandler
808 void setDefaultAttrsToDest(
size_t nRow,
size_t nSize)
810 std::vector<sc::CellTextAttr> aAttrs(nSize);
817 mrSrcDoc(rSrcDoc), mrSrcCol(rSrcCol), mrDestCol(rDestCol), mpDestPos(pDestPos)
820 maDestPos = *mpDestPos;
828 *mpDestPos = maDestPos;
831 void operator() (
const sc::CellStoreType::value_type& aNode,
size_t nOffset,
size_t nDataSize)
833 size_t nTopRow = aNode.position + nOffset;
841 sc::numeric_block::const_iterator it = sc::numeric_block::begin(*aNode.data);
842 std::advance(it, nOffset);
843 sc::numeric_block::const_iterator itEnd = it;
844 std::advance(itEnd, nDataSize);
850 sc::string_block::const_iterator it = sc::string_block::begin(*aNode.data);
851 std::advance(it, nOffset);
852 sc::string_block::const_iterator itEnd = it;
853 std::advance(itEnd, nDataSize);
860 sc::edittext_block::const_iterator it = sc::edittext_block::begin(*aNode.data);
861 std::advance(it, nOffset);
862 sc::edittext_block::const_iterator itEnd = it;
863 std::advance(itEnd, nDataSize);
865 std::vector<EditTextObject*> aCloned;
866 aCloned.reserve(nDataSize);
867 for (; it != itEnd; ++it)
871 maDestPos.
miCellPos, nTopRow, aCloned.begin(), aCloned.end());
876 sc::formula_block::const_iterator it = sc::formula_block::begin(*aNode.data);
877 std::advance(it, nOffset);
878 sc::formula_block::const_iterator itEnd = it;
879 std::advance(itEnd, nDataSize);
881 std::vector<ScFormulaCell*> aCloned;
882 aCloned.reserve(nDataSize);
884 for (; it != itEnd; ++it, aDestPos.IncRow())
888 const_cast<ScFormulaCell&>(rOld).
Interpret();
894 if (!aCloned.empty())
899 maDestPos.
miCellPos, nTopRow, aCloned.begin(), aCloned.end());
902 sc::CellStoreType::position_type aPos =
903 rDestCells.position(maDestPos.
miCellPos, nTopRow);
906 size_t nLastRow = nTopRow + nDataSize;
909 aPos = rDestCells.position(maDestPos.
miCellPos, nLastRow+1);
919 setDefaultAttrsToDest(nTopRow, nDataSize);
921 mrSrcCol.
DuplicateNotes(nTopRow, nDataSize, mrDestCol, maDestPos,
false);
926 class CopyTextAttrToClipHandler
929 sc::CellTextAttrStoreType::iterator miPos;
933 mrDestAttrs(rAttrs), miPos(mrDestAttrs.
begin()) {}
935 void operator() (
const sc::CellTextAttrStoreType::value_type& aNode,
size_t nOffset,
size_t nDataSize )
940 sc::celltextattr_block::const_iterator it = sc::celltextattr_block::begin(*aNode.data);
941 std::advance(it, nOffset);
942 sc::celltextattr_block::const_iterator itEnd = it;
943 std::advance(itEnd, nDataSize);
945 size_t nPos = aNode.position + nOffset;
946 miPos = mrDestAttrs.set(miPos, nPos, it, itEnd);
983 rDestCol.
maCells.set_empty(nRow1, nRow2);
988 std::pair<sc::CellStoreType::const_iterator,size_t> aPos =
maCells.position(nRow1);
989 sc::CellStoreType::const_iterator it = aPos.first;
990 size_t nOffset = aPos.second;
991 size_t nDataSize = 0;
992 size_t nCurRow = nRow1;
996 bool bLastBlock =
false;
997 nDataSize = it->size - nOffset;
1001 nDataSize = nRow2 - nCurRow + 1;
1009 sc::numeric_block::const_iterator itData = sc::numeric_block::begin(*it->data);
1010 std::advance(itData, nOffset);
1011 sc::numeric_block::const_iterator itDataEnd = itData;
1012 std::advance(itDataEnd, nDataSize);
1018 sc::string_block::const_iterator itData = sc::string_block::begin(*it->data);
1019 std::advance(itData, nOffset);
1020 sc::string_block::const_iterator itDataEnd = itData;
1021 std::advance(itDataEnd, nDataSize);
1027 sc::edittext_block::const_iterator itData = sc::edittext_block::begin(*it->data);
1028 std::advance(itData, nOffset);
1029 sc::edittext_block::const_iterator itDataEnd = itData;
1030 std::advance(itDataEnd, nDataSize);
1033 std::vector<svl::SharedString> aConverted;
1034 aConverted.reserve(nDataSize);
1035 for (; itData != itDataEnd; ++itData)
1039 aConverted.push_back(aSS);
1046 sc::formula_block::const_iterator itData = sc::formula_block::begin(*it->data);
1047 std::advance(itData, nOffset);
1048 sc::formula_block::const_iterator itDataEnd = itData;
1049 std::advance(itDataEnd, nDataSize);
1052 for (
SCROW i = 0; itData != itDataEnd; ++itData, ++
i)
1054 SCROW nRow = nCurRow +
i;
1084 for (
SCROW nRow = nRow1; nRow <= nRow2; ++nRow)
1087 SvNumberFormatterMergeMap::const_iterator itNum = rMap.find(nNumFmt);
1088 if (itNum != rMap.end())
1089 nNumFmt = itNum->second;
1100 std::pair<sc::CellStoreType::const_iterator,size_t> aPos =
maCells.position(nSrcRow);
1101 sc::CellStoreType::const_iterator it = aPos.first;
1106 rDestCol.
maCells.set(nDestRow, sc::numeric_block::at(*it->data, aPos.second));
1109 rDestCol.
maCells.set(nDestRow, sc::string_block::at(*it->data, aPos.second));
1114 if (&rDocument == &rDestCol.
GetDoc())
1122 ScFormulaCell*
p = sc::formula_block::at(*it->data, aPos.second);
1127 aDestPos.
SetRow(nDestRow);
1135 rDestCol.
maCells.set_empty(nDestRow, nDestRow);
1153 rDestCol.
maCellNotes.set_empty(nDestRow, nDestRow);
1158 rDestCol.
maCellNotes.set_empty(nDestRow, nDestRow);
1170 if ((nType == SvNumFormatType::DATE) || (nType == SvNumFormatType::TIME) || (nType == SvNumFormatType::DATETIME))
1176 class CopyAsLinkHandler
1186 void setDefaultAttrToDest(
size_t nRow)
1192 void setDefaultAttrsToDest(
size_t nRow,
size_t nSize)
1194 std::vector<sc::CellTextAttr> aAttrs(nSize);
1206 aArr.AddSingleReference(aRef);
1210 void createRefBlock(
const sc::CellStoreType::value_type& aNode,
size_t nOffset,
size_t nDataSize)
1212 size_t nTopRow = aNode.position + nOffset;
1214 for (
size_t i = 0;
i < nDataSize; ++
i)
1216 SCROW nRow = nTopRow +
i;
1217 mrDestCol.
SetFormulaCell(maDestPos, nRow, createRefCell(nRow), meListenType);
1220 setDefaultAttrsToDest(nTopRow, nDataSize);
1226 mrDestCol(rDestCol),
1227 mpDestPos(pDestPos),
1228 mnCopyFlags(nCopyFlags),
1232 maDestPos = *mpDestPos;
1235 ~CopyAsLinkHandler()
1246 *mpDestPos = maDestPos;
1250 void setStartListening(
bool b )
1255 void operator() (
const sc::CellStoreType::value_type& aNode,
size_t nOffset,
size_t nDataSize)
1257 size_t nRow = aNode.position + nOffset;
1262 mrSrcCol.
DuplicateNotes(nRow, nDataSize, mrDestCol, maDestPos, bCloneCaption);
1272 sc::numeric_block::const_iterator it = sc::numeric_block::begin(*aNode.data);
1273 std::advance(it, nOffset);
1274 sc::numeric_block::const_iterator itEnd = it;
1275 std::advance(itEnd, nDataSize);
1278 for (; it != itEnd; ++it, aSrcPos.IncRow(), ++nRow)
1280 if (!canCopyValue(mrSrcCol.
GetDoc(), aSrcPos, mnCopyFlags))
1284 setDefaultAttrToDest(nRow);
1294 createRefBlock(aNode, nOffset, nDataSize);
1302 createRefBlock(aNode, nOffset, nDataSize);
1311 class CopyByCloneHandler
1323 void setDefaultAttrToDest(
size_t nRow)
1329 void setDefaultAttrsToDest(
size_t nRow,
size_t nSize)
1331 std::vector<sc::CellTextAttr> aAttrs(nSize);
1346 bool bForceFormula =
false;
1348 if (bCloneSpecialBoolean)
1352 if (pCode && pCode->
GetLen() == 1)
1357 bForceFormula =
true;
1361 if (bForceFormula || bCloneFormula)
1367 setDefaultAttrToDest(nRow);
1377 if (nErr != FormulaError::NONE)
1382 mrDestCol.
SetFormulaCell(maDestPos, nRow, pErrCell, meListenType);
1383 setDefaultAttrToDest(nRow);
1388 if (bCloneValue || bCloneDateTime)
1396 setDefaultAttrToDest(nRow);
1425 setDefaultAttrToDest(nRow);
1432 mrDestCol(rDestCol),
1433 mpDestPos(pDestPos),
1434 mpSharedStringPool(pSharedStringPool),
1435 mnCopyFlags(nCopyFlags),
1440 maDestPos = *mpDestPos;
1443 ~CopyByCloneHandler()
1466 *mpDestPos = maDestPos;
1469 void setStartListening(
bool b )
1474 void operator() (
const sc::CellStoreType::value_type& aNode,
size_t nOffset,
size_t nDataSize)
1476 size_t nRow = aNode.position + nOffset;
1481 mrSrcCol.
DuplicateNotes(nRow, nDataSize, mrDestCol, maDestPos, bCloneCaption);
1491 sc::numeric_block::const_iterator it = sc::numeric_block::begin(*aNode.data);
1492 std::advance(it, nOffset);
1493 sc::numeric_block::const_iterator itEnd = it;
1494 std::advance(itEnd, nDataSize);
1497 for (; it != itEnd; ++it, aSrcPos.IncRow(), ++nRow)
1499 if (!canCopyValue(mrSrcCol.
GetDoc(), aSrcPos, mnCopyFlags))
1503 setDefaultAttrToDest(nRow);
1512 sc::string_block::const_iterator it = sc::string_block::begin(*aNode.data);
1513 std::advance(it, nOffset);
1514 sc::string_block::const_iterator itEnd = it;
1515 std::advance(itEnd, nDataSize);
1517 for (; it != itEnd; ++it, ++nRow)
1530 if (mpSharedStringPool)
1542 setDefaultAttrToDest(nRow);
1549 if (!(mnCopyFlags & InsertDeleteFlags::STRING))
1552 sc::edittext_block::const_iterator it = sc::edittext_block::begin(*aNode.data);
1553 std::advance(it, nOffset);
1554 sc::edittext_block::const_iterator itEnd = it;
1555 std::advance(itEnd, nDataSize);
1557 std::vector<EditTextObject*> aCloned;
1558 aCloned.reserve(nDataSize);
1559 for (; it != itEnd; ++it)
1563 maDestPos.
miCellPos, nRow, aCloned.begin(), aCloned.end());
1565 setDefaultAttrsToDest(nRow, nDataSize);
1570 sc::formula_block::const_iterator it = sc::formula_block::begin(*aNode.data);
1571 std::advance(it, nOffset);
1572 sc::formula_block::const_iterator itEnd = it;
1573 std::advance(itEnd, nDataSize);
1588 for (; it != itEnd; ++it, ++nRow)
1589 cloneFormulaCell(nRow, **it);
1603 const ScMarkData* pMarkData,
bool bAsLink,
bool bGlobalNamesToLocal)
const
1612 while ( aIter.Next( nStart, nEnd ) && nStart <= nRow2 )
1614 if ( nEnd >= nRow1 )
1615 CopyToColumn(rCxt, std::max(nRow1,nStart), std::min(nRow2,nEnd),
1616 nFlags,
false, rColumn, pMarkData, bAsLink );
1621 OSL_FAIL(
"CopyToColumn: bMarked, but no mark");
1631 for (
SCROW nRow = nRow1; nRow <= nRow2; nRow++ )
1634 rColumn.
pAttrArray->GetPattern( nRow )->GetStyleSheet();
1636 std::unique_ptr<ScPatternAttr> pNewPattern(
new ScPatternAttr( *pPattern ));
1637 pNewPattern->SetStyleSheet( const_cast<ScStyleSheet*>(pStyle) );
1638 rColumn.
pAttrArray->SetPattern( nRow, std::move(pNewPattern),
true );
1662 pSharedStringPool, bGlobalNamesToLocal);
1675 CopyToColumn(rCxt, 0, nRow1-1, InsertDeleteFlags::FORMULA,
false, rColumn);
1677 CopyToColumn(rCxt, nRow1, nRow2, nFlags, bMarked, rColumn);
1679 if (nRow2 <
GetDoc().MaxRow())
1680 CopyToColumn(rCxt, nRow2+1,
GetDoc().MaxRow(), InsertDeleteFlags::FORMULA,
false, rColumn);
1690 aRangeSet.
scan(rPosCol);
1697 CopyToClipHandler aFunc(
GetDoc(), *
this, rDestCol,
nullptr);
1698 sc::CellStoreType::const_iterator itPos =
maCells.begin();
1699 for (
const auto& rRange : aRanges)
1710 SCROW nStart = -1, nEnd = -1;
1711 const ScPatternAttr* pPattern = aAttrIter.Next( nStart, nEnd );
1730 pPattern = aAttrIter.Next( nStart, nEnd );
1739 SCROW nStart = -1, nEnd = -1;
1740 const ScPatternAttr* pPattern = aAttrIter.Next( nStart, nEnd );
1756 pPattern = aAttrIter.Next( nStart, nEnd );
1764 SCROW nStart = 0, nEnd = 0;
1765 const ScPatternAttr* pPattern = aAttrIter.Next( nStart, nEnd );
1766 while (pPattern && bOk)
1772 pPattern = aAttrIter.Next( nStart, nEnd );
1782 SCROW nStart = -1, nEnd = -1;
1783 const ScPatternAttr* pPattern = aAttrIter.Next( nStart, nEnd );
1793 pPattern = aAttrIter.Next( nStart, nEnd );
1801 for (
auto& rCellItem : rCells)
1806 sc::formula_block::iterator itCell = sc::formula_block::begin(*rCellItem.data);
1807 sc::formula_block::iterator itCellEnd = sc::formula_block::end(*rCellItem.data);
1808 for (; itCell != itCellEnd; ++itCell)
1816 class NoteCaptionUpdater
1821 NoteCaptionUpdater(
SCCOL nCol,
SCTAB nTab ) : mnCol(nCol), mnTab(nTab) {}
1823 void operator() (
size_t nRow,
ScPostIt* p )
1833 NoteCaptionUpdater aFunc(nCol,
nTab);
1839 assert(static_cast<int>(pObjects.size()) >= nRowEnd - nRowStart + 1);
1842 for (
SCROW nCurrentRow = nRowStart; nCurrentRow <= nRowEnd; nCurrentRow++, nObj++)
1844 if (pObjects[nObj].empty())
1853 for (
auto &
pObject : pObjects)
1897 resetColumnPosition(
maCells, nCol);
1910 aNonEmpties.
scan(*
this, nStartRow, nEndRow);
1915 sc::CellStoreType::position_type aPos =
maCells.position(nStartRow);
1919 aPos =
maCells.position(aPos.first, nEndRow+1);
1924 aPos = rCol.
maCells.position(nStartRow);
1928 aPos = rCol.
maCells.position(aPos.first, nEndRow+1);
1942 aPos = rCol.
maCells.position(nStartRow);
1946 aPos = rCol.
maCells.position(aPos.first, nEndRow+1);
1956 for (
const auto& rRange : aRanges)
1958 for (
SCROW nRow = rRange.mnRow1; nRow <= rRange.mnRow2; ++nRow)
1968 class SharedTopFormulaCellPicker
1971 SharedTopFormulaCellPicker() =
default;
1972 SharedTopFormulaCellPicker(SharedTopFormulaCellPicker
const &) =
default;
1973 SharedTopFormulaCellPicker(SharedTopFormulaCellPicker &&) =
default;
1974 SharedTopFormulaCellPicker &
operator =(SharedTopFormulaCellPicker
const &) =
default;
1975 SharedTopFormulaCellPicker &
operator =(SharedTopFormulaCellPicker &&) =
default;
1977 virtual ~SharedTopFormulaCellPicker() {}
1979 void operator() ( sc::CellStoreType::value_type& node )
1984 size_t nTopRow = node.position;
1986 sc::formula_block::iterator itBeg = sc::formula_block::begin(*node.data);
1987 sc::formula_block::iterator itEnd = sc::formula_block::end(*node.data);
1991 for (sc::formula_block::iterator it = itBeg; it != itEnd; ++it)
1994 size_t nRow = nTopRow + std::distance(itBeg, it);
1997 processNonShared(pCell, nRow);
2009 std::advance(it, nOffsetToLast);
2015 virtual void processSharedTop(
ScFormulaCell** ,
size_t ,
size_t ) {}
2018 class UpdateRefOnCopy
2026 mrCxt(rCxt), mpUndoDoc(pUndoDoc), mbUpdated(
false) {}
2028 bool isUpdated()
const {
return mbUpdated; }
2030 void operator() (sc::CellStoreType::value_type& node,
size_t nOffset,
size_t nDataSize)
2035 sc::formula_block::iterator it = sc::formula_block::begin(*node.data);
2036 std::advance(it, nOffset);
2037 sc::formula_block::iterator itEnd = it;
2038 std::advance(itEnd, nDataSize);
2040 for (; it != itEnd; ++it)
2048 class UpdateRefOnNonCopy
2055 bool mbClipboardSource;
2081 std::unique_ptr<ScTokenArray> pOldCode(pCode->
Clone());
2087 bool bGroupShifted =
false;
2092 for (++pp; pp != ppEnd; ++pp)
2096 aErrorPos, mpCxt->
mrDoc))
2098 assert(!
"can't move formula cell");
2112 bGroupShifted =
true;
2122 recompileTokenArray(*pTop);
2130 for (pp = rGroup.
mpCells; pp != ppEnd; ++pp)
2139 fillUndoDoc(aOldPos, rGroup.
mnLength, *pOldCode);
2144 for (pp = rGroup.
mpCells; pp != ppEnd; ++pp)
2166 std::unique_ptr<ScTokenArray> pOldCode(pCode->
Clone());
2193 bRecalcOnMove = aPos != aOldPos;
2203 recompileTokenArray(*pTop);
2210 auto pPosSet = std::make_shared<sc::ColumnBlockPositionSet>(mpCxt->
mrDoc);
2218 for (; pp != ppEnd; ++pp)
2230 if (!mbClipboardSource || !bCellMoved)
2231 fillUndoDoc(aOldPos, rGroup.
mnLength, *pOldCode);
2236 if (!mpUndoDoc || nLength <= 0)
2249 std::vector<ScFormulaCell*> aCells;
2250 aCells.reserve(nLength);
2252 aCells.push_back(pFC);
2254 for (
SCROW i = 1; i < nLength; ++i, aUndoPos.
IncRow())
2257 aCells.push_back(pFC);
2262 std::for_each(aCells.begin(), aCells.end(), std::default_delete<ScFormulaCell>());
2269 mnCol(nCol), mnTab(nTab), mpCxt(pCxt),
2270 mpUndoDoc(pUndoDoc), mbUpdated(
false),
2271 mbClipboardSource(pCxt->mrDoc.IsClipboardSource()){}
2278 updateRefOnShift(rGroup);
2281 updateRefOnMove(rGroup);
2292 for (; pp != ppEnd; ++pp, aUndoPos.
IncRow())
2305 bool isUpdated()
const {
return mbUpdated; }
2308 class UpdateRefGroupBoundChecker :
public SharedTopFormulaCellPicker
2311 std::vector<SCROW>& mrBounds;
2315 mrCxt(rCxt), mrBounds(rBounds) {}
2317 virtual void processSharedTop(
ScFormulaCell** ppCells,
size_t ,
size_t )
override
2327 class UpdateRefExpandGroupBoundChecker :
public SharedTopFormulaCellPicker
2330 std::vector<SCROW>& mrBounds;
2333 UpdateRefExpandGroupBoundChecker(
const sc::RefUpdateContext& rCxt, std::vector<SCROW>& rBounds) :
2334 mrCxt(rCxt), mrBounds(rBounds) {}
2336 virtual void processSharedTop(
ScFormulaCell** ppCells,
size_t ,
size_t )
override
2346 class FormulaGroupPicker :
public SharedTopFormulaCellPicker
2348 std::vector<sc::FormulaGroupEntry>& mrGroups;
2351 explicit FormulaGroupPicker( std::vector<sc::FormulaGroupEntry>& rGroups ) : mrGroups(rGroups) {}
2353 virtual void processNonShared(
ScFormulaCell* pCell,
size_t nRow )
override
2355 mrGroups.emplace_back(pCell, nRow);
2358 virtual void processSharedTop(
ScFormulaCell** ppCells,
size_t nRow,
size_t nLength )
override
2360 mrGroups.emplace_back(ppCells, nRow, nLength);
2372 UpdateRefOnCopy aHandler(rCxt, pUndoDoc);
2374 sc::CellStoreType::position_type aPos = blockPos
2388 return aHandler.isUpdated();
2400 std::vector<SCROW> aBounds;
2404 if (bThisColShifted)
2415 aBounds.push_back(nSplitPos);
2420 aBounds.push_back(nSplitPos);
2423 aBounds.push_back(nSplitPos);
2429 UpdateRefGroupBoundChecker aBoundChecker(rCxt, aBounds);
2436 UpdateRefExpandGroupBoundChecker aExpandChecker(rCxt, aBounds);
2447 UpdateRefOnNonCopy aHandler(nCol, nTab, &rCxt, pUndoDoc);
2448 aHandler = std::for_each(aGroups.begin(), aGroups.end(), aHandler);
2449 if (bSplit || aHandler.isUpdated())
2452 return aHandler.isUpdated();
2457 std::vector<sc::FormulaGroupEntry> aGroups;
2458 std::for_each(
maCells.begin(),
maCells.end(), FormulaGroupPicker(aGroups));
2464 class UpdateTransHandler
2467 sc::CellStoreType::iterator miPos;
2475 maSource(rSource), maDest(rDest), mpUndoDoc(pUndoDoc) {}
2479 sc::CellStoreType::position_type aPos = mrColumn.
GetCellStore().position(miPos, nRow);
2487 class UpdateGrowHandler
2490 sc::CellStoreType::iterator miPos;
2498 maArea(rArea), mnGrowX(nGrowX), mnGrowY(nGrowY) {}
2502 sc::CellStoreType::position_type aPos = mrColumn.
GetCellStore().position(miPos, nRow);
2510 class InsertTabUpdater
2514 sc::CellTextAttrStoreType::iterator miAttrPos;
2521 mrTextAttrs(rTextAttrs),
2522 miAttrPos(rTextAttrs.
begin()),
2524 mbModified(
false) {}
2540 bool isModified()
const {
return mbModified; }
2543 class DeleteTabUpdater
2547 sc::CellTextAttrStoreType::iterator miAttrPos;
2553 mrTextAttrs(rTextAttrs),
2554 miAttrPos(rTextAttrs.
begin()),
2556 mbModified(
false) {}
2572 bool isModified()
const {
return mbModified; }
2575 class InsertAbsTabUpdater
2578 sc::CellTextAttrStoreType::iterator miAttrPos;
2584 mrTextAttrs(rTextAttrs),
2585 miAttrPos(rTextAttrs.
begin()),
2588 mbModified(
false) {}
2604 bool isModified()
const {
return mbModified; }
2607 class MoveTabUpdater
2611 sc::CellTextAttrStoreType::iterator miAttrPos;
2617 mrTextAttrs(rTextAttrs),
2618 miAttrPos(rTextAttrs.
begin()),
2620 mbModified(
false) {}
2636 bool isModified()
const {
return mbModified; }
2639 class UpdateCompileHandler
2641 bool mbForceIfNameInUse:1;
2643 explicit UpdateCompileHandler(
bool bForceIfNameInUse) :
2644 mbForceIfNameInUse(bForceIfNameInUse) {}
2656 explicit TabNoSetter(
SCTAB nTab) : mnTab(nTab) {}
2664 class UsedRangeNameFinder
2676 class CheckVectorizationHandler
2679 CheckVectorizationHandler()
2699 struct SetDirtyVarHandler
2707 class SetDirtyHandler
2713 mrDoc(rDoc), mrCxt(rCxt) {}
2733 class SetDirtyOnRangeHandler
2738 explicit SetDirtyOnRangeHandler(
ScColumn& rColumn)
2739 : maValueRanges(rColumn.
GetDoc().GetSheetLimits()),
2740 mrColumn(rColumn) {}
2747 void operator() (mdds::mtv::element_t type,
size_t nTopRow,
size_t nDataSize)
2754 SCROW nRow1 = nTopRow;
2755 SCROW nRow2 = nTopRow + nDataSize - 1;
2756 maValueRanges.
set(nRow1, nRow2,
true);
2761 std::vector<SCROW> aRows;
2773 for (
const auto& rSpan : aSpans)
2774 rBroadcastSpans.
set(mrColumn.
GetDoc(),
nTab,
nCol, rSpan.mnRow1, rSpan.mnRow2,
true);
2778 class SetTableOpDirtyOnRangeHandler
2783 explicit SetTableOpDirtyOnRangeHandler(
ScColumn& rColumn)
2784 : maValueRanges(rColumn.
GetDoc().GetSheetLimits()),
2785 mrColumn(rColumn) {}
2792 void operator() (mdds::mtv::element_t type,
size_t nTopRow,
size_t nDataSize)
2799 SCROW nRow1 = nTopRow;
2800 SCROW nRow2 = nTopRow + nDataSize - 1;
2801 maValueRanges.
set(nRow1, nRow2,
true);
2806 std::vector<SCROW> aRows;
2812 struct SetDirtyAfterLoadHandler
2839 struct SetDirtyIfPostponedHandler
2848 struct CalcAllHandler
2850 #define DEBUG_SC_CHECK_FORMULATREE_CALCULATION 0
2853 #if DEBUG_SC_CHECK_FORMULATREE_CALCULATION
2855 double nOldVal, nNewVal;
2859 #if DEBUG_SC_CHECK_FORMULATREE_CALCULATION
2865 assert(nOldVal == nNewVal);
2868 #undef DEBUG_SC_CHECK_FORMULATREE_CALCULATION
2871 class CompileAllHandler
2887 class CompileXMLHandler
2895 mrProgress(rProgress),
2901 if( (nFormat % SV_COUNTRY_LANGUAGE_OFFSET) != 0)
2914 class CompileErrorCellsHandler
2918 sc::CellStoreType::iterator miPos;
2926 mnErrCode(nErrCode),
2934 if (nCurError == FormulaError::NONE)
2938 if (mnErrCode != FormulaError::NONE && nCurError != mnErrCode)
2942 sc::CellStoreType::position_type aPos = mrColumn.
GetCellStore().position(miPos, nRow);
2946 OUString aFormula = pCell->
GetFormula(mrCxt);
2947 pCell->
Compile(mrCxt, aFormula);
2953 bool isCompiled()
const {
return mbCompiled; }
2956 class CalcAfterLoadHandler
2959 bool mbStartListening;
2963 mrCxt(rCxt), mbStartListening(bStartListening) {}
2971 struct ResetChangedHandler
2982 class FindEditCellsHandler
2985 sc::CellTextAttrStoreType::iterator miAttrPos;
2986 sc::CellStoreType::iterator miCellPos;
2989 explicit FindEditCellsHandler(
ScColumn& rCol) :
3005 if (IsAmbiguousScriptNonZero(nScriptType))
3014 std::pair<size_t,bool> operator() (
const sc::CellStoreType::value_type& node,
size_t nOffset,
size_t nDataSize)
3016 typedef std::pair<size_t,bool> RetType;
3020 return RetType(0,
false);
3024 for (
size_t i = 0; i < nDataSize; ++i)
3026 SCROW nRow = node.position + i + nOffset;
3028 if (IsAmbiguousScriptNonZero(nScriptType))
3030 return RetType(i+nOffset,
true);
3034 return RetType(0,
false);
3043 UpdateTransHandler aFunc(*
this, rSource, rDest, pUndoDoc);
3049 UpdateGrowHandler aFunc(*
this, rArea, nGrowX, nGrowY);
3068 if (aFunc.isModified())
3082 if (aFunc.isModified())
3090 if (aFunc.isModified())
3101 if (aFunc.isModified())
3107 UpdateCompileHandler aFunc(bForceIfNameInUse);
3116 TabNoSetter aFunc(nTab);
3122 UsedRangeNameFinder aFunc(rIndexes);
3128 SetDirtyVarHandler aFunc;
3137 std::pair<sc::CellStoreType::const_iterator,size_t> aPos =
maCells.position(nRow);
3138 sc::CellStoreType::const_iterator it = aPos.first;
3143 const ScFormulaCell* p = sc::formula_block::at(*it->data, aPos.second);
3150 CheckVectorizationHandler aFunc;
3158 SetDirtyHandler aFunc(
GetDoc(), rCxt);
3168 SetDirtyOnRangeHandler aHdl(*
this);
3170 aHdl.fillBroadcastSpans(rBroadcastSpans);
3175 class BroadcastBroadcastersHandler
3182 : maHint(nHint,
ScAddress(nCol, 0, nTab))
3183 , mbBroadcasted(
false)
3191 mbBroadcasted =
true;
3194 bool wasBroadcasted() {
return mbBroadcasted; }
3201 BroadcastBroadcastersHandler aBroadcasterHdl(nHint, nTab, nCol);
3203 return aBroadcasterHdl.wasBroadcasted();
3216 SetDirtyOnRangeHandler aHdl(*
this);
3223 SetDirtyOnRangeHandler aHdl(*
this);
3231 SetDirtyOnRangeHandler aHdl(*
this);
3252 SetTableOpDirtyOnRangeHandler aHdl(*
this);
3260 SetDirtyAfterLoadHandler aFunc;
3266 class RecalcOnRefMoveCollector
3268 std::vector<SCROW> maDirtyRows;
3273 maDirtyRows.push_back(nRow);
3276 const std::vector<SCROW>& getDirtyRows()
const
3287 SetDirtyIfPostponedHandler aFunc;
3295 RecalcOnRefMoveCollector aFunc;
3302 CalcAllHandler aFunc;
3308 CompileAllHandler aFunc(rCxt);
3314 CompileXMLHandler aFunc(rCxt, rProgress, *
this);
3321 CompileErrorCellsHandler aHdl(rCxt, *
this, nErrCode);
3323 return aHdl.isCompiled();
3328 CalcAfterLoadHandler aFunc(rCxt, bStartListening);
3334 ResetChangedHandler aFunc;
3342 FindEditCellsHandler aFunc(*
this);
3343 std::pair<sc::CellStoreType::const_iterator,size_t> aPos =
3346 if (aPos.first ==
maCells.end())
3349 rFirst = aPos.first->position + aPos.second;
3362 return pAttrArray->SearchStyle(nRow, pSearchStyle, bUp, &aArray);
3368 return pAttrArray->SearchStyle( nRow, pSearchStyle, bUp );
3373 bool bInSelection,
const ScMarkData& rMark)
const
3381 rRow, rEndRow, pSearchStyle, bUp, &aArray);
3387 return pAttrArray->SearchStyleRange( rRow, rEndRow, pSearchStyle, bUp );
sc::MatrixEdge GetBlockMatrixEdges(SCROW nRow1, SCROW nRow2, sc::MatrixEdge nMask, bool bNoMatrixAtAll) const
bool IsInFormulaTree(const ScFormulaCell *pCell) const
bool CompileErrorCells(sc::CompileFormulaContext &rCxt, FormulaError nErrCode)
void CellStorageModified()
Called whenever the state of cell array gets modified i.e.
virtual editeng::FieldUpdater GetFieldUpdater()=0
Numeric values (and numeric results if InsertDeleteFlags::FORMULA is not set).
void ApplyStyle(SCROW nRow, const ScStyleSheet *rStyle)
If set, global named expressions will be converted to sheet-local named expressions.
SCROW mnRowDelta
Amount and direction of movement in the row direction.
void UpdateNoteCaptions(SCROW nRow1, SCROW nRow2)
Temporarily switch on/off auto calculation mode.
CellTextAttrStoreType::const_iterator miCellTextAttrPos
::boost::intrusive_ptr< ScFormulaCellGroup > ScFormulaCellGroupRef
void setPositionDelta(const ScAddress &rDelta)
OUString getString() const
void SetDirty(SCROW nRow1, SCROW nRow2, BroadcastMode)
CellStoreType::const_iterator miCellPos
SharedString intern(const OUString &rStr)
SC_DLLPUBLIC svl::SharedStringPool & GetSharedStringPool()
todo: It should be possible to have MarkArrays for each table, in order to enable "search all" across...
void DeleteArea(SCROW nStartRow, SCROW nEndRow, InsertDeleteFlags nDelFlag, bool bBroadcast=true, sc::ColumnSpanSet *pBroadcastSpans=nullptr)
void DuplicateNotes(SCROW nStartRow, size_t nDataSize, ScColumn &rDestCol, sc::ColumnBlockPosition &rDestBlockPos, bool bCloneCaption, SCROW nRowOffsetDest=0) const
void MergeSelectionPattern(ScMergePatternState &rState, const ScMarkData &rMark, bool bDeep) const
virtual void CheckToken(const formula::FormulaToken &r) override
Single reference (one address) into the sheet.
void MarkScenarioIn(ScMarkData &rDestMark) const
void ApplyPatternArea(SCROW nStartRow, SCROW nEndRow, const ScPatternAttr &rPatAttr, ScEditDataArray *pDataArray=nullptr, bool *const pIsChanged=nullptr)
~ScColumn() COVERITY_NOEXCEPT_FALSE
CellTextAttrStoreType::iterator miCellTextAttrPos
const mdds::mtv::element_t element_type_celltextattr
broadcast only existing cell broadcasters => no AreaBroadcast of range!
void SetDirtyIfPostponed()
void CopyUpdated(const ScColumn &rPosCol, ScColumn &rDestCol) const
void SetMultiMarkArea(const ScRange &rRange, bool bMark=true, bool bSetupMulti=false)
SC_DLLPUBLIC const ScFormulaCell * GetFormulaCell(const ScAddress &rPos) const
bool IsExpandRefs() const
bool mbValueChanged
When this flag is true, the result of the formula needs to be re-calculated either because it contain...
bool isStartListening() const
Context for reference update during shifting, moving or copying of cell ranges.
void CalcAfterLoad(sc::CompileFormulaContext &rCxt, bool bStartListening)
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. ...
std::unordered_map< sal_uInt32, sal_uInt32 > SvNumberFormatterMergeMap
void UpdateDeleteTab(sc::RefUpdateDeleteTabContext &rCxt)
void ResetChanged(SCROW nStartRow, SCROW nEndRow)
Store position data for column array storage.
void CopyStaticToDocument(SCROW nRow1, SCROW nRow2, const SvNumberFormatterMergeMap &rMap, ScColumn &rDestCol)
This is very similar to ScCellValue, except that it references the original value instead of copying ...
SC_DLLPUBLIC formula::FormulaGrammar::Grammar GetGrammar() const
void Remove(const SfxPoolItem &)
bool HasAttribSelection(const ScMarkData &rMark, HasAttrFlags nMask) const
SCROW GetMaxRowCount() const
bool mbClearTabDeletedFlag
When true, go through all reference tokens and clears "sheet deleted" flag if its corresponding index...
void ChangeSelectionIndent(bool bIncrement, const ScMarkData &rMark)
void ChangeSelectionIndent(bool bIncrement, const ScMarkData &rMark, SCCOL nCol)
EmbeddedObjectRef * pObject
void CompileAll(sc::CompileFormulaContext &rCxt)
StoreT::iterator ProcessBlock(const typename StoreT::iterator &itPos, StoreT &rStore, Func &rFunc, typename StoreT::size_type nStart, typename StoreT::size_type nEnd)
Non-const variant of the above function.
const ScRange & GetMarkArea() const
void UpdateDrawObjectsForRow(std::vector< SdrObject * > &pObjects, SCCOL nTargetCol, SCROW nTargetRow)
const SfxSetItem & ApplyTo(const SfxSetItem &rSetItem)
sc::RefUpdateResult AdjustReferenceOnMove(const sc::RefUpdateContext &rCxt, const ScAddress &rOldPos, const ScAddress &rNewPos)
Internal use only (d&d undo): do not delete caption objects of cell notes.
void ApplySelectionStyle(const ScStyleSheet &rStyle, const ScMarkData &rMark)
SC_DLLPUBLIC ScDocumentPool * GetPool()
void ParseFormula(const CellStoreType &rStore, Func &rFunc)
BroadcasterStoreType::iterator miBroadcasterPos
bool Next(SCROW &rTop, SCROW &rBottom)
void CopyToColumn(sc::CopyToDocContext &rCxt, SCROW nRow1, SCROW nRow2, InsertDeleteFlags nFlags, bool bMarked, ScColumn &rColumn, const ScMarkData *pMarkData=nullptr, bool bAsLink=false, bool bGlobalNamesToLocal=false) const
ScFormulaCell * SetFormulaCell(SCROW nRow, ScFormulaCell *pCell, sc::StartListeningType eListenType=sc::SingleCellListening, bool bInheritNumFormatIfNeeded=true)
Takes ownership of pCell.
void UpdateTranspose(const ScRange &rSource, const ScAddress &rDest, ScDocument *pUndoDoc)
bool HasMarks(SCCOL nCol) const
SC_DLLPUBLIC bool Move(SCCOL nDeltaX, SCROW nDeltaY, SCTAB nDeltaZ, ScAddress &rErrorPos, const ScDocument &rDoc)
const mdds::mtv::element_t element_type_formula
void updateTableFields(int nTab)
void SetAllFormulasDirty(const sc::SetFormulaDirtyContext &rCxt)
void ApplySelectionLineStyle(const ScMarkData &rMark, const ::editeng::SvxBorderLine *pLine, bool bColorOnly)
const EditTextObject * mpEditText
void CopyToClip(sc::CopyToClipContext &rCxt, SCROW nRow1, SCROW nRow2, ScColumn &rColumn) const
Keep track of spans in a single column only.
void SetText(const OUString &rStr)
ScRefCellValue GetCellValue(SCROW nRow) const
enumrange< T >::Iterator begin(enumrange< T >)
SC_DLLPUBLIC SCROW MaxRow() const
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 ...
void UpdateGrow(const ScRange &rArea, SCCOL nGrowX, SCROW nGrowY)
Additional class containing cell annotation data.
This is a rather odd datastructure.
bool IsMultiMarked() const
void EndListeningFormulaCells(sc::EndListeningContext &rCxt, SCROW nRow1, SCROW nRow2, SCROW *pStartRow, SCROW *pEndRow)
void SetNumberFormat(SCROW nRow, sal_uInt32 nNumberFormat)
const ScStyleSheet * GetSelectionStyle(const ScMarkData &rMark, bool &rFound) const
sc::CellStoreType maCells
void UpdateCompile(bool bForceIfNameInUse=false)
bool SearchStyleRange(SCROW &rRow, SCROW &rEndRow, const ScStyleSheet *pSearchStyle, bool bUp, bool bInSelection, const ScMarkData &rMark) const
void set(const ScDocument &rDoc, SCTAB nTab, SCCOL nCol, SCROW nRow, bool bVal)
ScFormulaCell * mpFormula
void CheckRelativeReferenceBounds(const sc::RefUpdateContext &rCxt, const ScAddress &rPos, SCROW nGroupLen, std::vector< SCROW > &rBounds) const
SC_DLLPUBLIC const SfxPoolItem * GetAttr(SCCOL nCol, SCROW nRow, SCTAB nTab, sal_uInt16 nWhich) const
void PutInFormulaTree(ScFormulaCell *pCell)
Internal use only (copy from clip): do not delete existing cell contents when pasting notes...
void DuplicateSparklines(SCROW nStartRow, size_t nDataSize, ScColumn &rDestCol, sc::ColumnBlockPosition &rDestBlockPos, SCROW nRowOffsetDest=0) const
const SfxPoolItem & GetItem(sal_uInt16 nWhichP) const
void SetTabNo(SCTAB nNewTab)
void SetDirtyFromClip(SCROW nRow1, SCROW nRow2, sc::ColumnSpanSet &rBroadcastSpans)
bool UpdateReference(sc::RefUpdateContext &rCxt, ScDocument *pUndoDoc)
Update reference addresses in formula cell in response to mass cell movement.
ColumnBlockPosition * getBlockPosition(SCTAB nTab, SCCOL nCol)
bool mbNameModified
When this flag is true, it indicates that the token array contains a range name that's been updated...
void InsertRow(SCROW nStartRow, SCSIZE nSize)
SC_DLLPUBLIC ScDrawLayer * GetDrawLayer()
void getSpans(SpansType &rSpans) const
SC_DLLPUBLIC SvNumberFormatter * GetFormatTable() const
void InitBlockPosition(sc::ColumnBlockPosition &rBlockPos)
Keep track of all named expressions that have been updated during reference update.
void Broadcast(const SfxHint &rHint)
void set(SCTAB nTab, SCCOL nCol)
ScColumnData & operator=(const ScColumnData &)=delete
void UndoToColumn(sc::CopyToDocContext &rCxt, SCROW nRow1, SCROW nRow2, InsertDeleteFlags nFlags, bool bMarked, ScColumn &rColumn) const
UpdateRefMode meMode
update mode - insert/delete, copy, or move.
void SetFlag3D(bool bVal)
void Set(SCCOL nCol, SCROW nRow, SCTAB nTab)
const svl::SharedString * mpString
void InitAddress(const ScAddress &rAdr)
InitAddress: InitFlags and set address.
void RegroupFormulaCells(std::vector< ScAddress > *pGroupPos=nullptr)
Regroup formula cells for the entire column.
sc::CellTextAttrStoreType maCellTextAttrs
std::unique_ptr< ScPostIt > Clone(const ScAddress &rOwnPos, ScDocument &rDestDoc, const ScAddress &rDestPos, bool bCloneCaption) const
Clones this note and its caption object, if specified.
CAUTION! The following defines must be in the same namespace as the respective type.
bool TestCopyScenarioTo(const ScColumn &rDestCol) const
void CheckVectorizationState()
void Init(SCCOL nNewCol, SCTAB nNewTab, ScDocument &rDoc, bool bEmptyAttrArray)
void InitAttrArray(ScAttrArray *attrArray)
const ScStyleSheet * GetStyleSheet() const
void SetAddressRow(SCROW nRow)
void getRows(std::vector< SCROW > &rRows) const
void UpdateInsertTab(sc::RefUpdateInsertTabContext &rCxt)
static void JoinNewFormulaCell(const sc::CellStoreType::position_type &aPos, ScFormulaCell &rCell)
std::unique_ptr< EditTextObject > CreateTextObject()
constexpr std::enable_if_t< std::is_signed_v< T >, std::make_unsigned_t< T > > make_unsigned(T value)
bool TestInsertRow(SCROW nStartRow, SCSIZE nSize) const
void UpdateDrawObjects(std::vector< std::vector< SdrObject * >> &pObjects, SCROW nRowStart, SCROW nRowEnd)
const mdds::mtv::element_t element_type_empty
void set(SCROW nRow1, SCROW nRow2, bool bVal)
void IncRow(SCROW nDelta=1)
ScMarkArray GetMarkArray(SCCOL nCol) const
SfxItemSet & GetItemSet()
ScDocument & GetDoc() const
Structure that stores segments of boolean flags per column, and perform custom action on those segmen...
void MoveObject(SdrObject *pObj, const ScAddress &rNewPosition)
constexpr TypedWhichId< SfxUInt32Item > ATTR_VALUE_FORMAT(146)
const mdds::mtv::element_t element_type_numeric
Mapped standard element types (for convenience).
void TrackFormulas(SfxHintId nHintId=SfxHintId::ScDataChanged)
void ProcessNote(CellNoteStoreType &rStore, Func &rFunc)
sal_uInt32 GetNumberFormat(SvNumberFormatter *) const
void FindRangeNamesInUse(SCROW nRow1, SCROW nRow2, sc::UpdatedRangeNames &rIndexes) const
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.
bool TestInsertCol(SCROW nStartRow, SCROW nEndRow) const
void CheckExpandReferenceBounds(const sc::RefUpdateContext &rCxt, const ScAddress &rPos, SCROW nGroupLen, std::vector< SCROW > &rBounds) const
sal_uInt32 GetNumberFormat(const ScInterpreterContext &rContext, SCROW nRow) const
bool UpdateReferenceOnCopy(sc::RefUpdateContext &rCxt, ScDocument *pUndoDoc=nullptr)
ScRange maRange
Range of cells that are about to be moved for insert/delete/move modes.
void ApplyAttr(SCROW nRow, const SfxPoolItem &rAttr)
BroadcastMode
Broadcast mode for SetDirty(SCROW,SCROW,BroadcastMode).
bool BroadcastBroadcasters(SCROW nRow1, SCROW nRow2, SfxHintId nHint)
Broadcast single broadcasters in range, without explicitly setting anything dirty, not doing area broadcasts.
void CopyScenarioTo(ScColumn &rDestCol) const
CellStoreType::iterator miCellPos
void ProcessFormulaEditText(CellStoreType &rStore, Func &rFunc)
mdds::mtv::soa::multi_type_vector< CTAttrFunc > CellTextAttrStoreType
void CopyCellNotesToDocument(SCROW nRow1, SCROW nRow2, ScColumn &rDestCol, bool bCloneCaption=true, SCROW nRowOffsetDest=0) const
Internal use only (undo etc.): do not copy/delete caption objects of cell notes.
constexpr TypedWhichId< ScMergeFlagAttr > ATTR_MERGE_FLAG(145)
const SfxPoolItem * Put(const SfxPoolItem &rItem, sal_uInt16 nWhich)
void UpdateInsertTabOnlyCells(sc::RefUpdateInsertTabContext &rCxt)
mdds::mtv::soa::multi_type_vector< CellFunc, CellStoreTrait > CellStoreType
ScColumn(ScSheetLimits const &)
sc::BroadcasterStoreType maBroadcasters
bool IsFormulaVectorDisabled() const
SC_DLLPUBLIC ScFormulaCell * SetFormulaCell(const ScAddress &rPos, ScFormulaCell *pCell)
Set formula cell, and transfer its ownership to the document.
sc::SparklineStoreType maSparklines
broadcast existing cells with position => does AreaBroadcast
sc::CellNoteStoreType maCellNotes
void SetTableOpDirty(const ScRange &)
SvtScriptType GetRangeScriptType(sc::CellTextAttrStoreType::iterator &itPos, SCROW nRow1, SCROW nRow2, const sc::CellStoreType::iterator &itr)
Get combined script types of the specified range.
SCTAB mnTabDelta
Amount and direction of movement in the sheet direction.
sc::CellTextAttrStoreType & GetCellAttrStore()
void CopyCellTextAttrsToDocument(SCROW nRow1, SCROW nRow2, ScColumn &rDestCol) const
const mdds::mtv::element_t element_type_edittext
void DeleteSelection(InsertDeleteFlags nDelFlag, const ScMarkData &rMark, bool bBroadcast)
void MoveTo(SCROW nStartRow, SCROW nEndRow, ScColumn &rCol)
void ClearSelectionItems(const sal_uInt16 *pWhich, const ScMarkData &rMark)
std::pair< CellStoreType::const_iterator, size_t > FindFormulaEditText(const CellStoreType &rStore, SCROW nRow1, SCROW nRow2, Func &rFunc)
Dates, times, datetime values.
virtual std::unique_ptr< EditTextObject > Clone() const =0
void ApplyPattern(SCROW nRow, const ScPatternAttr &rPatAttr)
const T & Put(std::unique_ptr< T > xItem, sal_uInt16 nWhich=0)
bool HasSelectionMatrixFragment(const ScMarkData &rMark, const ScRangeList &rRangeList) const
bool Contains(const ScAddress &) const
is Address& fully in Range?
void CopyScenarioFrom(const ScColumn &rSrcCol)
std::vector< RowSpan > SpansType
std::vector< sc::FormulaGroupEntry > GetFormulaGroupEntries()
Get all non-grouped formula cells and formula cell groups in the whole column.
SC_DLLPUBLIC ScPatternAttr * GetDefPattern() const
SCROW SearchStyle(SCROW nRow, const ScStyleSheet *pSearchStyle, bool bUp, bool bInSelection, const ScMarkData &rMark) const
May return -1 if not found.
void UpdateMoveTab(sc::RefUpdateMoveTabContext &rCxt, SCTAB nTabNo)
bool mbReferenceModified
This flag indicates whether any reference in the token array has been modified.
bool IsDrawObjectsEmptyBlock(SCROW nStartRow, SCROW nEndRow) const
void scan(const ScColumn &rColumn)
Scan an entire column and tag all non-empty cell positions.
void SwapCol(ScColumn &rCol)
void BroadcastCells(const std::vector< SCROW > &rRows, SfxHintId nHint)
bool HasObjectsAnchoredInRange(const ScRange &rRange)
static SC_DLLPUBLIC OUString GetString(const EditTextObject &rEditText, const ScDocument *pDoc)
Retrieves string with paragraphs delimited by new lines (' ').
ScInterpreterContext & GetNonThreadedContext() const
SCROW ApplySelectionCache(SfxItemPoolCache *pCache, const ScMarkData &rMark, ScEditDataArray *pDataArray, bool *const pIsChanged)
bool ValidRow(SCROW nRow, SCROW nMaxRow)
sc::RefUpdateResult AdjustReferenceOnShift(const sc::RefUpdateContext &rCxt, const ScAddress &rOldPos)
Adjust all references in response to shifting of cells during cell insertion and deletion.
static std::unique_ptr< EditTextObject > Clone(const EditTextObject &rSrc, ScDocument &rDestDoc)
const ScMultiSel & GetMultiSelData() const
void ApplyPatternIfNumberformatIncompatible(const ScRange &rRange, const ScPatternAttr &rPattern, SvNumFormatType nNewType)
bool IsFormulaDirty(SCROW nRow) const
bool SetFormulaCells(const ScAddress &rPos, std::vector< ScFormulaCell * > &rCells)
SCROW ApplySelectionCache(SfxItemPoolCache *pCache, const ScMarkData &rMark, ScEditDataArray *pDataArray, bool *const pIsChanged, SCCOL nCol)
void BroadcastRecalcOnRefMove()
const sc::CellTextAttr * GetCellTextAttr(SCROW nRow) const
const ScStyleSheet * GetAreaStyle(bool &rFound, SCROW nRow1, SCROW nRow2) const
SCCOL mnColDelta
Amount and direction of movement in the column direction.
void CopyCellToDocument(SCROW nSrcRow, SCROW nDestRow, ScColumn &rDestCol)
std::unique_ptr< ScAttrArray > pAttrArray
void ClearSelectionItems(const sal_uInt16 *pWhich, const ScMarkData &rMark, SCCOL nCol)
const mdds::mtv::element_t element_type_string
void AreaBroadcast(const ScHint &rHint)
only area, no cell broadcast
sc::CellStoreType & GetCellStore()
void UpdateCaptionPos(const ScAddress &rPos)
Updates caption position according to position of the passed cell.
const ScPatternAttr * GetMostUsedPattern(SCROW nStartRow, SCROW nEndRow) const
void UpdateInsertTabAbs(SCTAB nNewPos)
Strings (and string results if InsertDeleteFlags::FORMULA is not set).
std::unique_ptr< ScTokenArray > Clone() const
SC_DLLPUBLIC ScFieldEditEngine & GetEditEngine()
bool HasEditCells(SCROW nStartRow, SCROW nEndRow, SCROW &rFirst)
bool IsAllMarked(const ScRange &rRange) const
ColumnBlockPosition * getBlockPosition(SCTAB nTab, SCCOL nCol)
void ClearTabDeleted(const ScAddress &rPos, SCTAB nStartTab, SCTAB nEndTab)
Clear sheet deleted flag from internal reference tokens if the sheet index falls within specified ran...
SC_DLLPUBLIC bool GetAutoCalc() const
bool m_bDetectedRangeSegmentation false
BroadcasterStoreType::iterator ProcessBroadcaster(const BroadcasterStoreType::iterator &it, BroadcasterStoreType &rStore, SCROW nRow1, SCROW nRow2, FuncElem &rFuncElem)
void CompileXML(sc::CompileFormulaContext &rCxt, ScProgress &rProgress)
bool isKeepScenarioFlags() const