Adding upstream version 4:24.2.0.upstream/4%24.2.0

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 3002 insertions, 0 deletions

diff --git a/svx/source/svdraw/svdedxv.cxx b/svx/source/svdraw/svdedxv.cxx
new file mode 100644
index 0000000000..c2d35cc75b
--- /dev/null
+++ b/svx/source/svdraw/svdedxv.cxx
@@ -0,0 +1,3002 @@
+/* -*- 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 <com/sun/star/i18n/WordType.hpp>
+#include <editeng/editdata.hxx>
+#include <editeng/editeng.hxx>
+#include <editeng/editobj.hxx>
+#include <editeng/editstat.hxx>
+#include <editeng/outlobj.hxx>
+#include <editeng/unotext.hxx>
+#include <o3tl/deleter.hxx>
+#include <svl/itemiter.hxx>
+#include <svl/style.hxx>
+#include <svl/whiter.hxx>
+#include <svtools/accessibilityoptions.hxx>
+#include <svx/sdtfchim.hxx>
+#include <svx/selectioncontroller.hxx>
+#include <svx/svdedxv.hxx>
+#include <svx/svdetc.hxx>
+#include <svx/svdotable.hxx>
+#include <svx/svdotext.hxx>
+#include <svx/svdoutl.hxx>
+#include <svx/svdpage.hxx>
+#include <svx/svdpagv.hxx>
+#include <svx/svdundo.hxx>
+#include <vcl/canvastools.hxx>
+#include <vcl/commandevent.hxx>
+#include <vcl/cursor.hxx>
+#include <vcl/weld.hxx>
+#include <vcl/window.hxx>
+#include <comphelper/lok.hxx>
+#include <basegfx/polygon/b2dpolygontools.hxx>
+#include <drawinglayer/processor2d/baseprocessor2d.hxx>
+#include <drawinglayer/primitive2d/maskprimitive2d.hxx>
+#include <drawinglayer/processor2d/processor2dtools.hxx>
+#include <drawinglayer/primitive2d/PolyPolygonColorPrimitive2D.hxx>
+#include <editeng/outliner.hxx>
+#include <sal/log.hxx>
+#include <sdr/overlay/overlaytools.hxx>
+#include <sfx2/viewsh.hxx>
+#include <svx/dialmgr.hxx>
+#include <svx/sdr/overlay/overlaymanager.hxx>
+#include <svx/sdr/overlay/overlayselection.hxx>
+#include <svx/sdr/table/tablecontroller.hxx>
+#include <svx/sdrpagewindow.hxx>
+#include <svx/sdrpaintwindow.hxx>
+#include <svx/sdrundomanager.hxx>
+#include <svx/strings.hrc>
+#include <svx/svdviter.hxx>
+#include <svtools/optionsdrawinglayer.hxx>
+#include <textchain.hxx>
+#include <textchaincursor.hxx>
+#include <tools/debug.hxx>
+#include <vcl/svapp.hxx>
+
+#include <memory>
+
+SdrObjEditView::SdrObjEditView(SdrModel& rSdrModel, OutputDevice* pOut)
+    : SdrGlueEditView(rSdrModel, pOut)
+    , mpTextEditPV(nullptr)
+    , mpTextEditOutlinerView(nullptr)
+    , mpTextEditWin(nullptr)
+    , pTextEditCursorBuffer(nullptr)
+    , pMacroObj(nullptr)
+    , pMacroPV(nullptr)
+    , pMacroWin(nullptr)
+    , nMacroTol(0)
+    , mbTextEditDontDelete(false)
+    , mbTextEditOnlyOneView(false)
+    , mbTextEditNewObj(false)
+    , mbQuickTextEditMode(true)
+    , mbMacroDown(false)
+    , mpOldTextEditUndoManager(nullptr)
+{
+}
+
+SdrObjEditView::~SdrObjEditView()
+{
+    mpTextEditWin = nullptr; // so there's no ShowCursor in SdrEndTextEdit
+    assert(!IsTextEdit());
+    if (IsTextEdit())
+        suppress_fun_call_w_exception(SdrEndTextEdit());
+    mpTextEditOutliner.reset();
+    assert(nullptr == mpOldTextEditUndoManager); // should have been reset
+}
+
+bool SdrObjEditView::IsAction() const { return IsMacroObj() || SdrGlueEditView::IsAction(); }
+
+void SdrObjEditView::MovAction(const Point& rPnt)
+{
+    if (IsMacroObj())
+        MovMacroObj(rPnt);
+    SdrGlueEditView::MovAction(rPnt);
+}
+
+void SdrObjEditView::EndAction()
+{
+    if (IsMacroObj())
+        EndMacroObj();
+    SdrGlueEditView::EndAction();
+}
+
+void SdrObjEditView::BckAction()
+{
+    BrkMacroObj();
+    SdrGlueEditView::BckAction();
+}
+
+void SdrObjEditView::BrkAction()
+{
+    BrkMacroObj();
+    SdrGlueEditView::BrkAction();
+}
+
+SdrPageView* SdrObjEditView::ShowSdrPage(SdrPage* pPage)
+{
+    SdrPageView* pPageView = SdrGlueEditView::ShowSdrPage(pPage);
+
+    if (comphelper::LibreOfficeKit::isActive() && pPageView)
+    {
+        // Check if other views have an active text edit on the same page as
+        // this one.
+        SdrViewIter::ForAllViews(pPageView->GetPage(), [this](SdrView* pView) {
+            if (pView == this || !pView->IsTextEdit())
+                return;
+
+            OutputDevice* pOutDev = GetFirstOutputDevice();
+            if (!pOutDev || pOutDev->GetOutDevType() != OUTDEV_WINDOW)
+                return;
+
+            // Found one, so create an outliner view, to get invalidations when
+            // the text edit changes.
+            // Call GetSfxViewShell() to make sure ImpMakeOutlinerView()
+            // registers the view shell of this draw view, and not the view
+            // shell of pView.
+            OutlinerView* pOutlinerView
+                = pView->ImpMakeOutlinerView(pOutDev->GetOwnerWindow(), nullptr, GetSfxViewShell());
+            pOutlinerView->HideCursor();
+            pView->GetTextEditOutliner()->InsertView(pOutlinerView);
+        });
+    }
+
+    return pPageView;
+}
+
+namespace
+{
+/// Removes outliner views registered in other draw views that use pOutputDevice.
+void lcl_RemoveTextEditOutlinerViews(SdrObjEditView const* pThis, SdrPageView const* pPageView,
+                                     OutputDevice const* pOutputDevice)
+{
+    if (!comphelper::LibreOfficeKit::isActive())
+        return;
+
+    if (!pPageView)
+        return;
+
+    if (!pOutputDevice || pOutputDevice->GetOutDevType() != OUTDEV_WINDOW)
+        return;
+
+    SdrViewIter::ForAllViews(pPageView->GetPage(), [&pThis, &pOutputDevice](SdrView* pView) {
+        if (pView == pThis || !pView->IsTextEdit())
+            return;
+
+        SdrOutliner* pOutliner = pView->GetTextEditOutliner();
+        for (size_t nView = 0; nView < pOutliner->GetViewCount(); ++nView)
+        {
+            OutlinerView* pOutlinerView = pOutliner->GetView(nView);
+            if (pOutlinerView->GetWindow()->GetOutDev() != pOutputDevice)
+                continue;
+
+            pOutliner->RemoveView(pOutlinerView);
+            delete pOutlinerView;
+        }
+    });
+}
+}
+
+void SdrObjEditView::HideSdrPage()
+{
+    lcl_RemoveTextEditOutlinerViews(this, GetSdrPageView(), GetFirstOutputDevice());
+
+    if (mpTextEditPV == GetSdrPageView())
+    {
+        // HideSdrPage() will clear mpPageView, avoid a dangling pointer.
+        mpTextEditPV = nullptr;
+    }
+
+    SdrGlueEditView::HideSdrPage();
+}
+
+void SdrObjEditView::TakeActionRect(tools::Rectangle& rRect) const
+{
+    if (IsMacroObj())
+    {
+        rRect = pMacroObj->GetCurrentBoundRect();
+    }
+    else
+    {
+        SdrGlueEditView::TakeActionRect(rRect);
+    }
+}
+
+void SdrObjEditView::Notify(SfxBroadcaster& rBC, const SfxHint& rHint)
+{
+    SdrGlueEditView::Notify(rBC, rHint);
+    if (mpTextEditOutliner == nullptr)
+        return;
+
+    // change of printer while editing
+    if (rHint.GetId() != SfxHintId::ThisIsAnSdrHint)
+        return;
+
+    const SdrHint* pSdrHint = static_cast<const SdrHint*>(&rHint);
+    SdrHintKind eKind = pSdrHint->GetKind();
+    if (eKind == SdrHintKind::RefDeviceChange)
+    {
+        mpTextEditOutliner->SetRefDevice(GetModel().GetRefDevice());
+    }
+    if (eKind == SdrHintKind::DefaultTabChange)
+    {
+        mpTextEditOutliner->SetDefTab(GetModel().GetDefaultTabulator());
+    }
+}
+
+void SdrObjEditView::ModelHasChanged()
+{
+    SdrGlueEditView::ModelHasChanged();
+    rtl::Reference<SdrTextObj> pTextObj = mxWeakTextEditObj.get();
+    if (pTextObj && !pTextObj->IsInserted())
+        SdrEndTextEdit(); // object deleted
+    // TextEditObj changed?
+    if (!IsTextEdit())
+        return;
+
+    if (pTextObj != nullptr)
+    {
+        size_t nOutlViewCnt = mpTextEditOutliner->GetViewCount();
+        bool bAreaChg = false;
+        bool bAnchorChg = false;
+        bool bColorChg = false;
+        bool bContourFrame = pTextObj->IsContourTextFrame();
+        EEAnchorMode eNewAnchor(EEAnchorMode::VCenterHCenter);
+        tools::Rectangle aOldArea(aMinTextEditArea);
+        aOldArea.Union(aTextEditArea);
+        Color aNewColor;
+        { // check area
+            Size aPaperMin1;
+            Size aPaperMax1;
+            tools::Rectangle aEditArea1;
+            tools::Rectangle aMinArea1;
+            pTextObj->TakeTextEditArea(&aPaperMin1, &aPaperMax1, &aEditArea1, &aMinArea1);
+            Point aPvOfs(pTextObj->GetTextEditOffset());
+
+            // add possible GridOffset to up-to-now view-independent EditAreas
+            basegfx::B2DVector aGridOffset(0.0, 0.0);
+            if (getPossibleGridOffsetForSdrObject(aGridOffset, pTextObj.get(), GetSdrPageView()))
+            {
+                const Point aOffset(basegfx::fround(aGridOffset.getX()),
+                                    basegfx::fround(aGridOffset.getY()));
+
+                aEditArea1 += aOffset;
+                aMinArea1 += aOffset;
+            }
+
+            aEditArea1.Move(aPvOfs.X(), aPvOfs.Y());
+            aMinArea1.Move(aPvOfs.X(), aPvOfs.Y());
+            tools::Rectangle aNewArea(aMinArea1);
+            aNewArea.Union(aEditArea1);
+
+            if (aNewArea != aOldArea || aEditArea1 != aTextEditArea || aMinArea1 != aMinTextEditArea
+                || mpTextEditOutliner->GetMinAutoPaperSize() != aPaperMin1
+                || mpTextEditOutliner->GetMaxAutoPaperSize() != aPaperMax1)
+            {
+                aTextEditArea = aEditArea1;
+                aMinTextEditArea = aMinArea1;
+
+                const bool bPrevUpdateLayout = mpTextEditOutliner->SetUpdateLayout(false);
+                mpTextEditOutliner->SetMinAutoPaperSize(aPaperMin1);
+                mpTextEditOutliner->SetMaxAutoPaperSize(aPaperMax1);
+                mpTextEditOutliner->SetPaperSize(Size(0, 0)); // re-format Outliner
+
+                if (!bContourFrame)
+                {
+                    mpTextEditOutliner->ClearPolygon();
+                    EEControlBits nStat = mpTextEditOutliner->GetControlWord();
+                    nStat |= EEControlBits::AUTOPAGESIZE;
+                    mpTextEditOutliner->SetControlWord(nStat);
+                }
+                else
+                {
+                    EEControlBits nStat = mpTextEditOutliner->GetControlWord();
+                    nStat &= ~EEControlBits::AUTOPAGESIZE;
+                    mpTextEditOutliner->SetControlWord(nStat);
+                    tools::Rectangle aAnchorRect;
+                    pTextObj->TakeTextAnchorRect(aAnchorRect);
+                    pTextObj->ImpSetContourPolygon(*mpTextEditOutliner, aAnchorRect, true);
+                }
+                for (size_t nOV = 0; nOV < nOutlViewCnt; nOV++)
+                {
+                    OutlinerView* pOLV = mpTextEditOutliner->GetView(nOV);
+                    EVControlBits nStat0 = pOLV->GetControlWord();
+                    EVControlBits nStat = nStat0;
+                    // AutoViewSize only if not ContourFrame.
+                    if (!bContourFrame)
+                        nStat |= EVControlBits::AUTOSIZE;
+                    else
+                        nStat &= ~EVControlBits::AUTOSIZE;
+                    if (nStat != nStat0)
+                        pOLV->SetControlWord(nStat);
+                }
+
+                mpTextEditOutliner->SetUpdateLayout(bPrevUpdateLayout);
+                bAreaChg = true;
+            }
+        }
+        if (mpTextEditOutlinerView != nullptr)
+        { // check fill and anchor
+            EEAnchorMode eOldAnchor = mpTextEditOutlinerView->GetAnchorMode();
+            eNewAnchor = pTextObj->GetOutlinerViewAnchorMode();
+            bAnchorChg = eOldAnchor != eNewAnchor;
+            Color aOldColor(mpTextEditOutlinerView->GetBackgroundColor());
+            aNewColor = GetTextEditBackgroundColor(*this);
+            bColorChg = aOldColor != aNewColor;
+        }
+        // refresh always when it's a contour frame. That
+        // refresh is necessary since it triggers the repaint
+        // which makes the Handles visible. Changes at TakeTextRect()
+        // seem to have resulted in a case where no refresh is executed.
+        // Before that, a refresh must have been always executed
+        // (else this error would have happened earlier), thus I
+        // even think here a refresh should be done always.
+        // Since follow-up problems cannot even be guessed I only
+        // add this one more case to the if below.
+        // BTW: It's VERY bad style that here, inside ModelHasChanged()
+        // the outliner is again massively changed for the text object
+        // in text edit mode. Normally, all necessary data should be
+        // set at SdrBeginTextEdit(). Some changes and value assigns in
+        // SdrBeginTextEdit() are completely useless since they are set here
+        // again on ModelHasChanged().
+        if (bContourFrame || bAreaChg || bAnchorChg || bColorChg)
+        {
+            for (size_t nOV = 0; nOV < nOutlViewCnt; nOV++)
+            {
+                OutlinerView* pOLV = mpTextEditOutliner->GetView(nOV);
+                { // invalidate old OutlinerView area
+                    vcl::Window* pWin = pOLV->GetWindow();
+                    tools::Rectangle aTmpRect(aOldArea);
+                    sal_uInt16 nPixSiz = pOLV->GetInvalidateMore() + 1;
+                    Size aMore(pWin->PixelToLogic(Size(nPixSiz, nPixSiz)));
+                    aTmpRect.AdjustLeft(-(aMore.Width()));
+                    aTmpRect.AdjustRight(aMore.Width());
+                    aTmpRect.AdjustTop(-(aMore.Height()));
+                    aTmpRect.AdjustBottom(aMore.Height());
+                    InvalidateOneWin(*pWin->GetOutDev(), aTmpRect);
+                }
+                if (bAnchorChg)
+                    pOLV->SetAnchorMode(eNewAnchor);
+                if (bColorChg)
+                    pOLV->SetBackgroundColor(aNewColor);
+
+                pOLV->SetOutputArea(
+                    aTextEditArea); // because otherwise, we're not re-anchoring correctly
+                ImpInvalidateOutlinerView(*pOLV);
+            }
+            mpTextEditOutlinerView->ShowCursor();
+        }
+    }
+    ImpMakeTextCursorAreaVisible();
+}
+
+namespace
+{
+class TextEditFrameOverlayObject;
+class TextEditHighContrastOverlaySelection;
+
+/**
+        Helper class to visualize the content of an active EditView as an
+        OverlayObject. These objects work with Primitives and are handled
+        from the OverlayManager(s) in place as needed.
+
+        It allows complete visualization of the content of the active
+        EditView without the need of Invalidates triggered by the EditView
+        and thus avoiding potentially expensive repaints by using the
+        automatically buffered Overlay mechanism.
+
+        It buffers as much as possible locally and *only* triggers a real
+        change (see call to objectChange()) when really needed.
+     */
+class TextEditOverlayObject : public sdr::overlay::OverlayObject
+{
+protected:
+    /// local access to associated sdr::overlay::OverlaySelection
+    std::unique_ptr<sdr::overlay::OverlaySelection> mxOverlayTransparentSelection;
+    std::unique_ptr<TextEditHighContrastOverlaySelection> mxOverlayHighContrastSelection;
+    std::unique_ptr<TextEditFrameOverlayObject> mxOverlayFrame;
+
+    /// local definition depends on active OutlinerView
+    OutlinerView& mrOutlinerView;
+
+    /// geometry definitions with buffering
+    basegfx::B2DRange maLastRange;
+    basegfx::B2DRange maRange;
+
+    /// text content definitions with buffering
+    drawinglayer::primitive2d::Primitive2DContainer maTextPrimitives;
+    drawinglayer::primitive2d::Primitive2DContainer maLastTextPrimitives;
+
+    // geometry creation for OverlayObject, can use local *Last* values
+    virtual drawinglayer::primitive2d::Primitive2DContainer
+    createOverlayObjectPrimitive2DSequence() override;
+
+public:
+    TextEditOverlayObject(const Color& rColor, OutlinerView& rOutlinerView);
+    virtual ~TextEditOverlayObject() override;
+
+    sdr::overlay::OverlayObject* getOverlaySelection();
+    sdr::overlay::OverlayObject* getOverlayFrame();
+
+    const OutlinerView& getOutlinerView() const { return mrOutlinerView; }
+
+    /// override to check conditions for last createOverlayObjectPrimitive2DSequence
+    virtual drawinglayer::primitive2d::Primitive2DContainer
+    getOverlayObjectPrimitive2DSequence() const override;
+
+    // data write access. In this OverlayObject we only have the
+    // callback that triggers detecting if something *has* changed
+    void checkDataChange(const basegfx::B2DRange& rMinTextEditArea);
+    void checkSelectionChange();
+
+    const basegfx::B2DRange& getRange() const { return maRange; }
+    const drawinglayer::primitive2d::Primitive2DContainer& getTextPrimitives() const
+    {
+        return maTextPrimitives;
+    }
+};
+
+class TextEditFrameOverlayObject : public sdr::overlay::OverlayObject
+{
+private:
+    const TextEditOverlayObject& mrTextEditOverlayObject;
+
+    // geometry creation for OverlayObject, can use local *Last* values
+    virtual drawinglayer::primitive2d::Primitive2DContainer
+    createOverlayObjectPrimitive2DSequence() override;
+
+public:
+    TextEditFrameOverlayObject(const TextEditOverlayObject& rTextEditOverlayObject);
+    using sdr::overlay::OverlayObject::objectChange;
+    virtual ~TextEditFrameOverlayObject() override;
+};
+
+class TextEditHighContrastOverlaySelection : public sdr::overlay::OverlayObject
+{
+private:
+    const TextEditOverlayObject& mrTextEditOverlayObject;
+    std::vector<basegfx::B2DRange> maRanges;
+
+    // geometry creation for OverlayObject, can use local *Last* values
+    virtual drawinglayer::primitive2d::Primitive2DContainer
+    createOverlayObjectPrimitive2DSequence() override;
+
+public:
+    TextEditHighContrastOverlaySelection(const TextEditOverlayObject& rTextEditOverlayObject);
+    void setRanges(std::vector<basegfx::B2DRange>&& rNew);
+    virtual ~TextEditHighContrastOverlaySelection() override;
+};
+
+TextEditHighContrastOverlaySelection::TextEditHighContrastOverlaySelection(
+    const TextEditOverlayObject& rTextEditOverlayObject)
+    : OverlayObject(rTextEditOverlayObject.getBaseColor())
+    , mrTextEditOverlayObject(rTextEditOverlayObject)
+{
+    allowAntiAliase(rTextEditOverlayObject.allowsAntiAliase());
+    // use selection colors in HighContrast mode
+    mbHighContrastSelection = true;
+}
+
+void TextEditHighContrastOverlaySelection::setRanges(std::vector<basegfx::B2DRange>&& rNew)
+{
+    if (rNew != maRanges)
+    {
+        maRanges = std::move(rNew);
+        objectChange();
+    }
+}
+
+drawinglayer::primitive2d::Primitive2DContainer
+TextEditHighContrastOverlaySelection::createOverlayObjectPrimitive2DSequence()
+{
+    drawinglayer::primitive2d::Primitive2DContainer aRetval;
+
+    size_t nCount = maRanges.size();
+
+    if (nCount)
+    {
+        basegfx::B2DPolyPolygon aClipPolyPolygon;
+
+        basegfx::BColor aRGBColor(getBaseColor().getBColor());
+
+        for (size_t a = 0; a < nCount; ++a)
+            aClipPolyPolygon.append(basegfx::utils::createPolygonFromRect(maRanges[a]));
+
+        // This is used in high contrast mode, we will render the selection
+        // with the bg forced to the selection Highlight color and the fg color
+        // forced to the HighlightText color
+        aRetval.append(drawinglayer::primitive2d::Primitive2DReference(
+            new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D(
+                basegfx::B2DPolyPolygon(
+                    basegfx::utils::createPolygonFromRect(aClipPolyPolygon.getB2DRange())),
+                aRGBColor)));
+        aRetval.append(mrTextEditOverlayObject.getTextPrimitives());
+        aRetval.append(drawinglayer::primitive2d::Primitive2DReference(
+            new drawinglayer::primitive2d::MaskPrimitive2D(aClipPolyPolygon, std::move(aRetval))));
+    }
+
+    return aRetval;
+}
+
+TextEditHighContrastOverlaySelection::~TextEditHighContrastOverlaySelection()
+{
+    if (getOverlayManager())
+    {
+        getOverlayManager()->remove(*this);
+    }
+}
+
+sdr::overlay::OverlayObject* TextEditOverlayObject::getOverlaySelection()
+{
+    if (mxOverlayTransparentSelection)
+        return mxOverlayTransparentSelection.get();
+    return mxOverlayHighContrastSelection.get();
+}
+
+sdr::overlay::OverlayObject* TextEditOverlayObject::getOverlayFrame()
+{
+    if (!mxOverlayFrame)
+        mxOverlayFrame.reset(new TextEditFrameOverlayObject(*this));
+    return mxOverlayFrame.get();
+}
+
+drawinglayer::primitive2d::Primitive2DContainer
+TextEditOverlayObject::createOverlayObjectPrimitive2DSequence()
+{
+    drawinglayer::primitive2d::Primitive2DContainer aRetval;
+
+    // add buffered TextPrimitives
+    aRetval.append(maTextPrimitives);
+
+    return aRetval;
+}
+
+drawinglayer::primitive2d::Primitive2DContainer
+TextEditFrameOverlayObject::createOverlayObjectPrimitive2DSequence()
+{
+    drawinglayer::primitive2d::Primitive2DContainer aRetval;
+
+    /// outer frame visualization
+    const double fTransparence(SvtOptionsDrawinglayer::GetTransparentSelectionPercent() * 0.01);
+    const sal_uInt16 nPixSiz(mrTextEditOverlayObject.getOutlinerView().GetInvalidateMore() - 1);
+
+    aRetval.push_back(new drawinglayer::primitive2d::OverlayRectanglePrimitive(
+        mrTextEditOverlayObject.getRange(), getBaseColor().getBColor(), fTransparence,
+        std::max(6, nPixSiz - 2), // grow
+        0.0, // shrink
+        0.0));
+
+    return aRetval;
+}
+
+TextEditOverlayObject::TextEditOverlayObject(const Color& rColor, OutlinerView& rOutlinerView)
+    : OverlayObject(rColor)
+    , mrOutlinerView(rOutlinerView)
+{
+    // no AA for TextEdit overlay
+    allowAntiAliase(false);
+
+    // create local OverlaySelection - this is an integral part of EditText
+    // visualization
+    if (Application::GetSettings().GetStyleSettings().GetHighContrastMode())
+    {
+        mxOverlayHighContrastSelection.reset(new TextEditHighContrastOverlaySelection(*this));
+    }
+    else
+    {
+        std::vector<basegfx::B2DRange> aEmptySelection{};
+        mxOverlayTransparentSelection.reset(new sdr::overlay::OverlaySelection(
+            sdr::overlay::OverlayType::Transparent, rColor, std::move(aEmptySelection), true));
+    }
+}
+
+TextEditOverlayObject::~TextEditOverlayObject()
+{
+    mxOverlayTransparentSelection.reset();
+    mxOverlayHighContrastSelection.reset();
+
+    if (getOverlayManager())
+    {
+        getOverlayManager()->remove(*this);
+    }
+}
+
+TextEditFrameOverlayObject::TextEditFrameOverlayObject(
+    const TextEditOverlayObject& rTextEditOverlayObject)
+    : OverlayObject(rTextEditOverlayObject.getBaseColor())
+    , mrTextEditOverlayObject(rTextEditOverlayObject)
+{
+    allowAntiAliase(rTextEditOverlayObject.allowsAntiAliase());
+    // use selection colors in HighContrast mode
+    mbHighContrastSelection = true;
+}
+
+TextEditFrameOverlayObject::~TextEditFrameOverlayObject()
+{
+    if (getOverlayManager())
+    {
+        getOverlayManager()->remove(*this);
+    }
+}
+
+drawinglayer::primitive2d::Primitive2DContainer
+TextEditOverlayObject::getOverlayObjectPrimitive2DSequence() const
+{
+    if (!getPrimitive2DSequence().empty())
+    {
+        if (!maRange.equal(maLastRange) || maLastTextPrimitives != maTextPrimitives)
+        {
+            // conditions of last local decomposition have changed, delete to force new evaluation
+            const_cast<TextEditOverlayObject*>(this)->resetPrimitive2DSequence();
+        }
+    }
+
+    if (getPrimitive2DSequence().empty())
+    {
+        // remember new buffered values
+        const_cast<TextEditOverlayObject*>(this)->maLastRange = maRange;
+        const_cast<TextEditOverlayObject*>(this)->maLastTextPrimitives = maTextPrimitives;
+    }
+
+    // call base implementation
+    return OverlayObject::getOverlayObjectPrimitive2DSequence();
+}
+
+void TextEditOverlayObject::checkDataChange(const basegfx::B2DRange& rMinTextEditArea)
+{
+    bool bObjectChange(false);
+
+    // check current range
+    const tools::Rectangle aOutArea(mrOutlinerView.GetOutputArea());
+    basegfx::B2DRange aNewRange = vcl::unotools::b2DRectangleFromRectangle(aOutArea);
+    aNewRange.expand(rMinTextEditArea);
+
+    if (aNewRange != maRange)
+    {
+        maRange = aNewRange;
+        bObjectChange = true;
+    }
+
+    // check if text primitives did change
+    SdrOutliner* pSdrOutliner = dynamic_cast<SdrOutliner*>(getOutlinerView().GetOutliner());
+
+    if (pSdrOutliner)
+    {
+        // get TextPrimitives directly from active Outliner
+        basegfx::B2DHomMatrix aNewTransformA;
+        basegfx::B2DHomMatrix aNewTransformB;
+        basegfx::B2DRange aClipRange;
+        drawinglayer::primitive2d::Primitive2DContainer aNewTextPrimitives;
+
+        // active Outliner is always in unified oriented coordinate system (currently)
+        // so just translate to TopLeft of visible Range. Keep in mind that top-left
+        // depends on vertical text and top-to-bottom text attributes
+        const tools::Rectangle aVisArea(mrOutlinerView.GetVisArea());
+        const bool bVerticalWriting(pSdrOutliner->IsVertical());
+        const bool bTopToBottom(pSdrOutliner->IsTopToBottom());
+        const double fStartInX(bVerticalWriting && bTopToBottom
+                                   ? aOutArea.Right() - aVisArea.Left()
+                                   : aOutArea.Left() - aVisArea.Left());
+        const double fStartInY(bVerticalWriting && !bTopToBottom
+                                   ? aOutArea.Bottom() - aVisArea.Top()
+                                   : aOutArea.Top() - aVisArea.Top());
+
+        aNewTransformB.translate(fStartInX, fStartInY);
+
+        // get the current TextPrimitives. This is the most expensive part
+        // of this mechanism, it *may* be possible to buffer layouted
+        // primitives per ParaPortion with/in/dependent on the EditEngine
+        // content if needed. For now, get and compare
+        SdrTextObj::impDecomposeBlockTextPrimitiveDirect(
+            aNewTextPrimitives, *pSdrOutliner, aNewTransformA, aNewTransformB, aClipRange);
+
+        if (aNewTextPrimitives != maTextPrimitives)
+        {
+            maTextPrimitives = std::move(aNewTextPrimitives);
+            bObjectChange = true;
+        }
+    }
+
+    if (bObjectChange)
+    {
+        // if there really *was* a change signal the OverlayManager to
+        // refresh this object's visualization
+        objectChange();
+
+        if (mxOverlayFrame)
+            mxOverlayFrame->objectChange();
+
+        // on data change, always do a SelectionChange, too
+        // since the selection is an integral part of text visualization
+        checkSelectionChange();
+    }
+}
+
+void TextEditOverlayObject::checkSelectionChange()
+{
+    if (!(getOverlaySelection() && getOverlayManager()))
+        return;
+
+    std::vector<tools::Rectangle> aLogicRects;
+    std::vector<basegfx::B2DRange> aLogicRanges;
+    const Size aLogicPixel(getOverlayManager()->getOutputDevice().PixelToLogic(Size(1, 1)));
+
+    // get logic selection
+    getOutlinerView().GetSelectionRectangles(aLogicRects);
+
+    aLogicRanges.reserve(aLogicRects.size());
+    for (const auto& aRect : aLogicRects)
+    {
+        // convert from logic Rectangles to logic Ranges, do not forget to add
+        // one Unit (in this case logical units for one pixel, pre-calculated)
+        aLogicRanges.emplace_back(
+            aRect.Left() - aLogicPixel.Width(), aRect.Top() - aLogicPixel.Height(),
+            aRect.Right() + aLogicPixel.Width(), aRect.Bottom() + aLogicPixel.Height());
+    }
+
+    if (mxOverlayTransparentSelection)
+        mxOverlayTransparentSelection->setRanges(std::move(aLogicRanges));
+    else
+        mxOverlayHighContrastSelection->setRanges(std::move(aLogicRanges));
+}
+} // end of anonymous namespace
+
+// TextEdit
+
+// callback from the active EditView, forward to evtl. existing instances of the
+// TextEditOverlayObject(s). This will additionally update the selection which
+// is an integral part of the text visualization
+void SdrObjEditView::EditViewInvalidate(const tools::Rectangle&)
+{
+    if (!IsTextEdit())
+        return;
+
+    // MinTextRange may have changed. Forward it, too
+    const basegfx::B2DRange aMinTextRange
+        = vcl::unotools::b2DRectangleFromRectangle(aMinTextEditArea);
+
+    for (sal_uInt32 a(0); a < maTEOverlayGroup.count(); a++)
+    {
+        TextEditOverlayObject* pCandidate
+            = dynamic_cast<TextEditOverlayObject*>(&maTEOverlayGroup.getOverlayObject(a));
+
+        if (pCandidate)
+        {
+            pCandidate->checkDataChange(aMinTextRange);
+        }
+    }
+}
+
+// callback from the active EditView, forward to evtl. existing instances of the
+// TextEditOverlayObject(s). This cvall *only* updates the selection visualization
+// which is e.g. used when only the selection is changed, but not the text
+void SdrObjEditView::EditViewSelectionChange()
+{
+    if (!IsTextEdit())
+        return;
+
+    for (sal_uInt32 a(0); a < maTEOverlayGroup.count(); a++)
+    {
+        TextEditOverlayObject* pCandidate
+            = dynamic_cast<TextEditOverlayObject*>(&maTEOverlayGroup.getOverlayObject(a));
+
+        if (pCandidate)
+        {
+            pCandidate->checkSelectionChange();
+        }
+    }
+}
+
+OutputDevice& SdrObjEditView::EditViewOutputDevice() const { return *mpTextEditWin->GetOutDev(); }
+
+Point SdrObjEditView::EditViewPointerPosPixel() const
+{
+    return mpTextEditWin->GetPointerPosPixel();
+}
+
+css::uno::Reference<css::datatransfer::clipboard::XClipboard> SdrObjEditView::GetClipboard() const
+{
+    if (!mpTextEditWin)
+        return nullptr;
+    return mpTextEditWin->GetClipboard();
+}
+
+css::uno::Reference<css::datatransfer::dnd::XDropTarget> SdrObjEditView::GetDropTarget()
+{
+    if (!mpTextEditWin)
+        return nullptr;
+    return mpTextEditWin->GetDropTarget();
+}
+
+void SdrObjEditView::EditViewInputContext(const InputContext& rInputContext)
+{
+    if (!mpTextEditWin)
+        return;
+    mpTextEditWin->SetInputContext(rInputContext);
+}
+
+void SdrObjEditView::EditViewCursorRect(const tools::Rectangle& rRect, int nExtTextInputWidth)
+{
+    if (!mpTextEditWin)
+        return;
+    mpTextEditWin->SetCursorRect(&rRect, nExtTextInputWidth);
+}
+
+void SdrObjEditView::TextEditDrawing(SdrPaintWindow& rPaintWindow)
+{
+    if (!comphelper::LibreOfficeKit::isActive())
+    {
+        // adapt all TextEditOverlayObject(s), so call EditViewInvalidate()
+        // to update accordingly (will update selection, too). Suppress new
+        // stuff when LibreOfficeKit is active
+        EditViewInvalidate(tools::Rectangle());
+    }
+    else
+    {
+        // draw old text edit stuff
+        if (IsTextEdit())
+        {
+            const SdrOutliner* pActiveOutliner = GetTextEditOutliner();
+
+            if (pActiveOutliner)
+            {
+                const sal_uInt32 nViewCount(pActiveOutliner->GetViewCount());
+
+                if (nViewCount)
+                {
+                    const vcl::Region& rRedrawRegion = rPaintWindow.GetRedrawRegion();
+                    const tools::Rectangle aCheckRect(rRedrawRegion.GetBoundRect());
+
+                    for (sal_uInt32 i(0); i < nViewCount; i++)
+                    {
+                        OutlinerView* pOLV = pActiveOutliner->GetView(i);
+
+                        // If rPaintWindow knows that the output device is a render
+                        // context and is aware of the underlying vcl::Window,
+                        // compare against that; that's how double-buffering can
+                        // still find the matching OutlinerView.
+                        OutputDevice* pOutputDevice = rPaintWindow.GetWindow()
+                                                          ? rPaintWindow.GetWindow()->GetOutDev()
+                                                          : &rPaintWindow.GetOutputDevice();
+                        if (pOLV->GetWindow()->GetOutDev() == pOutputDevice
+                            || comphelper::LibreOfficeKit::isActive())
+                        {
+                            ImpPaintOutlinerView(*pOLV, aCheckRect,
+                                                 rPaintWindow.GetTargetOutputDevice());
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+void SdrObjEditView::ImpPaintOutlinerView(OutlinerView& rOutlView, const tools::Rectangle& rRect,
+                                          OutputDevice& rTargetDevice) const
+{
+    const SdrTextObj* pText = GetTextEditObject();
+    bool bTextFrame(pText && pText->IsTextFrame());
+    bool bFitToSize(mpTextEditOutliner->GetControlWord() & EEControlBits::STRETCHING);
+    bool bModified(mpTextEditOutliner->IsModified());
+    tools::Rectangle aBlankRect(rOutlView.GetOutputArea());
+    aBlankRect.Union(aMinTextEditArea);
+    tools::Rectangle aPixRect(rTargetDevice.LogicToPixel(aBlankRect));
+
+    // in the tiled rendering case, the setup is incomplete, and we very
+    // easily get an empty rRect on input - that will cause that everything is
+    // clipped; happens in case of editing text inside a shape in Calc.
+    // FIXME would be better to complete the setup so that we don't get an
+    // empty rRect here
+    if (!comphelper::LibreOfficeKit::isActive() || !rRect.IsEmpty())
+        aBlankRect.Intersection(rRect);
+
+    rOutlView.GetOutliner()->SetUpdateLayout(true); // Bugfix #22596#
+    rOutlView.Paint(aBlankRect, &rTargetDevice);
+
+    if (!bModified)
+    {
+        mpTextEditOutliner->ClearModifyFlag();
+    }
+
+    if (bTextFrame && !bFitToSize)
+    {
+        // completely reworked to use primitives; this ensures same look and functionality
+        const drawinglayer::geometry::ViewInformation2D aViewInformation2D;
+        std::unique_ptr<drawinglayer::processor2d::BaseProcessor2D> xProcessor(
+            drawinglayer::processor2d::createProcessor2DFromOutputDevice(rTargetDevice,
+                                                                         aViewInformation2D));
+
+        const bool bMapModeEnabled(rTargetDevice.IsMapModeEnabled());
+        const basegfx::B2DRange aRange = vcl::unotools::b2DRectangleFromRectangle(aPixRect);
+        const Color aHilightColor(SvtOptionsDrawinglayer::getHilightColor());
+        const double fTransparence(SvtOptionsDrawinglayer::GetTransparentSelectionPercent() * 0.01);
+        const sal_uInt16 nPixSiz(rOutlView.GetInvalidateMore() - 1);
+        const drawinglayer::primitive2d::Primitive2DReference xReference(
+            new drawinglayer::primitive2d::OverlayRectanglePrimitive(
+                aRange, aHilightColor.getBColor(), fTransparence, std::max(6, nPixSiz - 2), // grow
+                0.0, // shrink
+                0.0));
+        const drawinglayer::primitive2d::Primitive2DContainer aSequence{ xReference };
+
+        rTargetDevice.EnableMapMode(false);
+        xProcessor->process(aSequence);
+        rTargetDevice.EnableMapMode(bMapModeEnabled);
+    }
+
+    rOutlView.ShowCursor(/*bGotoCursor=*/true, /*bActivate=*/true);
+}
+
+void SdrObjEditView::ImpInvalidateOutlinerView(OutlinerView const& rOutlView) const
+{
+    vcl::Window* pWin = rOutlView.GetWindow();
+
+    if (!pWin)
+        return;
+
+    const SdrTextObj* pText = GetTextEditObject();
+    bool bTextFrame(pText && pText->IsTextFrame());
+    bool bFitToSize(pText && pText->IsFitToSize());
+
+    if (!bTextFrame || bFitToSize)
+        return;
+
+    tools::Rectangle aBlankRect(rOutlView.GetOutputArea());
+    aBlankRect.Union(aMinTextEditArea);
+    tools::Rectangle aPixRect(pWin->LogicToPixel(aBlankRect));
+    sal_uInt16 nPixSiz(rOutlView.GetInvalidateMore() - 1);
+
+    aPixRect.AdjustLeft(-1);
+    aPixRect.AdjustTop(-1);
+    aPixRect.AdjustRight(1);
+    aPixRect.AdjustBottom(1);
+
+    {
+        // limit xPixRect because of driver problems when pixel coordinates are too far out
+        Size aMaxXY(pWin->GetOutputSizePixel());
+        tools::Long a(2 * nPixSiz);
+        tools::Long nMaxX(aMaxXY.Width() + a);
+        tools::Long nMaxY(aMaxXY.Height() + a);
+
+        if (aPixRect.Left() < -a)
+            aPixRect.SetLeft(-a);
+        if (aPixRect.Top() < -a)
+            aPixRect.SetTop(-a);
+        if (aPixRect.Right() > nMaxX)
+            aPixRect.SetRight(nMaxX);
+        if (aPixRect.Bottom() > nMaxY)
+            aPixRect.SetBottom(nMaxY);
+    }
+
+    tools::Rectangle aOuterPix(aPixRect);
+    aOuterPix.AdjustLeft(-nPixSiz);
+    aOuterPix.AdjustTop(-nPixSiz);
+    aOuterPix.AdjustRight(nPixSiz);
+    aOuterPix.AdjustBottom(nPixSiz);
+
+    bool bMapModeEnabled(pWin->IsMapModeEnabled());
+    pWin->EnableMapMode(false);
+    pWin->Invalidate(aOuterPix);
+    pWin->EnableMapMode(bMapModeEnabled);
+}
+
+OutlinerView* SdrObjEditView::ImpMakeOutlinerView(vcl::Window* pWin, OutlinerView* pGivenView,
+                                                  SfxViewShell* pViewShell) const
+{
+    // background
+    Color aBackground(GetTextEditBackgroundColor(*this));
+    rtl::Reference<SdrTextObj> pText = mxWeakTextEditObj.get();
+    bool bTextFrame = pText != nullptr && pText->IsTextFrame();
+    bool bContourFrame = pText != nullptr && pText->IsContourTextFrame();
+    // create OutlinerView
+    OutlinerView* pOutlView = pGivenView;
+    mpTextEditOutliner->SetUpdateLayout(false);
+
+    if (pOutlView == nullptr)
+    {
+        pOutlView = new OutlinerView(mpTextEditOutliner.get(), pWin);
+    }
+    else
+    {
+        pOutlView->SetWindow(pWin);
+    }
+
+    if (mbNegativeX)
+        pOutlView->GetEditView().SetNegativeX(mbNegativeX);
+
+    // disallow scrolling
+    EVControlBits nStat = pOutlView->GetControlWord();
+    nStat &= ~EVControlBits::AUTOSCROLL;
+    // AutoViewSize only if not ContourFrame.
+    if (!bContourFrame)
+        nStat |= EVControlBits::AUTOSIZE;
+    if (bTextFrame)
+    {
+        sal_uInt16 nPixSiz = maHdlList.GetHdlSize() * 2 + 1;
+        nStat |= EVControlBits::INVONEMORE;
+        pOutlView->SetInvalidateMore(nPixSiz);
+    }
+    pOutlView->SetControlWord(nStat);
+    pOutlView->SetBackgroundColor(aBackground);
+
+    // In case we're in the process of constructing a new view shell,
+    // SfxViewShell::Current() may still point to the old one. So if possible,
+    // depend on the application owning this draw view to provide the view
+    // shell.
+    SfxViewShell* pSfxViewShell = pViewShell ? pViewShell : GetSfxViewShell();
+    pOutlView->RegisterViewShell(pSfxViewShell ? pSfxViewShell : SfxViewShell::Current());
+
+    if (pText != nullptr)
+    {
+        pOutlView->SetAnchorMode(pText->GetOutlinerViewAnchorMode());
+        mpTextEditOutliner->SetFixedCellHeight(
+            pText->GetMergedItem(SDRATTR_TEXT_USEFIXEDCELLHEIGHT).GetValue());
+    }
+    // do update before setting output area so that aTextEditArea can be recalculated
+    mpTextEditOutliner->SetUpdateLayout(true);
+    pOutlView->SetOutputArea(aTextEditArea);
+    ImpInvalidateOutlinerView(*pOutlView);
+    return pOutlView;
+}
+
+IMPL_LINK(SdrObjEditView, ImpOutlinerStatusEventHdl, EditStatus&, rEditStat, void)
+{
+    if (mpTextEditOutliner)
+    {
+        rtl::Reference<SdrTextObj> pTextObj = mxWeakTextEditObj.get();
+        if (pTextObj)
+        {
+            pTextObj->onEditOutlinerStatusEvent(&rEditStat);
+        }
+    }
+}
+
+void SdrObjEditView::ImpChainingEventHdl()
+{
+    if (!mpTextEditOutliner)
+        return;
+
+    rtl::Reference<SdrTextObj> pTextObj = mxWeakTextEditObj.get();
+    OutlinerView* pOLV = GetTextEditOutlinerView();
+    if (pTextObj && pOLV)
+    {
+        TextChain* pTextChain = pTextObj->GetTextChain();
+
+        // XXX: IsChainable and GetNilChainingEvent are a bit mixed up atm
+        if (!pTextObj->IsChainable())
+        {
+            return;
+        }
+        // This is true during an underflow-caused overflow (with pEdtOutl->SetText())
+        if (pTextChain->GetNilChainingEvent(pTextObj.get()))
+        {
+            return;
+        }
+
+        // We prevent to trigger further handling of overflow/underflow for pTextObj
+        pTextChain->SetNilChainingEvent(pTextObj.get(), true); // XXX
+
+        // Save previous selection pos // NOTE: It must be done to have the right CursorEvent in KeyInput
+        pTextChain->SetPreChainingSel(pTextObj.get(), pOLV->GetSelection());
+        //maPreChainingSel = new ESelection(pOLV->GetSelection());
+
+        // Handling Undo
+        const int nText = 0; // XXX: hardcoded index (SdrTextObj::getText handles only 0)
+
+        const bool bUndoEnabled = IsUndoEnabled();
+        std::unique_ptr<SdrUndoObjSetText> pTxtUndo;
+        if (bUndoEnabled)
+            pTxtUndo.reset(
+                dynamic_cast<SdrUndoObjSetText*>(GetModel()
+                                                     .GetSdrUndoFactory()
+                                                     .CreateUndoObjectSetText(*pTextObj, nText)
+                                                     .release()));
+
+        // trigger actual chaining
+        pTextObj->onChainingEvent();
+
+        if (pTxtUndo)
+        {
+            pTxtUndo->AfterSetText();
+            if (!pTxtUndo->IsDifferent())
+            {
+                pTxtUndo.reset();
+            }
+        }
+
+        if (pTxtUndo)
+            AddUndo(std::move(pTxtUndo));
+
+        //maCursorEvent = new CursorChainingEvent(pTextChain->GetCursorEvent(pTextObj));
+        //SdrTextObj *pNextLink = pTextObj->GetNextLinkInChain();
+
+        // NOTE: Must be called. Don't let the function return if you set it to true and not reset it
+        pTextChain->SetNilChainingEvent(pTextObj.get(), false);
+    }
+    else
+    {
+        // XXX
+        SAL_INFO("svx.chaining", "[OnChaining] No Edit Outliner View");
+    }
+}
+
+IMPL_LINK_NOARG(SdrObjEditView, ImpAfterCutOrPasteChainingEventHdl, LinkParamNone*, void)
+{
+    SdrTextObj* pTextObj = GetTextEditObject();
+    if (!pTextObj)
+        return;
+    ImpChainingEventHdl();
+    TextChainCursorManager aCursorManager(this, pTextObj);
+    ImpMoveCursorAfterChainingEvent(&aCursorManager);
+}
+
+void SdrObjEditView::ImpMoveCursorAfterChainingEvent(TextChainCursorManager* pCursorManager)
+{
+    rtl::Reference<SdrTextObj> pTextObj = mxWeakTextEditObj.get();
+
+    if (!pTextObj || !pCursorManager)
+        return;
+
+    // Check if it has links to move it to
+    if (!pTextObj || !pTextObj->IsChainable())
+        return;
+
+    TextChain* pTextChain = pTextObj->GetTextChain();
+    ESelection aNewSel = pTextChain->GetPostChainingSel(pTextObj.get());
+
+    pCursorManager->HandleCursorEventAfterChaining(pTextChain->GetCursorEvent(pTextObj.get()),
+                                                   aNewSel);
+
+    // Reset event
+    pTextChain->SetCursorEvent(pTextObj.get(), CursorChainingEvent::NULL_EVENT);
+}
+
+IMPL_LINK(SdrObjEditView, ImpOutlinerCalcFieldValueHdl, EditFieldInfo*, pFI, void)
+{
+    bool bOk = false;
+    OUString& rStr = pFI->GetRepresentation();
+    rStr.clear();
+    rtl::Reference<SdrTextObj> pTextObj = mxWeakTextEditObj.get();
+    if (pTextObj != nullptr)
+    {
+        std::optional<Color> pTxtCol;
+        std::optional<Color> pFldCol;
+        std::optional<FontLineStyle> pFldLineStyle;
+        bOk = pTextObj->CalcFieldValue(pFI->GetField(), pFI->GetPara(), pFI->GetPos(), true,
+                                       pTxtCol, pFldCol, pFldLineStyle, rStr);
+        if (bOk)
+        {
+            if (pTxtCol)
+            {
+                pFI->SetTextColor(*pTxtCol);
+            }
+            if (pFldLineStyle)
+            {
+                pFI->SetFontLineStyle(*pFldLineStyle);
+            }
+            if (pFldCol)
+            {
+                pFI->SetFieldColor(*pFldCol);
+            }
+            else
+            {
+                pFI->SetFieldColor(COL_LIGHTGRAY); // TODO: remove this later on (357)
+            }
+        }
+    }
+    Outliner& rDrawOutl = GetModel().GetDrawOutliner(pTextObj.get());
+    Link<EditFieldInfo*, void> aDrawOutlLink = rDrawOutl.GetCalcFieldValueHdl();
+    if (!bOk && aDrawOutlLink.IsSet())
+    {
+        aDrawOutlLink.Call(pFI);
+        bOk = !rStr.isEmpty();
+    }
+    if (!bOk)
+    {
+        aOldCalcFieldValueLink.Call(pFI);
+    }
+}
+
+IMPL_LINK_NOARG(SdrObjEditView, EndTextEditHdl, SdrUndoManager*, void) { SdrEndTextEdit(); }
+
+// Default implementation - null UndoManager
+std::unique_ptr<SdrUndoManager> SdrObjEditView::createLocalTextUndoManager()
+{
+    SAL_WARN("svx", "SdrObjEditView::createLocalTextUndoManager needs to be overridden");
+    return std::unique_ptr<SdrUndoManager>();
+}
+
+bool SdrObjEditView::SdrBeginTextEdit(SdrObject* pObj_, SdrPageView* pPV, vcl::Window* pWin,
+                                      bool bIsNewObj, SdrOutliner* pGivenOutliner,
+                                      OutlinerView* pGivenOutlinerView, bool bDontDeleteOutliner,
+                                      bool bOnlyOneView, bool bGrabFocus)
+{
+    // FIXME cannot be an assert() yet, the code is not ready for that;
+    // eg. press F7 in Impress when you are inside a text object with spelling
+    // mistakes => boom; and it is unclear how to avoid that
+    SAL_WARN_IF(IsTextEdit(), "svx", "SdrBeginTextEdit called when IsTextEdit() is already true.");
+    // FIXME this encourages all sorts of bad habits and should be removed
+    SdrEndTextEdit();
+
+    SdrTextObj* pObj = DynCastSdrTextObj(pObj_);
+    if (!pObj)
+        return false; // currently only possible with text objects
+
+    if (bGrabFocus && pWin)
+    {
+        // attention, this call may cause an EndTextEdit() call to this view
+        pWin->GrabFocus(); // to force the cursor into the edit view
+    }
+
+    mbTextEditDontDelete = bDontDeleteOutliner && pGivenOutliner != nullptr;
+    mbTextEditOnlyOneView = bOnlyOneView;
+    mbTextEditNewObj = bIsNewObj;
+    const sal_uInt32 nWinCount(PaintWindowCount());
+
+    bool bBrk(false);
+
+    if (!pWin)
+    {
+        for (sal_uInt32 i = 0; i < nWinCount && !pWin; i++)
+        {
+            SdrPaintWindow* pPaintWindow = GetPaintWindow(i);
+
+            if (OUTDEV_WINDOW == pPaintWindow->GetOutputDevice().GetOutDevType())
+            {
+                pWin = pPaintWindow->GetOutputDevice().GetOwnerWindow();
+            }
+        }
+
+        // break, when no window exists
+        if (!pWin)
+        {
+            bBrk = true;
+        }
+    }
+
+    if (!bBrk && !pPV)
+    {
+        pPV = GetSdrPageView();
+
+        // break, when no PageView for the object exists
+        if (!pPV)
+        {
+            bBrk = true;
+        }
+    }
+
+    // no TextEdit on objects in locked Layer
+    if (pPV && pPV->GetLockedLayers().IsSet(pObj->GetLayer()))
+    {
+        bBrk = true;
+    }
+
+    if (mpTextEditOutliner)
+    {
+        OSL_FAIL("SdrObjEditView::SdrBeginTextEdit(): Old Outliner still exists.");
+        mpTextEditOutliner.reset();
+    }
+
+    if (!bBrk)
+    {
+        mpTextEditWin = pWin;
+        mpTextEditPV = pPV;
+        mxWeakTextEditObj = pObj;
+        if (pGivenOutliner)
+        {
+            mpTextEditOutliner.reset(pGivenOutliner);
+            pGivenOutliner = nullptr; // so we don't delete it on the error path
+        }
+        else
+            mpTextEditOutliner
+                = SdrMakeOutliner(OutlinerMode::TextObject, pObj->getSdrModelFromSdrObject());
+
+        {
+            mpTextEditOutliner->ForceAutoColor(SvtAccessibilityOptions::GetIsAutomaticFontColor());
+        }
+
+        aOldCalcFieldValueLink = mpTextEditOutliner->GetCalcFieldValueHdl();
+        // FieldHdl has to be set by SdrBeginTextEdit, because this call an UpdateFields
+        mpTextEditOutliner->SetCalcFieldValueHdl(
+            LINK(this, SdrObjEditView, ImpOutlinerCalcFieldValueHdl));
+        mpTextEditOutliner->SetBeginPasteOrDropHdl(LINK(this, SdrObjEditView, BeginPasteOrDropHdl));
+        mpTextEditOutliner->SetEndPasteOrDropHdl(LINK(this, SdrObjEditView, EndPasteOrDropHdl));
+
+        // It is just necessary to make the visualized page known. Set it.
+        mpTextEditOutliner->setVisualizedPage(pPV->GetPage());
+
+        rtl::Reference<SdrTextObj> pTextObj = mxWeakTextEditObj.get();
+        mpTextEditOutliner->SetTextObjNoInit(pTextObj.get());
+
+        if (pTextObj->BegTextEdit(*mpTextEditOutliner))
+        {
+            // switch off any running TextAnimations
+            pTextObj->SetTextAnimationAllowed(false);
+
+            // remember old cursor
+            if (mpTextEditOutliner->GetViewCount() != 0)
+            {
+                mpTextEditOutliner->RemoveView(static_cast<size_t>(0));
+            }
+
+            // Determine EditArea via TakeTextEditArea.
+            // TODO: This could theoretically be left out, because TakeTextRect() calculates the aTextEditArea,
+            // but aMinTextEditArea has to happen, too (therefore leaving this in right now)
+            pTextObj->TakeTextEditArea(nullptr, nullptr, &aTextEditArea, &aMinTextEditArea);
+
+            tools::Rectangle aTextRect;
+            tools::Rectangle aAnchorRect;
+            pTextObj->TakeTextRect(*mpTextEditOutliner, aTextRect, true,
+                                   &aAnchorRect /* Give true here, not false */);
+
+            if (!pTextObj->IsContourTextFrame())
+            {
+                // FitToSize not together with ContourFrame, for now
+                if (pTextObj->IsFitToSize())
+                    aTextRect = aAnchorRect;
+            }
+
+            aTextEditArea = aTextRect;
+
+            // add possible GridOffset to up-to-now view-independent EditAreas
+            basegfx::B2DVector aGridOffset(0.0, 0.0);
+            if (getPossibleGridOffsetForSdrObject(aGridOffset, pTextObj.get(), pPV))
+            {
+                const Point aOffset(basegfx::fround(aGridOffset.getX()),
+                                    basegfx::fround(aGridOffset.getY()));
+
+                aTextEditArea += aOffset;
+                aMinTextEditArea += aOffset;
+            }
+
+            Point aPvOfs(pTextObj->GetTextEditOffset());
+            aTextEditArea.Move(aPvOfs.X(), aPvOfs.Y());
+            aMinTextEditArea.Move(aPvOfs.X(), aPvOfs.Y());
+            pTextEditCursorBuffer = pWin->GetCursor();
+
+            maHdlList.SetMoveOutside(true);
+
+            // Since IsMarkHdlWhenTextEdit() is ignored, it is necessary
+            // to call AdjustMarkHdl() always.
+            AdjustMarkHdl();
+
+            mpTextEditOutlinerView = ImpMakeOutlinerView(pWin, pGivenOutlinerView);
+
+            if (!comphelper::LibreOfficeKit::isActive() && mpTextEditOutlinerView)
+            {
+                // activate visualization of EditView on Overlay, suppress when
+                // LibreOfficeKit is active
+                mpTextEditOutlinerView->GetEditView().setEditViewCallbacks(this);
+
+                const Color aHilightColor(SvtOptionsDrawinglayer::getHilightColor());
+                const SdrTextObj* pText = GetTextEditObject();
+                // show for cases like tdf#94223 but not for table cells like tdf#151311
+                const bool bVisualizeSurroundingFrame(
+                    pText && pText->GetObjIdentifier() != SdrObjKind::Table);
+                SdrPageView* pPageView = GetSdrPageView();
+
+                if (pPageView)
+                {
+                    for (sal_uInt32 b(0); b < pPageView->PageWindowCount(); b++)
+                    {
+                        const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b);
+
+                        if (rPageWindow.GetPaintWindow().OutputToWindow())
+                        {
+                            const rtl::Reference<sdr::overlay::OverlayManager>& xManager
+                                = rPageWindow.GetOverlayManager();
+                            if (xManager.is())
+                            {
+                                std::unique_ptr<TextEditOverlayObject> pNewTextEditOverlayObject(
+                                    new TextEditOverlayObject(aHilightColor,
+                                                              *mpTextEditOutlinerView));
+
+                                xManager->add(*pNewTextEditOverlayObject);
+                                if (bVisualizeSurroundingFrame)
+                                    xManager->add(*pNewTextEditOverlayObject->getOverlayFrame());
+                                xManager->add(*pNewTextEditOverlayObject->getOverlaySelection());
+
+                                maTEOverlayGroup.append(std::move(pNewTextEditOverlayObject));
+                            }
+                        }
+                    }
+                }
+            }
+
+            // check if this view is already inserted
+            size_t i2, nCount = mpTextEditOutliner->GetViewCount();
+            for (i2 = 0; i2 < nCount; i2++)
+            {
+                if (mpTextEditOutliner->GetView(i2) == mpTextEditOutlinerView)
+                    break;
+            }
+
+            if (i2 == nCount)
+                mpTextEditOutliner->InsertView(mpTextEditOutlinerView, 0);
+
+            maHdlList.SetMoveOutside(false);
+            maHdlList.SetMoveOutside(true);
+
+            // register all windows as OutlinerViews with the Outliner
+            if (!bOnlyOneView)
+            {
+                for (sal_uInt32 i = 0; i < nWinCount; i++)
+                {
+                    SdrPaintWindow* pPaintWindow = GetPaintWindow(i);
+                    OutputDevice& rOutDev = pPaintWindow->GetOutputDevice();
+
+                    if (&rOutDev != pWin->GetOutDev() && OUTDEV_WINDOW == rOutDev.GetOutDevType())
+                    {
+                        OutlinerView* pOutlView
+                            = ImpMakeOutlinerView(rOutDev.GetOwnerWindow(), nullptr);
+                        mpTextEditOutliner->InsertView(pOutlView, static_cast<sal_uInt16>(i));
+                    }
+                }
+
+                if (comphelper::LibreOfficeKit::isActive())
+                {
+                    // Register an outliner view for all other sdr views that
+                    // show the same page, so that when the text edit changes,
+                    // all interested windows get an invalidation.
+                    SdrViewIter::ForAllViews(pObj->getSdrPageFromSdrObject(), [this, &pWin](
+                                                                                  SdrView* pView) {
+                        if (pView == this)
+                            return;
+
+                        for (sal_uInt32 nViewPaintWindow = 0;
+                             nViewPaintWindow < pView->PaintWindowCount(); ++nViewPaintWindow)
+                        {
+                            SdrPaintWindow* pPaintWindow = pView->GetPaintWindow(nViewPaintWindow);
+                            OutputDevice& rOutDev = pPaintWindow->GetOutputDevice();
+
+                            if (&rOutDev != pWin->GetOutDev()
+                                && OUTDEV_WINDOW == rOutDev.GetOutDevType())
+                            {
+                                OutlinerView* pOutlView
+                                    = ImpMakeOutlinerView(rOutDev.GetOwnerWindow(), nullptr);
+                                pOutlView->HideCursor();
+                                rOutDev.GetOwnerWindow()->SetCursor(nullptr);
+                                mpTextEditOutliner->InsertView(pOutlView);
+                            }
+                        }
+                    });
+                }
+            }
+
+            mpTextEditOutlinerView->ShowCursor();
+            mpTextEditOutliner->SetStatusEventHdl(
+                LINK(this, SdrObjEditView, ImpOutlinerStatusEventHdl));
+            if (pTextObj->IsChainable())
+            {
+                mpTextEditOutlinerView->SetEndCutPasteLinkHdl(
+                    LINK(this, SdrObjEditView, ImpAfterCutOrPasteChainingEventHdl));
+            }
+
+            mpTextEditOutliner->ClearModifyFlag();
+
+            if (pTextObj->IsFitToSize())
+            {
+                pWin->Invalidate(aTextEditArea);
+            }
+
+            SdrHint aHint(SdrHintKind::BeginEdit, *pTextObj);
+            GetModel().Broadcast(aHint);
+
+            mpTextEditOutliner->setVisualizedPage(nullptr);
+
+            if (mxSelectionController.is())
+                mxSelectionController->onSelectionHasChanged();
+
+            if (IsUndoEnabled() && !GetModel().GetDisableTextEditUsesCommonUndoManager())
+            {
+                SdrUndoManager* pSdrUndoManager = nullptr;
+                mpLocalTextEditUndoManager = createLocalTextUndoManager();
+
+                if (mpLocalTextEditUndoManager)
+                    pSdrUndoManager = mpLocalTextEditUndoManager.get();
+
+                if (pSdrUndoManager)
+                {
+                    // we have an outliner, undo manager and it's an EditUndoManager, exchange
+                    // the document undo manager and the default one from the outliner and tell
+                    // it that text edit starts by setting a callback if it needs to end text edit mode.
+                    assert(nullptr == mpOldTextEditUndoManager);
+
+                    mpOldTextEditUndoManager = mpTextEditOutliner->SetUndoManager(pSdrUndoManager);
+                    pSdrUndoManager->SetEndTextEditHdl(LINK(this, SdrObjEditView, EndTextEditHdl));
+                }
+                else
+                {
+                    OSL_ENSURE(false,
+                               "The document undo manager is not derived from SdrUndoManager (!)");
+                }
+            }
+
+            return true; // ran fine, let TextEdit run now
+        }
+        else
+        {
+            mpTextEditOutliner->SetCalcFieldValueHdl(aOldCalcFieldValueLink);
+            mpTextEditOutliner->SetBeginPasteOrDropHdl(Link<PasteOrDropInfos*, void>());
+            mpTextEditOutliner->SetEndPasteOrDropHdl(Link<PasteOrDropInfos*, void>());
+        }
+    }
+    if (mpTextEditOutliner != nullptr)
+    {
+        mpTextEditOutliner->setVisualizedPage(nullptr);
+    }
+
+    // something went wrong...
+    if (!bDontDeleteOutliner)
+    {
+        delete pGivenOutliner;
+        if (pGivenOutlinerView != nullptr)
+        {
+            delete pGivenOutlinerView;
+            pGivenOutlinerView = nullptr;
+        }
+    }
+    mpTextEditOutliner.reset();
+
+    mpTextEditOutlinerView = nullptr;
+    mxWeakTextEditObj.clear();
+    mpTextEditPV = nullptr;
+    mpTextEditWin = nullptr;
+    maHdlList.SetMoveOutside(false);
+
+    return false;
+}
+
+SdrEndTextEditKind SdrObjEditView::SdrEndTextEdit(bool bDontDeleteReally)
+{
+    SdrEndTextEditKind eRet = SdrEndTextEditKind::Unchanged;
+    rtl::Reference<SdrTextObj> pTEObj = mxWeakTextEditObj.get();
+    vcl::Window* pTEWin = mpTextEditWin;
+    OutlinerView* pTEOutlinerView = mpTextEditOutlinerView;
+    vcl::Cursor* pTECursorBuffer = pTextEditCursorBuffer;
+    SdrUndoManager* pUndoEditUndoManager = nullptr;
+    bool bNeedToUndoSavedRedoTextEdit(false);
+
+    if (IsUndoEnabled() && pTEObj && mpTextEditOutliner
+        && !GetModel().GetDisableTextEditUsesCommonUndoManager())
+    {
+        // change back the UndoManager to the remembered original one
+        SfxUndoManager* pOriginal = mpTextEditOutliner->SetUndoManager(mpOldTextEditUndoManager);
+        mpOldTextEditUndoManager = nullptr;
+
+        if (pOriginal)
+        {
+            // check if we got back our document undo manager
+            SdrUndoManager* pSdrUndoManager = mpLocalTextEditUndoManager.get();
+
+            if (pSdrUndoManager && dynamic_cast<SdrUndoManager*>(pOriginal) == pSdrUndoManager)
+            {
+                if (pSdrUndoManager->isEndTextEditTriggeredFromUndo())
+                {
+                    // remember the UndoManager where missing Undos have to be triggered after end
+                    // text edit. When the undo had triggered the end text edit, the original action
+                    // which had to be undone originally is not yet undone.
+                    pUndoEditUndoManager = pSdrUndoManager;
+
+                    // We are ending text edit; if text edit was triggered from undo, execute all redos
+                    // to create a complete text change undo action for the redo buffer. Also mark this
+                    // state when at least one redo was executed; the created extra TextChange needs to
+                    // be undone in addition to the first real undo outside the text edit changes
+                    while (pSdrUndoManager->GetRedoActionCount()
+                           > pSdrUndoManager->GetRedoActionCountBeforeTextEdit())
+                    {
+                        bNeedToUndoSavedRedoTextEdit = true;
+                        pSdrUndoManager->Redo();
+                    }
+                }
+
+                // reset the callback link and let the undo manager cleanup all text edit
+                // undo actions to get the stack back to the form before the text edit
+                pSdrUndoManager->SetEndTextEditHdl(Link<SdrUndoManager*, void>());
+            }
+            else
+            {
+                OSL_ENSURE(false, "Got UndoManager back in SdrEndTextEdit which is NOT the "
+                                  "expected document UndoManager (!)");
+                delete pOriginal;
+            }
+
+            // cid#1493241 - Wrapper object use after free
+            if (pUndoEditUndoManager == mpLocalTextEditUndoManager.get())
+                pUndoEditUndoManager = nullptr;
+            mpLocalTextEditUndoManager.reset();
+        }
+    }
+    else
+    {
+        assert(nullptr == mpOldTextEditUndoManager); // cannot be restored!
+    }
+
+    if (auto pTextEditObj = mxWeakTextEditObj.get())
+    {
+        SdrHint aHint(SdrHintKind::EndEdit, *pTextEditObj);
+        GetModel().Broadcast(aHint);
+    }
+
+    // if new mechanism was used, clean it up. At cleanup no need to check
+    // for LibreOfficeKit
+    if (mpTextEditOutlinerView)
+    {
+        mpTextEditOutlinerView->GetEditView().setEditViewCallbacks(nullptr);
+        maTEOverlayGroup.clear();
+    }
+
+    mxWeakTextEditObj.clear();
+    mpTextEditPV = nullptr;
+    mpTextEditWin = nullptr;
+    mpTextEditOutlinerView = nullptr;
+    pTextEditCursorBuffer = nullptr;
+    aTextEditArea = tools::Rectangle();
+
+    if (SdrOutliner* pTEOutliner = mpTextEditOutliner.release())
+    {
+        bool bModified = pTEOutliner->IsModified();
+        if (pTEOutlinerView != nullptr)
+        {
+            pTEOutlinerView->HideCursor();
+        }
+        if (pTEObj != nullptr)
+        {
+            pTEOutliner->CompleteOnlineSpelling();
+
+            std::unique_ptr<SdrUndoObjSetText> pTxtUndo;
+
+            if (bModified)
+            {
+                sal_Int32 nText;
+                for (nText = 0; nText < pTEObj->getTextCount(); ++nText)
+                    if (pTEObj->getText(nText) == pTEObj->getActiveText())
+                        break;
+
+                pTxtUndo.reset(
+                    dynamic_cast<SdrUndoObjSetText*>(GetModel()
+                                                         .GetSdrUndoFactory()
+                                                         .CreateUndoObjectSetText(*pTEObj, nText)
+                                                         .release()));
+            }
+            DBG_ASSERT(!bModified || pTxtUndo,
+                       "svx::SdrObjEditView::EndTextEdit(), could not create undo action!");
+            // Set old CalcFieldValue-Handler again, this
+            // has to happen before Obj::EndTextEdit(), as this does UpdateFields().
+            pTEOutliner->SetCalcFieldValueHdl(aOldCalcFieldValueLink);
+            pTEOutliner->SetBeginPasteOrDropHdl(Link<PasteOrDropInfos*, void>());
+            pTEOutliner->SetEndPasteOrDropHdl(Link<PasteOrDropInfos*, void>());
+
+            const bool bUndo = IsUndoEnabled();
+            if (bUndo)
+            {
+                OUString aObjName(pTEObj->TakeObjNameSingul());
+                BegUndo(SvxResId(STR_UndoObjSetText), aObjName);
+            }
+
+            pTEObj->EndTextEdit(*pTEOutliner);
+
+            if ((pTEObj->GetRotateAngle() != 0_deg100) || (pTEObj && pTEObj->IsFontwork()))
+            {
+                pTEObj->ActionChanged();
+            }
+
+            if (pTxtUndo != nullptr)
+            {
+                pTxtUndo->AfterSetText();
+                if (!pTxtUndo->IsDifferent())
+                {
+                    pTxtUndo.reset();
+                }
+            }
+            // check deletion of entire TextObj
+            std::unique_ptr<SdrUndoAction> pDelUndo;
+            bool bDelObj = false;
+            if (mbTextEditNewObj)
+            {
+                bDelObj = pTEObj->IsTextFrame() && !pTEObj->HasText() && !pTEObj->IsEmptyPresObj()
+                          && !pTEObj->HasFill() && !pTEObj->HasLine();
+
+                if (pTEObj->IsInserted() && bDelObj
+                    && pTEObj->GetObjInventor() == SdrInventor::Default && !bDontDeleteReally)
+                {
+                    SdrObjKind eIdent = pTEObj->GetObjIdentifier();
+                    if (eIdent == SdrObjKind::Text)
+                    {
+                        pDelUndo = GetModel().GetSdrUndoFactory().CreateUndoDeleteObject(*pTEObj);
+                    }
+                }
+            }
+            if (pTxtUndo)
+            {
+                if (bUndo)
+                    AddUndo(std::move(pTxtUndo));
+                eRet = SdrEndTextEditKind::Changed;
+            }
+            if (pDelUndo != nullptr)
+            {
+                if (bUndo)
+                {
+                    AddUndo(std::move(pDelUndo));
+                }
+                eRet = SdrEndTextEditKind::Deleted;
+                DBG_ASSERT(pTEObj->getParentSdrObjListFromSdrObject() != nullptr,
+                           "SdrObjEditView::SdrEndTextEdit(): Fatal: Object edited doesn't have an "
+                           "ObjList!");
+                if (pTEObj->getParentSdrObjListFromSdrObject() != nullptr)
+                {
+                    pTEObj->getParentSdrObjListFromSdrObject()->RemoveObject(pTEObj->GetOrdNum());
+                    CheckMarked(); // remove selection immediately...
+                }
+            }
+            else if (bDelObj)
+            { // for Writer: the app has to do the deletion itself.
+                eRet = SdrEndTextEditKind::ShouldBeDeleted;
+            }
+
+            if (bUndo)
+                EndUndo(); // EndUndo after Remove, in case UndoStack is deleted immediately
+
+            // Switch on any TextAnimation again after TextEdit
+            if (pTEObj)
+            {
+                pTEObj->SetTextAnimationAllowed(true);
+            }
+
+            // Since IsMarkHdlWhenTextEdit() is ignored, it is necessary
+            // to call AdjustMarkHdl() always.
+            AdjustMarkHdl();
+        }
+        // delete all OutlinerViews
+        for (size_t i = pTEOutliner->GetViewCount(); i > 0;)
+        {
+            i--;
+            OutlinerView* pOLV = pTEOutliner->GetView(i);
+            sal_uInt16 nMorePix = pOLV->GetInvalidateMore() + 10;
+            vcl::Window* pWin = pOLV->GetWindow();
+            tools::Rectangle aRect(pOLV->GetOutputArea());
+            pTEOutliner->RemoveView(i);
+            if (!mbTextEditDontDelete || i != 0)
+            {
+                // may not own the zeroth one
+                delete pOLV;
+            }
+            aRect.Union(aTextEditArea);
+            aRect.Union(aMinTextEditArea);
+            aRect = pWin->LogicToPixel(aRect);
+            aRect.AdjustLeft(-nMorePix);
+            aRect.AdjustTop(-nMorePix);
+            aRect.AdjustRight(nMorePix);
+            aRect.AdjustBottom(nMorePix);
+            aRect = pWin->PixelToLogic(aRect);
+            InvalidateOneWin(*pWin->GetOutDev(), aRect);
+            pWin->GetOutDev()->SetFillColor();
+            pWin->GetOutDev()->SetLineColor(COL_BLACK);
+        }
+        // and now the Outliner itself
+        if (!mbTextEditDontDelete)
+            delete pTEOutliner;
+        else
+            pTEOutliner->Clear();
+        if (pTEWin != nullptr)
+        {
+            pTEWin->SetCursor(pTECursorBuffer);
+        }
+        maHdlList.SetMoveOutside(false);
+        if (eRet != SdrEndTextEditKind::Unchanged)
+        {
+            GetMarkedObjectListWriteAccess().SetNameDirty();
+        }
+        // coverity[leaked_storage] - if pTEOutliner wasn't deleted it didn't really belong to us
+    }
+
+    if (pTEObj && !pTEObj->getSdrModelFromSdrObject().isLocked() && pTEObj->GetBroadcaster())
+    {
+        SdrHint aHint(SdrHintKind::EndEdit, *pTEObj);
+        const_cast<SfxBroadcaster*>(pTEObj->GetBroadcaster())->Broadcast(aHint);
+    }
+
+    if (pUndoEditUndoManager)
+    {
+        if (bNeedToUndoSavedRedoTextEdit)
+        {
+            // undo the text edit action since it was created as part of an EndTextEdit
+            // callback from undo itself. This needs to be done after the call to
+            // FmFormView::SdrEndTextEdit since it gets created there
+            pUndoEditUndoManager->Undo();
+        }
+
+        // trigger the Undo which was not executed, but lead to this
+        // end text edit
+        pUndoEditUndoManager->Undo();
+    }
+
+    return eRet;
+}
+
+// info about TextEdit. Default is false.
+bool SdrObjEditView::IsTextEdit() const { return mxWeakTextEditObj.get().is(); }
+
+// info about TextEditPageView. Default is 0L.
+SdrPageView* SdrObjEditView::GetTextEditPageView() const { return mpTextEditPV; }
+
+OutlinerView* SdrObjEditView::ImpFindOutlinerView(vcl::Window const* pWin) const
+{
+    if (pWin == nullptr)
+        return nullptr;
+    if (mpTextEditOutliner == nullptr)
+        return nullptr;
+    OutlinerView* pNewView = nullptr;
+    size_t nWinCount = mpTextEditOutliner->GetViewCount();
+    for (size_t i = 0; i < nWinCount && pNewView == nullptr; i++)
+    {
+        OutlinerView* pView = mpTextEditOutliner->GetView(i);
+        if (pView->GetWindow() == pWin)
+            pNewView = pView;
+    }
+    return pNewView;
+}
+
+void SdrObjEditView::SetTextEditWin(vcl::Window* pWin)
+{
+    if (!(mxWeakTextEditObj.get() && pWin != nullptr && pWin != mpTextEditWin))
+        return;
+
+    OutlinerView* pNewView = ImpFindOutlinerView(pWin);
+    if (pNewView != nullptr && pNewView != mpTextEditOutlinerView)
+    {
+        if (mpTextEditOutlinerView != nullptr)
+        {
+            mpTextEditOutlinerView->HideCursor();
+        }
+        mpTextEditOutlinerView = pNewView;
+        mpTextEditWin = pWin;
+        pWin->GrabFocus(); // Make the cursor blink here as well
+        pNewView->ShowCursor();
+        ImpMakeTextCursorAreaVisible();
+    }
+}
+
+bool SdrObjEditView::IsTextEditHit(const Point& rHit) const
+{
+    bool bOk = false;
+    if (mxWeakTextEditObj.get())
+    {
+        tools::Rectangle aEditArea;
+        if (OutlinerView* pOLV = mpTextEditOutliner->GetView(0))
+            aEditArea.Union(pOLV->GetOutputArea());
+
+        if (aEditArea.Contains(rHit))
+        { // check if any characters were actually hit
+            const Point aPnt(rHit - aEditArea.TopLeft());
+            tools::Long nHitTol = 2000;
+            if (OutputDevice* pRef = mpTextEditOutliner->GetRefDevice())
+                nHitTol = OutputDevice::LogicToLogic(nHitTol, MapUnit::Map100thMM,
+                                                     pRef->GetMapMode().GetMapUnit());
+
+            bOk = mpTextEditOutliner->IsTextPos(aPnt, static_cast<sal_uInt16>(nHitTol));
+        }
+    }
+    return bOk;
+}
+
+bool SdrObjEditView::IsTextEditFrameHit(const Point& rHit) const
+{
+    bool bOk = false;
+    if (rtl::Reference<SdrTextObj> pText = mxWeakTextEditObj.get())
+    {
+        OutlinerView* pOLV = mpTextEditOutliner->GetView(0);
+        if (pOLV)
+        {
+            vcl::Window* pWin = pOLV->GetWindow();
+            if (pText != nullptr && pText->IsTextFrame() && pWin != nullptr)
+            {
+                sal_uInt16 nPixSiz = pOLV->GetInvalidateMore();
+                tools::Rectangle aEditArea(aMinTextEditArea);
+                aEditArea.Union(pOLV->GetOutputArea());
+                if (!aEditArea.Contains(rHit))
+                {
+                    Size aSiz(pWin->PixelToLogic(Size(nPixSiz, nPixSiz)));
+                    aEditArea.AdjustLeft(-(aSiz.Width()));
+                    aEditArea.AdjustTop(-(aSiz.Height()));
+                    aEditArea.AdjustRight(aSiz.Width());
+                    aEditArea.AdjustBottom(aSiz.Height());
+                    bOk = aEditArea.Contains(rHit);
+                }
+            }
+        }
+    }
+    return bOk;
+}
+
+std::unique_ptr<TextChainCursorManager>
+SdrObjEditView::ImpHandleMotionThroughBoxesKeyInput(const KeyEvent& rKEvt, bool* bOutHandled)
+{
+    *bOutHandled = false;
+
+    rtl::Reference<SdrTextObj> pTextObj = mxWeakTextEditObj.get();
+    if (!pTextObj)
+        return nullptr;
+
+    if (!pTextObj->GetNextLinkInChain() && !pTextObj->GetPrevLinkInChain())
+        return nullptr;
+
+    std::unique_ptr<TextChainCursorManager> pCursorManager(
+        new TextChainCursorManager(this, pTextObj.get()));
+    if (pCursorManager->HandleKeyEvent(rKEvt))
+    {
+        // Possibly do other stuff here if necessary...
+        // XXX: Careful with the checks below (in KeyInput) for pWin and co. You should do them here I guess.
+        *bOutHandled = true;
+    }
+
+    return pCursorManager;
+}
+
+bool SdrObjEditView::KeyInput(const KeyEvent& rKEvt, vcl::Window* pWin)
+{
+    if (mpTextEditOutlinerView)
+    {
+        /* Start special handling of keys within a chain */
+        // We possibly move to another box before any handling
+        bool bHandled = false;
+        std::unique_ptr<TextChainCursorManager> xCursorManager(
+            ImpHandleMotionThroughBoxesKeyInput(rKEvt, &bHandled));
+        if (bHandled)
+            return true;
+        /* End special handling of keys within a chain */
+
+        if (mpTextEditOutlinerView->PostKeyEvent(rKEvt, pWin))
+        {
+            if (mpTextEditOutliner && mpTextEditOutliner->IsModified())
+                GetModel().SetChanged();
+
+            /* Start chaining processing */
+            ImpChainingEventHdl();
+            ImpMoveCursorAfterChainingEvent(xCursorManager.get());
+            /* End chaining processing */
+
+            if (pWin != nullptr && pWin != mpTextEditWin)
+                SetTextEditWin(pWin);
+            ImpMakeTextCursorAreaVisible();
+            return true;
+        }
+    }
+    return SdrGlueEditView::KeyInput(rKEvt, pWin);
+}
+
+bool SdrObjEditView::MouseButtonDown(const MouseEvent& rMEvt, OutputDevice* pWin)
+{
+    if (mpTextEditOutlinerView != nullptr)
+    {
+        bool bPostIt = mpTextEditOutliner->IsInSelectionMode();
+        if (!bPostIt)
+        {
+            Point aPt(rMEvt.GetPosPixel());
+            if (pWin != nullptr)
+                aPt = pWin->PixelToLogic(aPt);
+            else if (mpTextEditWin != nullptr)
+                aPt = mpTextEditWin->PixelToLogic(aPt);
+            bPostIt = IsTextEditHit(aPt);
+        }
+        if (bPostIt)
+        {
+            Point aPixPos(rMEvt.GetPosPixel());
+            if (pWin)
+            {
+                tools::Rectangle aR(pWin->LogicToPixel(mpTextEditOutlinerView->GetOutputArea()));
+                if (aPixPos.X() < aR.Left())
+                    aPixPos.setX(aR.Left());
+                if (aPixPos.X() > aR.Right())
+                    aPixPos.setX(aR.Right());
+                if (aPixPos.Y() < aR.Top())
+                    aPixPos.setY(aR.Top());
+                if (aPixPos.Y() > aR.Bottom())
+                    aPixPos.setY(aR.Bottom());
+            }
+            MouseEvent aMEvt(aPixPos, rMEvt.GetClicks(), rMEvt.GetMode(), rMEvt.GetButtons(),
+                             rMEvt.GetModifier());
+            if (mpTextEditOutlinerView->MouseButtonDown(aMEvt))
+            {
+                if (pWin != nullptr && pWin != mpTextEditWin->GetOutDev()
+                    && pWin->GetOutDevType() == OUTDEV_WINDOW)
+                    SetTextEditWin(pWin->GetOwnerWindow());
+                ImpMakeTextCursorAreaVisible();
+                return true;
+            }
+        }
+    }
+    return SdrGlueEditView::MouseButtonDown(rMEvt, pWin);
+}
+
+bool SdrObjEditView::MouseButtonUp(const MouseEvent& rMEvt, OutputDevice* pWin)
+{
+    if (mpTextEditOutlinerView != nullptr)
+    {
+        bool bPostIt = mpTextEditOutliner->IsInSelectionMode();
+        if (!bPostIt)
+        {
+            Point aPt(rMEvt.GetPosPixel());
+            if (pWin != nullptr)
+                aPt = pWin->PixelToLogic(aPt);
+            else if (mpTextEditWin != nullptr)
+                aPt = mpTextEditWin->PixelToLogic(aPt);
+            bPostIt = IsTextEditHit(aPt);
+        }
+        if (bPostIt && pWin)
+        {
+            Point aPixPos(rMEvt.GetPosPixel());
+            tools::Rectangle aR(pWin->LogicToPixel(mpTextEditOutlinerView->GetOutputArea()));
+            if (aPixPos.X() < aR.Left())
+                aPixPos.setX(aR.Left());
+            if (aPixPos.X() > aR.Right())
+                aPixPos.setX(aR.Right());
+            if (aPixPos.Y() < aR.Top())
+                aPixPos.setY(aR.Top());
+            if (aPixPos.Y() > aR.Bottom())
+                aPixPos.setY(aR.Bottom());
+            MouseEvent aMEvt(aPixPos, rMEvt.GetClicks(), rMEvt.GetMode(), rMEvt.GetButtons(),
+                             rMEvt.GetModifier());
+            if (mpTextEditOutlinerView->MouseButtonUp(aMEvt))
+            {
+                ImpMakeTextCursorAreaVisible();
+                return true;
+            }
+        }
+    }
+    return SdrGlueEditView::MouseButtonUp(rMEvt, pWin);
+}
+
+bool SdrObjEditView::MouseMove(const MouseEvent& rMEvt, OutputDevice* pWin)
+{
+    if (mpTextEditOutlinerView != nullptr)
+    {
+        bool bSelMode = mpTextEditOutliner->IsInSelectionMode();
+        bool bPostIt = bSelMode;
+        if (!bPostIt)
+        {
+            Point aPt(rMEvt.GetPosPixel());
+            if (pWin)
+                aPt = pWin->PixelToLogic(aPt);
+            else if (mpTextEditWin)
+                aPt = mpTextEditWin->PixelToLogic(aPt);
+            bPostIt = IsTextEditHit(aPt);
+        }
+        if (bPostIt)
+        {
+            Point aPixPos(rMEvt.GetPosPixel());
+            tools::Rectangle aR(mpTextEditOutlinerView->GetOutputArea());
+            if (pWin)
+                aR = pWin->LogicToPixel(aR);
+            else if (mpTextEditWin)
+                aR = mpTextEditWin->LogicToPixel(aR);
+            if (aPixPos.X() < aR.Left())
+                aPixPos.setX(aR.Left());
+            if (aPixPos.X() > aR.Right())
+                aPixPos.setX(aR.Right());
+            if (aPixPos.Y() < aR.Top())
+                aPixPos.setY(aR.Top());
+            if (aPixPos.Y() > aR.Bottom())
+                aPixPos.setY(aR.Bottom());
+            MouseEvent aMEvt(aPixPos, rMEvt.GetClicks(), rMEvt.GetMode(), rMEvt.GetButtons(),
+                             rMEvt.GetModifier());
+            if (mpTextEditOutlinerView->MouseMove(aMEvt) && bSelMode)
+            {
+                ImpMakeTextCursorAreaVisible();
+                return true;
+            }
+        }
+    }
+    return SdrGlueEditView::MouseMove(rMEvt, pWin);
+}
+
+bool SdrObjEditView::Command(const CommandEvent& rCEvt, vcl::Window* pWin)
+{
+    // as long as OutlinerView returns a sal_Bool, it only gets CommandEventId::StartDrag
+    if (mpTextEditOutlinerView != nullptr)
+    {
+        if (rCEvt.GetCommand() == CommandEventId::StartDrag)
+        {
+            bool bPostIt = mpTextEditOutliner->IsInSelectionMode() || !rCEvt.IsMouseEvent();
+            if (!bPostIt && rCEvt.IsMouseEvent())
+            {
+                Point aPt(rCEvt.GetMousePosPixel());
+                if (pWin != nullptr)
+                    aPt = pWin->PixelToLogic(aPt);
+                else if (mpTextEditWin != nullptr)
+                    aPt = mpTextEditWin->PixelToLogic(aPt);
+                bPostIt = IsTextEditHit(aPt);
+            }
+            if (bPostIt)
+            {
+                Point aPixPos(rCEvt.GetMousePosPixel());
+                if (rCEvt.IsMouseEvent() && pWin)
+                {
+                    tools::Rectangle aR(
+                        pWin->LogicToPixel(mpTextEditOutlinerView->GetOutputArea()));
+                    if (aPixPos.X() < aR.Left())
+                        aPixPos.setX(aR.Left());
+                    if (aPixPos.X() > aR.Right())
+                        aPixPos.setX(aR.Right());
+                    if (aPixPos.Y() < aR.Top())
+                        aPixPos.setY(aR.Top());
+                    if (aPixPos.Y() > aR.Bottom())
+                        aPixPos.setY(aR.Bottom());
+                }
+                CommandEvent aCEvt(aPixPos, rCEvt.GetCommand(), rCEvt.IsMouseEvent());
+                // Command is void at the OutlinerView, sadly
+                mpTextEditOutlinerView->Command(aCEvt);
+                if (pWin != nullptr && pWin != mpTextEditWin)
+                    SetTextEditWin(pWin);
+                ImpMakeTextCursorAreaVisible();
+                return true;
+            }
+        }
+        else
+        {
+            mpTextEditOutlinerView->Command(rCEvt);
+            if (comphelper::LibreOfficeKit::isActive())
+            {
+                // It could execute CommandEventId::ExtTextInput, while SdrObjEditView::KeyInput
+                // isn't called
+                if (mpTextEditOutliner && mpTextEditOutliner->IsModified())
+                    GetModel().SetChanged();
+            }
+            return true;
+        }
+    }
+    return SdrGlueEditView::Command(rCEvt, pWin);
+}
+
+bool SdrObjEditView::ImpIsTextEditAllSelected() const
+{
+    bool bRet = false;
+    if (mpTextEditOutliner != nullptr && mpTextEditOutlinerView != nullptr)
+    {
+        if (SdrTextObj::HasTextImpl(mpTextEditOutliner.get()))
+        {
+            const sal_Int32 nParaCnt = mpTextEditOutliner->GetParagraphCount();
+            Paragraph* pLastPara
+                = mpTextEditOutliner->GetParagraph(nParaCnt > 1 ? nParaCnt - 1 : 0);
+
+            ESelection aESel(mpTextEditOutlinerView->GetSelection());
+            if (aESel.nStartPara == 0 && aESel.nStartPos == 0 && aESel.nEndPara == (nParaCnt - 1))
+            {
+                if (mpTextEditOutliner->GetText(pLastPara).getLength() == aESel.nEndPos)
+                    bRet = true;
+            }
+            // in case the selection was done backwards
+            if (!bRet && aESel.nEndPara == 0 && aESel.nEndPos == 0
+                && aESel.nStartPara == (nParaCnt - 1))
+            {
+                if (mpTextEditOutliner->GetText(pLastPara).getLength() == aESel.nStartPos)
+                    bRet = true;
+            }
+        }
+        else
+        {
+            bRet = true;
+        }
+    }
+    return bRet;
+}
+
+void SdrObjEditView::ImpMakeTextCursorAreaVisible()
+{
+    if (mpTextEditOutlinerView != nullptr && mpTextEditWin != nullptr)
+    {
+        vcl::Cursor* pCsr = mpTextEditWin->GetCursor();
+        if (pCsr != nullptr)
+        {
+            Size aSiz(pCsr->GetSize());
+            if (!aSiz.IsEmpty())
+            {
+                MakeVisible(tools::Rectangle(pCsr->GetPos(), aSiz), *mpTextEditWin);
+            }
+        }
+    }
+}
+
+SvtScriptType SdrObjEditView::GetScriptType() const
+{
+    SvtScriptType nScriptType = SvtScriptType::NONE;
+
+    if (IsTextEdit())
+    {
+        auto pText = mxWeakTextEditObj.get();
+        if (pText->GetOutlinerParaObject())
+            nScriptType = pText->GetOutlinerParaObject()->GetTextObject().GetScriptType();
+
+        if (mpTextEditOutlinerView)
+            nScriptType = mpTextEditOutlinerView->GetSelectedScriptType();
+    }
+    else
+    {
+        const size_t nMarkCount(GetMarkedObjectCount());
+
+        for (size_t i = 0; i < nMarkCount; ++i)
+        {
+            OutlinerParaObject* pParaObj = GetMarkedObjectByIndex(i)->GetOutlinerParaObject();
+
+            if (pParaObj)
+            {
+                nScriptType |= pParaObj->GetTextObject().GetScriptType();
+            }
+        }
+    }
+
+    if (nScriptType == SvtScriptType::NONE)
+        nScriptType = SvtScriptType::LATIN;
+
+    return nScriptType;
+}
+
+void SdrObjEditView::GetAttributes(SfxItemSet& rTargetSet, bool bOnlyHardAttr) const
+{
+    if (mxSelectionController.is())
+        if (mxSelectionController->GetAttributes(rTargetSet, bOnlyHardAttr))
+            return;
+
+    if (IsTextEdit())
+    {
+        DBG_ASSERT(mpTextEditOutlinerView != nullptr,
+                   "SdrObjEditView::GetAttributes(): mpTextEditOutlinerView=NULL");
+        DBG_ASSERT(mpTextEditOutliner != nullptr,
+                   "SdrObjEditView::GetAttributes(): mpTextEditOutliner=NULL");
+
+        auto pText = mxWeakTextEditObj.get();
+        // take care of bOnlyHardAttr(!)
+        if (!bOnlyHardAttr && pText->GetStyleSheet())
+            rTargetSet.Put(pText->GetStyleSheet()->GetItemSet());
+
+        // add object attributes
+        rTargetSet.Put(pText->GetMergedItemSet());
+
+        if (mpTextEditOutlinerView)
+        {
+            // FALSE= regard InvalidItems as "holes," not as Default
+            rTargetSet.Put(mpTextEditOutlinerView->GetAttribs(), false);
+        }
+
+        if (GetMarkedObjectCount() == 1 && GetMarkedObjectByIndex(0) == pText.get())
+        {
+            MergeNotPersistAttrFromMarked(rTargetSet);
+        }
+    }
+    else
+    {
+        SdrGlueEditView::GetAttributes(rTargetSet, bOnlyHardAttr);
+    }
+}
+
+bool SdrObjEditView::SetAttributes(const SfxItemSet& rSet, bool bReplaceAll)
+{
+    bool bRet = false;
+    rtl::Reference<SdrTextObj> pTextEditObj = mxWeakTextEditObj.get();
+    bool bTextEdit = mpTextEditOutlinerView != nullptr && pTextEditObj != nullptr;
+    bool bAllTextSelected = ImpIsTextEditAllSelected();
+    const SfxItemSet* pSet = &rSet;
+
+    if (!bTextEdit)
+    {
+        // no TextEdit active -> all Items to drawing object
+        if (mxSelectionController.is())
+            bRet = mxSelectionController->SetAttributes(*pSet, bReplaceAll);
+
+        if (!bRet)
+        {
+            SdrGlueEditView::SetAttributes(*pSet, bReplaceAll);
+            bRet = true;
+        }
+    }
+    else
+    {
+#ifdef DBG_UTIL
+        {
+            bool bHasEEFeatureItems = false;
+            SfxItemIter aIter(rSet);
+            for (const SfxPoolItem* pItem = aIter.GetCurItem(); !bHasEEFeatureItems && pItem;
+                 pItem = aIter.NextItem())
+            {
+                if (!IsInvalidItem(pItem))
+                {
+                    sal_uInt16 nW = pItem->Which();
+                    if (nW >= EE_FEATURE_START && nW <= EE_FEATURE_END)
+                        bHasEEFeatureItems = true;
+                }
+            }
+
+            if (bHasEEFeatureItems)
+            {
+                std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(
+                    nullptr, VclMessageType::Info, VclButtonsType::Ok,
+                    "SdrObjEditView::SetAttributes(): Setting EE_FEATURE items "
+                    "at the SdrView does not make sense! It only leads to "
+                    "overhead and unreadable documents."));
+                xInfoBox->run();
+            }
+        }
+#endif
+
+        bool bOnlyEEItems;
+        bool bNoEEItems = !SearchOutlinerItems(*pSet, bReplaceAll, &bOnlyEEItems);
+        // everything selected? -> attributes to the border, too
+        // if no EEItems, attributes to the border only
+        if (bAllTextSelected || bNoEEItems)
+        {
+            if (mxSelectionController.is())
+                bRet = mxSelectionController->SetAttributes(*pSet, bReplaceAll);
+
+            if (!bRet)
+            {
+                const bool bUndo = IsUndoEnabled();
+
+                if (bUndo)
+                {
+                    BegUndo(ImpGetDescriptionString(STR_EditSetAttributes));
+                    AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pTextEditObj));
+
+                    // If this is a text object also rescue the OutlinerParaObject since
+                    // applying attributes to the object may change text layout when
+                    // multiple portions exist with multiple formats. If an OutlinerParaObject
+                    // really exists and needs to be rescued is evaluated in the undo
+                    // implementation itself.
+                    bool bRescueText(pTextEditObj);
+
+                    AddUndo(GetModel().GetSdrUndoFactory().CreateUndoAttrObject(
+                        *pTextEditObj, false, !bNoEEItems || bRescueText));
+                    EndUndo();
+                }
+
+                pTextEditObj->SetMergedItemSetAndBroadcast(*pSet, bReplaceAll);
+
+                FlushComeBackTimer(); // to set ModeHasChanged immediately
+            }
+        }
+        else if (!bOnlyEEItems)
+        {
+            // Otherwise split Set, if necessary.
+            // Now we build an ItemSet aSet that doesn't contain EE_Items from
+            // *pSet (otherwise it would be a copy).
+            WhichRangesContainer pNewWhichTable
+                = RemoveWhichRange(pSet->GetRanges(), EE_ITEMS_START, EE_ITEMS_END);
+            SfxItemSet aSet(GetModel().GetItemPool(), std::move(pNewWhichTable));
+            SfxWhichIter aIter(aSet);
+            sal_uInt16 nWhich = aIter.FirstWhich();
+            while (nWhich != 0)
+            {
+                const SfxPoolItem* pItem;
+                SfxItemState eState = pSet->GetItemState(nWhich, false, &pItem);
+                if (eState == SfxItemState::SET)
+                    aSet.Put(*pItem);
+                nWhich = aIter.NextWhich();
+            }
+
+            if (mxSelectionController.is())
+                bRet = mxSelectionController->SetAttributes(aSet, bReplaceAll);
+
+            if (!bRet)
+            {
+                if (IsUndoEnabled())
+                {
+                    BegUndo(ImpGetDescriptionString(STR_EditSetAttributes));
+                    AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pTextEditObj));
+                    AddUndo(GetModel().GetSdrUndoFactory().CreateUndoAttrObject(*pTextEditObj));
+                    EndUndo();
+                }
+
+                pTextEditObj->SetMergedItemSetAndBroadcast(aSet, bReplaceAll);
+
+                if (GetMarkedObjectCount() == 1 && GetMarkedObjectByIndex(0) == pTextEditObj.get())
+                {
+                    SetNotPersistAttrToMarked(aSet);
+                }
+            }
+            FlushComeBackTimer();
+        }
+        if (!bNoEEItems)
+        {
+            // and now the attributes to the EditEngine
+            if (bReplaceAll)
+            {
+                mpTextEditOutlinerView->RemoveAttribs(true);
+            }
+            mpTextEditOutlinerView->SetAttribs(rSet);
+
+            Outliner* pTEOutliner = mpTextEditOutlinerView->GetOutliner();
+            if (pTEOutliner && pTEOutliner->IsModified())
+                GetModel().SetChanged();
+
+            ImpMakeTextCursorAreaVisible();
+        }
+        bRet = true;
+    }
+    return bRet;
+}
+
+SfxStyleSheet* SdrObjEditView::GetStyleSheet() const
+{
+    SfxStyleSheet* pSheet = nullptr;
+
+    if (mxSelectionController.is())
+    {
+        if (mxSelectionController->GetStyleSheet(pSheet))
+            return pSheet;
+    }
+
+    if (mpTextEditOutlinerView)
+    {
+        pSheet = mpTextEditOutlinerView->GetStyleSheet();
+    }
+    else
+    {
+        pSheet = SdrGlueEditView::GetStyleSheet();
+    }
+    return pSheet;
+}
+
+void SdrObjEditView::SetStyleSheet(SfxStyleSheet* pStyleSheet, bool bDontRemoveHardAttr)
+{
+    if (mxSelectionController.is())
+    {
+        if (mxSelectionController->SetStyleSheet(pStyleSheet, bDontRemoveHardAttr))
+            return;
+    }
+
+    // if we are currently in edit mode we must also set the stylesheet
+    // on all paragraphs in the Outliner for the edit view
+    if (nullptr != mpTextEditOutlinerView)
+    {
+        Outliner* pOutliner = mpTextEditOutlinerView->GetOutliner();
+
+        const sal_Int32 nParaCount = pOutliner->GetParagraphCount();
+        for (sal_Int32 nPara = 0; nPara < nParaCount; nPara++)
+        {
+            pOutliner->SetStyleSheet(nPara, pStyleSheet);
+        }
+    }
+
+    SdrGlueEditView::SetStyleSheet(pStyleSheet, bDontRemoveHardAttr);
+}
+
+void SdrObjEditView::AddDeviceToPaintView(OutputDevice& rNewDev, vcl::Window* pWindow)
+{
+    SdrGlueEditView::AddDeviceToPaintView(rNewDev, pWindow);
+
+    if (mxWeakTextEditObj.get() && !mbTextEditOnlyOneView
+        && rNewDev.GetOutDevType() == OUTDEV_WINDOW)
+    {
+        OutlinerView* pOutlView = ImpMakeOutlinerView(rNewDev.GetOwnerWindow(), nullptr);
+        mpTextEditOutliner->InsertView(pOutlView);
+    }
+}
+
+void SdrObjEditView::DeleteDeviceFromPaintView(OutputDevice& rOldDev)
+{
+    SdrGlueEditView::DeleteDeviceFromPaintView(rOldDev);
+
+    if (mxWeakTextEditObj.get() && !mbTextEditOnlyOneView
+        && rOldDev.GetOutDevType() == OUTDEV_WINDOW)
+    {
+        for (size_t i = mpTextEditOutliner->GetViewCount(); i > 0;)
+        {
+            i--;
+            OutlinerView* pOLV = mpTextEditOutliner->GetView(i);
+            if (pOLV && pOLV->GetWindow() == rOldDev.GetOwnerWindow())
+            {
+                mpTextEditOutliner->RemoveView(i);
+            }
+        }
+    }
+
+    lcl_RemoveTextEditOutlinerViews(this, GetSdrPageView(), &rOldDev);
+}
+
+bool SdrObjEditView::IsTextEditInSelectionMode() const
+{
+    return mpTextEditOutliner != nullptr && mpTextEditOutliner->IsInSelectionMode();
+}
+
+// MacroMode
+
+void SdrObjEditView::BegMacroObj(const Point& rPnt, short nTol, SdrObject* pObj, SdrPageView* pPV,
+                                 vcl::Window* pWin)
+{
+    BrkMacroObj();
+    if (pObj != nullptr && pPV != nullptr && pWin != nullptr && pObj->HasMacro())
+    {
+        nTol = ImpGetHitTolLogic(nTol, nullptr);
+        pMacroObj = pObj;
+        pMacroPV = pPV;
+        pMacroWin = pWin;
+        mbMacroDown = false;
+        nMacroTol = sal_uInt16(nTol);
+        aMacroDownPos = rPnt;
+        MovMacroObj(rPnt);
+    }
+}
+
+void SdrObjEditView::ImpMacroUp(const Point& rUpPos)
+{
+    if (pMacroObj != nullptr && mbMacroDown)
+    {
+        SdrObjMacroHitRec aHitRec;
+        aHitRec.aPos = rUpPos;
+        aHitRec.nTol = nMacroTol;
+        aHitRec.pVisiLayer = &pMacroPV->GetVisibleLayers();
+        aHitRec.pPageView = pMacroPV;
+        pMacroObj->PaintMacro(*pMacroWin->GetOutDev(), tools::Rectangle(), aHitRec);
+        mbMacroDown = false;
+    }
+}
+
+void SdrObjEditView::ImpMacroDown(const Point& rDownPos)
+{
+    if (pMacroObj != nullptr && !mbMacroDown)
+    {
+        SdrObjMacroHitRec aHitRec;
+        aHitRec.aPos = rDownPos;
+        aHitRec.nTol = nMacroTol;
+        aHitRec.pVisiLayer = &pMacroPV->GetVisibleLayers();
+        aHitRec.pPageView = pMacroPV;
+        pMacroObj->PaintMacro(*pMacroWin->GetOutDev(), tools::Rectangle(), aHitRec);
+        mbMacroDown = true;
+    }
+}
+
+void SdrObjEditView::MovMacroObj(const Point& rPnt)
+{
+    if (pMacroObj == nullptr)
+        return;
+
+    SdrObjMacroHitRec aHitRec;
+    aHitRec.aPos = rPnt;
+    aHitRec.nTol = nMacroTol;
+    aHitRec.pVisiLayer = &pMacroPV->GetVisibleLayers();
+    aHitRec.pPageView = pMacroPV;
+    bool bDown = pMacroObj->IsMacroHit(aHitRec);
+    if (bDown)
+        ImpMacroDown(rPnt);
+    else
+        ImpMacroUp(rPnt);
+}
+
+void SdrObjEditView::BrkMacroObj()
+{
+    if (pMacroObj != nullptr)
+    {
+        ImpMacroUp(aMacroDownPos);
+        pMacroObj = nullptr;
+        pMacroPV = nullptr;
+        pMacroWin = nullptr;
+    }
+}
+
+bool SdrObjEditView::EndMacroObj()
+{
+    if (pMacroObj != nullptr && mbMacroDown)
+    {
+        ImpMacroUp(aMacroDownPos);
+        SdrObjMacroHitRec aHitRec;
+        aHitRec.aPos = aMacroDownPos;
+        aHitRec.nTol = nMacroTol;
+        aHitRec.pVisiLayer = &pMacroPV->GetVisibleLayers();
+        aHitRec.pPageView = pMacroPV;
+        bool bRet = pMacroObj->DoMacro(aHitRec);
+        pMacroObj = nullptr;
+        pMacroPV = nullptr;
+        pMacroWin = nullptr;
+        return bRet;
+    }
+    else
+    {
+        BrkMacroObj();
+        return false;
+    }
+}
+
+/** fills the given any with a XTextCursor for the current text selection.
+    Leaves the any untouched if there currently is no text selected */
+void SdrObjEditView::getTextSelection(css::uno::Any& rSelection)
+{
+    if (!IsTextEdit())
+        return;
+
+    OutlinerView* pOutlinerView = GetTextEditOutlinerView();
+    if (!(pOutlinerView && pOutlinerView->HasSelection()))
+        return;
+
+    SdrObject* pObj = GetTextEditObject();
+
+    if (!pObj)
+        return;
+
+    css::uno::Reference<css::text::XText> xText(pObj->getUnoShape(), css::uno::UNO_QUERY);
+    if (xText.is())
+    {
+        SvxUnoTextBase* pRange = comphelper::getFromUnoTunnel<SvxUnoTextBase>(xText);
+        if (pRange)
+        {
+            rSelection <<= pRange->createTextCursorBySelection(pOutlinerView->GetSelection());
+        }
+    }
+}
+
+/* check if we have a single selection and that single object likes
+    to handle the mouse and keyboard events itself
+
+    TODO: the selection controller should be queried from the
+    object specific view contact. Currently this method only
+    works for tables.
+*/
+void SdrObjEditView::MarkListHasChanged()
+{
+    SdrGlueEditView::MarkListHasChanged();
+
+    if (mxSelectionController.is())
+    {
+        mxLastSelectionController = mxSelectionController;
+        mxSelectionController->onSelectionHasChanged();
+    }
+
+    mxSelectionController.clear();
+
+    const SdrMarkList& rMarkList = GetMarkedObjectList();
+    if (rMarkList.GetMarkCount() != 1)
+        return;
+
+    const SdrObject* pObj(rMarkList.GetMark(0)->GetMarkedSdrObj());
+    SdrView* pView(dynamic_cast<SdrView*>(this));
+
+    // check for table
+    if (pObj && pView && (pObj->GetObjInventor() == SdrInventor::Default)
+        && (pObj->GetObjIdentifier() == SdrObjKind::Table))
+    {
+        mxSelectionController = sdr::table::CreateTableController(
+            *pView, static_cast<const sdr::table::SdrTableObj&>(*pObj), mxLastSelectionController);
+
+        if (mxSelectionController.is())
+        {
+            mxLastSelectionController.clear();
+            mxSelectionController->onSelectionHasChanged();
+        }
+    }
+}
+
+IMPL_LINK(SdrObjEditView, EndPasteOrDropHdl, PasteOrDropInfos*, pInfo, void)
+{
+    OnEndPasteOrDrop(pInfo);
+}
+
+IMPL_LINK(SdrObjEditView, BeginPasteOrDropHdl, PasteOrDropInfos*, pInfo, void)
+{
+    OnBeginPasteOrDrop(pInfo);
+}
+
+void SdrObjEditView::OnBeginPasteOrDrop(PasteOrDropInfos*)
+{
+    // applications can derive from these virtual methods to do something before a drop or paste operation
+}
+
+void SdrObjEditView::OnEndPasteOrDrop(PasteOrDropInfos*)
+{
+    // applications can derive from these virtual methods to do something before a drop or paste operation
+}
+
+sal_uInt16 SdrObjEditView::GetSelectionLevel() const
+{
+    sal_uInt16 nLevel = 0xFFFF;
+    if (IsTextEdit())
+    {
+        DBG_ASSERT(mpTextEditOutlinerView != nullptr,
+                   "SdrObjEditView::GetAttributes(): mpTextEditOutlinerView=NULL");
+        DBG_ASSERT(mpTextEditOutliner != nullptr,
+                   "SdrObjEditView::GetAttributes(): mpTextEditOutliner=NULL");
+        if (mpTextEditOutlinerView)
+        {
+            //start and end position
+            ESelection aSelect = mpTextEditOutlinerView->GetSelection();
+            sal_uInt16 nStartPara = ::std::min(aSelect.nStartPara, aSelect.nEndPara);
+            sal_uInt16 nEndPara = ::std::max(aSelect.nStartPara, aSelect.nEndPara);
+            //get level from each paragraph
+            nLevel = 0;
+            for (sal_uInt16 nPara = nStartPara; nPara <= nEndPara; nPara++)
+            {
+                sal_uInt16 nParaDepth
+                    = 1 << static_cast<sal_uInt16>(mpTextEditOutliner->GetDepth(nPara));
+                if (!(nLevel & nParaDepth))
+                    nLevel += nParaDepth;
+            }
+            //reduce one level for Outliner Object
+            //if( nLevel > 0 && GetTextEditObject()->GetObjIdentifier() == OBJ_OUTLINETEXT )
+            //  nLevel = nLevel >> 1;
+            //no bullet paragraph selected
+            if (nLevel == 0)
+                nLevel = 0xFFFF;
+        }
+    }
+    return nLevel;
+}
+
+bool SdrObjEditView::SupportsFormatPaintbrush(SdrInventor nObjectInventor,
+                                              SdrObjKind nObjectIdentifier)
+{
+    if (nObjectInventor != SdrInventor::Default && nObjectInventor != SdrInventor::E3d)
+        return false;
+    switch (nObjectIdentifier)
+    {
+        case SdrObjKind::NONE:
+        case SdrObjKind::Group:
+            return false;
+        case SdrObjKind::Line:
+        case SdrObjKind::Rectangle:
+        case SdrObjKind::CircleOrEllipse:
+        case SdrObjKind::CircleSection:
+        case SdrObjKind::CircleArc:
+        case SdrObjKind::CircleCut:
+        case SdrObjKind::Polygon:
+        case SdrObjKind::PolyLine:
+        case SdrObjKind::PathLine:
+        case SdrObjKind::PathFill:
+        case SdrObjKind::FreehandLine:
+        case SdrObjKind::FreehandFill:
+        case SdrObjKind::Text:
+        case SdrObjKind::TitleText:
+        case SdrObjKind::OutlineText:
+        case SdrObjKind::Graphic:
+        case SdrObjKind::OLE2:
+        case SdrObjKind::Table:
+            return true;
+        case SdrObjKind::Caption:
+            return false;
+        case SdrObjKind::Edge:
+        case SdrObjKind::PathPoly:
+        case SdrObjKind::PathPolyLine:
+            return true;
+        case SdrObjKind::Page:
+        case SdrObjKind::Measure:
+        case SdrObjKind::OLEPluginFrame:
+        case SdrObjKind::UNO:
+            return false;
+        case SdrObjKind::CustomShape:
+            return true;
+        default:
+            return false;
+    }
+}
+
+static const WhichRangesContainer& GetFormatRangeImpl(bool bTextOnly)
+{
+    static const WhichRangesContainer gFull(
+        svl::Items<XATTR_LINE_FIRST, XATTR_LINE_LAST, XATTR_FILL_FIRST, XATTRSET_FILL,
+                   SDRATTR_SHADOW_FIRST, SDRATTR_SHADOW_LAST, SDRATTR_MISC_FIRST,
+                   SDRATTR_MISC_LAST, // table cell formats
+                   SDRATTR_GRAF_FIRST, SDRATTR_GRAF_LAST, SDRATTR_TABLE_FIRST, SDRATTR_TABLE_LAST,
+                   SDRATTR_GLOW_FIRST, SDRATTR_GLOW_LAST, SDRATTR_SOFTEDGE_FIRST,
+                   SDRATTR_SOFTEDGE_LAST, EE_PARA_START, EE_PARA_END, EE_CHAR_START, EE_CHAR_END>);
+
+    static const WhichRangesContainer gTextOnly(
+        svl::Items<SDRATTR_MISC_FIRST, SDRATTR_MISC_LAST, EE_PARA_START, EE_PARA_END, EE_CHAR_START,
+                   EE_CHAR_END>);
+
+    return bTextOnly ? gTextOnly : gFull;
+}
+
+void SdrObjEditView::TakeFormatPaintBrush(std::shared_ptr<SfxItemSet>& rFormatSet)
+{
+    const SdrMarkList& rMarkList = GetMarkedObjectList();
+    if (rMarkList.GetMarkCount() <= 0)
+        return;
+
+    OutlinerView* pOLV = GetTextEditOutlinerView();
+
+    rFormatSet = std::make_shared<SfxItemSet>(GetModel().GetItemPool(),
+                                              GetFormatRangeImpl(pOLV != nullptr));
+    if (pOLV)
+    {
+        rFormatSet->Put(pOLV->GetAttribs());
+    }
+    else
+    {
+        const bool bOnlyHardAttr = false;
+        rFormatSet->Put(GetAttrFromMarked(bOnlyHardAttr));
+    }
+
+    // check for cloning from table cell, in which case we need to copy cell-specific formatting attributes
+    const SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
+    if (pObj && (pObj->GetObjInventor() == SdrInventor::Default)
+        && (pObj->GetObjIdentifier() == SdrObjKind::Table))
+    {
+        auto pTable = static_cast<const sdr::table::SdrTableObj*>(pObj);
+        if (mxSelectionController.is() && pTable->getActiveCell().is())
+        {
+            mxSelectionController->GetAttributes(*rFormatSet, false);
+        }
+    }
+}
+
+static SfxItemSet CreatePaintSet(const WhichRangesContainer& pRanges, SfxItemPool& rPool,
+                                 const SfxItemSet& rSourceSet, const SfxItemSet& rTargetSet,
+                                 bool bNoCharacterFormats, bool bNoParagraphFormats)
+{
+    SfxItemSet aPaintSet(rPool, pRanges);
+
+    for (const auto& pRange : pRanges)
+    {
+        sal_uInt16 nWhich = pRange.first;
+        const sal_uInt16 nLastWhich = pRange.second;
+
+        if (bNoCharacterFormats && (nWhich == EE_CHAR_START))
+            continue;
+
+        if (bNoParagraphFormats && (nWhich == EE_PARA_START))
+            continue;
+
+        for (; nWhich <= nLastWhich; nWhich++)
+        {
+            const SfxPoolItem* pSourceItem = rSourceSet.GetItem(nWhich);
+            const SfxPoolItem* pTargetItem = rTargetSet.GetItem(nWhich);
+
+            if ((pSourceItem && !pTargetItem)
+                || (pSourceItem && pTargetItem && *pSourceItem != *pTargetItem))
+            {
+                aPaintSet.Put(*pSourceItem);
+            }
+        }
+    }
+    return aPaintSet;
+}
+
+void SdrObjEditView::ApplyFormatPaintBrushToText(SfxItemSet const& rFormatSet, SdrTextObj& rTextObj,
+                                                 SdrText* pText, bool bNoCharacterFormats,
+                                                 bool bNoParagraphFormats)
+{
+    OutlinerParaObject* pParaObj = pText ? pText->GetOutlinerParaObject() : nullptr;
+    if (!pParaObj)
+        return;
+
+    SdrOutliner& rOutliner = rTextObj.ImpGetDrawOutliner();
+    rOutliner.SetText(*pParaObj);
+
+    sal_Int32 nParaCount(rOutliner.GetParagraphCount());
+
+    if (!nParaCount)
+        return;
+
+    for (sal_Int32 nPara = 0; nPara < nParaCount; nPara++)
+    {
+        if (!bNoCharacterFormats)
+            rOutliner.RemoveCharAttribs(nPara);
+
+        SfxItemSet aSet(rOutliner.GetParaAttribs(nPara));
+        aSet.Put(CreatePaintSet(GetFormatRangeImpl(true), *aSet.GetPool(), rFormatSet, aSet,
+                                bNoCharacterFormats, bNoParagraphFormats));
+        rOutliner.SetParaAttribs(nPara, aSet);
+    }
+
+    std::optional<OutlinerParaObject> pTemp = rOutliner.CreateParaObject(0, nParaCount);
+    rOutliner.Clear();
+
+    rTextObj.NbcSetOutlinerParaObjectForText(std::move(pTemp), pText);
+}
+
+void SdrObjEditView::DisposeUndoManager()
+{
+    if (mpTextEditOutliner)
+    {
+        if (typeid(mpTextEditOutliner->GetUndoManager()) != typeid(EditUndoManager))
+        {
+            // Non-owning pointer, clear it.
+            mpTextEditOutliner->SetUndoManager(nullptr);
+        }
+    }
+
+    mpOldTextEditUndoManager = nullptr;
+}
+
+void SdrObjEditView::ApplyFormatPaintBrush(SfxItemSet& rFormatSet, bool bNoCharacterFormats,
+                                           bool bNoParagraphFormats)
+{
+    if (mxSelectionController.is()
+        && mxSelectionController->ApplyFormatPaintBrush(rFormatSet, bNoCharacterFormats,
+                                                        bNoParagraphFormats))
+    {
+        return;
+    }
+
+    OutlinerView* pOLV = GetTextEditOutlinerView();
+    const SdrMarkList& rMarkList = GetMarkedObjectList();
+    if (!pOLV)
+    {
+        SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
+        const SfxItemSet& rShapeSet = pObj->GetMergedItemSet();
+
+        // if not in text edit mode (aka the user selected text or clicked on a word)
+        // apply formatting attributes to selected shape
+        // All formatting items (see ranges above) that are unequal in selected shape and
+        // the format paintbrush are hard set on the selected shape.
+
+        const WhichRangesContainer& pRanges = rFormatSet.GetRanges();
+        bool bTextOnly = true;
+
+        for (const auto& pRange : pRanges)
+        {
+            if ((pRange.first != EE_PARA_START) && (pRange.first != EE_CHAR_START))
+            {
+                bTextOnly = false;
+                break;
+            }
+        }
+
+        if (!bTextOnly)
+        {
+            SfxItemSet aPaintSet(CreatePaintSet(GetFormatRangeImpl(false), *rShapeSet.GetPool(),
+                                                rFormatSet, rShapeSet, bNoCharacterFormats,
+                                                bNoParagraphFormats));
+            SetAttrToMarked(aPaintSet, false /*bReplaceAll*/);
+        }
+
+        // now apply character and paragraph formatting to text, if the shape has any
+        SdrTextObj* pTextObj = DynCastSdrTextObj(pObj);
+        if (pTextObj)
+        {
+            sal_Int32 nText = pTextObj->getTextCount();
+
+            while (--nText >= 0)
+            {
+                SdrText* pText = pTextObj->getText(nText);
+                ApplyFormatPaintBrushToText(rFormatSet, *pTextObj, pText, bNoCharacterFormats,
+                                            bNoParagraphFormats);
+            }
+        }
+    }
+    else
+    {
+        ::Outliner* pOutliner = pOLV->GetOutliner();
+        if (pOutliner)
+        {
+            const EditEngine& rEditEngine = pOutliner->GetEditEngine();
+
+            ESelection aSel(pOLV->GetSelection());
+            if (!aSel.HasRange())
+                pOLV->SetSelection(rEditEngine.GetWord(aSel, css::i18n::WordType::DICTIONARY_WORD));
+
+            const bool bRemoveParaAttribs = !bNoParagraphFormats;
+            pOLV->RemoveAttribsKeepLanguages(bRemoveParaAttribs);
+            SfxItemSet aSet(pOLV->GetAttribs());
+            SfxItemSet aPaintSet(CreatePaintSet(GetFormatRangeImpl(true), *aSet.GetPool(),
+                                                rFormatSet, aSet, bNoCharacterFormats,
+                                                bNoParagraphFormats));
+            pOLV->SetAttribs(aPaintSet);
+        }
+    }
+
+    // check for cloning to table cell, in which case we need to copy cell-specific formatting attributes
+    SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
+    if (pObj && (pObj->GetObjInventor() == SdrInventor::Default)
+        && (pObj->GetObjIdentifier() == SdrObjKind::Table))
+    {
+        auto pTable = static_cast<sdr::table::SdrTableObj*>(pObj);
+        if (pTable->getActiveCell().is() && mxSelectionController.is())
+        {
+            mxSelectionController->SetAttributes(rFormatSet, false);
+        }
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */