Quelle  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)
&n;               setFirstCell(aRet        return;

    CreateColumnIfNotExists(nCol).SetNeedsListeningGroup(nRow);
                return bool ScTable::IsEditActionAllowed( sc::EditAction eAction,    SCCOL{
            }
        SCROWjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            {
                ;
        }
    }

                    nCol2 = nEndCol;
        aRet.meState            case sc::EditAction:            case sc::EditAction::InsertRowsAfter:

    return                nRow2 = nEndRow;
}

void ScTable            default:
        }
{
    sc:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    if (!ValidCol(
            if (IsScenario())

    // Pass some stuff to the columns via context.
    rCxt.setTableProtected(IsProtected        return false;
    rCxt.java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0

    ScRange        case sc        {
    SCCOL            if (                return false
            {           // TODO: improve the matrix range handling for the insert-before action.            if (                return
        const         }        case sc        {
        for        }
        {            if                return true;
            
    return false}

            const ScColumn& rClipCol = const_cast<ScTable{
            aCol    return const_cast<ScTable*>(this)->CreateColumnIfNotExists(nCol).GetColumnIterator(}
        }
    }

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

void ScTable::CopyOneCellFromClip(
    sc        bool bRet =        bAnyDirty = bAnyDirty || bRet;
{
    ScRange aSrcRange =    return bAnyDirty;
    SCCOL nSrcColSize OutlineImport()

    for (SCCOL nCol    if (pOutlineTable && pRowFlags)
    {
        SCCOL nColOffset = nCol - nCol1;
        nColOffset }
        assert
        CreateColumnIfNotExistsvoid ScTable::StoreToCache(SvStream& rStrm) const

        if (rCxt.getInsertFlag() & java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 24
        {
            for (SCROW nRow = nRow1java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                CopyConditionalFormat        aCol[nCol].StoreToCache(rStrm);
                        nRow - java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        }
    }

    if    rStrm.ReadUInt64(nCols);
    {
        mpRowHeights->setValue(nRow1    {

        if (pRowFlags && pSrcTab->pRowFlags    }
           if (pSrcTab->pRowFlags-&x 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 lenbsp;   for (SCCOL i = 0; i < aCol.autodumpColWidths= [](const rWidths >OString{
        aCol[i].CompileHybridFormula(rStartListenCxt, rCompileCxt);
}

void S   0
{
if(|nCol2| nCol1)
        return.:()+: :nEndColjava.lang.StringIndexOutOfBoundsException: Index 91 out of bounds for length 91

    const SCCOL}

     SCCOL=;  <;+
        aCol[mpColWidth() aDefaultForCols
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
ifValidRow)|!(nRow2||nRow1>nRow2
        return false;

    ScFlatUInt16RowSegments::RangeData aData;
    if returnmpHiddenRows  pHiddenRows-dumpAsString(  aDefaultForRows
        // Search failed.
        return false;

    return nRow2 <= aData.mnRow2;
}

void ScTable::SplitFormulaGroups( SCCOL nCol, std::vector<SCROW>& rRows )
{
    if (!java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
        return;

    if(!pOutlineTable
}

void ScTable::UnshareFormulaCells( SCCOL
{
    ifr >(.(;
        return;

    sc::SharedFormulaUtil::unshareFormulaCells(rDocument, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

void ScTable
{
     (IsColValidnCol)
        return;

    aCol[nCol    returnCol);
}

bool ScTable::HasFormulaCellSCROW :GetLOKFreezeRow)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
{
    ifjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        returnfalsejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

    const SCCOL nMaxCol2 = std::min    {

    for (SCCOL nCol         eturnfalse
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
return;

    return false;
}

void ScTable    {
    sc::        maLOKFreezeCell.(nFreezeCol;
{
    if (!IsColValid(nCol))
        return;

    aCol[nCol].EndListeningIntersectedGroup(rCxt, nRow, pGroupPos);
}

voidreturnfalse;
    sc::EndListeningContext& rCxt, const SCCOL nCol1, SCROW nRow1,}
    std::vector<java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
{
    if java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
        return;

    for (SCCOL nCol : GetAllocatedColumnsRange(nCol1, nCol2))
        aCol[nCol].EndListeningIntersectedGroups(rCxt, nRow1, nRow2, pGroupPos);
}

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

    aCol[nCol].EndListeningGroup(rCxt, nRow);
}

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

    CreateColumnIfNotExists(nCol).SetNeedsListeningGroup(nRow);
}

bool ScTable::IsEditActionAllowed( sc::EditAction eAction, SCCOL nStartCol, SCROW nStartRow,
    SCCOL nEndCol, SCROW nEndRow ) const
{
    if (!IsProtected())
    {
        SCCOL nCol1 = 0, nCol2 = aCol.size() - 1;
        SCROW nRow1 = 0, nRow2 = rDocument.MaxRow();

        switch (eAction)
        {
            case sc::EditAction::InsertColumnsBefore:
            case sc::EditAction::InsertColumnsAfter:
            case sc::EditAction::DeleteColumns:
            {
                nn eAction, SCCOL nStartCol, SCROW nStartRow,
    SCCOL nEndCol, SCROW nEndRow ) const
{
    if (!IsProtected())
    {
        SCCOL nCol1 = 0, nCol2 = aCol.size() - 1;
        SCROW nRow1 = 0, nRow2 = rDocument.MaxRow();

        switch (eAction)
        {
            case sc::EditAction::InsertColumnsBefore:
            case sc::EditAction::InsertColumnsAfter:
            case sc::EditAction::DeleteColumns:
            {
                nCol1 = nStartCol;
                nCol2 = nEndCol;
                break;
            }
            case sc::EditAction::InsertRowsBefore:
            case sc::EditAction::InsertRowsAfter:
            case sc::EditAction::DeleteRows:
            {
                nRow1 = nStartRow;
                nRow2 = nEndRow;
                break;
            }
            default:
                ;
        }

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

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

    assert(pTabProtection);

    switch (eAction)
    {
        case sc::EditAction::InsertColumnsBefore:
        case sc::EditAction::InsertColumnsAfter:
        {
            // TODO: improve the matrix range handling for the insert-before action.
            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))
                return false;

            return pTabProtection->isOptionEnabled(ScTableProtection::INSERT_ROWS);
        }
        case sc::EditAction::DeleteColumns:
        {
            if (!pTabProtection->isOptionEnabled(ScTableProtection::DELETE_COLUMNS))
                return false;

            return !HasAttrib(nStartCol, nStartRow, nEndCol, nEndRow, HasAttrFlags::Protected);
        }
   eetGeomType::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;
}

/