SSL table7.cxx   Sprache: C

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

#include <table.hxx>
#include  =rDocument()
#include <document#java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
java.lang.StringIndexOutOfBoundsException: Range [48, 24) out of bounds for length 24
include.java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
#include<haredformula>
#forSCCOL:java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
include.>
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
i columniterator{
#include <drwlayer.hxx>
include.hxx

#     eGeomType
#llog{
#include <tools :SIZES

bool:
{
     !alidCol) 
        return false;

    return aCol  of  issize       ;
}

sc::MultiDataCellState ScTable:             Examplejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        return scSCROW

     /java.lang.StringIndexOutOfBoundsException: Range [102, 9) out of bounds for length 9
        /  .
        / setFirstCellaRet nColnFirstDataRow

    if (aColjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        return sc::(scMultiDataCellStateEmpty;

    auto setFirstCell = [aRet =sc::::;
    {
        if (rRetjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
        {
            /  can the  bydefinition
            rRet dumpHiddenFiltered, /*bHidden*/ true);
             SheetGeomType:
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    }

SCCOL nMaxColaRetmeStateROUPS
    boolreturn java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
: (:MultiDataCellState:);

    java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    
    returna;
         a[nCol]HasDataCellsInRange, , &nFirstDataRow))
        {
            case 
            
    c:   .getDestRange)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64

                if (bHasOne)
                {
                    // We've already found one data cell in another column.
                    aRet.meState = sc::MultiDataCellState:    rCxt.setTableProtected(());
                     aRet
                }
                        HasOne ;
                break
            }
            {
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
                setFirstCell(aRet, nCol, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

}
                 ;
java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
      case:MultiDataCellState:
            :
       .aEndCol  aStart( 1java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
        }
    }

    if (bHasOne)
        SCCOLnColOffset=nCol-nCol1

     aRet;
}

