/* -*- 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 <memory>

#include <viscrs.hxx>

#include <o3tl/any.hxx>

#include <sfx2/printer.hxx>

#include <sfx2/viewfrm.hxx>

#include <cmdid.h>

#include <docsh.hxx>

#include <rubylist.hxx>

#include <doc.hxx>

#include <IDocumentDeviceAccess.hxx>

#include <unotxvw.hxx>

#include <unodispatch.hxx>

#include <unomap.hxx>

#include <unoprnms.hxx>

#include <view.hxx>

#include <viewopt.hxx>

#include <unomod.hxx>

#include <unoframe.hxx>

#include <unocrsr.hxx>

#include <wrtsh.hxx>

#include <unotbl.hxx>

#include <svx/fmshell.hxx>

#include <svx/svdview.hxx>

#include <svx/svdpage.hxx>

#include <svx/svdouno.hxx>

#include <editeng/pbinitem.hxx>

#include <pagedesc.hxx>

#include <editeng/lrspitem.hxx>

#include <editeng/ulspitem.hxx>

#include <sfx2/bindings.hxx>

#include <sfx2/request.hxx>

#include <frmatr.hxx>

#include <IMark.hxx>

#include <unodraw.hxx>

#include <svx/svdpagv.hxx>

#include <ndtxt.hxx>

#include <SwStyleNameMapper.hxx>

#include <com/sun/star/beans/PropertyAttribute.hpp>

#include <com/sun/star/drawing/ShapeCollection.hpp>

#include <editeng/outliner.hxx>

#include <editeng/editview.hxx>

#include <unoparagraph.hxx>

#include <unocrsrhelper.hxx>

#include <unotextrange.hxx>

#include <sfx2/docfile.hxx>

#include <swdtflvr.hxx>

#include <rootfrm.hxx>

#include <edtwin.hxx>

#include <vcl/svapp.hxx>

#include <comphelper/processfactory.hxx>

#include <comphelper/profilezone.hxx>

#include <comphelper/servicehelper.hxx>

#include <cppuhelper/supportsservice.hxx>

#include <cppuhelper/typeprovider.hxx>

#include <tools/UnitConversion.hxx>

#include <comphelper/dumpxmltostring.hxx>

#include <fmtanchr.hxx>

#include <names.hxx>

using namespace ::com::sun::star;

using namespace ::com::sun::star::uno;

using namespace ::com::sun::star::lang;

using namespace ::com::sun::star::beans;

using namespace ::com::sun::star::text;

using namespace ::com::sun::star::view;

using namespace ::com::sun::star::frame;

using ::com::sun::star::util::URL;

SwXTextView::SwXTextView(SwView* pSwView) :

    SwXTextView_Base(pSwView),

    m_SelChangedListeners(m_aMutex),

    m_pView(pSwView),

    m_pPropSet( aSwMapProvider.GetPropertySet( PROPERTY_MAP_TEXT_VIEW ) )

{

}

SwXTextView::~SwXTextView()

{

    Invalidate();

}

void SwXTextView::Invalidate()

{

    if(mxViewSettings.is())

    {

        mxViewSettings->Invalidate();

        mxViewSettings.clear();

    }

    if(mxTextViewCursor.is())

    {

        mxTextViewCursor->Invalidate();

        mxTextViewCursor.clear();

    }

    osl_atomic_increment(&m_refCount); //prevent second d'tor call

    {

        uno::Reference<uno::XInterface> const xInt(static_cast<

                cppu::OWeakObject*>(static_cast<SfxBaseController*>(this)));

        lang::EventObject aEvent(xInt);

        m_SelChangedListeners.disposeAndClear(aEvent);

    }

    osl_atomic_decrement(&m_refCount);

    m_pView = nullptr;

}

sal_Bool SwXTextView::select(const uno::Any& aInterface)

{

    SolarMutexGuard aGuard;

    uno::Reference< uno::XInterface >  xInterface;

    if (!GetView() || !(aInterface >>= xInterface))

    {

        return false;

    }

    SwWrtShell& rSh = GetView()->GetWrtShell();

    SwDoc* pDoc = GetView()->GetDocShell()->GetDoc();

    std::vector<SdrObject *> sdrObjects;

    uno::Reference<awt::XControlModel> const xCtrlModel(xInterface,

            UNO_QUERY);

    if (xCtrlModel.is())

    {

        uno::Reference<awt::XControl> xControl;

        SdrObject *const pSdrObject = GetControl(xCtrlModel, xControl);

        if (pSdrObject) // hmm... needs view to verify it's in right doc...

        {

            sdrObjects.push_back(pSdrObject);

        }

    }

    else

    {

        std::optional<SwPaM> pPaM;

        std::pair<UIName, FlyCntType> frame;

        UIName tableName;

        SwUnoTableCursor const* pTableCursor(nullptr);

        ::sw::mark::MarkBase const* pMark(nullptr);

        SwUnoCursorHelper::GetSelectableFromAny(xInterface, *pDoc,

                pPaM, frame, tableName, pTableCursor, pMark, sdrObjects);

        if (pPaM)

        {

            rSh.EnterStdMode();

            rSh.SetSelection(*pPaM);

            // the pPaM has been copied - delete it

            while (pPaM->GetNext() != &*pPaM)

            {

                // coverity[deref_arg] - the SwPaM delete moves a new entry into GetNext()

                delete pPaM->GetNext();

            }

            pPaM.reset();

            return true;

        }

        else if (!frame.first.isEmpty())

        {

            bool const bSuccess(rSh.GotoFly(frame.first, frame.second));

            if (bSuccess)

            {

                rSh.HideCursor();

                rSh.EnterSelFrameMode();

            }

            return true;

        }

        else if (!tableName.isEmpty())

        {

            rSh.EnterStdMode();

            rSh.GotoTable(tableName);

            return true;

        }

        else if (pTableCursor)

        {

            UnoActionRemoveContext const aContext(*pTableCursor);

            rSh.EnterStdMode();

            rSh.SetSelection(*pTableCursor);

            return true;

        }

        else if (pMark)

        {

            rSh.EnterStdMode();

            rSh.GotoMark(pMark);

            return true;

        }

        // sdrObjects handled below

    }

    bool bRet(false);

    if (!sdrObjects.empty())

    {

        SdrView *const pDrawView = rSh.GetDrawView();

        SdrPageView *const pPV = pDrawView->GetSdrPageView();

        pDrawView->SdrEndTextEdit();

        pDrawView->UnmarkAll();

        for (SdrObject* pSdrObject : sdrObjects)

        {

            // GetSelectableFromAny did not check pSdrObject is in right doc!

            if (pPV && pSdrObject->getSdrPageFromSdrObject() == pPV->GetPage())

            {

                pDrawView->MarkObj(pSdrObject, pPV);

                bRet = true;

            }

        }

        // tdf#112696 if we selected every individual element of a group, then

        // select that group instead

        const SdrMarkList &rMrkList = pDrawView->GetMarkedObjectList();

        size_t nMarkCount = rMrkList.GetMarkCount();

        if (nMarkCount > 1)

        {

            SdrObject* pObject = rMrkList.GetMark(0)->GetMarkedSdrObj();

            SdrObject* pGroupParent = pObject->getParentSdrObjectFromSdrObject();

            for (size_t i = 1; i < nMarkCount; ++i)

            {

                pObject = rMrkList.GetMark(i)->GetMarkedSdrObj();

                SdrObject* pParent = pObject->getParentSdrObjectFromSdrObject();

                if (pParent != pGroupParent)

                {

                    pGroupParent = nullptr;

                    break;

                }

            }

            if (pGroupParent && pGroupParent->IsGroupObject() &&

                pGroupParent->getChildrenOfSdrObject()->GetObjCount() == nMarkCount)

            {

                pDrawView->UnmarkAll();

                pDrawView->MarkObj(pGroupParent, pPV);

            }

        }

    }

    return bRet;

}

uno::Any SwXTextView::getSelection()

{

    SolarMutexGuard aGuard;

    uno::Reference< uno::XInterface >  aRef;

    if(GetView())

    {

        //force immediate shell update

        m_pView->StopShellTimer();

        //Generating an interface from the current selection.

        SwWrtShell& rSh = m_pView->GetWrtShell();

        ShellMode eSelMode = m_pView->GetShellMode();

        switch(eSelMode)

        {

            case ShellMode::TableText      :

            {

                if(rSh.GetTableCursor())

                {

                    OSL_ENSURE(rSh.GetTableFormat(), "not a table format?");

                    uno::Reference< text::XTextTableCursor >  xCursor = new SwXTextTableCursor(*rSh.GetTableFormat(),

                                                    rSh.GetTableCursor());

                    aRef.set(xCursor, uno::UNO_QUERY);

                    break;

                }

                [[fallthrough]];

                    // without a table selection the text will be delivered

            }

            case ShellMode::ListText       :

            case ShellMode::TableListText:

            case ShellMode::Text            :

            {

                rtl::Reference< SwXTextRanges > xPos = SwXTextRanges::Create(rSh.GetCursor());

                aRef.set(uno::Reference< container::XIndexAccess >(xPos), uno::UNO_QUERY);

            }

            break;

            case ShellMode::Frame           :

            {

                SwFrameFormat *const pFormat = rSh.GetFlyFrameFormat();

                if (pFormat)

                {

                    aRef = cppu::getXWeak(SwXTextFrame::CreateXTextFrame(

                            pFormat->GetDoc(), pFormat).get());

                }

            }

            break;

            case ShellMode::Graphic         :

            {

                SwFrameFormat *const pFormat = rSh.GetFlyFrameFormat();

                if (pFormat)

                {

                    aRef = cppu::getXWeak(SwXTextGraphicObject::CreateXTextGraphicObject(

                            pFormat->GetDoc(), pFormat).get());

                }

            }

            break;

            case ShellMode::Object          :

            {

                SwFrameFormat *const pFormat = rSh.GetFlyFrameFormat();

                if (pFormat)

                {

                    aRef = cppu::getXWeak(SwXTextEmbeddedObject::CreateXTextEmbeddedObject(

                            pFormat->GetDoc(), pFormat).get());

                }

            }

            break;

            case ShellMode::Draw            :

            case ShellMode::DrawForm        :

            case ShellMode::DrawText        :

            case ShellMode::Bezier          :

            case ShellMode::ExtrudedCustomShape:

            case ShellMode::FontWork:

            {

                uno::Reference< drawing::XShapes >  xShCol = drawing::ShapeCollection::create(

                        comphelper::getProcessComponentContext());

                const SdrMarkList& rMarkList = rSh.GetDrawView()->GetMarkedObjectList();

                for(size_t i = 0; i < rMarkList.GetMarkCount(); ++i)

                {

                    SdrObject* pObj = rMarkList.GetMark(i)->GetMarkedSdrObj();

                    uno::Reference<drawing::XShape> xShape = SwFmDrawPage::GetShape( pObj );

                    xShCol->add(xShape);

                }

                aRef.set(xShCol, uno::UNO_QUERY);

            }

            break;

            default:;//prevent warning

        }

    }

    uno::Any aRet(&aRef, cppu::UnoType<uno::XInterface>::get());

    return aRet;

}

void SwXTextView::addSelectionChangeListener(

                                    const uno::Reference< view::XSelectionChangeListener > & rxListener)

{

    SolarMutexGuard aGuard;

    m_SelChangedListeners.addInterface(rxListener);

}

void SwXTextView::removeSelectionChangeListener(

                                        const uno::Reference< view::XSelectionChangeListener > & rxListener)

{

    SolarMutexGuard aGuard;

    m_SelChangedListeners.removeInterface(rxListener);

}

SdrObject* SwXTextView::GetControl(

        const uno::Reference< awt::XControlModel > & xModel,

        uno::Reference< awt::XControl >& xToFill  )

{

    SwView* pView2 = GetView();

    FmFormShell* pFormShell = pView2 ? pView2->GetFormShell() : nullptr;

    SdrView* pDrawView = pView2 ? pView2->GetDrawView() : nullptr;

    vcl::Window* pWindow = pView2 ? pView2->GetWrtShell().GetWin() : nullptr;

    OSL_ENSURE( pFormShell && pDrawView && pWindow, "SwXTextView::GetControl: how could I?" );

    SdrObject* pControl = nullptr;

    if ( pFormShell && pDrawView && pWindow )

        pControl = pFormShell->GetFormControl( xModel, *pDrawView, *pWindow->GetOutDev(), xToFill );

    return pControl;

}

uno::Reference< awt::XControl >  SwXTextView::getControl(const uno::Reference< awt::XControlModel > & xModel)

{

    SolarMutexGuard aGuard;

    uno::Reference< awt::XControl >  xRet;

    GetControl(xModel, xRet);

    return xRet;

}

uno::Reference< form::runtime::XFormController > SAL_CALL SwXTextView::getFormController( const uno::Reference< form::XForm >& Form )

{

    SolarMutexGuard aGuard;

    SwView* pView2 = GetView();

    FmFormShell* pFormShell = pView2 ? pView2->GetFormShell() : nullptr;

    SdrView* pDrawView = pView2 ? pView2->GetDrawView() : nullptr;

    vcl::Window* pWindow = pView2 ? pView2->GetWrtShell().GetWin() : nullptr;

    OSL_ENSURE( pFormShell && pDrawView && pWindow, "SwXTextView::getFormController: how could I?" );

    uno::Reference< form::runtime::XFormController > xController;

    if ( pFormShell && pDrawView && pWindow )

        xController = FmFormShell::GetFormController( Form, *pDrawView, *pWindow->GetOutDev() );

    return xController;

}

sal_Bool SAL_CALL SwXTextView::isFormDesignMode(  )

{

    SolarMutexGuard aGuard;

    SwView* pView2 = GetView();

    FmFormShell* pFormShell = pView2 ? pView2->GetFormShell() : nullptr;

    return !pFormShell || pFormShell->IsDesignMode();

}

void SAL_CALL SwXTextView::setFormDesignMode( sal_Bool DesignMode )

{

    SolarMutexGuard aGuard;

    SwView* pView2 = GetView();

    FmFormShell* pFormShell = pView2 ? pView2->GetFormShell() : nullptr;

    if ( pFormShell )

        pFormShell->SetDesignMode( DesignMode );

}

uno::Reference< text::XTextViewCursor >  SwXTextView::getViewCursor()

{

    SolarMutexGuard aGuard;

    comphelper::ProfileZone aZone("getViewCursor");

    if(!GetView())

        throw uno::RuntimeException();

    if(!mxTextViewCursor.is())

    {

        mxTextViewCursor = new SwXTextViewCursor(GetView());

    }

    return mxTextViewCursor;

}

uno::Reference<text::XTextRange>

SwXTextView::createTextRangeByPixelPosition(const awt::Point& rPixelPosition)

{

    SolarMutexGuard aGuard;

    Point aPixelPoint(rPixelPosition.X, rPixelPosition.Y);

    if (!m_pView)

        throw RuntimeException();

    Point aLogicPoint = m_pView->GetEditWin().PixelToLogic(aPixelPoint);

    SwWrtShell& rSh = m_pView->GetWrtShell();

    SwPosition aPosition(*rSh.GetCurrentShellCursor().GetPoint());

    rSh.GetLayout()->GetModelPositionForViewPoint(&aPosition, aLogicPoint);

    if (aPosition.GetNode().IsGrfNode())

    {

        // The point is closest to a graphic node, look up its format.

        const SwFrameFormat* pGraphicFormat = aPosition.GetNode().GetFlyFormat();

        if (pGraphicFormat)

        {

            // Get the anchor of this format.

            const SwFormatAnchor& rAnchor = pGraphicFormat->GetAnchor();

            const SwPosition* pAnchor = rAnchor.GetContentAnchor();

            if (pAnchor)

            {

                aPosition = *pAnchor;

            }

            else

            {

                // Page-anchored graphics have no anchor.

                return {};

            }

        }

    }

    rtl::Reference<SwXTextRange> xRet

        = SwXTextRange::CreateXTextRange(*rSh.GetDoc(), aPosition, /*pMark=*/nullptr);

    return xRet;

}

uno::Reference< beans::XPropertySet >  SwXTextView::getViewSettings()

{

    SolarMutexGuard aGuard;

    if(!m_pView)

        throw uno::RuntimeException();

    if(!mxViewSettings.is())

    {

        mxViewSettings = new SwXViewSettings( m_pView );

    }

    return mxViewSettings;

}

Sequence< Sequence< PropertyValue > > SwXTextView::getRubyList( sal_Bool /*bAutomatic*/ )

{

    SolarMutexGuard aGuard;

    if(!GetView())

        throw RuntimeException();

    SwWrtShell& rSh = m_pView->GetWrtShell();

    ShellMode  eSelMode = m_pView->GetShellMode();

    if (eSelMode != ShellMode::ListText      &&

        eSelMode != ShellMode::TableListText &&

        eSelMode != ShellMode::TableText      &&

        eSelMode != ShellMode::Text           )

        return Sequence< Sequence< PropertyValue > > ();

    SwRubyList aList;

    const sal_uInt16 nCount = SwDoc::FillRubyList( *rSh.GetCursor(), aList );

    Sequence< Sequence< PropertyValue > > aRet(nCount);

    Sequence< PropertyValue >* pRet = aRet.getArray();

    ProgName aString;

    for(sal_uInt16 n = 0; n < nCount; n++)

    {

        const SwRubyListEntry* pEntry = aList[n].get();

        const OUString& rEntryText = pEntry->GetText();

        const SwFormatRuby& rAttr = pEntry->GetRubyAttr();

        sal_Int32 nSequence = pEntry->GetSequence();

        pRet[n].realloc(7);

        PropertyValue* pValues = pRet[n].getArray();

        pValues[0].Name = UNO_NAME_RUBY_BASE_TEXT;

        pValues[0].Value <<= rEntryText;

        pValues[1].Name = UNO_NAME_RUBY_TEXT;

        pValues[1].Value <<= rAttr.GetText();

        pValues[2].Name = UNO_NAME_RUBY_CHAR_STYLE_NAME;

        SwStyleNameMapper::FillProgName(rAttr.GetCharFormatName(), aString, SwGetPoolIdFromName::ChrFmt );

        pValues[2].Value <<= aString.toString();

        pValues[3].Name = UNO_NAME_RUBY_ADJUST;

        pValues[3].Value <<= static_cast<sal_Int16>(rAttr.GetAdjustment());

        pValues[4].Name = UNO_NAME_RUBY_IS_ABOVE;

        pValues[4].Value <<= !rAttr.GetPosition();

        pValues[5].Name = UNO_NAME_RUBY_POSITION;

        pValues[5].Value <<= rAttr.GetPosition();

        pValues[6].Name = UNO_NAME_RUBY_SEQUENCE_NUMBER;

        pValues[6].Value <<= nSequence;

    }

    return aRet;

}

void SAL_CALL SwXTextView::setRubyList(

    const Sequence< Sequence< PropertyValue > >& rRubyList, sal_Bool /*bAutomatic*/ )

{

    SolarMutexGuard aGuard;

    if(!GetView() || !rRubyList.hasElements())

        throw RuntimeException();

    SwWrtShell& rSh = m_pView->GetWrtShell();

    ShellMode eSelMode = m_pView->GetShellMode();

    if (eSelMode != ShellMode::ListText      &&

        eSelMode != ShellMode::TableListText &&

        eSelMode != ShellMode::TableText      &&

        eSelMode != ShellMode::Text           )

        throw RuntimeException();

    SwRubyList aList;

    for(const Sequence<PropertyValue>& rPropList : rRubyList)

    {

        std::unique_ptr<SwRubyListEntry> pEntry(new SwRubyListEntry);

        OUString sTmp;

        for(const PropertyValue& rProperty : rPropList)

        {

            if(rProperty.Name == UNO_NAME_RUBY_BASE_TEXT)

            {

                rProperty.Value >>= sTmp;

                pEntry->SetText(sTmp);

            }

            else if(rProperty.Name == UNO_NAME_RUBY_TEXT)

            {

                rProperty.Value >>= sTmp;

                pEntry->GetRubyAttr().SetText(sTmp);

            }

            else if(rProperty.Name == UNO_NAME_RUBY_CHAR_STYLE_NAME)

            {

                if(rProperty.Value >>= sTmp)

                {

                    UIName sName;

                    SwStyleNameMapper::FillUIName(ProgName(sTmp), sName, SwGetPoolIdFromName::ChrFmt );

                    const SwPoolFormatId nPoolId = sName.isEmpty() ? SwPoolFormatId::ZERO

                        : SwStyleNameMapper::GetPoolIdFromUIName(sName,

                                SwGetPoolIdFromName::ChrFmt );

                    pEntry->GetRubyAttr().SetCharFormatName( sName );

                    pEntry->GetRubyAttr().SetCharFormatId( nPoolId );

                }

            }

            else if(rProperty.Name == UNO_NAME_RUBY_ADJUST)

            {

                sal_Int16 nTmp = 0;

                if(rProperty.Value >>= nTmp)

                    pEntry->GetRubyAttr().SetAdjustment(static_cast<css::text::RubyAdjust>(nTmp));

            }

            else if(rProperty.Name == UNO_NAME_RUBY_IS_ABOVE)

            {

                bool bValue = !rProperty.Value.hasValue() ||

                    *o3tl::doAccess<bool>(rProperty.Value);

                pEntry->GetRubyAttr().SetPosition(bValue ? 0 : 1);

            }

            else if(rProperty.Name == UNO_NAME_RUBY_POSITION)

            {

                sal_Int16 nTmp = 0;

                if(rProperty.Value >>= nTmp)

                    pEntry->GetRubyAttr().SetPosition( nTmp );

            }

            else if (rProperty.Name == UNO_NAME_RUBY_SEQUENCE_NUMBER)

            {

                sal_Int32 nTmp = 0;

                if (rProperty.Value >>= nTmp)

                {

                    pEntry->SetSequence(nTmp);

                }

            }

        }

        aList.push_back(std::move(pEntry));

    }

    SwDoc* pDoc = m_pView->GetDocShell()->GetDoc();

    pDoc->SetRubyList( *rSh.GetCursor(), aList );

}

SfxObjectShellLock SwXTextView::BuildTmpSelectionDoc()

{

    SwWrtShell& rOldSh = m_pView->GetWrtShell();

    SfxPrinter *pPrt = rOldSh.getIDocumentDeviceAccess().getPrinter( false );

    rtl::Reference<SwDocShell> pDocSh = new SwDocShell(SfxObjectCreateMode::STANDARD);

    SfxObjectShellLock xDocSh(pDocSh.get());

    xDocSh->DoInitNew();

    SwDoc *const pTempDoc( pDocSh->GetDoc() );

    // #i103634#, #i112425#: do not expand numbering and fields on PDF export

    pTempDoc->SetClipBoard(true);

    rOldSh.FillPrtDoc(*pTempDoc,  pPrt);

    SfxViewFrame* pDocFrame = SfxViewFrame::LoadHiddenDocument( *xDocSh, SFX_INTERFACE_NONE );

    SwView* pDocView = static_cast<SwView*>( pDocFrame->GetViewShell() );

    pDocView->AttrChangedNotify(nullptr);//So that SelectShell is called.

    if (SwWrtShell* pSh = pDocView->GetWrtShellPtr())

    {

        IDocumentDeviceAccess& rIDDA = pSh->getIDocumentDeviceAccess();

        SfxPrinter* pTempPrinter = rIDDA.getPrinter( true );

        const SwPageDesc& rCurPageDesc = rOldSh.GetPageDesc(rOldSh.GetCurPageDesc());

        IDocumentDeviceAccess& rIDDA_old = rOldSh.getIDocumentDeviceAccess();

        if( rIDDA_old.getPrinter( false ) )

        {

            rIDDA.setJobsetup( *rIDDA_old.getJobsetup() );

            //#69563# if it isn't the same printer then the pointer has been invalidated!

            pTempPrinter = rIDDA.getPrinter( true );

        }

        pTempPrinter->SetPaperBin(rCurPageDesc.GetMaster().GetPaperBin().GetValue());

    }

    return xDocSh;

}

void SwXTextView::NotifySelChanged()

{

    OSL_ENSURE( m_pView, "view is missing" );

    lang::EventObject const aEvent(getXWeak());

    m_SelChangedListeners.notifyEach(

            &view::XSelectionChangeListener::selectionChanged, aEvent);

}

void SwXTextView::NotifyDBChanged()

{

    URL aURL;

    aURL.Complete = OUString::createFromAscii(SwXDispatch::GetDBChangeURL());

    m_SelChangedListeners.forEach(

        [&aURL] (const uno::Reference<XSelectionChangeListener>& xListener)

        {

            uno::Reference<XDispatch> xDispatch(xListener, UNO_QUERY);

            if (xDispatch)

                xDispatch->dispatch(aURL, {});

        });

}

uno::Reference< beans::XPropertySetInfo > SAL_CALL SwXTextView::getPropertySetInfo(  )

{

    SolarMutexGuard aGuard;

    static uno::Reference< XPropertySetInfo > aRef = m_pPropSet->getPropertySetInfo();

    return aRef;

}

void SAL_CALL SwXTextView::setPropertyValue(

        const OUString& rPropertyName, const uno::Any& rValue )

{

    SolarMutexGuard aGuard;

    if (rPropertyName == "PDFExport_ShowChanges")

    {

        // hack used in PDF export code to turn off (or on) exporting showing tracked changes

        // logic is simplified from FN_REDLINE_SHOW path in SwView

        bool bShow = false;

        rValue >>= bShow;

        SwWrtShell& rSh = m_pView->GetWrtShell();

        rSh.StartAllAction();

        rSh.GetLayout()->SetHideRedlines(!bShow);

        rSh.EndAllAction();

        return;

    }

    const SfxItemPropertyMapEntry* pEntry = m_pPropSet->getPropertyMap().getByName( rPropertyName );

    if (!pEntry)

        throw UnknownPropertyException(rPropertyName);

    else if (pEntry->nFlags & PropertyAttribute::READONLY)

        throw PropertyVetoException();

    else

    {

        switch (pEntry->nWID)

        {

            case WID_IS_HIDE_SPELL_MARKS :

                // deprecated #i91949

            break;

            case WID_IS_CONSTANT_SPELLCHECK :

            {

                bool bVal = false;

                const SwViewOption *pOpt = m_pView->GetWrtShell().GetViewOptions();

                if (!pOpt || !(rValue >>= bVal))

                    throw RuntimeException();

                SwViewOption aNewOpt( *pOpt );

                if (pEntry->nWID == WID_IS_CONSTANT_SPELLCHECK)

                    aNewOpt.SetOnlineSpell(bVal);

                m_pView->GetWrtShell().ApplyViewOptions( aNewOpt );

            }

            break;

            default :

                OSL_FAIL("unknown WID");

        }

    }

}

uno::Any SAL_CALL SwXTextView::getPropertyValue(

        const OUString& rPropertyName )

{

    SolarMutexGuard aGuard;

    Any aRet;

    if (rPropertyName == "PDFExport_ShowChanges")

    {

        const bool bShow = !m_pView->GetWrtShell().GetLayout()->IsHideRedlines();

        aRet <<= bShow;

        return aRet;

    }

    const SfxItemPropertyMapEntry* pEntry = m_pPropSet->getPropertyMap().getByName( rPropertyName );

    if (!pEntry)

        throw UnknownPropertyException(rPropertyName);

    sal_Int16 nWID = pEntry->nWID;

    switch (nWID)

    {

        case WID_PAGE_COUNT :

        case WID_LINE_COUNT :

        {

            // format document completely in order to get meaningful

            // values for page count and line count

            m_pView->GetWrtShell().CalcLayout();

            sal_Int32 nCount = -1;

            if (nWID == WID_PAGE_COUNT)

                nCount = m_pView->GetWrtShell().GetPageCount();

            else // WID_LINE_COUNT

                nCount = m_pView->GetWrtShell().GetLineCount();

            aRet <<= nCount;

        }

        break;

        case WID_IS_HIDE_SPELL_MARKS :

            // deprecated #i91949

        break;

        case WID_IS_CONSTANT_SPELLCHECK :

        {

            const SwViewOption *pOpt = m_pView->GetWrtShell().GetViewOptions();

            if (!pOpt)

                throw RuntimeException();

            aRet <<= pOpt->IsOnlineSpell();

        }

        break;

        default :

            OSL_FAIL("unknown WID");

    }

    return aRet;

}

void SAL_CALL SwXTextView::addPropertyChangeListener(

        const OUString& /*rPropertyName*/,

        const uno::Reference< beans::XPropertyChangeListener >& /*rxListener*/ )

{

    OSL_FAIL("not implemented");

}

void SAL_CALL SwXTextView::removePropertyChangeListener(

        const OUString& /*rPropertyName*/,

        const uno::Reference< beans::XPropertyChangeListener >& /*rxListener*/ )

{

    OSL_FAIL("not implemented");

}

void SAL_CALL SwXTextView::addVetoableChangeListener(

        const OUString& /*rPropertyName*/,

        const uno::Reference< beans::XVetoableChangeListener >& /*rxListener*/ )

{

    OSL_FAIL("not implemented");

}

void SAL_CALL SwXTextView::removeVetoableChangeListener(

        const OUString& /*rPropertyName*/,

        const uno::Reference< beans::XVetoableChangeListener >& /*rxListener*/ )

{

    OSL_FAIL("not implemented");

}

OUString SwXTextView::getImplementationName()

{

    return u"SwXTextView"_ustr;

}

sal_Bool SwXTextView::supportsService(const OUString& rServiceName)

{

    return cppu::supportsService(this, rServiceName);

}

Sequence< OUString > SwXTextView::getSupportedServiceNames()

