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

#include <boost/property_tree/json_parser.hpp>

#include <PostItMgr.hxx>

#include <postithelper.hxx>

#include <AnnotationWin.hxx>

#include "frmsidebarwincontainer.hxx"

#include <accmap.hxx>

#include <SidebarWindowsConsts.hxx>

#include "AnchorOverlayObject.hxx"

#include "ShadowOverlayObject.hxx"

#include <utility>

#include <vcl/svapp.hxx>

#include <vcl/outdev.hxx>

#include <vcl/settings.hxx>

#include <chrdlgmodes.hxx>

#include <viewopt.hxx>

#include <view.hxx>

#include <docsh.hxx>

#include <wrtsh.hxx>

#include <doc.hxx>

#include <IDocumentSettingAccess.hxx>

#include <IDocumentFieldsAccess.hxx>

#include <IDocumentRedlineAccess.hxx>

#if ENABLE_YRS

#include <IDocumentState.hxx>

#endif

#include <docstyle.hxx>

#include <fldbas.hxx>

#include <fmtfld.hxx>

#include <docufld.hxx>

#include <edtwin.hxx>

#include <txtfld.hxx>

#include <txtannotationfld.hxx>

#include <rootfrm.hxx>

#include <SwRewriter.hxx>

#include <tools/color.hxx>

#include <unotools/datetime.hxx>

#include <swmodule.hxx>

#include <strings.hrc>

#include <cmdid.h>

#include <sfx2/docfile.hxx>

#include <sfx2/docfilt.hxx>

#include <sfx2/request.hxx>

#include <sfx2/event.hxx>

#include <svl/srchitem.hxx>

#include <svl/languageoptions.hxx>

#include <svl/hint.hxx>

#include <svx/svdview.hxx>

#include <editeng/eeitem.hxx>

#include <editeng/langitem.hxx>

#include <editeng/outliner.hxx>

#include <editeng/outlobj.hxx>

#include <comphelper/lok.hxx>

#include <comphelper/string.hxx>

#include <officecfg/Office/Writer.hxx>

#include <LibreOfficeKit/LibreOfficeKitEnums.h>

#include <annotsh.hxx>

#include <swabstdlg.hxx>

#include <pagefrm.hxx>

#include <officecfg/Office/Common.hxx>

#include <memory>

// distance between Anchor Y and initial note position

#define POSTIT_INITIAL_ANCHOR_DISTANCE      20

//distance between two postits

#define POSTIT_SPACE_BETWEEN                8

#define POSTIT_MINIMUMSIZE_WITH_META        60

#define POSTIT_SCROLL_SIDEBAR_HEIGHT        20

// if we layout more often we stop, this should never happen

#define MAX_LOOP_COUNT                      50

using namespace sw::sidebarwindows;

using namespace sw::annotation;

namespace {

    enum class CommentNotificationType { Add, Remove, Modify, Resolve, SearchHighlight, RedlinedDeletion };

    bool comp_pos(const std::unique_ptr<SwAnnotationItem>& a, const std::unique_ptr<SwAnnotationItem>& b)

    {

        // sort by anchor position

        SwPosition aPosAnchorA = a->GetAnchorPosition();

        SwPosition aPosAnchorB = b->GetAnchorPosition();

        bool aAnchorAInFooter = false;

        bool aAnchorBInFooter = false;

        // is the anchor placed in Footnote or the Footer?

        if( aPosAnchorA.GetNode().FindFootnoteStartNode() || aPosAnchorA.GetNode().FindFooterStartNode() )

            aAnchorAInFooter = true;

        if( aPosAnchorB.GetNode().FindFootnoteStartNode() || aPosAnchorB.GetNode().FindFooterStartNode() )

            aAnchorBInFooter = true;

        // fdo#34800

        // if AnchorA is in footnote, and AnchorB isn't

        // we do not want to change over the position

        if( aAnchorAInFooter && !aAnchorBInFooter )

            return false;

        // if aAnchorA is not placed in a footnote, and aAnchorB is

        // force a change over

        else if( !aAnchorAInFooter && aAnchorBInFooter )

            return true;

        // If neither or both are in the footer, compare the positions.

        // Since footnotes are in Inserts section of nodes array and footers

        // in Autotext section, all footnotes precede any footers so no need

        // to check that.

        else

            return aPosAnchorA < aPosAnchorB;

    }

    /// Emits LOK notification about one addition/removal/change of a comment

    void lcl_CommentNotification(const SwView* pView, const CommentNotificationType nType, const SwAnnotationItem* pItem, const sal_uInt32 nPostItId)

    {

        if (!comphelper::LibreOfficeKit::isActive())

            return;

        boost::property_tree::ptree aAnnotation;

        aAnnotation.put("action", (nType == CommentNotificationType::Add ? "Add" :

                                   (nType == CommentNotificationType::Remove ? "Remove" :

                                    (nType == CommentNotificationType::Modify ? "Modify" :

                                     (nType == CommentNotificationType::RedlinedDeletion ? "RedlinedDeletion" :

                                      (nType == CommentNotificationType::SearchHighlight ? "SearchHighlight" :

                                       (nType == CommentNotificationType::Resolve ? "Resolve" : "???")))))));

        aAnnotation.put("id", nPostItId);

        if (nType != CommentNotificationType::Remove && pItem != nullptr)

        {

            sw::annotation::SwAnnotationWin* pWin = pItem->mpPostIt.get();

            const SwPostItField* pField = pWin->GetPostItField();

            const SwRect& aRect = pWin->GetAnchorRect();

            tools::Rectangle aSVRect(aRect.Pos().getX(),

                                    aRect.Pos().getY(),

                                    aRect.Pos().getX() + aRect.SSize().Width(),

                                    aRect.Pos().getY() + aRect.SSize().Height());

            if (!pItem->maLayoutInfo.mPositionFromCommentAnchor)

            {

                // Comments on frames: anchor position is the corner position, not the whole frame.

                aSVRect.SetSize(Size(0, 0));

            }

            std::vector<OString> aRects;

            for (const basegfx::B2DRange& aRange : pWin->GetAnnotationTextRanges())

            {

                const SwRect rect(aRange.getMinX(), aRange.getMinY(), aRange.getWidth(), aRange.getHeight());

                aRects.push_back(rect.SVRect().toString());

            }

            const OString sRects = comphelper::string::join("; ", aRects);

            aAnnotation.put("id", pField->GetPostItId());

            aAnnotation.put("parentId", pField->GetParentPostItId());

            aAnnotation.put("author", pField->GetPar1().toUtf8().getStr());

            // Note, for just plain text we could use "text" populated by pField->GetPar2()

            aAnnotation.put("html", pWin->GetSimpleHtml());

            aAnnotation.put("resolved", pField->GetResolved() ? "true" : "false");

            aAnnotation.put("dateTime", utl::toISO8601(pField->GetDateTime().GetUNODateTime()));

            aAnnotation.put("anchorPos", aSVRect.toString());

            aAnnotation.put("textRange", sRects.getStr());

            aAnnotation.put("layoutStatus", pItem->mLayoutStatus);

            if (nType == CommentNotificationType::SearchHighlight)

            {

                ESelection aSel = pWin->GetOutlinerView()->GetSelection();

                OString sSelStr = OString::Concat(OString::number(aSel.start.nPara)) + ","

                                  + OString::number(aSel.start.nIndex) + ","

                                  + OString::number(aSel.end.nPara) + ","

                                  + OString::number(aSel.end.nIndex);

                aAnnotation.put("searchSelection", sSelStr);

            }

        }

        if (nType == CommentNotificationType::Remove && comphelper::LibreOfficeKit::isActive())

        {

            // Redline author is basically the author which has made the modification rather than author of the comments

            // This is important to know who removed the comment

            aAnnotation.put("author", SwModule::get()->GetRedlineAuthor(SwModule::get()->GetRedlineAuthor()));

        }

        boost::property_tree::ptree aTree;

        aTree.add_child("comment", aAnnotation);

        std::stringstream aStream;

        boost::property_tree::write_json(aStream, aTree);

        std::string aPayload = aStream.str();

        if (pView)

        {

            pView->libreOfficeKitViewCallback(LOK_CALLBACK_COMMENT, OString(aPayload));

        }

    }

    class FilterFunctor

    {

    public:

        virtual bool operator()(const SwFormatField* pField) const = 0;

        virtual ~FilterFunctor() {}

    };

    class IsPostitField : public FilterFunctor

    {

    public:

        bool operator()(const SwFormatField* pField) const override

        {

            return pField->GetField()->GetTyp()->Which() == SwFieldIds::Postit;

        }

    };

    class IsPostitFieldWithAuthorOf : public FilterFunctor

    {

        OUString m_sAuthor;

    public:

        explicit IsPostitFieldWithAuthorOf(OUString aAuthor)

            : m_sAuthor(std::move(aAuthor))

        {

        }

        bool operator()(const SwFormatField* pField) const override

        {

            if (pField->GetField()->GetTyp()->Which() != SwFieldIds::Postit)

                return false;

            return static_cast<const SwPostItField*>(pField->GetField())->GetPar1() == m_sAuthor;

        }

    };

    class IsPostitFieldWithPostitId : public FilterFunctor

    {

        sal_uInt32 m_nPostItId;

    public:

        explicit IsPostitFieldWithPostitId(sal_uInt32 nPostItId)

            : m_nPostItId(nPostItId)

            {}

        bool operator()(const SwFormatField* pField) const override

        {

            if (pField->GetField()->GetTyp()->Which() != SwFieldIds::Postit)

                return false;

            return static_cast<const SwPostItField*>(pField->GetField())->GetPostItId() == m_nPostItId;

        }

    };

    class IsFieldNotDeleted : public FilterFunctor

    {

    private:

        IDocumentRedlineAccess const& m_rIDRA;

        FilterFunctor const& m_rNext;

    public:

        IsFieldNotDeleted(IDocumentRedlineAccess const& rIDRA,

                const FilterFunctor & rNext)

            : m_rIDRA(rIDRA)

            , m_rNext(rNext)

        {

        }

        bool operator()(const SwFormatField* pField) const override

        {

            if (!m_rNext(pField))

                return false;

            if (!pField->GetTextField())

                return false;

            return !sw::IsFieldDeletedInModel(m_rIDRA, *pField->GetTextField());

        }

    };

    //Manages the passed in vector by automatically removing entries if they are deleted

    //and automatically adding entries if they appear in the document and match the

    //functor.

    //

    //This will completely refill in the case of a "anonymous" NULL pField stating

    //rather unhelpfully that "something changed" so you may process the same

    //Fields more than once.

    class FieldDocWatchingStack : public SfxListener

    {

        std::vector<std::unique_ptr<SwAnnotationItem>>& m_aSidebarItems;

        std::vector<const SwFormatField*> m_aFormatFields;

        SwDocShell& m_rDocShell;

        FilterFunctor& m_rFilter;

        virtual void Notify(SfxBroadcaster&, const SfxHint& rHint) override

        {

            if ( rHint.GetId() != SfxHintId::SwFormatField )

                return;

            const SwFormatFieldHint* pHint = static_cast<const SwFormatFieldHint*>(&rHint);

            bool bAllInvalidated = false;

            if (pHint->Which() == SwFormatFieldHintWhich::REMOVED)

            {

                const SwFormatField* pField = pHint->GetField();

                bAllInvalidated = pField == nullptr;

                if (!bAllInvalidated && m_rFilter(pField))

                {

                    EndListening(const_cast<SwFormatField&>(*pField));

                    std::erase(m_aFormatFields, pField);

                }

            }

            else if (pHint->Which() == SwFormatFieldHintWhich::INSERTED)

            {

                const SwFormatField* pField = pHint->GetField();

                bAllInvalidated = pField == nullptr;

                if (!bAllInvalidated && m_rFilter(pField))

                {

                    StartListening(const_cast<SwFormatField&>(*pField));

                    m_aFormatFields.push_back(pField);

                }

            }

            if (bAllInvalidated)

                FillVector();

            return;

        }

    public:

        FieldDocWatchingStack(std::vector<std::unique_ptr<SwAnnotationItem>>& in, SwDocShell &rDocShell, FilterFunctor& rFilter)

            : m_aSidebarItems(in)

            , m_rDocShell(rDocShell)

            , m_rFilter(rFilter)

        {

            FillVector();

            StartListening(m_rDocShell);

        }

        void FillVector()

        {

            EndListeningToAllFields();

            m_aFormatFields.clear();

            m_aFormatFields.reserve(m_aSidebarItems.size());

            for (auto const& p : m_aSidebarItems)

            {

                const SwFormatField& rField = p->GetFormatField();

                if (!m_rFilter(&rField))

                    continue;

                StartListening(const_cast<SwFormatField&>(rField));

                m_aFormatFields.push_back(&rField);

            }

        }

        void EndListeningToAllFields()

        {

            for (auto const& pField : m_aFormatFields)

            {

                EndListening(const_cast<SwFormatField&>(*pField));

            }

        }

        virtual ~FieldDocWatchingStack() override

        {

            EndListeningToAllFields();

            EndListening(m_rDocShell);

        }

        const SwFormatField* pop()

        {

            if (m_aFormatFields.empty())

                return nullptr;

            const SwFormatField* p = m_aFormatFields.back();

            EndListening(const_cast<SwFormatField&>(*p));

            m_aFormatFields.pop_back();

            return p;

        }

    };

// a RAII object that sets Ignore redline flag, and restores previous redline flags in dtor

class CommentDeleteFlagsRestoreImpl : public SwPostItMgr::CommentDeleteFlagsRestore

{

public:

    CommentDeleteFlagsRestoreImpl(SwWrtShell* shell)

        : m_pWrtShell(shell)

        , m_eRestreFlags(m_pWrtShell->GetRedlineFlags())

    {

        m_pWrtShell->SetRedlineFlags(m_eRestreFlags | RedlineFlags::Ignore);

    }

    ~CommentDeleteFlagsRestoreImpl() { m_pWrtShell->SetRedlineFlags(m_eRestreFlags); }

private:

    SwWrtShell* m_pWrtShell;

    RedlineFlags m_eRestreFlags;

};

bool isOwnFileFormat(SfxMedium* pMedium)

{

    // Assume that unsaved documents are own format

    return !pMedium || !pMedium->GetFilter() || pMedium->GetFilter()->IsOwnFormat();

}

} // anonymous namespace

SwPostItMgr::SwPostItMgr(SwView* pView)

    : mpView(pView)

    , mpWrtShell(mpView->GetDocShell()->GetWrtShell())

    , mpEditWin(&mpView->GetEditWin())

    , mnEventId(nullptr)

    , mbWaitingForCalcRects(false)

    , mpActivePostIt(nullptr)

    , mbLayout(false)

    , mbLayoutHeight(0)

    , mbLayouting(false)

    , mbReadOnly(mpView->GetDocShell()->IsReadOnly())

    , mbDeleteNote(true)

{

    if(!mpView->GetDrawView() )

        mpView->GetWrtShell().MakeDrawView();

    //make sure we get the colour yellow always, even if not the first one of comments or redlining

    SwModule::get()->GetRedlineAuthor();

    // collect all PostIts and redline comments that exist after loading the document

    // don't check for existence for any of them, don't focus them

    AddPostIts(false,false);

    /*  this code can be used once we want redline comments in the Sidebar

    AddRedlineComments(false,false);

    */

    // we want to receive stuff like SfxHintId::DocChanged

    StartListening(*mpView->GetDocShell());

    // listen to stylesheet pool to update on stylesheet rename,

    // as EditTextObject references styles by name.

    SfxStyleSheetBasePool* pStyleSheetPool = mpView->GetDocShell()->GetStyleSheetPool();

    if (pStyleSheetPool)

        StartListening(*static_cast<SwDocStyleSheetPool*>(pStyleSheetPool)->GetEEStyleSheetPool());

    if (!mvPostItFields.empty())

    {

        mbWaitingForCalcRects = true;

        mnEventId = Application::PostUserEvent( LINK( this, SwPostItMgr, CalcHdl) );

    }

}

SwPostItMgr::~SwPostItMgr()

{

    if ( mnEventId )

        Application::RemoveUserEvent( mnEventId );

    // forget about all our Sidebar windows

    RemoveSidebarWin();

    EndListeningAll();

    mPages.clear();

}

bool SwPostItMgr::CheckForRemovedPostIts()

{

    IDocumentRedlineAccess const& rIDRA(mpWrtShell->getIDocumentRedlineAccess());

    bool bRemoved = false;

    auto it = mvPostItFields.begin();

    while(it != mvPostItFields.end())

    {

        if (!(*it)->UseElement(*mpWrtShell->GetLayout(), rIDRA))

        {

            EndListening(const_cast<SfxBroadcaster&>(*(*it)->GetBroadcaster()));

            if((*it)->mpPostIt && (*it)->mpPostIt->GetPostItField())

                lcl_CommentNotification(mpView, CommentNotificationType::Remove, nullptr, (*it)->mpPostIt->GetPostItField()->GetPostItId());

            std::unique_ptr<SwAnnotationItem> p = std::move(*it);

            it = mvPostItFields.erase(it);

            if (GetActiveSidebarWin() == p->mpPostIt)

                SetActiveSidebarWin(nullptr);

            p->mpPostIt.disposeAndClear();

            if (comphelper::LibreOfficeKit::isActive() && !comphelper::LibreOfficeKit::isTiledAnnotations())

            {

                const SwPostItField* pPostItField = static_cast<const SwPostItField*>(p->GetFormatField().GetField());

                lcl_CommentNotification(mpView, CommentNotificationType::Remove, nullptr, pPostItField->GetPostItId());

            }

            bRemoved = true;

        }

        else

            ++it;

    }

    if ( !bRemoved )

        return false;

    // make sure that no deleted items remain in page lists

    // todo: only remove deleted ones?!

    if ( mvPostItFields.empty() )

    {

        PreparePageContainer();

        PrepareView();

    }

    else

    {

        // if postits are there make sure that page lists are not empty

        // otherwise sudden paints can cause pain (in BorderOverPageBorder)

        CalcRects();

    }

    return true;

}

SwAnnotationItem* SwPostItMgr::InsertItem(SfxBroadcaster* pItem, bool bCheckExistence, bool bFocus)

{

    if (bCheckExistence)

    {

        for (auto const& postItField : mvPostItFields)

        {

            if ( postItField->GetBroadcaster() == pItem )

                return nullptr;

        }

    }

    mbLayout = bFocus;

    SwAnnotationItem* pAnnotationItem = nullptr;

    if (auto pSwFormatField = dynamic_cast< SwFormatField *>( pItem ))

    {

        IsPostitField isPostitField;

        if (!isPostitField(pSwFormatField))

            return nullptr;

        mvPostItFields.push_back(std::make_unique<SwAnnotationItem>(*pSwFormatField, bFocus));

        pAnnotationItem = mvPostItFields.back().get();

    }

    assert(dynamic_cast< const SwFormatField *>( pItem ) && "Mgr::InsertItem: seems like new stuff was added");

    StartListening(*pItem);

    return pAnnotationItem;

}

sw::annotation::SwAnnotationWin* SwPostItMgr::GetRemovedAnnotationWin( const SfxBroadcaster* pBroadcast )

{

    auto i = std::find_if(mvPostItFields.begin(), mvPostItFields.end(),

        [&pBroadcast](const std::unique_ptr<SwAnnotationItem>& pField) { return pField->GetBroadcaster() == pBroadcast; });

    if (i != mvPostItFields.end())

    {

        return (*i)->mpPostIt;

    }

    return nullptr;

}

void SwPostItMgr::RemoveItem( SfxBroadcaster* pBroadcast )

{

    EndListening(*pBroadcast);

    auto i = std::find_if(mvPostItFields.begin(), mvPostItFields.end(),

        [&pBroadcast](const std::unique_ptr<SwAnnotationItem>& pField) { return pField->GetBroadcaster() == pBroadcast; });

    if (i != mvPostItFields.end())

    {

#if ENABLE_YRS

        // note: (*i)->mpPostIt may be null here, if it's in hidden text - see testMissingDefaultLineColor

        mpView->GetDocShell()->GetDoc()->getIDocumentState().YrsRemoveComment(

            (*i)->GetAnchorPosition());

#endif

        std::unique_ptr<SwAnnotationItem> p = std::move(*i);

        // tdf#120487 remove from list before dispose, so comment window

        // won't be recreated due to the entry still in the list if focus

        // transferring from the pPostIt triggers relayout of postits

        // tdf#133348 remove from list before calling SetActiveSidebarWin

        // so GetNextPostIt won't deal with mvPostItFields containing empty unique_ptr

        mvPostItFields.erase(i);

        if (GetActiveSidebarWin() == p->mpPostIt)

            SetActiveSidebarWin(nullptr);

        p->mpPostIt.disposeAndClear();

    }

    mbLayout = true;

    PrepareView();

}

