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

#include <string_view>

#include <config_features.h>

#include <config_wasm_strip.h>

#include <stdlib.h>

#include <hintids.hxx>

#include <comphelper/diagnose_ex.hxx>

#include <comphelper/string.hxx>

#include <comphelper/lok.hxx>

#include <o3tl/any.hxx>

#include <o3tl/string_view.hxx>

#include <officecfg/Office/Common.hxx>

#include <vcl/graph.hxx>

#include <vcl/inputctx.hxx>

#include <svl/eitem.hxx>

#include <unotools/configmgr.hxx>

#include <unotools/lingucfg.hxx>

#include <unotools/useroptions.hxx>

#include <sfx2/dispatch.hxx>

#include <sfx2/docfile.hxx>

#include <sfx2/objface.hxx>

#include <sfx2/request.hxx>

#include <svx/ruler.hxx>

#include <svx/srchdlg.hxx>

#include <svx/fmshell.hxx>

#include <svx/extrusionbar.hxx>

#include <svx/fontworkbar.hxx>

#include <svx/fmview.hxx>

#include <unotxvw.hxx>

#include <cmdid.h>

#include <svl/hint.hxx>

#include <swmodule.hxx>

#include <inputwin.hxx>

#include <uivwimp.hxx>

#include <edtwin.hxx>

#include <textsh.hxx>

#include <listsh.hxx>

#include <tabsh.hxx>

#include <grfsh.hxx>

#include <mediash.hxx>

#include <docsh.hxx>

#include <frmsh.hxx>

#include <olesh.hxx>

#include <drawsh.hxx>

#include <drawbase.hxx>

#include <drformsh.hxx>

#include <drwtxtsh.hxx>

#include <beziersh.hxx>

#include <navsh.hxx>

#include <globdoc.hxx>

#include <scroll.hxx>

#include <gloshdl.hxx>

#include <usrpref.hxx>

#include <srcview.hxx>

#include <doc.hxx>

#include <IDocumentUndoRedo.hxx>

#include <IDocumentSettingAccess.hxx>

#include <IDocumentDrawModelAccess.hxx>

#include <DocumentFieldsManager.hxx>

#include <IDocumentState.hxx>

#include <IDocumentLayoutAccess.hxx>

#include <drawdoc.hxx>

#include <wdocsh.hxx>

#include <wrtsh.hxx>

#include <barcfg.hxx>

#include <pview.hxx>

#include <swdtflvr.hxx>

#include <prtopt.hxx>

#include <unotxdoc.hxx>

#include <com/sun/star/frame/FrameSearchFlag.hpp>

#include <com/sun/star/frame/XLayoutManager.hpp>

#include <com/sun/star/scanner/ScannerContext.hpp>

#include <com/sun/star/scanner/XScannerManager2.hpp>

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

#include <com/sun/star/sdb/XDatabaseContext.hpp>

#include <com/sun/star/sdb/DatabaseContext.hpp>

#include <toolkit/helper/vclunohelper.hxx>

#include <sal/log.hxx>

#include <formatclipboard.hxx>

#include <PostItMgr.hxx>

#include <annotsh.hxx>

#include <swruler.hxx>

#include <svx/theme/ThemeColorChangerCommon.hxx>

#include <com/sun/star/document/XDocumentProperties.hpp>

#include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>

#include <comphelper/propertyvalue.hxx>

#include <comphelper/servicehelper.hxx>

#include <framework/windowstatehelper.hxx>

#include <sfx2/lokhelper.hxx>

#include <LibreOfficeKit/LibreOfficeKitEnums.h>

#include <svtools/embedhlp.hxx>

#include <tools/UnitConversion.hxx>

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

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

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

#include <svx/sdrpaintwindow.hxx>

#include <svx/svdview.hxx>

#include <node2lay.hxx>

#include <cntfrm.hxx>

#include <IDocumentRedlineAccess.hxx>

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

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

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

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

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

#define SWVIEWFLAGS SfxViewShellFlags::HAS_PRINTOPTIONS

// Statics. OMG.

bool bDocSzUpdated = true;

SvxSearchItem*  SwView::s_pSrchItem   = nullptr;

bool            SwView::s_bExtra      = false;

bool            SwView::s_bFound      = false;

bool            SwView::s_bJustOpened = false;

std::unique_ptr<SearchAttrItemList>  SwView::s_xSearchList;

std::unique_ptr<SearchAttrItemList>  SwView::s_xReplaceList;

SfxDispatcher &SwView::GetDispatcher()

{

    return *GetViewFrame().GetDispatcher();

}

void SwView::ImpSetVerb( SelectionType nSelType )

{

    Sequence<embed::VerbDescriptor> newVerbs;

    if ( !GetViewFrame().GetFrame().IsInPlace() &&

         (SelectionType::Ole|SelectionType::Graphic) & nSelType )

    {

        FlyProtectFlags eProtectFlags = m_pWrtShell->IsSelObjProtected(FlyProtectFlags::Content);

        if (eProtectFlags == FlyProtectFlags::NONE || nSelType & SelectionType::Ole)

        {

            if ( nSelType & SelectionType::Ole )

            {

                try

                {

                    newVerbs = GetWrtShell().GetOLEObject()->getSupportedVerbs();

                }

                catch (css::uno::Exception&)

                {

                    DBG_UNHANDLED_EXCEPTION("sw.ui", "Failed to retrieve supported verbs");

                }

            }

        }

    }

    if (m_bVerbsActive || newVerbs.hasElements())

    {

        SetVerbs(newVerbs);

        m_bVerbsActive = newVerbs.hasElements();

    }

}

// Called by the SwEditWin when it gets the focus.

void SwView::GotFocus() const

{

    // if we got the focus, and the form shell *is* on the top of the dispatcher

    // stack, then we need to rebuild the stack (the form shell doesn't belong to

    // the top then)

    const SfxDispatcher& rDispatcher = const_cast< SwView* >( this )->GetDispatcher();

    SfxShell* pTopShell = rDispatcher.GetShell( 0 );

    FmFormShell* pAsFormShell = dynamic_cast<FmFormShell*>( pTopShell  );

    if ( pAsFormShell )

    {

        pAsFormShell->ForgetActiveControl();

        const_cast< SwView* >( this )->AttrChangedNotify(nullptr);

    }

    else if ( m_pPostItMgr )

    {

        SwAnnotationShell* pAsAnnotationShell = dynamic_cast<SwAnnotationShell*>( pTopShell  );

        if ( pAsAnnotationShell )

        {

            m_pPostItMgr->SetActiveSidebarWin(nullptr);

            const_cast< SwView* >( this )->AttrChangedNotify(nullptr);

        }

    }

    if (SwWrtShell* pWrtShell = GetWrtShellPtr())

    {

        SwWrtShell& rWrtShell = GetWrtShell();

        rWrtShell.GetDoc()->getIDocumentLayoutAccess().SetCurrentViewShell( pWrtShell );

        rWrtShell.GetDoc()->getIDocumentSettingAccess().set( DocumentSettingId::BROWSE_MODE,

                                 rWrtShell.GetViewOptions()->getBrowseMode() );

    }

}

// called by the FormShell when a form control is focused. This is

// a request to put the form shell on the top of the dispatcher stack

IMPL_LINK_NOARG(SwView, FormControlActivated, LinkParamNone*, void)

{

    // if a form control has been activated, and the form shell is not on the top

    // of the dispatcher stack, then we need to activate it

    const SfxDispatcher& rDispatcher = GetDispatcher();

    const SfxShell* pTopShell = rDispatcher.GetShell( 0 );

    const FmFormShell* pAsFormShell = dynamic_cast<const FmFormShell*>( pTopShell  );

    if ( !pAsFormShell )

    {

        // if we're editing text currently, cancel this

        SdrView *pSdrView = m_pWrtShell ? m_pWrtShell->GetDrawView() : nullptr;

        if ( pSdrView && pSdrView->IsTextEdit() )

            pSdrView->SdrEndTextEdit( true );

        AttrChangedNotify(nullptr);

    }

}

namespace

{

uno::Reference<frame::XLayoutManager> getLayoutManager(const SfxViewFrame& rViewFrame)

{

    uno::Reference<frame::XLayoutManager> xLayoutManager;

    uno::Reference<beans::XPropertySet> xPropSet(rViewFrame.GetFrame().GetFrameInterface(),

                                                 uno::UNO_QUERY);

    if (xPropSet.is())

    {

        try

        {

            xLayoutManager.set(xPropSet->getPropertyValue(u"LayoutManager"_ustr), uno::UNO_QUERY);

        }

        catch (const Exception& e)

        {

            SAL_WARN("sw.ui", "Failure getting layout manager: " + e.Message);

        }

    }

    return xLayoutManager;

}

}

void SwView::SetUIElementVisibility(const OUString& sElementURL, bool bShow) const

{

    if (auto xLayoutManager = getLayoutManager(GetViewFrame()))

    {

        if (!xLayoutManager->getElement(sElementURL).is())

            xLayoutManager->createElement(sElementURL);

        if (bShow)

            xLayoutManager->showElement(sElementURL);

        else

            xLayoutManager->hideElement(sElementURL);

    }

}

void SwView::ShowUIElement(const OUString& sElementURL) const

{

    SetUIElementVisibility(sElementURL, true);

}

void SwView::HideUIElement(const OUString& sElementURL) const

{

    SetUIElementVisibility(sElementURL, false);

}

void SwView::SelectShell()

{

    // Attention: Maintain the SelectShell for the WebView additionally

    // In case of m_bDying, our SfxShells are already gone, don't try to select a shell at all.

    if(m_bInDtor || m_bDying)

        return;

    // Decision if the UpdateTable has to be called

    bool bUpdateTable = false;

    const SwFrameFormat* pCurTableFormat = m_pWrtShell->GetTableFormat();

    if(pCurTableFormat && pCurTableFormat != m_pLastTableFormat)

    {

        bUpdateTable = true; // can only be executed later

    }

    m_pLastTableFormat = pCurTableFormat;

    //SEL_TBL and SEL_TBL_CELLS can be ORed!

    SelectionType nNewSelectionType = m_pWrtShell->GetSelectionType()

                                & ~SelectionType::TableCell;

    // Determine if a different fly frame was selected.

    bool bUpdateFly = false;

    const SwFrameFormat* pCurFlyFormat = nullptr;

    if (m_nSelectionType & SelectionType::Ole || m_nSelectionType & SelectionType::Graphic)

    {

        pCurFlyFormat = m_pWrtShell->GetFlyFrameFormat();

    }

    if (pCurFlyFormat && pCurFlyFormat != m_pLastFlyFormat)

    {

        bUpdateFly = true;

    }

    m_pLastFlyFormat = pCurFlyFormat;

    if ( m_pFormShell && m_pFormShell->IsActiveControl() )

        nNewSelectionType |= SelectionType::FormControl;

    if ( nNewSelectionType == m_nSelectionType &&

        !(m_nSelectionType == SelectionType::Ole && m_pWrtShell->IsOLEMath()) )

    {

        GetViewFrame().GetBindings().InvalidateAll( false );

        if ( m_nSelectionType & SelectionType::Ole ||

             m_nSelectionType & SelectionType::Graphic )

            // For graphs and OLE the verb can be modified of course!

            ImpSetVerb( nNewSelectionType );

        if (bUpdateFly)

        {

            SfxViewFrame& rViewFrame = GetViewFrame();

            uno::Reference<frame::XFrame> xFrame = rViewFrame.GetFrame().GetFrameInterface();

            if (xFrame.is())

            {

                // Invalidate cached dispatch objects.

                xFrame->contextChanged();

            }

        }

    }

    else

    {

        SfxDispatcher &rDispatcher = GetDispatcher();

        SwToolbarConfigItem* pBarCfg = SwModule::get()->GetToolbarConfig();

        if ( m_pShell )

        {

            rDispatcher.Flush();        // Really erase all cached shells

            //Remember to the old selection which toolbar was visible

            ToolbarId eId = rDispatcher.GetObjectBarId(SFX_OBJECTBAR_OBJECT);

            if (eId != ToolbarId::None)

                pBarCfg->SetTopToolbar(m_nSelectionType, eId);

            for ( sal_uInt16 i = 0; true; ++i )

            {

                SfxShell *pSfxShell = rDispatcher.GetShell( i );

                if  (  dynamic_cast< const SwBaseShell *>( pSfxShell ) !=  nullptr

                    || dynamic_cast< const SwDrawTextShell *>( pSfxShell ) !=  nullptr

                    || dynamic_cast< const svx::ExtrusionBar*>( pSfxShell ) !=  nullptr

                    || dynamic_cast< const svx::FontworkBar*>( pSfxShell ) !=  nullptr

                    || dynamic_cast< const SwAnnotationShell *>( pSfxShell ) !=  nullptr

                    )

                {

                    rDispatcher.Pop( *pSfxShell, SfxDispatcherPopFlags::POP_DELETE );

                }

                else if ( dynamic_cast< const FmFormShell *>( pSfxShell ) !=  nullptr )

                {

                    rDispatcher.Pop( *pSfxShell );

                }

                else

                    break;

            }

        }

        bool bInitFormShell = false;

        if (!m_pFormShell)

        {

            bInitFormShell = true;

            m_pFormShell = new FmFormShell( this );

            m_pFormShell->SetControlActivationHandler( LINK( this, SwView, FormControlActivated ) );

            StartListening(*m_pFormShell);

        }

        bool bSetExtInpCntxt = false;

        m_nSelectionType = nNewSelectionType;

        ShellMode eShellMode;

        if ( !( m_nSelectionType & SelectionType::FormControl ) )

            rDispatcher.Push( *m_pFormShell );

        m_pShell = new SwNavigationShell( *this );

        rDispatcher.Push( *m_pShell );

        if ( m_nSelectionType & SelectionType::Ole )

        {

            eShellMode = ShellMode::Object;

            m_pShell = new SwOleShell( *this );

            rDispatcher.Push( *m_pShell );

        }

        else if ( m_nSelectionType & SelectionType::Frame

            || m_nSelectionType & SelectionType::Graphic)

        {

            eShellMode = ShellMode::Frame;

            m_pShell = new SwFrameShell( *this );

            rDispatcher.Push( *m_pShell );

            if(m_nSelectionType & SelectionType::Graphic )

            {

                eShellMode = ShellMode::Graphic;

                m_pShell = new SwGrfShell( *this );

                rDispatcher.Push( *m_pShell );

            }

        }

        else if ( m_nSelectionType & SelectionType::DrawObject )

        {

            eShellMode = ShellMode::Draw;

            m_pShell = new SwDrawShell( *this );

            rDispatcher.Push( *m_pShell );

            if ( m_nSelectionType & SelectionType::Ornament )

            {

                eShellMode = ShellMode::Bezier;

                m_pShell = new SwBezierShell( *this );

                rDispatcher.Push( *m_pShell );

            }

#if HAVE_FEATURE_AVMEDIA

            else if( m_nSelectionType & SelectionType::Media )

            {

                eShellMode = ShellMode::Media;

                m_pShell = new SwMediaShell( *this );

                rDispatcher.Push( *m_pShell );

            }

#endif

            if (m_nSelectionType & SelectionType::ExtrudedCustomShape)

            {

                eShellMode = ShellMode::ExtrudedCustomShape;

                m_pShell = new svx::ExtrusionBar(this);

                rDispatcher.Push( *m_pShell );

            }

            if (m_nSelectionType & SelectionType::FontWork)

            {

                eShellMode = ShellMode::FontWork;

                m_pShell = new svx::FontworkBar(this);

                rDispatcher.Push( *m_pShell );

            }

        }

        else if ( m_nSelectionType & SelectionType::DbForm )

        {

            eShellMode = ShellMode::DrawForm;

            m_pShell = new SwDrawFormShell( *this );

            rDispatcher.Push( *m_pShell );

        }

        else if ( m_nSelectionType & SelectionType::DrawObjectEditMode )

        {

            bSetExtInpCntxt = true;

            eShellMode = ShellMode::DrawText;

            rDispatcher.Push( *(new SwBaseShell( *this )) );

            m_pShell = new SwDrawTextShell( *this );

            rDispatcher.Push( *m_pShell );

        }

        else if ( m_nSelectionType & SelectionType::PostIt )

        {

            eShellMode = ShellMode::PostIt;

            m_pShell = new SwAnnotationShell( *this );

            rDispatcher.Push( *m_pShell );

        }

        else

        {

            bSetExtInpCntxt = true;

            eShellMode = ShellMode::Text;

            if ( m_nSelectionType & SelectionType::NumberList )

            {

                eShellMode = ShellMode::ListText;

                m_pShell = new SwListShell( *this );

                rDispatcher.Push( *m_pShell );

            }

            m_pShell = new SwTextShell(*this);

            rDispatcher.Push( *m_pShell );

            if ( m_nSelectionType & SelectionType::Table )

            {

                eShellMode = eShellMode == ShellMode::ListText ? ShellMode::TableListText

                                                        : ShellMode::TableText;

                m_pShell = new SwTableShell( *this );

                rDispatcher.Push( *m_pShell );

            }

        }

        if ( m_nSelectionType & SelectionType::FormControl )

            rDispatcher.Push( *m_pFormShell );

        m_pViewImpl->SetShellMode(eShellMode);

        ImpSetVerb( m_nSelectionType );

        if( !GetDocShell()->IsReadOnly() )

        {

            if( bSetExtInpCntxt && GetWrtShell().HasReadonlySel() )

                bSetExtInpCntxt = false;

            InputContext aCntxt( GetEditWin().GetInputContext() );

            aCntxt.SetOptions( bSetExtInpCntxt

                                ? (aCntxt.GetOptions() |

                                        ( InputContextFlags::Text |

                                            InputContextFlags::ExtText ))

                                : (aCntxt.GetOptions() & ~

                                        InputContextFlags( InputContextFlags::Text |

                                            InputContextFlags::ExtText )) );

            GetEditWin().SetInputContext( aCntxt );

        }

        // Show Mail Merge toolbar initially for documents with Database fields

        if (!m_bInitOnceCompleted && GetWrtShell().IsAnyDatabaseFieldInDoc() && !comphelper::IsFuzzing())

            ShowUIElement(u"private:resource/toolbar/mailmerge"_ustr);

        // Activate the toolbar to the new selection which also was active last time.

        // Before a flush () must be, but does not affect the UI according to MBA and

        // is not a performance problem.

        // TODO/LATER: maybe now the Flush() command is superfluous?!

        rDispatcher.Flush();

        Point aPnt = GetEditWin().OutputToScreenPixel(GetEditWin().GetPointerPosPixel());

        aPnt = GetEditWin().PixelToLogic(aPnt);

        GetEditWin().UpdatePointer(aPnt);

        SdrView* pDView = GetWrtShell().GetDrawView();

        if ( bInitFormShell && pDView )

            m_pFormShell->SetView(dynamic_cast<FmFormView*>( pDView) );

    }

    // Opportune time for the communication with OLE objects?

    if ( GetDocShell()->GetDoc()->IsOLEPrtNotifyPending() )

        GetDocShell()->GetDoc()->PrtOLENotify( false );

    // now the table-update

    if(bUpdateTable)

        m_pWrtShell->UpdateTable();

    GetViewImpl()->GetUNOObject_Impl()->NotifySelChanged();

    m_bInitOnceCompleted = true;

}

// Interaction: AttrChangedNotify() and TimeoutHdl.

// No Update if actions are still open, since the cursor on the core side

// can be somewhere in no man's land.

// But since we can no longer supply status and we want instead lock

// the dispatcher.

IMPL_LINK_NOARG(SwView, AttrChangedNotify, LinkParamNone*, void)

{

    if ( GetEditWin().IsChainMode() )

        GetEditWin().SetChainMode( false );

    if (!m_pWrtShell || !GetDocShell())

    {

        return;

    }

    //Opt: Not if PaintLocked. During unlock a notify will be once more triggered.

    if( !m_pWrtShell->IsPaintLocked() && !g_bNoInterrupt &&

        GetDocShell()->IsReadOnly() )

        CheckReadonlyState();

    if( !m_pWrtShell->IsPaintLocked() && !g_bNoInterrupt )

        CheckReadonlySelection();

    if( !m_bAttrChgNotified )

    {

        if (m_pWrtShell->ActionPend() || g_bNoInterrupt ||

             GetDispatcher().IsLocked() ||               //do not confuse the SFX

             GetViewFrame().GetBindings().IsInUpdate() )//do not confuse the SFX

        {

            m_bAttrChgNotified = true;

            m_aTimer.Start();

            const SfxBoolItem *pItem =

                GetObjectShell()->GetMedium()->GetItemSet().

                                    GetItemIfSet( SID_HIDDEN, false );

            if ( !pItem || !pItem->GetValue() )

            {

                GetViewFrame().GetBindings().ENTERREGISTRATIONS();

                m_bAttrChgNotifiedWithRegistrations = true;

            }

        }

        else

            SelectShell();

    }

    // change ui if cursor is at a SwPostItField

    if (m_pPostItMgr)

    {

        // only perform the code that is needed to determine, if at the

        // actual cursor position is a post-it field

        m_pPostItMgr->SetShadowState( m_pWrtShell->GetPostItFieldAtCursor() );

    }

}

IMPL_LINK_NOARG(SwView, TimeoutHdl, Timer *, void)

{

    if (m_pWrtShell->ActionPend() || g_bNoInterrupt)

    {

        m_aTimer.Start();

        return;

    }

    if ( m_bAttrChgNotifiedWithRegistrations )

    {

        GetViewFrame().GetBindings().LEAVEREGISTRATIONS();

        m_bAttrChgNotifiedWithRegistrations = false;

    }

    CheckReadonlyState();

    CheckReadonlySelection();

    bool bOldUndo = m_pWrtShell->DoesUndo();

    m_pWrtShell->DoUndo( false );

    SelectShell();

    m_pWrtShell->DoUndo( bOldUndo );

    m_bAttrChgNotified = false;

    GetViewImpl()->GetUNOObject_Impl()->NotifySelChanged();

}

void SwView::CheckReadonlyState()

{

    SfxDispatcher &rDis = GetDispatcher();

    // To be able to recognize if it is already disabled!

    SfxItemState eStateRO, eStateProtAll;

    SfxPoolItemHolder aResult;

    // Query the status from a slot which is only known to us.

    // Otherwise the slot is known from other; like the BasicIde

    eStateRO = rDis.QueryState(FN_INSERT_BOOKMARK, aResult);

    eStateProtAll = rDis.QueryState(FN_EDIT_REGION, aResult);

    bool bChgd = false;

    if ( !m_pWrtShell->IsCursorReadonly() )

    {

        static constexpr sal_uInt16 aROIds[] =

        {

            SID_PASTE_SPECIAL, SID_PASTE_UNFORMATTED, SID_CHARMAP_CONTROL,

            SID_REDO, SID_UNDO, SID_REPEAT,

            SID_PASTE, SID_DELETE, SID_ATTR_CHAR_FONT,

            SID_ATTR_CHAR_POSTURE, SID_ATTR_CHAR_WEIGHT, SID_ATTR_CHAR_SHADOWED,

            SID_ATTR_CHAR_WORDLINEMODE, SID_ATTR_CHAR_CONTOUR, SID_ATTR_CHAR_STRIKEOUT,

            SID_ATTR_CHAR_UNDERLINE, SID_ATTR_CHAR_FONTHEIGHT, SID_ATTR_CHAR_COLOR,

            SID_ATTR_CHAR_KERNING, SID_ATTR_CHAR_CASEMAP, SID_ATTR_CHAR_LANGUAGE,

            SID_ATTR_CHAR_ESCAPEMENT, SID_ATTR_PARA_ADJUST, SID_ATTR_PARA_ADJUST_LEFT,

            SID_ATTR_PARA_ADJUST_RIGHT, SID_ATTR_PARA_ADJUST_CENTER, SID_ATTR_PARA_ADJUST_BLOCK,

            SID_ATTR_PARA_LINESPACE, SID_ATTR_PARA_LINESPACE_10, SID_ATTR_PARA_LINESPACE_15,

            SID_ATTR_PARA_LINESPACE_20, SID_ATTR_PARA_SPLIT, SID_ATTR_PARA_ORPHANS,

            SID_ATTR_PARA_WIDOWS, SID_ATTR_PARA_MODEL, SID_ATTR_PARA_KEEP,

            SID_ATTR_CHAR_AUTOKERN, SID_BACKGROUND_COLOR, SID_CHAR_DLG,

            SID_PARA_DLG, SID_ATTR_FLASH, SID_DEC_INDENT,

            SID_INC_INDENT, SID_ATTR_CHAR_COLOR_EXT, SID_ATTR_CHAR_COLOR_BACKGROUND,

            SID_ATTR_CHAR_COLOR_BACKGROUND_EXT, SID_CHARMAP, FN_SVX_SET_NUMBER,

            FN_SVX_SET_BULLET, FN_SVX_SET_OUTLINE, SID_ATTR_CHAR_BACK_COLOR,

            SID_ULINE_VAL_SINGLE, SID_ULINE_VAL_DOUBLE, SID_ULINE_VAL_DOTTED,

            SID_ATTR_CHAR_OVERLINE, SID_ATTR_PARA_ADJUST_START, SID_ATTR_PARA_ADJUST_END,

            SID_AUTOSPELL_CHECK, SID_SBA_BRW_INSERT,

            FN_NUM_BULLET_ON, FN_NUM_NUMBERING_ON, FN_SELECT_PARA,

            FN_INSERT_BOOKMARK, FN_INSERT_BREAK, FN_INSERT_BREAK_DLG,

            FN_INSERT_COLUMN_BREAK, FN_INSERT_LINEBREAK, FN_INSERT_CONTENT_CONTROL,

            FN_INSERT_CHECKBOX_CONTENT_CONTROL, FN_INSERT_DROPDOWN_CONTENT_CONTROL, FN_INSERT_PICTURE_CONTENT_CONTROL,

            FN_INSERT_DATE_CONTENT_CONTROL, FN_INSERT_PLAIN_TEXT_CONTENT_CONTROL, FN_POSTIT,

            FN_INSERT_TABLE, FN_INSERT_COMBO_BOX_CONTENT_CONTROL, FN_INSERT_SOFT_HYPHEN,

            FN_INSERT_HARD_SPACE, FN_INSERT_NNBSP, FN_INSERT_HARDHYPHEN,

            FN_GROW_FONT_SIZE, FN_SHRINK_FONT_SIZE, FN_SET_SUPER_SCRIPT,

            FN_SET_SUB_SCRIPT, FN_FORMAT_DROPCAPS, FN_FORMAT_TABLE_DLG,

            FN_FORMAT_RESET, FN_CALCULATE, FN_EXPAND_GLOSSARY,

            FN_BACKSPACE, FN_DELETE_SENT, FN_DELETE_BACK_SENT,

            FN_DELETE_WORD, FN_DELETE_BACK_WORD, FN_DELETE_LINE,

            FN_DELETE_BACK_LINE, FN_DELETE_PARA, FN_DELETE_BACK_PARA,

            FN_DELETE_WHOLE_LINE, FN_SHIFT_BACKSPACE, FN_TXTATR_INET,

            FN_JAVAEDIT, FN_PASTE_NESTED_TABLE, FN_TABLE_PASTE_ROW_BEFORE,

            FN_TABLE_PASTE_COL_BEFORE, FN_SPELL_GRAMMAR_DIALOG };

        static_assert(std::is_sorted(std::begin(aROIds), std::end(aROIds)));

        if ( SfxItemState::DISABLED == eStateRO )

        {

            if (m_pWrtShell->GetViewOptions()->IsReadonly())

                ShowUIElement(u"private:resource/toolbar/drawtextobjectbar"_ustr);

            rDis.SetSlotFilter( SfxSlotFilterState::ENABLED_READONLY, aROIds );

            bChgd = true;

        }

    }

    else if( m_pWrtShell->IsAllProtect() )

    {

        if ( SfxItemState::DISABLED == eStateProtAll )

        {

            static constexpr sal_uInt16 aAllProtIds[] = { SID_SAVEDOC, FN_EDIT_REGION };

            static_assert(std::is_sorted(std::begin(aAllProtIds), std::end(aAllProtIds)));

            rDis.SetSlotFilter( SfxSlotFilterState::ENABLED_READONLY, aAllProtIds );

            bChgd = true;

        }

    }

    else if ( SfxItemState::DISABLED != eStateRO ||

                SfxItemState::DISABLED != eStateProtAll )

    {

        if (m_pWrtShell->GetViewOptions()->IsReadonly())

            HideUIElement(u"private:resource/toolbar/drawtextobjectbar"_ustr);

        bChgd = true;

        rDis.SetSlotFilter();

    }

    if ( bChgd )

        GetViewFrame().GetBindings().InvalidateAll(true);

}

