summaryrefslogtreecommitdiffstats
path: root/sc/inc/attarray.hxx
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 09:06:44 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 09:06:44 +0000
commited5640d8b587fbcfed7dd7967f3de04b37a76f26 (patch)
tree7a5f7c6c9d02226d7471cb3cc8fbbf631b415303 /sc/inc/attarray.hxx
parentInitial commit. (diff)
downloadlibreoffice-ed5640d8b587fbcfed7dd7967f3de04b37a76f26.tar.xz
libreoffice-ed5640d8b587fbcfed7dd7967f3de04b37a76f26.zip
Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'sc/inc/attarray.hxx')
-rw-r--r--sc/inc/attarray.hxx324
1 files changed, 324 insertions, 0 deletions
diff --git a/sc/inc/attarray.hxx b/sc/inc/attarray.hxx
new file mode 100644
index 000000000..868118796
--- /dev/null
+++ b/sc/inc/attarray.hxx
@@ -0,0 +1,324 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#pragma once
+
+#include "global.hxx"
+#include "attrib.hxx"
+#include "document.hxx"
+#include "patattr.hxx"
+
+#include <algorithm>
+#include <memory>
+#include <optional>
+
+#include <svl/itemset.hxx>
+
+class ScDocument;
+class ScEditDataArray;
+class ScMarkArray;
+class ScStyleSheet;
+class ScFlatBoolRowSegments;
+
+class SfxItemPoolCache;
+class SfxStyleSheetBase;
+class SvxBoxItem;
+class SvxBoxInfoItem;
+
+namespace editeng { class SvxBorderLine; }
+
+#define SC_LINE_EMPTY 0
+#define SC_LINE_SET 1
+#define SC_LINE_DONTCARE 2
+
+#define SC_ATTRARRAY_DELTA 4
+
+#define DEBUG_SC_TESTATTRARRAY 0
+
+struct ScLineFlags
+{
+ sal_uInt8 nLeft;
+ sal_uInt8 nRight;
+ sal_uInt8 nTop;
+ sal_uInt8 nBottom;
+ sal_uInt8 nHori;
+ sal_uInt8 nVert;
+
+ ScLineFlags() : nLeft(SC_LINE_EMPTY),nRight(SC_LINE_EMPTY),nTop(SC_LINE_EMPTY),
+ nBottom(SC_LINE_EMPTY),nHori(SC_LINE_EMPTY),nVert(SC_LINE_EMPTY) {}
+};
+
+struct ScMergePatternState
+{
+ std::optional<SfxItemSet> pItemSet;
+ const ScPatternAttr* pOld1; ///< existing objects, temporary
+ const ScPatternAttr* pOld2;
+
+ bool mbValidPatternId;
+ sal_uInt64 mnPatternId;
+
+ ScMergePatternState() : pOld1(nullptr), pOld2(nullptr),
+ mbValidPatternId(true), mnPatternId(0) {}
+};
+
+// we store an array of these where the pattern applies to all rows up till nEndRow
+struct ScAttrEntry
+{
+ SCROW nEndRow;
+ const ScPatternAttr* pPattern;
+ bool operator==( const ScAttrEntry& other ) const
+ {
+ return nEndRow == other.nEndRow && pPattern == other.pPattern;
+ }
+};
+
+class ScAttrArray
+{
+private:
+ SCCOL nCol;
+ SCTAB nTab;
+ ScDocument& rDocument;
+
+ std::vector<ScAttrEntry> mvData;
+
+friend class ScDocument; // for FillInfo
+friend class ScDocumentIterator;
+friend class ScAttrIterator;
+friend class ScHorizontalAttrIterator;
+
+ bool ApplyFrame( const SvxBoxItem& rLineOuter, const SvxBoxInfoItem* pLineInner,
+ SCROW nStartRow, SCROW nEndRow,
+ bool bLeft, SCCOL nDistRight, bool bTop, SCROW nDistBottom );
+
+ void RemoveCellCharAttribs( SCROW nStartRow, SCROW nEndRow,
+ const ScPatternAttr* pPattern, ScEditDataArray* pDataArray );
+ void SetDefaultIfNotInit( SCSIZE nNeeded = 1 );
+ bool HasAttrib_Impl(const ScPatternAttr* pPattern, HasAttrFlags nMask, SCROW nRow1, SCROW nRow2, SCSIZE i) const;
+
+ ScAttrArray(const ScAttrArray&) = delete;
+ ScAttrArray& operator=(const ScAttrArray&) = delete;
+
+public:
+ ScAttrArray( SCCOL nNewCol, SCTAB nNewTab, ScDocument& rDoc, ScAttrArray* pNextColAttrArray );
+ ~ScAttrArray();
+
+ ScDocument& GetDoc() { return rDocument; }
+ const ScDocument& GetDoc() const { return rDocument; }
+ void SetTab(SCTAB nNewTab) { nTab = nNewTab; }
+ void SetCol(SCCOL nNewCol) { nCol = nNewCol; }
+#if DEBUG_SC_TESTATTRARRAY
+ void TestData() const;
+#endif
+ void Reset( const ScPatternAttr* pPattern);
+ bool Concat(SCSIZE nPos);
+
+ const ScPatternAttr* GetPattern( SCROW nRow ) const;
+
+ /** Returns if you search for attributes at nRow the range from rStartRow
+ to rEndRow where that attribute combination (ScPatternAttr) is applied.
+ The next ScPatternAttr different from this one starts at rEndRow+1
+ (if that is <= MAXROW).
+ */
+ const ScPatternAttr* GetPatternRange( SCROW& rStartRow, SCROW& rEndRow, SCROW nRow ) const;
+
+ void MergePatternArea( SCROW nStartRow, SCROW nEndRow, ScMergePatternState& rState, bool bDeep ) const;
+
+ void MergeBlockFrame( SvxBoxItem* pLineOuter, SvxBoxInfoItem* pLineInner, ScLineFlags& rFlags,
+ SCROW nStartRow, SCROW nEndRow, bool bLeft, SCCOL nDistRight ) const;
+ void ApplyBlockFrame(const SvxBoxItem& rLineOuter, const SvxBoxInfoItem* pLineInner,
+ SCROW nStartRow, SCROW nEndRow, bool bLeft, SCCOL nDistRight);
+
+ void SetPattern( SCROW nRow, const ScPatternAttr* pPattern, bool bPutToPool = false )
+ { SetPatternAreaImpl(nRow, nRow, pPattern, bPutToPool, nullptr, /*bPassingOwnership*/false); }
+ const ScPatternAttr* SetPattern( SCROW nRow, std::unique_ptr<ScPatternAttr> pPattern, bool bPutToPool = false )
+ { return SetPatternAreaImpl(nRow, nRow, pPattern.release(), bPutToPool, nullptr, /*bPassingOwnership*/true); }
+ void SetPatternArea( SCROW nStartRow, SCROW nEndRow, std::unique_ptr<ScPatternAttr> pPattern,
+ bool bPutToPool = false, ScEditDataArray* pDataArray = nullptr)
+ { SetPatternAreaImpl(nStartRow, nEndRow, pPattern.release(), bPutToPool, pDataArray, /*bPassingOwnership*/true); }
+ void SetPatternArea( SCROW nStartRow, SCROW nEndRow, const ScPatternAttr* pPattern,
+ bool bPutToPool = false, ScEditDataArray* pDataArray = nullptr)
+ { SetPatternAreaImpl(nStartRow, nEndRow, pPattern, bPutToPool, pDataArray, /*bPassingOwnership*/false); }
+ void ApplyStyleArea( SCROW nStartRow, SCROW nEndRow, const ScStyleSheet& rStyle );
+ void ApplyCacheArea( SCROW nStartRow, SCROW nEndRow, SfxItemPoolCache* pCache,
+ ScEditDataArray* pDataArray = nullptr, bool* const pIsChanged = nullptr );
+ void SetAttrEntries(std::vector<ScAttrEntry> && vNewData);
+ void ApplyLineStyleArea( SCROW nStartRow, SCROW nEndRow,
+ const ::editeng::SvxBorderLine* pLine, bool bColorOnly );
+
+ void AddCondFormat( SCROW nStartRow, SCROW nEndRow, sal_uInt32 nIndex );
+ /// if nIndex == 0, remove all conditional format data
+ void RemoveCondFormat( SCROW nStartRow, SCROW nEndRow, sal_uInt32 nIndex );
+
+ void ClearItems( SCROW nStartRow, SCROW nEndRow, const sal_uInt16* pWhich );
+ void ChangeIndent( SCROW nStartRow, SCROW nEndRow, bool bIncrement );
+
+ /// Including current, may return -1
+ SCROW GetNextUnprotected( SCROW nRow, bool bUp ) const;
+
+ /// May return -1 if not found
+ SCROW SearchStyle(
+ SCROW nRow, const ScStyleSheet* pSearchStyle, bool bUp,
+ const ScMarkArray* pMarkArray = nullptr) const;
+
+ bool SearchStyleRange(
+ SCROW& rRow, SCROW& rEndRow, const ScStyleSheet* pSearchStyle, bool bUp,
+ const ScMarkArray* pMarkArray = nullptr) const;
+
+ bool ApplyFlags( SCROW nStartRow, SCROW nEndRow, ScMF nFlags );
+ bool RemoveFlags( SCROW nStartRow, SCROW nEndRow, ScMF nFlags );
+
+ bool Search( SCROW nRow, SCSIZE& nIndex ) const;
+
+ bool HasAttrib( SCROW nRow1, SCROW nRow2, HasAttrFlags nMask ) const;
+ bool HasAttrib( SCROW nRow, HasAttrFlags nMask, SCROW* nStartRow = nullptr, SCROW* nEndRow = nullptr ) const;
+ bool IsMerged( SCROW nRow ) const;
+ bool ExtendMerge( SCCOL nThisCol, SCROW nStartRow, SCROW nEndRow,
+ SCCOL& rPaintCol, SCROW& rPaintRow,
+ bool bRefresh );
+ void RemoveAreaMerge( SCROW nStartRow, SCROW nEndRow );
+
+ void FindStyleSheet( const SfxStyleSheetBase* pStyleSheet, ScFlatBoolRowSegments& rUsedRows, bool bReset );
+ bool IsStyleSheetUsed( const ScStyleSheet& rStyle ) const;
+
+ void SetPatternAreaSafe( SCROW nStartRow, SCROW nEndRow,
+ const ScPatternAttr* pWantedPattern, bool bDefault );
+ void CopyAreaSafe( SCROW nStartRow, SCROW nEndRow, tools::Long nDy, ScAttrArray& rAttrArray );
+
+ bool IsEmpty() const;
+
+ bool GetFirstVisibleAttr( SCROW& rFirstRow ) const;
+ bool GetLastVisibleAttr( SCROW& rLastRow, SCROW nLastData ) const;
+ bool HasVisibleAttrIn( SCROW nStartRow, SCROW nEndRow ) const;
+ bool IsVisibleEqual( const ScAttrArray& rOther,
+ SCROW nStartRow, SCROW nEndRow ) const;
+ bool IsAllEqual( const ScAttrArray& rOther, SCROW nStartRow, SCROW nEndRow ) const;
+
+ bool TestInsertCol( SCROW nStartRow, SCROW nEndRow) const;
+ bool TestInsertRow( SCSIZE nSize ) const;
+ void InsertRow( SCROW nStartRow, SCSIZE nSize );
+ void DeleteRow( SCROW nStartRow, SCSIZE nSize );
+ void DeleteRange( SCSIZE nStartIndex, SCSIZE nEndIndex );
+ void DeleteArea( SCROW nStartRow, SCROW nEndRow );
+ void MoveTo( SCROW nStartRow, SCROW nEndRow, ScAttrArray& rAttrArray );
+ void CopyArea(
+ SCROW nStartRow, SCROW nEndRow, tools::Long nDy, ScAttrArray& rAttrArray, ScMF nStripFlags = ScMF::NONE) const;
+
+ void DeleteHardAttr( SCROW nStartRow, SCROW nEndRow );
+
+ /* i123909: Pre-calculate needed memory, and pre-reserve enough memory */
+ bool Reserve( SCSIZE nReserve );
+ SCSIZE Count() const { return mvData.size(); }
+ SCSIZE Count( SCROW nRow1, SCROW nRow2 ) const;
+
+private:
+ const ScPatternAttr* SetPatternAreaImpl( SCROW nStartRow, SCROW nEndRow, const ScPatternAttr* pPattern,
+ bool bPutToPool = false, ScEditDataArray* pDataArray = nullptr,
+ bool bPassingPatternOwnership = false );
+};
+
+// Iterator for attributes
+
+class ScAttrIterator
+{
+ const ScAttrArray* pArray;
+ const ScPatternAttr* pDefPattern;
+ SCSIZE nPos;
+ SCROW nRow;
+ SCROW nEndRow;
+public:
+ inline ScAttrIterator( const ScAttrArray* pNewArray, SCROW nStart, SCROW nEnd, const ScPatternAttr* pDefaultPattern );
+ inline const ScPatternAttr* Next( SCROW& rTop, SCROW& rBottom );
+ inline const ScPatternAttr* Resync( SCROW nRow, SCROW& rTop, SCROW& rBottom );
+ SCROW GetNextRow() const { return nRow; }
+};
+
+inline ScAttrIterator::ScAttrIterator( const ScAttrArray* pNewArray, SCROW nStart, SCROW nEnd, const ScPatternAttr* pDefaultPattern ) :
+ pArray( pNewArray ),
+ pDefPattern( pDefaultPattern ),
+ nRow( nStart ),
+ nEndRow( nEnd )
+{
+ if ( pArray->Count() )
+ {
+ if ( nStart > 0 )
+ pArray->Search( nStart, nPos );
+ else
+ nPos = 0;
+ }
+ else
+ nPos = 0;
+}
+
+inline const ScPatternAttr* ScAttrIterator::Next( SCROW& rTop, SCROW& rBottom )
+{
+ const ScPatternAttr* pRet;
+ if ( !pArray->Count() )
+ {
+ if ( !nPos )
+ {
+ ++nPos;
+ if ( nRow > pArray->GetDoc().MaxRow())
+ return nullptr;
+ rTop = nRow;
+ rBottom = std::min( nEndRow, pArray->GetDoc().MaxRow());
+ nRow = rBottom + 1;
+ return pDefPattern;
+ }
+ return nullptr;
+ }
+
+ if ( nPos < pArray->Count() && nRow <= nEndRow )
+ {
+ rTop = nRow;
+ rBottom = std::min( pArray->mvData[nPos].nEndRow, nEndRow );
+ pRet = pArray->mvData[nPos].pPattern;
+ nRow = rBottom + 1;
+ ++nPos;
+ }
+ else
+ pRet = nullptr;
+ return pRet;
+}
+
+inline const ScPatternAttr* ScAttrIterator::Resync( SCROW nRowP, SCROW& rTop, SCROW& rBottom )
+{
+ nRow = nRowP;
+ if ( !pArray->Count() )
+ {
+ nPos = 0;
+ return Next( rTop, rBottom );
+ }
+ // Chances are high that the pattern changed on nRowP introduced a span
+ // starting right there. Assume that Next() was called so nPos already
+ // advanced. Another high chance is that the change extended a previous or
+ // next pattern. In all these cases we don't need to search.
+ if (3 <= nPos && nPos <= pArray->Count() && pArray->mvData[nPos-3].nEndRow < nRowP &&
+ nRowP <= pArray->mvData[nPos-2].nEndRow)
+ nPos -= 2;
+ else if (2 <= nPos && nPos <= pArray->Count() && pArray->mvData[nPos-2].nEndRow < nRowP &&
+ nRowP <= pArray->mvData[nPos-1].nEndRow)
+ --nPos;
+ else if (pArray->Count() > 0 && nRowP <= pArray->mvData[0].nEndRow)
+ nPos = 0;
+ else
+ pArray->Search( nRowP, nPos );
+ return Next( rTop, rBottom);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */