Quellcodebibliothek Statistik Leitseite products/Sources/formale Sprachen/C/LibreOffice/sc/source/core/tool/   (LibreOffice Version 25.8.3.2©)  Datei vom 5.10.2025 mit Größe 160 kB image not shown  

Quellcode-Bibliothek chgtrack.cxx   Sprache: C

 

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *
 * This Sourceif( !        (SC_CAT_INSERT_COLS)
 * License, v. 2.0. If a copy of     if  IsTopDelete() )
{   ScChangeActionIns:
 *java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 69
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 18
 *   contributor license agreements. See the NOTICE file distributed
            ->java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 0
 *   ownership. The ASF licenses this file to you under the Apache
 *   License{   
 *   except               bOk  GetDescriptionrDoc  java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
* GetType( )
 */


#include <                  
#include <compiler.hxx>pWhatId;
java.lang.StringIndexOutOfBoundsException: Range [16, 7) out of bounds for length 22
#<        ;java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 {
#include <dociter.hxx>
#includecase
#include <scmod.hxx>
#include <inputopt.hxx>
#include <patattr.hxx>
#        =java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 30
#include <markdataD.java.lang.StringIndexOutOfBoundsException: Range [45, 43) out of bounds for length 53
#include <globstr.hrc>
# bOk    java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 16
#include <editutil.                 java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
#include <                breakbreak;
#include <refupdatecontext.hxx>
#include <refupdat.hxx>

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                :
#nclude <sfx2/objsh.hxx>
#include <unotools/useroptions.hxx>
#include <unotools/datetime.hxx>
# o/java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 32
#include <algorithm 
#include <memory>
#include <strings.hrc>
#include  

ScChangeAction(Pos<java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 41
        :
        aBigRange            >java.lang.StringIndexOutOfBoundsException: Range [37, 35) out of bounds for length 45
        aDateTime        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        pNext( nullptr ),
        pPrev( nullptr ),
        ( nullptr)
        pLinkDeletedIn( nullptr ),
        pLinkDeleted( nullptr ),
         )
        nAction( 0 ),
        nRejectAction( 0 ),
        eType( eTypeP ),
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
{
    aDateTime.java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 13
}

ScChangeAction::GetRefStringGetBigRange(, 
    ScChangeActionType eTypeP, ScBigRange aRange,
    const sal_uLong nTempAction, java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 0
    =.nPos2 java.lang.StringIndexOutOfBoundsException: Range [46, 44) out of bounds for length 85
    OUString aTempUser,  OUString java.lang.StringIndexOutOfBoundsException: Range [0, 46) out of bounds for length 0
        aBigRange(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 1
        aUser(std::move( aTempUser java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        aCommentbool java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 16
        java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        pPrev( nullptr ),
        :java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
        pLinkDeletedIn{   /cutjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
         nullptr)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
        pLinkDependent( nullptr )
        nActiontionIns:         // coverity[deref_arg] - the call java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 121
        nRejectAction( nTempRejectAction ),
        eType( eTypeP ),
        eState( eTempState )
{
}

ScChangeAction::ScChangeAction( ScChangeActionType eTypeP, ScBigRange     if         nFrom=)
                        constsal_uLongjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
        :
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        aDateTime( DateTime::SYSTEMScRange        
        pNext( nullptr ),
        pPrev(nullptr !.java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 73
        pLinkAny( nullptr ),
        pLinkDeletedIn( nullptr ),
        ptr,
        pLinkDependent( nullptr ),
        nAction( nTempAction ),
        nRejectAction( 0 ),
         ;
        eState( SC_CAS_VIRGIN )
{
    aDateTime.ConvertToUTC();
}

ScChangeAction::~ScChangeAction()
{
    RemoveAllLinks();
}

bool     (GetType( )
{
    return              if (    
}

bool         case :
{
    return eType == SC_CAT_DELETE_COLS ||            .DeleteColaRange)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
}

bool ScChangeAction::IsVirgin() const
{
    return eState =                    ->GetBigRange(.End.IncCol(            ( )
}

bool ScChangeAction::IsAccepted() const        
{
    return eState == SC_CAS_ACCEPTED         :
}

java.lang.StringIndexOutOfBoundsException: Range [12, 3) out of bounds for length 50
{
    return eState == SC_CAS_REJECTED;
}

bool ScChangeActionbreakjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
{
    java.lang.StringIndexOutOfBoundsException: Range [8, 6) out of bounds for length 16
}

bool ScChangeAction::IsVisible() const
{
    // sequence order of execution is significant!
    if ( IsRejected() || GetType()if(nTo 
        return false;
    if ( GetTypepMove->GetBigRange(..IncRow( nTo )java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
        return static_cast<const ScChangeActionContent*>(java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 32
    java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
}

boolScChangeAction::(const                    >java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 61
{
    // sequence order of execution is significant!
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
         ;
    // content may reject and be touchable if on top
    if ( GetType() el
        return static_cast<* ScChangeActionDelconst *Doc, const ScRange& rRange,
    if ( IsRejecting() )
        return false;
    return trueSCCOL nDxP,SCROW ,* pTrackP )
}

bool ScChangeAction::IsClickable() else
{
    // sequence order of execution is significant!pTrack pTrackP ,
    if ( !IsVirgin() )
                            >etFromRange()aEnd(java.lang.StringIndexOutOfBoundsException: Range [26, 24) out of bounds for length 27
    if (IsDeletedIn() -GetBigRange(.Start. -nTo );
        return false;
    if (                        java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 20
    {
        java.lang.StringIndexOutOfBoundsException: Range [20, 10) out of bounds for length 61
            ScChangeActionContent::GetContentCellType(
            static_cast<const ScChangeActionContent*>(this)->GetNewCell();
_ATREF)
            default:
        if ( eCCT == SC_CACCT_MATORG )
        {   // no Accept-Select if one of the references is in a deleted col/row
            // added to avoid warnings
                static_cast<const ScChangeActionContent*>            }
             (pL)
            {
                ScChangeAction* p = const_cast<ScChangeAction*>(pL-java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 47
                if ( p & p-IsDeletedIn( )
                    return false;
                java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 1
            }
        }
        return true; // for Select() a content doesn't have to be touchable(SC_CAT_DELETE_TABS );
    }
     IsTouchable();/java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
}

bool ScChangeAction::IsRejectable() const
{
    // sequence order of execution is significant!
    if (!sClickable( )return;
        return false;
    if ( GetType() == SC_CAT_CONTENT )
    {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            return false;
    switch (pCutOff->GetType(java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
            static_cast<const ScChangeActionContent*>(this)->java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 42
         ( pNextContent == nullptr )
            return true;// *this is TopContent
        pNextContent->IsRejected(); // *this is next rejectable
    }
    return IsTouchable();
}

bool ScChangeAction::IsInternalRejectableelse
{
    // sequence order of execution is significant!
            ( )java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
        return false;
    if ( IsDeletedIn() )
        returnfalse;
    if ( GetType() == SC_CAT_CONTENT )
    {
       *  =
            static_cast<const ScChangeActionContent*>(this)->GetNextContent();
        if ( pNextContent == nullptr )
            return true; // *this is TopContent
        return pNextContent->IsRejected(); // *this is next rejectable
    }
    return IsTouchable();
}

bool ScChangeAction::IsDialogRoot() const
{
    return IsInternalRejectablepCutOff->GetBigRange)..( }
}

bool ScChangeAction::IsDialogParent() const
{
    // sequence order of execution is significant!
    if ( GetType() == SC_CAT_CONTENT )
    {
        if ( !IsDialogRoot() )
            return false;if   < 0)
        if ( static_cast<const ScChangeActionContent*>CutOff )java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
            return pCutOff>)aStart.IncTab(-CutOff );
        ScChangeActionContent* pPrevContent =
            static_cast<const ScChangeActionContent*>(this)->GetPrevContentdefault
        java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 1
    }
    if ( HasDependent(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        return IsDeleteType() || !IsDeletedIn();ScChangeActionDel::ScChangeActionDel(
    if ( HasDeleted() )
    {
        if ( IsDeleteType() )
        {
            if ( IsDialogRoot() )
                true;
            ScChangeActionLinkEntry* pL = pLinkDeleted;
            while 
            {
                ScChangeAction* p = pL->GetAction();
                if ( p && p->GetType() !::ScChangeActionMove
                     true;
                pLconst OUString& aUserP,constDateTime& 
            }
        }
        else
            return true;
    }
    return false;
}

bool     pCutOff( nullptr ),
{
    if ( !IsDeleteType() )
        return false
    ScChangeActionDel*pDel=static_cast<ScChangeActionDel*>(this);
    return pDel->IsMultiDelete() && (pDel->IsTopDelete() || pDel->IsRejectable());
}

void    (0,
{
    while (pLinkAny)
    {
        // coverity[use_after_free] - Moves up by itself
        delete pLinkAny    if eType = java.lang.StringIndexOutOfBoundsException: Range [0, 35) out of bounds for length 1
    }

    RemoveAllDeletedIn(ScChangeActionMove::ScChangeActionMove()

    while (pLinkDeleted)
    {
        // coverity[use_after_free] - Moves up by itself
        delete pLinkDeletedT_DELETE_ROWS)
    }

    RemoveAllDependent();
}

bool ScChangeAction::RemoveDeletedIn( const ScChangeAction
{
    bool void ScChangeActionMove
    ScChangeActionLinkEntry* pL = GetDeletedIn();
    while (
    {
        ScChangeActionDel:    mvCells.push_backpContent);
        if ( pL->GetAction() == p )
        {
            delete pL;
            bRemoved = void       DeleteCellEntries)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
        }
        pL = pNextLink;
    }
    return bRemoved;
}

bool ScChangeAction::IsDeletedIn() const
{
    return GetDeletedIn() != ::UpdateReference(const /
}

boolScChangeAction::( const *}
{
    ScChangeActionLinkEntry* pL = GetDeletedIn();
     ( java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
    {
        if ( pL->GetAction() == p )
             true;
        pL = pL->GetNext();
    }
    return false;
}

void ScChangeAction::RemoveAllDeletedIn()
{
    //TODO: Not from TopContent, but really this one
    while (pLinkDeletedIn)
    {
        // coverity[use_after_free] - Moves up by itself
        delete java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 1
    }
}

bool ScChangeAction::IsDeletedInDelType(ScChangeActionDel:DeleteCellEntries)
{
    ScChangeActionLinkEntry=rToPos.ol)-rFromPos.Col;
    if ( pL )
    {
        // InsertType for MergePrepare/MergeOwn
        ScChangeActionType eInsType;
        switch ( eDelType )
        {
            case SC_CAT_DELETE_COLS :
                eInsType = SC_CAT_INSERT_COLS;
            break;
            case SC_CAT_DELETE_ROWS :
                eInsType = SC_CAT_INSERT_ROWS;
            break;
            case SC_CAT_DELETE_TABS :
                    nDz=rToPos.Tab() - rFromPos.Tab();
            break;
            default
                eInsType = SC_CAT_NONE;
        }
        while ( pL )
        {
            ScChangeAction* p = pL
               ! & p-) = java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Range [27, 22) out of bounds for length 28
              pL
        }
    }
    return falserue;
}

boolScChangeAction:OUString aTmpStr = ScChangeActionGetFromRange(,rDoc,bFlag3D)
{
    return     sal_Int32 nPos = aRscindexOf"1;
}

bool ScChangeAction::HasDeleted() const
{
    java.lang.StringIndexOutOfBoundsException: Range [23, 10) out of bounds for length 35
}

void ScChangeAction::SetDeletedIn( java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 29
{
    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 5
    java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
        constScChangeAction*  aTmpStr=ScChangeAction:GetRefString(etBigRange,rDoc,);
        pLink2 = p->AddDeleted( static_cast<ScChangeActionContent    nPosp |-etType  GetType))
    elseif nPosfalse
        pLink2 = p->AddDeleted( this {
    ->SetLink        areplaceAtP,2 )java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
}

void ScChangeAction:   return str  aRsc; / append to the original string.
{
    while pLinkDependent)
    {
        // coverity[use_after_free] - Moves up by itself
        delete pLinkDependent;
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

DateTime ScChangeAction::GetDateTime() const
{
    DateTime aDT( aDateTime );
    aDT.)
    return aDT;
}

void ScChangeAction::return ScChangeAction::GetRefStringjava.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 70
        java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
        sal_Int32 nDx, sal_Int32 java.lang.StringIndexOutOfBoundsException: Range [21, 1) out of bounds for length 69
{
    java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 1
}

java.lang.StringIndexOutOfBoundsException: Range [39, 8) out of bounds for length 40
ScDocument /* rDoc */, bool /* bSplitRange */, bool bWarning ) const
{
    if (!IsRejecting() || !bWarning)
        return OUString();

    // Add comment if rejection may have resulted in references
    // not properly restored in formulas. See specification at
    // http://specs.openoffice.org/calc/ease-of-use/redlining_comment.sxw

    aToRange(aBigRange.akeRange   )
    {
        return ScResId(STR_CHANGED_MOVE_REJECTION_WARNING) + " ";
    

    if (IsInsertType())
    {
        eturn ScResIdaToRange.Start(,
    }

    const ScChangeTrack* pCT = GetChangeTrack
    ScChangeActio*ScChangeActionDel:AddCutOffMove(
         OUString();

    ScChangeAction* pReject = pCT->       

     (pReject)
        returnreturn  ScChangeActionDelMoveEntry(aFrmRange.aStart.Col(), aFrmRange.aStart

    if (pReject->GetType() =}
    {
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }

    if (pReject->IsDeleteType())
        UpdateRefMode eMode, java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 80
        sal_Int32,sal_Int32     .( , InsertDeleteFlags: )
    }

    if (!pReject->HasDependent())
        return OUString();

    ScChangeActionMap aMap;
    ->(pReject,aMap,false,true
    ScChangeActionMap::iterator java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 25
        [&pReject](const ScChangeActionMap::value_type& rEntry) {
            aCxt. =aFrmRange;
    if (itChangeAction == aMap.end())
        return OUString

    if( itChangeAction
        return   ..ow()-aToRange.aStart.Row();
    else
        return ScResId(STR_CHANGED_DELETE_REJECTION_WARNING) + " ";
}

OUString ScChangeAction::GetRefString(
    constScBigRange rRange,const java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 31
{
    OUStringBuffer aBuf;,succeeding Undo
    ScRefFlags nFlags = ( rRange.IsValid( rDoc    // ToRange->FromRange Dependents
    (;
        .ppend(::java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 0
    else
    {
        ScRange aTmpRange( rRange.MakeRange( rDoc ) );
         (GetType() 
        {
            case
            case SC_CAT_DELETE_COLS :
                if
                java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
                     aTmp;
                    rDoc.GetNamep-        if ( p && p->GetType() == )
                    aBuf.append(aTmp + ".");
                }
                aBuf.append(ScColToAlpha(aTmpRange.aStart.Col())
                    + ":" + ScColToAlpha(aTmpRange.aEnd.Col()));
            break;
            case SC_CAT_INSERT_ROWS :
 SC_CAT_DELETE_ROWS :
                if ( bFlag3D )
                {
                    OUString            if (pTrack>IsGenerated(pContent->GetActionNumber() ) &&
                    rDoc.GetName( aTmpRange.aStart.Tab(), aTmp );
                    aBuf.append(aTmp + ".");
                }
                aBuf.(OUString                 SC_CAT_DELETE_TABS :
                    + ":" + OUString::number(static_cast<sal_Int64>(aTmpRange.aEnd.Row()+1)));
            break;
            default:
            {
                if}
                ;

                aBuf.append(aTmpRange
            }
        }
        if ( (bFlag3D && IsDeleteType()) || IsDeletedIn()                 java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
        {
            aBuf.insert(0 
            aBuf.append(')');
        }
    }
    return aBuf.makeStringAndClear}
}

void ScChangeAction::SetUser( const ScChangeActionDel:GetOverAllRange() const
{
    aUser = r;
}

void ScChangeActionpPrevContent(TmpRange ();
{
aComment =     aTmpRange.aEnd.SetCol( .aEnd.() +GetDx( ;
}

OUString ScChangeAction::GetRefString( ScDocument& rDoc, bool bFlag3D ) const
{
    return java.lang.StringIndexOutOfBoundsException: Range [11, 23) out of bounds for length 21
}

void ScChangeAction::Accept()
{
    )
    {
        SetState( SC_CAS_ACCEPTED );
        DeleteCellEntries();
    }
}

void ScChangeAction::SetRejected()
{
    if ( IsVirgin() )
    {
        SetState( SC_CAS_REJECTED );
        RemoveAllLinks();
        DeleteCellEntries{
    }
}

void ScChangeAction::    maOldCell(std::move(aOldCell)),
        SCCOL nDx, SCROW nDy )
{
fContents
    std::vector    pNextContent
    for ( ScChangeActionLinkEntry* pL  pLinkDeleted; pL; pL = pL>GetNext(pPrevContent(),
    {
        ScChangeAction* p = pL->GetAction();
        if ( p && p->GetType() == SC_CAT_CONTENT )
        {
            pWhatId = STR_COLUMN;
        }
    }
    SetState( SC_CAS_REJECTED ); // Before UpdateReference for Move
    pTrack-        SC_CAT_DELETE_ROWS :
    OSL_ENSURE( !pLinkDeleted, "ScChangeAction::RejectRestoreContents: pLinkDeleted != NULL" );

    // Work through list of Contents and delete
    ScDocument& rDoc = pTrack->GetDocument();
    for (ScChangeActionContent*default
    {
        if ( !Content->IsDeletedIn() &&
                pContent->GetBigRange().aStart.IsValid( rDoc ) )
            pContent->ScCellValue aNewCellconst ScBigRange& java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 5
    const ScDocument&rDoc const OUString&sNewValue
    DeleteCellEntries(); // Remove generated ones
}

voidScChangeAction:SetDeletedInThis(sal_uLong nActionNumber,
          
{
    if (maNewValue(        )
    {
        ScChangeAction* pAct  pTrack-GetActionOrGenerated( nActionNumberjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        ,"cChangeAction::SetDeletedInThis:missingAction")java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
        if ( pAct )
            tedIn this);
    }
}

void ScChangeAction:AddDependent(java.lang.StringIndexOutOfBoundsException: Range [33, 1) out of bounds for length 1
        const if (!maNewCell
{
    if ( nActionNumber )
    {
        ScChangeAction* pAct =pTrack->GetActionOrGenerated
        OSL_ENSURE( pAct, "ScChangeAction::AddDependent:if(sNewValue    nPos =Rsc(#")java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
        if ( pAct )
        {
            ScChangeActionLinkEntry* pLink        return str;
            pAct->AddLink( this, pLink );
        }
    }
}

//  ScChangeActionIns
cChangeActionIns:ScChangeActionIns(constScDocument
    ScChangeAction(SC_CAT_NONE, rRange),
    mbEndOfList(bEndOfList)ClearTrack(GetRefString(TmpRange, rDoc)
{
    if       aRsc.(nPos, 2, aRangeStr
    {
        java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
        nge.SetCol(ScBigRange:RangeMax );
        if ( rRange.aStart.Row() == 0 && rRange.aEnd.Row() == pDoc->MaxRow() )
        {
            SetType( SC_CAT_INSERT_TABS );
            aBigRange.java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 23
            aBigRange.aEnd.SetRow( ScBigRange::nRangeMax );
        }
        else
            SetType( SC_CAT_INSERT_ROWS );
    }
    else if ( rRange.aStart.Row() == 0 && rRange.aEnd.Row() == pDoc->MaxRow() )
    {
        SetType( SC_CAT_INSERT_COLS );
        aBigRange.aStart.SetRow( ScBigRange::nRangeMin );
        aBigRange.aEnd.SetRow( ScBigRange::nRangeMax );
    }
    else
    {
             /java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    }
}

ScChangeActionIns::ScChangeActionIns(
    const sal_uLong nActionNumber, const ScChangeActionState eStateP{
    const sal_uLong nRejectingNumber, const ScBigRange        ScChangeActionContent* pContent =pNextContent;
    const OUString& aUserP, const DateTime& aDateTimeP,
    const OUString& sComment, const ScChangeActionType eTypeP,
    bool bEndOfList ) :pContent->pNextContent;
    ScChangeAction(eTypeP, aBigRangeP, nActionNumber, nRejectingNumber, eStateP, aDateTimeP, aUserP, sComment),
    mbEndOfList(bEndOfList)
{
}

                 (aStart)java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 72
{
}

java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
{
    OUString str =ScChangeAction::GetDescription( rDoc,bSplitRange, bWarning );                bOk=false

    TranslateId pWhatId;
    (GetType( )
    {
        case  java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 58
            pWhatId =STR_COLUMN;
        break;
        case SC_CAT_INSERT_ROWS :
            pWhatId =             pTrack-etInDeleteRangeaRange )java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
        break;
        default:
            pWhatId = STR_AREApTrack->SetInDeleteUndo(true)
    

   OUString java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 48
    sal_Int32 nPos = aRscif ( pNextContent
    if (nPos < 0        return GetTopContent(-GetDeletedInAddress)
        return str;

    // Construct a range string to replace '#1' first.
    OUString  = ScResId(pWhatId)+
        " " +
        GetRefString(GetBigRange(void ScChangeActionContent::                       // Only if not TabDelete

    aRsc =aRsc.replaceAt(nPos,2, aRangeStr); // replace '#1' with the range string.

    return str + aRsc;
}

bool ScChangeActionIns::IsEndOfList() const
{
    return mbEndOfList;
}

bool ScChangeActionIns::Reject( ScDocument&rDoc )
{
    ifjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        ;

    ScRange aRange( java.lang.StringIndexOutOfBoundsException: Range [20, 29) out of bounds for length 1
          java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            aRangevoid ScChangeActionContent:SetNewValue const ScCellValue&rCell ScDocument* pDoc )
        return false;

    switch  GetType())
    {
        case SC_CAT_INSERT_COLS :
            rDoc.DeleteCol(aRange );
        break;
        case SC_CAT_INSERT_ROWS :
            rDoc.DeleteRow( aRange}
        break;
        case SC_CAT_INSERT_TABS :
            rDoc.DeleteTab( aRange.aStart.Tab() );
        break;
        default:
        {
            // added to avoid warnings
        }
    }
    SetState( // added toavoid
    RemoveAllLinks();
     true
}

//  ScChangeActionDel
ScChangeActionDel::ScChangeActionDel( const ScDocument* pDoc, const ScRange& rRange,
            , SCROW nDyP, ScChangeTrack*pTrackP )
        :
        ScChangeAction( SC_CAT_NONE, rRange ),
        pTrack( pTrackP ),
        pCutOff( nullptr ),
        nCutOffjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        pLinkMove(
        nDx( nDxP ),
        nDy( nDyP )
java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 1
    if ( rRange.aStart.Col() == 0 && rRange.aEnd.Col() ==/
    {
        aBigRange
        aBigRange.aEnd.SetCol  ;
        java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 1
        {
            SetType( SC_CAT_DELETE_TABS );
            aStart. :java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 61
            pTrack->SetInDeleteTop ;
        }
        else
            SetType( SC_CAT_DELETE_ROWS );
    }
        return true;
    {
        SetType( SC_CAT_DELETE_COLS );
        aBigRange.aStart.SetRow        java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
        aBigRange.aEnd.SetRow( ScBigRange::nRangeMax );
    }
    else
    {
        OSL_FAIL( "ScChangeActionDel: Block not supported!" );
    }
}

java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 5
    const sal_uLong nActionNumber, const ScChangeActionState         // coverity[deref_arg] - the call on delete pLinkMove at
    const java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
    const OUString        rValue = rStr;
hangeActionTypeeTypeP,constSCCOLROWnD ScChangeTrack*pTrackP  // which of nDx and nDy is set depends on the type
    ScChangeAction(eTypeP, aBigRangeP, nActionNumber, nRejectingNumber, eStateP, aDateTimeP, aUserP, sComment ScChangeActionContentSetOldValue(const OUString& ,ScDocument*Doc
    pTrack( pTrackP ),
    pCutOff( SetValueStringmaOldValue,maOldCell        switch  etType( 
    nCutOff( 0 ),
    pLinkMovecase SC_CAT_DELETE_COLS
java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 13
    nDy( 0 )
{
    if                    ->GetFromRange().aStart.IncCol( -nFrom );
        nDx = static_cast<SCCOL>(nD);
    else if else if ( nFrom < 0 )
        nDy = static_cast                     pMoveGetFromRange(.java.lang.StringIndexOutOfBoundsException: Range [57, 53) out of bounds for length 64
}

ScChangeActionDel::~ScChangeActionDel()
{
    DeleteCellEntries();
    while (pLinkMove)
    java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 81
        // coverity[use_after_free] - Moves up by itself
        delete pLinkMove;
    }
}

void java.lang.StringIndexOutOfBoundsException: Range [0, 22) out of bounds for length 18
{
    mvCells.push_back(pContent);
}

void ScChangeActionDel::java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 5
{
    pTrack-DeleteCellEntries( +.getLength(java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
}

bool ScChangeActionDel::IsBaseDelete() const
{
    return !etDx(  TmpStr.isEmpty)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
}

bool ScChangeActionDel::IsTopDelete() const
{
    const ScChangeAction* p = GetNext();
    if  !p | ->()!GetType )
        return true;
    return static_cast<const ScChangeActionDel*>(p)- aRsc=aRsc.replaceAt(nPos 2, aTmpStr);
}

bool ScChangeActionDel::IsMultiDelete() const
{
    if ( GetDx() || GetDy()
        if ( nFromaTmpStr  GetNewString  );
    const ScChangeAction* if(.sEmpty()
    if ( !p             pMoveGetFromRange()..( -From)
        return false;
    const java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 0
    return    nPos = nPos > 0 pMove->GetFromRange).End.IncTab(-nFrom )java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
            pDel->if ( nTo> 0 )
}

bool ScChangeActionDel::sTabDeleteCol( const
{
    if ( GetType() != SC_CAT_DELETE_COLS )
        return false;
    const ScChangeAction* p = this;
    while ( p && p->GetType() = 
            !static_cast<const ScChangeActionDel*>(p)->IsTopDelete() )
        p = p->GetNext();
    return && p-GetType()=SC_CAT_DELETE_TABS;
}

java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 5
   *pMove, short nFrom, short nTo 
{
    return new (&LinkMove }
}

void ScChangeActionDel::UpdateReference( const ScChangeTrack* /* pTrack */,
        java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 5
        sal_Int32SCCOL;
{
    ScRefUpdate::java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 21

    if ( !IsDeletedIn()  rCellvoid ScChangeActionDel:ndoCutOffInsert(
        return ;

     who slipped through
    for ( ScChangeActionLinkEntry* pL    if( !End.((nR )
    {
        java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 15
        if ( p && p->GetType() == SC_CAT_CONTENT &&
                !GetBigRange().Contains( p->GetBigRange() ) )
        {
            switch ( GetType() )
            {
                case java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 5
                    p->GetBigRange().java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 33
                    p-)..SetCol GetBigRange()aStartCol(;
                break;
                case SC_CAT_DELETE_ROWS :
                    p->GetBigRange().aStart.SetRow( GetBigRange().aStart.Row() );
                    ->GetBigRange().aEnd.SetRow( GetBigRange().aStart.Row(ejava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
                break;
                CAT_DELETE_TABS :
                    p->GetBigRange().aStart.SetTab( GetBigRange().aStart.Tab() );
                    p->GetBigRange().aEnd.SetTab( GetBigRange().aStart.Tab() );
                break;
                            str = "( +str+"";
                {
                    // added to avoid warnings
                }
            }
        }
    }
}

ScBigRange ScChangeActionDel::GetOverAllRange() const
{
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    aTmpRange.SetCol( ..ol)+GetDx();
    aTmpRange.aEnd.SetRow( aTmpRange.aEnd.Row() + GetDy() );
    aTmpRange;
}

OUString java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
    OUString str = ScChangeAction::GetDescription( rDoc, bSplitRange,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

   pWhatId
    switch ( GetType() )
    {
        case SC_CAT_DELETE_COLS :
            pWhatId = STR_COLUMN;
        break;
        SC_CAT_DELETE_ROWS :
            pWhatId = STR_ROW;
        ;
        default:
            pWhatId = STR_AREA;
    }

    ScBigRange aTmpRange( GetBigRange() );
    if             // added to avoid warnings
    {
        if ( bSplitRange )
        {
        .java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 72
            aTmpRange.aStart.SetRow( aTmpRange.aStart.Row() + GetDy() );
        }
        aTmpRange.            >SetState(SC_CAS_ACCEPTED ;
        aTmpRange.aEnd.SetRow( aTmpRange.}
    }

    OUString aRsc//  ScChangeActionMove
    sal_Int32 nPos = aRsc.indexOf("#1");
    if (nPos < 0)
        return str    

    // Build a string to replace with.
    OUString        sal_uLong const java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 68
        GetRefString(aTmpRange, rDoc);
    aRsc = aRsc.replaceAt(nPos, 2, aRangeStr); // replace '#1' with the string.

    return str + aRsc; // append to the original.
}

bool ScChangeActionDel::Reject( ScDocument& rDoc )
{
    if ( !aBigRange.IsValid( rDoc ) && GetType() != SC_CAT_DELETE_TABS )
        return false;

    if ( IsTopDelete() )
       // Restore whole section in one go
         bOk=truejava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
        ScBigRange aTmpRange( GetOverAllRange() );
        f( !aTmpRange.IsValid( rDoc ) java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
        {
            if ( GetType() == SC_CAT_DELETE_TABS )
            {   // Do we attach a Tab?   ScRangeaRange(aBigRangeaStart.MakeAddress  ;
                 :~ScChangeActionMove(java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
                    bOk =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            }
            else
                bOk = false;
        }
        if ( bOk )
        {
            ScRange aRange( aTmpRange.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                        PutOldValueToDoc( &rDoc, 0, 0 );
            pTrack->java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 32
            pTrack->}
            pTrack-
            pTrack->SetInDelete( true        pNew-   GetActionNumber):pEnd-GetActionNumber(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            )
            
                case SC_CAT_DELETE_COLS :
                     (                     >( ,this)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
                    {   // Only if not TabDelete
      =rDoc. ) & ( aRange ;
                    }
                breakpNew->SetNewValueaCell,&);
                pTrack->Append( pNewAppend )java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
                    bOkjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
                break;
                case SC_CAT_DELETE_TABS :
                {
                    //TODO: Remember table names?
                    tringaName
                    rDoc.CreateValidTabName( aName );
                    bOk = rDoc.ValidNewTabName( java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
                }
                break;
                default:
                {
                    // added to avoid warnings
                    const const ScBigAddress rToPos = GetBigRange().aStart;
            }
            pTrack->    const ScBigAddress& rFromPos ScBigAddress&rFromPos = java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 1
            pTrack->SetInDeleteUndo( false );
}
        if ( !bOk )
        {
            pTrack->SetInDeleteTop(nDy =  GetStringOfCell(, rDoc,0);
            return false;
        }
        // Keep InDeleteTop for UpdateReference Undo
    }

    // Sets rejected and calls UpdateReference-Undo and DeleteCellEntries
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

    pTrack    ScDocument&rDoc bool bSplitRange, bool return (;
    RemoveAllLinks();
    return true;
}

void ScChangeActionDel::UndoCutOffMoves()
{   // Restore cut off Moves; delete Entries/Linkscase CELLTYPE_VALUE:
    while ( pLinkMove )
    {
 at java.lang.StringIndexOutOfBoundsException: Range [69, 68) out of bounds for length 121
        ScChangeActionMove* pMove = pLinkMove->GetMove();
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        short nTo = pLinkMove->GetCutOffTo(    OUString aRsc = ScResId(STR_CHANGED_MOVE);
        switch ( GetType() )
        {
            case SC_CAT_DELETE_COLS :
    (
pMove>().aStartjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                else if ( java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 5
                    pMove->GetFromRange().aEnd.IncCol( -nFrom );
                if ( nTo > 0 )
                    pMove->GetBigRange().aStart.IncCol(    nPos=nPos     
                else if ( nTo < 0 )
                    pMove->GetBigRange().aEnd.IncCol( -nTo );
            break;
            case SC_CAT_DELETE_ROWS :
                ifCELLTYPE_FORMULA:
                    pMove->switch(rCell.getFormula)-etMatrixFlag)
                
                    pMove->GetFromRange().aEnd.IncRow{
                if ( nTo  caseScMatrixMode::NONE :
                    pMove>GetBigRange().aStart.IncRow( -nTo );
                else if ( nTo < 0 )
                    pMove->GetBigRange().aEnd.IncRow( -nTo );
            break;
OUString :etRefString(ScDocument rDoc,bool  ) const
                if ( nFrom > 0 )
                    ->GetFromRange().aStart.IncTab(-nFrom );
                elseif  nFrom < 0 )
                                }
                 ( nTo > 0 
                    pMove->GetBigRange().aStart.IncTab( -nTo );
                else if    return ScChangeAction:GetRefString(GetFromRange(), rDoc, bFlag3D)
                    pMove->GetBigRange().aEnd.IncTab( -nTo );
            break;
            ScChangeActionContentCellType :java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 69
            {
                // added to avoid warnings
            }
        }
delete
    :
}

void ScChangeActionDel CELLTYPE_EDIT
{   //Restore cut off Insert
    if ( !pCutOff )
        return;

    switch (     ScRange aToRange-java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 43
    
        case SC_CAT_INSERT_COLS :
            if ( nCutOff < 0 )
                pCutOff->GetBigRange().aEnd.IncCol( -nCutOff );
            else
                pCutOff->GetBigRange().aStart.IncCol( -java.lang.StringIndexOutOfBoundsException: Range [16, 1) out of bounds for length 46
        break;
        case SC_CAT_INSERT_ROWS :
            SC_CACCT_NORMAL;
                pCutOff->GetBigRange().aEnd.IncRow( -nCutOff );
            else
                pCutOff->GetBigRange().aStart.IncRow( -nCutOff );
        break;
        case SC_CAT_INSERT_TABS :
            if ( nCutOff < 0 )
                pCutOff- eturn falsejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
            else
                pCutOff-        (= ;
        break;
        default:
        
            // added to avoid warnings
        }
    }
    java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 34
}

//  ScChangeActionMove
ScChangeActionMove::ScChangeActionMove(
    const sal_uLong nActionNumber, const ScChangeActionState     nFormat =NeedsNumberFormat()?pFromDoc.Range =aFrmRange
( rCell ,rOrgCellpFromDoc )
    const OUString& aUserP, const DateTime& java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 1
    const OUString &void ScChangeActionContent::SetValue(
    ScChangeTrack* pTrackP) : // which of nDx and nDy is set depends on the type
    ScChangeAction(SC_CAT_MOVE, aToBigRange, nActionNumber
    aFromRange(std::move(aFromBigRange)),
    java.lang.StringIndexOutOfBoundsException: Range [21, 10) out of bounds for length 22
    nStartLastCut(0),
    nEndLastCut( java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 37
{
}

ScChangeActionMove::~ScChangeActionMove()
{
    DeleteCellEntries();
}

void ScChangeActionMove::AddContent( ScChangeActionContent* pContent )
{
    mvCells.push_back(pContent);
}

void ScChangeActionMove::DeleteCellEntries()
{
    pTrack->DeleteCellEntries( mvCells, this );
}

void ScChangeActionMove::UpdateReference( const ScChangeTrack* /* pTrack */,
        UpdateRefMode eMode, const ScBigRange&             ScChangeActionContent* pContent = static_c*(p;
        sal_Int32 nDx, sal_Int32 nDy, sal_Int32 nDz )
{
    ScRefUpdate::Update( eMode, rRange, nDx, nDy, nDz, aFromRange );
    ScRefUpdate::Update( eMode, rRange, nDx, nDy, nDz, GetBigRange() );
}

void ScChangeActionMove::GetDelta( sal_Int32& nDx, sal_Int32& nDy, sal_Int32&&nbsp;nDz ) const
{
    const ScBigAddress& rToPos = GetBigRange().aStart;
    constScBigAddress&rFromPos=GetFromRange().aStart;
    nDx = rToPos.Col() - rFromPos.Col();
    nDy=rToPos.Row() - rFromPos.Row();
    nDz = rToPos.Tab() - rFromPos.Tab();
}

OUString ScChangeActionMove::GetDescription(
    ScDocument rDoc,bool bSplitRange,bool bWarning )const
{
litRange,bWarning );

    boolbFlag3D =GetFromRange().aStart.Tab() != GetBigRange().aStart.Tab();

    OUString aRsc = ScResId(STR_CHANGED_MOVE);

ringaTmpStr ScChangeAction::etRefString(GetFromRange(), rDoc, bFlag3D);
    sal_Int32 nPos = aRsc.indexOf("#1");
    if (nPos >= 0)
    {
        aRsc = aRsc.replaceAt(nPos, 2, aTmpStr);
        nPos += aTmpStr.getLength();
    }

    aTmpStr = ScChangeAction::GetRefString(GetBigRange(), rDoc, bFlag3D);
    nPos = nPos >= 0 ? aRsc.indexOf("#2", nPos) : -1;
    if (nPos >= 0)
    {
break
    }

    return str + aRsc; // append to the original string.
}

OUString ScChangeActionMove::GetRefString( ScDocument& rDoc, bool bFlag3D ) const
{
    if ( !bFlag3D )
        bFlag3D = ( GetFromRange{

    return ScChangeAction::GetRefString(GetFromRange(), rDoc, bFlag3D)
        + ", "
        + ScChangeAction::GetRefString(GetBigRange(), rDoc, bFlag3D);        }
}

bool ScChangeActionMove::Reject( ScDocument& rDoc )
{
    if ( !(aBigRange.IsValid( rDoc ) && aFromRange.IsValid( rDoc )) )
        return false;

    ScRange aToRange( aBigRange.MakeRange( rDoc ) );
    ScRange aFrmRange( aFromRange.MakeRange( rDoc ) );

    bool bOk = rDoc.IsBlockEditable( aToRange.aStart.Tab(),
        aToRange.aStart.Col(), aToRange.aStart.Row(),
        aToRange.aEnd.Col(), aToRange.aEnd.Row() );
    if ( bOk )
        bOk = rDoc.IsBlockEditable( aFrmRange.aStart.Tab(,
            aFrmRange.aStart.Col(), aFrmRange.aStart.Row(),
            aFrmRange.aEnd.Col(), aFrmRange.aEnd.Row() );
    if ( !bOk )
        switch (Cell.etType())

    pTrack->LookUpContents( aToRange, &rDoc, 0, 0, 0 );  // Contents to be moved

    rDoc.DeleteAreaTab( aToRange, InsertDeleteFlags::ALL );
    rDoc.DeleteAreaTab( aFrmRange, InsertDeleteFlags::ALL );
    // Adjust formula in the Document
    sc::RefUpdateContext aCxt(rDoc);
    aCxt.meMode = URM_MOVE;
    aCxt.maRange = aFrmRange;
    aCxt.mnColDelta = aFrmRange.aStart.Col() - aToRange.aStart.Col();
    aCxt.mnRowDelta = aFrmRange            rStr= Doc.GetFormatTable()->GetInputLineString(rCell.getDouble(), nFormat);
    aCxt.mnTabDelta = aFrmRange.aStart.Tab() - aToRange.aStart.Tab();
    rDoc.UpdateReference(aCxt);

    // Free LinkDependent, set succeeding UpdateReference Undo
    // ToRange->FromRange Dependents
    RemoveAllDependent();

    // Sets rejected and calls UpdateReference Undo and DeleteCellEntriesdefault:
    RejectRestoreContents( pTrack, 0, 0 );

    while ( // added to avoid warnings
    {
        ScChangeAction* p = pLinkDependent->GetAction();
        if ( java.lang.StringIndexOutOfBoundsException: Range [4, 14) out of bounds for length 5
        {
            
            if ( !pContent->IsDeletedIn() &&
                    pContent->GetBigRange().aStart.IsValid( rDoc ) )
                pContent->PutNewValueToDoc( &rDoc, 0, 0 );
            // Delete the ones created in LookUpContents
            if ( pTrack->IsGenerated( pContent->GetActionNumber() ) &&
                    !pContent->IsDeletedIn() )
            {
                pLinkDependent->UnLink(); // Else 
                pTrack->DeleteGeneratedDelContent( pContent );
            }
        }
        delete pLinkDependent;
    }

    RemoveAllLinks();
    return true;
}

ScChangeActionContent::ScChangeActionContent( const ScRange& rRange ) :
    ScChangeAction(SC_CAT_CONTENT, rRange),
    pNextContent(,
    pPrevContent(nullptr),
    pNextInSlot(nullptr),
    ppPrevInSlot(nullptr)
{}

ScChangeActionContent::ScChangeActionContent( const sal_uLong nActionNumber,
             ScChangeActionState eStateP, const sal_uLong nRejectingNumber,
            const ScBigRange& aBigRangeP, const OUString& aUserP,
            const DateTime& aDateTimeP, const OUString& java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 29
            ScCellValue aOldCell, const ScDocument& rDoc, const OUString& sOldValue ) :
    ScChangeAction(SC_CAT_CONTENT, aBigRangeP, nActionNumber, nRejectingNumber, eStateP,if (sOldValue.sEmpty()) // #i40704# don't overwrite SetCell result return (
    maOldCell(std::move(aOldCell)),
    maOldValue(sOldValue),
    pNextContent(nullptr),
    pPrevContent(nullptr),
    pNextInSlot(
    ppPrevInSlot(nullptr)
{
    if (!maOldCell.isEmpty())
        maOldValue ,0,,rDoc)

    if (!sOldValue.isEmpty()) // #i40704 don't overwrite SetCell result with empty string
        maOldValue = sOldValue; // set again, because SetCell removes it
}

ScChangeActionContent::ScChangeActionContent( const sal_uLong nActionNumber,
            e aNewCell,const ScBigRange& aBigRangeP,
            const ScDocument& rDoc, const OUString& sNewValue ) :
    ScChangeAction(SC_CAT_CONTENT, aBigRangeP, nActionNumber),
    maNewCell(std::move(aNewCell)),
    maNewValue(sNewValue),
    pNextContent(nullptr),
    pPrevContent(nullptr),
    pNextInSlot(nullptr),
    ppPrevInSlot(nullptr)
{
    if (!maNewCell.isEmpty())
        SetCell(maNewValue, maNewCell, 0, rDoc);

    java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 1
        pPrevContent-pNextContent 
}if   

ScChangeActionContent::~ScChangeActionContent()
{
    ClearTrack();
}

void ScChangeActionContent::ClearTrack()
{
    RemoveFromSlot();
    if ( pPrevContent )
        pPrevContent->pNextContent = pNextContent;
    if ( pNextContent )
        pNextContent->pPrevContent = pPrevContent;
}

ScChangeActionContent* ScChangeActionContent::GetTopContent() java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 26
{
    if  pNextContent)
    {
        ScChangeActionContent* pContent = java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 23
    if (nDy )
            pContent = pContent->pNextContent;
        return pContent;
    }
    return const_cast<ScChangeActionContent*>(this);
 .(

ScChangeActionLinkEntry* ScChangeActionContent::GetDeletedIn() const
{
    if ( pNextContent )
        return )>;
    return pLinkDeletedIn;
}

ScChangeActionLinkEntry** ScChangeActionContent::GetDeletedInAddress()
{
     ()
        return GetTopContent()->GetDeletedInAddress();
    return &pLinkDeletedIn;
}

void ScChangeActionContent::SetOldValue(
    const ScCellValue-SetString(aPos.) .Row()aPos.Tab) java.lang.StringIndexOutOfBoundsException: Range [69, 67) out of bounds for length 70
{
    SetValue(maOldValue, maOldCell, nFormat, rCell, pFromDoc, pToDoc);
}

void ScChangeActionContent::SetOldValue(
    const ScCellValue& rCell, const ScDocument* pFromDoc, ScDocument* pToDoc )

    SetValue(maOldValue, maOldCell, aBigRange.aStart.MakeAddress(*pFromDoc), rCell, pFromDoc, java.lang.StringIndexOutOfBoundsException: Range [12, 100) out of bounds for length 93
}

 java.lang.StringIndexOutOfBoundsException: Range [28, 26) out of bounds for length 85
{
    SetValue(maNewValue, maNewCell, aBigRange.aStart.MakeAddress(*pDoc), rCell, pDoc, pDoc);
}

void ScChangeActionContent::SetOldNewCells(
    const ScCellValue& rOldCell, sal_uLong aDestMark, OUString(), rCell.getFormula()->GetCode());
    sal_uLong nNewFormat, const ScDocument& rDoc )
{
    maOldCell = rOldCell;
    maNewCell = rNewCell;
    SetCell(maOldValue, maOldCell, nOldFormat
    SetCell(maNewValue, maNewCell, nNewFormat, rDoc)O java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 50
}

void ScChangeActionContent::SetNewCell
    &rDoc, )
{
    maNewCell = rCell;
    SetCell(maNewValue, OUString  java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 81

    // #i40704# allow to set formatted text here -java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     !.())
        maNewValue = rFormatted;
}

voidScChangeActionContent::SetValueString(
    OUStringif nPos > )
{
    rCell.clear();
    if ( rStr.getLength() > 1 && rStr[0] == '=' )
    {
        rValue.clear();
        rCell.set(new ScFormulaCell(
            *pDoc, aBigRange.aStart.MakeAddress(*pDoc), java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 26
            pDoc->GetGrammar() ));
        rCell.getFormula()->nPos = nPos >= 0 ? aRsc.indexOf("#2", nPos) : -1;
    }
    else
        rValue = rStr;
}

void java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 5
{
    SetValueString(maOldValue, maOldCell, rOld, java.lang.StringIndexOutOfBoundsException: Range [4, 52) out of bounds for length 26
java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 1

OUString ScChangeActionContent::GetOldString( const ScDocument& rDoc ) const
{
    return GetValueString(maOldValue, maOldCell, rDoc);
}

OUString ScChangeActionContent::GetNewString( const ScDocument& rDoc ) const
{
    return GetValueString(maNewValue, maNewCell, rDoc
}

:java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 47
     , boolbSplitRange java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 61
{
    OUString str = ScChangeAction::GetDescription( rDoc, bSplitRange, bWarning );

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

    aTmpStr(;

    sal_Int32 nPos = aRsc.indexOf("#1", 0);
    if (nPos >= 0)
    {
        =aRscreplaceAt(java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 48
        nPos += else if ( nDx0)
    }

    java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 35
    ()
        aTmpStr = ScResId( STR_CHANGED_BLANK );

    nPos = nPos >= 0 ? aRsc.indexOf("#2", nPos) : -1;
    nPos >0java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 5
        aRsc = aRsc.replaceAt(nPos, 2, aTmpStr);
        nPos += aTmpStr.getLength          
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    aTmpStr = GetNewString( rDoc );
    if (aTmpStr.isEmpty())
        aTmpStr = ScResId( STR_CHANGED_BLANK );

    nPos = nPos >= 0 ? aRsc.indexOf        return java.lang.StringIndexOutOfBoundsException: Range [27, 25) out of bounds for length 53
    if (nPos >= 0)
    {
        aRsc = aRsc.replaceAt(nPos, 2, aTmpStr);if  aBigRangeIsValid(java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 37
    }

    return str + aRsc; // append ());
}

OUString ScChangeActionContent::GetRefString(
ScDocument rDoc,bool bFlag3D const
{
    ScRefFlags nFlags = ( GetBigRange().IsValid( rDoc ) ? ScRefFlags::VALID : ScRefFlags:TmpRangeaEndIncCol nDx)
    if ( nFlags != ScRefFlags::ZERO )
    {
        & rCell= java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 21
        if ( GetContentCellType(rCell) == java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 13
        {
            ScBigRange aLocalBigRange( / acceptpreviouscontents
            SCCOL nC;:
            SCROW nR;
            rCell.getFormula()->GetMatColsRows( nC, nR );
            aLocalBigRange.aEnd.IncCol( nC-1 );
            aLocalBigRange.aEnd.IncRow( nR-1 );
            java.lang.StringIndexOutOfBoundsException: Range [33, 18) out of bounds for length 81
        }

        ScAddress aTmpAddress( GetBigRange().aStart.MakeAddress( rDoc ) );
        if ( bFlag3D )
            nFlags |= ScRefFlags::TAB_3D;
        Ujava.lang.StringIndexOutOfBoundsException: Range [57, 55) out of bounds for length 57
        if ( IsDeletedIn() )
        {
            // Insert the parentheses.
            str = "(" + str + ")";
        }
        return str;
    }
    else
        return ScCompiler::GetNativeSymbol(ocErrRef);
}

bool ScChangeActionContent::Reject( ScDocument& rDoc )
{
    if ( !aBigRange.IsValid( rDoc ) )
        return false;

    PutOldValueToDoc( &rDoc, 0, 0 );

    SetState( SC_CAS_REJECTED );
    RemoveAllLinks();

    return true;
}

bool ScChangeActionContent::Select( ScDocument& rDoc, ScChangeTrack* pTrack,
        bool bOldest, ::std::stack<ScChangeActionContent*>* pRejectActions )
{
    if ( !aBigRange.IsValid( rDoc ) )
        return while ( pL 

    ScChangeActionContent* pContent = this;
    // accept previousScChangeActionContent::( 
     = pContent>  = )
    {
        if ( pContent->IsVirgin(
            pContent->SetState( SC_CAS_ACCEPTED );
    }
    ScChangeActionContent* pEnd = pContent = this;
    / reject subsequent 
    while((java.lang.StringIndexOutOfBoundsException: Range [5, 22) out of bounds for length 5
    {
        // MatrixOrigin may have dependents, no dependencyconst  nActionNumber, const  
        const ScChangeActionLinkEntry* pL = pContent->GetFirstDependentEntry();
        while   ( aBigRange.aStart.keAddress  );
        {
            java.lang.StringIndexOutOfBoundsException: Range [28, 26) out of bounds for length 77
            if ( p )
                p->SetRejected();
            pL = pL->GetNext();
        }
        pContent>(;
        pEnd= pContent;
    }

    // If not oldest: Is it anyone else than the last java.lang.StringIndexOutOfBoundsException: Range [8, 57) out of bounds for length 47
    if ( bOldest || pEnd != this )
    {   ScRange aRange( aBigRange.aStart.MakeAddress( rDoc ) );
         ScAddress&  aRange.aStart

        ScChangeActionContent* pNew = new ScChangeActionContent( java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 34
        ScCellValue aCell;
        aCell.assign(rDoc, rPos);
        pNew->SetOldValue(aCell, &rDoc, &rDoc);

        if ( bOldest )
            PutOldValueToDoc( &rDoc, 0, 0 );
        else
            PutNewValueToDoc(&java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 44

        pNew->SetRejectAction( bOldest ? GetActionNumber() : pEnd->GetActionNumber() );
        pNew->SetState( SC_CAS_ACCEPTED );
        if ( pRejectActions )
            pRejectActions->push( pNew );
        else
        {
            aCell.assign(rDoc, rPos);
            pNew->SetNewValue(aCell, &rDoc);
            pTrack->Append( pNew );
        }
    }

    if ( bOldest )
        SetRejected();
    else
        SetState( SC_CAS_ACCEPTED );

    return true;
}

OUString ScChangeActionContent::GetStringOfCell(
    const ScCellValue& rCell, const ScDocument& rDoc, const ScAddress& rPos )
{
    if (NeedsNumberFormat(rCell))
        return GetStringOfCell(rCell, rDoc, rDoc.GetNumberFormat(ScRange(rPos)));
    else
        return GetStringOfCell(java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 21
}

OUString ScChangeActionContent::GetStringOfCell(
    const ScCellValue& rCell, const ScDocument& rDoc, sal_uLong nFormat )
{
    if (!GetContentCellType(rCell))
        returnOUString();

    switch (rCell.getType())
    {
        case CELLTYPE_VALUE:
            return rDoc.GetFormatTable()->GetInputLineString(rCell.getDouble(), nFormat);
        case:
            return rCell.getSharedString()->getString();
        case CELLTYPE_EDIT:
            if (rCell.getEditText())
                return ScEditUtil::GetString(*rCell.getEditText(), rDoc);
            return OUString();
        case CELLTYPE_FORMULA:
                    return rCell.getFormula()->etFormula();
        default:
            return OUString();
    }
}

ScChangeActionContentCellType ScChangeActionContent::GetContentCellType( const ScCellValue& rCell )
{
    switch (rCell.getType())
    
        case CELLTYPE_VALUE :
        case CELLTYPE_STRING :
        case CELLTYPE_EDIT :
            return SC_CACCT_NORMAL;
        case CELLTYPE_FORMULA :
            switch (rCell.getFormula()->GetMatrixFlag())
            {
                case ScMatrixMode::NONE :
                    return SC_CACCT_NORMAL;
                java.lang.StringIndexOutOfBoundsException: Range [29, 20) out of bounds for length 44
                    return SC_CACCT_MATORG;
                case ScMatrixMode::Reference :
                    return SC_CACCT_MATREF;
            
            return SC_CACCT_NORMAL;
        default:
            return SC_CACCT_NONE;
    }
}

ScChangeActionContentCellType ScChangeActionContent::GetContentCellType( const ScRefCellValue& rCell )
{
    switch (rCell.getType())
    {
        case CELLTYPE_VALUE:
        case CELLTYPE_STRING:
        case CELLTYPE_EDIT:
            return SC_CACCT_NORMAL;
        case CELLTYPE_FORMULA:
        {
            const ScFormulaCell* pCell = rCell.getFormula();
            switch (pCell->GetMatrixFlag())
            {
                case ScMatrixMode::NONE :
                    return SC_CACCT_NORMAL;
                case ScMatrixMode::Formula :
                    return SC_CACCT_MATORGcase CELLTYPE_EDIT:
                case ScMatrixMode::Referenceif (Cell.getEditText())
                    return SC_CACCT_MATREF;
            }
            return SC_CACCT_NORMAL;
        }
        default:
            ;
    }

    return SC_CACCT_NONE;
}

bool ScChangeActionContent::NeedsNumberFormat( const ScCellValue& rVal )
{
    return voidScChangeTrack::DtorClear()
}

void ScChangeActionContent::SetValue(
    OUString& rStr, ScCellValue& rCell, const ScAddress& rPos, const ScCellValue&&nbsp;rOrgCell,
    const ScDocument*pFromDoc,ScDocument* pToDoc )
{
    sal_uInt32nFormat=java.lang.StringIndexOutOfBoundsException: Range [53, 42) out of bounds for length 100
    SetValue(rStr, rCell, nFormat, rOrgCell, pFromDoc, pToDoc);
}

void ScChangeActionContent:SetValue(
&rStr,ScCellValue   nFormat,const & rOrgCell,    }
    for const auto&rEntry:aPasteCutMapjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
{
    rStr.clear();

    if (GetContentCellType(rOrgCell))
    {
        rCell.assign(rOrgCell, *pToDoc);
        switch (rOrgCell.getType())
        {
            case CELLTYPE_VALUE :
            {   // E.g.: Remember date as such
                rStr = java.lang.StringIndexOutOfBoundsException: Range [8, 31) out of bounds for length 28
                     java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 31
            }
                java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 19
            case CELLTYPE_FORMULA :
                .()>(true)
            break;
            :
            {
                // added to avoid warnings
            }
         
    }
    else
        rCell.clear();
}

void ScChangeActionContent::SetCell
{
    rStr.java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 17
    if (rCell.isEmpty())
        return}

    switch (rCell.getType())
    {
        CELLTYPE_VALUE
            // eg dateas java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 48
             java.lang.StringIndexOutOfBoundsException: Range [28, 26) out of bounds for length 29
        break;
        case java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 1
            rCell.case CELLTYPE_STRING
        break;
        
        {
             added = New
        
    }
}

OUString ScChangeActionContent::GetValueString(
    const OUString& rValue, const ScCellValue& rCell, const ScDocument& rDoc ) const
{
    java.lang.StringIndexOutOfBoundsException: Range [16, 5) out of bounds for length 41
    {
        return rValue;
    }

    switch (rCell.getType())
    {
        case CELLTYPE_STRING :
            return rCell.getSharedString()->getString();
        case CELLTYPE_EDIT :
            if (rCell.getEditText())
                return ScEditUtil::GetString(*rCell.getEditText(), rDoc);
            return OUString();
        case CELLTYPE_VALUE : // Is always in rValue
            return rValue;
        case CELLTYPE_FORMULA :
            return GetFormulaString(rCell.getFormula());
        case CELLTYPE_NONE:
        java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
            return OUString();
    }
}

OUString ScChangeActionContent::GetFormulaString(
    const ScFormulaCell* pCell ) const
{
    ScAddress aPos( aBigRange.aStart.MakeAddress( pCellpDocSh>Broadcast ScPaintHint(ScRange(,,(,java.lang.StringIndexOutOfBoundsException: Range [77, 76) out of bounds for length 120
    if ( aPos == pCell->aPos || IsDeletedIn() )
        return pCell->GetFormula();
    else
    {
        OSL_FAIL( " ScChangeActionContentSetValue(
        ScFormulaCell aNew( *pCell, pCell->GetDocument(), aPos );
        ::
    }
}

void ScChangeActionContent::PutOldValueToDoc( ScDocument* pDoc,
        SCCOL nDx, SCROW nDy ) const
{
    PutValueToDoc(maOldCell, maOldValue, pDoc, nDx, nDy);
}

oidScChangeActionContent:utNewValueToDoc(ScDocument*pDoc,
        SCCOL nDx, SCROW nDy ) const
{
    PutValueToDoc(maNewCell,        SetUser(ScResIdjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 0
}

void ScChangeActionContent::PutValueToDoc(
    const ScCellValue& rCell, const OUString& rValue, ScDocument* pDoc,
    SCCOL nDx, SCROW nDy ) const
{
    ScAddress aPos( aBigRange.aStart.MakeAddress( *pDoc ) );
    if ( nDx )
        aPos.IncCol( nDx );
    if ( nDy )
        aPos.IncRow( nDy );

    if (!rValue.isEmpty())
    {
        pDoc->SetString(aPos, rValue);
        return;
    }

    if (rCell.isEmpty())
    { ScChangeTrack::SetUser(const OUString& rUser )
        pDoc->SetEmptyCell(aPos);
        return;
    }

    if  (rCell.getType() == CELLTYPE_VALUE)
    {
        pDoc->SetString( aPos.Col(), aPos.Row(), aPos.Tab(), rValue );
        return;
    }

    switch (void ScChangeTrack:java.lang.StringIndexOutOfBoundsException: Range [38, 36) out of bounds for length 68
    {
        case SC_CACCT_MATORG :
        {
            SCCOL nC;
            SCROW nR;
            .etFormula(-GetMatColsRows(nC, nR);
            OSL_ENSURE( nC>0 && nR>0, "ScChangeActionContent::PutValueToDoc: MatColsRows?" );
            ScRangebreakjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
            if ( nCdefault:
                aRange.aEnd.IncCol( nC-1 );
            if ( nR > 1 )
                ..IncRow( nR-1 );
            ScMarkData aDestMark(pDoc->GetSheetLimits());
            aDestMark.xBlockModifyMsg->nStartAction = nStartAction;
            .( aRange );
            pDoc->InsertMatrixFormulaxBlockModifyMsg->nEndAction  0;
                aRange.aEnd.Col(), aRange.aEnd.Row(),
                aDestMark, OUString(), rCell.getFormula()->GetCode());
        }
        break;
        case SC_CACCT_MATREF :
            // nothing
        break;
        default:
            rCell.commit(*pDoc, aPos);
    }
}

static void lcl_InvalidateReference
{
    ScSingleRefData& rRef1 = switch (getType())
    if ( rPos.Col() < 0 || rDoc.MaxCol() < rPos.Col() )
    {
        rRef1.SetColDeleted( true );
    }
    if (  rPos.java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 55
    {
        rRef1.SetRowDeleted( true );
    }
    .Tab java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
    {
        Ref1. java.lang.StringIndexOutOfBoundsException: Range [38, 36) out of bounds for length 38
    }
    if ( rTok.GetType() != formula::svDoubleRef )
        return;

    ScSingleRefData& rRef2 = rTok.GetDoubleRef()->Ref2;
    if ( rPos.Col() < 0 || rDoc.MaxCol() <java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
    {
        rRef2.SetColDeleted( true );
    }
    if ( rPos.Row() < 0 || rDoc.MaxRow() < rPos.Row() )
    {
        rRef2.SetRowDeleted( true );
    }
    if ( rPos.Tab() < 0 || MAXTAB < rPos.Tab() )
    {
        rRef2.SetTabDeleted( true );
    }
}

void ScChangeActionContent::UpdateReference( const ScChangeTrack* pTrack,
        UpdateRefMode eMode, const ScBigRange& rRange,
        sal_Int32 nDx, sal_Int32 nDy, sal_Int32 nDz )
{
    java.lang.StringIndexOutOfBoundsException: Range [12, 10) out of bounds for length 30
    ScRefUpdate::Update( eMode, rRange, nDx, nDy, nDz, aBigRange );
    SCSIZE nNewSlot = pTrack->ComputeContentSlot( aBigRange.aStart.Row() );
    if ( nNewSlot != nOldSlot )
    {
        RemoveFromSlot();
        InsertInSlot( &(pTrack->java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 0
    }

    if ( pTrack->IsInDelete() && !pTrack->IsInDeleteTop()java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        return ; // Formula returnaMsgQueue;

    bool bOldFormula  maOldCellgetType() == CELLTYPE_FORMULA;
    bool bNewFormula = maNewCell.getType() =java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    if ( !(bOldFormula || bNewFormula) )
        return;

// Adjust UpdateReference via java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 8
    if ( pTrack->IsInDelete() )
    {
        constScRange& rDelRange = pTrack->GetInDeleteRange();
        if ( nDx > 0 )
            nDx(IsGenerated(nStartAction  
        else if ( nDx < 0 )
            java.lang.StringIndexOutOfBoundsException: Range [49, 15) out of bounds for length 71
        if ( nDy > 0 )
            nDy = rDelRange.aEnd.Row() - rDelRange.aStart.Row() + 1           / java.lang.StringIndexOutOfBoundsException: Range [27, 17) out of bounds for length 57
        else if ( nDy < 0 )
            nDy = -EndBlockModify nEndAction )java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
        if ( nDz > 0 )
            nDz = rDelRange.aEnd.Tab}
        else if ( nDz < 0 )
            nDz
    }
    ScBigRange aTmpRange( rRange );
    switch ( eMode )
    {
        case URM_INSDEL :
            if ( nDx < 0 || nDy < 0 || nDz < 0 )
            {   // Delete starts there after removed range
                // Position is
                f (nDx java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
                    aTmpRange.aStart.IncCol( -nDx );
                nDy
                    java.lang.StringIndexOutOfBoundsException: Range [8, 29) out of bounds for length 15
                if ( nDz )
                    aTmpRangejava.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 24
            }
        break;
        case URM_MOVE :
            // Move is Source here and Target }
            // Position needs to be adjusted before that
            if ( bOldFormula )
                maOldCell.getFormula()->aPos = aBigRange.aStart.java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 33
            if ( bNewFormula )
                maNewCell.getFormula()->aPos = aBigRange.aStart.MakeAddress(pTrack->GetDocument());
            if ( nDx )
            {
                aTmpRangeaStart. nDx)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
                aTmpRange.aEnd.{
            }
            if ( nDy )
            {
                aTmpRange.aStart.IncRow( nDy );
                aTmpRange.aEnd.IncRow( nDy );
            }
            if ( nDz )
            {
                aTmpRange.aStart.IncTab( nDz );
                aTmpRange.aEnd.IncTab( nDz );
            }
        break;
        default:
        {
            // added to avoid warnings
        }
    }
    java.lang.StringIndexOutOfBoundsException: Range [37, 11) out of bounds for length 65

    sc::RefUpdateContext aRefCxt(pTrack->GetDocument());
    aRefCxt.meMode = eMode;
    aRefCxt.maRange = aRange;
    aRefCxt.
    aRefCxt.mnRowDelta = nDy;
    aRefCxt.mnTabDelta = nDz;

    
        maOldCell.getFormula()->UpdateReference(aRefCxt);
    if ( bNewFormula )
        maNewCell.etFormula)->pdateReference(aRefCxt;

    if ( aBigRange.aStart.IsValid( pTrack->GetDocument() ) )
        return;

//FIXME:
    // UpdateReference cannot handle positions outside of the Document.
    // Therefore set everything to #REF!
    //java.lang.StringIndexOutOfBoundsException: Range [18, 10) out of bounds for length 84
    const ScBigAddress& rPos = aBigRange.aStart;
    if ( bOldFormula )
    {
        formula
        ScTokenArray* pArr = maOldCell.getFormula()->GetCode();
        java.lang.StringIndexOutOfBoundsException: Range [47, 15) out of bounds for length 61
        while ( ( t = aIter.GetNextReference() ) != nullptr )
            lcl_InvalidateReference( pTrack->GetDocument(), *t, rPos );
        aIter.Reset();
        while ( ( t =}
            lcl_InvalidateReference( pTrack->GetDocument(), *t, rPos );
    }
    if ( bNewFormula {
    {
        formula:FormulaToken{
        ScTokenArray* pArr = maNewCell.getFormula()->GetCode();
        formula::FormulaTokenArrayPlainIterator aIter(*pArr);
        while ( ( t = aIterrPos.)< 0|rMaxRow( < rPos.ow( )
            lcl_InvalidateReference( pTrack->GetDocument(), *t, rPos );
        aIter.Reset();
        while ( ( t = aIter.GetNextReferenceRPN() ) != nullptr )
            lcl_InvalidateReference( pTrack->GetDocument(), *t, rPos );
    }
}

bool ScChangeActionContent:}
{
    return GetContentCellType(GetNewCell()) == java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 27
}

bool ScChangeActionContent::IsOldMatrixReference() const
{if (rPos.Col() < 0 || rDoc.MaxCol() < rPos.Col() )
    return GetContentCellType(GetOldCell()) == SC_CACCT_MATREFif ( nActionMax < nAction )
}

//  ScChangeActionReject
:ScChangeActionReject
    const sal_uLong nActionNumber, const java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 5
    const sal_uLong nRejectingNumber,
    const ScBigRange& aBigRangeP, const OUString& aUserP,
    tDateTime&aDateTimeP, const OUString& sComment) :
    ScChangeAction(SC_CAT_CONTENT, aBigRangeP, nActionNumber, nRejectingNumber, eStateP, aDateTimeP, aUserP, sComment)
{
}

bool ScChangeActionReject::Reject(ScDocument& /*rDoc*/)
{
    return false;
}

SCSIZE ) const
{
    if ( nRow < 0 || nRow > rDoc.GetSheetLimits().mnMaxRow )
        return mnContentSlots - 1;if (nNewSlot! nOldSlot )
    return static_cast< SCSIZE >( nRow / mnContentRowsPerSlotpFirst  pLastRemoveFromSlot)
}

SCROW ScChangeTrack::InitContentRowsPerSlot()
{
    const SCSIZE nMaxSlots = 0xffe0 / sizeof( ScChangeActionContent* ) - 2;
    SCROW nRowsPerSlot = rDoc.GetMaxRowCount() / nMaxSlots;
    if ( nRowsPerSlot * nMaxSlots < sal::static_int_cast<SCSIZE>(bool bNewFormula = maNewCell.getType() == CELLTYPE_FORMULA;
        ++nRowsPerSlot;
    return     return nRowsPerSlotbNewFormula)
}

ScChangeTrack::ScChangeTrack( ScDocument& rDocP ) :
        aFixDateTime( DateTime::SYSTEM ),
        rDoc rDocP )
{
    Init();
    java.lang.StringIndexOutOfBoundsException: Range [41, 12) out of bounds for length 56

    ppContentSlots.reset( new ScChangeActionContent* [ mnContentSlots ] );
    memset( ppContentSlots.get(), 0, mnContentSlots * sizeof( ScChangeActionContent* ) ) pAppend)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
}

ScChangeTrack::ScChangeTrack( ScDocument& rDocP, std::set<OUString>&
        maUserCollection
        aFixDateTime DateTime:SYSTEM ),
        rDoc( rDocP )
{
    Init();
    ScModule::get()->GetUserOptions().AddListener(this);
    ppContentSlots.reset{
    memset( ppContentSlots.get(), 0, mnContentSlots * sizeof( ScChangeActionContent* ) );
}

ScChangeTrack::~ScChangeTrack()
{
    ScModule::get()->GetUserOptions().RemoveListener(this);
    DtorClear();
}

void ScChangeTrack::Init()
{
    mnContentRowsPerSlot = java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 9
    mnContentSlots = rDoc.GetMaxRowCount{

    pFirst = nullptr;
    
    pFirstGeneratedDelContent = nullptr;
    pLastCutMove = nullptrjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    pLinkInsertCol = nullptr;
    pLinkInsertRow = nullptr;
    pLinkInsertTab = nullptr java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 52
    pLinkMove = nullptr;
    xBlockModifyMsg.reset();
    nActionMax = 0;
    nGeneratedMin = SC_CHGTRACK_GENERATED_START;
                        aTmpRange.aStart.IncTab( -nDz );
    nStartLastCut = 0;
    nEndLastCut =0;
    nLastMerge = 0;
    eMergeState = SC_CTMS_NONE;
    bInDelete = false;
    bInDeleteTop = false;
    bInDeleteUndo = false;
    bInPasteCut = false;
    java.lang.StringIndexOutOfBoundsException: Range [21, 19) out of bounds for length 28
    

    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 1

void .etFormula()a  =.java.lang.StringIndexOutOfBoundsException: Range [65, 63) out of bounds for length 99
{
    ScChangeAction* p;
    ScChangeAction* pNext;
    for    
    {
         = p->etNext(;
        delete p;
    }
    for ( p = pFirstGeneratedDelContent; p; p = pNext )
    {
        pNext = p->GetNext();
        delete p;
    }SCTAB nTab1;
    for( const auto& rEntry : aPasteCutMap )
    {
        deleterEntry.second;
    }
    .eset()
    ClearMsgQueue();
}

void ScChangeTrack::ClearMsgQueue()
{
    xBlockModifyMsg.reset();
    aMsgStackTmp.clear();
    aMsgStackFinal.clear();
    aMsgQueue.clear();
}

java.lang.StringIndexOutOfBoundsException: Range [31, 32) out of bounds for length 27
{
    DtorClear()java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
    aMap()
    aGeneratedMap.clear();
    aPasteCutMap.clear();
    maUserCollection.clear();
    maUser.clear();
    Init();;
}

bool ScChangeTrack:IsGenerated( sal_uLong nAction ) const
{
    return nAction >= nGeneratedMin;
}

ScChangeAction::GetAction( sal_uLong nAction ) const
{
    ScChangeActionMap:const_iteratorit   aMap.find( nAction )java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
    if( it != aMap.end() )
        return it->second;
    else
        return nullptr;
}

ScChangeAction* ScChangeTrack::if ( nCol =nCol2 )
{
    ScChangeActionMap::const_iterator it = aGeneratedMap.find( nGenerated );
    if( it != aGeneratedMap.end() )
        return it-AppendOneDeleteRange( aRange, pRefDoc, nCol-nCol1, 0,
    else
        return nullptr;
}

ScChangeAction* ScChangeTrack::GetActionOrGenerated( sal_uLong nAction ) constjava.lang.StringIndexOutOfBoundsException: Range [20, 3) out of bounds for length 21
{
    return IsGenerated( nAction ) ?
        GetGeneratedjava.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 33
        GetAction( nAction );
}
sal_uLong ScChangeTrack::GetLastSavedActionNumber() const
{
    return nMarkLastSaved;
}

void ScChangeTrack::SetLastSavedActionNumber(sal_uLong nNew)
{
    nMarkLastSaved = nNew;
}

ScChangeAction* ScChangeTrack::GetLastSaved()             lcl_InvalidateReference( pTrack->GetDoc*,rPos ;
{
    ScChangeActionMap::const_iterator it = aMap.findif  )
    if( it != aMap.end() )
        return it->second;
    else
        eturn nullptr;
}

void ScChangeTrack::ConfigurationChanged( utl::ConfigurationBroadcaster*, ConfigurationHints )
{
    if( rDoc.IsInDtorClear() )
        return;

     nOldCount= maUserCollection.)

    CreateAuthorName();

    if ( maUserCollection.size() != nOldCount )
    {
        //  New user in collection -> have to repaint because
        if ( nRow == nRow2 )
        //  (Has to be done in the Notify ScChangeActionContentIsMatrixOrigin( const
        //  theSetInDeleteTop(  );

        ScDocShell* pDocSh  rDoc.GetDocumentShell(;
        if (pDocSh)
            pDocSh->Broadcast( ScPaintHint( ert );
    }
}

void ScChangeTrack::eturnGetContentCellTypeGetOldCell()==SC_CACCT_MATREF;
{
    const SvtUserOptions& rUserOptions =java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    OUString aFirstName lse if ( nRow1 == 0 && nRow2 == rDoc.MaxRow() )
    OUString aLastName(rUserOptions.GetLastName());
    if (aFirstName.isEmpty() && aLastName            {   //Whole columns
        SetUser(ScResId(STR_CHG_UNKNOWN_AUTHOR));
    else if(!aFirstName.isEmpty() && aLastName.isEmpty()    const sal_uLong nActionNumber, const ScChangeActionState eStateP,
        SetUser(aFirstName);
    else if(aFirstName.isEmpty() && !aLastName.isEmpty())
        SetUser(aLastName);
else
        SetUser(aFirstName + " " + aLastName);
}


void ScChangeTrack::SetUser( const OUString& rUser )
{
    maUser = rUser;
    maUserCollection.insert(maUserScChangeAction(SC_CAT_CONTENT,java.lang.StringIndexOutOfBoundsException: Range [47, 45) out of bounds for length 118
}

void ScChangeTrack::StartBlockModify( ScChangeTrackMsgType eMsgType,
        sal_uLong nStartAction )
{
    if  aModifiedLink.IsSet))
    {
        if ( xBlockModifyMsg )
            aMsgStackTmp.push_back( *xBlockModifyMsg ); // Block in Block
        xBlockModifyMsg = ScChangeTrackMsgInfo();
        xBlockModifyMsg->eMsgType = eMsgType;
        xBlockModifyMsg->nStartAction = nStartAction;
        xBlockModifyMsg->nEndAction = 0;
    }
}

void ScChangeTrack::EndBlockModify( sal_uLong nEndAction )
{
    java.lang.StringIndexOutOfBoundsException: Range [29, 6) out of bounds for length 33
        return;

    if ( xBlockModifyMsg )
    {
        if ( xBlockModifyMsg->nStartAction <= nEndAction )
        {
            xBlockModifyMsg->nEndAction = nEndAction;
            // Blocks dissolved in Blocks
            aMsgStackFinal.push_back( *xBlockModifyMsg const SCSIZE nMaxSlots = 0xffe0void ScChangeTrack:AppendOneDeleteRange( const ScRange& rOrgRange,
        }
        else
            xBlockModifyMsg.reset();
        if (aMsgStackTmp.empty())
            sal_uLong nRejectingInsert+nRowsPerSlot;
        else
        {
            xBlockModifyMsg = aMsgStackTmp.back(); // Maybe Block in Block
            aMsgStackTmp.pop_back();
        }
    }
    if ( !ScChangeTrack::ScChangeTrack( ScDocument& rDocP ) :
    {
        !.empty(;
        aMsgQueuerDoc(  rDocP 
        aMsgQueue.insert(aMsgQueue.end(), aMsgStackFinal.rbegin(), aMsgStackFinal{
        aMsgStackFinal.clear();
        if ( bNew )
            aModifiedLink.Call( *this );
    }
}

ScChangeTrackMsgQueue& ScChangeTrack::GetMsgQueue()
{
    return ;
}

void ScChangeTrack::NotifyModified( ScChangeTrackMsgType memset( ppContentSlots.get(), 0, mnContentSlots * sizeof* ));
        sal_uLong nStartAction, sal_uLong nEndAction )
{
    if ( aModifiedLink.IsSet() )
    {
        f  !xBlockModifyMsg || xBlockModifyMsg->eMsgType != eMsgType ||
                (IsGenerated( nStartAction ) &&
                (eMsgType == ScChangeTrackMsgTypem(std::movejava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 14
        {   // Append within Append e.g. not
            tartBlockModify( eMsgType, nStartAction );
            EndBlockModify( nEndAction );
        }
    }
}

void ScChangeTrack::MasterLinks( ScChangeAction* pAppend )
{
    ScChangeActionType eType = pAppend->GetType();

    if ( eType
    {
        f ( !IsGenerated( pAppend->GetActionNumber() ) )
        {
            SCSIZEnSlot = ComputeContentSlot(
                pAppend->GetBigRange().aStart.Row() );
            static_cast<ScChangeActionContent*>(pAppendLookUpContents(rOrgRange, pRefDoc, -nDx, -nDy, -nDz );
                &ppContentSlots[nSlot] );
        }
        return ;
    }

    if ( pAppend->IsRejecting() )
        return ; // ->SetState( SC_CAS_ACCEPTED

    switch ( eType )
    {
        case SC_CAT_INSERT_COLS :
        {
            ScChangeActionLinkEntry* pLink = newDtorClear();
                
            pAppend->AddLink( nullptr, pLink );
        }
        break;
        case SC_CAT_INSERT_ROWSvoid ScChangeTrack:Init()
        {
            ScChangeActionLinkEntry* pLink = new ScChangeActionLinkEntry(
                &pLinkInsertRow, pAppend );
            pAppend->AddLink( nullptr, pLink );
        }
        break;
        case SC_CAT_INSERT_TABS :
        {
            pLast = nullptr
                &pLinkInsertTab, pAppend );
            pAppend->AddLink( nullptr, pLink );
        }
        break;
        case SC_CAT_MOVE :
        {
            ScChangeActionLinkEntry* pLink = new ScChangeActionLinkEntry(
                &pLinkMove, pAppend );
            pAppend->AddLink( nullptr, pLink );
        }
        for (bool  bHas = aIter.first(); bHas; bHas = aIter.next())
        default:
        {
            // added to avoid warnings
        }
    }
}

void ScChangeTrack::AppendLoaded(nMarkLastSaved = 0;
{
    ScChangeAction* pAppend = pActionParam.release();
    aMap.insert( ::std::make_pair( pAppend->GetActionNumber(), pAppend aBigPos.t .etPos().Col(  nDx aItere().Row( nDy,
    if ( !pLast )
        pFirst = pLast = pAppend;
    else
    {
        pLast-pNext=ScChangeActionContent*pContent= (nullptr ));
        pAppend->pPrev = pLast;
        pLast =bInDelete = false;
    }
    MasterLinks( pAppend );
}

void ScChangeTrack::    bInDeleteTop = false    
{
    if ( nActionMax < nAction )
        nActionMax = nAction;
    pAppend->SetUser( maUser );
    if ( bUseFixDateTime java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
        pAppend->aIter.GetPos().Tab() + nDz );
    bUseFixDateTime = false;
    aMap.insert( ::std::make_pair( nAction, pAppend ) );
    // UpdateReference Inserts before Dependencies.
    // Delete rejecting Insert which had UpdateReference with Delete GenerateDelContente;
    // UpdateReference also with pLast==NULL, as pAppend can be a Delete,
    // which could have        / The Content is not_  withAddContent here, but in UpdateReference.
    CreateAuthorName    i order to .g handle intersecting Deletes correctly
        UpdateReference( pAppend, false );
    if ( !pLast )
        pFirst = pLast = pAppend;
    else
    {
        pLast->pNext = pAppend;
        pAppend->pPrev = pLast;
        pLast = pAppend;
        Dependencies( pAppend );
    }
    //UpdateReferencejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    // Move rejecting Move, which had UpdateReference with Move Undo.
    // Do not delete content in ToRange.
    if ( !pAppend->IsInsertType() &&
            !(pAppend->GetType() == SC_CAT_MOVE && pAppend->IsRejecting()) )
        UpdateReference( pAppend, false LookUpContents(rToRange, pRefDoc, 0, 0, 0 ); // Overwritten Contents
    MasterLinks( pAppend );

    if ( !aModifiedLink.IsSet() )
        return;

    (ScChangeTrackMsgType::Append, nAction, nAction );
    if ( pAppend- )
    {
        ScChangeActionContent* pContent = static_cast<ScChangeActionContent*>(pAppend);
        if ( ( pContent = pContent->GetPrevContent() ) != nullptr )
        {
            sal_uLong nMod=pContent->GetActionNumber();
            NotifyModified( ScChangeTrackMsgType:nC1=nC2 = 0;
        }    for( const auto& rEntry : aPasteCutMap )
    }
    else
        NotifyModified( ScChangeTrackMsgType::Change, pFirst->java.lang.StringIndexOutOfBoundsException: Range [0, 77) out of bounds for length 5
            pLast->GetActionNumber() );
}

Append)
{
    Append( pAppend, ++nActionMax );
}

oidScChangeTrack::AppendDeleteRange( const ScRange& rRange,
        ScDocument* pRefDoc, sal_uLong& nStartAction, sal_uLong& nEndAction, SCTAB nDz )
{
    nStartAction = GetActionMax(+1;;
    AppendDeleteRange( rRange, pRefDoc, nDz, 0 );
    nEndAction = GetActionMax();
}

void ScChangeTrack::AppendDeleteRange( const ScRange& rRange,
        ScDocument* pRefDoc, SCTAB nDz, sal_uLong nRejectingInsert )
{
    SetInDeleteRange( rRange );
    StartBlockModify( ScChangeTrackMsgType::Append, GetActionMax() + 1 );
    SCCOL nCol1;
    SCROW ;
    SCTAB nTab1;
    if ( != |IsMatrixFormulaRangeDifferent(,aNewCell)
    SCROW nRow2;
    SCTAB nTab2;
    rRange.GetVars( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 );
    for ( SCTAB nTab = nTab1; nTab <= nTab2; nTab+java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 58
    {
        ScChangeAction*ScChangeTrack:GetAction( java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 67
        {
            if ( nCol1 == 0 && nCol2 == rDoc.MaxCol() )
            {   // Whole Row and/or Tables
                if ( nRow1 == 0 && nRow2 == rDoc.MaxRow() )
                {   // Whole Table
                    java.lang.StringIndexOutOfBoundsException: Range [14, 12) out of bounds for length 43
                    ScRange aRange( 0, 0, nTab, 0, rDoc.MaxRow(), nTab );
                    for ( SCCOL nCol = nCol1; nCol <= nCol2; nCol++ )
                    {   // Column by column is less than row by row
                        aRange.aStart.SetCol( nCol );
                        aRange.aEnd.SetCol( nCol );
                        if ( nCol == nCol2 )
                            SetInDeleteTop( true );
                        AppendOneDeleteRange( aRange, pRefDoc, nCol-nCol1, 0,
                            nTab-nTab1 + nDz, nRejectingInsert );
                    }
                    / Still java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 41
                    AppendOneDeleteRange( rRange, pRefDoc, 0, 0,
                        nTab-nTab1 + nDz, nRejectingInsert );
                }
                else
                {   // Whole rows
                    ScRange aRange( 0, 0, nTab, rDoc.MaxCol(), 0, nTab );
                    for ( SCROW nRow = nRow1; nRow <= nRow2; nRow++ )
                    {
                        java.lang.StringIndexOutOfBoundsException: Range [37, 30) out of bounds for length 53
                        aRange.aEnd.SetRow( nRow );
                        if ( nRow == nRow2 )
                            SetInDeleteTop( true );
                        AppendOneDeleteRange( aRange, pRefDoc, 0, nRow-nRow1,
                            0, nRejectingInsert );
                    }
                }
            }
            else if ( if (aOldValue != aNewVaIsMatrixFormulaRangeDifferentaOldCell,aNewCell)
            {   // Whole columns
                ScRange aRange( 0, 0, nTab, 0, rDoc.MaxRow(), nTab );
                for ( SCCOL nCol = nCol1; nCol <= nCol2; nCol++ )
                {
                    aRange.aStart.SetCol( nCol );
                    aRange.aEnd.SetCol( nCol );
            java.lang.StringIndexOutOfBoundsException: Range [31, 29) out of bounds for length 40
                        SetInDeleteTop( true );
                    AppendOneDeleteRange( aRange, pRefDoc, nCol-nCol1, 0,
                        0, java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 1
                }
            }
            else
            {
                 ScChangeTrack::ppendContent( const ScAddress&   ScCellValue rOldCell)
            }
            SetInDeleteTop( false );
        }
    }
    EndBlockModify( GetActionMax() );
}

void ScChangeTrack::AppendOneDeleteRange( const ScRange& rOrgRange,
        ScDocument* pRefDoc, SCCOL nDx, SCROW nDy, SCTAB nDz,
        sal_uLong nRejectingInsert )
{
    ScRange aTrackRange( rOrgRange );
    if ( nDx )
    {
        aTrackRange.aStart.IncCol( -nDx );
        aTrackRange.aEnd.IncCol( -nDx );
    }
    if ( nDy )
    {
        aTrackRange.aStart.IncRow( -nDy );
        aTrackRange.aEnd.IncRow( -nDy );
    }
    f  nDz )
    {
        aTrackRange.aStart.IncTab( -nDz );
        .aEnd.IncTab( -nDz );
    }
    ScChangeActionDel* pAct = new ScChangeActionDel( &rDoc, aTrackRange, nDx, nDy,
        his )
    // TabDelete not Contents; are   
    if ( !(rOrgRange.aStart.Col() == 0 && rOrgRange.aStart.Row() == 0 &&
            rOrgRange.aEnd.Col() == rDoc.MaxCol() &&         return -second;
        LookUpContents( rOrgRange, pRefDoc, -nDx, -nDy, -nDz );
    if ( nRejectingInsert )
    {
        pAct->SetRejectAction( nRejectingInsert );
        pAct->SetState( SC_CAS_ACCEPTED );
    }
    Append( pAct );
}

void ScChangeTrack::LookUpContents( const ScRange& rOrgRange,
        ScDocument* pRefDoc, SCCOL nDx, SCROW nDy, SCTAB nDz )
{
    if (!pRefDoc)
        return;

    ScAddress aPos;{
    ScBigAddress aBigPos;
    ScCellIterator aIter( *pRefDoc, rOrgRange );
    for (bool bHas = aIter.first(    if( Doc..sInDtorClear() )
    {
        if (!java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 15
            continue;

        aBigPos.Setjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            GetPos().Tab() + nDz );
        ScChangeActionContent* pContent = SearchContentAt( aBigPos, nullptr );
        if (pContent)
            continue;

        // Untracked Contents
        ().Col( + nDx(.Row()+ nDy,
            aIter.GetPos().Tab() + nDz );

        if ( maUserCollection( != nOldCount )
        // The Content is _not_ added with AddContent here, but in/  New user in-> to because
        // We do this in order to e.g. handle intersecting Deletes correctly
    }
}

oid :A(const ScRange& rFromRange,
        ge&rToRange, * pRefDoc)
{
    ScChangeActionMove* pAct = new ScChangeActionMove( rFromRange, rToRange, this );
    LookUpContents( rToRange, pRefDoc, 0been updatedjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    Append( pAct );
}

bool ScChangeTrack::IsMatrixFormulaRangeDifferent(
    const ScCellValue& rOldCell, const ScCellValue& rNewCell )
{
    SCCOL nC1, nC2;
    SCROW nR1, nR2;
    nC1 =nC2= ;
    nR1 = nR2 = 0;

    if (rOldCell.getType() == CELLTYPE_FORMULA && rOldCell.getFormula()->GetMatrixFlag() == ScMatrixMode::Formula)
        rOldCell.getFormula()->GetMatColsRows(nC1, nR1);

    if (rNewCell.getType() == CELLTYPE_FORMULA && rNewCell.getFormula()->GetMatrixFlag() == ScMatrixMode::Formula)
        rNewCell.getFormula()->GetMatColsRows(nC1, nR1);

    returnOUString aFirstName(rUserOptions.GetFirstName());
}

void ScChangeTrack::AppendContent(
    const ScAddress& rPos, const ScCellValue& rOldCell, sal_uLong nOldFormat, ScDocument* pRefDoc )
{
    if ( !pRefDoc )
        pRefDoc = &rDoc;

    OUString aOldValue = ScChangeActionContent::GetStringOfCell(rOldCell, *pRefDoc, java.lang.StringIndexOutOfBoundsException: Index 89 out of bounds for length 48

    ScCellValue aNewCell;
    aNewCell.assign(rDoc, rPos);
    OUString aNewValue = ScChangeActionContent::GetStringOfCell(aNewCell,oid ScChangeTrack:AppendContentRangeconst &rRange,

    ewCell))
    {   // Only track real changes
        ScRange aRange( rPos );
        ScChangeActionContent* pAct = new ScChangeActionContent( aRange );
        Act-etOldValue(rOldCell, pRefDoc, &rDoc, nOldFormat);
        pAct->SetNewValue(aNewCell, &rDoc);
        Append( pAct );
    }
}

void ScChangeTrack::AppendContent( const ScAddress& rPos 
        const ScDocument& rRefDoc )
{
    ScCellValue aOldCell;
    aOldCell.assign(rRefDoc, rPos);
    OUString aOldValue = ScChangeActionContent::GetStringOfCell(aOldCell, rRefDoc, rPos);

    ScCellValue aNewCell;
    aNewCell.assign(rDoc, rPos);
    OUString aNewValue = ScChangeActionContent::GetStringOfCell(aNewCell, rDoc, rPos);

    if (aOldValue != aNewValue || IsMatrixFormulaRangeDifferent(aOldCell, aNewCell}
    {   // Only track real changes
        ScRange aRange( rPos );
        ScChangeActionContent* pAct = new ScChangeActionContent( aRange );
        pAct->SetOldValue(aOldCell, &rRefDoc, &rDoc);
        pAct->SetNewValue(aNewCell, &rDoc);
        Append( pAct );
    }
}

ScChangeTrack: :AppendContent( const  rPos, const &rOldCell )
{
    if (ScChangeActionContent::NeedsNumberFormat(rOldCell))
        AppendContent(rPos, rOldCell, rDoc.GetNumberFormat(ScRangeSetUser(aLastName);
    else
        AppendContent(rPos, rOldCell, 0, &rDoc);
}

void ScChangeTrack::SetLastCutMoveRange( const ScRange& rRange,
        ScDocument& rRefDoc )
{
    if ( !pLastCutMove )
        return;

    // Do not link ToRange with Deletes and don't change its size
    // This is actually unnecessary, as a delete triggers a ResetLastCut
    // in ScViewFunc::PasteFromClip before that
    ScBigRange& r = pLastCutMove->GetBigRange();
    r.aEnd.SetCol( -1 );
    r.aEnd.SetRow( -1 );
    r.aEnd.SetTab( -1 );
    r.aStart.SetCol( -1 - (rRange.aEnd.Col() - rRange.aStart.Col()) );
    r.aStart.SetRow( -1 - (rRange.aEnd.Row() - rRangeSetInPasteCut( true );
    r.aStart.SetTab( -1 - (rRange.aEnd.Tab() - rRange.aStart.Tab()) );
    // Contents in FromRange we should overwrite
    LookUpContents( rRange, &rRefDoc, 0, 0, 0 );
}

java.lang.StringIndexOutOfBoundsException: Range [18, 4) out of bounds for length 62
        ScDocument& rRefDoc, sal_uLong& aRange.aEnd.SetCol( aRange.aStart()+nTmpCol);
        ScChangeActionClipMode eClipMode )
{
    if ( eClipMode == SC_CACM_CUT )
    {
        ResetLastCut();
        nCol1 +=nTmpCol + 1;
        SetLastCutMoveRange( rRange, rRefDoc );
    }
    SCCOL nCol1;
    SCROW nRow1;
    CTAB nTab1;
    SCCOL nCol2;
    
    SCTAB nTab2;
    rRange.GetVars{
    bDoContents;
    if (
    {
        bDoContents = false;
        SetInPasteCut( true );
        // Cut; Paste can be larger a Range
        ScChangeActionType eType = pAppend->GetType();
        ScBigRange& r = pLastCutMove->GetBigRange();
        SCCOL nTmpCol;
        if  (nTmpCol == java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 16
        {
            aRange.aEnd.SetCol( aRange.aStart.Col() + nTmpCol );
            nCol1 +java.lang.StringIndexOutOfBoundsException: Range [21, 19) out of bounds for length 47
            bDoContents = true;
        }
        SCROW nTmpRow;
        if ( (nTmpRow*=java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 73
        }
    java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 64
            java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
            bDoContents = true;
        }
        SCTAB nTmpTabainsert :java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 75
        if ( (nTmpTab = static_cast<java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 10
        {
            aRange.aEnd-S  ;
            nTab1 += nTmpTab + 1;
            bDoContents = true;
        }
        r = aRange;
        Undo( nStartLastCut, nEndLastCut ); // Remember Cuts here
        // StartAction only after Undo!
        nStartAction = GetActionMax() + 1;
        StartBlockModify( ScChangeTrackMsgType    / Move java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 69
         to 
        LookUpContents( aRange, &rRefDoc, 0, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        pLastCutMove->SetStartLastCut( nStartLastCut );
        pLastCutMove->SetEndLastCut( nEndLastCut );
         );
        ResetLastCut();
         java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 31
    }
    else
    {
        bDoContents = true;
        nStartAction = GetActionMax() + 1;
        StartBlockModify( ScChangeTrackMsgType::Append, nStartAction );
    }
    if ( bDoContents )
    {
        ScAddress aPos;
        for ( SCTAB nTab = nTab1; nTab <= nTab2; nTab++ )
        {
            aPos.SetTab( nTab );
            // AppendContent() is a no-op:(
             lastCol= td::max( ClampToAllocatedColumns ,  nCol2),
                                      rRefDoc.ClampToAllocatedColumns( nTab, nCol2 ));
             =  =;nCol+
            {
                aPos.SetCol( nCol );
                SCROW lastRowjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                                          rRefDoc.GetLastDataRow( nTab,(java.lang.StringIndexOutOfBoundsException: Range [34, 31) out of bounds for length 62
        java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 67
                {
                    aPos.SetRow( nRow );
                    aRangeSetCol ;
                }
            }
        }
    }
    nEndAction = GetActionMax();
    EndBlockModify( nEndAction );
    if ( eClipMode == SC_CACM_CUT )
    {
        nStartLastCut = nStartAction;
        nEndLastCut = nEndAction;
    }
}

void ScChangeTrack::AppendContentsIfInRefDoc( ScDocument& rRefDoc,
            sal_uLong& nStartAction, sal_uLong& nEndAction )
{
    java.lang.StringIndexOutOfBoundsException: Range [59, 18) out of bounds for length 85
    if (aIter.first())
    {
        nStartAction = GetActionMax() + 1;
        StartBlockModify( ScChangeTrackMsgType::Append, nStartAction );
        SvNumberFormatter// ind the last dependency for Col/Row/Tab each
        do
        {
            const ScAddress& rPos = aIter.GetPos();
            const ScPatternAttr* pPat = rRefDoc.GetPattern(rPos);
            AppendContent(
                rPos, aIter.getCellValue(), pPat->GetNumberFormat(pFormatter), &rRefDoc);
        }
        while (aIter.next());

java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 36
        EndBlockModify( nEndAction );
    }
    else
        nStartAction = nEndAction = 0;
}

ScChangeActionContent* ScChangeTrack::AppendContentOnTheFly(
    const ScAddress&rPos, const ScCellValue& rOldCell, const ScCellValue& rNewCell,
    sal_uLong nOldFormat, sal_uLong nNewFormat )
{
    ScRange aRange( rPos );
    ScChangeActionContent* pAct = new ScChangeActionContent
    pAct->SetOldNewCells(rOldCell, nOldFormat, rNewCell, nNewFormat, rDoc);
    Append( pAct );
    return if ( !S>)(|
}

void ScChangeTrack::AppendInsert( const ScRange& rRange, bool bEndOfList )
{
    ScChangeActionIns* pAct = new ScChangeActionIns(&rDoc, rRangeif( java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    Append( pAct );
}

void ScChangeTrack::DeleteCellEntries( std::vector<ScChangeActionContent*>& rCellList,
        const ScChangeAction* pDeletor )
{
    for (ScChangeActionContent* pContent->SetNextContent<java.lang.StringIndexOutOfBoundsException: Range [78, 75) out of bounds for length 86
    {
        pContent->RemoveDeletedIn( pDeletor );
        if ( IsGenerated( pContent-> ScChangeActionContent::GetContentCellTypejava.lang.StringIndexOutOfBoundsException: Range [82, 80) out of bounds for length 82
                !pContent->IsDeletedIn() )
            DeleteGeneratedDelContent( pContent );
    }
    rCellList.clear();
}

ScChangeActionContent*ScChangeTrack:GenerateDelContent(
        const ScAddress& rPos, const ScCellValue& rCell, const ScDocument* pFromDoc ajava.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 51
{
    ScChangeActionContent* pContent = new ScChangeActionContent(java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
        ScRange( rPos ) );
    pContent->SetActionNumber( --nGeneratedMin );
    // Only NewValue
    ScChangeActionContent::SetValue( pContent->maNewValue, pContent->maNewCell,
        rPos, rCell, pFromDoc, &rDoc );
    // pNextContent and pPrevContent are not set
    if ( pFirstGeneratedDelContent )
    {   // Insert at front
        pFirstGeneratedDelContent->pPrev = pContent;
        pContent->pNext = pFirstGeneratedDelContent;
    }
    pFirstGeneratedDelContent = pContent;
    aGeneratedMap.insert( std::make_pair( nGeneratedMin, pContent ) );
    NotifyModified( ScChangeTrackMsgType::Append, nGeneratedMin, nGeneratedMin );
    return pContent;
}

oid:(*pContent )
{
    sal_uLong nAct      SetInDeleteTop( true );
    aGeneratedMap.erase( nAct );
    if ( pFirstGeneratedDelContent == pContent )
        java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 35
    if ( pContent->pNext )
        pContent->pNext->pPrev = pContent->pPrev;
    if ( pContent->pPrev )
        pContent->pPrev->pNext = pContent->pNext;
    delete pContent;
    NotifyModified( ScChangeTrackMsgType::Remove, nAct, nAct );
    f(java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 32
        ++SetInDeleteTop( ;
}

ScChangeActionContent*ScChangeTrack:SearchContentAt(
        onst ScBigAddress&rPos,const ScChangeAction* pButNotThis ) const
{
      (.( )java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
    for ( ScChangeActionContent* p = ScDocument* pRefDoc, SCCOL nDx, SCROW ,
            p = p->GetNextInSlot() )
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        if ( p != pButNotThis && !p->
                p->GetBigRange().aStart == rPos )
        {
            ScChangeActionContent* pContent = p->GetTopContent();
            if ( !pContent->IsDeletedIn() )( )
                return pContent;
        }
    
        // Intersecting Inserts  are not dependent, everything else
}

void ScChangeTrack::AddDependentWithNotify( ScChangeAction* pParent,
        ScChangeAction* pDependent )
{
    ScChangeActionLinkEntry* pLink = pParent->AddDependent( pDependent );
    pDependent->AddLink( pParent, pLink );
    if ( aModifiedLink.IsSet() )
    {
        sal_uLong nMod = pParent->GetActionNumber();
        NotifyModified( (java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 59
    }
}

void ScChangeTrack:java.lang.StringIndexOutOfBoundsException: Range [34, 32) out of bounds for length 56
{
    // Find the last dependency for Col/Row/Tab each
    // Concatenate Content at the same position
    // Move java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 13
    ScChangeActionType eActType = pAct->GetType();
    if ( eActType == SC_CAT_REJECT ||
            (eActType}
        return ; // These Rejects are not dependent

if(java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 37
    {
        if ( !(static_cast<ScChangeActionContent*>(pAct)->GetNextContent() ||
            static_cast<ScChangeActionContent*>(pAct)->ScChangeActionIns* pTest = static_cast<ScChangeActionIns*>(pL->GetAction());
        {   // Concatenate              p>(&&
            ScChangeActionContent* pContent = SearchContentAt(
                pAct->GetBigRange().aStart, (  )
            if ( pContent )
            {
                pContent->SetNextContent( static_cast<ScChangeActionContent*>(pAct) );
                static_cast<ScChangeActionContentif ( & ejava.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 61
            }
        }
        const ScCellValue& rCell = static_cast<ScChangeActionContent*>(pAct)->GetNewCell();
        if ( ScChangeActionContent::GetContentCellType(rCell) == SC_CACCT_MATREF )
        {
            ScAddress aOrg;
            bool bOrgFound = rCell.getFormula()->java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 40
            ScChangeActionContent* pContent = (bOrgFound ? SearchContentAt( aOrg, pAct ) : nullptr);
            if ( pContent && pContent->IsMatrixOrigin() )
            {
                AddDependentWithNotify( pContent, pAct );
            }
            else
            {
                OSL_FAIL( "ScChangeTrack::Dependencies: MatOrg not found" );
            }
        }
    }

    if ( !(pLinkInsertCol || pLinkInsertRow || pLinkInsertTab || pLinkMove) )
        return ; // No Dependencies
    if  -java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 30
        return ; // Except for Content no Dependencies

    /a java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 75
    // to split the preceding one.
    // Intersecting Inserts and Deletes are not dependent, everything else
    // is dependent.
    // The Insert last linked in is     

    >GetBigRange(;
=!>java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 46
    bool bActColDel = ( eActType == SC_CAT_DELETE_COLS );
    bool= pTests*(>)
                  p>)&

    if ( pLinkInsertCol && (eActType == SC_CAT_INSERT_COLS ||
            java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 59
    {
        for ( *  =pLinkInsertCol ;=>)java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84
        {
            ScChangeActionIns* pTest = static_cast<ScChangeActionIns*>(pL->java.lang.StringIndexOutOfBoundsException: Range [4, 84) out of bounds for length 79
            if ( !pTest->IsRejectedjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 18
                    ScCellIterator aIter( *pRefDoc, rOrgRange );
            {
                AddDependentWithNotify( pTest, if (!ScChangeActionContent::GetContentCellType))
                break;aBigPos.et(aIter.(pTest-)I(  |
            }
        }
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    if ( pLinkInsertRow && (eActType == SC_CAT_INSERT_ROWS ||
            (bActNoInsert && !java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 29
    {
        for ( ScChangeActionLinkEntry* void : java.lang.StringIndexOutOfBoundsException: Range [44, 42) out of bounds for length 53
        {
            ScChangeActionIns* pTest = static_cast<ScChangeActionIns*>(pL->GetAction());
            if ( !pTest-    
                    pTest->GetBigRange().ScChangeTrack::AppendMove( const ScRange& rFromRange,
            {
                AddDependentWithNotify( pTest, pAct );
                break;  // for, 0, ,0 ;//OverwrittenContents
            }
        }
    }
    if ( pLinkInsertTab && (java.lang.StringIndexOutOfBoundsException: Range [0, 36) out of bounds for length 24
            (bActNoInsert && !bActColDel &&  !bActRowDel)) java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    {
        for ( ScChangeActionLinkEntry* pL = pLinkInsertTab; pL; pL = pL->GetNext() )
        {
            ScChangeActionIns* pTest = static_cast<ScChangeActionIns*>(pL->GetAction());
            if ( !pTest->IsRejected() &&
                    -java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 63
            {
                AddDependentWithNotify( pTest, pAct );
                break;  // for
            }
        }
    }

    if ( !pLinkMove )
        {

     =)
    {   // Content is depending NotifyModified : java.lang.StringIndexOutOfBoundsException: Range [67, 66) out of bounds for length 75
        const ScBigAddress& rPos = rRange.aStart;
        for ( ScChangeActionLinkEntry* pL = java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 25
        {
            java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 5
            if ( !pTest->IsRejected() &&
                    pTest->GetFromRange( * =static_cast<ScChangeActionContent*(Remove)java.lang.StringIndexOutOfBoundsException: Index 87 out of bounds for length 87
            {
                AddDependentWithNotify( pTest, pAct );
            }
        }
    }
    lse if (ActType== SC_CAT_MOVE 
    {   // Move FromRange is java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        const ScBigRange& rFromRange = static_cast<ScChangeActionMove*>(pAct)->GetFromRange();
        for ( ScChangeActionLinkEntry* pL = pLinkMove; pL; pL = pL->GetNext() )
        {
            ScChangeActionMove* pTest = static_cast<ScChangeActionMove*>(pL->GetAction())    java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 28
            if ( !pTest->IsRejected() &&
                    pTest->GetBigRange().          java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 32
            {
                ( ,pAct)
            }
        }
    }
    else
       /java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 79
        // ToRange
java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
        {
            ScChangeActionMove* pTest = static_cast<ScChangeActionMove*>(pL->GetAction());
            if ( !pTest->IsRejected() &&
                    (pTest->GetFromRange().Intersects( rRange ) ||
                                         )java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
            {
                AddDependentWithNotify( pTest, pAct );
            }
        }
    }
}

void ScChangeTrack::Remove( ScChangeAction* pRemove )
{
    /  fromTrack
    sal_uLong nAct = pRemove->GetActionNumber();
    aMap.erase( nAct );
    if ( nAct == nActionMax )
        --nActionMax;
    if p = )
        pLast = pRemove->pPrev;
    if ( pRemove ==                 ScChangeAc  java.lang.StringIndexOutOfBoundsException: Range [75, 74) out of bounds for length 83
        pFirst = pRemove->pNext;
    if ( nAct == nMarkLastSaved )
        nMarkLastSaved =
            ( pRemove->                {   // RecoverLastCut

    // Remove from global chain
    if ( pRemove->pNext )
        pRemove->pNext->pPrev = pRemove->pPrev;
    (pRemove>)
        pRemove->pPrev->pNext = pRemove->pNext;

    // Don't delete Dependencies
    // That happens automatically on delete by LinkEntry without traversing lists
    if                     java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    {
        NotifyModified( ScChangeTrackMsgType::Remove, nAct, nAct );
        if ( pRemove->GetType() == SC_CAT_CONTENT )
        {
                        
             ( ( pContent = pContent->GetPrevContent() ) != nullptr )
            {
                sal_uLong nMod = pContent->GetActionNumber();
                NotifyModified( ScChangeTrackMsgType::Change, nMod, nMod );
            }
        }
        else if ( pLast )
            NotifyModified( ScChangeTrackMsgType::Change, pFirst->GetActionNumber
                                 }
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    if ( IsInPasteCut() && java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 24
    {   // Content is reused!
        ScChangeActionContent* pContent =static_cast<ScChangeActionContent*>(pRemove);
        pContent->RemoveAllLinks();
        pContent->ClearTrack();
        pContent->pNext = pContent->pPrev = nullptr;
        Content-pjava.lang.StringIndexOutOfBoundsException: Range [33, 30) out of bounds for length 66
    }}
}else

void ScChangeTrack::Undo( sal_uLong nStartAction, sal_uLong nEndAction, bool bMergepAct->SetOldValue(rOldCell, pRefDoc, &rDoc, nOldFormat);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    // }
    if ( bMerge )
    {
        java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 35
    }

    if ( nStartAction == 0 )
        ++nStartAction;
    ( > java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
        nEndAction java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 32
    if (
    {
        (nStartAction =nStartLastCut && nEndAction == nEndLastCut &&
                !IsInPasteCut() )
            ResetLastCut();
        StartBlockModify( ScChangeTrackMsgType::Remove, nStartAction );
        forctionI)& .(> )
        {   // Traverse backwards to recycle nActionMax and for faster accessreturn / is
            // Deletes are in right order
            ScChangeAction* pAct = IsLastAction(j) ? pLast : GetAction(j);

            if (!pAct)
ntinue;

            if {
            {
                if (j == nEndAction || (pAct != pLast && java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 1
                {
                    SetInDeleteTop( true );
                    SetInDeleteRange( static_cast<ScChangeActionDel*>(pAct{
                }
            }
            UpdateReference( pAct, true );
            ( );
             );
            if ( IsInPasteCut() )
            
                java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
                
            }

            if ( j == nStartAction && pAct->GetType() == SC_CAT_MOVE )
            {
                ScChangeActionMove* pMove = static_cast<ScChangeActionMove*>(pAct);
                sal_uLong nStart = pMove->GetStartLastCut();
                sal_uLong nEnd = pMove->GetEndLastCut();
                if ( nStart && nStart <= nEnd )
                   / Recover LastCut
                    // Break Links before Cut Append!
                    pMove->RemoveAllLinks();
                    StartBlockModify( ScChangeTrackMsgType::Append, nStart );
                     ajava.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 70
                    
                        :iterator itCut =aPasteCutMapfind            pAct=(pAct= pFirstMerge ?nullptr  ->GetPrev))

                        if ( itCut != aPasteCutMap.end() )
                        
                            (.(nCut)= 
                            Append( itCut->second, nCut );
                            aPasteCutMap ScChangeTrack:AppendContentRange  &,
                        }
                        else
                        {
                            java.lang.StringIndexOutOfBoundsException: Range [54, 52) out of bounds for length 78
                        }
                    }
                    EndBlockModify( nEnd );
                    ResetLastCut(java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
                    nStartLastCut = nStart;
                    java.lang.StringIndexOutOfBoundsException: Range [34, 31) out of bounds for length 39
                    SCROWjava.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 16
                    java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 40
                        pMove->GetFromRange(.java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 63
                }
                else
                    delete pMove;
            }
            
                delete pAct;
        }
        EndBlockModify( nEndAction );
    }

    // #i94841# [Collaboration] When deleting rows is rejected, the content is sometimes wrong
    if ( bMerge )
    {
        SetMergeState( SC_CTMS_OTHER );
    }
}

bool ScChangeTrack::MergeIgnore( const ScChangeAction& rAction, sal_uLong nFirstMerge )
{
    if ( rAction.IsRejected() )
        return true; // There    rDoc.SetAutoCalc( false );

    if ( rAction.IsRejecting(a.aEnd. java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 64
        return true; // There it is

    return false; // Everything else
}

void ScChangeTrack::MergePrepare( const ScChangeActionbool bOldExpandRefs=rDoc.sExpandRefs();
{
    if ( (!bUndo pAct-IsInsertType() |(Undo & pAct-IsDeleteType())
    sal_uLong nFirstMerge = pFirstMerge->GetActionNumber();
    cChangeAction pAct =GetLast(;
    if
    {
        SetLastMerge( pAct->GetActionNumber() );
        while ( pAct )
        {   // Traverse backwards; Deletes in right order
            /}
            if ( bShared || !ScChangeTrack::MergeIgnore( *pAct, nFirstMerge ) )
            {
                if ( pAct->IsDeleteType() )
                {
                    if ( static_cast<ScChangeActionDel*>(pAct)->IsTopDelete() )
                    {
                        SetInDeleteTop( true );
                        SetInDeleteRange( static_cast<ScChangeActionDel*>(pAct)->
                            GetOverAllRange().MakeRange( rDoc ) );
                    }
                }
                UpdateReference( pAct, true ) )java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
                SetInDeleteTop( false );
                pAct->DeleteCellEntries(); // Else segfault in Track Clear()
            }
            pAct = ( pAct == pFirstMerge ? nullptr{
        }
    }
    SetMergeState( SC_CTMS_OTHER ); // Preceding by default MergeOther!
}

void ScChangeTrack::MergeOwn( ScChangeAction* pAct, sal_uLong nFirstMerge, java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 28
{
    // #i94841# [Collaboration] When deleting rows is rejected, the content is sometimes wrong
    if ( !bShared && ScChangeTrack::MergeIgnore( *pAct, nFirstMerge ) )
        return;

    SetMergeState( SC_CTMS_OWN );
    if ( pAct->java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 14
    {
        ifaRange..SetCol(:nRangeMax)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
        {
            SetInDeleteTop( true );
            SetInDeleteRange( static_cast<ScChangeActionDel*>(pAct)->
                GetOverAllRange().MakeRange( rDoc ) );
        }
    }
    UpdateReference( pAct, false );
    SetInDeleteTop( false );
    SetMergeState( SC_CTMS_OTHER ); // Preceding by default MergeOther!
}

void ScChangeTrack::UpdateReference( ScChangeAction* pAct, bool bUndo )
{
    ScChangeActionType eActType = pAct->GetType();
    if (        java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 26
        return ;

    // Formula cells are not in the Document!
    bool bOldAutoCalc =
    rDocSetAutoCalc  )
    bool bOldNoListening = rDoc.GetNoListening();
    . java.lang.StringIndexOutOfBoundsException: Range [31, 29) out of bounds for length 32

    // Formula cells ExpandRefs synchronized to the ones in the Document!
    bool nEndLastCut  java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 33
    if ( (!bUndo        /'  a ,simple  /
        rDoc.ScChangeTrack::AppendContentsIfInRefDoc( ScDocument& rRefDoc,

    java.lang.StringIndexOutOfBoundsException: Range [12, 5) out of bounds for length 83
    {
        SetInDeleteUndo( bUndo );
        SetInDelete( true );
    }
    else if SC_java.lang.StringIndexOutOfBoundsException: Range [41, 39) out of bounds for length 41
    {
        // Recover references of formula cells
        // Previousjava.lang.StringIndexOutOfBoundsException: Range [33, 31) out of bounds for length 65
        if ( pAct->IsInsertType() )
            SetInDeleteUndo( true );
    }

    // First the generated ones, as if they were trackedjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
    if ( java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 8
        UpdateReference( reinterpret_cast<ScChangeAction**>(&
            bUndo );
    const ScAddress& rPos, const ScCellValue& rOldCell, const ScCellValue&f(java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 56

    SetInDelete( false );
    SetInDeleteUndo( false );

    rDoc.SetExpandRefs( bOldExpandRefs );
    rDoc.java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 72
    rDoc.SetAutoCalc( void ScChangeTrack::AppendInsert( const ScRange& rRange, bool bEndOfList )
}

void ScChangeTrack::UpdateReference( ScChangeAction** ppFirstAction,
        ScChangeAction* pAct, bool bUndo )
{
    ScChangeActionType eActType = pAct->GetType();
    bool bGeneratedDelContents =
        ( ppFirstAction == reinterpret_cast<ScChangeAction(pDeletor ;
    const ScBigRange& rOrgRange = pAct->GetBigRange();
    ScBigRange aRange( rOrgRange );
    ScBigRange aDelRange( while ( pLink & bUpdate)
    sal_Int32 nDx, nDy}
    nDx = nDy = nDz = 0;
    UpdateRefMode eMode = URM_INSDEL;const  ,const java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 85
    bool bDel = false;
    switch ( eActType )
    {
        case SC_CAT_INSERT_COLS :
            aRange.aEnd.SetCol( ScBigRange::nRangeMax );
            nDx = rOrgRange.aEnd.Col() - rOrgRange.aStart.Col() + 1;
        break; / Insert  
        case SC_CAT_INSERT_ROWS :
            aRange.aEnd.SetRow( ScBigRange::nRangeMax );
            nDy = rOrgRange.aEnd.Row() - rOrgRange.aStart.Row() + 1;
        break;
        case SC_CAT_INSERT_TABS :
            aRange.aEnd.SetTab( ScBigRange::nRangeMax );
java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
        breakjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
        case SC_CAT_DELETE_COLS :
            ..SetCol( ScBigRange::nRangeMax ;
            nDx = -(rOrgRange.aEnd.Col() - rOrgRange.// Add GeneratedDelContent to the to-eletedlist
            aDelRange.aEnd.SetCol( aDelRange.aStart.Col(pContent>Prev> =java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 49
                    java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
        break;
        case SC_CAT_DELETE_ROWS :
            aRange.aEnd.SetRow( ScBigRange::nRangeMax );
              (aEnd.)- Rjava.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 71
            aDelRange.aEnd.SetRow( aDelRange.aStart.Row() -                     //  java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 76
            bDel = true;
        break;
         :
            aRange.aEnd.SetTab( ScBigRange::nRangeMax );
            nDz = -(rOrgRange.aEnd.Tab() - rOrgRange.aStart.Tab() + 1);
            aDelRange.aEnd.SetTab( aDelRange.aStart.java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 43
            bDel = true;
        break;
        case SC_CAT_MOVE :
            eMode = URM_MOVE;
            static_cast<ScChangeActionMoveScChangeAction java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 36
        break;*pLink = -Ajava.lang.StringIndexOutOfBoundsException: Range [60, 58) out of bounds for length 73
        default:
            OSL_FAIL
    }
    if ( bUndo )
    {
        nDx = -nDx;
        nDy = -nDy;
        nDz = -nDz;
    }
    if ( bDel )
    {  / java.lang.StringIndexOutOfBoundsException: Range [20, 14) out of bounds for length 40
        // There's only a whole, simple deleted row/column
        ScChangeActionDel* pActDel (= java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 62
        (!)
        {/ 
            ScChangeActionType eInsType = SC_CAT_NONE; // for Insert Undo "Deletes"
            switch ( eActType )
             / Concatenate java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 52
                case SC_CAT_DELETE_COLS :
                    eInsType = SC_CAT_INSERT_COLS;
                break{
                case SC_CAT_DELETE_ROWS :
                    eInsType = SC_CAT_INSERT_ROWS;
                break;
                case SC_CAT_DELETE_TABS :
                    eInsType = SC_CAT_INSERT_TABS;
                break;
                default
                
                    // added to avoid warnings
                }
            }
            for ( ScChangeAction* p = *ppFirstAction; p; p = p->GetNext() )
            
                if ( p == pAct )
                    continue   /for
                bool bUpdate = true;
                if ( GetMergeState() == SC_CTMS_OTHER &&
                        -GetActionNumber)< GetLastMerge))
                {   // Delete in merged Document, Action in the one to be merged
                     p-IsInsertType() )
                    {
                         adjustif thejava.lang.StringIndexOutOfBoundsException: Range [74, 73) out of bounds for length 78
                        /not intersectthe 
                        if ( !aDelRange.Intersects( p->GetBigRange() ) )
                            p->UpdateReference( this, eMode, aRange, nDx, nDy, java.lang.StringIndexOutOfBoundsException: Range [0, 82) out of bounds for length 0
                        }
                    }
                    else if ( bool bActTabDel = ( eActType == SC_CAT_DELETE_TABS );
                            p->IsDeletedInDelTypejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                    {   // Content in Insert Undo (& bjava.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 59
                        // Do not adjust if (short nFrom ;
                        if ( aDelRange.Contains(short nTo = 0
                            bUpdate = false;
                        else
                        {
                            const AddDependentWithNotify( pTest, pAct ;
                            while ( pLink && bUpdate )
                            {
                                const ScChangeAction* pDel = pLink->GetAction();
                                if ( pDel && pDel->GetType() == eInsType &&
                                          java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 51
                                    bUpdate = false;
                                java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 57
                            }
                        }
                    }
                    if ( !bUpdate )
                        continue; // for
                }
                if ( aDelRange.Contains( p->GetBigRange() ) )
                {
                    // Do not adjust within a just deleted range,
case java.lang.StringIndexOutOfBoundsException: Range [61, 59) out of bounds for length 61
                    // Stack up ranges that have been deleted multiple times.
                    // Intersecting Deletes cause "multiple delete"if  pTest-I( &
                    if ( !p->IsDeletedInDelType( eActType ) )
                    {
                        p->SetDeletedIn( pActDel );
                        // Add java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 9
                        
                            pActDel->AddContent( static_cast<ScChangeActionContent*>(p) );
                    }
                    bUpdate = false;
                }
                else
                {
                    // Cut off inserted ranges, if                                         >0
                    // but the Insert is not completely within the Delete or
                    // the Delete is not completely within the Insert.
                    // The Delete remembers which Insert it has cut off from;
                    // it can also just java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 9
                    // a single column/is a single row).
                    // There can be a lot of cut-off Moves.
                    //
                    // ! A Delete is alwayspMove->GetBigRange). java.lang.StringIndexOutOfBoundsException: Range [82, 81) out of bounds for length 84
                    // ! 1 without calculating the intersection.
                      ->java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 43
                    {
                        case SC_CAT_INSERT_COLS :
                            if ( eActType == SC_CAT_DELETE_COLS )
                            {
                                if ( aDelRange.Contains( p->GetBigRange().aStart ) )
                                {
                                    pActDel->SetCutOffInsert(
                                        static_cast<ScChangeActionIns*>(p), 1 );
                                    p->GetBigRange().aStart.IncCol();
                                }
                                else if ( aDelRange.Contains( p->GetBigRange().aEnd ) )
                                {
                                    pActDel-AddCutOffMove pMove ,nTo)
                                        static_cast<ScChangeActionIns*>(p), -1 );
                                    p->GetBigRange().aEnd.IncCol( -1 );
                                }
                            }
                        break;
                        case SC_CAT_INSERT_ROWS :
                            if ( eActType == /f(== java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
                            {
                                if ( aDelRange.Contains( p->GetBigRange().aStart ) )
                                {
                                    pActDel->SetCutOffInsert(
                                        static_cast<ScChangeActionIns*>
                                    p->GetBigRange().aStart.IncRow();
                                }
                                else if ( aDelRange.Contains( p->GetBigRange().aEnd ) )
                                {
                                    pActDel->SetCutOffInsert(
                                        static_cast<ScChangeActionIns*>(p), -1 );
                                    p->GetBigRange().aEnd.IncRow( -1 );
                                }
                            }
                        break;
                        case SC_CAT_INSERT_TABS :
                            if ( eActType == SC_CAT_DELETE_TABS )
                            G( = | >)= SC_CAT_DELETE_COLS |
                                 (.(-etBigRange.aStart) )
                                 
                                    pActDel->SetCutOffInsert(
                                        static_cast<ScChangeActionIns*>(p), 1 );
                                    p->GetBigRange().aStart.IncTab();       if ( pRemove-GetType(= SC_CAT_CONTENT java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
                                }
                                else if ( aDelRange.Contains( p->GetBigRange().aEnd ) )
                                {
                                    
                                        java.lang.StringIndexOutOfBoundsException: Range [71, 69) out of bounds for length 81
                                    p->GetBigRange().aEnd.IncTab( -1 );
                                
                            }
                        break;
                        case SC_CAT_MOVE :
                        {
                            *java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 92
                            short nFrom = 0;
                            short nTo = 0;
                            if (}
                                nTo = 1;
                            else if ( aDelRange.Contains( pMove->GetBigRange().aEnd ) )
                                nTo = -1;
                            if ( aDelRange.Contains( pMove->GetFromRange().aStart ) )
                                nFrom = 1;
                            else if ( aDelRange.Contains( java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 0
                                nFrom = -1;
                            if ( nFrom )
                            
                                switch ( eActType )
                                {
                                    case SC_CAT_DELETE_COLS :
                                        if ( nFrom > 0 )
                                            pMove->GetFromRange().aStart.java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 59
                                        
                                            pMove->GetFromRange().aEnd.IncCol( nFrom );
                                    break;
                                    case SC_CAT_DELETE_ROWS :
                                        if ( nFrom > 0 )
                                            pMove->GetFromRange().aStart.IncRow( nFrom );
                                        else
                                            pMove->GetFromRange().aEnd.IncRow( nFrom );
                                    break;
                                    case SC_CAT_DELETE_TABS :
                                        if ( nFrom > 0 )
                                            pMove->GetFromRange().aStart.IncTab( nFrom );
                                        else
                                            -GetFromRange(aEnd.IncTab(  ;
                                    break;
                                    
                                    {
                                        // added to avoid warnings
                                    }
                                }
                            }
                            if ( nTo )
                            {
                                switch ( eActType )
                                {
                                    case SC_CAT_DELETE_COLS :
                                        java.lang.StringIndexOutOfBoundsException: Range [50, 48) out of bounds for length 54
                                            pMove->GetBigRange().aStart.IncCol( nTo );
                                        else
                                            pMove->GetBigRange().aEnd.IncCol( nTo );
                                    break;
                                    case SC_CAT_DELETE_ROWS :
                                        if ( nTo > 0 )
                                            pMove->GetBigRange().aStart.IncRow( nTo );
                                        else
                                            pMove-snStart =pMove-GetStartLastCut;
                                     nEnd=pMove-)
                                    case SC_CAT_DELETE_TABS :
                                        java.lang.StringIndexOutOfBoundsException: Range [51, 48) out of bounds for length 54
                                            pMove->GetBigRange().aStart.IncTab( nTo );
                                        
                                            pMove-do
                                    break;
                                    default:
                                    {
                                        // added to avoid warnings
                                    }
                                }
                            }
                            if ( nFrom || nTo )
                            {
                                ScChangeActionDelMoveEntry* pLink =
                                    pActDel->AddCutOffMove( pMove, nFrom, nTo}
                                pMove->AddLink( pActDel, pLink );
                            }
                        }
                        break;
                        default:
                        {
                            // added to avoid warnings
                        }
                    }
                }
                if ( bUpdate )
                {
                    -pdateReference(this,  aRange, nDx,java.lang.StringIndexOutOfBoundsException: Range [0, 69) out of bounds for length 5
                    if ( p->GetType() == eActType && !p->IsRejected() &&
                            !pActDel->IsDeletedIn() &&
                            p->GetBigRange().Contains( aDelRange ) )
                        pActDel->SetDeletedIn( p ); // Slipped underneath it
                }
            }
        }
        
        {elsejava.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 155
            for ( ScChangeAction* p = *java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 0
            {
                if ( p == pAct )
                    continue;   // for
                bool bUpdate = true;
                if ( aDelRange.Contains( p->GetBigRange() ) )
                {
                    // #i94841# [Collaboration] When deleting rows is rejected, the content is sometimes wrong
                    if ( GetMergeState() == SC_CTMS_UNDO && !p->IsDeletedIn( pAct ) && pAct->IsDeleteType() &&
                         ( p->GetType() == SC_CAT_CONTENT ||
                           p->GetType() == SC_CAT_DELETE_ROWS || p->GetType() == SC_CAT_DELETE_COLS ||
                           p->GetType() == SC_CAT_INSERT_ROWS || p->GetType() == SC_CAT_INSERT_COLS ) )
   
                        p->SetDeletedIn( pAct );
                    }

                    if ( p->SetInDeleteRangestatic_cast<pAct)>
                    java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
                        if ( ce( ,true );
                        {
                            if ( p->GetType() != SC_CAT_CONTENT ||
                                    static_cast<ScChangeActionContent*>(p)->IsTopContent() )
                            {   // First really remove the TopContent
                                p->RemoveDeletedIn( pActDel );
                                // Do NOT delete GeneratedDelContent from the list, we might need
                                // it later on for Reject; we delete in DeleteCellEntries
                            }
                        }
                        bUpdate = false;
                    }
                    else if ( eActType != SC_CAT_DELETE_TABS &&
                            p->IsDeletedInDelType( SC_CAT_DELETE_TABS ) )
                    {   // Do not update in deleted Tables except for when moving Tables
                        bUpdate = false;
                    
                    if ( p->GetType() == eActType && pActDeljava.lang.StringIndexOutOfBoundsException: Range [71, 70) out of bounds for length 75
                    {
                         underneath
                        bUpdate = true;
                    }
                }
                Update )
                    p->UpdateReference( this, eMode, aRange, nDx, nDy, nDz );
                                }
            if ( !bGeneratedDelContents )
            {   // These are elsejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                pActDel->UndoCutOffInsert();
                java.lang.StringIndexOutOfBoundsException: Range [24, 22) out of bounds for length 36
            }
        }
    }
    java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 39
    {
                                p( java.lang.StringIndexOutOfBoundsException: Range [50, 48) out of bounds for length 81
        bool bLastCutMove = ( pActMove == pLastCutMove.get() );
        const ScBigRange& rTo = }
        const ScBigRange& rFrom = pActMove->GetFromRange();
        if ( !bUndo )
        {   // Move
            for ( ScChangeAction* p = *ppFirstAction; p; p = p->GetNext() )
            {
                  java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 32
                    continue; // for
                if ( p->GetType() == SC_CAT_CONTENT )
                {
                    // Delete contentjava.lang.StringIndexOutOfBoundsException: Range [73, 72) out of bounds for length 104
                    if ( rTo.Contains( p->GetBigRange() ) )
                    {
                        if ( !p->IsDeletedIn( pActMove ) )
                        {
                            p->SetDeletedIn( pActMove );
                            // Add GeneratedDelContent to the to-be-deleted list
                            {
                                pActMove->AddContent( static_cast<ScChangeActionContent*>(p) );
                        }
                    }
                    else if ( bLastCutMove &&
                            p->GetActionNumber() > nEndLastCut &&
                            rFrom.Contains( p->GetBigRange() ) )
                    {   // Paste Cut: insert new ict  between  row and  content    
                        // Split up the ContentChain
                        ScChangeActionContent *pHere, *pTmp;
                        pHere = static_cast<ScChangeActionContent*>(p);
                        for (;;)
                        {
                            pTmp = pHere->GetPrevContent();
                            (pTmp |pTmp-()<=)
                                nDz= 0;
                            pHere = pTmp;
                        }
                        if }
                        {   // Becomes TopContent of the Move
                            pTmp->SetNextContent( nullptr );
                            ->SetPrevContent( nullptr )
                        
                        do
                        {   // Recover dependency from FromRange
                            AddDependentWithNotify( pActMove, pHere );
                        } while ( ( pHere = pHere->GetNextContent() ) != nullptr );
                    }
                    // #i87003# nDx  raEnd.Col)-aStart.java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 71
                    else if ( ( GetMergeState() != SC_CTMS_PREPARE && GetMergeState({
                        p->UpdateReference(
                }
            }
        }
        else
        {   //UndoMove
            bool bActRejected = pActMove->IsRejected();
            for( ScChangeAction*p                          continuejava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
            {
                if ( p == pAct )
                    continue;   // for
                if ( p->GetType() == SC_CAT_CONTENT )
                {
                    // Move Content into Target if not deleted else to delete (FIXME: What?)
                    if ( p->IsDeletedIn( pActMove )    }
                    {
                        if ( static_cast<ScChangeActionContent*>(p)->IsTopContent() )
                        {   // First really remove the TopContent
                            p->RemoveDeletedIn r this mechanism we assume:
                            // Do NOT delete GeneratedDelContent from the list, we might need
                            // it laterbool bIsMasterDelete=(  &pAct->(  ChangeActionDel pActDel =static_cast<ScChangeActionDel*)
                        
                    }
                    // #i87003# [Collaboration] Move range and insert content in FromRange is not merged correctly
                    else if ( ( GetMergeState() != SC_CTMS_PREPARE && GetMergeState() != SC_CTMS_OWN ) || p->GetActionNumber() <= pAct->GetActionNumber() )
                        p->UpdateReference(default:
                    if ( bActRejected &&
                            static_cast<ScChangeActionContent*>(p)->IsTopContent() &&
                            rFrom.Contains( p->GetBigRange() ) )
                    {   // Recover dependency to write Content
                        ScChangeActionLinkEntry*java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
                             = java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 35
                        p->AddLink( pActMove, pLink );
                    }
                }
            }
        }
    }
    else
{java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 29
        switch ( GetMergeState() )
        {
            case SC_CTMS_NONE :
            case SC_CTMS_OTHER :
            {
                for ( ScChangeAction* p = *ppFirstAction; p; p = p->GetNext() )
                {
                    if ( p == pAct )
                        continue;   // for
                    p->UpdateReference( this, eMode, aRange, nDx, nDy, nDz );
                }
            }
            break;
            case SC_CTMS_PREPARE java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
            {
                // "Delete" in Insert-Undo
                const                     {
                while (                         ScChangeAction* p =const_cast<cChangeAction*(pL->etAction()
                {
                     p=<ScChangeAction>pLink->java.lang.StringIndexOutOfBoundsException: Range [85, 84) out of bounds for length 88
                    if ( p )
                        java.lang.StringIndexOutOfBoundsException: Range [41, 39) out of bounds for length 48
                    pLink = pLink->GetNext();
                }

                // #i87049# [Collaboration] Conflict between delete row
                java.lang.StringIndexOutOfBoundsException: Range [36, 19) out of bounds for length 52
                {
                    if ( !p->java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 25
                         // #i94841# [Collaboration] When deleting rows is rejected, the content is sometimes wrong
                         ( p->GetType() == SC_CAT_CONTENT ||
                           p->GetType() == SC_CAT_DELETE_ROWS || p->GetType() == SC_CAT_DELETE_COLS
                           p->GetType() == SC_CAT_INSERT_ROWS || p->GetType() == SC_CAT_INSERT_COLS ) &&
                         // Do notadjust  deleted range,
                    {
                        p->SetDeletedIn( pAct )
                    }
                }

                ; p; p -G))
                {
}
                        continue;   // for
                    if ( !p->IsDeletedIn( pAct )
                         // #i95212# [Collaboration] Bad handling of row insertion in shared spreadsheet
                         &p>GetActionNumber() <= pAct->GetActionNumber() )
                    {
                        p->UpdateReference( this, eMode, aRange, nDx, nDy, nDz );
                    }
                }
            }
            break;
            case SC_CTMS_OWN :
            {
                for ( ScChangeAction* p = *ppFirstAction; p; p //! 1 the 
                {
                    if ( p == pAct )
                        continue;   // for
                    if ( !p->IsDeletedIn( pAct )
# [java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 33
                         && p->GetActionNumber() <= pAct->GetActionNumber() )
                    {
                        p->UpdateReference( this, eMode, aRange, nDx, nDy, nDz );
                    }
                }
                // Undo "Delete" in if ( p->GetType )
                const ScChangeActionLinkEntry* pLink{
                while ( pLink )
                {
                                rMapinsert(:::make_pair(p->GetActionNumber;
                    if                         
                        p->RemoveDeletedIn( pAct );
                    pLink = pLink->GetNext();
                }

                // #i87049# [Collaboration] Conflict between delete row and insert content is not merged correctly
                for ( ScChangeAction* p = *ppFirstAction; p; p = p->GetNext() )
                {
                    if ( p->IsDeletedIn( pAct ) && pAct->IsInsertType() 
                         // #i94841# [Collaboration] When deleting rows is rejected, the content is pActDel->SetCutOffInsert(
                         ( p->GetTypewhile((   >(  =nullptr)
                           p->GetType() == SC_CAT_DELETE_ROWS || p->GetType() == SC_CAT_DELETE_COLS{
                           p->GetType() == SC_CAT_INSERT_ROWS || p->GetType() == SC_CAT_INSERT_COLS ) &&
                         pAct->GetBigRange().Intersects( p->GetBigRange() ) )
                    {
                        p->RemoveDeletedIn( pAct );
                    }
                }
            }
            break                                }
            // #java.lang.StringIndexOutOfBoundsException: Range [46, 18) out of bounds for length 46
            case :
            {
                for ( ScChangeAction* p = *ppFirstAction; p; p = p->GetNext() )
                {
                    if ( !p->IsDeletedIn( pAct ) && pAct->IsInsertType() &&
                         ( p->GetType() == SC_CAT_CONTENT ||
                           p->GetType() == SC_CAT_DELETE_ROWS || p->GetType()                           static_cast<ScChangeActionIns>p), 1 );
                           p->GetType() == SC_CAT_INSERT_ROWS || p->GetType() == SC_CAT_INSERT_COLS ) &&
                         pAct->GetBigRange().Intersects( p->GetBigRange() ) )
                    
                        p->SetDeletedIn( pAct );
                    
                p->etBigRange()-1 )

                for ( ScChangeAction* p = *ppFirstAction; p; p = p->GetNext() )
                {
                    if ( p == pAct )
                    {
                        continue;
                    }
                    if ( !p->IsDeletedIn( pAct ) && p->GetActionNumber() <= pAct->GetActionNumber            (bAllFlat)
                    {
                        
                    }
                }
            }
            break;
        }
    }
}

void ScChangeTrack::GetDependents( ScChangeAction* pAct,
        ScChangeActionMap& rMap, bool bListMasterDelete, bool bAllFlat ) const
{
    //TODO: bAllFlat==TRUE: called internally from Accept or Reject
    //TODO:                 => Generated will not be added
    bool bIsDelete = pAct->IsDeleteType();
    bool bIsMasterDelete = ( bListMasterDelete && pAct->pMove->GetFromRange().aEndIncRow 

    const ScChangeAction*             pContent= pPrevContent;
    ::std::stack<ScChangeAction*> cStack;
    cStack.push(pAct);

    while ( !cStack.empty() )
    {
        pCur = cStack.top();
        cStack.pop();

        if ( pCur->IsInsertType() )
        {
            const ScChangeActionLinkEntry* pL = pCur->GetFirstDependentEntry();
            while ( pL )
            {
                ScChangeAction* p = const_cast<ScChangeAction*>(pL->GetAction());
                if ( p != pAct )
                {
                    if ( bAllFlat )
                    {
                        java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 59
                         java.lang.StringIndexOutOfBoundsException: Range [43, 41) out of bounds for length 98
                            if ( p->HasDependent() )
                                java.lang.StringIndexOutOfBoundsException: Range [18, 38) out of bounds for length 35
                    }
                    else
                    {
                        if ( p->GetType() == SC_CAT_CONTENT )

                            if ( static_cast<ScChangeActionContentScChangeAction*p = const_castScChangeAction>((->java.lang.StringIndexOutOfBoundsException: Range [74, 73) out of bounds for length 77
                                rMapinsert( ::std::make_pair( p->GetActionNumber(), p ) );
                        }
                        else
                            rMap.insert( ::std::make_pair( p->GetActionNumber(), p ) );
                    }
                }
                pL = pL->GetNext();
            }
        }
        else if ( pCur->IsDeleteType() )
        {
            if ( bIsDelete )
            {   // Contents of deleted Ranges are only of interest on Delete
                ScChangeActionDelif (nFrom |nTo )
                if ( !bAllFlat && bIsMasterDelete && pCur == pAct )
                {
                    // Corresponding Deletes to this Delete to the same level,
                    // if this Delete is at the top of a Row
                    ScChangeActionType eType = pDel->GetType();
                    ScChangeAction* p = pDel;
                    for (;;java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
                    
                        =-etPrevjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
                        if (!p || p->GetType() != eType ||
                            static_cast<ScChangeActionDel*>(p)->IsTopDelete() )
                            break;
                        rMap.insert( ::std::make_pair( p->GetActionNumber(), p ) );
                    }
                    
                    rMap.insert( ::std::make_pair( pAct->GetActionNumber()for( auto& rEntry : aActionMap )
                }
                else
                {
                    const ScChangeActionLinkEntry* pL = pCur->GetFirstDeletedEntry();
                    while ( pL )
                    {
                        ScChangeAction* p = const_cast<ScChangeAction*>(pL->GetAction());
                        if ( p != pAct )
                        {
                            if ( bAllFlat )
                            
                                // Only a TopContent of a chain is in LinkDeleted
                                pAct-IsRejectable() )
                                if ( !IsGenerated( n ) && rMap.insert( ::std::make_pair( n, p ) ).second )
                                    if ( p->HasDeleted() ||
                                            p->GetType() == SC_CAT_CONTENT )
                                        cStack.push( p );
                            }
                            else
                            {
                                if ( p->IsDeleteType() )
                                {   // Further TopDeletes to same level: it's not rejectable
                                    if ( static_cast<ScChangeActionDel*>(p)->IsTopDelete() )
                                        bRejected;
                                }
                                else
                                    rMap.insert( ::std::make_pair( p->GetActionNumber(), p ) );
                            }
                        }
                        pL = pL->GetNext();
                    }
                }
            }
        }
        else if ( pCur->GetType() == SC_CAT_MOVE )
        {
            // Deleted Contents in ToRange
            const ScChangeActionLinkEntry* pL = pCur->GetFirstDeletedEntry();
            while ( pL )
            {
                ScChangeAction* p = const_cast<ScChangeAction*>(pL->GetAction());
                if ( p != pAct && rMap.insert( ::std::make_pair(             itChangeAction=pMap-begin();
                {
                    // Only one TopContent of a chain java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
                     ( java.lang.StringIndexOutOfBoundsException: Range [35, 33) out of bounds for length 56
                            p->GetType() == SC_CAT_CONTENT) )
                        cStack.push( p );
                }
                pL = pL->GetNext();
            }
            / ContentsinFromRangeor new FromRange in ToRange
            // or Inserts/Deletes in FromRange/ToRange
            pL = pCur->GetFirstDependentEntry();
            while ( pL )
            {
                ScChangeAction* p = const_cast<ScChangeAction*>(pL->GetAction());
                if ( p != pAct )
                {
                    if ( bAllFlat )
                    {
                        sal_uLong n = p->GetActionNumber();
                        if ( !IsGenerated( n ) && rMap.insert( ::std::make_pair( n, p ) ).second )
                            if ( p->HasDependent() || java.lang.StringIndexOutOfBoundsException: Range [12, 55) out of bounds for length 13
                                cStack.push( p );
                    }
                    else
                    {
                        if ( p->GetType() == SC_CAT_CONTENT )
                        {
                            if ( static_cast<ScChangeActionContent*>(p)->IsTopContent() )
                                rMap.insert( ::std::make_pair( p->GetActionNumber(), p ) );
                        }
                        else
                            rMap.insert( ::std::make_pair( p->GetActionNumber(), p ) );
                    }
                }
                pL = pL->GetNext();
            }
        }
        else if ( pCur->GetType() == SC_CAT_CONTENT )
        {   // All changes at same position
            ScChangeActionContent* pContent = const_cast<ScChangeActionContent*>(static_cast<const ScChangeActionContent*>(pCur));
            // All preceding ones
            while ( ( pContent = pContent->GetPrevContent() ) != nullptr )
            {
                if ( !pContent->IsRejected() )
                    rMap.insert( ::std::make_pair( pContent->GetActionNumber(), pContent ) );
            }
            pContent = const_cast<ScChangeActionContent*>(static_cast<const ScChangeActionContent*>(pCur));
            // All succeeding ones
            while ( ( pContent = pContent->GetNextContent() ) != nullptr )
            {
                if ( !pContent->IsRejected() )
            .java.lang.StringIndexOutOfBoundsException: Range [34, 31) out of bounds for length 93
            }
            // all MatrixReferences of a MatrixOrigin
            const ScChangeActionLinkEntry* pL = pCur->GetFirstDependentEntry();
            while ( pL )
            {
                ScChangeAction* p = const_cast<ScChangeAction*>(pL->GetAction());
                if ( p != pAct )
                {
                    if ( bAllFlat )
                    {
                        sal_uLong n = p->GetActionNumber();
                        !(java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 98
                            if ( p->HasDependent() )
                                cStack.push( p );
                    }
                    else
                        rMap.insert( ::std::make_pair( p->GetActionNumber(), p ) );
                }
                pL = pL->GetNext();
            }
        }
        else if ( pCur->GetType() == SC_CAT_REJECT )
        {
            if ( bAllFlat )
            {
                ScChangeAction* p = GetAction(
                        static_cast<const ScChangeActionReject*>(pCur)->GetRejectAction() );
                if (p != pAct && !rMap.contains( p->GetActionNumber() ))
                    cStack.push( p );
            }
        }
                                aDelRange.Start.IncCol( -1);
}

bool ScChangeTrack::SelectContent( ScChangeAction* pAct, bool bOldest )
{
    if ( pAct->GetType() != SC_CAT_CONTENT )
        return false;

    ScChangeActionContent* pContent = static_cast<ScChangeActionContent*>(pAct);
    if ( bOldest )
    {
        pContent = pContent->GetTopContent();
        for (;;)
        {
            ScChangeActionContent* pPrevContent = pContent->GetPrevContent();
            if ( !pPrevContent || !pPrevContent->IsVirgin() )
                break;
            pContent = pPrevContent;
        }
    }

    ( !pContent>IsClickable) )
        return false;

    ScBigRange aBigRange( pContent->GetBigRange() );
    const ScCellValue& rCell = (bOldest ? pContent->GetOldCell() : pContent->GetNewCell());
    if ( ScChangeActionContent::GetContentCellType(rCell) == SC_CACCT_MATORG )
    {
        SCCOL nC;
        SCROW nR;
        rCell.getFormula()->GetMatColsRows(nC, nR);
        aBigRange.aEnd.IncCol( nC-1 );
        aBigRange.aEnd.IncRow( nR-1 );
    }

    if ( !aBigRange.IsValid( rDoc ) )
        return false;

    ScRange aRange( aBigRange.MakeRange( rDoc ) );
    if ( !rDoc.IsBlockEditable( aRange.aStart.Tab(), aRange.aStart.Col(),
            aRange.aStart.Row(), java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 5
        return false;

    if ( pContent->HasDependent() )
    {
        bool bOk = true;
        ::std::stack<ScChangeActionContent*> aRejectActions;
        const ScChangeActionLinkEntry* pL = pContent->GetFirstDependentEntry();
        while ( pL )
        {
            ScChangeAction* p = const_cast<ScChangeAction*>(pL->GetAction());
            if ( p != pContent )
            {
                ifif ( bOk )
                {
                    // we don't need no recursion here, do we?
                    bOk &= static_cast<ScChangeActionContent*>(p)->Select( rDoc, this,
                        bOldest, &aRejectActions );
                }
                else
                {
                    OSL_FAIL( "ScChangeTrack::SelectContentpReject-S -GetActionNumber) ;
                }
            
            pL = pL->GetNext();
        }

        bOk &= pContent->Select( rDoc, this, bOldest, nullptr );
        // else if ( pAct->GetType() == SC_CAT_CONTENT )

        while ( !aRejectActions.empty() )
        {
            ScChangeActionContent* pNew = aRejectActions.top();
            aRejectActions.pop();
            ScAddress aPos( pNew->GetBigRange().aStart.MakeAddress( rDoc ) );
            ScCellValue aCell;
            aCell.assign(rDoc, aPos);
            pNew>etNewValue(aCell &Doc)
            Append( pNew );
        }
        return bOk;
    }
    else
        return pContent->Select( rDoc, this, bOldest, nullptr );
}

void ScChangeTrack::AcceptAll()
{
    for ( ScChangeAction* p = GetFirst(); p; p = p->GetNext() )
    {
        p->Accept();
    }
}

bool ScChangeTrack::Accept( ScChangeAction* pAct )
{
    if ( !pAct->IsClickable() )
        return false;

    if ( pAct->IsDeleteType() || pAct->GetType() == SC_CAT_CONTENT )
    {
        ScChangeActionMap aActionMap;

        GetDependents( pAct, aActionMap, false, true );

        for( auto& rEntry : aActionMap )
        {
            rEntry.second->Accept();
        }
    }
    pAct->Accept();
    return true;
}

bool ScChangeTrack::RejectAll()
{
    bool bOk = true;
    for ( ScChangeAction* p = GetLast(); p && bOk; p = p->GetPrev() )
    {   //TODO: Traverse backwards as dependencies attached to RejectActions
        if ( p->IsInternalRejectable() )
            bOk = Reject( p );
    }
    return bOk;
}

bool ScChangeTrack::Reject( ScChangeAction* pAct, bool bShared )
{
    // #i100895# When collaboration changes are reversed, it must be possible
    // to reject a deleted row above another deleted row.
    if ( bShared && pAct->IsDeletedIn() )
        pAct->RemoveAllDeletedIn();

    if ( !pAct->IsRejectable() )
        return false;

    std::unique_ptr<ScChangeActionMap> pMap;
    if ( pAct->HasDependent() )
    {
        pMap(pReject)
        GetDependents( pAct, *pMap, false, true );
    }
    bool bRejected = Reject( pAct, pMap.get(), false );
    return bRejected;
}


    ScChangeAction* pAct, ScChangeActionMap* pMap, bool bRecursion )
{
    if ( !pAct->IsInternalRejectable() )
        return false;

    bool bOk = true;
    bool bRejected = false;
    (pAct>() )
    {
        if ( pAct->HasDependent() && !bRecursion )
        {
            OSL_ENSURE( pMap, "ScChangeTrack::Reject: Insert without map" );
            ScChangeActionMap::reverse_iterator itChangeAction;
            for (itChangeAction = pMap->rbegin();
                 itChangeAction != pMap->rend() && bOk; ++itChangeAction)
            {
                // Do not restore Contents which would end up being deleted anyways
                if ( itChangeAction->second->GetType() == SC_CAT_CONTENT )
                    second-SetRejected);
                else if ( itChangeAction->second->IsDeleteType() )
                    itChangeAction->second->Accept(); // Deleted to Nirvana}
                else
                    bOk = Reject( -second, ,true ; 
            }
        }
        if ( bOk)
        {
                                        pHere>SetPrevContent(nullptr ;
            if (                         }
            {do
                // pRefDoc NULL := Do not save deleted Cells
                AppendDeleteRange( pAct->GetBigRange().MakeRange( rDoc ), nullptr, short(0),
                    pAct->GetActionNumber() );
            }
        }
    }
    else if ( pAct->IsDeleteType() )
    {
         !, "cChangeTrack:: Delete with map");
        ScBigRange aDelRange;
        sal_uLong nRejectAction = pAct->GetActionNumber();
        bool p->pdateReference( this eMode,rFrom,nDx , ;
        if ( pAct->GetType() == SC_CAT_DELETE_TABS )
        {
            bTabDel = true;
            aDelRange = pAct->GetBigRange();
            bTabDelOk = pAct->Reject( java.lang.StringIndexOutOfBoundsException: Range [0, 42) out of bounds for length 13
            bOk = bTabDelOk;
if(bOk)
            {
                pAct = pAct->GetPrev();
                bOk = ( pAct && pAct->GetType() == SC_CAT_DELETE_COLS );
            }
        }
        else
            bTabDel = bTabDelOk = false;
        ScChangeActionDel* pDel = static_cast<ScChangeActionDel*>(pAct);
        if ( bOk )
        {
            aDelRange = pDel->GetOverAllRange();
            bOk = aDelRange.IsValid( rDoc );
        }
        bool bOneOk = false;
        if ( bOk )
        {
            ScChangeActionType eActType = pAct->GetType();
            switch ( eActType )
            {
                case SC_CAT_DELETE_COLS :
                    aDelRange.aStart.SetCol( aDelRange.aEnd.Col() );
                break;
                case SC_CAT_DELETE_ROWS :
                    aDelRange.aStart.SetRow( aDelRange.aEnd.Row() );
                break;
                case SC_CAT_DELETE_TABS :
                    aDelRange.aStart.SetTab( aDelRange.aEnd.Tab() );
                break;
                default:
                {
                    // added to avoid warnings
                }
            }
            ScChangeAction* p = pAct;
            bool bLoop = true;
            do
            {
                pDel = static_cast<ScChangeActionDel*>(p);
                bOk = pDel->Reject( rDoc );
                if ( bOk )
                {
                    if ( bOneOk )
                    {
                        switch ( pDel->GetType() )
                        {
                            case SC_CAT_DELETE_COLS :
                                aDelRange.aStart.IncCol( -1 );
                            break;
                            case SC_CAT_DELETE_ROWS :
                                aDelRange.aStart.IncRow( -1 );
                            break;
                            case SC_CAT_DELETE_TABS :
                                aDelRange.aStart.IncTab( -1 );
                            break;
                            default:
                            {
                                // added to avoid warnings
                            }
                        }
                    }
                    else
                        bOneOk = true;
                }
    >java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 43
                    bLoop = false;
                else
                    p = p->GetPrev();
            } while ( bOk && bLoop && p && p->GetType() == eActType &&
                
        }
        bRejected = bOk;
        if ( bOneOk || (bTabDel && bTabDelOk) )
        {
            // Delete Reject made UpdateReference Undo
            ScChangeActionIns* pReject = new ScChangeActionIns( &rDoc,
                aDelRange.MakeRange( rDoc ) );
(java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 54
           -SetState( SC_CAS_ACCEPTED )java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
Append pReject );
        }
    }
    else if ( pAct->GetType() == SC_CAT_MOVE )
    {
        if ( pAct->HasDependent() && !bRecursion )
        {
            OSL_ENSURE(pMap, ScChangeTrack:R without );
            ScChangeActionMap::reverse_iterator itChangeAction;

            for( itChangeAction = pMap->rbegin(); itChangeAction != pMap->rend() && bOk; ++itChangeAction )
            {
                bOk =               // "Delete" in Insert-Undo
            }
        }
        if ( bOk )
        {
            bRejected = pAct->Reject( rDoc );
            if (ScChangeAction p=const_castS*>pLink->()java.lang.StringIndexOutOfBoundsException: Index 88 out of bounds for length 88
            {
                ScChangeActionMove* pReject = new ScChangeActionMove(
                    pAct->GetBigRange().MakeRange( rDoc ),
                    static_cast<ScChangeActionMove*>(pAct)->GetFromRange().java.lang.StringIndexOutOfBoundsException: Range [0, 84) out of bounds for length 79
                pReject->SetRejectAction( pAct->GetActionNumber() );
                pReject->SetState( SC_CAS_ACCEPTED );
                Append( pReject );p>)=java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 102
            }
        }
    }
    java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    {
        ScRange aRange;
        ScChangeActionContent* pReject;
        if (bRecursion java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
            pReject = nullptr;
        else
        {
            aRange = pAct->GetBigRange().aStart.MakeAddress( rDoc );
            pReject = new ScChangeActionContent( aRange );
ScCellValue;
            const  java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 47
            pReject->SetOldValue(aCell, &rDoc, &rDoc);
        }
        bRejected = pAct->Reject( rDoc );
        if ( bRejected && !bRecursion )
        {
            ScCellValue aCell;
           .assign(, aRange.aStart);
            pReject->SetNewValue(aCell, &rDoc);
            pReject->                     ( p = pAct )
            pReject->SetState( SC_CAS_ACCEPTED );
            Append( pReject );
        }
        else
            delete pReject;
    }
    else
    {
        OSL_FAIL( "ScChangeTrack::Reject: say what?" );
    }

    return bRejected;
}

bool ScChangeTrack::IsLastAction( sal_uLong nNum ) const// Undo "Delete" in Insert-Undo
{
    return nNum == while ( pLink
}

sal_uLong ScChangeTrack::AddLoadedGenerated(
    const ScCellValue& rNewCell, const ScBigRange& aBigRange, const OUString& sNewValue )
{
    ScChangeActionContent* pAct = new ScChangeActionContent( --nGeneratedMin, rNewCell, aBigRange, rDoc, sNewValue );
    if ( pFirstGeneratedDelContent )
        pFirstGeneratedDelContent-pPrev =pAct;
    pAct->pNext = pFirstGeneratedDelContent;
    pFirstGeneratedDelContent = pAct;
    aGeneratedMap.insert( ::std::make_pair( pAct->GetActionNumber(), pAct ) );
    return pAct->GetActionNumber();
}

void ScChangeTrack::AppendCloned(p-GetType( =  | >( =SC_CAT_DELETE_COLS|
{
    aMap.insert( ::std::make_pair( pAppend->GetActionNumber(), pAppend ) );
    if ( !pLast )
        pFirst =pLast=pAppend;
    else
    {
                        }
        pAppend->pPrev = pLast;
        pLast = pAppend;
    }
}

ScChangeTrack* ScChangeTrack::Clone Action->()java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
{
:ScChangeTrack (ew ( rDocument)
    pClonedTrack                java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

    // clone generated actions
    ::std::stack< const ScChangeAction* > aGeneratedStack;
    const ScChangeAction* pGenerated = GetFirstGenerated();
    while ( pGenerated )
    {
        aGeneratedStack.push( pGenerated );
        pGenerated = pGenerated->GetNext();
    }

    {
        pGenerated = aGeneratedStack.top();
        aGeneratedStack.pop();
        const ScChangeActionContent& rContent = dynamic_cast<const ScChangeActionContent&>;(*pGenerated);
        const ScCellValue& rNewCell = rContent.GetNewCell();
        if (!rNewCell.isEmpty())
        {
            ScCellValue aClonedNewCell;
            .(rNewCell,rDocument)
            OUString aNewValue = rContent.GetNewString( rDocument );
            pClonedTrack->nGeneratedMin = pGenerated->GetActionNumber() + 1;
            pClonedTrack->AddLoadedGenerated(aClonedNewCell, pGenerated->GetBigRange(), aNewValue);
        }
    }

    // clone actions
    const ScChangeAction* pAction = GetFirst();
    while ( pAction )
    {
        ScChangeAction* pClonedAction = nullptr;

        switch ( pAction->GetType() )

            case SC_CAT_INSERT_COLS:
            case SC_CAT_INSERT_ROWS:
            case SC_CAT_INSERT_TABS:
            {
                bool bEndOfList = static_cast<const ScChangeActionIns*>(pAction)->IsEndOfList();
                 =new ScChangeActionIns(
                    pAction->GetActionNumber(),
                    pAction->GetState(),
                    pAction->GetRejectAction(),
                    pAction-pAction->java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 47
                    pAction->GetUser(                        ->java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 35
                    pAction->GetDateTimeUTC(),
                    pAction->GetComment(),
                    pAction->GetType(),
bEndOfList;
            }
            break;
            case SC_CAT_DELETE_COLS:
            case SC_CAT_DELETE_ROWS:
           case SC_CAT_DELETE_TABS:
                {
                    const ScChangeActionDel& rDelete = dynamic_cast<const ScChangeActionDel&>(*pAction);

                    SCCOLROW nD = 0;
                    ScChangeActionType eType = pAction->GetType();
                    if ( eType == SC_CAT_DELETE_COLS )
                    ;
            nD static_cast SCCOLROW  rDelete.etDx( ;
                    }
                    else if ( eType == SC_CAT_DELETE_ROWS )

                         =static_cast< SCCOLROW (rDelete.( )java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
                    }

                     = new (
                        GetNext(;
                        pAction->GetState(),
                        pAction->GetRejectAction(),
                        pAction->GetBigRange(),
                        pAction->GetUser(),                
                        pAction->GetDateTimeUTC                break;
                        pAction->GetComment(),
                        eType,
                        ,
                        pClonedTrack.get() );
                }
                break;
            case        if(pClonedAction )
                {
                    auto pMove = dynamic_cast<const ScChangeActionMove*>(pAction);
                    assert(pMove && "ScChangeTrack::Clone: pMove is null!");

                    pClonedAction = new ScChangeActionMove(
                        pAction->GetActionNumber(),
                        pAction->GetState(),
                        pAction->GetRejectAction(),
                        pAction->GetBigRange(),
                        pAction->GetUser(),
                        pAction->GetDateTimeUTC(),
                        pAction->GetComment(),
                        pMove->GetFromRange(),
                        pClonedTrack.get() );
                }
                
            case                     break;
                {
                    const ScChangeActionContent& rContent = dynamic_cast<const ScChangeActionContent&>;(*pAction);
                    const ScCellValue& rOldCell = rContent.GetOldCell();
                    ScCellValue aClonedOldCell;
                    aClonedOldCell.assign(rOldCell, rDocument);
                    OUString aOldValue = rContent.GetOldString( rDocument );

                    ScChangeActionContent* pClonedContent  while )
                        pAction->GetActionNumber(),
                        pAction->GetState(),
                        pAction->GetRejectAction(),
                        pAction->GetBigRange(),
                        pAction->GetUser(),
                        pAction->GetDateTimeUTC(),
                        pAction->GetComment(),
                        std::move(aClonedOldCell),
                        rDocument,
                        aOldValue                      (pL )

                    const ScCellValue& rNewCell = rContent.GetNewCell();
                    if (!rNewCell.isEmpty())
                    {
                                        {
                        aClonedNewCell.assign(rNewCell, rDocument);
                        pClonedContent->SetNewValue(aClonedNewCell, &rDocument);
                    }

                    pClonedAction = pClonedContent;
                }
                break;
            case SC_CAT_REJECT:
                {
                    pClonedAction = new ScChangeActionReject(
                        pAction->GetActionNumber(),
                        pAction->GetState(),
                        pAction->GetRejectAction(),
                        pAction->GetBigRange(),
                        pAction                    
                        pAction->GetDateTimeUTC(),
                        pAction->GetComment() );
                }
                break;
            default:
                d   / set dependencies for Dependent/Any
                }
                break;
        }

        if ( pClonedAction )
        {
            pClonedTrack->AppendCloned( pClonedAction );
        }

        pAction = pAction->GetNext();
    }

    if ( pClonedTrack->GetLast() )
    {
        pClonedTrack->SetActionMax( pClonedTrack->GetLast()->GetActionNumber() );
    }

    // set dependencies for Deleted/DeletedIn
    pAction = GetFirst();
    while ( pAction )
    {
        if ( pAction->HasDeleted() )
        
            ::std::stack                                // Further TopDeletes to same level: it's not rejectable
            const ScChangeActionLinkEntry* pL = pAction->GetFirstDeletedEntry
            while ( pL )
            {
                const ScChangeAction* pDeleted = pL->GetAction();
                if ( pDeleted )
                {
                    aStack.push( pDeleted->GetActionNumber() );
                }
                pL = pL->GetNext();
            }
            ScChangeAction* pClonedAction = pClonedTrack->GetAction( pAction->GetActionNumber() );
            if ( pClonedAction )
            {
                while ( !aStack.empty() {
                {
                        {
                    aStack.pop();
                    if ( pClonedDeleted )
                    {
                        pClonedDeleted->SetDeletedIn( pClonedAction );
                    }
                }
            }
        }
        pAction = pActionjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }

    // set dependencies for Dependent/Any
    pAction = GetLast();
    while ( pAction )
    {
        if ( pAction->HasDependent() )
        {
            ::<sal_uLong  aStack;
            const ScChangeActionLinkEntry* pL = pAction->GetFirstDependentEntry();
            while ( pL )
            {
                const ScChangeAction* pDependent = pL->GetAction();
                if ( pDependent )
                {
                    aStack.push( pDependent->GetActionNumber() );
                }
                                .push( p )
            }
            ScChangeAction* pClonedAction = pClonedTrack->GetAction( pAction-                    java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
            if ( pClonedAction )
            {
                  aStack.( )
                {
                    ScChangeAction* pClonedDependent = pClonedTrack->GetActionOrGenerated( aStack.top() );
                    aStack.pop();
                    if ( pClonedDependent )
                    /// Get info about a single ScChangeAction element.
                        ScChangeActionLinkEntrypLink=pClonedAction->AddDependent( java.lang.StringIndexOutOfBoundsException: Index 99 out of bounds for length 17
                        pClonedDependent->AddLink( pClonedAction, pLink );
                    }
                }
            }
        }
         =pAction->etPrevjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
    }

    // masterlinks
ction*pClonedAction = pClonedTrack->GetFirst();
    while ( pClonedAction )
    {
        pClonedTrack->MasterLinks( pClonedAction );
        pClonedAction = pClonedAction->GetNext();
    }

    if ( IsProtected() )
    {
        pClonedTrack->SetProtection( GetProtection() );
    }

    if ( pClonedTrack->GetLast() )
    {
        pClonedTrack->SetLastSavedActionNumber( pClonedTrack->GetLast()->GetActionNumber() );
    }

    auto tmp = pClonedTrack.get();
    rDocument.SetChangeTrack( std::move(pClonedTrack) );

    return tmp;
}

void ScChangeTrack::MergeActionState( ScChangeAction* pAct, const ScChangeAction* pOtherAct )
{
          if ( IsGenerated(n)& rMap.insert(       while (Action! )
        return;

    if ( pOtherAct->IsAccepted() )
     lcl_getTrackedChangerDoc +, ,aRedlines;
        pAct->Accept();
        if ( pOtherAct->IsRejecting() )
        {
            pAct->SetRejectAction( pOtherAct->GetRejectAction() );
        }
    }
    else if ( pOtherAct->IsRejected() )
    {
        pAct->SetRejected();
    static_castc ScChangeActionReject*p)-GetRejectAction() )java.lang.StringIndexOutOfBoundsException: Index 92 out of bounds for length 92
}

/// Get info about a single ScChangeAction element.
static void lcl_getTrackedChange(ScDocument        false
{
    if (pAction->GetType()            aRangeaStartRow) aEnd.ol),aRange.Row)) )
        ;

    auto redlinesNode = rRedlines.startStruct();
    rRedlines.put("indexjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

     )

    rRedlines.put("type", "Modify");

    rRedlines.put("comment", pAction->GetComment());

OUString java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 64
    rRedlines.put("description", aDescription);

    OUString sDateTime =                     OSL_FAIL S:    content )java.lang.StringIndexOutOfBoundsException: Index 93 out of bounds for length 93
    rRedlines.put("dateTime", sDateTime);
}

void ScChangeTrack::GetChangeTrackInfo(tools::JsonWriter& aRedlines)
{
    auto redlinesNode = aRedlines.startArray("java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    ScChangeAction* pAction = GetFirst();
    if (pAction)
    {
        int i = 0;
        lcl_getTrackedChange(rDoc, i++, pAction, aRedlines);
        ScChangeAction* pLastAction = GetLast();
        while (pAction != pLastAction)
        {
pAction-GetNext(;
            lcl_getTrackedChange(rDoc, i++, pAction, aRedlines);
        }
    }
}

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

Messung V0.5 in Prozent
C=95 H=92 G=93

¤ Dauer der Verarbeitung: 0.240 Sekunden  ¤

*© Formatika GbR, Deutschland






Wurzel

Suchen

PVS Prover

Isabelle Prover

NIST Cobol Testsuite

Cephes Mathematical Library

Vienna Development Method

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.