void SwPostItMgr::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )

{

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

    {

        const SfxEventHint& rSfxEventHint = static_cast<const SfxEventHint&>(rHint);

        if (rSfxEventHint.GetEventId() == SfxEventHintId::SwEventLayoutFinished)

        {

            if ( !mbWaitingForCalcRects && !mvPostItFields.empty())

            {

                mbWaitingForCalcRects = true;

                mnEventId = Application::PostUserEvent( LINK( this, SwPostItMgr, CalcHdl) );

            }

        }

    }

    else if ( rHint.GetId() == SfxHintId::SwFormatField )

    {

        const SwFormatFieldHint * pFormatHint = static_cast<const SwFormatFieldHint*>(&rHint);

        SwFormatField* pField = const_cast <SwFormatField*>( pFormatHint->GetField() );

        switch ( pFormatHint->Which() )

        {

            case SwFormatFieldHintWhich::INSERTED :

            {

                if (!pField)

                {

                    AddPostIts();

                    break;

                }

                // get field to be inserted from hint

                if ( pField->IsFieldInDoc() )

                {

                    bool bEmpty = !HasNotes();

                    SwAnnotationItem* pItem = InsertItem( pField, true, false );

                    if (bEmpty && !mvPostItFields.empty())

                        PrepareView(true);

                    // True until the layout of this post it finishes

                    if (pItem)

                        pItem->mbPendingLayout = true;

                }

                else

                {

                    OSL_FAIL("Inserted field not in document!" );

                }

                break;

            }

            case SwFormatFieldHintWhich::REMOVED:

            case SwFormatFieldHintWhich::REDLINED_DELETION:

            {

                if (mbDeleteNote)

                {

                    if (!pField)

                    {

                        const bool bWasRemoved = CheckForRemovedPostIts();

                        // tdf#143643 ensure relayout on undo of insert comment

                        if (bWasRemoved)

                            mbLayout = true;

                        break;

                    }

                    this->Broadcast(rHint);

                    RemoveItem(pField);

                    // If LOK has disabled tiled annotations, emit annotation callbacks

                    if (comphelper::LibreOfficeKit::isActive() && !comphelper::LibreOfficeKit::isTiledAnnotations())

                    {

                        SwPostItField* pPostItField = static_cast<SwPostItField*>(pField->GetField());

                        auto type = pFormatHint->Which() == SwFormatFieldHintWhich::REMOVED ? CommentNotificationType::Remove: CommentNotificationType::RedlinedDeletion;

                        lcl_CommentNotification(mpView, type, nullptr, pPostItField->GetPostItId());

                    }

                }

                break;

            }

            case SwFormatFieldHintWhich::FOCUS:

            {

                if (pFormatHint->GetView()== mpView)

                    Focus(rBC);

                break;

            }

            case SwFormatFieldHintWhich::CHANGED:

            case SwFormatFieldHintWhich::RESOLVED:

            {

                SwFormatField* pFormatField = dynamic_cast<SwFormatField*>(&rBC);

                for (auto const& postItField : mvPostItFields)

                {

                    if ( pFormatField == postItField->GetBroadcaster() )

                    {

                        if (postItField->mpPostIt)

                        {

                            postItField->mpPostIt->SetPostItText();

                            mbLayout = true;

                            this->Forward(rBC, rHint);

                        }

                        // If LOK has disabled tiled annotations, emit annotation callbacks

                        if (comphelper::LibreOfficeKit::isActive() && !comphelper::LibreOfficeKit::isTiledAnnotations())

                        {

                            if(SwFormatFieldHintWhich::CHANGED == pFormatHint->Which())

                                lcl_CommentNotification(mpView, CommentNotificationType::Modify, postItField.get(), 0);

                            else

                                lcl_CommentNotification(mpView, CommentNotificationType::Resolve, postItField.get(), 0);

                        }

                        break;

                    }

                }

                break;

            }

        }

    }

    else if ( rHint.GetId() == SfxHintId::StyleSheetModifiedExtended )

    {

        const SfxStyleSheetModifiedHint * pStyleHint = static_cast<const SfxStyleSheetModifiedHint*>(&rHint);

        for (const auto& postItField : mvPostItFields)

        {

            auto pField = static_cast<SwPostItField*>(postItField->GetFormatField().GetField());

            pField->ChangeStyleSheetName(pStyleHint->GetOldName(), pStyleHint->GetStyleSheet());

        }

    }

    else

    {

        SfxHintId nId = rHint.GetId();

        switch ( nId )

        {

            case SfxHintId::ModeChanged:

            {

                if ( mbReadOnly != mpView->GetDocShell()->IsReadOnly() )

                {

                    mbReadOnly = !mbReadOnly;

                    SetReadOnlyState();

                    mbLayout = true;

                }

                break;

            }

            case SfxHintId::DocChanged:

            {

                if ( mpView->GetDocShell() == &rBC )

                {

                    if ( !mbWaitingForCalcRects && !mvPostItFields.empty())

                    {

                        mbWaitingForCalcRects = true;

                        mnEventId = Application::PostUserEvent( LINK( this, SwPostItMgr, CalcHdl) );

                    }

                }

                break;

            }

            case SfxHintId::LanguageChanged:

            {

                SetSpellChecking();

                break;

            }

            case SfxHintId::SwSplitNodeOperation:

            {

                // if we are in a SplitNode/Cut operation, do not delete note and then add again, as this will flicker

                mbDeleteNote = !mbDeleteNote;

                break;

            }

            case SfxHintId::Dying:

            {

                if ( mpView->GetDocShell() != &rBC )

                {

                    // field to be removed is the broadcaster

                    OSL_FAIL("Notification for removed SwFormatField was not sent!");

                    RemoveItem(&rBC);

                }

                break;

            }

            default: break;

        }

    }

}

