    /* -*- 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 .
     */

    #include <algorithm>
    #include <memory>
    #include <table.hxx>
    #include <patattr.hxx>
    #include <docpool.hxx>
    #include <formulacell.hxx>
    #include <document.hxx>
    #include <drwlayer.hxx>
    #include <olinetab.hxx>
    #include <rechead.hxx>
    #include <stlpool.hxx>
    #include <attarray.hxx>
    #include <markdata.hxx>
    #include <progress.hxx>
    #include <dociter.hxx>
    #include <conditio.hxx>
    #include <chartlis.hxx>
    #include <fillinfo.hxx>
    #include <bcaslot.hxx>
    #include <postit.hxx>
    #include <sheetevents.hxx>
    #include <segmenttree.hxx>
    #include <queryparam.hxx>
    #include <queryentry.hxx>
    #include <dbdata.hxx>
    #include <colorscale.hxx>
    #include <tokenarray.hxx>
    #include <clipcontext.hxx>
    #include <types.hxx>
    #include <editutil.hxx>
    #include <mtvcellfunc.hxx>
    #include <refupdatecontext.hxx>
    #include <scopetools.hxx>
    #include <tabprotection.hxx>
    #include <columnspanset.hxx>
    #include <rowheightcontext.hxx>
    #include <refhint.hxx>
    #include <listenercontext.hxx>
    #include <token.hxx>
    #include <compressedarray.hxx>
    #include <brdcst.hxx>

    #include <scitems.hxx>
    #include <editeng/boxitem.hxx>
    #include <editeng/editobj.hxx>
    #include <svl/poolcach.hxx>
    #include <unotools/charclass.hxx>
    #include <math.h>
    #include <svl/PasswordHelper.hxx>
    #include <unotools/transliterationwrapper.hxx>

    namespace {

    class ColumnRegroupFormulaCells
    {
        ScColContainer& mrCols;
        std::vector<ScAddress>* mpGroupPos;

    public:
        ColumnRegroupFormulaCells( ScColContainer& rCols, std::vector<ScAddress>* pGroupPos ) :
            mrCols(rCols), mpGroupPos(pGroupPos) {}

        void operator() (SCCOL nCol)
        {
            mrCols[nCol].RegroupFormulaCells(mpGroupPos);
        }
    };

    }

    sal_uInt16 ScTable::GetTextWidth(SCCOL nCol, SCROW nRow) const
    {
        return aCol[nCol].GetTextWidth(nRow);
    }

    bool ScTable::SetOutlineTable( const ScOutlineTable* pNewOutline )
    {
        sal_uInt16 nOldSizeX = 0;
        sal_uInt16 nOldSizeY = 0;
        sal_uInt16 nNewSizeX = 0;
        sal_uInt16 nNewSizeY = 0;

        if (pOutlineTable)
        {
            nOldSizeX = pOutlineTable->GetColArray().GetDepth();
            nOldSizeY = pOutlineTable->GetRowArray().GetDepth();
            pOutlineTable.reset();
        }

        if (pNewOutline)
        {
            pOutlineTable.reset(new ScOutlineTable( *pNewOutline ));
            nNewSizeX = pOutlineTable->GetColArray().GetDepth();
            nNewSizeY = pOutlineTable->GetRowArray().GetDepth();
        }

        return ( nNewSizeX != nOldSizeX || nNewSizeY != nOldSizeY );        // changed size?
    }

    void ScTable::StartOutlineTable()
    {
        if (!pOutlineTable)
            pOutlineTable.reset(new ScOutlineTable);
    }

    void ScTable::SetSheetEvents( std::unique_ptr<ScSheetEvents> pNew )
    {
        pSheetEvents = std::move(pNew);

        SetCalcNotification( false );       // discard notifications before the events were set

        SetStreamValid(false);
    }

    void ScTable::SetCalcNotification( bool bSet )
    {
        bCalcNotification = bSet;
    }

    bool ScTable::TestInsertRow( SCCOL nStartCol, SCCOL nEndCol, SCROW nStartRow, SCSIZE nSize ) const
    {
        bool bTest = true;

        if ( nStartCol==0 && nEndCol==MAXCOL && pOutlineTable )
            bTest = pOutlineTable->TestInsertRow(nSize);

        for (SCCOL i=nStartCol; (i<=nEndCol) && bTest; i++)
            bTest = aCol[i].TestInsertRow(nStartRow, nSize);

        return bTest;
    }

    void ScTable::InsertRow( SCCOL nStartCol, SCCOL nEndCol, SCROW nStartRow, SCSIZE nSize )
    {
        if (nStartCol==0 && nEndCol==MAXCOL)
        {
            if (mpRowHeights && pRowFlags)
            {
                mpRowHeights->insertSegment(nStartRow, nSize);
                CRFlags nNewFlags = pRowFlags->Insert( nStartRow, nSize);
                // only copy manual size flag, clear all others
                if (nNewFlags != CRFlags::NONE && (nNewFlags != CRFlags::ManualSize))
                    pRowFlags->SetValue( nStartRow, nStartRow + nSize - 1,
                            nNewFlags & CRFlags::ManualSize);
            }

            if (pOutlineTable)
                pOutlineTable->InsertRow( nStartRow, nSize );

            mpFilteredRows->insertSegment(nStartRow, nSize);
            mpHiddenRows->insertSegment(nStartRow, nSize);

            if (!maRowManualBreaks.empty())
            {
                // Copy all breaks up to nStartRow (non-inclusive).
                ::std::set<SCROW>::iterator itr1 = maRowManualBreaks.lower_bound(nStartRow);
                ::std::set<SCROW> aNewBreaks(maRowManualBreaks.begin(), itr1);

                // Copy all breaks from nStartRow (inclusive) to the last element,
                // but add nSize to each value.
                ::std::set<SCROW>::iterator itr2 = maRowManualBreaks.end();
                for (; itr1 != itr2; ++itr1)
                    aNewBreaks.insert(static_cast<SCROW>(*itr1 + nSize));

                maRowManualBreaks.swap(aNewBreaks);
            }
        }

        for (SCCOL j=nStartCol; j<=nEndCol; j++)
            aCol[j].InsertRow( nStartRow, nSize );

        mpCondFormatList->InsertRow(nTab, nStartCol, nEndCol, nStartRow, nSize);

        InvalidatePageBreaks();

        // TODO: In the future we may want to check if the table has been
        // really modified before setting the stream invalid.
        SetStreamValid(false);
    }

    void ScTable::DeleteRow(
        const sc::ColumnSet& rRegroupCols, SCCOL nStartCol, SCCOL nEndCol, SCROW nStartRow, SCSIZE nSize,
        bool* pUndoOutline, std::vector<ScAddress>* pGroupPos )
    {
        if (nStartCol==0 && nEndCol==MAXCOL)
        {
            if (pRowFlags)
                pRowFlags->Remove( nStartRow, nSize);

            if (mpRowHeights)
                mpRowHeights->removeSegment(nStartRow, nStartRow+nSize);

            if (pOutlineTable)
                if (pOutlineTable->DeleteRow( nStartRow, nSize ))
                    if (pUndoOutline)
                        *pUndoOutline = true;

            mpFilteredRows->removeSegment(nStartRow, nStartRow+nSize);
            mpHiddenRows->removeSegment(nStartRow, nStartRow+nSize);

            if (!maRowManualBreaks.empty())
            {
                // Erase all manual breaks between nStartRow and nStartRow + nSize - 1 (inclusive).
                std::set<SCROW>::iterator itr1 = maRowManualBreaks.lower_bound(nStartRow);
                std::set<SCROW>::iterator itr2 = maRowManualBreaks.upper_bound(static_cast<SCROW>(nStartRow + nSize - 1));
                maRowManualBreaks.erase(itr1, itr2);

                // Copy all breaks from the 1st element up to nStartRow to the new container.
                itr1 = maRowManualBreaks.lower_bound(nStartRow);
                ::std::set<SCROW> aNewBreaks(maRowManualBreaks.begin(), itr1);

                // Copy all breaks from nStartRow to the last element, but subtract each value by nSize.
                itr2 = maRowManualBreaks.end();
                for (; itr1 != itr2; ++itr1)
                    aNewBreaks.insert(static_cast<SCROW>(*itr1 - nSize));

                maRowManualBreaks.swap(aNewBreaks);
            }
        }

        {   // scope for bulk broadcast
            ScBulkBroadcast aBulkBroadcast( pDocument->GetBASM(), SfxHintId::ScDataChanged);
            for (SCCOL j=nStartCol; j<=nEndCol; j++)
                aCol[j].DeleteRow(nStartRow, nSize, pGroupPos);
        }

        std::vector<SCCOL> aRegroupCols;
        rRegroupCols.getColumns(nTab, aRegroupCols);
        std::for_each(
            aRegroupCols.begin(), aRegroupCols.end(), ColumnRegroupFormulaCells(aCol, pGroupPos));

        InvalidatePageBreaks();

        // TODO: In the future we may want to check if the table has been
        // really modified before setting the stream invalid.
        SetStreamValid(false);
    }

    bool ScTable::TestInsertCol( SCROW nStartRow, SCROW nEndRow, SCSIZE nSize ) const
    {
        if ( nSize > static_cast<SCSIZE>(MAXCOL) )
            return false;

        if ( nStartRow==0 && nEndRow==MAXROW && pOutlineTable
            && ! pOutlineTable->TestInsertCol(nSize) )
                return false;

        auto range = GetColumnsRange( MAXCOL - static_cast<SCCOL>(nSize) + 1, MAXCOL );
        for (auto it = range.rbegin(); it != range.rend(); ++it )
            if (! aCol[*it].TestInsertCol(nStartRow, nEndRow))
                return false;

        return true;
    }

    void ScTable::InsertCol(
        const sc::ColumnSet& rRegroupCols, SCCOL nStartCol, SCROW nStartRow, SCROW nEndRow, SCSIZE nSize )
    {
        if (nStartRow==0 && nEndRow==MAXROW)
        {
            if (mpColWidth && mpColFlags)
            {
                mpColWidth->InsertPreservingSize(nStartCol, nSize, STD_COL_WIDTH);
                // The inserted columns have the same widths as the columns, which were selected for insert.
                for (SCSIZE i=0; i < std::min(MAXCOL-nSize-nStartCol, nSize); ++i)
                    mpColWidth->SetValue(nStartCol + i, mpColWidth->GetValue(nStartCol+i+nSize));
                mpColFlags->InsertPreservingSize(nStartCol, nSize, CRFlags::NONE);
            }
            if (pOutlineTable)
                pOutlineTable->InsertCol( nStartCol, nSize );

            mpHiddenCols->insertSegment(nStartCol, static_cast<SCCOL>(nSize));
            mpFilteredCols->insertSegment(nStartCol, static_cast<SCCOL>(nSize));

            if (!maColManualBreaks.empty())
            {
                // Copy all breaks up to nStartCol (non-inclusive).
                ::std::set<SCCOL>::iterator itr1 = maColManualBreaks.lower_bound(nStartCol);
                ::std::set<SCCOL> aNewBreaks(maColManualBreaks.begin(), itr1);

                // Copy all breaks from nStartCol (inclusive) to the last element,
                // but add nSize to each value.
                ::std::set<SCCOL>::iterator itr2 = maColManualBreaks.end();
                for (; itr1 != itr2; ++itr1)
                    aNewBreaks.insert(static_cast<SCCOL>(*itr1 + nSize));

                maColManualBreaks.swap(aNewBreaks);
            }
        }

        if ((nStartRow == 0) && (nEndRow == MAXROW))
        {
            for (SCSIZE i=0; i < nSize; i++)
                for (SCCOL nCol = aCol.size() - 1; nCol > nStartCol; nCol--)
                    aCol[nCol].SwapCol(aCol[nCol-1]);
        }
        else
        {
            for (SCSIZE i=0; static_cast<SCCOL>(i+nSize)+nStartCol < aCol.size(); i++)
                aCol[aCol.size() - 1 - nSize - i].MoveTo(nStartRow, nEndRow, aCol[aCol.size() - 1 - i]);
        }

        std::vector<SCCOL> aRegroupCols;
        rRegroupCols.getColumns(nTab, aRegroupCols);
        std::for_each(aRegroupCols.begin(), aRegroupCols.end(), ColumnRegroupFormulaCells(aCol, nullptr));

        if (nStartCol>0)                        // copy old attributes
        {
            sal_uInt16 nWhichArray[2];
            nWhichArray[0] = ATTR_MERGE;
            nWhichArray[1] = 0;

            sc::CopyToDocContext aCxt(*pDocument);
            for (SCSIZE i=0; i<nSize; i++)
            {
                aCol[nStartCol-1].CopyToColumn(aCxt, nStartRow, nEndRow, InsertDeleteFlags::ATTRIB,
                                                    false, aCol[nStartCol+i] );
                aCol[nStartCol+i].RemoveFlags( nStartRow, nEndRow,
                                                    ScMF::Hor | ScMF::Ver | ScMF::Auto );
                aCol[nStartCol+i].ClearItems( nStartRow, nEndRow, nWhichArray );
            }
        }

        mpCondFormatList->InsertCol(nTab, nStartRow, nEndRow, nStartCol, nSize);

        InvalidatePageBreaks();

        // TODO: In the future we may want to check if the table has been
        // really modified before setting the stream invalid.
        SetStreamValid(false);
    }

    void ScTable::DeleteCol(
        const sc::ColumnSet& rRegroupCols, SCCOL nStartCol, SCROW nStartRow, SCROW nEndRow, SCSIZE nSize, bool* pUndoOutline )
    {
        if (nStartRow==0 && nEndRow==MAXROW)
        {
            if (mpColWidth && mpColFlags)
            {
                assert( nStartCol + nSize <= MAXCOL+1 );    // moving 0 if ==MAXCOL+1 is correct
                mpColWidth->RemovePreservingSize(nStartCol, nSize, STD_COL_WIDTH);
                mpColFlags->RemovePreservingSize(nStartCol, nSize, CRFlags::NONE);
            }
            if (pOutlineTable)
                if (pOutlineTable->DeleteCol( nStartCol, nSize ))
                    if (pUndoOutline)
                        *pUndoOutline = true;

            SCCOL nRmSize = nStartCol + static_cast<SCCOL>(nSize);
            mpHiddenCols->removeSegment(nStartCol, nRmSize);
            mpFilteredCols->removeSegment(nStartCol, nRmSize);

            if (!maColManualBreaks.empty())
            {
                // Erase all manual breaks between nStartCol and nStartCol + nSize - 1 (inclusive).
                std::set<SCCOL>::iterator itr1 = maColManualBreaks.lower_bound(nStartCol);
                std::set<SCCOL>::iterator itr2 = maColManualBreaks.upper_bound(static_cast<SCCOL>(nStartCol + nSize - 1));
                maColManualBreaks.erase(itr1, itr2);

                // Copy all breaks from the 1st element up to nStartCol to the new container.
                itr1 = maColManualBreaks.lower_bound(nStartCol);
                ::std::set<SCCOL> aNewBreaks(maColManualBreaks.begin(), itr1);

                // Copy all breaks from nStartCol to the last element, but subtract each value by nSize.
                itr2 = maColManualBreaks.end();
                for (; itr1 != itr2; ++itr1)
                    aNewBreaks.insert(static_cast<SCCOL>(*itr1 - nSize));

                maColManualBreaks.swap(aNewBreaks);
            }
        }

        for (SCSIZE i = 0; i < nSize; i++)
            aCol[nStartCol + i].DeleteArea(nStartRow, nEndRow, InsertDeleteFlags::ALL, false);

        if ((nStartRow == 0) && (nEndRow == MAXROW))
        {
            for (SCSIZE i=0; i < nSize; i++)
                for (SCCOL nCol = nStartCol; nCol < aCol.size() - 1; nCol++)
                    aCol[nCol].SwapCol(aCol[nCol+1]);
        }
        else
        {
            for (SCSIZE i=0; static_cast<SCCOL>(i+nSize)+nStartCol < aCol.size(); i++)
                aCol[nStartCol + nSize + i].MoveTo(nStartRow, nEndRow, aCol[nStartCol + i]);
        }

        std::vector<SCCOL> aRegroupCols;
        rRegroupCols.getColumns(nTab, aRegroupCols);
        std::for_each(aRegroupCols.begin(), aRegroupCols.end(), ColumnRegroupFormulaCells(aCol, nullptr));

        InvalidatePageBreaks();

        // TODO: In the future we may want to check if the table has been
        // really modified before setting the stream invalid.
        SetStreamValid(false);
    }

    void ScTable::DeleteArea(
        SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, InsertDeleteFlags nDelFlag,
        bool bBroadcast, sc::ColumnSpanSet* pBroadcastSpans )
    {
        if ( nCol2 >= aCol.size() ) nCol2 = aCol.size() - 1;
        if (nRow2 > MAXROW) nRow2 = MAXROW;
        if (ValidColRow(nCol1, nRow1) && ValidColRow(nCol2, nRow2))
        {
            {   // scope for bulk broadcast
                ScBulkBroadcast aBulkBroadcast( pDocument->GetBASM(), SfxHintId::ScDataChanged);
                for (SCCOL i = nCol1; i <= nCol2; i++)
                    aCol[i].DeleteArea(nRow1, nRow2, nDelFlag, bBroadcast, pBroadcastSpans);
            }

                // Do not set protected cell in a protected table

            if ( IsProtected() && (nDelFlag & InsertDeleteFlags::ATTRIB) )
            {
                ScPatternAttr aPattern(pDocument->GetPool());
                aPattern.GetItemSet().Put( ScProtectionAttr( false ) );
                ApplyPatternArea( nCol1, nRow1, nCol2, nRow2, aPattern );
            }

            if( nDelFlag & InsertDeleteFlags::ATTRIB )
                mpCondFormatList->DeleteArea( nCol1, nRow1, nCol2, nRow2 );
        }

        // TODO: In the future we may want to check if the table has been
        // really modified before setting the stream invalid.
        SetStreamValid(false);
    }

    void ScTable::DeleteSelection( InsertDeleteFlags nDelFlag, const ScMarkData& rMark, bool bBroadcast )
    {
        {   // scope for bulk broadcast
            ScBulkBroadcast aBulkBroadcast( pDocument->GetBASM(), SfxHintId::ScDataChanged);
            for (SCCOL i=0; i < aCol.size(); i++)
                aCol[i].DeleteSelection(nDelFlag, rMark, bBroadcast);
        }

        ScRangeList aRangeList;
        rMark.FillRangeListWithMarks(&aRangeList, false);

        for (size_t i = 0; i < aRangeList.size(); ++i)
        {
            const ScRange & rRange = aRangeList[i];

            if((nDelFlag & InsertDeleteFlags::ATTRIB) && rRange.aStart.Tab() == nTab)
                mpCondFormatList->DeleteArea( rRange.aStart.Col(), rRange.aStart.Row(), rRange.aEnd.Col(), rRange.aEnd.Row() );
        }

            // Do not set protected cell in a protected sheet

        if ( IsProtected() && (nDelFlag & InsertDeleteFlags::ATTRIB) )
        {
            ScDocumentPool* pPool = pDocument->GetPool();
            SfxItemSet aSet( *pPool, svl::Items<ATTR_PATTERN_START, ATTR_PATTERN_END>{} );
            aSet.Put( ScProtectionAttr( false ) );
            SfxItemPoolCache aCache( pPool, &aSet );
            ApplySelectionCache( &aCache, rMark );
        }

        // TODO: In the future we may want to check if the table has been
        // really modified before setting the stream invalid.
        SetStreamValid(false);
    }

    // pTable = Clipboard
    void ScTable::CopyToClip(
        sc::CopyToClipContext& rCxt, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
        ScTable* pTable )
    {
        if (!ValidColRow(nCol1, nRow1) || !ValidColRow(nCol2, nRow2))
            return;

        //  copy content
        //local range names need to be copied first for formula cells
        if (!pTable->mpRangeName && mpRangeName)
            pTable->mpRangeName.reset( new ScRangeName(*mpRangeName) );

        SCCOL i;

        for ( i = nCol1; i <= nCol2; i++)
            aCol[i].CopyToClip(rCxt, nRow1, nRow2, pTable->aCol[i]);  // notes are handled at column level

        //  copy widths/heights, and only "hidden", "filtered" and "manual" flags
        //  also for all preceding columns/rows, to have valid positions for drawing objects

        if (mpColWidth && pTable->mpColWidth)
            pTable->mpColWidth->CopyFrom(*mpColWidth, 0, nCol2);

        pTable->CopyColHidden(*this, 0, nCol2);
        pTable->CopyColFiltered(*this, 0, nCol2);
        if (pDBDataNoName)
            pTable->SetAnonymousDBData(std::unique_ptr<ScDBData>(new ScDBData(*pDBDataNoName)));

        if (pRowFlags && pTable->pRowFlags && mpRowHeights && pTable->mpRowHeights)
        {
            pTable->pRowFlags->CopyFromAnded( *pRowFlags, 0, nRow2, CRFlags::ManualSize);
            pTable->CopyRowHeight(*this, 0, nRow2, 0);
        }

        pTable->CopyRowHidden(*this, 0, nRow2);
        pTable->CopyRowFiltered(*this, 0, nRow2);

        // If necessary replace formulas with values

        if ( IsProtected() )
            for (i = nCol1; i <= nCol2; i++)
                pTable->aCol[i].RemoveProtected(nRow1, nRow2);

        pTable->mpCondFormatList.reset(new ScConditionalFormatList(pTable->pDocument, *mpCondFormatList));
    }

    void ScTable::CopyToClip(
        sc::CopyToClipContext& rCxt, const ScRangeList& rRanges, ScTable* pTable )
    {
        for ( size_t i = 0, nListSize = rRanges.size(); i < nListSize; ++i )
        {
            const ScRange & r = rRanges[ i ];
            CopyToClip( rCxt, r.aStart.Col(), r.aStart.Row(), r.aEnd.Col(), r.aEnd.Row(), pTable);
        }
    }

    void ScTable::CopyStaticToDocument(
        SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, const SvNumberFormatterMergeMap& rMap, ScTable* pDestTab )
    {
        if (nCol1 > nCol2)
            return;

        for (SCCOL i = nCol1; i <= nCol2; ++i)
        {
            ScColumn& rSrcCol = aCol[i];
            ScColumn& rDestCol = pDestTab->aCol[i];
            rSrcCol.CopyStaticToDocument(nRow1, nRow2, rMap, rDestCol);
        }
    }

    void ScTable::CopyCellToDocument(SCCOL nSrcCol, SCROW nSrcRow, SCCOL nDestCol, SCROW nDestRow, ScTable& rDestTab )
    {
        if (!ValidColRow(nSrcCol, nSrcRow) || !ValidColRow(nDestCol, nDestRow))
            return;

        ScColumn& rSrcCol = aCol[nSrcCol];
        ScColumn& rDestCol = rDestTab.aCol[nDestCol];
        rSrcCol.CopyCellToDocument(nSrcRow, nDestRow, rDestCol);
    }

    namespace {

    bool CheckAndDeduplicateCondFormat(ScDocument* pDocument, ScConditionalFormat* pOldFormat, const ScConditionalFormat* pNewFormat, SCTAB nTab)
    {
        if (!pOldFormat)
            return false;

        if (pOldFormat->EqualEntries(*pNewFormat, true))
        {
            const ScRangeList& rNewRangeList = pNewFormat->GetRange();
            ScRangeList& rDstRangeList = pOldFormat->GetRangeList();
            for (size_t i = 0; i < rNewRangeList.size(); ++i)
            {
                rDstRangeList.Join(rNewRangeList[i]);
            }
            pDocument->AddCondFormatData(rNewRangeList, nTab, pOldFormat->GetKey());
            return true;
        }

        return false;
    }

    }

    void ScTable::CopyConditionalFormat( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
            SCCOL nDx, SCROW nDy, const ScTable* pTable)
    {
        ScRange aOldRange( nCol1 - nDx, nRow1 - nDy, pTable->nTab, nCol2 - nDx, nRow2 - nDy, pTable->nTab);
        ScRange aNewRange( nCol1, nRow1, nTab, nCol2, nRow2, nTab );
        bool bSameDoc = pDocument->GetStyleSheetPool() == pTable->pDocument->GetStyleSheetPool();

        for(ScConditionalFormatList::const_iterator itr = pTable->mpCondFormatList->begin(),
                itrEnd = pTable->mpCondFormatList->end(); itr != itrEnd; ++itr)
        {
            const ScRangeList& rCondFormatRange = (*itr)->GetRange();
            if(!rCondFormatRange.Intersects( aOldRange ))
                continue;

            ScRangeList aIntersectedRange = rCondFormatRange.GetIntersectedRange(aOldRange);
            ScConditionalFormat* pNewFormat = (*itr)->Clone(pDocument);

            pNewFormat->SetRange(aIntersectedRange);
            sc::RefUpdateContext aRefCxt(*pDocument);
            aRefCxt.meMode = URM_COPY;
            aRefCxt.maRange = aNewRange;
            aRefCxt.mnColDelta = nDx;
            aRefCxt.mnRowDelta = nDy;
            aRefCxt.mnTabDelta = nTab - pTable->nTab;
            pNewFormat->UpdateReference(aRefCxt, true);

            if (bSameDoc && pTable->nTab == nTab && CheckAndDeduplicateCondFormat(pDocument, mpCondFormatList->GetFormat((*itr)->GetKey()), pNewFormat, nTab))
            {
                delete pNewFormat;
                continue;
            }
            sal_uLong nMax = 0;
            bool bDuplicate = false;
            for(ScConditionalFormatList::const_iterator itrCond = mpCondFormatList->begin();
                    itrCond != mpCondFormatList->end(); ++itrCond)
            {
                // Check if there is the same format in the destination
                // If there is, then simply expand its range
                if (CheckAndDeduplicateCondFormat(pDocument, (*itrCond).get(), pNewFormat, nTab))
                {
                    bDuplicate = true;
                    break;
                }

                if ((*itrCond)->GetKey() > nMax)
                    nMax = (*itrCond)->GetKey();
            }
            // Do not add duplicate entries
            if (bDuplicate)
            {
                delete pNewFormat;
                continue;
            }

            pNewFormat->SetKey(nMax + 1);
            mpCondFormatList->InsertNew(pNewFormat);

            if(!bSameDoc)
            {
                for(size_t i = 0, n = pNewFormat->size();
                        i < n; ++i)
                {
                    OUString aStyleName;
                    const ScFormatEntry* pEntry = pNewFormat->GetEntry(i);
                    if(pEntry->GetType() == ScFormatEntry::Type::Condition)
                        aStyleName = static_cast<const ScCondFormatEntry*>(pEntry)->GetStyle();
                    else if(pEntry->GetType() == ScFormatEntry::Type::Date)
                        aStyleName = static_cast<const ScCondDateFormatEntry*>(pEntry)->GetStyleName();

                    if(!aStyleName.isEmpty())
                    {
                        if(pDocument->GetStyleSheetPool()->Find(aStyleName, SfxStyleFamily::Para))
                            continue;

                        pDocument->GetStyleSheetPool()->CopyStyleFrom(
                                pTable->pDocument->GetStyleSheetPool(), aStyleName, SfxStyleFamily::Para );
                    }
                }
            }

            pDocument->AddCondFormatData( pNewFormat->GetRange(), nTab, pNewFormat->GetKey() );
        }
    }

    bool ScTable::InitColumnBlockPosition( sc::ColumnBlockPosition& rBlockPos, SCCOL nCol )
    {
        if (!ValidCol(nCol))
            return false;

        aCol[nCol].InitBlockPosition(rBlockPos);
        return true;
    }

    void ScTable::CopyFromClip(
        sc::CopyFromClipContext& rCxt, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
        SCCOL nDx, SCROW nDy, ScTable* pTable )
    {
        if (nCol2 > aCol.size() - 1)
            nCol2 = aCol.size() - 1;
        if (nRow2 > MAXROW)
            nRow2 = MAXROW;

        if (ValidColRow(nCol1, nRow1) && ValidColRow(nCol2, nRow2))
        {
            for ( SCCOL i = nCol1; i <= nCol2; i++)
                aCol[i].CopyFromClip(rCxt, nRow1, nRow2, nDy, pTable->aCol[i - nDx]); // notes are handles at column level

            if (rCxt.getInsertFlag() & InsertDeleteFlags::ATTRIB)
            {
                // make sure that there are no old references to the cond formats
                sal_uInt16 nWhichArray[2];
                nWhichArray[0] = ATTR_CONDITIONAL;
                nWhichArray[1] = 0;
                for ( SCCOL i = nCol1; i <= nCol2; ++i)
                    aCol[i].ClearItems(nRow1, nRow2, nWhichArray);
            }

            if ((rCxt.getInsertFlag() & InsertDeleteFlags::ATTRIB) != InsertDeleteFlags::NONE)
            {
                if (nRow1==0 && nRow2==MAXROW && mpColWidth && pTable->mpColWidth)
                    mpColWidth->CopyFrom(*pTable->mpColWidth, nCol1, nCol2, nCol1 - nDx);

                if (nCol1==0 && nCol2==MAXCOL && mpRowHeights && pTable->mpRowHeights &&
                                                 pRowFlags && pTable->pRowFlags)
                {
                    CopyRowHeight(*pTable, nRow1, nRow2, -nDy);
                    // Must copy CRFlags::ManualSize bit too, otherwise pRowHeight doesn't make sense
                    for (SCROW j=nRow1; j<=nRow2; j++)
                    {
                        if ( pTable->pRowFlags->GetValue(j-nDy) & CRFlags::ManualSize )
                            pRowFlags->OrValue( j, CRFlags::ManualSize);
                        else
                            pRowFlags->AndValue( j, ~CRFlags::ManualSize);
                    }
                }

                // Do not set protected cell in a protected sheet
                if (IsProtected() && (rCxt.getInsertFlag() & InsertDeleteFlags::ATTRIB))
                {
                    ScPatternAttr aPattern(pDocument->GetPool());
                    aPattern.GetItemSet().Put( ScProtectionAttr( false ) );
                    ApplyPatternArea( nCol1, nRow1, nCol2, nRow2, aPattern );
                }

                // create deep copies for conditional formatting
                CopyConditionalFormat( nCol1, nRow1, nCol2, nRow2, nDx, nDy, pTable);
            }
        }
    }

    void ScTable::MixData(
        sc::MixDocContext& rCxt, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
        ScPasteFunc nFunction, bool bSkipEmpty, const ScTable* pSrcTab )
    {
        for (SCCOL i=nCol1; i<=nCol2; i++)
            aCol[i].MixData(rCxt, nRow1, nRow2, nFunction, bSkipEmpty, pSrcTab->aCol[i]);
    }

    // Selection form this document
    void ScTable::MixMarked(
        sc::MixDocContext& rCxt, const ScMarkData& rMark, ScPasteFunc nFunction,
        bool bSkipEmpty, const ScTable* pSrcTab )
    {
        for (SCCOL i=0; i < aCol.size(); i++)
            aCol[i].MixMarked(rCxt, rMark, nFunction, bSkipEmpty, pSrcTab->aCol[i]);
    }

    namespace {

    class TransClipHandler
    {
        ScTable& mrClipTab;
        SCTAB mnSrcTab;
        SCCOL mnSrcCol;
        size_t mnTopRow;
        SCROW mnTransRow;
        bool mbAsLink;
        bool mbWasCut;

        ScAddress getDestPos(size_t nRow) const
        {
            return ScAddress(static_cast<SCCOL>(nRow-mnTopRow), mnTransRow, mrClipTab.GetTab());
        }

        ScFormulaCell* createRefCell(size_t nSrcRow, const ScAddress& rDestPos) const
        {
            ScAddress aSrcPos(mnSrcCol, nSrcRow, mnSrcTab);
            ScSingleRefData aRef;
            aRef.InitAddress(aSrcPos); // Absolute reference.
            aRef.SetFlag3D(true);

            ScTokenArray aArr;
            aArr.AddSingleReference(aRef);
            return new ScFormulaCell(&mrClipTab.GetDoc(), rDestPos, aArr);
        }

        void setLink(size_t nRow)
        {
            SCCOL nTransCol = nRow - mnTopRow;
            mrClipTab.SetFormulaCell(
                nTransCol, mnTransRow, createRefCell(nRow, getDestPos(nRow)));
        }

    public:
        TransClipHandler(ScTable& rClipTab, SCTAB nSrcTab, SCCOL nSrcCol, size_t nTopRow, SCROW nTransRow, bool bAsLink, bool bWasCut) :
            mrClipTab(rClipTab), mnSrcTab(nSrcTab), mnSrcCol(nSrcCol),
            mnTopRow(nTopRow), mnTransRow(nTransRow), mbAsLink(bAsLink), mbWasCut(bWasCut) {}

        void operator() (size_t nRow, double fVal)
        {
            if (mbAsLink)
            {
                setLink(nRow);
                return;
            }

            SCCOL nTransCol = nRow - mnTopRow;
            mrClipTab.SetValue(nTransCol, mnTransRow, fVal);
        }

        void operator() (size_t nRow, const svl::SharedString& rStr)
        {
            if (mbAsLink)
            {
                setLink(nRow);
                return;
            }

            SCCOL nTransCol = nRow - mnTopRow;
            mrClipTab.SetRawString(nTransCol, mnTransRow, rStr);
        }

        void operator() (size_t nRow, const EditTextObject* p)
        {
            if (mbAsLink)
            {
                setLink(nRow);
                return;
            }

            SCCOL nTransCol = nRow - mnTopRow;
            mrClipTab.SetEditText(nTransCol, mnTransRow, ScEditUtil::Clone(*p, mrClipTab.GetDoc()));
        }

        void operator() (size_t nRow, const ScFormulaCell* p)
        {
            if (mbAsLink)
            {
                setLink(nRow);
                return;
            }

            ScFormulaCell* pNew = new ScFormulaCell(
                *p, mrClipTab.GetDoc(), getDestPos(nRow), ScCloneFlags::StartListening);

            //  rotate reference
            //  for Cut, the references are later adjusted through UpdateTranspose

            if (!mbWasCut)
                pNew->TransposeReference();

            SCCOL nTransCol = nRow - mnTopRow;
            mrClipTab.SetFormulaCell(nTransCol, mnTransRow, pNew);
        }
    };

    }

    void ScTable::TransposeClip( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
                                    ScTable* pTransClip, InsertDeleteFlags nFlags, bool bAsLink )
    {
        bool bWasCut = pDocument->IsCutMode();

        ScDocument* pDestDoc = pTransClip->pDocument;

        for (SCCOL nCol=nCol1; nCol<=nCol2; nCol++)
        {
            SCROW nRow;
            if ( bAsLink && nFlags == InsertDeleteFlags::ALL )
            {
                //  with InsertDeleteFlags::ALL, also create links (formulas) for empty cells

                for ( nRow=nRow1; nRow<=nRow2; nRow++ )
                {
                    //  create simple formula, as in ScColumn::CreateRefCell

                    ScAddress aDestPos( static_cast<SCCOL>(nRow-nRow1), static_cast<SCROW>(nCol-nCol1), pTransClip->nTab );
                    ScSingleRefData aRef;
                    aRef.InitAddress(ScAddress(nCol,nRow,nTab));
                    aRef.SetFlag3D(true);
                    ScTokenArray aArr;
                    aArr.AddSingleReference( aRef );

                    pTransClip->SetFormulaCell(
                        static_cast<SCCOL>(nRow-nRow1), static_cast<SCROW>(nCol-nCol1),
                        new ScFormulaCell(pDestDoc, aDestPos, aArr));
                }
            }
            else
            {
                TransClipHandler aFunc(*pTransClip, nTab, nCol, nRow1, static_cast<SCROW>(nCol-nCol1), bAsLink, bWasCut);
                const sc::CellStoreType& rCells = aCol[nCol].maCells;
                sc::ParseAllNonEmpty(rCells.begin(), rCells, nRow1, nRow2, aFunc);
            }

            //  Attribute

            SCROW nAttrRow1;
            SCROW nAttrRow2;
            const ScPatternAttr* pPattern;
            std::unique_ptr<ScAttrIterator> pAttrIter(aCol[nCol].CreateAttrIterator( nRow1, nRow2 ));
            while ( (pPattern = pAttrIter->Next( nAttrRow1, nAttrRow2 )) != nullptr )
            {
                if ( !IsDefaultItem( pPattern ) )
                {
                    const SfxItemSet& rSet = pPattern->GetItemSet();
                    if ( rSet.GetItemState( ATTR_MERGE, false ) == SfxItemState::DEFAULT &&
                         rSet.GetItemState( ATTR_MERGE_FLAG, false ) == SfxItemState::DEFAULT &&
                         rSet.GetItemState( ATTR_BORDER, false ) == SfxItemState::DEFAULT )
                    {
                        // no borders or merge items involved - use pattern as-is
                        for (nRow = nAttrRow1; nRow<=nAttrRow2; nRow++)
                            pTransClip->SetPattern( static_cast<SCCOL>(nRow-nRow1), static_cast<SCROW>(nCol-nCol1), *pPattern );
                    }
                    else
                    {
                        // transpose borders and merge values, remove merge flags (refreshed after pasting)
                        ScPatternAttr aNewPattern( *pPattern );
                        SfxItemSet& rNewSet = aNewPattern.GetItemSet();

                        const SvxBoxItem& rOldBox = rSet.Get(ATTR_BORDER);
                        if ( rOldBox.GetTop() || rOldBox.GetBottom() || rOldBox.GetLeft() || rOldBox.GetRight() )
                        {
                            SvxBoxItem aNew( ATTR_BORDER );
                            aNew.SetLine( rOldBox.GetLine( SvxBoxItemLine::TOP ), SvxBoxItemLine::LEFT );
                            aNew.SetLine( rOldBox.GetLine( SvxBoxItemLine::LEFT ), SvxBoxItemLine::TOP );
                            aNew.SetLine( rOldBox.GetLine( SvxBoxItemLine::BOTTOM ), SvxBoxItemLine::RIGHT );
                            aNew.SetLine( rOldBox.GetLine( SvxBoxItemLine::RIGHT ), SvxBoxItemLine::BOTTOM );
                            aNew.SetDistance( rOldBox.GetDistance( SvxBoxItemLine::TOP ), SvxBoxItemLine::LEFT );
                            aNew.SetDistance( rOldBox.GetDistance( SvxBoxItemLine::LEFT ), SvxBoxItemLine::TOP );
                            aNew.SetDistance( rOldBox.GetDistance( SvxBoxItemLine::BOTTOM ), SvxBoxItemLine::RIGHT );
                            aNew.SetDistance( rOldBox.GetDistance( SvxBoxItemLine::RIGHT ), SvxBoxItemLine::BOTTOM );
                            rNewSet.Put( aNew );
                        }

                        const ScMergeAttr& rOldMerge = rSet.Get(ATTR_MERGE);
                        if (rOldMerge.IsMerged())
                            rNewSet.Put( ScMergeAttr( std::min(
                                            static_cast<SCCOL>(rOldMerge.GetRowMerge()),
                                            static_cast<SCCOL>(MAXCOL+1 - (nAttrRow2-nRow1))),
                                        std::min(
                                            static_cast<SCROW>(rOldMerge.GetColMerge()),
                                            static_cast<SCROW>(MAXROW+1 - (nCol-nCol1)))));
                        const ScMergeFlagAttr& rOldFlag = rSet.Get(ATTR_MERGE_FLAG);
                        if (rOldFlag.IsOverlapped())
                        {
                            ScMF nNewFlags = rOldFlag.GetValue() & ~ScMF( ScMF::Hor | ScMF::Ver );
                            if ( nNewFlags != ScMF::NONE )
                                rNewSet.Put( ScMergeFlagAttr( nNewFlags ) );
                            else
                                rNewSet.ClearItem( ATTR_MERGE_FLAG );
                        }

                        for (nRow = nAttrRow1; nRow<=nAttrRow2; nRow++)
                            pTransClip->SetPattern( static_cast<SCCOL>(nRow-nRow1),
                                    static_cast<SCROW>(nCol-nCol1), aNewPattern);
                    }
                }
            }

            // Cell Notes - fdo#68381 paste cell notes on Transpose
            if ( pDocument->HasColNotes(nCol, nTab) )
                TransposeColNotes(pTransClip, nCol1, nCol, nRow1, nRow2);
        }
    }

    void ScTable::TransposeColNotes(ScTable* pTransClip, SCCOL nCol1, SCCOL nCol, SCROW nRow1, SCROW nRow2)
    {
        sc::CellNoteStoreType::const_iterator itBlk = aCol[nCol].maCellNotes.begin(), itBlkEnd = aCol[nCol].maCellNotes.end();

        // Locate the top row position.
        size_t nOffsetInBlock = 0;
        size_t nBlockStart = 0, nBlockEnd = 0, nRowPos = static_cast<size_t>(nRow1);
        for (; itBlk != itBlkEnd; ++itBlk, nBlockStart = nBlockEnd)
        {
            nBlockEnd = nBlockStart + itBlk->size;
            if (nBlockStart <= nRowPos && nRowPos < nBlockEnd)
            {
                // Found.
                nOffsetInBlock = nRowPos - nBlockStart;
                break;
            }
        }

        if (itBlk != itBlkEnd)
            // Specified range found
        {
            nRowPos = static_cast<size_t>(nRow2); // End row position.

            // Keep processing until we hit the end row position.
            sc::cellnote_block::const_iterator itData, itDataEnd;
            for (; itBlk != itBlkEnd; ++itBlk, nBlockStart = nBlockEnd, nOffsetInBlock = 0)
            {
                nBlockEnd = nBlockStart + itBlk->size;

                if (itBlk->data)
                {
                    itData = sc::cellnote_block::begin(*itBlk->data);
                    std::advance(itData, nOffsetInBlock);

                    if (nBlockStart <= nRowPos && nRowPos < nBlockEnd)
                    {
                        // This block contains the end row. Only process partially.
                        size_t nOffsetEnd = nRowPos - nBlockStart + 1;
                        itDataEnd = sc::cellnote_block::begin(*itBlk->data);
                        std::advance(itDataEnd, nOffsetEnd);
                        size_t curRow = nBlockStart + nOffsetInBlock;
                        for (; itData != itDataEnd; ++itData, ++curRow)
                        {
                            ScAddress aDestPos( static_cast<SCCOL>(curRow-nRow1), static_cast<SCROW>(nCol-nCol1), pTransClip->nTab );
                            pTransClip->pDocument->ReleaseNote(aDestPos);
                            ScPostIt* pNote = *itData;
                            if (pNote)
                            {
                                ScPostIt* pClonedNote = pNote->Clone( ScAddress(nCol, curRow, nTab), *pTransClip->pDocument, aDestPos, true );
                                pTransClip->pDocument->SetNote(aDestPos, pClonedNote);
                            }
                        }
                        break; // we reached the last valid block
                    }
                    else
                    {
                        itDataEnd = sc::cellnote_block::end(*itBlk->data);
                        size_t curRow = nBlockStart + nOffsetInBlock;
                        for (; itData != itDataEnd; ++itData, ++curRow)
                        {
                            ScAddress aDestPos( static_cast<SCCOL>(curRow-nRow1), static_cast<SCROW>(nCol-nCol1), pTransClip->nTab );
                            pTransClip->pDocument->ReleaseNote(aDestPos);
                            ScPostIt* pNote = *itData;
                            if (pNote)
                            {
                                ScPostIt* pClonedNote = pNote->Clone( ScAddress(nCol, curRow, nTab), *pTransClip->pDocument, aDestPos, true );
                                pTransClip->pDocument->SetNote(aDestPos, pClonedNote);
                            }
                        }
                    }
                }
                else
                {
                    size_t curRow;
                    for ( curRow = nBlockStart + nOffsetInBlock; curRow <= nBlockEnd && curRow <= nRowPos; ++curRow)
                    {
                        ScAddress aDestPos( static_cast<SCCOL>(curRow-nRow1), static_cast<SCROW>(nCol-nCol1), pTransClip->nTab );
                        pTransClip->pDocument->ReleaseNote(aDestPos);
                    }
                    if (curRow == nRowPos)
                        break;
                }
            }
        }
    }

    ScColumn* ScTable::FetchColumn( SCCOL nCol )
    {
        if (!ValidCol(nCol))
            return nullptr;

        return &aCol[nCol];
    }

    const ScColumn* ScTable::FetchColumn( SCCOL nCol ) const
    {
        if (!ValidCol(nCol))
            return nullptr;

        return &aCol[nCol];
    }

    void ScTable::StartListeners( sc::StartListeningContext& rCxt, bool bAll )
    {
        std::shared_ptr<const sc::ColumnSet> pColSet = rCxt.getColumnSet();
        if (!pColSet)
        {
            for (SCCOL i=0; i < aCol.size(); i++)
                aCol[i].StartListeners(rCxt, bAll);
        }
        else if (pColSet->hasTab( nTab))
        {
            std::vector<SCCOL> aColumns;
            pColSet->getColumns( nTab, aColumns);
            for (auto i : aColumns)
            {
                if (0 <= i && i < aCol.size())
                    aCol[i].StartListeners(rCxt, bAll);
            }
        }
    }

    void ScTable::AttachFormulaCells(
        sc::StartListeningContext& rCxt, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 )
    {
        for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
            aCol[nCol].AttachFormulaCells(rCxt, nRow1, nRow2);
    }

    void ScTable::DetachFormulaCells(
        sc::EndListeningContext& rCxt, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 )
    {
        for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
            aCol[nCol].DetachFormulaCells(rCxt, nRow1, nRow2);
    }

    void ScTable::SetDirtyFromClip(
        SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, sc::ColumnSpanSet& rBroadcastSpans )
    {
        if ( nCol2 >= aCol.size() ) nCol2 = aCol.size() - 1;
        if (nCol2 > MAXCOL) nCol2 = MAXCOL;
        if (nRow2 > MAXROW) nRow2 = MAXROW;
        if (ValidColRow(nCol1, nRow1) && ValidColRow(nCol2, nRow2))
            for (SCCOL i = nCol1; i <= nCol2; i++)
                aCol[i].SetDirtyFromClip(nRow1, nRow2, rBroadcastSpans);
    }

    void ScTable::StartListeningFormulaCells(
        sc::StartListeningContext& rStartCxt, sc::EndListeningContext& rEndCxt,
        SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 )
    {
        if ( nCol2 >= aCol.size() ) nCol2 = aCol.size() - 1;
        if (nCol2 > MAXCOL) nCol2 = MAXCOL;
        if (nRow2 > MAXROW) nRow2 = MAXROW;
        if (ValidColRow(nCol1, nRow1) && ValidColRow(nCol2, nRow2))
            for (SCCOL i = nCol1; i <= nCol2; i++)
                aCol[i].StartListeningFormulaCells(rStartCxt, rEndCxt, nRow1, nRow2);
    }

    void ScTable::CopyToTable(
        sc::CopyToDocContext& rCxt, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
        InsertDeleteFlags nFlags, bool bMarked, ScTable* pDestTab, const ScMarkData* pMarkData,
        bool bAsLink, bool bColRowFlags, bool bGlobalNamesToLocal, bool bCopyCaptions )
    {
        if (!ValidColRow(nCol1, nRow1) || !ValidColRow(nCol2, nRow2))
            return;

        bool bIsUndoDoc = pDestTab->pDocument->IsUndo();
        if (nFlags != InsertDeleteFlags::NONE)
        {
            InsertDeleteFlags nTempFlags( nFlags &
                    ~InsertDeleteFlags( InsertDeleteFlags::NOTE | InsertDeleteFlags::ADDNOTES));
            for (SCCOL i = nCol1; i <= nCol2; i++)
                aCol[i].CopyToColumn(rCxt, nRow1, nRow2, bIsUndoDoc ? nFlags : nTempFlags, bMarked,
                                    pDestTab->aCol[i], pMarkData, bAsLink, bGlobalNamesToLocal);
        }

        if (!bColRowFlags)      // Column widths/Row heights/Flags
            return;

        if(bIsUndoDoc && (nFlags & InsertDeleteFlags::ATTRIB))
        {
            pDestTab->mpCondFormatList.reset(new ScConditionalFormatList(pDestTab->pDocument, *mpCondFormatList));
        }

        if (pDBDataNoName)
        {
            std::unique_ptr<ScDBData> pNewDBData(new ScDBData(*pDBDataNoName));
            SCCOL aCol1, aCol2;
            SCROW aRow1, aRow2;
            SCTAB aTab;
            pNewDBData->GetArea(aTab, aCol1, aRow1, aCol2, aRow2);
            pNewDBData->MoveTo(pDestTab->nTab, aCol1, aRow1, aCol2, aRow2);
            pDestTab->SetAnonymousDBData(std::move(pNewDBData));
        }
        //  Charts have to be adjusted when hide/show
        ScChartListenerCollection* pCharts = pDestTab->pDocument->GetChartListenerCollection();

        bool bFlagChange = false;

        bool bWidth  = (nRow1==0 && nRow2==MAXROW && mpColWidth && pDestTab->mpColWidth);
        bool bHeight = (nCol1==0 && nCol2==MAXCOL && mpRowHeights && pDestTab->mpRowHeights);

        if (bWidth || bHeight)
        {
            if (bWidth)
            {
                auto destTabColWidthIt = pDestTab->mpColWidth->begin() + nCol1;
                auto thisTabColWidthIt = mpColWidth->begin() + nCol1;
                pDestTab->mpColWidth->CopyFrom(*mpColWidth, nCol1, nCol2);
                pDestTab->mpColFlags->CopyFrom(*mpColFlags, nCol1, nCol2);
                for (SCCOL i = nCol1; i <= nCol2; ++i)
                {
                    bool bThisHidden = ColHidden(i);
                    bool bHiddenChange = (pDestTab->ColHidden(i) != bThisHidden);
                    bool bChange = bHiddenChange || (*destTabColWidthIt != *thisTabColWidthIt);
                    pDestTab->SetColHidden(i, i, bThisHidden);
                    //TODO: collect changes?
                    if (bHiddenChange && pCharts)
                        pCharts->SetRangeDirty(ScRange( i, 0, nTab, i, MAXROW, nTab ));

                    if (bChange)
                        bFlagChange = true;

                    ++destTabColWidthIt;
                    ++thisTabColWidthIt;
                }
                pDestTab->SetColManualBreaks( maColManualBreaks);
            }

            if (bHeight)
            {
                bool bChange = pDestTab->GetRowHeight(nRow1, nRow2) != GetRowHeight(nRow1, nRow2);

                if (bChange)
                    bFlagChange = true;

                pDestTab->CopyRowHeight(*this, nRow1, nRow2, 0);
                pDestTab->pRowFlags->CopyFrom(*pRowFlags, nRow1, nRow2);

                // Hidden flags.
                for (SCROW i = nRow1; i <= nRow2; ++i)
                {
                    SCROW nLastRow;
                    bool bHidden = RowHidden(i, nullptr, &nLastRow);
                    if (nLastRow >= nRow2)
                        // the last row shouldn't exceed the upper bound the caller specified.
                        nLastRow = nRow2;

                    bool bHiddenChanged = pDestTab->SetRowHidden(i, nLastRow, bHidden);
                    if (bHiddenChanged && pCharts)
                        // Hidden flags differ.
                        pCharts->SetRangeDirty(ScRange(0, i, nTab, MAXCOL, nLastRow, nTab));

                    if (bHiddenChanged)
                        bFlagChange = true;

                    // Jump to the last row of the identical flag segment.
                    i = nLastRow;
                }

                // Filtered flags.
                for (SCROW i = nRow1; i <= nRow2; ++i)
                {
                    SCROW nLastRow;
                    bool bFiltered = RowFiltered(i, nullptr, &nLastRow);
                    if (nLastRow >= nRow2)
                        // the last row shouldn't exceed the upper bound the caller specified.
                        nLastRow = nRow2;
                    pDestTab->SetRowFiltered(i, nLastRow, bFiltered);
                    i = nLastRow;
                }
                pDestTab->SetRowManualBreaks( maRowManualBreaks);
            }
        }

        if (bFlagChange)
            pDestTab->InvalidatePageBreaks();

        if(nFlags & InsertDeleteFlags::ATTRIB)
        {
            pDestTab->mpCondFormatList->DeleteArea(nCol1, nRow1, nCol2, nRow2);
            pDestTab->CopyConditionalFormat(nCol1, nRow1, nCol2, nRow2, 0, 0, this);
        }

        if(nFlags & InsertDeleteFlags::OUTLINE) // also only when bColRowFlags
            pDestTab->SetOutlineTable( pOutlineTable.get() );

        if (!bIsUndoDoc && bCopyCaptions && (nFlags & (InsertDeleteFlags::NOTE | InsertDeleteFlags::ADDNOTES)))
        {
            bool bCloneCaption = (nFlags & InsertDeleteFlags::NOCAPTIONS) == InsertDeleteFlags::NONE;
            CopyCaptionsToTable( nCol1, nRow1, nCol2, nRow2, pDestTab, bCloneCaption);
        }
    }

    void ScTable::CopyCaptionsToTable( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, ScTable* pDestTab,
            bool bCloneCaption )
    {
        if (!ValidColRow(nCol1, nRow1) || !ValidColRow(nCol2, nRow2))
            return;

        for (SCCOL i = nCol1; i <= nCol2; i++)
        {
            aCol[i].CopyCellNotesToDocument(nRow1, nRow2, pDestTab->aCol[i], bCloneCaption);
            pDestTab->aCol[i].UpdateNoteCaptions(nRow1, nRow2);
        }
    }

    void ScTable::UndoToTable(
        sc::CopyToDocContext& rCxt, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
        InsertDeleteFlags nFlags, bool bMarked, ScTable* pDestTab )
    {
        if (ValidColRow(nCol1, nRow1) && ValidColRow(nCol2, nRow2))
        {
            bool bWidth  = (nRow1==0 && nRow2==MAXROW && mpColWidth && pDestTab->mpColWidth);
            bool bHeight = (nCol1==0 && nCol2==MAXCOL && mpRowHeights && pDestTab->mpRowHeights);

            for ( SCCOL i = 0; i < aCol.size(); i++)
            {
                if ( i >= nCol1 && i <= nCol2 )
                    aCol[i].UndoToColumn(rCxt, nRow1, nRow2, nFlags, bMarked, pDestTab->aCol[i]);
                else
                    aCol[i].CopyToColumn(rCxt, 0, MAXROW, InsertDeleteFlags::FORMULA, false, pDestTab->aCol[i]);
            }

            if (nFlags & InsertDeleteFlags::ATTRIB)
                pDestTab->mpCondFormatList.reset(new ScConditionalFormatList(pDestTab->pDocument, *mpCondFormatList));

            if (bWidth||bHeight)
            {
                if (bWidth)
                {
                    pDestTab->mpColWidth->CopyFrom(*mpColWidth, nCol1, nCol2);
                    pDestTab->SetColManualBreaks( maColManualBreaks);
                }
                if (bHeight)
                {
                    pDestTab->CopyRowHeight(*this, nRow1, nRow2, 0);
                    pDestTab->SetRowManualBreaks( maRowManualBreaks);
                }
            }
        }
    }

    void ScTable::CopyUpdated( const ScTable* pPosTab, ScTable* pDestTab ) const
    {
        for (SCCOL i=0; i < aCol.size(); i++)
            aCol[i].CopyUpdated( pPosTab->aCol[i], pDestTab->aCol[i] );
    }

    void ScTable::InvalidateTableArea()
    {
        bTableAreaValid = false;
    }

    void ScTable::InvalidatePageBreaks()
    {
        mbPageBreaksValid = false;
    }

    void ScTable::CopyScenarioTo( ScTable* pDestTab ) const
    {
        OSL_ENSURE( bScenario, "bScenario == FALSE" );

        for (SCCOL i=0; i < aCol.size(); i++)
            aCol[i].CopyScenarioTo( pDestTab->aCol[i] );
    }

    void ScTable::CopyScenarioFrom( const ScTable* pSrcTab )
    {
        OSL_ENSURE( bScenario, "bScenario == FALSE" );

        for (SCCOL i=0; i < aCol.size(); i++)
            aCol[i].CopyScenarioFrom( pSrcTab->aCol[i] );
    }

    void ScTable::MarkScenarioIn( ScMarkData& rDestMark, ScScenarioFlags nNeededBits ) const
    {
        OSL_ENSURE( bScenario, "bScenario == FALSE" );

        if ( ( nScenarioFlags & nNeededBits ) != nNeededBits )  // Are all Bits set?
            return;

        for (SCCOL i=0; i < aCol.size(); i++)
            aCol[i].MarkScenarioIn( rDestMark );
    }

    bool ScTable::HasScenarioRange( const ScRange& rRange ) const
    {
        OSL_ENSURE( bScenario, "bScenario == FALSE" );

        ScRange aTabRange = rRange;
        aTabRange.aStart.SetTab( nTab );
        aTabRange.aEnd.SetTab( nTab );

        const ScRangeList* pList = GetScenarioRanges();

        if (pList)
        {
            for ( size_t j = 0, n = pList->size(); j < n; j++ )
            {
                const ScRange & rR = (*pList)[j];
                if ( rR.Intersects( aTabRange ) )
                    return true;
            }
        }

        return false;
    }

    void ScTable::InvalidateScenarioRanges()
    {
        pScenarioRanges.reset();
    }

    const ScRangeList* ScTable::GetScenarioRanges() const
    {
        OSL_ENSURE( bScenario, "bScenario == FALSE" );

        if (!pScenarioRanges)
        {
            const_cast<ScTable*>(this)->pScenarioRanges.reset(new ScRangeList);
            ScMarkData aMark;
            MarkScenarioIn( aMark, ScScenarioFlags::NONE );     // always
            aMark.FillRangeListWithMarks( pScenarioRanges.get(), false );
        }
        return pScenarioRanges.get();
    }

    bool ScTable::TestCopyScenarioTo( const ScTable* pDestTab ) const
    {
        OSL_ENSURE( bScenario, "bScenario == FALSE" );

        if (!pDestTab->IsProtected())
            return true;

        bool bOk = true;
        for (SCCOL i=0; i < aCol.size() && bOk; i++)
            bOk = aCol[i].TestCopyScenarioTo( pDestTab->aCol[i] );
        return bOk;
    }

    bool ScTable::SetString( SCCOL nCol, SCROW nRow, SCTAB nTabP, const OUString& rString,
                             const ScSetStringParam * pParam )
    {
        if (ValidColRow(nCol,nRow))
            return aCol[nCol].SetString(
                nRow, nTabP, rString, pDocument->GetAddressConvention(), pParam );
        else
            return false;
    }

    bool ScTable::SetEditText( SCCOL nCol, SCROW nRow, std::unique_ptr<EditTextObject> pEditText )
    {
        if (!ValidColRow(nCol, nRow))
        {
            return false;
        }

        aCol[nCol].SetEditText(nRow, std::move(pEditText));
        return true;
    }

    void ScTable::SetEditText( SCCOL nCol, SCROW nRow, const EditTextObject& rEditText, const SfxItemPool* pEditPool )
    {
        if (!ValidColRow(nCol, nRow))
            return;

        aCol[nCol].SetEditText(nRow, rEditText, pEditPool);
    }

    SCROW ScTable::GetFirstEditTextRow( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 ) const
    {
        if (!ValidCol(nCol1) || !ValidCol(nCol2) || nCol2 < nCol1)
            return -1;

        if (!ValidRow(nRow1) || !ValidRow(nRow2) || nRow2 < nRow1)
            return -1;

        SCROW nFirst = MAXROW+1;
        for (SCCOL i = nCol1; i <= nCol2; ++i)
        {
            const ScColumn& rCol = aCol[i];
            SCROW nThisFirst = -1;
            if (const_cast<ScColumn&>(rCol).HasEditCells(nRow1, nRow2, nThisFirst))
            {
                if (nThisFirst == nRow1)
                    return nRow1;

                if (nThisFirst < nFirst)
                    nFirst = nThisFirst;
            }
        }

        return nFirst == (MAXROW+1) ? -1 : nFirst;
    }

    void ScTable::SetEmptyCell( SCCOL nCol, SCROW nRow )
    {
        if (!ValidColRow(nCol, nRow))
            return;

        aCol[nCol].Delete(nRow);
    }

    void ScTable::SetFormula(
        SCCOL nCol, SCROW nRow, const ScTokenArray& rArray, formula::FormulaGrammar::Grammar eGram )
    {
        if (!ValidColRow(nCol, nRow))
            return;

        aCol[nCol].SetFormula(nRow, rArray, eGram);
    }

    void ScTable::SetFormula(
        SCCOL nCol, SCROW nRow, const OUString& rFormula, formula::FormulaGrammar::Grammar eGram )
    {
        if (!ValidColRow(nCol, nRow))
            return;

        aCol[nCol].SetFormula(nRow, rFormula, eGram);
    }

    ScFormulaCell* ScTable::SetFormulaCell( SCCOL nCol, SCROW nRow, ScFormulaCell* pCell )
    {
        if (!ValidColRow(nCol, nRow))
        {
            delete pCell;
            return nullptr;
        }

        return aCol[nCol].SetFormulaCell(nRow, pCell, sc::ConvertToGroupListening);
    }

    bool ScTable::SetFormulaCells( SCCOL nCol, SCROW nRow, std::vector<ScFormulaCell*>& rCells )
    {
        if (!ValidCol(nCol))
            return false;

        return aCol[nCol].SetFormulaCells(nRow, rCells);
    }

    svl::SharedString ScTable::GetSharedString( SCCOL nCol, SCROW nRow ) const
    {
        if (!ValidColRow(nCol, nRow))
            return svl::SharedString();

        return aCol[nCol].GetSharedString(nRow);
    }

    void ScTable::SetValue( SCCOL nCol, SCROW nRow, const double& rVal )
    {
        if (ValidColRow(nCol, nRow))
            aCol[nCol].SetValue( nRow, rVal );
    }

    void ScTable::SetRawString( SCCOL nCol, SCROW nRow, const svl::SharedString& rStr )
    {
        if (ValidColRow(nCol, nRow))
            aCol[nCol].SetRawString(nRow, rStr);
    }

    void ScTable::GetString( SCCOL nCol, SCROW nRow, OUString& rString, const ScInterpreterContext* pContext ) const
    {
        if (ValidColRow(nCol,nRow))
            aCol[nCol].GetString( nRow, rString, pContext );
        else
            rString.clear();
    }

    double* ScTable::GetValueCell( SCCOL nCol, SCROW nRow )
    {
        if (!ValidColRow(nCol,nRow))
            return nullptr;

        return aCol[nCol].GetValueCell(nRow);
    }

    void ScTable::GetInputString( SCCOL nCol, SCROW nRow, OUString& rString ) const
    {
        if (ValidColRow(nCol,nRow))
            aCol[nCol].GetInputString( nRow, rString );
        else
            rString.clear();
    }

    double ScTable::GetValue( SCCOL nCol, SCROW nRow ) const
    {
        if (ValidColRow( nCol, nRow ))
            return aCol[nCol].GetValue( nRow );
        return 0.0;
    }

    const EditTextObject* ScTable::GetEditText( SCCOL nCol, SCROW nRow ) const
    {
        if (!ValidColRow(nCol, nRow))
            return nullptr;

        return aCol[nCol].GetEditText(nRow);
    }

    void ScTable::RemoveEditTextCharAttribs( SCCOL nCol, SCROW nRow, const ScPatternAttr& rAttr )
    {
        if (!ValidColRow(nCol, nRow))
            return;

        return aCol[nCol].RemoveEditTextCharAttribs(nRow, rAttr);
    }

    void ScTable::GetFormula( SCCOL nCol, SCROW nRow, OUString& rFormula ) const
    {
        if (ValidColRow(nCol,nRow))
            aCol[nCol].GetFormula( nRow, rFormula );
        else
            rFormula.clear();
    }

    const ScFormulaCell* ScTable::GetFormulaCell( SCCOL nCol, SCROW nRow ) const
    {
        if (!ValidColRow(nCol, nRow))
            return nullptr;

        return aCol[nCol].GetFormulaCell(nRow);
    }

    ScFormulaCell* ScTable::GetFormulaCell( SCCOL nCol, SCROW nRow )
    {
        if (!ValidColRow(nCol, nRow))
            return nullptr;

        return aCol[nCol].GetFormulaCell(nRow);
    }

    ScPostIt* ScTable::ReleaseNote( SCCOL nCol, SCROW nRow )
    {
        if (!ValidCol(nCol))
            return nullptr;

        return aCol[nCol].ReleaseNote(nRow);
    }

    size_t ScTable::GetNoteCount( SCCOL nCol ) const
    {
        if (!ValidCol(nCol))
            return 0;

        return aCol[nCol].GetNoteCount();
    }

    SCROW ScTable::GetNotePosition( SCCOL nCol, size_t nIndex ) const
    {
        if (!ValidCol(nCol))
            return -1;

        return aCol[nCol].GetNotePosition(nIndex);
    }

    void ScTable::CreateAllNoteCaptions()
    {
        for (SCCOL i = 0; i < aCol.size(); ++i)
            aCol[i].CreateAllNoteCaptions();
    }

    void ScTable::ForgetNoteCaptions( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, bool bPreserveData )
    {
        if (!ValidCol(nCol1) || !ValidCol(nCol2))
            return;
        if ( nCol2 >= aCol.size() ) nCol2 = aCol.size() - 1;
        for (SCCOL i = nCol1; i <= nCol2; ++i)
            aCol[i].ForgetNoteCaptions(nRow1, nRow2, bPreserveData);
    }

    void ScTable::GetAllNoteEntries( std::vector<sc::NoteEntry>& rNotes ) const
    {
        for (SCCOL nCol = 0; nCol < aCol.size(); ++nCol)
            aCol[nCol].GetAllNoteEntries(rNotes);
    }

    void ScTable::GetNotesInRange( const ScRange& rRange, std::vector<sc::NoteEntry>& rNotes ) const
    {
        SCROW nStartRow = rRange.aStart.Row();
        SCROW nEndRow = rRange.aEnd.Row();
        for (SCCOL nCol = rRange.aStart.Col(); nCol <= rRange.aEnd.Col(); ++nCol)
        {
            aCol[nCol].GetNotesInRange(nStartRow, nEndRow, rNotes);
        }
    }

    CommentCaptionState ScTable::GetAllNoteCaptionsState(const ScRange& rRange, std::vector<sc::NoteEntry>& rNotes )
    {
        SCROW nStartRow = rRange.aStart.Row();
        SCROW nEndRow = rRange.aEnd.Row();
        bool bIsFirstNoteShownState = true; // because of error: -Werror=maybe-uninitialized
        bool bFirstControl = true;

        for (SCCOL nCol = rRange.aStart.Col(); nCol <= rRange.aEnd.Col(); ++nCol)
        {
            if (bFirstControl && pDocument->HasColNotes(nCol, nTab)) // detect status of first note caption
            {
                aCol[nCol].GetNotesInRange(nStartRow, nEndRow, rNotes);
                bIsFirstNoteShownState = rNotes.begin()->mpNote->IsCaptionShown();
                bFirstControl = false;
            }

            if (pDocument->HasColNotes(nCol, nTab))
            {
                aCol[nCol].GetNotesInRange(nStartRow, nEndRow, rNotes);

                for(std::vector<sc::NoteEntry>::const_iterator itr = rNotes.begin(),
                             itrEnd = rNotes.end(); itr != itrEnd; ++itr)
                {
                    if ( bIsFirstNoteShownState != itr->mpNote->IsCaptionShown())  // compare the first note caption with others
                    {
                        return CommentCaptionState::MIXED;
                    }
                }
            }
        }
        return bIsFirstNoteShownState ? CommentCaptionState::ALLSHOWN : CommentCaptionState::ALLHIDDEN;
    }

    void ScTable::GetUnprotectedCells( ScRangeList& rRangeList ) const
    {
        for (auto const & pCol : aCol)
            pCol->GetUnprotectedCells(0, MAXROW, rRangeList);
    }

    bool ScTable::ContainsNotesInRange( const ScRange& rRange ) const
    {
        SCROW nStartRow = rRange.aStart.Row();
        SCROW nEndRow = rRange.aEnd.Row();
        for (SCCOL nCol = rRange.aStart.Col(); nCol <= rRange.aEnd.Col(); ++nCol)
        {
            bool bContainsNote = !aCol[nCol].IsNotesEmptyBlock(nStartRow, nEndRow);
            if(bContainsNote)
                return true;
        }

        return false;
    }

    CellType ScTable::GetCellType( SCCOL nCol, SCROW nRow ) const
    {
        if (ValidColRow( nCol, nRow ))
            return aCol[nCol].GetCellType( nRow );
        return CELLTYPE_NONE;
    }

    ScRefCellValue ScTable::GetCellValue( SCCOL nCol, SCROW nRow ) const
    {
        if (!ValidColRow(nCol, nRow))
            return ScRefCellValue();

        return aCol[nCol].GetCellValue(nRow);
    }

    void ScTable::GetFirstDataPos(SCCOL& rCol, SCROW& rRow) const
    {
        rCol = 0;
        rRow = MAXROW+1;
        while (rCol < (aCol.size() - 1) && aCol[rCol].IsEmptyData() )
            ++rCol;
        SCCOL nCol = rCol;
        while (nCol < aCol.size() && rRow > 0)
        {
            if (!aCol[nCol].IsEmptyData())
                rRow = ::std::min( rRow, aCol[nCol].GetFirstDataPos());
            ++nCol;
        }
    }

    void ScTable::GetLastDataPos(SCCOL& rCol, SCROW& rRow) const
    {
        rCol = aCol.size() - 1;
        rRow = 0;
        while (aCol[rCol].IsEmptyData() && (rCol > 0))
            rCol--;
        SCCOL nCol = rCol;
        while (nCol >= 0 && rRow < MAXROW)
            rRow = ::std::max( rRow, aCol[nCol--].GetLastDataPos());
    }

    bool ScTable::HasData( SCCOL nCol, SCROW nRow ) const
    {
        if (ValidColRow(nCol,nRow))
            return aCol[nCol].HasDataAt( nRow );
        else
            return false;
    }

    bool ScTable::HasStringData( SCCOL nCol, SCROW nRow ) const
    {
        if (ValidColRow(nCol,nRow))
            return aCol[nCol].HasStringData( nRow );
        else
            return false;
    }

    bool ScTable::HasValueData( SCCOL nCol, SCROW nRow ) const
    {
        if (ValidColRow(nCol,nRow))
            return aCol[nCol].HasValueData( nRow );
        else
            return false;
    }

    bool ScTable::HasStringCells( SCCOL nStartCol, SCROW nStartRow,
                                    SCCOL nEndCol, SCROW nEndRow ) const
    {
        if ( ValidCol(nEndCol) )
            for ( SCCOL nCol=nStartCol; nCol<=nEndCol; nCol++ )
                if (aCol[nCol].HasStringCells(nStartRow, nEndRow))
                    return true;

        return false;
    }

    void ScTable::SetDirtyVar()
    {
        for (SCCOL i=0; i < aCol.size(); i++)
            aCol[i].SetDirtyVar();
    }

    void ScTable::CheckVectorizationState()
    {
        sc::AutoCalcSwitch aACSwitch(*pDocument, false);

        for (SCCOL i = 0; i < aCol.size(); i++)
            aCol[i].CheckVectorizationState();
    }

    void ScTable::SetAllFormulasDirty( const sc::SetFormulaDirtyContext& rCxt )
    {
        sc::AutoCalcSwitch aACSwitch(*pDocument, false);

        for (SCCOL i=0; i < aCol.size(); i++)
            aCol[i].SetAllFormulasDirty(rCxt);
    }

    void ScTable::SetDirty( const ScRange& rRange, ScColumn::BroadcastMode eMode )
    {
        bool bOldAutoCalc = pDocument->GetAutoCalc();
        pDocument->SetAutoCalc( false );    // avoid multiple recalculations
        SCCOL nCol2 = rRange.aEnd.Col();
        for (SCCOL i=rRange.aStart.Col(); i<=nCol2; i++)
            aCol[i].SetDirty(rRange.aStart.Row(), rRange.aEnd.Row(), eMode);
        pDocument->SetAutoCalc( bOldAutoCalc );
    }

    void ScTable::SetTableOpDirty( const ScRange& rRange )
    {
        bool bOldAutoCalc = pDocument->GetAutoCalc();
        pDocument->SetAutoCalc( false );    // no multiple recalculation
        SCCOL nCol2 = rRange.aEnd.Col();
        for (SCCOL i=rRange.aStart.Col(); i<=nCol2; i++)
            aCol[i].SetTableOpDirty( rRange );
        pDocument->SetAutoCalc( bOldAutoCalc );
    }

    void ScTable::SetDirtyAfterLoad()
    {
        bool bOldAutoCalc = pDocument->GetAutoCalc();
        pDocument->SetAutoCalc( false );    // avoid multiple recalculations
        for (SCCOL i=0; i < aCol.size(); i++)
            aCol[i].SetDirtyAfterLoad();
        pDocument->SetAutoCalc( bOldAutoCalc );
    }

    void ScTable::SetDirtyIfPostponed()
    {
        bool bOldAutoCalc = pDocument->GetAutoCalc();
        pDocument->SetAutoCalc( false );    // avoid multiple recalculations
        for (SCCOL i=0; i < aCol.size(); i++)
            aCol[i].SetDirtyIfPostponed();
        pDocument->SetAutoCalc( bOldAutoCalc );
    }

    void ScTable::BroadcastRecalcOnRefMove()
    {
        sc::AutoCalcSwitch aSwitch(*pDocument, false);
        for (SCCOL i = 0; i < aCol.size(); ++i)
            aCol[i].BroadcastRecalcOnRefMove();
    }

    bool ScTable::BroadcastBroadcasters( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, ScHint& rHint )
    {
        bool bBroadcasted = false;
        sc::AutoCalcSwitch aSwitch(*pDocument, false);
        rHint.GetAddress().SetTab(nTab);
        for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
            bBroadcasted |= aCol[nCol].BroadcastBroadcasters( nRow1, nRow2, rHint);
        return bBroadcasted;
    }

    void ScTable::TransferListeners(
        ScTable& rDestTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
        SCCOL nColDelta, SCROW nRowDelta )
    {
        for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
        {
            ScColumn& rSrcCol = aCol[nCol];
            ScColumn& rDestCol = rDestTab.aCol[nCol+nColDelta];
            rSrcCol.TransferListeners(rDestCol, nRow1, nRow2, nRowDelta);
        }
    }

    void ScTable::SetLoadingMedium(bool bLoading)
    {
        mpRowHeights->enableTreeSearch(!bLoading);
    }

    void ScTable::CalcAll()
    {
        for (SCCOL i=0; i < aCol.size(); i++)
            aCol[i].CalcAll();

        mpCondFormatList->CalcAll();
    }

    void ScTable::CompileAll( sc::CompileFormulaContext& rCxt )
    {
        for (SCCOL i = 0; i < aCol.size(); ++i)
            aCol[i].CompileAll(rCxt);

        if(mpCondFormatList)
            mpCondFormatList->CompileAll();
    }

    void ScTable::CompileXML( sc::CompileFormulaContext& rCxt, ScProgress& rProgress )
    {
        if (mpRangeName)
            mpRangeName->CompileUnresolvedXML(rCxt);

        for (SCCOL i=0; i < aCol.size(); i++)
        {
            aCol[i].CompileXML(rCxt, rProgress);
        }

        if(mpCondFormatList)
            mpCondFormatList->CompileXML();
    }

    bool ScTable::CompileErrorCells( sc::CompileFormulaContext& rCxt, FormulaError nErrCode )
    {
        bool bCompiled = false;
        for (SCCOL i = 0; i < aCol.size(); ++i)
        {
            if (aCol[i].CompileErrorCells(rCxt, nErrCode))
                bCompiled = true;
        }

        return bCompiled;
    }

    void ScTable::CalcAfterLoad( sc::CompileFormulaContext& rCxt, bool bStartListening )
    {
        for (SCCOL i = 0; i < aCol.size(); ++i)
            aCol[i].CalcAfterLoad(rCxt, bStartListening);
    }

    void ScTable::ResetChanged( const ScRange& rRange )
    {
        SCCOL nStartCol = rRange.aStart.Col();
        SCROW nStartRow = rRange.aStart.Row();
        SCCOL nEndCol = rRange.aEnd.Col();
        SCROW nEndRow = rRange.aEnd.Row();

        for (SCCOL nCol=nStartCol; nCol<=nEndCol; nCol++)
            aCol[nCol].ResetChanged(nStartRow, nEndRow);
    }

    //  Attribute

    const SfxPoolItem* ScTable::GetAttr( SCCOL nCol, SCROW nRow, sal_uInt16 nWhich ) const
    {
        if (ValidColRow(nCol,nRow))
            return &aCol[nCol].GetAttr( nRow, nWhich );
        else
            return nullptr;
    }

    sal_uInt32 ScTable::GetNumberFormat( const ScInterpreterContext& rContext, const ScAddress& rPos ) const
    {
        return ValidColRow(rPos.Col(),rPos.Row()) ?
            aCol[rPos.Col()].GetNumberFormat( rContext, rPos.Row() ) :
            0;
    }

    sal_uInt32 ScTable::GetNumberFormat( SCCOL nCol, SCROW nRow ) const
    {
        if (ValidColRow(nCol,nRow))
            return aCol[nCol].GetNumberFormat( pDocument->GetNonThreadedContext(), nRow );
        else
            return 0;
    }

    sal_uInt32 ScTable::GetNumberFormat( SCCOL nCol, SCROW nStartRow, SCROW nEndRow ) const
    {
        if (!ValidCol(nCol) || !ValidRow(nStartRow) || !ValidRow(nEndRow))
            return 0;

        return aCol[nCol].GetNumberFormat(nStartRow, nEndRow);
    }

    void ScTable::SetNumberFormat( SCCOL nCol, SCROW nRow, sal_uInt32 nNumberFormat )
    {
        if (!ValidColRow(nCol, nRow))
            return;

        aCol[nCol].SetNumberFormat(nRow, nNumberFormat);
    }

    const ScPatternAttr* ScTable::GetPattern( SCCOL nCol, SCROW nRow ) const
    {
        if (ValidColRow(nCol,nRow))
            return aCol[nCol].GetPattern( nRow );
        else
        {
            OSL_FAIL("wrong column or row");
            return pDocument->GetDefPattern();      // for safety
        }
    }

    const ScPatternAttr* ScTable::GetMostUsedPattern( SCCOL nCol, SCROW nStartRow, SCROW nEndRow ) const
    {
        if ( ValidColRow( nCol, nStartRow ) && ValidRow( nEndRow ) && (nStartRow <= nEndRow) )
            return aCol[nCol].GetMostUsedPattern( nStartRow, nEndRow );
        else
            return nullptr;
    }

    bool ScTable::HasAttrib( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, HasAttrFlags nMask ) const
    {
        if ( nCol1 >= aCol.size() )
             return false;
        if ( nCol2 >= aCol.size() )
             nCol2 = aCol.size() - 1; // Rows above range, doesn't contains flags

        bool bFound = false;
        for (SCCOL i=nCol1; i<=nCol2 && !bFound; i++)
            bFound |= aCol[i].HasAttrib( nRow1, nRow2, nMask );
        return bFound;
    }

    bool ScTable::HasAttribSelection( const ScMarkData& rMark, HasAttrFlags nMask ) const
    {
        std::vector<sc::ColRowSpan> aSpans = rMark.GetMarkedColSpans();

        for (sc::ColRowSpan & aSpan : aSpans)
        {
            for (SCCOLROW j = aSpan.mnStart; j <= aSpan.mnEnd; ++j)
            {
                if (aCol[j].HasAttribSelection(rMark, nMask))
                  return true;
            }
        }
        return false;
    }

    bool ScTable::ExtendMerge( SCCOL nStartCol, SCROW nStartRow,
                               SCCOL& rEndCol, SCROW& rEndRow,
                               bool bRefresh )
    {
        if (!(ValidCol(nStartCol) && ValidCol(rEndCol)))
        {
            OSL_FAIL("ScTable::ExtendMerge: invalid column number");
            return false;
        }
        if ( nStartCol >= aCol.size() )
        {
            OSL_FAIL("ScTable::ExtendMerge: invalid nStartCol");
            return false;
        }
        bool bFound = false;
        SCCOL nOldEndX = std::min( rEndCol, static_cast<SCCOL>(aCol.size()-1) );
        SCROW nOldEndY = rEndRow;
        for (SCCOL i=nStartCol; i<=nOldEndX; i++)
            bFound |= aCol[i].ExtendMerge( i, nStartRow, nOldEndY, rEndCol, rEndRow, bRefresh );
        return bFound;
    }

    void ScTable::SetMergedCells( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 )
    {
        ScMergeAttr aAttr(nCol2-nCol1+1, nRow2-nRow1+1);
        ApplyAttr(nCol1, nRow1, aAttr);

        if (nCol1 < nCol2)
            ApplyFlags(nCol1+1, nRow1, nCol2, nRow2, ScMF::Hor);

        if (nRow1 < nRow2)
            ApplyFlags(nCol1, nRow1+1, nCol1, nRow2, ScMF::Ver);

        if (nCol1 < nCol2 && nRow1 < nRow2)
            ApplyFlags(nCol1+1, nRow1+1, nCol2, nRow2, ScMF::Hor | ScMF::Ver);
    }

    bool ScTable::IsBlockEmpty( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, bool bIgnoreNotes ) const
    {
        if (!(ValidCol(nCol1) && ValidCol(nCol2)))
        {
            OSL_FAIL("ScTable::IsBlockEmpty: invalid column number");
            return false;
        }
        bool bEmpty = true;
        for (SCCOL i=nCol1; i<=nCol2 && bEmpty; i++)
        {
            bEmpty = aCol[i].IsEmptyBlock( nRow1, nRow2 );
            if (!bIgnoreNotes && bEmpty)
            {
                bEmpty = aCol[i].IsNotesEmptyBlock(nRow1, nRow2);
            }
        }
        return bEmpty;
    }

    SCSIZE ScTable::FillMaxRot( RowInfo* pRowInfo, SCSIZE nArrCount, SCCOL nX1, SCCOL nX2,
                                SCCOL nCol, SCROW nAttrRow1, SCROW nAttrRow2, SCSIZE nArrY,
                                const ScPatternAttr* pPattern, const SfxItemSet* pCondSet )
    {
        //  Return value = new nArrY

        ScRotateDir nRotDir = pPattern->GetRotateDir( pCondSet );
        if ( nRotDir != ScRotateDir::NONE )
        {
            bool bHit = true;
            if ( nCol+1 < nX1 )                             // column to the left
                bHit = ( nRotDir != ScRotateDir::Left );
            else if ( nCol > nX2+1 )                        // column to the right
                bHit = ( nRotDir != ScRotateDir::Right );      // ScRotateDir::Standard may now also be extended to the left

            if ( bHit )
            {
                double nFactor = 0.0;
                if ( nCol > nX2+1 )
                {
                    long nRotVal = pPattern->
                            GetItem( ATTR_ROTATE_VALUE, pCondSet ).GetValue();
                    double nRealOrient = nRotVal * F_PI18000;   // 1/100 degree
                    double nCos = cos( nRealOrient );
                    double nSin = sin( nRealOrient );
                    //TODO: limit !!!
                    //TODO: additional factor for varying PPT X/Y !!!

                    // for ScRotateDir::Left this gives a negative value,
                    // if the mode is considered
                    nFactor = -fabs( nCos / nSin );
                }

                for ( SCROW nRow = nAttrRow1; nRow <= nAttrRow2; nRow++ )
                {
                    if (!RowHidden(nRow))
                    {
                        bool bHitOne = true;
                        if ( nCol > nX2+1 )
                        {
                            // Does the rotated cell extend into the visible range?

                            SCCOL nTouchedCol = nCol;
                            long nWidth = static_cast<long>(mpRowHeights->getValue(nRow) * nFactor);
                            OSL_ENSURE(nWidth <= 0, "Wrong direction");
                            while ( nWidth < 0 && nTouchedCol > 0 )
                            {
                                --nTouchedCol;
                                nWidth += GetColWidth( nTouchedCol );
                            }
                            if ( nTouchedCol > nX2 )
                                bHitOne = false;
                        }

                        if (bHitOne)
                        {
                            while ( nArrY<nArrCount && pRowInfo[nArrY].nRowNo < nRow )
                                ++nArrY;
                            if ( nArrY<nArrCount && pRowInfo[nArrY].nRowNo == nRow )
                                pRowInfo[nArrY].nRotMaxCol = nCol;
                        }
                    }
                }
            }
        }

        return nArrY;
    }

    void ScTable::FindMaxRotCol( RowInfo* pRowInfo, SCSIZE nArrCount, SCCOL nX1, SCCOL nX2 )
    {
        if ( !mpColWidth || !mpRowHeights || !mpColFlags || !pRowFlags )
        {
            OSL_FAIL( "Row/column info missing" );
            return;
        }

        //  nRotMaxCol is initialized to SC_ROTMAX_NONE, nRowNo is already set

        SCROW nY1 = pRowInfo[0].nRowNo;
        SCROW nY2 = pRowInfo[nArrCount-1].nRowNo;

        for (SCCOL nCol : GetColumnsRange(0, MAXCOL))
        {
            if (!ColHidden(nCol))
            {
                SCSIZE nArrY = 0;
                ScDocAttrIterator aIter( pDocument, nTab, nCol, nY1, nCol, nY2 );
                SCCOL nAttrCol;
                SCROW nAttrRow1, nAttrRow2;
                const ScPatternAttr* pPattern = aIter.GetNext( nAttrCol, nAttrRow1, nAttrRow2 );
                while ( pPattern )
                {
                    const SfxPoolItem* pCondItem;
                    if ( pPattern->GetItemSet().GetItemState( ATTR_CONDITIONAL, true, &pCondItem )
                            == SfxItemState::SET )
                    {
                        //  Run through all formats, so that each cell does not have to be
                        //  handled individually

                        const std::vector<sal_uInt32>& rCondFormatData = static_cast<const ScCondFormatItem*>(pCondItem)->GetCondFormatData();
                        ScStyleSheetPool* pStylePool = pDocument->GetStyleSheetPool();
                        if (mpCondFormatList && pStylePool && !rCondFormatData.empty())
                        {
                            for(std::vector<sal_uInt32>::const_iterator itr = rCondFormatData.begin(), itrEnd = rCondFormatData.end();
                                    itr != itrEnd; ++itr)
                            {
                                const ScConditionalFormat* pFormat = mpCondFormatList->GetFormat(*itr);
                                if ( pFormat )
                                {
                                    size_t nEntryCount = pFormat->size();
                                    for (size_t nEntry=0; nEntry<nEntryCount; nEntry++)
                                    {
                                        const ScFormatEntry* pEntry = pFormat->GetEntry(nEntry);
                                        if(pEntry->GetType() != ScFormatEntry::Type::Condition)
                                            continue;

                                        OUString  aStyleName = static_cast<const ScCondFormatEntry*>(pEntry)->GetStyle();
                                        if (!aStyleName.isEmpty())
                                        {
                                            SfxStyleSheetBase* pStyleSheet =
                                                pStylePool->Find( aStyleName, SfxStyleFamily::Para );
                                            if ( pStyleSheet )
                                            {
                                                FillMaxRot( pRowInfo, nArrCount, nX1, nX2,
                                                        nCol, nAttrRow1, nAttrRow2,
                                                        nArrY, pPattern, &pStyleSheet->GetItemSet() );
                                                //  not changing nArrY
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }

                    nArrY = FillMaxRot( pRowInfo, nArrCount, nX1, nX2,
                                        nCol, nAttrRow1, nAttrRow2,
                                        nArrY, pPattern, nullptr );

                    pPattern = aIter.GetNext( nAttrCol, nAttrRow1, nAttrRow2 );
                }
            }
        }
    }

    bool ScTable::HasBlockMatrixFragment( const SCCOL nCol1, SCROW nRow1, const SCCOL nCol2, SCROW nRow2 ) const
    {
        using namespace sc;

        if ( !IsColValid( nCol1 ) )
            return false;

        const SCCOL nMaxCol2 = std::min<SCCOL>( nCol2, aCol.size() - 1 );

        MatrixEdge nEdges = MatrixEdge::Nothing;

        if ( nCol1 == nMaxCol2 )
        {   // left and right column
            const MatrixEdge n = MatrixEdge::Left | MatrixEdge::Right;
            nEdges = aCol[nCol1].GetBlockMatrixEdges( nRow1, nRow2, n );
            if ((nEdges != MatrixEdge::Nothing) && (((nEdges & n)!=n) || (nEdges & (MatrixEdge::Inside|MatrixEdge::Open))))
                return true;        // left or right edge is missing or open
        }
        else
        {   // left column
            nEdges = aCol[nCol1].GetBlockMatrixEdges(nRow1, nRow2, MatrixEdge::Left);
            if ((nEdges != MatrixEdge::Nothing) && ((!(nEdges & MatrixEdge::Left)) || (nEdges & (MatrixEdge::Inside|MatrixEdge::Open))))
                return true;        // left edge missing or open
            // right column
            nEdges = aCol[nMaxCol2].GetBlockMatrixEdges(nRow1, nRow2, MatrixEdge::Right);
            if ((nEdges != MatrixEdge::Nothing) && ((!(nEdges & MatrixEdge::Right)) || (nEdges & (MatrixEdge::Inside|MatrixEdge::Open))))
                return true;        // right edge is missing or open
        }

        if ( nRow1 == nRow2 )
        {   // Row on top and on bottom
            bool bOpen = false;
            const MatrixEdge n = MatrixEdge::Bottom | MatrixEdge::Top;
            for ( SCCOL i=nCol1; i<=nMaxCol2; i++)
            {
                nEdges = aCol[i].GetBlockMatrixEdges( nRow1, nRow1, n );
                if (nEdges != MatrixEdge::Nothing)
                {
                    if ( (nEdges & n) != n )
                        return true;        // Top or bottom edge missing
                    if (nEdges & MatrixEdge::Left)
                        bOpen = true;       // left edge open, continue
                    else if ( !bOpen )
                        return true;        // Something exist that has not been opened
                    if (nEdges & MatrixEdge::Right)
                        bOpen = false;      // Close right edge
                }
            }
            if ( bOpen )
                return true;
        }
        else
        {
            int j;
            MatrixEdge n;
            SCROW nR;
            // first top row, then bottom row
            for ( j=0, n = MatrixEdge::Top,    nR=nRow1; j<2;
                  j++, n = MatrixEdge::Bottom, nR=nRow2)
            {
                bool bOpen = false;
                for ( SCCOL i=nCol1; i<=nMaxCol2; i++)
                {
                    nEdges = aCol[i].GetBlockMatrixEdges( nR, nR, n );
                    if ( nEdges != MatrixEdge::Nothing)
                    {
                        // in top row no top edge respectively
                        // in bottom row no bottom edge
                        if ( (nEdges & n) != n )
                            return true;
                        if (nEdges & MatrixEdge::Left)
                            bOpen = true;       // open left edge, continue
                        else if ( !bOpen )
                            return true;        // Something exist that has not been opened
                        if (nEdges & MatrixEdge::Right)
                            bOpen = false;      // Close right edge
                    }
                }
                if ( bOpen )
                    return true;
            }
        }
        return false;
    }

    bool ScTable::HasSelectionMatrixFragment( const ScMarkData& rMark ) const
    {
        std::vector<sc::ColRowSpan> aSpans = rMark.GetMarkedColSpans();

        for (sc::ColRowSpan & aSpan : aSpans)
        {
            for ( SCCOLROW j=aSpan.mnStart; j<=aSpan.mnEnd; j++ )
            {
                if ( aCol[j].HasSelectionMatrixFragment(rMark) )
                    return true;
            }
        }
        return false;
    }

    bool ScTable::IsBlockEditable( SCCOL nCol1, SCROW nRow1, SCCOL nCol2,
                SCROW nRow2, bool* pOnlyNotBecauseOfMatrix /* = NULL */ ) const
    {
        if ( !ValidColRow( nCol2, nRow2 ) )
        {
            OSL_FAIL("IsBlockEditable: invalid column or row");
            if (pOnlyNotBecauseOfMatrix)
                *pOnlyNotBecauseOfMatrix = false;
            return false;
        }

        bool bIsEditable = true;
        if ( nLockCount )
            bIsEditable = false;
        else if ( IsProtected() && !pDocument->IsScenario(nTab) )
        {
            bIsEditable = !HasAttrib( nCol1, nRow1, nCol2, nRow2, HasAttrFlags::Protected );
            if (!bIsEditable)
            {
                // An enhanced protection permission may override the attribute.
                if (pTabProtection)
                    bIsEditable = pTabProtection->isBlockEditable( ScRange( nCol1, nRow1, nTab, nCol2, nRow2, nTab));
            }
            if (bIsEditable)
            {
                // If Sheet is protected and cells are not protected then
                // check the active scenario protect flag if this range is
                // on the active scenario range. Note the 'copy back' must also
                // be set to apply protection.
                sal_uInt16 nScenTab = nTab+1;
                while(pDocument->IsScenario(nScenTab))
                {
                    ScRange aEditRange(nCol1, nRow1, nScenTab, nCol2, nRow2, nScenTab);
                    if(pDocument->IsActiveScenario(nScenTab) && pDocument->HasScenarioRange(nScenTab, aEditRange))
                    {
                        ScScenarioFlags nFlags;
                        pDocument->GetScenarioFlags(nScenTab,nFlags);
                        bIsEditable = !((nFlags & ScScenarioFlags::Protected) && (nFlags & ScScenarioFlags::TwoWay));
                        break;
                    }
                    nScenTab++;
                }
            }
        }
        else if (pDocument->IsScenario(nTab))
        {
            // Determine if the preceding sheet is protected
            SCTAB nActualTab = nTab;
            do
            {
                nActualTab--;
            }
            while(pDocument->IsScenario(nActualTab));

            if(pDocument->IsTabProtected(nActualTab))
            {
                ScRange aEditRange(nCol1, nRow1, nTab, nCol2, nRow2, nTab);
                if(pDocument->HasScenarioRange(nTab, aEditRange))
                {
                    ScScenarioFlags nFlags;
                    pDocument->GetScenarioFlags(nTab,nFlags);
                    bIsEditable = !(nFlags & ScScenarioFlags::Protected);
                }
            }
        }
        if ( bIsEditable )
        {
            if ( HasBlockMatrixFragment( nCol1, nRow1, nCol2, nRow2 ) )
            {
                bIsEditable = false;
                if ( pOnlyNotBecauseOfMatrix )
                    *pOnlyNotBecauseOfMatrix = true;
            }
            else if ( pOnlyNotBecauseOfMatrix )
                *pOnlyNotBecauseOfMatrix = false;
        }
        else if ( pOnlyNotBecauseOfMatrix )
            *pOnlyNotBecauseOfMatrix = false;
        return bIsEditable;
    }

    bool ScTable::IsSelectionEditable( const ScMarkData& rMark,
                bool* pOnlyNotBecauseOfMatrix /* = NULL */ ) const
    {
        bool bIsEditable = true;
        if ( nLockCount )
            bIsEditable = false;
        else if ( IsProtected() && !pDocument->IsScenario(nTab) )
        {
            ScRangeList aRanges;
            rMark.FillRangeListWithMarks( &aRanges, false );
            bIsEditable = !HasAttribSelection( rMark, HasAttrFlags::Protected );
            if (!bIsEditable)
            {
                // An enhanced protection permission may override the attribute.
                if (pTabProtection)
                    bIsEditable = pTabProtection->isSelectionEditable( aRanges);
            }
            if (bIsEditable)
            {
                // If Sheet is protected and cells are not protected then
                // check the active scenario protect flag if this area is
                // in the active scenario range.
                SCTAB nScenTab = nTab+1;
                while(pDocument->IsScenario(nScenTab) && bIsEditable)
                {
                    if(pDocument->IsActiveScenario(nScenTab))
                    {
                        for (size_t i=0, nRange = aRanges.size(); (i < nRange) && bIsEditable; i++ )
                        {
                            const ScRange & rRange = aRanges[ i ];
                            if(pDocument->HasScenarioRange(nScenTab, rRange))
                            {
                                ScScenarioFlags nFlags;
                                pDocument->GetScenarioFlags(nScenTab,nFlags);
                                bIsEditable = !((nFlags & ScScenarioFlags::Protected) && (nFlags & ScScenarioFlags::TwoWay));
                            }
                        }
                    }
                    nScenTab++;
                }
            }
        }
        else if (pDocument->IsScenario(nTab))
        {
            // Determine if the preceding sheet is protected
            SCTAB nActualTab = nTab;
            do
            {
                nActualTab--;
            }
            while(pDocument->IsScenario(nActualTab));

            if(pDocument->IsTabProtected(nActualTab))
            {
                ScRangeList aRanges;
                rMark.FillRangeListWithMarks( &aRanges, false );
                for (size_t i = 0, nRange = aRanges.size(); (i < nRange) && bIsEditable; i++)
                {
                    const ScRange & rRange = aRanges[ i ];
                    if(pDocument->HasScenarioRange(nTab, rRange))
                    {
                        ScScenarioFlags nFlags;
                        pDocument->GetScenarioFlags(nTab,nFlags);
                        bIsEditable = !(nFlags & ScScenarioFlags::Protected);
                    }
                }
            }
        }
        if ( bIsEditable )
        {
            if ( HasSelectionMatrixFragment( rMark ) )
            {
                bIsEditable = false;
                if ( pOnlyNotBecauseOfMatrix )
                    *pOnlyNotBecauseOfMatrix = true;
            }
            else if ( pOnlyNotBecauseOfMatrix )
                *pOnlyNotBecauseOfMatrix = false;
        }
        else if ( pOnlyNotBecauseOfMatrix )
            *pOnlyNotBecauseOfMatrix = false;
        return bIsEditable;
    }

    void ScTable::LockTable()
    {
        ++nLockCount;
    }

    void ScTable::UnlockTable()
    {
        if (nLockCount)
            --nLockCount;
        else
        {
            OSL_FAIL("UnlockTable without LockTable");
        }
    }

    void ScTable::MergeSelectionPattern( ScMergePatternState& rState, const ScMarkData& rMark, bool bDeep ) const
    {
        std::vector<sc::ColRowSpan> aSpans = rMark.GetMarkedColSpans();

        for (const sc::ColRowSpan & rSpan : aSpans)
        {
            for (SCCOLROW i = rSpan.mnStart; i <= rSpan.mnEnd; ++i)
            {
                aCol[i].MergeSelectionPattern( rState, rMark, bDeep );
            }
        }
    }

    void ScTable::MergePatternArea( ScMergePatternState& rState, SCCOL nCol1, SCROW nRow1,
                                                        SCCOL nCol2, SCROW nRow2, bool bDeep ) const
    {
        for (SCCOL i=nCol1; i<=nCol2; i++)
            aCol[i].MergePatternArea( rState, nRow1, nRow2, bDeep );
    }

    void ScTable::MergeBlockFrame( SvxBoxItem* pLineOuter, SvxBoxInfoItem* pLineInner, ScLineFlags& rFlags,
                        SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow ) const
    {
        if (ValidColRow(nStartCol, nStartRow) && ValidColRow(nEndCol, nEndRow))
        {
            PutInOrder(nStartCol, nEndCol);
            PutInOrder(nStartRow, nEndRow);
            for (SCCOL i=nStartCol; i<=nEndCol; i++)
                aCol[i].MergeBlockFrame( pLineOuter, pLineInner, rFlags,
                                        nStartRow, nEndRow, (i==nStartCol), nEndCol-i );
        }
    }

    void ScTable::ApplyBlockFrame(const SvxBoxItem& rLineOuter, const SvxBoxInfoItem* pLineInner,
                                  SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow)
    {
        if (ValidColRow(nStartCol, nStartRow) && ValidColRow(nEndCol, nEndRow))
        {
            PutInOrder(nStartCol, nEndCol);
            PutInOrder(nStartRow, nEndRow);
            for (SCCOL i=nStartCol; i<=nEndCol; i++)
                aCol[i].ApplyBlockFrame(rLineOuter, pLineInner,
                                        nStartRow, nEndRow, (i==nStartCol), nEndCol-i);
        }
    }

    void ScTable::ApplyPattern( SCCOL nCol, SCROW nRow, const ScPatternAttr& rAttr )
    {
        if (ValidColRow(nCol,nRow))
            aCol[nCol].ApplyPattern( nRow, rAttr );
    }

    void ScTable::ApplyPatternArea( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,
                                         const ScPatternAttr& rAttr, ScEditDataArray* pDataArray,
                                         bool* const pIsChanged )
    {
        if (ValidColRow(nStartCol, nStartRow) && ValidColRow(nEndCol, nEndRow))
        {
            PutInOrder(nStartCol, nEndCol);
            PutInOrder(nStartRow, nEndRow);
            for (SCCOL i = nStartCol; i <= nEndCol; i++)
                aCol[i].ApplyPatternArea(nStartRow, nEndRow, rAttr, pDataArray, pIsChanged);
        }
    }

    void ScTable::ApplyPatternIfNumberformatIncompatible( const ScRange& rRange,
            const ScPatternAttr& rPattern, SvNumFormatType nNewType )
    {
        SCCOL nEndCol = rRange.aEnd.Col();
        for ( SCCOL nCol = rRange.aStart.Col(); nCol <= nEndCol; nCol++ )
        {
            aCol[nCol].ApplyPatternIfNumberformatIncompatible( rRange, rPattern, nNewType );
        }
    }

    void ScTable::AddCondFormatData( const ScRangeList& rRangeList, sal_uInt32 nIndex )
    {
        size_t n = rRangeList.size();
        for(size_t i = 0; i < n; ++i)
        {
            const ScRange & rRange = rRangeList[i];
            SCCOL nColStart = rRange.aStart.Col();
            SCCOL nColEnd = rRange.aEnd.Col();
            SCROW nRowStart = rRange.aStart.Row();
            SCROW nRowEnd = rRange.aEnd.Row();
            for(SCCOL nCol = nColStart; nCol <= nColEnd; ++nCol)
            {
                aCol[nCol].AddCondFormat(nRowStart, nRowEnd, nIndex);
            }
        }
    }

    void ScTable::RemoveCondFormatData( const ScRangeList& rRangeList, sal_uInt32 nIndex )
    {
        size_t n = rRangeList.size();
        for(size_t i = 0; i < n; ++i)
        {
            const ScRange & rRange = rRangeList[i];
            SCCOL nColStart = rRange.aStart.Col();
            SCCOL nColEnd = rRange.aEnd.Col();
            SCROW nRowStart = rRange.aStart.Row();
            SCROW nRowEnd = rRange.aEnd.Row();
            for(SCCOL nCol = nColStart; nCol <= nColEnd; ++nCol)
            {
                aCol[nCol].RemoveCondFormat(nRowStart, nRowEnd, nIndex);
            }
        }
    }

    void ScTable::ApplyStyle( SCCOL nCol, SCROW nRow, const ScStyleSheet* rStyle )
    {
        if (ValidColRow(nCol,nRow))
            // If column not exists then we need to create it
            CreateColumnIfNotExists( nCol ).ApplyStyle( nRow, rStyle );
    }

    void ScTable::ApplyStyleArea( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, const ScStyleSheet& rStyle )
    {
        if (ValidColRow(nStartCol, nStartRow) && ValidColRow(nEndCol, nEndRow))
        {
            PutInOrder(nStartCol, nEndCol);
            PutInOrder(nStartRow, nEndRow);
            if ( nEndCol == MAXCOL )
            {
                if ( nStartCol < aCol.size() )
                {
                    // If we would like set all columns to specific style, then change only default style for not existing columns
                    nEndCol = aCol.size() - 1;
                    for (SCCOL i = nStartCol; i <= nEndCol; i++)
                        aCol[i].ApplyStyleArea(nStartRow, nEndRow, rStyle);
                    aDefaultColAttrArray.ApplyStyleArea(nStartRow, nEndRow, rStyle );
                }
                else
                {
                    CreateColumnIfNotExists( nStartCol - 1 );
                    aDefaultColAttrArray.ApplyStyleArea(nStartRow, nEndRow, rStyle );
                }
            }
            else
            {
                CreateColumnIfNotExists( nEndCol );
                for (SCCOL i = nStartCol; i <= nEndCol; i++)
                    aCol[i].ApplyStyleArea(nStartRow, nEndRow, rStyle);
            }
        }
    }

    void ScTable::ApplySelectionStyle(const ScStyleSheet& rStyle, const ScMarkData& rMark)
    {
        for (SCCOL i=0; i < aCol.size(); i++)
            aCol[i].ApplySelectionStyle( rStyle, rMark );
    }

    void ScTable::ApplySelectionLineStyle( const ScMarkData& rMark,
                                const ::editeng::SvxBorderLine* pLine, bool bColorOnly )
    {
        if ( bColorOnly && !pLine )
            return;

        for (SCCOL i=0; i < aCol.size(); i++)
            aCol[i].ApplySelectionLineStyle( rMark, pLine, bColorOnly );
    }

    const ScStyleSheet* ScTable::GetStyle( SCCOL nCol, SCROW nRow ) const
    {
        if ( !ValidColRow( nCol, nRow ) )
            return nullptr;
        if ( nCol < aCol.size() )
            return aCol[nCol].GetStyle( nRow );
        else
            return aDefaultColAttrArray.GetPattern( nRow )->GetStyleSheet();
    }

    const ScStyleSheet* ScTable::GetSelectionStyle( const ScMarkData& rMark, bool& rFound ) const
    {
        rFound = false;

        bool    bEqual = true;
        bool    bColFound;

        const ScStyleSheet* pStyle = nullptr;
        const ScStyleSheet* pNewStyle;

        for (SCCOL i=0; i < aCol.size() && bEqual; i++)
            if (rMark.HasMultiMarks(i))
            {
                pNewStyle = aCol[i].GetSelectionStyle( rMark, bColFound );
                if (bColFound)
                {
                    rFound = true;
                    if ( !pNewStyle || ( pStyle && pNewStyle != pStyle ) )
                        bEqual = false;
                    pStyle = pNewStyle;
                }
            }

        return bEqual ? pStyle : nullptr;
    }

    const ScStyleSheet* ScTable::GetAreaStyle( bool& rFound, SCCOL nCol1, SCROW nRow1,
                                               SCCOL nCol2, SCROW nRow2 ) const
    {
        rFound = false;

        bool    bEqual = true;
        bool    bColFound;

        const ScStyleSheet* pStyle = nullptr;
        const ScStyleSheet* pNewStyle;

        for (SCCOL i=nCol1; i<=nCol2 && bEqual; i++)
        {
            pNewStyle = aCol[i].GetAreaStyle(bColFound, nRow1, nRow2);
            if (bColFound)
            {
                rFound = true;
                if ( !pNewStyle || ( pStyle && pNewStyle != pStyle ) )
                    bEqual = false;
                pStyle = pNewStyle;
            }
        }

        return bEqual ? pStyle : nullptr;
    }

    bool ScTable::IsStyleSheetUsed( const ScStyleSheet& rStyle ) const
    {
        bool bIsUsed = false;

        for ( SCCOL i=0; i < aCol.size(); i++ )
        {
            if ( aCol[i].IsStyleSheetUsed( rStyle ) )
            {
                bIsUsed = true;
            }
        }

        return bIsUsed;
    }

    void ScTable::StyleSheetChanged( const SfxStyleSheetBase* pStyleSheet, bool bRemoved,
                                    OutputDevice* pDev,
                                    double nPPTX, double nPPTY,
                                    const Fraction& rZoomX, const Fraction& rZoomY )
    {
        ScFlatBoolRowSegments aUsedRows;
        for (SCCOL i = 0; i < aCol.size(); ++i)
            aCol[i].FindStyleSheet(pStyleSheet, aUsedRows, bRemoved);

        sc::RowHeightContext aCxt(nPPTX, nPPTY, rZoomX, rZoomY, pDev);
        SCROW nRow = 0;
        while (nRow <= MAXROW)
        {
            ScFlatBoolRowSegments::RangeData aData;
            if (!aUsedRows.getRangeData(nRow, aData))
                // search failed!
                return;

            SCROW nEndRow = aData.mnRow2;
            if (aData.mbValue)
                SetOptimalHeight(aCxt, nRow, nEndRow);

            nRow = nEndRow + 1;
        }
    }

    bool ScTable::ApplyFlags( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,
                              ScMF nFlags )
    {
        bool bChanged = false;
        if (ValidColRow(nStartCol, nStartRow) && ValidColRow(nEndCol, nEndRow))
            for (SCCOL i = nStartCol; i <= nEndCol; i++)
                bChanged |= aCol[i].ApplyFlags(nStartRow, nEndRow, nFlags);
        return bChanged;
    }

    bool ScTable::RemoveFlags( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,
                               ScMF nFlags )
    {
        bool bChanged = false;
        if (ValidColRow(nStartCol, nStartRow) && ValidColRow(nEndCol, nEndRow))
            for (SCCOL i = nStartCol; i <= nEndCol; i++)
                bChanged |= aCol[i].RemoveFlags(nStartRow, nEndRow, nFlags);
        return bChanged;
    }

    void ScTable::SetPattern( SCCOL nCol, SCROW nRow, const ScPatternAttr& rAttr )
    {
        if (ValidColRow(nCol,nRow))
            aCol[nCol].SetPattern( nRow, rAttr );
    }

    void ScTable::ApplyAttr( SCCOL nCol, SCROW nRow, const SfxPoolItem& rAttr )
    {
        if (ValidColRow(nCol,nRow))
            aCol[nCol].ApplyAttr( nRow, rAttr );
    }

    void ScTable::ApplySelectionCache( SfxItemPoolCache* pCache, const ScMarkData& rMark,
                                       ScEditDataArray* pDataArray, bool* const pIsChanged )
    {
        for (SCCOL i=0; i < aCol.size(); i++)
            aCol[i].ApplySelectionCache( pCache, rMark, pDataArray, pIsChanged );
    }

    void ScTable::ChangeSelectionIndent( bool bIncrement, const ScMarkData& rMark )
    {
        for (SCCOL i=0; i < aCol.size(); i++)
            aCol[i].ChangeSelectionIndent( bIncrement, rMark );
    }

    void ScTable::ClearSelectionItems( const sal_uInt16* pWhich, const ScMarkData& rMark )
    {
        for (SCCOL i=0; i < aCol.size(); i++)
            aCol[i].ClearSelectionItems( pWhich, rMark );
    }

    //  Column widths / Row heights

    void ScTable::SetColWidth( SCCOL nCol, sal_uInt16 nNewWidth )
    {
        if (ValidCol(nCol) && mpColWidth)
        {
            if (!nNewWidth)
            {
                nNewWidth = STD_COL_WIDTH;
            }

            if ( nNewWidth != mpColWidth->GetValue(nCol) )
            {
                mpColWidth->SetValue(nCol, nNewWidth);
                InvalidatePageBreaks();
            }
        }
        else
        {
            OSL_FAIL("Invalid column number or no widths");
        }
    }

    void ScTable::SetColWidthOnly( SCCOL nCol, sal_uInt16 nNewWidth )
    {
        if (!ValidCol(nCol) || !mpColWidth)
            return;

        if (!nNewWidth)
            nNewWidth = STD_COL_WIDTH;

        if (nNewWidth != mpColWidth->GetValue(nCol))
            mpColWidth->SetValue(nCol, nNewWidth);
    }

    void ScTable::SetRowHeight( SCROW nRow, sal_uInt16 nNewHeight )
    {
        if (ValidRow(nRow) && mpRowHeights)
        {
            if (!nNewHeight)
            {
                OSL_FAIL("SetRowHeight: Row height zero");
                nNewHeight = ScGlobal::nStdRowHeight;
            }

            sal_uInt16 nOldHeight = mpRowHeights->getValue(nRow);
            if ( nNewHeight != nOldHeight )
            {
                mpRowHeights->setValue(nRow, nRow, nNewHeight);
                InvalidatePageBreaks();
            }
        }
        else
        {
            OSL_FAIL("Invalid row number or no heights");
        }
    }

    namespace {

    /**
     * Check if the new pixel size is different from the old size between
     * specified ranges.
     */
    bool lcl_pixelSizeChanged(
        ScFlatUInt16RowSegments& rRowHeights, SCROW nStartRow, SCROW nEndRow,
        sal_uInt16 nNewHeight, double nPPTY)
    {
        long nNewPix = static_cast<long>(nNewHeight * nPPTY);

        ScFlatUInt16RowSegments::ForwardIterator aFwdIter(rRowHeights);
        for (SCROW nRow = nStartRow; nRow <= nEndRow; ++nRow)
        {
            sal_uInt16 nHeight;
            if (!aFwdIter.getValue(nRow, nHeight))
                break;

            if (nHeight != nNewHeight)
            {
                bool bChanged = (nNewPix != static_cast<long>(nHeight * nPPTY));
                if (bChanged)
                    return true;
            }

            // Skip ahead to the last position of the current range.
            nRow = aFwdIter.getLastPos();
        }
        return false;
    }

    }

    bool ScTable::SetRowHeightRange( SCROW nStartRow, SCROW nEndRow, sal_uInt16 nNewHeight,
                                        double nPPTY )
    {
        bool bChanged = false;
        if (ValidRow(nStartRow) && ValidRow(nEndRow) && mpRowHeights)
        {
            if (!nNewHeight)
            {
                OSL_FAIL("SetRowHeight: Row height zero");
                nNewHeight = ScGlobal::nStdRowHeight;
            }

            bool bSingle = false;   // true = process every row for its own
            ScDrawLayer* pDrawLayer = pDocument->GetDrawLayer();
            if (pDrawLayer)
                if (pDrawLayer->HasObjectsInRows( nTab, nStartRow, nEndRow ))
                    bSingle = true;

            if (bSingle)
            {
                ScFlatUInt16RowSegments::RangeData aData;
                if (mpRowHeights->getRangeData(nStartRow, aData) &&
                    nNewHeight == aData.mnValue && nEndRow <= aData.mnRow2)
                {
                    bSingle = false;    // no difference in this range
                }
            }
            if (bSingle)
            {
                if (nEndRow-nStartRow < 20)
                {
                    if (!bChanged)
                        bChanged = lcl_pixelSizeChanged(*mpRowHeights, nStartRow, nEndRow, nNewHeight, nPPTY);

                    mpRowHeights->setValue(nStartRow, nEndRow, nNewHeight);
                }
                else
                {
                    SCROW nMid = (nStartRow+nEndRow) / 2;
                    if (SetRowHeightRange( nStartRow, nMid, nNewHeight, 1.0 ))
                        bChanged = true;
                    if (SetRowHeightRange( nMid+1, nEndRow, nNewHeight, 1.0 ))
                        bChanged = true;
                }
            }
            else
            {
                if (!bChanged)
                    bChanged = lcl_pixelSizeChanged(*mpRowHeights, nStartRow, nEndRow, nNewHeight, nPPTY);

                mpRowHeights->setValue(nStartRow, nEndRow, nNewHeight);
            }

            if (bChanged)
                InvalidatePageBreaks();
        }
        else
        {
            OSL_FAIL("Invalid row number or no heights");
        }

        return bChanged;
    }

    void ScTable::SetRowHeightOnly( SCROW nStartRow, SCROW nEndRow, sal_uInt16 nNewHeight )
    {
        if (!ValidRow(nStartRow) || !ValidRow(nEndRow) || !mpRowHeights)
            return;

        if (!nNewHeight)
            nNewHeight = ScGlobal::nStdRowHeight;

        mpRowHeights->setValue(nStartRow, nEndRow, nNewHeight);
    }

    void ScTable::SetManualHeight( SCROW nStartRow, SCROW nEndRow, bool bManual )
    {
        if (ValidRow(nStartRow) && ValidRow(nEndRow) && pRowFlags)
        {
            if (bManual)
                pRowFlags->OrValue( nStartRow, nEndRow, CRFlags::ManualSize);
            else
                pRowFlags->AndValue( nStartRow, nEndRow, ~CRFlags::ManualSize);
        }
        else
        {
            OSL_FAIL("Invalid row number or no column flags");
        }
    }

    sal_uInt16 ScTable::GetColWidth( SCCOL nCol, bool bHiddenAsZero ) const
    {
        OSL_ENSURE(ValidCol(nCol),"wrong column number");

        if (ValidCol(nCol) && mpColFlags && mpColWidth)
        {
            if (bHiddenAsZero && ColHidden(nCol))
                return 0;
            else
                return mpColWidth->GetValue(nCol);
        }
        else
            return sal_uInt16(STD_COL_WIDTH);
    }

    sal_uLong ScTable::GetColWidth( SCCOL nStartCol, SCCOL nEndCol ) const
    {
        if (!ValidCol(nStartCol) || !ValidCol(nEndCol) || nStartCol > nEndCol)
            return 0;

        sal_uLong nW = 0;
        bool bHidden = false;
        SCCOL nLastHiddenCol = -1;
        auto colWidthIt = mpColWidth->begin() + nStartCol;
        for (SCCOL nCol = nStartCol; nCol <= nEndCol; (++nCol <= nEndCol) ? ++colWidthIt : (void)false)
        {
            if (nCol > nLastHiddenCol)
                bHidden = ColHidden(nCol, nullptr, &nLastHiddenCol);

            if (bHidden)
                continue;

            nW += *colWidthIt;
        }
        return nW;
    }

    sal_uInt16 ScTable::GetOriginalWidth( SCCOL nCol ) const        // always the set value
    {
        OSL_ENSURE(ValidCol(nCol),"wrong column number");

        if (ValidCol(nCol) && mpColWidth)
            return mpColWidth->GetValue(nCol);
        else
            return sal_uInt16(STD_COL_WIDTH);
    }

    sal_uInt16 ScTable::GetCommonWidth( SCCOL nEndCol ) const
    {
        //  get the width that is used in the largest continuous column range (up to nEndCol)

        if ( !ValidCol(nEndCol) )
        {
            OSL_FAIL("wrong column");
            nEndCol = MAXCOL;
        }

        sal_uInt16 nMaxWidth = 0;
        sal_uInt16 nMaxCount = 0;
        SCCOL nRangeStart = 0;
        while ( nRangeStart <= nEndCol )
        {
            //  skip hidden columns
            while ( nRangeStart <= nEndCol && ColHidden(nRangeStart) )
                ++nRangeStart;
            if ( nRangeStart <= nEndCol )
            {
                sal_uInt16 nThisCount = 0;
                auto colWidthIt = mpColWidth->begin() + nRangeStart;
                sal_uInt16 nThisWidth = *colWidthIt;
                SCCOL nRangeEnd = nRangeStart;
                while ( nRangeEnd <= nEndCol && *colWidthIt == nThisWidth )
                {
                    ++nThisCount;
                    ++nRangeEnd;
                    ++colWidthIt;

                    //  skip hidden columns
                    while ( nRangeEnd <= nEndCol && ColHidden(nRangeEnd) )
                    {
                        ++nRangeEnd;
                        ++colWidthIt;
                    }
                }

                if ( nThisCount > nMaxCount )
                {
                    nMaxCount = nThisCount;
                    nMaxWidth = nThisWidth;
                }

                nRangeStart = nRangeEnd;        // next range
            }
        }

        return nMaxWidth;
    }

    sal_uInt16 ScTable::GetRowHeight( SCROW nRow, SCROW* pStartRow, SCROW* pEndRow, bool bHiddenAsZero ) const
    {
        OSL_ENSURE(ValidRow(nRow),"Invalid row number");

        if (ValidRow(nRow) && mpRowHeights)
        {
            if (bHiddenAsZero && RowHidden( nRow, pStartRow, pEndRow))
                return 0;
            else
            {
                ScFlatUInt16RowSegments::RangeData aData;
                if (!mpRowHeights->getRangeData(nRow, aData))
                {
                    if (pStartRow)
                        *pStartRow = nRow;
                    if (pEndRow)
                        *pEndRow = nRow;
                    // TODO: What should we return in case the search fails?
                    return 0;
                }

                // If bHiddenAsZero, pStartRow and pEndRow were initialized to
                // boundaries of a non-hidden segment. Assume that the previous and
                // next segment are hidden then and limit the current height
                // segment.
                if (pStartRow)
                    *pStartRow = (bHiddenAsZero ? std::max( *pStartRow, aData.mnRow1) : aData.mnRow1);
                if (pEndRow)
                    *pEndRow = (bHiddenAsZero ? std::min( *pEndRow, aData.mnRow2) : aData.mnRow2);
                return aData.mnValue;
            }
        }
        else
        {
            if (pStartRow)
                *pStartRow = nRow;
            if (pEndRow)
                *pEndRow = nRow;
            return ScGlobal::nStdRowHeight;
        }
    }

    sal_uLong ScTable::GetRowHeight( SCROW nStartRow, SCROW nEndRow, bool bHiddenAsZero ) const
    {
        OSL_ENSURE(ValidRow(nStartRow) && ValidRow(nEndRow),"wrong row number");

        if (ValidRow(nStartRow) && ValidRow(nEndRow) && mpRowHeights)
        {
            sal_uLong nHeight = 0;
            SCROW nRow = nStartRow;
            while (nRow <= nEndRow)
            {
                SCROW nLastRow = -1;
                if (!( ( RowHidden(nRow, nullptr, &nLastRow) ) && bHiddenAsZero ) )
                {
                    if (nLastRow > nEndRow)
                        nLastRow = nEndRow;
                    nHeight += mpRowHeights->getSumValue(nRow, nLastRow);
                }
                nRow = nLastRow + 1;
            }
            return nHeight;
        }
        else
            return (nEndRow - nStartRow + 1) * static_cast<sal_uLong>(ScGlobal::nStdRowHeight);
    }

    sal_uLong ScTable::GetScaledRowHeight( SCROW nStartRow, SCROW nEndRow, double fScale ) const
    {
        OSL_ENSURE(ValidRow(nStartRow) && ValidRow(nEndRow),"wrong row number");

        if (ValidRow(nStartRow) && ValidRow(nEndRow) && mpRowHeights)
        {
            sal_uLong nHeight = 0;
            SCROW nRow = nStartRow;
            while (nRow <= nEndRow)
            {
                SCROW nLastRow = -1;
                if (!RowHidden(nRow, nullptr, &nLastRow))
                {
                    if (nLastRow > nEndRow)
                        nLastRow = nEndRow;

                    // #i117315# can't use getSumValue, because individual values must be rounded
                    while (nRow <= nLastRow)
                    {
                        ScFlatUInt16RowSegments::RangeData aData;
                        if (!mpRowHeights->getRangeData(nRow, aData))
                            return nHeight;   // shouldn't happen

                        SCROW nSegmentEnd = std::min( nLastRow, aData.mnRow2 );

                        // round-down a single height value, multiply resulting (pixel) values
                        sal_uLong nOneHeight = static_cast<sal_uLong>( aData.mnValue * fScale );
                        nHeight += nOneHeight * ( nSegmentEnd + 1 - nRow );

                        nRow = nSegmentEnd + 1;
                    }
                }
                nRow = nLastRow + 1;
            }
            return nHeight;
        }
        else
            return static_cast<sal_uLong>((nEndRow - nStartRow + 1) * ScGlobal::nStdRowHeight * fScale);
    }

    sal_uInt16 ScTable::GetOriginalHeight( SCROW nRow ) const       // non-0 even if hidden
    {
        OSL_ENSURE(ValidRow(nRow),"wrong row number");

        if (ValidRow(nRow) && mpRowHeights)
            return mpRowHeights->getValue(nRow);
        else
            return ScGlobal::nStdRowHeight;
    }

    //  Column/Row -Flags

    SCROW ScTable::GetHiddenRowCount( SCROW nRow ) const
    {
        if (!ValidRow(nRow))
            return 0;

        SCROW nLastRow = -1;
        if (!RowHidden(nRow, nullptr, &nLastRow) || !ValidRow(nLastRow))
            return 0;

        return nLastRow - nRow + 1;
    }

    //TODO: combine ShowRows / DBShowRows

    void ScTable::ShowCol(SCCOL nCol, bool bShow)
    {
        if (ValidCol(nCol))
        {
            bool bWasVis = !ColHidden(nCol);
            if (bWasVis != bShow)
            {
                SetColHidden(nCol, nCol, !bShow);

                ScChartListenerCollection* pCharts = pDocument->GetChartListenerCollection();
                if ( pCharts )
                    pCharts->SetRangeDirty(ScRange( nCol, 0, nTab, nCol, MAXROW, nTab ));
            }
        }
        else
        {
            OSL_FAIL("Invalid column number or no flags");
        }
    }

    void ScTable::ShowRow(SCROW nRow, bool bShow)
    {
        if (ValidRow(nRow) && pRowFlags)
        {
            bool bWasVis = !RowHidden(nRow);
            if (bWasVis != bShow)
            {
                SetRowHidden(nRow, nRow, !bShow);
                if (bShow)
                    SetRowFiltered(nRow, nRow, false);
                ScChartListenerCollection* pCharts = pDocument->GetChartListenerCollection();
                if ( pCharts )
                    pCharts->SetRangeDirty(ScRange( 0, nRow, nTab, MAXCOL, nRow, nTab ));

                InvalidatePageBreaks();
            }
        }
        else
        {
            OSL_FAIL("Invalid row number or no flags");
        }
    }

    void ScTable::DBShowRow(SCROW nRow, bool bShow)
    {
        if (ValidRow(nRow) && pRowFlags)
        {
            //  Always set filter flag; unchanged when Hidden
            bool bChanged = SetRowHidden(nRow, nRow, !bShow);
            SetRowFiltered(nRow, nRow, !bShow);

            if (bChanged)
            {
                ScChartListenerCollection* pCharts = pDocument->GetChartListenerCollection();
                if ( pCharts )
                    pCharts->SetRangeDirty(ScRange( 0, nRow, nTab, MAXCOL, nRow, nTab ));

                if (pOutlineTable)
                    UpdateOutlineRow( nRow, nRow, bShow );

                InvalidatePageBreaks();
            }
        }
        else
        {
            OSL_FAIL("Invalid row number or no flags");
        }
    }

    void ScTable::DBShowRows(SCROW nRow1, SCROW nRow2, bool bShow)
    {
        SCROW nStartRow = nRow1;
        while (nStartRow <= nRow2)
        {
            SCROW nEndRow = -1;
            bool bWasVis = !RowHiddenLeaf(nStartRow, nullptr, &nEndRow);
            if (nEndRow > nRow2)
                nEndRow = nRow2;

            bool bChanged = ( bWasVis != bShow );

            SetRowHidden(nStartRow, nEndRow, !bShow);
            SetRowFiltered(nStartRow, nEndRow, !bShow);

            if ( bChanged )
            {
                ScChartListenerCollection* pCharts = pDocument->GetChartListenerCollection();
                if ( pCharts )
                    pCharts->SetRangeDirty(ScRange( 0, nStartRow, nTab, MAXCOL, nEndRow, nTab ));
            }

            nStartRow = nEndRow + 1;
        }

        //  #i12341# For Show/Hide rows, the outlines are updated separately from the outside.
        //  For filtering, the changes aren't visible to the caller, so UpdateOutlineRow has
        //  to be done here.
        if (pOutlineTable)
            UpdateOutlineRow( nRow1, nRow2, bShow );
    }

    void ScTable::ShowRows(SCROW nRow1, SCROW nRow2, bool bShow)
    {
        SCROW nStartRow = nRow1;

        // #i116164# if there are no drawing objects within the row range, a single HeightChanged call is enough
        ScDrawLayer* pDrawLayer = pDocument->GetDrawLayer();
        bool bHasObjects = pDrawLayer && pDrawLayer->HasObjectsInRows( nTab, nRow1, nRow2 );

        while (nStartRow <= nRow2)
        {
            SCROW nEndRow = -1;
            bool bWasVis = !RowHiddenLeaf(nStartRow, nullptr, &nEndRow);
            if (nEndRow > nRow2)
                nEndRow = nRow2;

            bool bChanged = ( bWasVis != bShow );

            SetRowHidden(nStartRow, nEndRow, !bShow);
            if (bShow)
                SetRowFiltered(nStartRow, nEndRow, false);

            if ( bChanged )
            {
                ScChartListenerCollection* pCharts = pDocument->GetChartListenerCollection();
                if ( pCharts )
                    pCharts->SetRangeDirty(ScRange( 0, nStartRow, nTab, MAXCOL, nEndRow, nTab ));

                InvalidatePageBreaks();
            }

            nStartRow = nEndRow + 1;
        }

        if ( !bHasObjects )
        {
            // #i116164# set the flags for the whole range at once
            SetRowHidden(nRow1, nRow2, !bShow);
            if (bShow)
                SetRowFiltered(nRow1, nRow2, false);
        }
    }

    bool ScTable::IsDataFiltered(SCCOL nColStart, SCROW nRowStart, SCCOL nColEnd, SCROW nRowEnd) const
    {
        for (SCROW i = nRowStart; i <= nRowEnd; ++i)
        {
            if (RowHidden(i))
                return true;
        }
        for (SCCOL i = nColStart; i <= nColEnd; ++i)
        {
            if (ColHidden(i))
                return true;
        }
        return false;
    }

    bool ScTable::IsDataFiltered(const ScRange& rRange) const
    {
        return IsDataFiltered(rRange.aStart.Col(), rRange.aStart.Row(),
                    rRange.aEnd.Col(), rRange.aEnd.Row());
    }

    void ScTable::SetRowFlags( SCROW nRow, CRFlags nNewFlags )
    {
        if (ValidRow(nRow) && pRowFlags)
            pRowFlags->SetValue( nRow, nNewFlags);
        else
        {
            OSL_FAIL("Invalid row number or no flags");
        }
    }

    void ScTable::SetRowFlags( SCROW nStartRow, SCROW nEndRow, CRFlags nNewFlags )
    {
        if (ValidRow(nStartRow) && ValidRow(nEndRow) && pRowFlags)
            pRowFlags->SetValue( nStartRow, nEndRow, nNewFlags);
        else
        {
            OSL_FAIL("Invalid row number(s) or no flags");
        }
    }

    CRFlags ScTable::GetColFlags( SCCOL nCol ) const
    {
        if (ValidCol(nCol) && mpColFlags)
            return mpColFlags->GetValue(nCol);
        else
            return CRFlags::NONE;
    }

    CRFlags ScTable::GetRowFlags( SCROW nRow ) const
    {
        if (ValidRow(nRow) && pRowFlags)
            return pRowFlags->GetValue(nRow);
        else
            return CRFlags::NONE;
    }

    SCROW ScTable::GetLastFlaggedRow() const
    {
        SCROW nLastFound = 0;
        if (pRowFlags)
        {
            SCROW nRow = pRowFlags->GetLastAnyBitAccess( CRFlags::All );
            if (ValidRow(nRow))
                nLastFound = nRow;
        }

        if (!maRowManualBreaks.empty())
            nLastFound = ::std::max(nLastFound, *maRowManualBreaks.rbegin());

        if (mpHiddenRows)
        {
            SCROW nRow = mpHiddenRows->findLastTrue();
            if (ValidRow(nRow))
                nLastFound = ::std::max(nLastFound, nRow);
        }

        if (mpFilteredRows)
        {
            SCROW nRow = mpFilteredRows->findLastTrue();
            if (ValidRow(nRow))
                nLastFound = ::std::max(nLastFound, nRow);
        }

        return nLastFound;
    }

    SCCOL ScTable::GetLastChangedCol() const
    {
        if ( !mpColFlags )
            return 0;

        SCCOL nLastFound = 0;
        const auto nColSize = aCol.size();
        auto colWidthIt = mpColWidth->begin() + 1;
        for (SCCOL nCol = 1; nCol < nColSize; (++nCol < nColSize) ? ++colWidthIt : (void)false)
            if ((mpColFlags->GetValue(nCol) & CRFlags::All) || (*colWidthIt != STD_COL_WIDTH))
                nLastFound = nCol;

        return nLastFound;
    }

    SCROW ScTable::GetLastChangedRow() const
    {
        if ( !pRowFlags )
            return 0;

        SCROW nLastFlags = GetLastFlaggedRow();

        // Find the last row position where the height is NOT the standard row
        // height.
        // KOHEI: Test this to make sure it does what it's supposed to.
        SCROW nLastHeight = mpRowHeights->findLastTrue(ScGlobal::nStdRowHeight);
        if (!ValidRow(nLastHeight))
            nLastHeight = 0;

        return std::max( nLastFlags, nLastHeight);
    }

    bool ScTable::UpdateOutlineCol( SCCOL nStartCol, SCCOL nEndCol, bool bShow )
    {
        if (pOutlineTable && mpColFlags)
        {
            return pOutlineTable->GetColArray().ManualAction( nStartCol, nEndCol, bShow, *this, true );
        }
        else
            return false;
    }

    bool ScTable::UpdateOutlineRow( SCROW nStartRow, SCROW nEndRow, bool bShow )
    {
        if (pOutlineTable && pRowFlags)
            return pOutlineTable->GetRowArray().ManualAction( nStartRow, nEndRow, bShow, *this, false );
        else
            return false;
    }

    void ScTable::ExtendHidden( SCCOL& rX1, SCROW& rY1, SCCOL& rX2, SCROW& rY2 )
    {
        // Column-wise expansion

        while (rX1 > 0 && ColHidden(rX1-1))
            --rX1;

        while (rX2 < MAXCOL && ColHidden(rX2+1))
            ++rX2;

        // Row-wise expansion

        if (rY1 > 0)
        {
            ScFlatBoolRowSegments::RangeData aData;
            if (mpHiddenRows->getRangeData(rY1-1, aData) && aData.mbValue)
            {
                SCROW nStartRow = aData.mnRow1;
                if (ValidRow(nStartRow))
                    rY1 = nStartRow;
            }
        }
        if (rY2 < MAXROW)
        {
            SCROW nEndRow = -1;
            if (RowHidden(rY2+1, nullptr, &nEndRow) && ValidRow(nEndRow))
                rY2 = nEndRow;
        }
    }

    void ScTable::StripHidden( SCCOL& rX1, SCROW& rY1, SCCOL& rX2, SCROW& rY2 )
    {
        while ( rX2>rX1 && ColHidden(rX2) )
            --rX2;
        while ( rX2>rX1 && ColHidden(rX1) )
            ++rX1;

        if (rY1 < rY2)
        {
            ScFlatBoolRowSegments::RangeData aData;
            if (mpHiddenRows->getRangeData(rY2, aData) && aData.mbValue)
            {
                SCROW nStartRow = aData.mnRow1;
                if (ValidRow(nStartRow) && nStartRow >= rY1)
                    rY2 = nStartRow;
            }
        }

        if (rY1 < rY2)
        {
            SCROW nEndRow = -1;
            if (RowHidden(rY1, nullptr, &nEndRow) && ValidRow(nEndRow) && nEndRow <= rY2)
                rY1 = nEndRow;
        }
    }

    //  Auto-Outline

    template< typename T >
    short DiffSign( T a, T b )
    {
        return (a<b) ? -1 :
                (a>b) ? 1 : 0;
    }

    namespace {

    class OutlineArrayFinder
    {
        ScRange maRef;
        SCCOL mnCol;
        SCTAB mnTab;
        ScOutlineArray* mpArray;
        bool mbSizeChanged;

    public:
        OutlineArrayFinder(const ScRange& rRef, SCCOL nCol, SCTAB nTab, ScOutlineArray* pArray, bool bSizeChanged) :
            maRef(rRef), mnCol(nCol), mnTab(nTab), mpArray(pArray),
            mbSizeChanged(bSizeChanged) {}

        bool operator() (size_t nRow, const ScFormulaCell* pCell)
        {
            SCROW nRow2 = static_cast<SCROW>(nRow);

            if (!pCell->HasRefListExpressibleAsOneReference(maRef))
                return false;

            if (maRef.aStart.Row() != nRow2 || maRef.aEnd.Row() != nRow2 ||
                maRef.aStart.Tab() != mnTab || maRef.aEnd.Tab() != mnTab)
                return false;

            if (DiffSign(maRef.aStart.Col(), mnCol) != DiffSign(maRef.aEnd.Col(), mnCol))
                return false;

            return mpArray->Insert(maRef.aStart.Col(), maRef.aEnd.Col(), mbSizeChanged);
        }
    };

    }

    void ScTable::DoAutoOutline( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow )
    {
        typedef mdds::flat_segment_tree<SCROW, bool> UsedRowsType;

        bool bSizeChanged = false;

        SCCOL nCol;
        SCROW nRow;
        bool bFound;
        ScRange aRef;

        StartOutlineTable();

                                // Rows

        UsedRowsType aUsed(0, MAXROW+1, false);
        for (nCol=nStartCol; nCol<=nEndCol; nCol++)
            aCol[nCol].FindUsed(nStartRow, nEndRow, aUsed);
        aUsed.build_tree();

        ScOutlineArray& rRowArray = pOutlineTable->GetRowArray();
        for (nRow=nStartRow; nRow<=nEndRow; nRow++)
        {
            bool bUsed = false;
            SCROW nLastRow = nRow;
            aUsed.search_tree(nRow, bUsed, nullptr, &nLastRow);
            if (!bUsed)
            {
                nRow = nLastRow;
                continue;
            }

            bFound = false;
            for (nCol=nStartCol; nCol<=nEndCol && !bFound; nCol++)
            {
                ScRefCellValue aCell = aCol[nCol].GetCellValue(nRow);

                if (aCell.meType != CELLTYPE_FORMULA)
                    continue;

                if (!aCell.mpFormula->HasRefListExpressibleAsOneReference(aRef))
                    continue;

                if ( aRef.aStart.Col() == nCol && aRef.aEnd.Col() == nCol &&
                     aRef.aStart.Tab() == nTab && aRef.aEnd.Tab() == nTab &&
                     DiffSign( aRef.aStart.Row(), nRow ) ==
                        DiffSign( aRef.aEnd.Row(), nRow ) )
                {
                    if (rRowArray.Insert( aRef.aStart.Row(), aRef.aEnd.Row(), bSizeChanged ))
                    {
                        bFound = true;
                    }
                }
            }
        }

        // Column
        ScOutlineArray& rColArray = pOutlineTable->GetColArray();
        for (nCol=nStartCol; nCol<=nEndCol; nCol++)
        {
            if (aCol[nCol].IsEmptyData())
                continue;

            OutlineArrayFinder aFunc(aRef, nCol, nTab, &rColArray, bSizeChanged);
            sc::FindFormula(aCol[nCol].maCells, nStartRow, nEndRow, aFunc);
        }
    }

                                        //  CopyData - for Query in other range

    void ScTable::CopyData( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,
                                SCCOL nDestCol, SCROW nDestRow, SCTAB nDestTab )
    {
        //TODO: if used for multiple rows, optimize after columns!

        ScAddress aSrc( nStartCol, nStartRow, nTab );
        ScAddress aDest( nDestCol, nDestRow, nDestTab );
        ScRange aRange( aSrc, aDest );
        bool bThisTab = ( nDestTab == nTab );
        SCROW nDestY = nDestRow;
        for (SCROW nRow=nStartRow; nRow<=nEndRow; nRow++)
        {
            aSrc.SetRow( nRow );
            aDest.SetRow( nDestY );
            SCCOL nDestX = nDestCol;
            for (SCCOL nCol=nStartCol; nCol<=nEndCol; nCol++)
            {
                aSrc.SetCol( nCol );
                aDest.SetCol( nDestX );
                ScCellValue aCell;
                aCell.assign(*pDocument, ScAddress(nCol, nRow, nTab));

                if (aCell.meType == CELLTYPE_FORMULA)
                {
                    sc::RefUpdateContext aCxt(*pDocument);
                    aCxt.meMode = URM_COPY;
                    aCxt.maRange = aRange;
                    aCxt.mnColDelta = nDestCol - nStartCol;
                    aCxt.mnRowDelta = nDestRow - nStartRow;
                    aCxt.mnTabDelta = nDestTab - nTab;
                    aCell.mpFormula->UpdateReference(aCxt);
                    aCell.mpFormula->aPos = aDest;
                }

                if (bThisTab)
                {
                    aCell.release(aCol[nDestX], nDestY);
                    SetPattern( nDestX, nDestY, *GetPattern( nCol, nRow ) );
                }
                else
                {
                    aCell.release(*pDocument, aDest);
                    pDocument->SetPattern( aDest, *GetPattern( nCol, nRow ) );
                }

                ++nDestX;
            }
            ++nDestY;
        }
    }

    bool ScTable::RefVisible(const ScFormulaCell* pCell)
    {
        ScRange aRef;

        if (pCell->HasOneReference(aRef))
        {
            if (aRef.aStart.Col()==aRef.aEnd.Col() && aRef.aStart.Tab()==aRef.aEnd.Tab())
            {
                SCROW nEndRow;
                if (!RowFiltered(aRef.aStart.Row(), nullptr, &nEndRow))
                    // row not filtered.
                    nEndRow = ::std::numeric_limits<SCROW>::max();

                if (!ValidRow(nEndRow) || nEndRow < aRef.aEnd.Row())
                    return true;    // at least partly visible
                return false;       // completely invisible
            }
        }

        return true;                        // somehow different
    }

    void ScTable::GetUpperCellString(SCCOL nCol, SCROW nRow, OUString& rStr)
    {
        GetInputString(nCol, nRow, rStr);
        rStr = ScGlobal::pCharClass->uppercase(rStr.trim());
    }

    // Calculate the size of the sheet and set the size on DrawPage

    void ScTable::SetDrawPageSize(bool bResetStreamValid, bool bUpdateNoteCaptionPos)
    {
        ScDrawLayer* pDrawLayer = pDocument->GetDrawLayer();
        if( pDrawLayer )
        {
            double fValX = GetColOffset( MAXCOL + 1 ) * HMM_PER_TWIPS;
            double fValY = GetRowOffset( MAXROW + 1 ) * HMM_PER_TWIPS;
            const long nMax = ::std::numeric_limits<long>::max();
            // #i113884# Avoid int32 overflow with possible negative results than can cause bad effects.
            // If the draw page size is smaller than all rows, only the bottom of the sheet is affected.
            long x = ( fValX > static_cast<double>(nMax) ) ? nMax : static_cast<long>(fValX);
            long y = ( fValY > static_cast<double>(nMax) ) ? nMax : static_cast<long>(fValY);

            if ( IsLayoutRTL() )        // IsNegativePage
                x = -x;

            pDrawLayer->SetPageSize( static_cast<sal_uInt16>(nTab), Size( x, y ), bUpdateNoteCaptionPos );
        }

        // #i102616# actions that modify the draw page size count as sheet modification
        // (exception: InitDrawLayer)
        if (bResetStreamValid)
            SetStreamValid(false);
    }

    void ScTable::SetRangeName(std::unique_ptr<ScRangeName> pNew)
    {
        mpRangeName = std::move(pNew);

        //fdo#39792: mark stream as invalid, otherwise new ScRangeName will not be written to file
        SetStreamValid(false);
    }

    ScRangeName* ScTable::GetRangeName() const
    {
        if (!mpRangeName)
            mpRangeName.reset(new ScRangeName);
        return mpRangeName.get();
    }

    sal_uLong ScTable::GetRowOffset( SCROW nRow, bool bHiddenAsZero ) const
    {
        sal_uLong n = 0;
        if ( mpHiddenRows && mpRowHeights )
        {
            if (nRow == 0)
                return 0;
            else if (nRow == 1)
                return GetRowHeight(0, nullptr, nullptr, bHiddenAsZero );

            n = GetTotalRowHeight(0, nRow-1, bHiddenAsZero);
    #if OSL_DEBUG_LEVEL > 0
            if (n == ::std::numeric_limits<unsigned long>::max())
                OSL_FAIL("ScTable::GetRowOffset: row heights overflow");
    #endif
        }
        else
        {
            OSL_FAIL("GetRowOffset: Data missing");
        }
        return n;
    }

    SCROW ScTable::GetRowForHeight(sal_uLong nHeight) const
    {
        sal_uLong nSum = 0;

        ScFlatBoolRowSegments::RangeData aData;

        ScFlatUInt16RowSegments::RangeData aRowHeightRange;
        aRowHeightRange.mnRow2 = -1;
        aRowHeightRange.mnValue = 0; // silence MSVC C4701

        for (SCROW nRow = 0; nRow <= MAXROW; ++nRow)
        {
            if (!mpHiddenRows->getRangeData(nRow, aData))
                // Failed to fetch the range data for whatever reason.
                break;

            if (aData.mbValue)
            {
                // This row is hidden.  Skip ahead all hidden rows.
                nRow = aData.mnRow2;
                continue;
            }

            if (aRowHeightRange.mnRow2 < nRow)
            {
                if (!mpRowHeights->getRangeData(nRow, aRowHeightRange))
                    // Failed to fetch the range data for whatever reason.
                    break;
            }

            nSum += aRowHeightRange.mnValue;

            if (nSum > nHeight)
            {
                if (nRow >= MAXROW)
                    return MAXROW;

                // Find the next visible row.
                ++nRow;

                if (!mpHiddenRows->getRangeData(nRow, aData))
                    // Failed to fetch the range data for whatever reason.
                    break;

                if (aData.mbValue)
                    // These rows are hidden.
                    nRow = aData.mnRow2 + 1;

                return nRow <= MAXROW ? nRow : MAXROW;
            }
        }
        return -1;
    }

    sal_uLong ScTable::GetColOffset( SCCOL nCol, bool bHiddenAsZero ) const
    {
        sal_uLong n = 0;
        if ( mpColWidth )
        {
            auto colWidthIt = mpColWidth->begin();
            for (SCCOL i = 0; i < nCol; (++i < nCol) ? ++colWidthIt : (void)false)
                if (!( bHiddenAsZero && ColHidden(i) ))
                    n += *colWidthIt;
        }
        else
        {
            OSL_FAIL("GetColumnOffset: Data missing");
        }
        return n;
    }

    /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

↑ V547 Expression '!bChanged' is always true.

↑ V547 Expression '!bChanged' is always true.