/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/*

 * This file is part of the LibreOffice project.

 *

 * This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/.

 *

 * This file incorporates work covered by the following license notice:

 *

 *   Licensed to the Apache Software Foundation (ASF) under one or more

 *   contributor license agreements. See the NOTICE file distributed

 *   with this work for additional information regarding copyright

 *   ownership. The ASF licenses this file to you under the Apache

 *   License, Version 2.0 (the "License"); you may not use this file

 *   except in compliance with the License. You may obtain a copy of

 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .

 */

#include <redline.hxx>

#include <tools/datetime.hxx>

#include <tools/lineend.hxx>

#include <svl/eitem.hxx>

#include <sfx2/viewfrm.hxx>

#include <sfx2/dispatch.hxx>

#include <svx/ctredlin.hxx>

#include <svx/postattr.hxx>

#include <utility>

#include <vcl/commandevent.hxx>

#include <vcl/weld/Dialog.hxx>

#include <vcl/weld/Menu.hxx>

#include <vcl/weld/weldutils.hxx>

#include <swtypes.hxx>

#include <wrtsh.hxx>

#include <view.hxx>

#include <swmodule.hxx>

#include <redlndlg.hxx>

#include <swwait.hxx>

#include <uitool.hxx>

#include <o3tl/string_view.hxx>

#include <o3tl/temporary.hxx>

#include <cmdid.h>

#include <strings.hrc>

// -> #111827#

#include <swundo.hxx>

#include <SwRewriter.hxx>

// <- #111827#

#include <vector>

#include <svx/svxdlg.hxx>

#include <osl/diagnose.h>

#include <bitmaps.hlst>

#include <docsh.hxx>

#include <IDocumentRedlineAccess.hxx>

#include <usrpref.hxx>

#include <memory>

SFX_IMPL_MODELESSDIALOGCONTOLLER_WITHID(SwRedlineAcceptChild, FN_REDLINE_ACCEPT)

SwRedlineAcceptChild::SwRedlineAcceptChild(vcl::Window* _pParent, sal_uInt16 nId,

                                           SfxBindings& rBindings, SfxChildWinInfo& rInfo)

    : SwChildWinWrapper(_pParent, nId)

{

    auto xDlg

        = std::make_shared<SwModelessRedlineAcceptDlg>(&rBindings, this, _pParent->GetFrameWeld());

    SetController(xDlg);

    xDlg->Initialize(rInfo);

}

SwModelessRedlineAcceptDlg::SwModelessRedlineAcceptDlg(

    SfxBindings* _pBindings, SwChildWinWrapper* pChild, weld::Window *pParent)

    : SfxModelessDialogController(_pBindings, pChild, pParent,

        u"svx/ui/acceptrejectchangesdialog.ui"_ustr, u"AcceptRejectChangesDialog"_ustr)

    , m_xContentArea(m_xBuilder->weld_container(u"container"_ustr))

    , m_pChildWin(pChild)

{

    m_xImplDlg.reset(new SwRedlineAcceptDlg(m_xDialog, m_xBuilder.get(), m_xContentArea.get()));

}

void SwModelessRedlineAcceptDlg::Activate()

{

    if (mbInDestruction)

        return;

    SwView *pView = ::GetActiveView();

    if (!pView) // can happen when switching to another app, when a Listbox in dialog

        return; // had the focus previously (actually THs Bug)

    SwDocShell *pDocSh = pView->GetDocShell();

    if (m_pChildWin->GetOldDocShell() != pDocSh)

    {   // doc-switch

        SwWait aWait( *pDocSh, false );

        SwWrtShell* pSh = pView->GetWrtShellPtr();

        if (!pSh)

            return;

        m_pChildWin->SetOldDocShell(pDocSh);  // avoid recursion (using modified-Hdl)

        bool bMod = pSh->IsModified();

        SfxBoolItem aShow(FN_REDLINE_SHOW, true);

        pSh->GetView().GetViewFrame().GetDispatcher()->ExecuteList(

            FN_REDLINE_SHOW, SfxCallMode::SYNCHRON|SfxCallMode::RECORD,

            { &aShow });

        if (!bMod)

            pSh->ResetModified();

        m_xImplDlg->Init();

        SfxModelessDialogController::Activate();

        return;

    }

    SfxModelessDialogController::Activate();

    m_xImplDlg->Activate();

}

