/* -*- 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 <basegfx/matrix/b2dhommatrix.hxx>

#include <com/sun/star/accessibility/AccessibleRole.hpp>

#include <com/sun/star/accessibility/AccessibleStateType.hpp>

#include <com/sun/star/accessibility/XAccessible.hpp>

#include <com/sun/star/lang/IndexOutOfBoundsException.hpp>

#include <comphelper/OAccessible.hxx>

#include <cppuhelper/supportsservice.hxx>

#include <drawinglayer/processor2d/baseprocessor2d.hxx>

#include <drawinglayer/processor2d/processor2dtools.hxx>

#include <comphelper/lok.hxx>

#include <editeng/eeitem.hxx>

#include <editeng/fhgtitem.hxx>

#include <editeng/fontitem.hxx>

#include <editeng/outliner.hxx>

#include <editeng/unoedhlp.hxx>

#include <editeng/unoedsrc.hxx>

#include <i18nlangtag/languagetag.hxx>

#include <osl/diagnose.h>

#include <svl/itempool.hxx>

#include <svl/itemset.hxx>

#include <sal/log.hxx>

#include <svx/sdr/overlay/overlayselection.hxx>

#include <svtools/optionsdrawinglayer.hxx>

#include <svx/AccessibleTextHelper.hxx>

#include <svx/weldeditview.hxx>

#include <comphelper/diagnose_ex.hxx>

#include <vcl/canvastools.hxx>

#include <vcl/cursor.hxx>

#include <vcl/event.hxx>

#include <vcl/ptrstyle.hxx>

#include <vcl/settings.hxx>

#include <vcl/svapp.hxx>

#include <vcl/window.hxx>

#include <vcl/uitest/uiobject.hxx>

void WeldEditView::SetText(const OUString& rStr) { GetEditEngine()->SetText(rStr); }

OUString WeldEditView::GetText() const { return GetEditEngine()->GetText(); }

void WeldEditView::SetModifyHdl(const Link<LinkParamNone*, void>& rLink)

{

    GetEditEngine()->SetModifyHdl(rLink);

}

EditView* WeldEditView::GetEditView() const { return m_xEditView.get(); }

EditEngine* WeldEditView::GetEditEngine() const { return m_xEditEngine.get(); }

bool WeldEditView::HasSelection() const

{

    EditView* pEditView = GetEditView();

    return pEditView && pEditView->HasSelection();

}

void WeldEditView::Delete()

{

    if (EditView* pEditView = GetEditView())

        pEditView->DeleteSelected();

}

void WeldEditView::Cut()

{

    if (EditView* pEditView = GetEditView())

        pEditView->Cut();

}

void WeldEditView::Copy()

{

    if (EditView* pEditView = GetEditView())

        pEditView->Copy();

}

void WeldEditView::Paste()

{

    if (EditView* pEditView = GetEditView())

        pEditView->Paste();

}

WeldEditView::WeldEditView()

    : m_bAcceptsTab(false)

    , m_aCursorTimer("WeldEditView CursorTimer")

    , m_bCursorVisible(false)

{

    m_aCursorTimer.SetInvokeHandler(LINK(this, WeldEditView, BlinkTimerHdl));

}

IMPL_LINK_NOARG(WeldEditView, BlinkTimerHdl, Timer*, void)

{

    m_bCursorVisible = !m_bCursorVisible;

    if (!m_aCachedCursorPixRect.IsEmpty())

    {

        OutputDevice& rDevice = EditViewOutputDevice();

        Invalidate(rDevice.PixelToLogic(m_aCachedCursorPixRect), weld::InvalidateFlags::Cursor);

    }

    else

        Invalidate();

}

// tdf#127033 want to use UI font so override makeEditEngine to enable that

void WeldEditView::makeEditEngine()

{

    rtl::Reference<SfxItemPool> pItemPool = EditEngine::CreatePool();

    vcl::Font aAppFont(Application::GetSettings().GetStyleSettings().GetAppFont());

    pItemPool->SetUserDefaultItem(SvxFontItem(aAppFont.GetFamilyTypeMaybeAskConfig(),

                                              aAppFont.GetFamilyName(), u""_ustr, PITCH_DONTKNOW,

                                              RTL_TEXTENCODING_DONTKNOW, EE_CHAR_FONTINFO));

    pItemPool->SetUserDefaultItem(SvxFontItem(aAppFont.GetFamilyTypeMaybeAskConfig(),

                                              aAppFont.GetFamilyName(), u""_ustr, PITCH_DONTKNOW,

                                              RTL_TEXTENCODING_DONTKNOW, EE_CHAR_FONTINFO_CJK));

    pItemPool->SetUserDefaultItem(SvxFontItem(aAppFont.GetFamilyTypeMaybeAskConfig(),

                                              aAppFont.GetFamilyName(), u""_ustr, PITCH_DONTKNOW,

                                              RTL_TEXTENCODING_DONTKNOW, EE_CHAR_FONTINFO_CTL));

    pItemPool->SetUserDefaultItem(

        SvxFontHeightItem(aAppFont.GetFontHeight() * 20, 100, EE_CHAR_FONTHEIGHT));

    pItemPool->SetUserDefaultItem(

        SvxFontHeightItem(aAppFont.GetFontHeight() * 20, 100, EE_CHAR_FONTHEIGHT_CJK));

    pItemPool->SetUserDefaultItem(

        SvxFontHeightItem(aAppFont.GetFontHeight() * 20, 100, EE_CHAR_FONTHEIGHT_CTL));

    m_xEditEngine.reset(new EditEngine(pItemPool.get()));

}

void WeldEditView::Resize()

{

    if (EditView* pEditView = GetEditView())

    {

        OutputDevice& rDevice = GetDrawingArea()->get_ref_device();

        Size aOutputSize(rDevice.PixelToLogic(GetOutputSizePixel()));

        // Resizes the edit engine to adjust to the size of the output area

        pEditView->SetOutputArea(tools::Rectangle(Point(0, 0), aOutputSize));

        GetEditEngine()->SetPaperSize(aOutputSize);

        pEditView->ShowCursor();

        const tools::Long nMaxVisAreaStart

            = pEditView->getEditEngine().GetTextHeight() - aOutputSize.Height();

        tools::Rectangle aVisArea(pEditView->GetVisArea());

        if (aVisArea.Top() > nMaxVisAreaStart)

        {

            aVisArea.SetTop(std::max<tools::Long>(nMaxVisAreaStart, 0));

            aVisArea.SetSize(aOutputSize);

            pEditView->SetVisArea(aVisArea);

            pEditView->ShowCursor();

        }

        EditViewScrollStateChange();

    }

    weld::CustomWidgetController::Resize();

}

void WeldEditView::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect)

{

    DoPaint(rRenderContext, rRect);

}

void WeldEditView::PaintSelection(vcl::RenderContext& rRenderContext, tools::Rectangle const& rRect,

                                  std::vector<tools::Rectangle> const& rLogicRects,

                                  Color const color)

{

    if (rLogicRects.empty())

    {

        return;

    }

    std::vector<basegfx::B2DRange> aLogicRanges;

    aLogicRanges.reserve(rLogicRects.size());

    tools::Long nMinX(LONG_MAX), nMaxX(0), nMinY(LONG_MAX), nMaxY(0);

    for (const auto& aRect : rLogicRects)

    {

        nMinX = std::min(nMinX, aRect.Left());

        nMinY = std::min(nMinY, aRect.Top());

        nMaxX = std::max(nMaxX, aRect.Right());

        nMaxY = std::max(nMaxY, aRect.Bottom());

    }

    const Size aLogicPixel(rRenderContext.PixelToLogic(Size(1, 1)));

    for (const auto& aRect : rLogicRects)

    {

        // Extend each range by one pixel so multiple lines touch each

        // other if adjacent, so the whole set is drawn with a single

        // border around the lot. But keep the selection within the

        // original max extents.

        auto nTop = aRect.Top();

        if (nTop > nMinY)

            nTop -= aLogicPixel.Height();

        auto nBottom = aRect.Bottom();

        if (nBottom < nMaxY)

            nBottom += aLogicPixel.Height();

        auto nLeft = aRect.Left();

        if (nLeft > nMinX)

            nLeft -= aLogicPixel.Width();

        auto nRight = aRect.Right();

        if (nRight < nMaxX)

            nRight += aLogicPixel.Width();

        aLogicRanges.emplace_back(nLeft, nTop, nRight, nBottom);

    }

    sdr::overlay::OverlaySelection aCursorOverlay(sdr::overlay::OverlayType::Transparent, color,

                                                  std::move(aLogicRanges), true);

    drawinglayer::geometry::ViewInformation2D aViewInformation2D;

    aViewInformation2D.setViewTransformation(rRenderContext.GetViewTransformation());

    aViewInformation2D.setViewport(vcl::unotools::b2DRectangleFromRectangle(rRect));

    std::unique_ptr<drawinglayer::processor2d::BaseProcessor2D> xProcessor(

        drawinglayer::processor2d::createProcessor2DFromOutputDevice(rRenderContext,

                                                                     aViewInformation2D));

    xProcessor->process(aCursorOverlay.getOverlayObjectPrimitive2DSequence());

}

void WeldEditView::DoPaint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect)

{

    EditView* const pEditView{ GetEditView() };

    if (pEditView == nullptr)

    {

        return;

    }

    // Fast path: blink-only repaint with valid cache

    weld::InvalidateFlags ePending = GetInvalidateFlags();

    if (ePending == weld::InvalidateFlags::Cursor && !m_aCachedCursorPixRect.IsEmpty())

    {

        VirtualDevice& rSrc = m_bCursorVisible ? *m_xCursorOnDev : *m_xCursorOffDev;

        // Blit cached bitmap in pixel coordinates to avoid rounding issues

        bool bMapMode = rRenderContext.IsMapModeEnabled();

        rRenderContext.EnableMapMode(false);

        rRenderContext.DrawOutDev(m_aCachedCursorPixRect.TopLeft(),

                                  m_aCachedCursorPixRect.GetSize(), Point(0, 0),

                                  m_aCachedCursorPixRect.GetSize(), rSrc);

        rRenderContext.EnableMapMode(bMapMode);

        return;

    }

    auto popIt = rRenderContext.ScopedPush(vcl::PushFlags::ALL);

    rRenderContext.SetClipRegion();

    pEditView->DrawText_ToEditView(

        comphelper::LibreOfficeKit::isActive() ? rRenderContext.PixelToLogic(rRect) : rRect,

        &rRenderContext);

    if (HasFocus())

    {

        pEditView->ShowCursor(false);

        vcl::Cursor* pCursor = pEditView->GetCursor();

        // Get the pixel bounding rect the cursor will occupy

        tools::Rectangle aPixRect = pCursor->GetBoundRect(rRenderContext);

        if (!aPixRect.IsEmpty())

        {

            m_aCachedCursorPixRect = aPixRect;

            Size aPixSize = aPixRect.GetSize();

            // Cache in pixel coordinates to avoid rounding issues

            bool bMapMode = rRenderContext.IsMapModeEnabled();

            rRenderContext.EnableMapMode(false);

            // Cache "cursor off" — text without cursor (before drawing cursor)

            m_xCursorOffDev->SetOutputSizePixel(aPixSize);

            m_xCursorOffDev->SetMapMode(MapMode(MapUnit::MapPixel));

            m_xCursorOffDev->DrawOutDev(Point(0, 0), aPixSize, aPixRect.TopLeft(), aPixSize,

                                        rRenderContext);

            // Draw cursor, then cache "cursor on"

            rRenderContext.EnableMapMode(bMapMode);

            pCursor->DrawToDevice(rRenderContext);

            rRenderContext.EnableMapMode(false);

            m_xCursorOnDev->SetOutputSizePixel(aPixSize);

            m_xCursorOnDev->SetMapMode(MapMode(MapUnit::MapPixel));

            m_xCursorOnDev->DrawOutDev(Point(0, 0), aPixSize, aPixRect.TopLeft(), aPixSize,

                                       rRenderContext);

            rRenderContext.EnableMapMode(bMapMode);

            // If cursor should be hidden, restore to clean state

            if (!m_bCursorVisible)

            {

                rRenderContext.EnableMapMode(false);

                rRenderContext.DrawOutDev(aPixRect.TopLeft(), aPixSize, Point(0, 0), aPixSize,

                                          *m_xCursorOffDev);

                rRenderContext.EnableMapMode(bMapMode);

            }

        }

    }

    // get logic selection

    std::vector<tools::Rectangle> aLogicRects;

    pEditView->GetSelectionRectangles(aLogicRects);

    // get the system's highlight color

    const Color aHighlight(SvtOptionsDrawinglayer::getHilightColor());

    PaintSelection(rRenderContext, rRect, aLogicRects, aHighlight);

}

bool WeldEditView::MouseMove(const MouseEvent& rMEvt)

{

    EditView* pEditView = GetEditView();

    return pEditView && pEditView->MouseMove(rMEvt);

}

bool WeldEditView::MouseButtonDown(const MouseEvent& rMEvt)

{

    if (!IsMouseCaptured())

        CaptureMouse();

    if (!HasFocus() && CanFocus())

        GrabFocus();

    EditView* pEditView = GetEditView();

    return pEditView && pEditView->MouseButtonDown(rMEvt);

}

bool WeldEditView::MouseButtonUp(const MouseEvent& rMEvt)

{

    if (IsMouseCaptured())

        ReleaseMouse();

    EditView* pEditView = GetEditView();

    return pEditView && pEditView->MouseButtonUp(rMEvt);

}

bool WeldEditView::KeyInput(const KeyEvent& rKEvt)

{

    EditView* pEditView = GetEditView();

    sal_uInt16 nKey = rKEvt.GetKeyCode().GetCode();

    if (nKey == KEY_TAB && !GetAcceptsTab())

    {

        return false;

    }

    else if (pEditView && !pEditView->PostKeyEvent(rKEvt))

    {

        if (rKEvt.GetKeyCode().IsMod1() && !rKEvt.GetKeyCode().IsMod2())

        {

            if (nKey == KEY_A)

            {

                if (GetEditEngine()->GetParagraphCount())

                {

                    pEditView->SetSelection(ESelection::All());

                }

                return true;

            }

        }

        return false;

    }

    return true;

}

bool WeldEditView::Command(const CommandEvent& rCEvt)

{

    EditView* pEditView = GetEditView();

    if (!pEditView)

        return false;

    return pEditView->Command(rCEvt);

}

Point WeldEditView::EditViewPointerPosPixel() const

{

    return GetDrawingArea()->get_pointer_position();

}

class WeldEditAccessible;

namespace

{

class WeldViewForwarder : public SvxViewForwarder

{

    WeldEditAccessible& m_rEditAcc;

    WeldViewForwarder(const WeldViewForwarder&) = delete;

    WeldViewForwarder& operator=(const WeldViewForwarder&) = delete;

public:

    explicit WeldViewForwarder(WeldEditAccessible& rAcc)

        : m_rEditAcc(rAcc)

    {

    }

    virtual bool IsValid() const override;

    virtual Point LogicToPixel(const Point& rPoint, const MapMode& rMapMode) const override;

    virtual Point PixelToLogic(const Point& rPoint, const MapMode& rMapMode) const override;

};

}

class WeldEditAccessible;

namespace

{

class WeldEditSource;

/* analog to SvxEditEngineForwarder */

class WeldTextForwarder : public SvxTextForwarder

{

    WeldEditAccessible& m_rEditAcc;

    WeldEditSource& m_rEditSource;

    DECL_LINK(NotifyHdl, EENotify&, void);

    WeldTextForwarder(const WeldTextForwarder&) = delete;

    WeldTextForwarder& operator=(const WeldTextForwarder&) = delete;

public:

    WeldTextForwarder(WeldEditAccessible& rAcc, WeldEditSource& rSource);

    virtual ~WeldTextForwarder() override;

    virtual sal_Int32 GetParagraphCount() const override;

    virtual sal_Int32 GetTextLen(sal_Int32 nParagraph) const override;

    virtual OUString GetText(const ESelection& rSel) const override;

    virtual SfxItemSet GetAttribs(const ESelection& rSel, EditEngineAttribs nOnlyHardAttrib

                                                          = EditEngineAttribs::All) const override;

    virtual SfxItemSet GetParaAttribs(sal_Int32 nPara) const override;

    virtual void SetParaAttribs(sal_Int32 nPara, const SfxItemSet& rSet) override;

    virtual void RemoveAttribs(const ESelection& rSelection) override;

    virtual void GetPortions(sal_Int32 nPara, std::vector<sal_Int32>& rList) const override;

    virtual OUString GetStyleSheet(sal_Int32 nPara) const override;

    virtual void SetStyleSheet(sal_Int32 nPara, const OUString& rStyleName) override;

    virtual SfxItemState GetItemState(const ESelection& rSel, sal_uInt16 nWhich) const override;

    virtual SfxItemState GetItemState(sal_Int32 nPara, sal_uInt16 nWhich) const override;

    virtual void QuickInsertText(const OUString& rText, const ESelection& rSel) override;

    virtual void QuickInsertField(const SvxFieldItem& rFld, const ESelection& rSel) override;

    virtual void QuickSetAttribs(const SfxItemSet& rSet, const ESelection& rSel) override;

    virtual void QuickInsertLineBreak(const ESelection& rSel) override;

    virtual SfxItemPool* GetPool() const override;

    virtual OUString CalcFieldValue(const SvxFieldItem& rField, sal_Int32 nPara, sal_Int32 nPos,

                                    std::optional<Color>& rpTxtColor,

                                    std::optional<Color>& rpFldColor,

                                    std::optional<FontLineStyle>& rpFldLineStyle) override;

    virtual void FieldClicked(const SvxFieldItem&) override;

    virtual bool IsValid() const override;

    virtual LanguageType GetLanguage(sal_Int32, sal_Int32) const override;

    virtual std::vector<EFieldInfo> GetFieldInfo(sal_Int32 nPara) const override;

    virtual EBulletInfo GetBulletInfo(sal_Int32 nPara) const override;

    virtual tools::Rectangle GetCharBounds(sal_Int32 nPara, sal_Int32 nIndex) const override;

    virtual tools::Rectangle GetParaBounds(sal_Int32 nPara) const override;

    virtual MapMode GetMapMode() const override;

    virtual OutputDevice* GetRefDevice() const override;

    virtual bool GetIndexAtPoint(const Point&, sal_Int32& nPara, sal_Int32& nIndex) const override;

    virtual bool GetWordIndices(sal_Int32 nPara, sal_Int32 nIndex, sal_Int32& nStart,

                                sal_Int32& nEnd) const override;

    virtual bool GetAttributeRun(sal_Int32& nStartIndex, sal_Int32& nEndIndex, sal_Int32 nPara,

                                 sal_Int32 nIndex, bool bInCell = false) const override;

    virtual sal_Int32 GetLineCount(sal_Int32 nPara) const override;

    virtual sal_Int32 GetLineLen(sal_Int32 nPara, sal_Int32 nLine) const override;

    virtual void GetLineBoundaries(/*out*/ sal_Int32& rStart, /*out*/ sal_Int32& rEnd,

                                   sal_Int32 nParagraph, sal_Int32 nLine) const override;

    virtual sal_Int32 GetLineNumberAtIndex(sal_Int32 nPara, sal_Int32 nLine) const override;

    virtual bool Delete(const ESelection&) override;

    virtual bool InsertText(const OUString&, const ESelection&) override;

    virtual bool QuickFormatDoc(bool bFull = false) override;

    virtual bool SupportsOutlineDepth() const override { return false; };

    virtual sal_Int16 GetDepth(sal_Int32 nPara) const override;

    virtual bool SetDepth(sal_Int32 nPara, sal_Int16 nNewDepth) override;

    virtual const SfxItemSet* GetEmptyItemSetPtr() override;

    // implementation functions for XParagraphAppend and XTextPortionAppend

    virtual void AppendParagraph() override;

    virtual sal_Int32 AppendTextPortion(sal_Int32 nPara, const OUString& rText,

                                        const SfxItemSet& rSet) override;

    virtual void CopyText(const SvxTextForwarder& rSource) override;

};

/* analog to SvxEditEngineViewForwarder */

class WeldEditViewForwarder : public SvxEditViewForwarder

{

    WeldEditAccessible& m_rEditAcc;

    WeldEditViewForwarder(const WeldEditViewForwarder&) = delete;

    WeldEditViewForwarder& operator=(const WeldEditViewForwarder&) = delete;

public:

    explicit WeldEditViewForwarder(WeldEditAccessible& rAcc);

    virtual bool IsValid() const override;

    virtual Point LogicToPixel(const Point& rPoint, const MapMode& rMapMode) const override;

    virtual Point PixelToLogic(const Point& rPoint, const MapMode& rMapMode) const override;

    virtual bool GetSelection(ESelection& rSelection) const override;

    virtual bool SetSelection(const ESelection& rSelection) override;

    virtual bool Copy() override;

    virtual bool Cut() override;

    virtual bool Paste() override;

};

class WeldEditSource : public SvxEditSource

{

    SfxBroadcaster m_aBroadCaster;

    WeldViewForwarder m_aViewFwd;

    WeldTextForwarder m_aTextFwd;

    WeldEditViewForwarder m_aEditViewFwd;

    WeldEditAccessible& m_rEditAcc;

    WeldEditSource(const WeldEditSource& rSrc)

        : SvxEditSource()

        , m_aViewFwd(rSrc.m_rEditAcc)

        , m_aTextFwd(rSrc.m_rEditAcc, *this)

        , m_aEditViewFwd(rSrc.m_rEditAcc)

        , m_rEditAcc(rSrc.m_rEditAcc)

    {

    }

    WeldEditSource& operator=(const WeldEditSource&) = delete;

public:

    WeldEditSource(WeldEditAccessible& rAcc)

        : m_aViewFwd(rAcc)

