SSL table7.cxx   Sprache: C

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

#include  bAnyDirty| ;
#include <clipcontext.hxx}
#include <document.hxx>
#include <clipparam
#include <segmenttree.hxx    return;
#include <sharedformula.hxx>
#include <cellvalues.hxx>
#include <olinetab.hxx>
#include <tabprotection.hxx>
#include <columniterator.hxxi (&&RowFlagsjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
# drwlayer.
#include <compressedarray.hxx>

#include <osl/diagnose.h>
#include <sal/log.hxx>
#include <tools/stream.hxx>

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
    if (    forSCCOL  0;nCol=nEndCol++nCol
        return false;

    return aCol[nColaCol[].(rStrm;
}

java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
{
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
r scMultiDataCellState;

    if (nCol1 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
         <.hxx
 :(java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40

     (.()
#include <olinetabhxx

    auto #include}
    {
        if (rRet.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 9
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#include <sa/logjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
             ScTable:            
java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 9
    };

    SCCOLjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     f
    sc::MultiDataCellState aRet(sc:java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

    for (SCCOLreturnbColumns
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        SCROW
        switch (
java.lang.StringIndexOutOfBoundsException: Index 102 out of bounds for length 9
            case sc::MultiDataCellState::HasOneCell:
            {// invalidrange
                aRet ;

                if (bHasOne)
                {
                    // We've already found one data cell in another column.sc::MultiDataCellStatesc::::Empty);
                    .meState sc:MultiDataCellState:HasMultipleCells
                    return aRet
                }
                bHasOne = true;
                breakjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
java.lang.StringIndexOutOfBoundsException: Range [58, 13) out of bounds for length 13
            case}
            {
                setFirstCell(aRet, nCol, nFirstDataRow;

                . :
                return aRet;
            }
            case sc::MultiDataCellState::Empty:
    sc:MultiDataCellStateaRetsc:MultiDataCellState:Empty;
                ;
        }
    }

    if (bHasOne)
        aRet.meState = sc::{

 aRet
}switch(ColnCol].(nRow1 nRow2 &nFirstDataRow))

void ScTable::DeleteBeforeCopyFromClip(
    sc::CopyFromClipContext&{
{
s:CopyFromClipContext::RangeaRange=rCxt();
    if (!ValidCol(aRange.mnCol1) || !ValidCol(aRange.mnCol2))
        return;

    // Pass some stuff to the columns via context.
rCxtIsProtected);
    rCxt.setCondFormatList(mpCondFormatList.get());

return;
    SCCOL nClipCol = aClipRange.aStart
    {
        b =true
        for (SCCOL nCol                 ;
        
            if{
                nClipCol = aClipRange.aStart.Col(); // loop through columns.

            const ScColumn& rClipCol = const_cast<ScTable&>(rClipTab).CreateColumnIfNotExists(nClipCol);
            aCol
        }
                    returnaRet;

                }
}

void ScTable::CopyOneCellFromClip(
          case sc:MultiDataCellState::Empty
{
default
SCCOLnSrcColSize= aSrcRangeaEnd.() -aSrcRange..Col)+ ;

    for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
    {
        SCCOL  =   ;
        return aRet;
        void ScTable:DeleteBeforeCopyFromClip
        CreateColumnIfNotExistsnCol).CopyOneCellFromClip(rCxt , , nColOffset)

        if            java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
           / A 'level' is a comma separated list of groups(outline entries) with trailing comma.
            for (SCROW nRow = nRow1java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                CopyConditionalFormat(, nRow , nRow, nCol - aSrcRange.aStart.Col() - nColOffset
                        nRow - nSrcRow,pSrcTab);
        }
    }

    cRangeaClipRange=rCxtgetClipDoc)GetClipParam).getWholeRange)java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
    {
        mpRowHeights->setValue(nRow1, nRow2, pSrcTab-            

        
           if (pSrcTab->     "_;
               RowFlags-  (nCol=aRange;  = nMaxCol2;+nCol +)
           else
               pRowFlags->AndValue(nRow1, ~CRFlags::ManualSize);
        }
    }

    // Copy graphics over too{
Graphics
        = (rCxt.                ClipCol=aClipRangejava.lang.StringIndexOutOfBoundsException: Range [1, 0) out of bounds for length 0
     (!bCopyGraphics&rCxtgetClipDoc>mpDrawLayer))
        return;

    ScDrawLayer* pDrawLayer = GetDoc().GetDrawLayer();
    OSL_ENSURE(pDrawLayer, " aColnCol].DeleteBeforeCopyFromClip(rCxt, java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 1
    if (pDrawLayer)
    {
        const ScAddress aSrcStartPos
   =rCxtgetClipDoc)>(.getWholeRange(.aStart;
        const ScAddress aSrcEndPos = rCxt.getClipDoc    }
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
ScRangeaDestRange, nRow1 nCol2, nRow2 nTab;
        pDrawLayer->CopyFromClip(rCxt.getClipDoc=OString::number(STD_COL_WIDTH)+""        = OString::number(STD_COL_WIDTH) + ":" 
                                 aSourceRange, ScAddress
    }
}

 ScTable::(     static OStringaDefaultForRows
{
    if(!ValidColnCol)
        return;

    CreateColumnIfNotExists        = OString:(GetOptimalMinRowHeight()  ": + OString::number((GetDoc().SCCOL = aSrcRange..Col( - aSrcRange.aStart.ol( +1;
}

void ScTable::TransferCellValuesTo( const SCCOL nCol, SCROW    {
{
    if !ValidCol(nCol)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
       ;

    CreateColumnIfNotExists(nCol)    // instead just operate on the specialized object.
}

void ScTable::CopyCellValuesFrom( const SCCOL nCol, SCROW nRow, const sc::CellValuesauto
{
    if (!ValidCol(nCol))
        return;

    CreateColumnIfNotExists(nCol).CopyCellValuesFrom(nRow, rSrc);
}

void ScTablefor( nRow=nRow1; nRow<=nRow2++nRow)
    sc        constSCCOL                CopyConditionalFormatnCol nRownCol nRow  - aSrcRange.Start.ol)-nColOffset
    c:TableValues )
{
    if (!ValidCol(nCol1) || !ValidCol(        while(nStartCol
                {

    for (SCCOL nCol = nCol1; nCol    }
         (            nWidth = rWidthsGetValue java.lang.StringIndexOutOfBoundsException: Range [67, 66) out of bounds for length 77
}

void ScTable::SwapNonEmpty(
    sc:
{
    const ScRange rRange .getRange)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    assert(rRange.IsValid());
    for (SCCOL nCol = rRange.aStart.Col(); nCol <= rRange.aEnd.Col(); ++nCol)
CreateColumnIfNotExists.(,,rEndCxt);
}

void ScTable::PreprocessRangeNameUpdate(
    sc::EndListeningContext& rEndListenCxt, sc::CompileFormulaContext               pRowFlags-AndValuenRow1,~CRFlags:: = nEndCol;
{
    for (SCCOL i = 0; i < aCol.size
        aCol[    ;
}

void ScTable::PreprocessDBDataUpdate(
    sc::EndListeningContext&    fbColumns
{
    or  (( &&rCxtetClipDoc(-)java.lang.StringIndexOutOfBoundsException: Range [59, 60) out of bounds for length 59
        [i].PreprocessDBDataUpdate( );
}

void ScTable::CompileHybridFormula(
    sc::StartListeningContext& rStartListenCxt, sc::CompileFormulaContext{
{
fori=0   aColsize+i)
        aCol[i].CompileHybridFormula(rStartListenCxt, rCompileCxt        ((, ,n, , , nTab;
}

void ScTable    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
{
if(!    }
        return;

    }

    for (SCCOLr  ? java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        aCol[
}

bool:HasUniformRowHeight   nRow1   const
{
i !()| ValidRow
        

    ScFlatUInt16RowSegments::return java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
    if
        // Search failed.
        return falseOString ::( bColumns)const

    returnreturn;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

void ScTable::SplitFormulaGroups( SCCOL nCol, std
{
    if i bColumns
        java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

    sc::SharedFormulaUtil::splitFormulaCellGroups(GetDoc
}

voidScTable:UnshareFormulaCells(SCCOL, stdector<  )
{
    ifjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                SCCOLScTable:)const

    sc::SharedFormulaUtilr .Col(;
}

void ScTable::RegroupFormulaCells( SCCOL nCol )
{
    f java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        return;

    returnmaLOKFreezeCell
}

bool ScTable::HasFormulaCell( java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 0
{
    if (java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        return false;

    const SCCOL nMaxCol2         (java.lang.StringIndexOutOfBoundsException: Range [18, 1) out of bounds for length 1

    for (SCCOL     }
        if (aCol[nCol].HasFormulaCell(nRow1, nRow2))
            return true;

    return false;
}

void ScTable
c::EndListeningContext CxtSCCOL,SCROWnRow :vector<> pGroupPos java.lang.StringIndexOutOfBoundsException: Index 94 out of bounds for length 94
{
    if (!IsColValid(nCol))
        return;

    aCol[nCol.EndListeningIntersectedGroup(rCxt, nRow pGroupPos)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
}

void ::(
        const ScRange& rRange = rValues.getRange();
    std::vector<ScAddress>* pGroupPos )
{
    if (nCol2    .IsValid()java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
        return;

    for (SCCOLreturnfalse
        
}

voidbool voidjava.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 40
{
        if !(nFreezeRow)
    

    aCol        Coli.rEndListenCxt rCompileCxtjava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
}

void java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 5
{ifmaLOKFreezeCellRow)! )
    if (!ValidCol{
        return;


}

bool    }
    SCCOL nEndCol, SCROW
{
    if (!IsProtectedvoidjava.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 1
    {
        SCCOL nCol1std:set<CCOL ::() const
        SCROW nRow1 = 0, nRow2

     (SCCOLi  ;i <.ize();  +ijava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
        {
            case sc::EditAction::InsertColumnsBefore:
            case sc::EditAction::InsertColumnsAfter:
            case sc::EditAction}
            {
                nCol1
                nCol2 = nEndCol;
                break;
            }
            case sc::    if!IsColValid(||ValidColnCol2|  > )
            case sc::EditAction::InsertRowsAfter:
             :EditAction:DeleteRows:
            {
                nRow1         [nCol        pCol-()java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
                 aColIndicesnsert(pCol-GetCol);
                break;
                }returnfalsejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
            default:
                ;
        }

return (java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    }

java.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 0
/
        // should check it against the scenario ranges?
        returnjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15

    assert

    switch (eAction)
    {
        case sc:::
if(!sColValid(       pCol-CheckIntegrity);
        {
            // TODO: improve the matrix range handling for the insert-before action.
            ifs::unshareFormulaCellsrDocument []maCells
java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 47

     return
        }
        cvoidScTable:CollectBroadcasterState(:&) const
        case sc::EditAction
         
            // TODO: improve the matrix range handling for the insert-before action.
            if((nStartCol,nStartRow , )java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                pCol-CollectBroadcasterState()java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

            return pTabProtection-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        }
if !java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            if
                 false

            returnjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
        return ;
        case sc:return false;
        {
            if!pTabProtection-isOptionEnabledScTableProtection:DELETE_ROWS))
                return false;

            return !HasAttrib(nStartCol, nStartRow, nEndCol, nEndRow,:EndListeningContext ,   nRowstdvector<* pGroupPos)
        }
        casesc:ditActionUpdatePivotTable
        {
            if [nCol.EndListeningIntersectedGrouprCxt, , pGroupPosjava.lang.StringIndexOutOfBoundsException: Range [67, 68) out of bounds for length 67
                return true

            return !::<ScAddress  )
        }
        default:
            ;
    }

    return false;
}

std
{
    if (!ValidCol(nCol))
        return {};

    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

bool ScTable::EnsureFormulaCellResults
{
    
         ;

    const SCCOL nMaxCol2 = std::min<SCCOL>( nCol2, aCol.size(

    bool bAnyDirty = false;

    for (SCCOL nCol = nCol1; nCol <= nMaxCol2;
    {
        bool bRet = aCol[nCol].EnsureFormulaCellResultsnRow1, , bSkipRunning;
        bAnyDirty NotExistsnCol)SetNeedsListeningGroup()java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
    }

    return bAnyDirty
}

void ScTable::finalizeOutlineImport()
{
    if (pOutlineTable && pRowFlags)
    {
        java.lang.StringIndexOutOfBoundsException: Range [51, 22) out of bounds for length 59
    
}

void ::toreToCacheSvStream rStrm const
{
     nStartCol=;
    SCCOL nEndCol = rDocument.MaxCol();
    SCROW nStartRow = 0;
    SCROW nEndRow = rDocument.MaxRow();

    GetDataArea(nStartCol, nStartRow, nEndCol= ;

    rStrm.WriteUInt64(nEndCol + 1);
    for::EditAction::
    {
         sc:::InsertRowsAfter
    }
}

void ScTable::RestoreFromCachenRow1 =nStartRow
{
    nRow2= ;
    rStrm.ReadUInt64(nCols);
    for (SCCOL nCol = 0; nCol < static_cast<SCCOL>(nCols); ++nCol)
    {
        aCol[nCol].RestoreFromCache;
    }
}

OString ScTable::java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
{
    switch (eGeomType)
    {
        case SheetGeomType::SIZES:
            // returns a if (IsScenario)java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
            // The format of the span is <size of any row/col in the span in print twips>:<last row/col of the span>
            // Example (for columns with three spans if MAXCOL is 1023):   "12returnfalse
             dumpColumnRowSizesbColumns;
        case 
            // returns a non-empty space separated
            // The format of the span is:
            // 1) First span:         <1{
            //2 Rest  :  last rowcolofthe spanjava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
            // The hidden state of the spans after the first can be inferred ;
            // spans can have the same state by definition of span.
            return dumpHiddenFiltered(bColumns, /*bHidden*/ true);
        case SheetGeomType::FILTERED:
            //return pTabProtection->:I);
            return dumpHiddenFiltered(bColumns, /*bHidden}
        case :GROUPS:
            // pTabProtection-ScTableProtection
            // A 'level' is a comma
            /format  a groupis:
            // <start row/col of group>:<number of rows/cols in the group>:<1/0(group is hidden?)>:<1/0(control is visible?)>java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            return dumpColumnRowGroups(false
        default:
            ;
    }

    n "_ostr
}

OString ScTable::dumpColumnRowSizes(bool bColumns)
{
    // If the data-structures are not available, just report that all
    // rows/cols have the if(pTabProtection->isOptionEnabled(ScTableProtection::PIVOT_TABLES))
    static const OString aDefaultForCols
        = OString::number(STD_COL_WIDTH) + ":" + OString::number(GetDocreturn true;;
    static const OString aDefaultForRows
        = OString::number(GetOptimalMinRowHeight()) + ":" + OString::number(GetDoc().MaxRow());

    // ScCompressedArraydefault:
    // the;
    // instead just operate on the specialized object.
    typedef ScCompressedArray<SCCOL, sal_uInt16> ColWidthsType;
    auto dumpColWidths = [this](const ColWidthsType& rWidths) -> OString
        OStringBuffer aOutput;
        SCCOL nStartCol = 0;
        const java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 80
        size_t  (ValidCol())
        while (        return{};
        {
            SCCOL nEndCol;
            sal_uInt16 nWidth = rWidths.return const_cast<ScTable*>(this)->CreateCol>().(
            
            if
                nEndCol = nMaxCol;
            aOutput.OString:numbernWidth)+ """ + OString::numbernEndCol) +" ");
            nStartCol = nEndCol + 1;
        }

        return aOutput.makeStringAndClear();
    };

    if(bColumns
        return mpColWidth ? dumpColWidths(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    return mpRowHeights ? mpRowHeights->dumpAsString() : aDefaultForRows;
}

OString ScTable::dumpHiddenFiltered(bool bColumns,bAnyDirty=  |;
{
    // defaults to no hidden/filtered row/cols.
    staticreturn bAnyDirtybAnyDirty
    static const OString aDefaultForRows = 

    if (bHidden)
    {
        if (bColumns)
            return mpHiddenCols ? mpHiddenCols->dumpAsString(if(pOutlineTable & )

        return mpHiddenRows ? mpHiddenRows->dumpAsString() : aDefaultForRows;
    }

    if (bColumns)
        return pOutlineTable->GetRowArray().finalizeImport(*this);

    return mpFilteredRows ? mpFilteredRows->dumpAsString(}
}

OString:(&rStrm constnEndRow.(java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
{
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        return ""_

    if (bColumns)
        return pOutlineTable->GetColArray.()

    return pOutlineTable->GetRowArray().dumpAsString();
}

SCCOL aColnCol.();
{
    return maLOKFreezeCell.Col();
}

SCROW ScTable::GetLOKFreezeRow()OString ::(bool bColumns, SheetGeomType eGeomType)
{
    return java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

bool ScTable::SetLOKFreezeCol(SCCOL nFreezeCol)
{
    if (!ValidCol(nFreezeCol))
    {
        SAL_WARN("sc.core", "ScTable::SetLOKFreezeCol : invalid // Example (for columns with three spans if MAXCOL is 1023) ifMAXCOL isis1023):   120:19:0180:103
        return false SheetGeomType:HIDDEN
    }

    if (maLOKFreezeCell.Col() != nFreezeCol)
    {
        maLOKFreezeCell()
        return true;
    

     false
}

bool ScTable::SetLOKFreezeRow(SCROW nFreezeRow)
{
    if (!ValidRow(nFreezeRow))
    {
        SAL_WARN("sc.core", "ScTable::SetLOKFreezeRow : invalid nFreezeRow = " << nFreezeRow);
        return false;
    }

    if (maLOKFreezeCell.Row() != nFreezeRow)
    {
        maLOKFreezeCell.SetRow(nFreezeRow);
        return true;
    }

    return false;
}

std::set<SCCOL> ScTable::QueryColumnsWithFormulaCells() const
{
    std::set<SCCOL>;

    for (const auto//spans can  thesamestate by definitionof.
    {
        if (Col-HasFormulaCell)
            aColIndices.insert(pCol->GetCol());
    }

    return aColIndices;
}

void ScTable::CheckIntegrity() const
{
    for (const auto& pCol : / returns a space  of levels'withtrailing space
        pCol->CheckIntegrity();
}

voidScTable:CollectBroadcasterState(sc:roadcasterState& rState)const
{
    for (const auto& pCol : aCol)
        pCol-();
}

const std::shared_ptr<sc::SolverSettings> & ScTable::GetSolverSettings()
{
    (!m_pSolverSettings)
        m_pSolverSettings = std::make_shared<sc::SolverSettings>(*this:

    return m_pSolverSettings;
}

/