void SwModelessRedlineAcceptDlg::Initialize(SfxChildWinInfo& rInfo)

{

    m_xImplDlg->Initialize(rInfo.aExtraString);

    SfxModelessDialogController::Initialize(rInfo);

}

void SwModelessRedlineAcceptDlg::FillInfo(SfxChildWinInfo& rInfo) const

{

    SfxModelessDialogController::FillInfo(rInfo);

    m_xImplDlg->FillInfo(rInfo.aExtraString);

}

SwModelessRedlineAcceptDlg::~SwModelessRedlineAcceptDlg()

{

    mbInDestruction = true;

}

namespace

{

const SwRedlineData* lcl_get_selected_redlinedata(const weld::TreeView& rTreeView)

{

    if (std::unique_ptr<weld::TreeIter> xEntry = rTreeView.get_selected())

    {

        RedlineData* pRedlinData = weld::fromId<RedlineData*>(rTreeView.get_id(*xEntry));

        if (rTreeView.get_iter_depth(*xEntry))

            return static_cast<SwRedlineDataChild*>(pRedlinData->pData)->pChild;

        else

            return static_cast<SwRedlineDataParent*>(pRedlinData->pData)->pData;

    }

    return nullptr;

}

void lcl_reselect(weld::TreeView& rTreeView, const SwRedlineData* pSelectedEntryRedlineData)

{

    if (!pSelectedEntryRedlineData)

    {

        rTreeView.set_cursor(-1);

        return;

    }

    rTreeView.all_foreach(

        [&rTreeView, &pSelectedEntryRedlineData](weld::TreeIter& rIter)

        {

            RedlineData* pRedlinData = weld::fromId<RedlineData*>(rTreeView.get_id(rIter));

            const SwRedlineData* pRedlineData;

            if (rTreeView.get_iter_depth(rIter))

                pRedlineData = static_cast<SwRedlineDataChild*>(pRedlinData->pData)->pChild;

            else

                pRedlineData = static_cast<SwRedlineDataParent*>(pRedlinData->pData)->pData;

            if (pRedlineData == pSelectedEntryRedlineData)

            {

                rTreeView.set_cursor(rIter);

                return true;

            }

            return false;

        });

}

}

SwRedlineAcceptDlg::SwRedlineAcceptDlg(std::shared_ptr<weld::Window> xParent, weld::Builder *pBuilder,

                                       weld::Container *pContentArea, bool bAutoFormat)

    : m_xParentDlg(std::move(xParent))

    , m_aSelectTimer("SwRedlineAcceptDlg m_aSelectTimer")

    , m_sInserted(SwResId(STR_REDLINE_INSERTED))

    , m_sDeleted(SwResId(STR_REDLINE_DELETED))

    , m_sFormated(SwResId(STR_REDLINE_FORMATTED))

    , m_sTableChgd(SwResId(STR_REDLINE_TABLECHG))

    , m_sFormatCollSet(SwResId(STR_REDLINE_FMTCOLLSET))

    , m_sAutoFormat(SwResId(STR_REDLINE_AUTOFMT))

    , m_bOnlyFormatedRedlines(false)

    , m_bRedlnAutoFormat(bAutoFormat)

    , m_bInhibitActivate(false)

    , m_bHasTrackedColumn(false)

    , m_xTabPagesCTRL(new SvxAcceptChgCtr(pContentArea))

    , m_xPopup(pBuilder->weld_menu(u"writermenu"_ustr))

    , m_xSortMenu(pBuilder->weld_menu(u"writersortmenu"_ustr))

    , m_rTPView(m_xTabPagesCTRL->GetViewPage())