        , m_aTextFwd(rAcc, *this)

        , m_aEditViewFwd(rAcc)

        , m_rEditAcc(rAcc)

    {

    }

    virtual std::unique_ptr<SvxEditSource> Clone() const override

    {

        return std::unique_ptr<SvxEditSource>(new WeldEditSource(*this));

    }

    virtual SvxTextForwarder* GetTextForwarder() override { return &m_aTextFwd; }

    virtual SvxViewForwarder* GetViewForwarder() override { return &m_aViewFwd; }

    virtual SvxEditViewForwarder* GetEditViewForwarder(bool /*bCreate*/) override

    {

        return &m_aEditViewFwd;

    }

    virtual void UpdateData() override

    {

        // would possibly only by needed if the XText interface is implemented

        // and its text needs to be updated.

    }

    virtual SfxBroadcaster& GetBroadcaster() const override

    {

        return const_cast<WeldEditSource*>(this)->m_aBroadCaster;

    }

};

}

class WeldEditAccessible : public comphelper::OAccessible

{

    weld::CustomWidgetController* m_pController;

    EditEngine* m_pEditEngine;

    EditView* m_pEditView;

    std::unique_ptr<::accessibility::AccessibleTextHelper> m_xTextHelper;

public:

    WeldEditAccessible(weld::CustomWidgetController* pController)

        : m_pController(pController)

        , m_pEditEngine(nullptr)

        , m_pEditView(nullptr)

    {

    }

    ::accessibility::AccessibleTextHelper* GetTextHelper() { return m_xTextHelper.get(); }

    void Init(EditEngine* pEditEngine, EditView* pEditView)

    {

        m_pEditEngine = pEditEngine;

        m_pEditView = pEditView;

        m_xTextHelper.reset(

            new ::accessibility::AccessibleTextHelper(std::make_unique<WeldEditSource>(*this)));

        m_xTextHelper->SetEventSource(this);

    }

    EditEngine* GetEditEngine() { return m_pEditEngine; }

    EditView* GetEditView() { return m_pEditView; }

    void SAL_CALL dispose() override

    {

        if (!isAlive())

            return;

        // remove handler before current object gets destroyed

        // (avoid handler being called for already dead object)

        m_pEditEngine->SetNotifyHdl(Link<EENotify&, void>());

        m_pEditEngine = nullptr;

        m_pEditView = nullptr;

        m_pController = nullptr; // implicitly results in AccessibleStateType::DEFUNC set

        //! make TextHelper implicitly release C++ references to some core objects

        m_xTextHelper->SetEditSource(::std::unique_ptr<SvxEditSource>());

        //! make TextHelper release references

        //! (e.g. the one set by the 'SetEventSource' call)

        m_xTextHelper->Dispose();

        m_xTextHelper.reset();

        OAccessible::dispose();

    }

    // XAccessibleComponent

    virtual css::uno::Reference<css::accessibility::XAccessible>

        SAL_CALL getAccessibleAtPoint(const css::awt::Point& rPoint) override

    {

        SolarMutexGuard aGuard;

        if (!m_xTextHelper)

            throw css::uno::RuntimeException();

        return m_xTextHelper->GetAt(rPoint);

    }

    virtual css::awt::Rectangle implGetBounds() override

    {

        if (!m_pController)

            throw css::uno::RuntimeException();

        const Point aOutPos;

        const Size aOutSize(m_pController->GetOutputSizePixel());

        css::awt::Rectangle aRet;

        aRet.X = aOutPos.X();

        aRet.Y = aOutPos.Y();

        aRet.Width = aOutSize.Width();

        aRet.Height = aOutSize.Height();

        return aRet;

    }

    virtual css::awt::Point SAL_CALL getLocationOnScreen() override

    {

        SolarMutexGuard aGuard;

        if (!m_pController)

            throw css::uno::RuntimeException();

        css::awt::Point aScreenLoc(0, 0);

        if (weld::DrawingArea* pDrawingArea = m_pController->GetDrawingArea())

        {

            AbsoluteScreenPixelPoint aPos = pDrawingArea->get_accessible_location_on_screen();

            aScreenLoc.X = aPos.X();

            aScreenLoc.Y = aPos.Y();

        }

        return aScreenLoc;

    }

    virtual void SAL_CALL grabFocus() override { m_pController->GrabFocus(); }

    virtual sal_Int32 SAL_CALL getForeground() override