void SwView::CheckReadonlySelection()

{

    SfxDisableFlags nDisableFlags = SfxDisableFlags::NONE;

    SfxDispatcher &rDis = GetDispatcher();

    if( m_pWrtShell->HasReadonlySel() &&

        ( !m_pWrtShell->GetDrawView() ||

            !m_pWrtShell->GetDrawView()->GetMarkedObjectList().GetMarkCount() ))

        nDisableFlags |= SfxDisableFlags::SwOnProtectedCursor;

    if( (SfxDisableFlags::SwOnProtectedCursor & nDisableFlags ) !=

        (SfxDisableFlags::SwOnProtectedCursor & rDis.GetDisableFlags() ) )

    {

        // Additionally move at the Window the InputContext, so that

        // in japanese / chinese versions the external input will be

        // turned on or off. This but only if the correct shell is on

        // the stack.

        switch( m_pViewImpl->GetShellMode() )

        {

        case ShellMode::Text:

        case ShellMode::ListText:

        case ShellMode::TableText:

        case ShellMode::TableListText:

            {

// Temporary solution!!! Should set the font of the current insertion point

//         at each cursor movement, so outside of this "if". But TH does not

//         evaluates the font at this time and the "purchase" appears to me

//         as too expensive.

//         Moreover, we don't have a font, but only attributes from which the

//         text formatting and the correct font will be build together.

                InputContext aCntxt( GetEditWin().GetInputContext() );

                aCntxt.SetOptions( SfxDisableFlags::SwOnProtectedCursor & nDisableFlags

                                    ? (aCntxt.GetOptions() & ~

                                            InputContextFlags( InputContextFlags::Text |

                                                InputContextFlags::ExtText ))

                                    : (aCntxt.GetOptions() |

                                            ( InputContextFlags::Text |

                                                InputContextFlags::ExtText )) );

                GetEditWin().SetInputContext( aCntxt );

            }

            break;

        default:

            ;

        }

    }

    if( nDisableFlags != rDis.GetDisableFlags() )

    {

        rDis.SetDisableFlags( nDisableFlags );

        GetViewFrame().GetBindings().InvalidateAll( true );

    }

}

SwView::SwView(SfxViewFrame& _rFrame, SfxViewShell* pOldSh)

    : SfxViewShell(_rFrame, SWVIEWFLAGS),

    m_aTimer( "sw::SwView m_aTimer" ),

    m_nNewPage(USHRT_MAX),

    m_nOldPageNum(0),

    m_pNumRuleNodeFromDoc(nullptr),

    m_pEditWin( VclPtr<SwEditWin>::Create( &_rFrame.GetWindow(), *this ) ),

    m_pShell(nullptr),

    m_pFormShell(nullptr),

    m_pHScrollbar(nullptr),

    m_pVScrollbar(nullptr),

    m_pLastTableFormat(nullptr),

    m_pLastFlyFormat(nullptr),

    m_pFormatClipboard(new SwFormatClipboard()),

    m_nSelectionType( SelectionType::All ),

    m_nPageCnt(0),

    m_nDrawSfxId( USHRT_MAX ),

    m_nFormSfxId( USHRT_MAX ),

    m_eFormObjKind(SdrObjKind::NONE),

    m_nLastPasteDestination( static_cast<SotExchangeDest>(0xFFFF) ),

    m_nLeftBorderDistance( 0 ),

    m_nRightBorderDistance( 0 ),

    m_eLastSearchCommand( static_cast<SvxSearchCmd>(0xFFFF) ),

    m_bWheelScrollInProgress(false),

    m_bCenterCursor(false),

    m_bTopCursor(false),

    m_bTabColFromDoc(false),

    m_bTabRowFromDoc(false),

    m_bSetTabColFromDoc(false),

    m_bSetTabRowFromDoc(false),

    m_bAttrChgNotified(false),

    m_bAttrChgNotifiedWithRegistrations(false),

    m_bVerbsActive(false),

    m_bDrawRotate(false),

    m_bDrawSelMode(true),

    m_bShowAtResize(true),

    m_bInOuterResizePixel(false),

    m_bInInnerResizePixel(false),

    m_bPasteState(false),

    m_bPasteSpecialState(false),

    m_bInMailMerge(false),

    m_bInDtor(false),

    m_bOldShellWasPagePreview(false),

    m_bIsPreviewDoubleClick(false),

    m_bMakeSelectionVisible(false),

    m_bForceChangesToolbar(true),

    m_nLOKPageUpDownOffset(0),

    m_aBringToAttentionBlinkTimer("SwView m_aBringToAttentionBlinkTimer"),

    m_nBringToAttentionBlinkTimeOutsRemaining(0)

{

    static bool bRequestDoubleBuffering = getenv("VCL_DOUBLEBUFFERING_ENABLE");

    if (bRequestDoubleBuffering)

        m_pEditWin->RequestDoubleBuffering(true);

    // According to discussion with MBA and further

    // investigations, no old SfxViewShell will be set as parameter <pOldSh>,

    // if function "New Window" is performed to open an additional view beside

    // an already existing one.

    // If the view is switch from one to another, the 'old' view is given by

    // parameter <pOldSh>.

    bDocSzUpdated = true;

    static bool bFuzzing = comphelper::IsFuzzing();

    if (!bFuzzing)

    {

        CreateScrollbar( true );

        CreateScrollbar( false );

    }

    m_pViewImpl.reset(new SwView_Impl(this));

    SetName(u"View"_ustr);

    SetWindow( m_pEditWin );

    m_aTimer.SetTimeout( 120 );

    SwDocShell& rDocSh = dynamic_cast<SwDocShell&>(*_rFrame.GetObjectShell());

    bool bOldModifyFlag = rDocSh.IsEnableSetModified();

    if (bOldModifyFlag)

        rDocSh.EnableSetModified( false );

    // HACK: SwDocShell has some cached font info, VCL informs about font updates,

    // but loading of docs with embedded fonts happens after SwDocShell is created

    // but before SwEditWin (which handles the VCL event) is created. So update

    // manually.

    if (rDocSh.GetDoc()->getIDocumentSettingAccess().get( DocumentSettingId::EMBED_FONTS ))

        rDocSh.UpdateFontList();

    bool bWebDShell = dynamic_cast<const SwWebDocShell*>(&rDocSh) !=  nullptr;

    const SwMasterUsrPref* pUsrPref = SwModule::get()->GetUsrPref(bWebDShell);

    SwViewOption aUsrPref( *pUsrPref);

    //! get lingu options without loading lingu DLL

    SvtLinguOptions aLinguOpt;

    SvtLinguConfig().GetOptions( aLinguOpt );

    aUsrPref.SetOnlineSpell( aLinguOpt.bIsSpellAuto );

    // Inherit the per-view setting from the per-document one.

    aUsrPref.SetRedlineRecordingOn(rDocSh.GetDoc()->getIDocumentRedlineAccess().IsRedlineOn());

    bool bOldShellWasSrcView = false;

    // determine if there is an existing view for

    // document

    SfxViewShell* pExistingSh = nullptr;

    if ( pOldSh )

    {

        pExistingSh = pOldSh;

        // determine type of existing view

        if (SwPagePreview* pPagePreview = dynamic_cast<SwPagePreview *>(pExistingSh))

        {

            m_sSwViewData = pPagePreview->GetPrevSwViewData();

            m_sNewCursorPos = pPagePreview->GetNewCursorPos();

            m_nNewPage = pPagePreview->GetNewPage();

            m_bOldShellWasPagePreview = true;

            m_bIsPreviewDoubleClick = !m_sNewCursorPos.isEmpty() || m_nNewPage != USHRT_MAX;

        }

        else if (dynamic_cast<const SwSrcView *>(pExistingSh) != nullptr)

            bOldShellWasSrcView = true;

    }

    SAL_INFO( "sw.ui", "before create WrtShell" );

    if (SwView *pView = dynamic_cast<SwView*>(pExistingSh))

    {

        m_pWrtShell.reset(new SwWrtShell(*pView->m_pWrtShell, m_pEditWin, *this));

    }

    else if (SwWrtShell *pWrtShell = dynamic_cast<SwWrtShell*>(rDocSh.GetDoc()->getIDocumentLayoutAccess().GetCurrentViewShell()))

    {

        m_pWrtShell.reset(new SwWrtShell(*pWrtShell, m_pEditWin, *this));

    }

    else

    {

        SwDoc& rDoc = *rDocSh.GetDoc();

        if( !bOldShellWasSrcView && bWebDShell && !m_bOldShellWasPagePreview )

            aUsrPref.setBrowseMode( true );

        else

            aUsrPref.setBrowseMode( rDoc.getIDocumentSettingAccess().get(DocumentSettingId::BROWSE_MODE) );

        //For the BrowseMode we do not assume a factor.

        if( aUsrPref.getBrowseMode() && aUsrPref.GetZoomType() != SvxZoomType::PERCENT )

        {

            aUsrPref.SetZoomType( SvxZoomType::PERCENT );

            aUsrPref.SetZoom( 100 );

        }

        else if (rDocSh.IsPreview())

        {

            aUsrPref.SetZoomType( SvxZoomType::WHOLEPAGE );

            aUsrPref.SetViewLayoutBookMode( false );

            aUsrPref.SetViewLayoutColumns( 1 );

        }

        else if (!pUsrPref->IsDefaultZoom())

        {

            aUsrPref.SetZoomType(pUsrPref->GetDefaultZoomType());

            aUsrPref.SetZoom(pUsrPref->GetDefaultZoomValue());

        }

        m_pWrtShell.reset(new SwWrtShell(rDoc, m_pEditWin, *this, &aUsrPref));

        // creating an SwView from a SwPagePreview needs to

        // add the SwViewShell to the ring of the other SwViewShell(s)

        if(m_bOldShellWasPagePreview)

        {

            SwViewShell& rPreviewViewShell = *static_cast<SwPagePreview*>(pExistingSh)->GetViewShell();

            m_pWrtShell->MoveTo(&rPreviewViewShell);

            // to update the field command et.al. if necessary

            const SwViewOption* pPreviewOpt = rPreviewViewShell.GetViewOptions();

            if( pPreviewOpt->IsFieldName() != aUsrPref.IsFieldName() ||

                    pPreviewOpt->IsShowHiddenField() != aUsrPref.IsShowHiddenField() ||

                    pPreviewOpt->IsShowHiddenPara() != aUsrPref.IsShowHiddenPara() ||

                    pPreviewOpt->IsShowHiddenChar() != aUsrPref.IsShowHiddenChar() )

                rPreviewViewShell.ApplyViewOptions(aUsrPref);

            // reset design mode at draw view for form

            // shell, if needed.

            if ( static_cast<SwPagePreview*>(pExistingSh)->ResetFormDesignMode() &&

                 m_pWrtShell->HasDrawView() )

            {

                SdrView* pDrawView = m_pWrtShell->GetDrawView();

                pDrawView->SetDesignMode( static_cast<SwPagePreview*>(pExistingSh)->FormDesignModeToReset() );

            }