{

    m_pTable = m_rTPView.GetTableControl();

    m_pTable->SetWriterView();

    m_rTPView.GetSortByComboBoxControl()->set_active(4);

    m_rTPView.SetSortByComboBoxChangedHdl(

        LINK(this, SwRedlineAcceptDlg, SortByComboBoxChangedHdl));

    m_rTPView.SetAcceptClickHdl(LINK(this, SwRedlineAcceptDlg, AcceptHdl));

    m_rTPView.SetAcceptAllClickHdl(LINK(this, SwRedlineAcceptDlg, AcceptAllHdl));

    m_rTPView.SetRejectClickHdl(LINK(this, SwRedlineAcceptDlg, RejectHdl));

    m_rTPView.SetRejectAllClickHdl(LINK(this, SwRedlineAcceptDlg, RejectAllHdl));

    m_rTPView.SetUndoClickHdl(LINK(this, SwRedlineAcceptDlg, UndoHdl));

    //tdf#89227 default to disabled, and only enable if possible to accept/reject

    m_rTPView.EnableAccept(false);

    m_rTPView.EnableReject(false);

    m_rTPView.EnableClearFormat(false);

    m_rTPView.EnableAcceptAll(false);

    m_rTPView.EnableRejectAll(false);

    m_rTPView.EnableClearFormatAll(false);

    m_xTabPagesCTRL->GetFilterPage()->SetReadyHdl(LINK(this, SwRedlineAcceptDlg, FilterChangedHdl));

    weld::ComboBox* pActLB = m_xTabPagesCTRL->GetFilterPage()->GetLbAction();

    pActLB->append_text(m_sInserted);

    pActLB->append_text(m_sDeleted);

    pActLB->append_text(m_sFormated);

    pActLB->append_text(m_sTableChgd);

    if (HasRedlineAutoFormat())

    {

        pActLB->append_text(m_sFormatCollSet);

        pActLB->append_text(m_sAutoFormat);

        m_rTPView.ShowUndo();

        m_rTPView.DisableUndo();     // no UNDO events yet

    }

    pActLB->set_active(0);

    weld::TreeView& rTreeView = m_pTable->GetWidget();

    rTreeView.set_selection_mode(SelectionMode::Multiple);

    rTreeView.connect_selection_changed(LINK(this, SwRedlineAcceptDlg, SelectHdl));

    rTreeView.connect_command(LINK(this, SwRedlineAcceptDlg, CommandHdl));

    // avoid multiple selection of the same texts:

    m_aSelectTimer.SetTimeout(100);

    m_aSelectTimer.SetInvokeHandler(LINK(this, SwRedlineAcceptDlg, GotoHdl));

    // we want to receive SfxHintId::SwRedlineContentAtPos

    StartListening(*(SwModule::get()->GetView()->GetDocShell()));

}

SwRedlineAcceptDlg::~SwRedlineAcceptDlg()

{

}

void SwRedlineAcceptDlg::Init(SwRedlineTable::size_type nStart)

{

    std::optional<SwWait> oWait;

    SwView* pView = GetActiveView();

    if (pView)

        oWait.emplace(*pView->GetDocShell(), false);

    weld::TreeView& rTreeView = m_pTable->GetWidget();

    m_aUsedSeqNo.clear();

    // tdf#162018 keep the selected entry selected

    const SwRedlineData* pSelectedEntryRedlineData = lcl_get_selected_redlinedata(rTreeView);

    // tdf#162337 tracked change selection when the Manage Changes dialog is initially opened

    if (pView && m_bInitialSelect)

    {

        m_bInitialSelect = false;

        SwWrtShell* pSh = pView->GetWrtShellPtr();

        if (pSh)

        {

            const SwRangeRedline* pCurrRedline = pSh->GetCurrRedline();

            if (pCurrRedline)

            {

                // Select current redline

                SwRedlineTable::size_type nPos

                    = pSh->FindRedlineOfData(pCurrRedline->GetRedlineData());

                pSh->GotoRedline(nPos, true);

                pSh->SetInSelect();

            }

            else

            {

                // Select the next redline if there is one

                pSh->AssureStdMode();

                pCurrRedline = pSh->SelNextRedline();

            }

            if (pCurrRedline)

                pSelectedEntryRedlineData = &pCurrRedline->GetRedlineData();

        }

    }

    rTreeView.freeze();

    if (nStart)

        RemoveParents(nStart, m_RedlineParents.size() - 1);

    else

    {

        rTreeView.clear();

        m_RedlineData.clear();

        m_RedlineChildren.clear();

        m_RedlineParents.erase(m_RedlineParents.begin() + nStart, m_RedlineParents.end());

    }

    rTreeView.thaw();

    // insert parents

    InsertParents(nStart);

    InitAuthors();

    lcl_reselect(rTreeView, pSelectedEntryRedlineData);

    EnableControls(pView);

}

static bool isAcceptRejectCommandsEnabled(const SwView& rView)

{

    // Check the state of the command, including read-only mode and special cases

    // like LOK AllowChangeComments mode

    return rView.GetViewFrame().GetDispatcher()->QueryState(FN_REDLINE_ACCEPT_ALL,

                                                            o3tl::temporary(SfxPoolItemHolder()))

           != SfxItemState::DISABLED;

}

void SwRedlineAcceptDlg::InitAuthors()

{

    if (!m_xTabPagesCTRL)

        return;

    SwView *pView = ::GetActiveView();

    if (!pView)

        return;

    SwWrtShell* pSh = pView->GetWrtShellPtr();

    SvxTPFilter *pFilterPage = m_xTabPagesCTRL->GetFilterPage();

    std::vector<OUString> aStrings;

    OUString sOldAuthor(pFilterPage->GetSelectedAuthor());

    pFilterPage->ClearAuthors();

    SwRedlineTable::size_type nCount = pSh ? pSh->GetRedlineCount() : 0;

    m_bOnlyFormatedRedlines = true;

    // determine authors

    for ( SwRedlineTable::size_type i = 0; i < nCount; i++)

    {

        const SwRangeRedline& rRedln = pSh->GetRedline(i);

        if( m_bOnlyFormatedRedlines && RedlineType::Format != rRedln.GetType() )

            m_bOnlyFormatedRedlines = false;

        aStrings.push_back(rRedln.GetAuthorString());

        for (sal_uInt16 nStack = 1; nStack < rRedln.GetStackCount(); nStack++)

        {

            aStrings.push_back(rRedln.GetAuthorString(nStack));

        }

    }

    std::sort(aStrings.begin(), aStrings.end());

    aStrings.erase(std::unique(aStrings.begin(), aStrings.end()), aStrings.end());

    for (auto const & i: aStrings)

        pFilterPage->InsertAuthor(i);

    if (pFilterPage->SelectAuthor(sOldAuthor) == -1 && !aStrings.empty())

        pFilterPage->SelectAuthor(aStrings[0]);

}

void SwRedlineAcceptDlg::EnableControls(const SwView* pView)

{

    if (!pView)

        return;

    SwWrtShell* pSh = pView->GetWrtShellPtr();

    if (!pSh)

        return;

    weld::TreeView& rTreeView = m_pTable->GetWidget();

    bool const bEnable = isAcceptRejectCommandsEnabled(*pView)

        && rTreeView.n_children() != 0

        && !pSh->getIDocumentRedlineAccess().GetRedlinePassword().hasElements();

    bool bAcceptReject = false;

    bool bIsNotFormated = false;

    rTreeView.selected_foreach([this, pSh, &bIsNotFormated, &bAcceptReject](weld::TreeIter& rEntry){

        // Only enable these controls for top-level redlines

        if (m_pTable->GetWidget().get_iter_depth(rEntry) == 0)

            bAcceptReject = true;

        // find the selected redline

        // (fdo#57874: ignore, if the redline is already gone)

        SwRedlineTable::size_type nPos = GetRedlinePos(rEntry);

        if( nPos != SwRedlineTable::npos )

        {

            const SwRangeRedline& rRedln = pSh->GetRedline( nPos );

            bIsNotFormated |= RedlineType::Format != rRedln.GetType();

        }

        return false;

    });

    m_rTPView.EnableAccept(bEnable && bAcceptReject);

    m_rTPView.EnableReject(bEnable && bAcceptReject);

    m_rTPView.EnableClearFormat(bEnable && !bIsNotFormated && bAcceptReject);

    m_rTPView.EnableAcceptAll(bEnable);

    m_rTPView.EnableRejectAll(bEnable);

    m_rTPView.EnableClearFormatAll(bEnable && m_bOnlyFormatedRedlines);

}

const OUString & SwRedlineAcceptDlg::GetActionImage(const SwRangeRedline& rRedln, sal_uInt16 nStack,

                                            bool bTableChanges, bool bRowChanges)