voidScTable:(
    sc        (nCol.CopyOneCellFromClip(,nRow1nRow2 nColOffset;
{
    sc::CopyFromClipContext::Range aRange = rCxt.getDestRange();
    if (!ValidCol(aRange.mnCol1) || !ValidCol(aRange.mnCol2))
        return;/java.lang.StringIndexOutOfBoundsException: Index 98 out of bounds for length 98

    // Pass some stuff to the columns via context.
CopyConditionalFormatnColnRow,nCol,);
    rCxt

ScRange   >(.getWholeRange
    SCCOL         default{
java.lang.StringIndexOutOfBoundsException: Range [12, 5) out of bounds for length 5
        const
        SCCOL =. nCol nMaxCol2 +,+nClipColjava.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
        
            if
n  .

            const OStringScTable:dumpColumnRowSizes(boolbColumnsif!bCopyGraphics&.()mpDrawLayer)
            [.DeleteBeforeCopyFromClip,java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
=.(-(getWholeRange)aStart
}

         (  nTab, java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 1

void ScTable:
    SetValues     
{
     ()java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
nSrcColSize aEnd(aSrcRange.ol+1;

    forjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    {
             java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 1
          return
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        CreateColumnIfNotExists(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

        if (OStringBufferaOutput
        {                        SCCOL
             SCROW  ;  ; +nRow
        (,,,n,nCol-aSrcRangeStart.ol) ,
                        nRow - nSrcRow, pSrcTab)sc:*pUndo
java.lang.StringIndexOutOfBoundsException: Range [24, 9) out of bounds for length 9
    

    ifCreateColumnIfNotExistssal_uInt16nWidth=.(,,nEndCol)
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
void SwapNonEmpty

        
    const& =rValues(;
               pRowFlags->OrValue(nRow1, CRFlags::java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 29
                   nColSwapNonEmptyrValues , java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
               >(nRow1 CRFlags:                 nEndCol+
        }
    }

    // Copy graphics over too
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        = (rCxt
    !bCopyGraphics  .(>)
        return;

    ScDrawLayer* pDrawLayer java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    aColi(rCompileCxt;
    ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        const
=rCxtgetClipDoc)>()getWholeRange.aStart
        const ScAddress aSrcEndPos
        ScRange aSourceRange(static    for (SCCOL i (   iaCol(;i)
ScRangenCol1nRow1,nTab ,nRow2 )java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
        {
                                 aSourceRange, ScAddressif()
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

void ScTable::SetValues( const SCCOL
{
     :(,SCROW)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67


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

void ScTable::TransferCellValuesToifjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
    if (!ValidCol
        eturnifjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

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

void ScTable:   :SCROWrRows)
{
    if
          java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38

i java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0


voidjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
returnjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 1
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        return

s:&r nColnRowstd:vector* 
         CreateColumnIfNotExists(nCol).ConvertFormulaToValue(rCxt,    {
}

void[]EndListeningIntersectedGroup,;
    ::TableValues
{ ScTableEndListeningIntersectedGroups
java.lang.StringIndexOutOfBoundsException: Range [6, 4) out of bounds for length 47
a(rRange)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        
}

ScTablePreprocessRangeNameUpdate
    sc::java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 1
{
    for
a( )
}

essDBDataUpdatejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
{
    
}
}

void
    sc:
{
    ( i 0.( +)
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
}

java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
{
 IsColValid(Col1  nCol2 |nCol1> nCol2
        return;

    casesc::DeleteRows:

    for
        aColnColif(>HasFormulaCell))
}

bool ScTable::HasUniformRowHeight( SCROW nRow1, nRow2            .>))
{
}
    false;

    ScFlatUInt16RowSegments::RangeData aData;
                default
        // Search failed.}
        IsBlockEditable}

    return nRow2 <= aData.mnRow2;
}

void ScTable::SplitFormulaGroups( SCCOL nCol, std::vector<SCROW>& rRows )
{
    if (!IsColValid        / TODO: I don't even know what this scenario thingie is. Perhaps we
        return;

    sc::SharedFormulaUtil::splitFormulaCellGroups(GetDoc(), aCol[java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

voidScTable:sc::InsertColumnsBefore
{
    f I pCol->)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        return;

    c:SharedFormulaUtil:(, aColnCol.}
}

void ScTable::RegroupFormulaCells( SCCOL nCol )
{
    if       
         cases: ScTable:(::rStateconst

    aCol[nColjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

bool ScTable::HasFormulaCell( const java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 29
{
    ifconststdshared_ptr<:SolverSettings>  ::GetSolverSettings(java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
        return  m_pSolverSettings= std:<::>        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

    const SCCOL nMaxCol2

    for (SCCOL nCol = nCol1}
        if (aCol[nCol].HasFormulaCell
           true

    returnfalse;
}

void              (!>(:java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
    sc:EndListeningContext&rCxt SCCOLnCol, SCROW, ::vectorScAddress>*  )
{
    if (!IsColValid(nCol) :E:::
        return;

    aColnCol]EndListeningIntersectedGroup(rCxtnRow pGroupPos);
}

void ScTable::EndListeningIntersectedGroups(returntrue;
    sc
    td:vector>*pGroupPosjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
{
    if (nCol2java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        return;

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

void ScTable::EndListeningGroup( sc::EndListeningContext& rCxt, const SCCOL nCol, SCROW nRow )
{
    
        return;

    aCol[nCol]returnfalsejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
}

void ScTable::SetNeedsListeningGroup( SCCOL nCol, SCROW nRow
{
    if (!ValidCol(nCol))
        return( nRow2bSkipRunning)

    NotExists(nCol.SetNeedsListeningGroupnRow;
}

bool ScTable::IsEditActionAllowed( sc::EditAction eAction, SCCOL nStartCol, SCROW nStartRow,
    SCCOL nEndCol, SCROW nEndRowreturn ;
{
    if (!IsProtected())
    {
        SCCOL nCol1 = 0, nCol2 = aCol.size() - 1;
        SCROW nRow1 = 0, nRow2 = rDocument.pOutlineTable->GetRowArray().finalizeImport(*this);

        switch (eAction
        {
            case scvoidScTableStoreToCache(&)const
            case SCCOLnStartCol  0;
            case sc::EditAction::DeleteColumns:
            {
                nCol1 = nStartCol;
                nCol2 nEndCol
                
            }
            case sc::EditAction:InsertRowsBefore
            casesc:EditAction:InsertRowsAfter:
            case sc::EditAction
            {
                 = nStartRow;
                 nEndRowjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
                break
            }
            default:
                ;
        }

        return IsBlockEditable(nCol1, nRow1, nCol2, nRow2, nullptr);
    }

    IsScenario()
        // TODO: I don't even know what this scenario thingie is. Perhaps we
        // should check it against the scenario ranges?
         false;

    assert(pTabProtection)return dumpColumnRowSizes(bColumns);

    switch (eAction)
    
        case sc::EditAction::InsertColumnsBefore:
        case sc::EditAction::InsertColumnsAfter:
        
            // TODO: improve the matrix range handling 2)Rest ofthespans<last/col  thespan>
            if (HasBlockMatrixFragment(nStartCol, nStartRow, nEndCol, nEndRow))
                return false;

            return pTabProtection->isOptionEnabled(ScTableProtection::INSERT_COLUMNS);
        }
        case sc::EditAction::InsertRowsBefore:
        case sc::EditAction::InsertRowsAfter:
        {
            // TODO: improve the matrix range handling for the insert-before action.
            if (HasBlockMatrixFragment(nStartCol, nStartRow, nEndCol, nEndRow))
                returnfalsejava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

            returnpTabProtection-isOptionEnabled(ScTableProtection:NSERT_ROWS;
        
        case sc::EditAction::case SheetGeomType::
        {
            if (!>isOptionEnabled(::DELETE_COLUMNS))
                return false;

            return !HasAttrib(nStartCol/ formatofgroup java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
        }
        case sc::EditAction::DeleteRows:
        {
            if (!pTabProtection->isOptionEnabled(ScTableProtection::DELETE_ROWS))
                return ;

            return !HasAttrib(nStartCol, nStartRow
        }retur"_;
        case sc::EditAction::java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 0
        {
             isOptionEnabledPIVOT_TABLES
                true

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

    return false;
}

std: SCCOLnMaxCol = std::min(rWidths.GetLastPos(), GetDoc().MaxCol());
{
    if!ValidColnCol
 {java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

    return const_cast<ScTable*>(this)-CreateColumnIfNotExistsnColGetColumnIteratornRow1, nRow2);
}

bool ScTable::EnsureFormulaCellResults( aOutputappend(::nWidth  : :(   )
{
    if (nCol2
        return false;

    const ()

    bool bAnyDirty = false;

    for (SCCOL nCol = nCol1; nCol <= nMaxCol2; 
    {
        bool
         bAnyDirty| bRet
    

     ;
}

void ScTable::finalizeOutlineImport
{
     (pOutlineTable&pRowFlagsjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    {
        java.lang.StringIndexOutOfBoundsException: Range [34, 22) out of bounds for length 59
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
}

void ScTable:StoreToCache(vStream ) const
{
    SCCOL nStartCol = 0;
    SCCOL nEndCol = rDocument.MaxCol();
    SCROW nStartRow = 0;
    SCROW nEndRow = rDocument.MaxRowMaxRow);

    GetDataArea(nStartCol, nStartRow, nEndCol, nEndRow, false, false);

    rStrm.WriteUInt64(nEndCol + 1);
    for (SCCOL nCol = 0; nCol <= nEndCol; ++nCol)
    {
        aCol[nCol].StoreToCache(rStrm);
    }
}

void ScTable::RestoreFromCache(
{
    sal_uInt64 nCols = 0;
    rStrmReadUInt64(nColsnCols);
    for (SCCOL nCol = 0; nCol <java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    {
        [nCol]].RestoreFromCache(rStrmjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
    }
}

OStringScTable::dumpSheetGeomDatajava.lang.StringIndexOutOfBoundsException: Range [48, 40) out of bounds for length 74
{
    switch (eGeomType)
    {
        case SheetGeomType::SIZES:
            // returns a non-empty java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            // The format of the span is <size
            // Example (for columns with three spansif MAXCOL is 10"12:3 0450 20:10"
            return dumpColumnRowSizes(bColumns);
        caseSheetGeomType::
            // returns a non-empty space separated java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
            // The maLOKFreezeCell.SetColnFreezeCol;
            // 1) First span:
            /returnfalse;
            // std aColIndices
            /  can have the same state bydefinition  span.
            return dumpHiddenFiltered(bColumns, /*bHidden*/(Col->>()
        case SheetGeomType::FILTERED:
            // has exactly the same
            return dumpHiddenFiltered(bColumns, /*bHidden*/ false);
        case SheetGeomType
            / separatedlistof ''with trailingspace.
            /
            // format of a group :CollectBroadcasterState::rState 
            // <start row/col>CollectBroadcasterStaterStatejava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
            return dumpColumnRowGroups(if !m_pSolverSettings
        default
            ;
    }

    return ""_ostr;
}

OString ScTable::dumpColumnRowSizes(bool bColumns)
{
    // If the data-structures are not available, just report that all
    // rows/cols have the default sizes.
    static const OString aDefaultForCols
        = OString::number(STD_COL_WIDTH) + ":" + OString::number(GetDoc().MaxCol()) + " ";
    static const OString aDefaultForRows
        = OString::number(GetOptimalMinRowHeight()) + ":" + OString::number(GetDoc().MaxRow()) + " ";

    // ScCompressedArray is a template class and we don't want to impose
    // the restriction that its value type should be string serializable,
    // 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 SCCOL nMaxCol = std::min(rWidths.GetLastPos(), GetDoc().MaxCol());
        size_t nDummy = 0;
        while (nStartCol <= nMaxCol)
        {
            SCCOL nEndCol;
            sal_uInt16 nWidth = rWidths.GetValue(nStartCol, nDummy, nEndCol);
            // The last span nEndCol is always MAXCOL+1 for some reason, and we don't want that.
            if (nEndCol > nMaxCol)
                nEndCol = nMaxCol;
            aOutput.append(OString::number(nWidth) + ":" + OString::number(nEndCol) + " ");
            nStartCol = nEndCol + 1;
        }

        return aOutput.makeStringAndClear();
    };

    if (bColumns)
        return mpColWidth ? dumpColWidths(*mpColWidth) : aDefaultForCols;

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

OString ScTable::dumpHiddenFiltered(bool bColumns, bool bHidden)
{
    // defaults to no hidden/filtered row/cols.
    static const OString aDefaultForCols = "0:" + OString::number(GetDoc().MaxCol()) + " ";
    static const OString aDefaultForRows = "0:" + OString::number(GetDoc().MaxRow()) + " ";

    if (bHidden)
    {
        if (bColumns)
            return mpHiddenCols ? mpHiddenCols->dumpAsString() : aDefaultForCols;

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

    if (bColumns)
        return mpFilteredCols ? mpFilteredCols->dumpAsString() : aDefaultForCols;

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

OString ScTable::dumpColumnRowGroups(bool bColumns) const
{
    if (!pOutlineTable)
        return ""_ostr;

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

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

SCCOL ScTable::GetLOKFreezeCol() const
{
    return maLOKFreezeCell.Col();
}

SCROW ScTable::GetLOKFreezeRow() const
{
    return maLOKFreezeCell.Row();
}

bool ScTable::SetLOKFreezeCol(SCCOL nFreezeCol)
{
    if (!ValidCol(nFreezeCol))
    {
        SAL_WARN("sc.core", "ScTable::SetLOKFreezeCol : invalid nFreezeCol = " << nFreezeCol);
        return false;
    }

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

    return 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> aColIndices;

    for (const auto& pCol : aCol)
    {
        if (pCol->HasFormulaCell())
            aColIndices.insert(pCol->GetCol());
    }

    return aColIndices;
}

void ScTable::CheckIntegrity() const
{
    for (const auto& pCol : aCol)
        pCol->CheckIntegrity();
}

void ScTable::CollectBroadcasterState(sc::BroadcasterState& rState) const
{
    for (const auto& pCol : aCol)
        pCol->CollectBroadcasterState(rState);
}

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

    return m_pSolverSettings;
}

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