sc/inc/attarray.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #ifndef INCLUDED_SC_INC_ATTARRAY_HXX
  21 #define INCLUDED_SC_INC_ATTARRAY_HXX
  22
  23 #include "global.hxx"
  24 #include "attrib.hxx"
  25 #include "patattr.hxx"
  26
  27 #include <algorithm>
  28 #include <memory>
  29
  30 #include <svl/itemset.hxx>
  31
  32 class ScDocument;
  33 class ScEditDataArray;
  34 class ScMarkArray;
  35 class ScStyleSheet;
  36 class ScFlatBoolRowSegments;
  37
  38 class SfxItemPoolCache;
  39 class SfxStyleSheetBase;
  40 class SvxBoxItem;
  41 class SvxBoxInfoItem;
  42
  43 namespace editeng { class SvxBorderLine; }
  44
  45 #define SC_LINE_EMPTY           0
  46 #define SC_LINE_SET             1
  47 #define SC_LINE_DONTCARE        2
  48
  49 #define SC_ATTRARRAY_DELTA      4
  50
  51 #define DEBUG_SC_TESTATTRARRAY 0
  52
  53 struct ScLineFlags
  54 {
  55     sal_uInt8   nLeft;
  56     sal_uInt8   nRight;
  57     sal_uInt8   nTop;
  58     sal_uInt8   nBottom;
  59     sal_uInt8   nHori;
  60     sal_uInt8   nVert;
  61
  62     ScLineFlags() : nLeft(SC_LINE_EMPTY),nRight(SC_LINE_EMPTY),nTop(SC_LINE_EMPTY),
  63                     nBottom(SC_LINE_EMPTY),nHori(SC_LINE_EMPTY),nVert(SC_LINE_EMPTY) {}
  64 };
  65
  66 struct ScMergePatternState
  67 {
  68     std::unique_ptr<SfxItemSet> pItemSet;
  69     const ScPatternAttr* pOld1;     ///< existing objects, temporary
  70     const ScPatternAttr* pOld2;
  71
  72     bool mbValidPatternId;
  73     sal_uInt64 mnPatternId;
  74
  75     ScMergePatternState() : pOld1(nullptr), pOld2(nullptr),
  76                         mbValidPatternId(true), mnPatternId(0) {}
  77 };
  78
  79 // we store an array of these where the pattern applies to all rows up till nEndRow
  80 struct ScAttrEntry
  81 {
  82     SCROW                   nEndRow;
  83     const ScPatternAttr*    pPattern;
  84 };
  85
  86 class ScAttrArray
  87 {
  88 private:
  89     SCCOL           nCol;
  90     SCTAB           nTab;
  91     ScDocument* const     pDocument;
  92
  93     std::vector<ScAttrEntry> mvData;
  94
  95 friend class ScDocument;                // for FillInfo
  96 friend class ScDocumentIterator;
  97 friend class ScAttrIterator;
  98 friend class ScHorizontalAttrIterator;
  99
 100     bool    ApplyFrame( const SvxBoxItem* pLineOuter, const SvxBoxInfoItem* pLineInner,
 101                             SCROW nStartRow, SCROW nEndRow,
 102                             bool bLeft, SCCOL nDistRight, bool bTop, SCROW nDistBottom );
 103
 104     void RemoveCellCharAttribs( SCROW nStartRow, SCROW nEndRow,
 105                               const ScPatternAttr* pPattern, ScEditDataArray* pDataArray );
 106     void SetDefaultIfNotInit( SCSIZE nNeeded = 1 );
 107     bool HasAttrib_Impl(const ScPatternAttr* pPattern, HasAttrFlags nMask, SCROW nRow1, SCROW nRow2, SCSIZE i) const;
 108
 109     ScAttrArray(const ScAttrArray&) = delete;
 110     ScAttrArray& operator=(const ScAttrArray&) = delete;
 111
 112 public:
 113             ScAttrArray( SCCOL nNewCol, SCTAB nNewTab, ScDocument* pDoc, ScAttrArray* pNextColAttrArray );
 114             ~ScAttrArray();
 115
 116     ScDocument* GetDoc() { return pDocument; }
 117     void    SetTab(SCTAB nNewTab)   { nTab = nNewTab; }
 118     void    SetCol(SCCOL nNewCol)   { nCol = nNewCol; }
 119 #if DEBUG_SC_TESTATTRARRAY
 120     void    TestData() const;
 121 #endif
 122     void    Reset( const ScPatternAttr* pPattern);
 123     bool    Concat(SCSIZE nPos);
 124
 125     const ScPatternAttr* GetPattern( SCROW nRow ) const;
 126
 127     /** Returns if you search for attributes at nRow the range from rStartRow
 128         to rEndRow where that attribute combination (ScPatternAttr) is applied.
 129         The next ScPatternAttr different from this one starts at rEndRow+1
 130         (if that is <= MAXROW).
 131      */
 132     const ScPatternAttr* GetPatternRange( SCROW& rStartRow, SCROW& rEndRow, SCROW nRow ) const;
 133
 134     void    MergePatternArea( SCROW nStartRow, SCROW nEndRow, ScMergePatternState& rState, bool bDeep ) const;
 135
 136     void    MergeBlockFrame( SvxBoxItem* pLineOuter, SvxBoxInfoItem* pLineInner, ScLineFlags& rFlags,
 137                             SCROW nStartRow, SCROW nEndRow, bool bLeft, SCCOL nDistRight ) const;
 138     void    ApplyBlockFrame(const SvxBoxItem& rLineOuter, const SvxBoxInfoItem* pLineInner,
 139                             SCROW nStartRow, SCROW nEndRow, bool bLeft, SCCOL nDistRight);
 140
 141     void    SetPattern( SCROW nRow, const ScPatternAttr* pPattern, bool bPutToPool = false )
 142     { SetPatternAreaImpl(nRow, nRow, pPattern, bPutToPool, nullptr, /*bPassingOwnership*/false); }
 143     const ScPatternAttr* SetPattern( SCROW nRow, std::unique_ptr<ScPatternAttr> pPattern, bool bPutToPool = false )
 144     { return SetPatternAreaImpl(nRow, nRow, pPattern.release(), bPutToPool, nullptr, /*bPassingOwnership*/true); }
 145     void    SetPatternArea( SCROW nStartRow, SCROW nEndRow, std::unique_ptr<ScPatternAttr> pPattern,
 146                             bool bPutToPool = false, ScEditDataArray* pDataArray = nullptr)
 147     { SetPatternAreaImpl(nStartRow, nEndRow, pPattern.release(), bPutToPool, pDataArray, /*bPassingOwnership*/true); }
 148     void    SetPatternArea( SCROW nStartRow, SCROW nEndRow, const ScPatternAttr* pPattern,
 149                             bool bPutToPool = false, ScEditDataArray* pDataArray = nullptr)
 150     { SetPatternAreaImpl(nStartRow, nEndRow, pPattern, bPutToPool, pDataArray, /*bPassingOwnership*/false); }
 151     void    ApplyStyleArea( SCROW nStartRow, SCROW nEndRow, const ScStyleSheet& rStyle );
 152     void    ApplyCacheArea( SCROW nStartRow, SCROW nEndRow, SfxItemPoolCache* pCache,
 153                             ScEditDataArray* pDataArray = nullptr, bool* const pIsChanged = nullptr );
 154     void    SetAttrEntries(std::vector<ScAttrEntry> && vNewData);
 155     void    ApplyLineStyleArea( SCROW nStartRow, SCROW nEndRow,
 156                                 const ::editeng::SvxBorderLine* pLine, bool bColorOnly );
 157
 158     void    AddCondFormat( SCROW nStartRow, SCROW nEndRow, sal_uInt32 nIndex );
 159     /// if nIndex == 0, remove all conditional format data
 160     void    RemoveCondFormat( SCROW nStartRow, SCROW nEndRow, sal_uInt32 nIndex );
 161
 162     void    ClearItems( SCROW nStartRow, SCROW nEndRow, const sal_uInt16* pWhich );
 163     void    ChangeIndent( SCROW nStartRow, SCROW nEndRow, bool bIncrement );
 164
 165             /// Including current, may return -1
 166     SCROW  GetNextUnprotected( SCROW nRow, bool bUp ) const;
 167
 168             /// May return -1 if not found
 169     SCROW SearchStyle(
 170         SCROW nRow, const ScStyleSheet* pSearchStyle, bool bUp,
 171         const ScMarkArray* pMarkArray = nullptr) const;
 172
 173     bool SearchStyleRange(
 174         SCROW& rRow, SCROW& rEndRow, const ScStyleSheet* pSearchStyle, bool bUp,
 175         const ScMarkArray* pMarkArray = nullptr) const;
 176
 177     bool    ApplyFlags( SCROW nStartRow, SCROW nEndRow, ScMF nFlags );
 178     bool    RemoveFlags( SCROW nStartRow, SCROW nEndRow, ScMF nFlags );
 179
 180     bool    Search( SCROW nRow, SCSIZE& nIndex ) const;
 181
 182     bool    HasAttrib( SCROW nRow1, SCROW nRow2, HasAttrFlags nMask ) const;
 183     bool    IsMerged( SCROW nRow ) const;
 184     bool    ExtendMerge( SCCOL nThisCol, SCROW nStartRow, SCROW nEndRow,
 185                                 SCCOL& rPaintCol, SCROW& rPaintRow,
 186                                 bool bRefresh );
 187     void    RemoveAreaMerge( SCROW nStartRow, SCROW nEndRow );
 188
 189     void    FindStyleSheet( const SfxStyleSheetBase* pStyleSheet, ScFlatBoolRowSegments& rUsedRows, bool bReset );
 190     bool    IsStyleSheetUsed( const ScStyleSheet& rStyle ) const;
 191
 192     void    SetPatternAreaSafe( SCROW nStartRow, SCROW nEndRow,
 193                                     const ScPatternAttr* pWantedPattern, bool bDefault );
 194     void    CopyAreaSafe( SCROW nStartRow, SCROW nEndRow, long nDy, ScAttrArray& rAttrArray );
 195
 196     bool    IsEmpty() const;
 197
 198     bool    GetFirstVisibleAttr( SCROW& rFirstRow ) const;
 199     bool    GetLastVisibleAttr( SCROW& rLastRow, SCROW nLastData ) const;
 200     bool    HasVisibleAttrIn( SCROW nStartRow, SCROW nEndRow ) const;
 201     bool    IsVisibleEqual( const ScAttrArray& rOther,
 202                             SCROW nStartRow, SCROW nEndRow ) const;
 203     bool    IsAllEqual( const ScAttrArray& rOther, SCROW nStartRow, SCROW nEndRow ) const;
 204
 205     bool    TestInsertCol( SCROW nStartRow, SCROW nEndRow) const;
 206     bool    TestInsertRow( SCSIZE nSize ) const;
 207     void    InsertRow( SCROW nStartRow, SCSIZE nSize );
 208     void    DeleteRow( SCROW nStartRow, SCSIZE nSize );
 209     void    DeleteRange( SCSIZE nStartIndex, SCSIZE nEndIndex );
 210     void    DeleteArea( SCROW nStartRow, SCROW nEndRow );
 211     void    MoveTo( SCROW nStartRow, SCROW nEndRow, ScAttrArray& rAttrArray );
 212     void    CopyArea(
 213         SCROW nStartRow, SCROW nEndRow, long nDy, ScAttrArray& rAttrArray, ScMF nStripFlags = ScMF::NONE) const;
 214
 215     void    DeleteHardAttr( SCROW nStartRow, SCROW nEndRow );
 216
 217     /* i123909: Pre-calculate needed memory, and pre-reserve enough memory */
 218     bool    Reserve( SCSIZE nReserve );
 219     SCSIZE  Count() const { return mvData.size(); }
 220     SCSIZE  Count( SCROW nRow1, SCROW nRow2 ) const;
 221
 222 private:
 223     const ScPatternAttr* SetPatternAreaImpl( SCROW nStartRow, SCROW nEndRow, const ScPatternAttr* pPattern,
 224                             bool bPutToPool = false, ScEditDataArray* pDataArray = nullptr,
 225                             bool bPassingPatternOwnership = false );
 226 };
 227
 228 //                              Iterator for attributes
 229
 230 class ScAttrIterator
 231 {
 232     const ScAttrArray*  pArray;
 233     const ScPatternAttr* pDefPattern;
 234     SCSIZE              nPos;
 235     SCROW               nRow;
 236     SCROW const         nEndRow;
 237 public:
 238     inline              ScAttrIterator( const ScAttrArray* pNewArray, SCROW nStart, SCROW nEnd, const ScPatternAttr* pDefaultPattern );
 239     inline const ScPatternAttr* Next( SCROW& rTop, SCROW& rBottom );
 240     inline const ScPatternAttr* Resync( SCROW nRow, SCROW& rTop, SCROW& rBottom );
 241     SCROW               GetNextRow() const { return nRow; }
 242 };
 243
 244 inline ScAttrIterator::ScAttrIterator( const ScAttrArray* pNewArray, SCROW nStart, SCROW nEnd, const ScPatternAttr* pDefaultPattern ) :
 245     pArray( pNewArray ),
 246     pDefPattern( pDefaultPattern ),
 247     nRow( nStart ),
 248     nEndRow( nEnd )
 249 {
 250     if ( pArray->Count() )
 251     {
 252         if ( nStart > 0 )
 253             pArray->Search( nStart, nPos );
 254         else
 255             nPos = 0;
 256     }
 257     else
 258         nPos = 0;
 259 }
 260
 261 inline const ScPatternAttr* ScAttrIterator::Next( SCROW& rTop, SCROW& rBottom )
 262 {
 263     const ScPatternAttr* pRet;
 264     if ( !pArray->Count() )
 265     {
 266         if ( !nPos )
 267         {
 268             ++nPos;
 269             if ( nRow > MAXROW )
 270                 return nullptr;
 271             rTop = nRow;
 272             rBottom = std::min( nEndRow, MAXROW );
 273             nRow = rBottom + 1;
 274             return pDefPattern;
 275         }
 276         return nullptr;
 277     }
 278
 279     if ( nPos < pArray->Count() && nRow <= nEndRow )
 280     {
 281         rTop = nRow;
 282         rBottom = std::min( pArray->mvData[nPos].nEndRow, nEndRow );
 283         pRet = pArray->mvData[nPos].pPattern;
 284         nRow = rBottom + 1;
 285         ++nPos;
 286     }
 287     else
 288         pRet = nullptr;
 289     return pRet;
 290 }
 291
 292 inline const ScPatternAttr* ScAttrIterator::Resync( SCROW nRowP, SCROW& rTop, SCROW& rBottom )
 293 {
 294     nRow = nRowP;
 295     if ( !pArray->Count() )
 296     {
 297         nPos = 0;
 298         return Next( rTop, rBottom );
 299     }
 300     // Chances are high that the pattern changed on nRowP introduced a span
 301     // starting right there. Assume that Next() was called so nPos already
 302     // advanced. Another high chance is that the change extended a previous or
 303     // next pattern. In all these cases we don't need to search.
 304     if (3 <= nPos && nPos <= pArray->Count() && pArray->mvData[nPos-3].nEndRow < nRowP &&
 305             nRowP <= pArray->mvData[nPos-2].nEndRow)
 306         nPos -= 2;
 307     else if (2 <= nPos && nPos <= pArray->Count() && pArray->mvData[nPos-2].nEndRow < nRowP &&
 308             nRowP <= pArray->mvData[nPos-1].nEndRow)
 309         --nPos;
 310     else if (pArray->Count() > 0 && nRowP <= pArray->mvData[0].nEndRow)
 311         nPos = 0;
 312     else
 313         pArray->Search( nRowP, nPos );
 314     return Next( rTop, rBottom);
 315 }
 316
 317 #endif
 318
 319 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */