/* -*- 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 <officecfg/Office/Common.hxx>

#include <svl/itemiter.hxx>

#include <svl/style.hxx>

#include <svl/whiter.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/dndlistenercontainer.hxx>

#include <vcl/weld/MessageDialog.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 <svx/sdr/contact/viewcontact.hxx>

#include <memory>

SdrObjEditView::SdrObjEditView(SdrModel& rSdrModel, OutputDevice* pOut)

    : SdrGlueEditView(rSdrModel, pOut)

    , maTEOverlayGroup()

    , maTextEditUpdateTimer("TextEditUpdateTimer")

    , mxWeakTextEditObj()

    , mpTextEditPV(nullptr)

    , mpTextEditOutlinerView(nullptr)

    , mpTextEditWin(nullptr)

    , m_pTextEditCursorBuffer(nullptr)

    , m_pMacroObj(nullptr)

    , m_pMacroPV(nullptr)

    , m_pMacroWin(nullptr)

    , m_aTextEditArea()

    , m_aMinTextEditArea()

    , m_aOldCalcFieldValueLink()

    , m_aMacroDownPos()

    , m_nMacroTol(0)

    , mbTextEditDontDelete(false)

    , mbTextEditOnlyOneView(false)

    , mbTextEditNewObj(false)

    , mbQuickTextEditMode(true)

    , mbMacroDown(false)

    , mbInteractiveSlideShow(false)

    , mxSelectionController()

    , mxLastSelectionController()

    , mpOldTextEditUndoManager(nullptr)

    , mpLocalTextEditUndoManager()

{

    // init some timer settings (not starting it of course)

    maTextEditUpdateTimer.SetTimeout(EDIT_UPDATEDATA_TIMEOUT);

    maTextEditUpdateTimer.SetInvokeHandler(LINK(this, SdrObjEditView, TextEditUpdate));

}

IMPL_LINK_NOARG(SdrObjEditView, ImpModifyHdl, LinkParamNone*, void)

{

    // IASS: active TextEdit had a model change. Check and react.

    if (nullptr == mpTextEditOutliner)

        // no Outliner, no TextEdit

        return;

    if (!mxWeakTextEditObj.get().is())

        // no TextObject, no TextEdit

        return;

    // reset & restart the timer

    maTextEditUpdateTimer.SetTimeout(EDIT_UPDATEDATA_TIMEOUT);

    maTextEditUpdateTimer.Start();

}

IMPL_LINK_NOARG(SdrObjEditView, TextEditUpdate, Timer*, void)

{

    // IASS: text was changed and EDIT_UPDATEDATA_TIMEOUT has passed

    // since last user input

    maTextEditUpdateTimer.Stop();

    // be safe: still in TextEdit?

    if (nullptr == mpTextEditOutliner)

        // no Outliner, no TextEdit

        return;

    if (!mxWeakTextEditObj.get().is())

        // no TextObject, no TextEdit

        return;

    // launch an ObjectChange: This is the straightforward method

    // to get this broadcasted. We do not risk to set the model

    // unwantedly to changed, we had a text edit going on already.

    // This is needed for SlideShow since it is not (yet) using the

    // standard schema with VC/VOC/OC

    if (isInteractiveSlideShow())

        mxWeakTextEditObj.get()->BroadcastObjectChange();

    // force repaint for objects with changed text in all views

    // that are VC/VOC/OC based (SlideShow is not yet)

    sdr::contact::ViewContact& rVC(mxWeakTextEditObj.get()->GetViewContact());

    if (!rVC.hasMultipleViewObjectContacts())

        // only one VOC -> this is us

        return;

    if (nullptr == mpTextEditPV)

        // should not happen, just invalidate all visualizations

        rVC.ActionChanged();

    else

        // invalidate only visualizations in different views:

        // this is important to not cause eventual high repaint costs

        // in the EditView -> we avoid this by running the TextEdit

        // on the overlay. NOTE: This is only for better performance,

        // any repaint will just work fine and do the right thing

        rVC.ActionChangedIfDifferentPageView(*mpTextEditPV);

}

SdrObjEditView::~SdrObjEditView()

{

    maTextEditUpdateTimer.Stop();

    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 = m_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(m_aMinTextEditArea);

        aOldArea.Union(m_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<tools::Long>(aGridOffset.getX()),

                                    basegfx::fround<tools::Long>(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 != m_aTextEditArea

                || aMinArea1 != m_aMinTextEditArea

                || mpTextEditOutliner->GetMinAutoPaperSize() != aPaperMin1

                || mpTextEditOutliner->GetMaxAutoPaperSize() != aPaperMax1)

            {

                m_aTextEditArea = aEditArea1;

                m_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);

                vcl::Window* pWin = pOLV->GetWindow();

                if (!pWin || pWin->isDisposed())

                    continue;

                { // invalidate old OutlinerView area

                    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);

                bool bWasCoursorVisible = pOLV->IsCursorVisible();

                vcl::Cursor* pOldCursor = pWin->GetCursor();

                pOLV->SetOutputArea(

                    m_aTextEditArea); // because otherwise, we're not re-anchoring correctly

                ImpInvalidateOutlinerView(*pOLV);

                // Undo SetOutputArea setting and showing the cursor

                if (!bWasCoursorVisible)

                    pOLV->HideCursor();

                pWin->SetCursor(pOldCursor);

            }

            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(new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D(

            basegfx::B2DPolyPolygon(

                basegfx::utils::createPolygonFromRect(aClipPolyPolygon.getB2DRange())),

            aRGBColor));

        aRetval.append(mrTextEditOverlayObject.getTextPrimitives());

        aRetval.append(new drawinglayer::primitive2d::MaskPrimitive2D(std::move(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

        TextHierarchyBreakupBlockText aBreakup(*pSdrOutliner, aNewTransformA, aNewTransformB,

                                               aClipRange);

        pSdrOutliner->StripPortions(aBreakup);

        aNewTextPrimitives.append(aBreakup.getTextPortionPrimitives());

        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 eventual 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(m_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 eventual existing instances of the

// TextEditOverlayObject(s). This call *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());

        return;

    }

    // draw old text edit stuff

    if (!IsTextEdit())

        return;

    const SdrOutliner* pActiveOutliner = GetTextEditOutliner();

    if (!pActiveOutliner)