{

    switch (rRedln.GetType(nStack))

    {

        case RedlineType::Insert:  return bTableChanges

            ? bRowChanges

                ? BMP_REDLINE_ROW_INSERTION

                : BMP_REDLINE_COL_INSERTION

            : rRedln.IsMoved()

                ? BMP_REDLINE_MOVED_INSERTION

                : rRedln.IsAnnotation()

                    ? BMP_REDLINE_COMMENT_INSERTION

                    : BMP_REDLINE_INSERTED;

        case RedlineType::Delete:  return bTableChanges

            ? bRowChanges

                 ? BMP_REDLINE_ROW_DELETION

                 : BMP_REDLINE_COL_DELETION

            : rRedln.IsMoved()

                ? BMP_REDLINE_MOVED_DELETION

                : rRedln.IsAnnotation()

                    ? BMP_REDLINE_COMMENT_DELETION

                    : BMP_REDLINE_DELETED;

        case RedlineType::Format:  return BMP_REDLINE_FORMATTED;

        case RedlineType::ParagraphFormat: return BMP_REDLINE_FORMATTED;

        case RedlineType::Table:   return BMP_REDLINE_TABLECHG;

        case RedlineType::FmtColl: return BMP_REDLINE_FMTCOLLSET;

        default: break;

    }

    return EMPTY_OUSTRING;

}

const OUString & SwRedlineAcceptDlg::GetActionText(const SwRangeRedline& rRedln, sal_uInt16 nStack)

{

    switch( rRedln.GetType(nStack) )

    {

        case RedlineType::Insert:   return m_sInserted;

        case RedlineType::Delete:   return m_sDeleted;

        case RedlineType::Format:   return m_sFormated;

        case RedlineType::ParagraphFormat:   return m_sFormated;

        case RedlineType::Table:    return m_sTableChgd;

        case RedlineType::FmtColl:  return m_sFormatCollSet;

        default:;//prevent warning

    }

    return EMPTY_OUSTRING;

}

// newly initialise after activation

void SwRedlineAcceptDlg::Activate()

{

    // prevent update if flag is set (#102547#)

    if( m_bInhibitActivate )

        return;

    SwView *pView = ::GetActiveView();

    if (!pView) // can happen when switching to another app

    {

        m_rTPView.EnableAccept(false);

        m_rTPView.EnableReject(false);

        m_rTPView.EnableClearFormat(false);

        m_rTPView.EnableAcceptAll(false);

        m_rTPView.EnableRejectAll(false);

        m_rTPView.EnableClearFormatAll(false);

        return; // had the focus previously

    }

    SwWait aWait( *pView->GetDocShell(), false );

    if (pView->GetDocShell()->IsReadOnly())

    {

        m_rTPView.EnableAccept(false);

        m_rTPView.EnableReject(false);

        m_rTPView.EnableClearFormat(false);

        m_rTPView.EnableAcceptAll(false);

        m_rTPView.EnableRejectAll(false);

        m_rTPView.EnableClearFormatAll(false);

        // note: enabling is done in EnableControls below

    }

    m_aUsedSeqNo.clear();

    // did something change?

    SwWrtShell* pSh = pView->GetWrtShellPtr();

    if (!pSh)

        return;

    // tdf#162018 keep the selected entry selected

    weld::TreeView& rTreeView = m_pTable->GetWidget();

    const SwRedlineData* pSelectedEntryRedlineData = lcl_get_selected_redlinedata(m_pTable->GetWidget());

    SwRedlineTable::size_type nCount = pSh->GetRedlineCount();

    // check the number of pointers

    for ( SwRedlineTable::size_type i = 0; i < nCount; i++)

    {

        const SwRangeRedline& rRedln = pSh->GetRedline(i);

        if (i >= m_RedlineParents.size())

        {

            // new entries have been appended

            Init(i);

            return;

        }

        SwRedlineDataParent *const pParent = m_RedlineParents[i].get();

        if (&rRedln.GetRedlineData() != pParent->pData)

        {

            // Redline-Parents were inserted, changed or deleted

            i = CalcDiff(i, false);

            if (i == SwRedlineTable::npos)

            {

                lcl_reselect(rTreeView, pSelectedEntryRedlineData);

                return;

            }

            continue;

        }

        const SwRedlineData *pRedlineData = rRedln.GetRedlineData().Next();

        const SwRedlineDataChild *pBackupData = pParent->pNext;

        if (!pRedlineData && pBackupData)

        {

            // Redline-Children were deleted

            i = CalcDiff(i, true);

            if (i == SwRedlineTable::npos)

            {

                lcl_reselect(rTreeView, pSelectedEntryRedlineData);

                return;

            }

            continue;

        }

        else

        {

            while (pRedlineData)

            {

                if (!pBackupData || pRedlineData != pBackupData->pChild)

                {

                    // Redline-Children were inserted, changed or deleted

                    i = CalcDiff(i, true);

                    if (i == SwRedlineTable::npos)

                    {

                        lcl_reselect(rTreeView, pSelectedEntryRedlineData);

                        return;

                    }

                    // here was a continue; targetted to the outer loop

                    // now a break will do, as there is nothing after it in the outer loop

                    break;

                }

                pBackupData = pBackupData->pNext;

                pRedlineData = pRedlineData->Next();

            }

        }

    }

    if (nCount != m_RedlineParents.size())

    {

        // Redlines were deleted at the end

        Init(nCount);

        return;

    }

    // check comment

    bool bIsShowChangesInMargin = SwModule::get()->GetUsrPref(false)->IsShowChangesInMargin();

    for (SwRedlineTable::size_type i = 0; i < nCount; i++)

    {

        const SwRangeRedline& rRedln = pSh->GetRedline(i);

        SwRedlineDataParent *const pParent = m_RedlineParents[i].get();

        if(rRedln.GetComment() != pParent->sComment)

        {

            bool bShowDeletedTextAsComment = bIsShowChangesInMargin &&

                RedlineType::Delete == rRedln.GetType() && rRedln.GetComment().isEmpty();

            const OUString sComment = bShowDeletedTextAsComment

                    ? rRedln.GetDescr()

                    : rRedln.GetComment();

            if (pParent->xTLBParent)

            {

                // update only comment

                rTreeView.set_text(*pParent->xTLBParent, sComment.replace('\n', ' '), 3);

            }

            pParent->sComment = sComment;

        }

    }

    InitAuthors();

    lcl_reselect(rTreeView, pSelectedEntryRedlineData);

    EnableControls(pView);

}

void SwRedlineAcceptDlg::Notify(SfxBroadcaster& /*rBC*/, const SfxHint& rHint)

{

    if (rHint.GetId() == SfxHintId::SwRedlineContentAtPos)

    {

        SwView* pView = GetActiveView();

        if (!pView)

            return;

        SwWrtShell* pSh = pView->GetWrtShellPtr();

        if (!pSh)

            return;

        const SwRangeRedline* pRangeRedline = pSh->GetCurrRedline();

        if (!pRangeRedline)

            return;

        const SwRedlineData& rRedlineData = pRangeRedline->GetRedlineData();

        weld::TreeView& rTreeView = m_pTable->GetWidget();

        rTreeView.all_foreach([&rTreeView, &rRedlineData](weld::TreeIter& rIter) {

            RedlineData* pRedlinData = weld::fromId<RedlineData*>(rTreeView.get_id(rIter));

            const SwRedlineData* pRedlineData;

            if (rTreeView.get_iter_depth(rIter))

                pRedlineData = static_cast<SwRedlineDataChild*>(pRedlinData->pData)->pChild;

            else

                pRedlineData = static_cast<SwRedlineDataParent*>(pRedlinData->pData)->pData;

            if (pRedlineData == &rRedlineData)

            {

                rTreeView.set_cursor(rIter);

                return true;

            }

            return false;

        });

    }

}

SwRedlineTable::size_type SwRedlineAcceptDlg::CalcDiff(SwRedlineTable::size_type nStart, bool bChild)

{

    if (!nStart || m_bHasTrackedColumn)

    {

        Init();

        return SwRedlineTable::npos;

    }

    weld::TreeView& rTreeView = m_pTable->GetWidget();

    rTreeView.freeze();

    SwView *pView = ::GetActiveView();

    if (!pView)

        return SwRedlineTable::npos;

    SwWrtShell* pSh = pView->GetWrtShellPtr();

    if (!pSh)

        return SwRedlineTable::npos;

    bool bHasRedlineAutoFormat = HasRedlineAutoFormat();

    SwRedlineDataParent *const pParent = m_RedlineParents[nStart].get();

    const SwRangeRedline& rRedln = pSh->GetRedline(nStart);

    if (bChild)     // should actually never happen, but just in case...

    {

        // throw away all entry's children and initialise newly

        SwRedlineDataChild* pBackupData = const_cast<SwRedlineDataChild*>(pParent->pNext);

        SwRedlineDataChild* pNext;

        while (pBackupData)

        {

            pNext = const_cast<SwRedlineDataChild*>(pBackupData->pNext);

            if (pBackupData->xTLBChild)

                rTreeView.remove(*pBackupData->xTLBChild);

            auto it = std::find_if(m_RedlineChildren.begin(), m_RedlineChildren.end(),

                [&pBackupData](const std::unique_ptr<SwRedlineDataChild>& rChildPtr) { return rChildPtr.get() == pBackupData; });

            if (it != m_RedlineChildren.end())

                m_RedlineChildren.erase(it);

            pBackupData = pNext;

        }

        pParent->pNext = nullptr;

        // insert new children

        InsertChildren(pParent, rRedln, bHasRedlineAutoFormat);

        rTreeView.thaw();

        return nStart;

    }

    // have entries been deleted?

    const SwRedlineData *pRedlineData = &rRedln.GetRedlineData();

    for (SwRedlineTable::size_type i = nStart + 1; i < m_RedlineParents.size(); i++)

    {

        if (m_RedlineParents[i]->pData == pRedlineData)

        {

            // remove entries from nStart to i-1

            RemoveParents(nStart, i - 1);

            rTreeView.thaw();

            return nStart - 1;

        }

    }

    // entries been inserted?

    SwRedlineTable::size_type nCount = pSh->GetRedlineCount();

    pRedlineData = m_RedlineParents[nStart]->pData;

    for (SwRedlineTable::size_type i = nStart + 1; i < nCount; i++)

    {

        if (&pSh->GetRedline(i).GetRedlineData() == pRedlineData)

        {

            rTreeView.thaw();

            // insert entries from nStart to i-1

            InsertParents(nStart, i - 1);

            return nStart - 1;

        }

    }

    rTreeView.thaw();

    Init(nStart);   // adjust all entries until the end

    return SwRedlineTable::npos;

}

void SwRedlineAcceptDlg::InsertChildren(SwRedlineDataParent *pParent, const SwRangeRedline& rRedln, bool bHasRedlineAutoFormat)

{

    SwRedlineDataChild *pLastRedlineChild = nullptr;

    const SwRedlineData *pRedlineData = &rRedln.GetRedlineData();

    bool bAutoFormatRedline = rRedln.IsAutoFormat();

    weld::TreeView& rTreeView = m_pTable->GetWidget();

    OUString sAction = GetActionText(rRedln);

    bool bValidParent = m_sFilterAction.isEmpty() || m_sFilterAction == sAction;

    bValidParent = bValidParent && m_pTable->IsValidEntry(rRedln.GetAuthorString(), rRedln.GetTimeStamp(), rRedln.GetComment());

    if (bHasRedlineAutoFormat)

    {

        if (pParent->pData->GetSeqNo())

        {

            std::pair<SwRedlineDataParentSortArr::const_iterator,bool> const ret

                = m_aUsedSeqNo.insert(pParent);

            if (ret.second) // already there

            {

                if (pParent->xTLBParent)

                {

                    rTreeView.set_text(*(*ret.first)->xTLBParent, m_sAutoFormat, 0);

                    rTreeView.remove(*pParent->xTLBParent);

                    pParent->xTLBParent.reset();

                }

                return;

            }

        }

        bValidParent = bValidParent && bAutoFormatRedline;

    }

    bool bValidTree = bValidParent;

    for (sal_uInt16 nStack = 1; nStack < rRedln.GetStackCount(); nStack++)

    {

        pRedlineData = pRedlineData->Next();

        SwRedlineDataChild* pRedlineChild = new SwRedlineDataChild;

        pRedlineChild->pChild = pRedlineData;

        m_RedlineChildren.push_back(std::unique_ptr<SwRedlineDataChild>(pRedlineChild));

        if ( pLastRedlineChild )

            pLastRedlineChild->pNext = pRedlineChild;

        else

            pParent->pNext = pRedlineChild;

        sAction = GetActionText(rRedln, nStack);

        bool bValidChild = m_sFilterAction.isEmpty() || m_sFilterAction == sAction;

        bValidChild = bValidChild && m_pTable->IsValidEntry(rRedln.GetAuthorString(nStack), rRedln.GetTimeStamp(nStack), rRedln.GetComment());

        if (bHasRedlineAutoFormat)

            bValidChild = bValidChild && bAutoFormatRedline;

        bValidTree |= bValidChild;

        if (bValidChild)

        {

            std::unique_ptr<RedlineData> pData(new RedlineData);

            pData->pData = pRedlineChild;

            pData->bDisabled = true;

            OUString sImage(GetActionImage(rRedln, nStack));

            const OUString& sAuthor = rRedln.GetAuthorString(nStack);

            pData->aDateTime = rRedln.GetTimeStamp(nStack);

            pData->eType = rRedln.GetType(nStack);

            OUString sDateEntry = GetAppLangDateTimeString(pData->aDateTime);

            const OUString& sComment = rRedln.GetComment(nStack);

            std::unique_ptr<weld::TreeIter> xChild(rTreeView.make_iterator());

            OUString sId(weld::toId(pData.get()));

            rTreeView.insert(pParent->xTLBParent.get(), -1, nullptr, &sId, nullptr, nullptr,

                             false, xChild.get());

            m_RedlineData.push_back(std::move(pData));

            rTreeView.set_image(*xChild, sImage, -1);

            rTreeView.set_text(*xChild, sAuthor, 1);

            rTreeView.set_text(*xChild, sDateEntry, 2);

            rTreeView.set_text(*xChild, sComment, 3);

            pRedlineChild->xTLBChild = std::move(xChild);

            if (!bValidParent)

                rTreeView.expand_row(*pParent->xTLBParent);

        }

        else

            pRedlineChild->xTLBChild.reset();

        pLastRedlineChild = pRedlineChild;

    }

    if (pLastRedlineChild)

        pLastRedlineChild->pNext = nullptr;

    if (!bValidTree && pParent->xTLBParent)

    {

        rTreeView.remove(*pParent->xTLBParent);

        pParent->xTLBParent.reset();

        if (bHasRedlineAutoFormat)

            m_aUsedSeqNo.erase(pParent);

    }

}