    {

        SolarMutexGuard aGuard;

        if (!m_pController)

            throw css::uno::RuntimeException();

        Color nCol = m_pEditEngine->GetAutoColor();

        return static_cast<sal_Int32>(nCol);

    }

    virtual sal_Int32 SAL_CALL getBackground() override

    {

        SolarMutexGuard aGuard;

        if (!m_pController)

            throw css::uno::RuntimeException();

        Color nCol = m_pEditEngine->GetBackgroundColor();

        return static_cast<sal_Int32>(nCol);

    }

    // XAccessibleContext

    virtual sal_Int64 SAL_CALL getAccessibleChildCount() override

    {

        if (m_xTextHelper)

            return m_xTextHelper->GetChildCount();

        return 0;

    }

    virtual css::uno::Reference<css::accessibility::XAccessible>

        SAL_CALL getAccessibleChild(sal_Int64 i) override

    {

        if (m_xTextHelper)

            return m_xTextHelper->GetChild(i);

        throw css::lang::IndexOutOfBoundsException(); // there is no child...

    }

    virtual css::uno::Reference<css::accessibility::XAccessible>

        SAL_CALL getAccessibleParent() override

    {

        SolarMutexGuard aGuard;

        if (!m_pController)

            throw css::uno::RuntimeException();

        return m_pController->GetDrawingArea()->get_accessible_parent();

    }

    virtual sal_Int64 SAL_CALL getAccessibleIndexInParent() override

    {

        SolarMutexGuard aGuard;

        if (!m_pController)

            throw css::uno::RuntimeException();

        // -1 for child not found/no parent (according to specification)

        sal_Int64 nRet = -1;

        css::uno::Reference<css::accessibility::XAccessible> xParent(getAccessibleParent());

        if (!xParent)

            return nRet;

        try

        {

            css::uno::Reference<css::accessibility::XAccessibleContext> xParentContext(

                xParent->getAccessibleContext());

            //  iterate over parent's children and search for this object

            if (xParentContext.is())

            {

                sal_Int64 nChildCount = xParentContext->getAccessibleChildCount();

                for (sal_Int64 nChild = 0; (nChild < nChildCount) && (-1 == nRet); ++nChild)

                {

                    css::uno::Reference<css::accessibility::XAccessible> xChild(

                        xParentContext->getAccessibleChild(nChild));

                    if (xChild.get() == this)

                        nRet = nChild;

                }

            }

        }

        catch (const css::uno::Exception&)

        {

            TOOLS_WARN_EXCEPTION("svx", "WeldEditAccessible::getAccessibleIndexInParent");

        }

        return nRet;

    }

    virtual sal_Int16 SAL_CALL getAccessibleRole() override

    {

        return css::accessibility::AccessibleRole::TEXT_FRAME;

    }

    virtual OUString SAL_CALL getAccessibleDescription() override

    {

        SolarMutexGuard aGuard;

        OUString aRet;

        if (m_pController)

        {

            aRet = m_pController->GetAccessibleDescription();

        }

        return aRet;

    }

    virtual OUString SAL_CALL getAccessibleId() override

    {

        SolarMutexGuard aGuard;

        if (m_pController)

            return m_pController->GetAccessibleId();

        return OUString();

    }

    virtual OUString SAL_CALL getAccessibleName() override

    {

        SolarMutexGuard aGuard;

        OUString aRet;

        if (m_pController)

        {

            aRet = m_pController->GetAccessibleName();

        }

        return aRet;

    }

    virtual css::uno::Reference<css::accessibility::XAccessibleRelationSet>

        SAL_CALL getAccessibleRelationSet() override

    {

        SolarMutexGuard aGuard;

        if (!m_pController)

            throw css::uno::RuntimeException();

        return m_pController->GetDrawingArea()->get_accessible_relation_set();

    }

    virtual sal_Int64 SAL_CALL getAccessibleStateSet() override

    {

        SolarMutexGuard aGuard;

        sal_Int64 nStateSet = 0;

        if (!m_pController || !m_xTextHelper)

            nStateSet |= css::accessibility::AccessibleStateType::DEFUNC;

        else

        {

            nStateSet |= css::accessibility::AccessibleStateType::MULTI_LINE;

            nStateSet |= css::accessibility::AccessibleStateType::ENABLED;

            nStateSet |= css::accessibility::AccessibleStateType::EDITABLE;

            nStateSet |= css::accessibility::AccessibleStateType::FOCUSABLE;

            nStateSet |= css::accessibility::AccessibleStateType::SELECTABLE;

            if (m_pController->HasFocus())

                nStateSet |= css::accessibility::AccessibleStateType::FOCUSED;

            if (m_pController->IsVisible())

                nStateSet |= css::accessibility::AccessibleStateType::SHOWING;

            if (m_pController->IsReallyVisible())

                nStateSet |= css::accessibility::AccessibleStateType::VISIBLE;

            if (COL_TRANSPARENT != m_pEditEngine->GetBackgroundColor())

                nStateSet |= css::accessibility::AccessibleStateType::OPAQUE;

        }

        return nStateSet;

    }

    virtual css::lang::Locale SAL_CALL getLocale() override

    {

        SolarMutexGuard aGuard;

        return LanguageTag(m_pEditEngine->GetDefaultLanguage()).getLocale();

    }

    // XAccessibleEventBroadcaster

    virtual void SAL_CALL addAccessibleEventListener(

        const css::uno::Reference<css::accessibility::XAccessibleEventListener>& rListener) override

    {

        if (!m_xTextHelper) // not disposing (about to destroy view shell)

            return;

        m_xTextHelper->AddEventListener(rListener);

    }

    virtual void SAL_CALL removeAccessibleEventListener(

        const css::uno::Reference<css::accessibility::XAccessibleEventListener>& rListener) override

    {

        if (!m_xTextHelper) // not disposing (about to destroy view shell)

            return;

        m_xTextHelper->RemoveEventListener(rListener);

    }

};

rtl::Reference<comphelper::OAccessible> WeldEditView::CreateAccessible()

{

#if !ENABLE_WASM_STRIP_ACCESSIBILITY

    if (!m_xAccessible.is())

        m_xAccessible.set(new WeldEditAccessible(this));

#endif

    return m_xAccessible;

}

WeldEditView::~WeldEditView()

{

#if !ENABLE_WASM_STRIP_ACCESSIBILITY

    if (m_xAccessible.is())

    {

        m_xAccessible->dispose();

        m_xAccessible.clear();

    }

#endif

}

bool WeldViewForwarder::IsValid() const { return m_rEditAcc.GetEditView() != nullptr; }

Point WeldViewForwarder::LogicToPixel(const Point& rPoint, const MapMode& rMapMode) const

{

    EditView* pEditView = m_rEditAcc.GetEditView();

    if (!pEditView)

        return Point();

    OutputDevice& rOutDev = pEditView->GetOutputDevice();

    MapMode aMapMode(rOutDev.GetMapMode());

    Point aPoint(OutputDevice::LogicToLogic(rPoint, rMapMode, MapMode(aMapMode.GetMapUnit())));

    aMapMode.SetOrigin(Point());

    return rOutDev.LogicToPixel(aPoint, aMapMode);

}

Point WeldViewForwarder::PixelToLogic(const Point& rPoint, const MapMode& rMapMode) const

{

    EditView* pEditView = m_rEditAcc.GetEditView();

    if (!pEditView)

        return Point();

    OutputDevice& rOutDev = pEditView->GetOutputDevice();

    MapMode aMapMode(rOutDev.GetMapMode());

    aMapMode.SetOrigin(Point());

    Point aPoint(rOutDev.PixelToLogic(rPoint, aMapMode));

    return OutputDevice::LogicToLogic(aPoint, MapMode(aMapMode.GetMapUnit()), rMapMode);

}

WeldTextForwarder::WeldTextForwarder(WeldEditAccessible& rAcc, WeldEditSource& rSource)

    : m_rEditAcc(rAcc)

    , m_rEditSource(rSource)

{

    EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();

    if (pEditEngine)

        pEditEngine->SetNotifyHdl(LINK(this, WeldTextForwarder, NotifyHdl));

}

WeldTextForwarder::~WeldTextForwarder()

{

    EditEngine* pEditEngine = m_rEditAcc.GetEditEngine();

    if (pEditEngine)

        pEditEngine->SetNotifyHdl(Link<EENotify&, void>());

}

IMPL_LINK(WeldTextForwarder, NotifyHdl, EENotify&, rNotify, void)

{

    if (EditEngine* pEditEngine = m_rEditAcc.GetEditEngine())

    {

        if (rNotify.eNotificationType == EE_NOTIFY_PROCESSNOTIFICATIONS

            && !pEditEngine->IsUpdateLayout())

        {

            // tdf#143088 an UpdateMode of false will just to on to cause

            // AccessibleTextHelper_Impl::GetTextForwarder to throw an

            // exception as a Frozen EditEngine is considered Invalid so return

            // early instead

            return;