{

    return { u"com.sun.star.text.TextDocumentView"_ustr, u"com.sun.star.view.OfficeDocumentView"_ustr };

}

SwXTextViewCursor::SwXTextViewCursor(SwView* pVw) :

    m_pView(pVw),

    m_pPropSet(aSwMapProvider.GetPropertySet(PROPERTY_MAP_TEXT_CURSOR))

{

}

SwXTextViewCursor::~SwXTextViewCursor()

{

}

// used to determine if there is a text selection or not.

// If there is no text selection the functions that need a working

// cursor will be disabled (throw RuntimeException). This will be the case

// for the following interfaces:

// - XViewCursor

// - XTextCursor

// - XTextRange

// - XLineCursor

bool SwXTextViewCursor::IsTextSelection( bool bAllowTables ) const

{

    bool bRes = false;

    OSL_ENSURE(m_pView, "m_pView is NULL ???");

    if(m_pView)

    {

        //! m_pView->GetShellMode() will only work after the shell

        //! has already changed and thus can not be used here!

        SelectionType eSelType = m_pView->GetWrtShell().GetSelectionType();

        bRes =  ( (SelectionType::Text & eSelType) ||

                  (SelectionType::NumberList & eSelType) )  &&

                (!(SelectionType::TableCell & eSelType) || bAllowTables);

    }

    return bRes;

}

sal_Bool SwXTextViewCursor::isVisible()

{

    OSL_FAIL("not implemented");

    return true;

}

void SwXTextViewCursor::setVisible(sal_Bool /*bVisible*/)

{

    OSL_FAIL("not implemented");

}

awt::Point SwXTextViewCursor::getPosition()

{

    SolarMutexGuard aGuard;

    awt::Point aRet;

    if(!m_pView)

        throw uno::RuntimeException();

    const SwWrtShell& rSh = m_pView->GetWrtShell();

    const SwRect& aCharRect(rSh.GetCharRect());

    const SwFrameFormat& rMaster = rSh.GetPageDesc( rSh.GetCurPageDesc() ).GetMaster();

    const SvxULSpaceItem& rUL = rMaster.GetULSpace();

    const tools::Long nY = aCharRect.Top() - (rUL.GetUpper() + DOCUMENTBORDER);

    aRet.Y = convertTwipToMm100(nY);

    const SvxLRSpaceItem& rLR = rMaster.GetLRSpace();

    const tools::Long nX = aCharRect.Left() - (rLR.ResolveLeft() + DOCUMENTBORDER);

    aRet.X = convertTwipToMm100(nX);

    return aRet;

}

void SwXTextViewCursor::collapseToStart()