void SwRedlineAcceptDlg::RemoveParents(SwRedlineTable::size_type nStart, SwRedlineTable::size_type nEnd)

{

    SwView *pView = ::GetActiveView();

    if (!pView)

        return;

    SwWrtShell* pSh = pView->GetWrtShellPtr();

    if (!pSh)

        return;

    SwRedlineTable::size_type nCount = pSh->GetRedlineCount();

    std::vector<const weld::TreeIter*> aLBoxArr;

    weld::TreeView& rTreeView = m_pTable->GetWidget();

    // because of Bug of TLB that ALWAYS calls the SelectHandler at Remove:

    rTreeView.connect_selection_changed(Link<weld::ItemView&, void>());

    bool bChildrenRemoved = false;

    rTreeView.thaw();

    rTreeView.unselect_all();

    // set the cursor after the last entry because otherwise performance problem in TLB.

    // TLB would otherwise reset the cursor at every Remove (expensive)

    SwRedlineTable::size_type nPos = std::min(nCount, m_RedlineParents.size());

    weld::TreeIter *pCurEntry = nullptr;

    while( ( pCurEntry == nullptr ) && ( nPos > 0 ) )

    {

        --nPos;

        pCurEntry = m_RedlineParents[nPos]->xTLBParent.get();

    }

    if (pCurEntry)

        rTreeView.set_cursor(*pCurEntry);

    rTreeView.freeze();

    for (SwRedlineTable::size_type i = nStart; i <= nEnd; i++)

    {

        if (!bChildrenRemoved && m_RedlineParents[i]->pNext)

        {

            SwRedlineDataChild * pChildPtr =

                const_cast<SwRedlineDataChild*>(m_RedlineParents[i]->pNext);

            auto it = std::find_if(m_RedlineChildren.begin(), m_RedlineChildren.end(),

                [&pChildPtr](const std::unique_ptr<SwRedlineDataChild>& rChildPtr) { return rChildPtr.get() == pChildPtr; });

            if (it != m_RedlineChildren.end())

            {

                sal_uInt16 nChildren = 0;

                while (pChildPtr)

                {

                    pChildPtr = const_cast<SwRedlineDataChild*>(pChildPtr->pNext);

                    nChildren++;

                }