void SwPostItMgr::Focus(const SfxBroadcaster& rBC)

{

    if (!mpWrtShell->GetViewOptions()->IsPostIts())

    {

        SfxRequest aRequest(mpView->GetViewFrame(), SID_TOGGLE_NOTES);

        mpView->ExecViewOptions(aRequest);

    }

    for (auto const& postItField : mvPostItFields)

    {

        // field to get the focus is the broadcaster

        if ( &rBC == postItField->GetBroadcaster() )

        {

            if (postItField->mpPostIt)

            {

                if (postItField->mpPostIt->IsResolved() &&

                        !mpWrtShell->GetViewOptions()->IsResolvedPostIts())

                {

                    SfxRequest aRequest(mpView->GetViewFrame(), SID_TOGGLE_RESOLVED_NOTES);

                    mpView->ExecViewOptions(aRequest);

                }

                postItField->mpPostIt->GrabFocus();

                MakeVisible(postItField->mpPostIt);

            }

            else

            {

                // when the layout algorithm starts, this postit is created and receives focus

                postItField->mbFocus = true;

            }

        }

    }

}

bool SwPostItMgr::CalcRects()

{

    if ( mnEventId )

    {

        // if CalcRects() was forced and an event is still pending: remove it

        // it is superfluous and also may cause reentrance problems if triggered while layouting

        Application::RemoveUserEvent( mnEventId );

        mnEventId = nullptr;

    }

    bool bChange = false;

    bool bRepair = false;

    PreparePageContainer();

    if ( !mvPostItFields.empty() )

    {

        IDocumentRedlineAccess const& rIDRA(mpWrtShell->getIDocumentRedlineAccess());

        for (auto const& pItem : mvPostItFields)

        {

            if (!pItem->UseElement(*mpWrtShell->GetLayout(), rIDRA))

            {

                OSL_FAIL("PostIt is not in doc or other wrong use");

                bRepair = true;

                continue;

            }

            const SwRect aOldAnchorRect( pItem->maLayoutInfo.mPosition );

            const SwPostItHelper::SwLayoutStatus eOldLayoutStatus = pItem->mLayoutStatus;

            const SwNodeOffset nOldStartNodeIdx( pItem->maLayoutInfo.mnStartNodeIdx );

            const sal_Int32 nOldStartContent( pItem->maLayoutInfo.mnStartContent );

            {

                // update layout information

                const SwTextAnnotationField* pTextAnnotationField =

                    dynamic_cast< const SwTextAnnotationField* >( pItem->GetFormatField().GetTextField() );

                const ::sw::mark::MarkBase* pAnnotationMark =

                    pTextAnnotationField != nullptr ? pTextAnnotationField->GetAnnotationMark() : nullptr;

                if ( pAnnotationMark != nullptr )

                {

                    pItem->mLayoutStatus =

                        SwPostItHelper::getLayoutInfos(

                            pItem->maLayoutInfo,

                            pItem->GetAnchorPosition(),

                            pAnnotationMark );

                }

                else

                {

                    pItem->mLayoutStatus =

                        SwPostItHelper::getLayoutInfos( pItem->maLayoutInfo, pItem->GetAnchorPosition() );

                }

            }

            bChange = bChange

                      || pItem->maLayoutInfo.mPosition != aOldAnchorRect

                      || pItem->mLayoutStatus != eOldLayoutStatus

                      || pItem->maLayoutInfo.mnStartNodeIdx != nOldStartNodeIdx

                      || pItem->maLayoutInfo.mnStartContent != nOldStartContent;

        }

        // show notes in right order in navigator

        //prevent Anchors during layout to overlap, e.g. when moving a frame

        if (mvPostItFields.size()>1 )

            std::stable_sort(mvPostItFields.begin(), mvPostItFields.end(), comp_pos);

        // sort the items into the right page vector, so layout can be done by page

        for (auto const& pItem : mvPostItFields)

        {

            if( SwPostItHelper::INVISIBLE == pItem->mLayoutStatus )

            {

                if (pItem->mpPostIt)

                    pItem->mpPostIt->HideNote();

                continue;

            }

            if( SwPostItHelper::HIDDEN == pItem->mLayoutStatus )

            {

                if (!mpWrtShell->GetViewOptions()->IsShowHiddenChar())

                {

                    if (pItem->mpPostIt)

                        pItem->mpPostIt->HideNote();

                    continue;

                }

            }

            const tools::ULong aPageNum = pItem->maLayoutInfo.mnPageNumber;

            if (aPageNum > mPages.size())

            {

                const tools::ULong nNumberOfPages = mPages.size();

                mPages.reserve(aPageNum);

                for (tools::ULong j=0; j<aPageNum - nNumberOfPages; ++j)

                    mPages.emplace_back( new SwPostItPageItem());

            }

            mPages[aPageNum-1]->mvSidebarItems.push_back(pItem.get());

            mPages[aPageNum-1]->mPageRect = pItem->maLayoutInfo.mPageFrame;

            mPages[aPageNum-1]->eSidebarPosition = pItem->maLayoutInfo.meSidebarPosition;

        }

        if (!bChange && mpWrtShell->getIDocumentSettingAccess().get(DocumentSettingId::BROWSE_MODE))

        {

            tools::Long nLayoutHeight = SwPostItHelper::getLayoutHeight( mpWrtShell->GetLayout() );

            if( nLayoutHeight > mbLayoutHeight )

            {

                if (mPages[0]->bScrollbar || HasScrollbars())

                    bChange = true;

            }

            else if( nLayoutHeight < mbLayoutHeight )

            {

                if (mPages[0]->bScrollbar || !BorderOverPageBorder(1))

                    bChange = true;

            }

        }

    }

    if ( bRepair )

        CheckForRemovedPostIts();

    mbLayoutHeight = SwPostItHelper::getLayoutHeight( mpWrtShell->GetLayout() );

    mbWaitingForCalcRects = false;

    return bChange;

}

bool SwPostItMgr::HasScrollbars() const

{

    for (auto const& postItField : mvPostItFields)

    {

        if (postItField->mbShow && postItField->mpPostIt && postItField->mpPostIt->HasScrollbar())

            return true;

    }

    return false;

}

void SwPostItMgr::PreparePageContainer()

{

    // we do not just delete the SwPostItPageItem, so offset/scrollbar is not lost

    tools::Long lPageSize = mpWrtShell->GetNumPages();

    tools::Long lContainerSize = mPages.size();