/* -*- 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 <framework/FrameworkHelper.hxx>

#include <framework/ViewShellWrapper.hxx>

#include <framework/ConfigurationController.hxx>

#include <memory>

#include <ViewShell.hxx>

#include <ViewShellImplementation.hxx>

#include <createtableobjectbar.hxx>

#include <ViewShellBase.hxx>

#include <ShellFactory.hxx>

#include <DrawController.hxx>

#include <LayerTabBar.hxx>

#include <Outliner.hxx>

#include <ResourceId.hxx>

#include <sal/log.hxx>

#include <sfx2/viewfrm.hxx>

#include <sfx2/bindings.hxx>

#include <sfx2/dispatch.hxx>

#include <vcl/commandevent.hxx>

#include <vcl/svapp.hxx>

#include <svl/eitem.hxx>

#include <svx/ruler.hxx>

#include <svx/svxids.hrc>

#include <svx/fmshell.hxx>

#include <WindowUpdater.hxx>

#include <sdxfer.hxx>

#include <app.hrc>

#include <OutlineView.hxx>

#include <DrawViewShell.hxx>

#include <DrawDocShell.hxx>

#include <slideshow.hxx>

#include <drawdoc.hxx>

#include <sdpage.hxx>

#include <zoomlist.hxx>

#include <FrameView.hxx>

#include <BezierObjectBar.hxx>

#include <TextObjectBar.hxx>

#include <GraphicObjectBar.hxx>

#include <MediaObjectBar.hxx>

#include <SlideSorter.hxx>

#include <SlideSorterViewShell.hxx>

#include <ViewShellManager.hxx>

#include <FormShellManager.hxx>

#include <EventMultiplexer.hxx>

#include <svx/extrusionbar.hxx>

#include <svx/fontworkbar.hxx>

#include <svx/svdoutl.hxx>

#include <tools/svborder.hxx>

#include <comphelper/lok.hxx>

#include <svl/slstitm.hxx>

#include <sfx2/request.hxx>

#include <SpellDialogChildWindow.hxx>

#include <controller/SlideSorterController.hxx>

#include <controller/SlsPageSelector.hxx>

#include <controller/SlsSelectionObserver.hxx>

#include <view/SlideSorterView.hxx>

#include <basegfx/utils/zoomtools.hxx>

#include <officecfg/Office/Draw.hxx>

#include <Window.hxx>

#include <fupoor.hxx>

#include <futext.hxx>

#include <editeng/numitem.hxx>

#include <editeng/eeitem.hxx>

#include <editeng/editview.hxx>

#include <editeng/editeng.hxx>

#include <editeng/editund2.hxx>

#include <svl/itempool.hxx>

#include <svl/intitem.hxx>

#include <svl/poolitem.hxx>

#include <strings.hxx>

#include <sdmod.hxx>

#include <AccessibleDocumentViewBase.hxx>

#include <framework/Configuration.hxx>

#include <framework/AbstractView.hxx>

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

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

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

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

namespace {

class ViewShellObjectBarFactory

    : public ::sd::ShellFactory<SfxShell>

{

public:

    explicit ViewShellObjectBarFactory (::sd::ViewShell& rViewShell);

    virtual SfxShell* CreateShell( ::sd::ShellId nId ) override;

    virtual void ReleaseShell (SfxShell* pShell) override;

private:

    ::sd::ViewShell& mrViewShell;

};

} // end of anonymous namespace

namespace sd {

/// When true, scrolling to bottom of a page switches to the next page.

bool ViewShell::CanPanAcrossPages() const

{

    return dynamic_cast<const DrawViewShell*>(this) && mpContentWindow &&

        mpContentWindow->GetVisibleHeight() < 1.0;

}

bool ViewShell::IsPageFlipMode() const

{

    return dynamic_cast< const DrawViewShell *>( this ) !=  nullptr && mpContentWindow &&

        mpContentWindow->GetVisibleHeight() >= 1.0;

}

SfxViewFrame* ViewShell::GetViewFrame() const

{

    const SfxViewShell* pViewShell = GetViewShell();

    if (pViewShell != nullptr)

    {

        return &pViewShell->GetViewFrame();

    }

    else

    {

        OSL_ASSERT (GetViewShell()!=nullptr);

        return nullptr;

    }

}

/// declare SFX-Slotmap and standard interface

ViewShell::ViewShell( vcl::Window* pParentWindow, ViewShellBase& rViewShellBase)

    :   SfxShell(&rViewShellBase)

    ,   mbHasRulers(false)

    ,   mpActiveWindow(nullptr)

    ,   mpView(nullptr)

    ,   mpFrameView(nullptr)

    ,   mpZoomList(new ZoomList( *this ))

    ,   mfLastZoomScale(0)

    ,   mbStartShowWithDialog(false)

    ,   mnPrintedHandoutPageNum(1)

    ,   mnPrintedHandoutPageCount(0)

    ,   meShellType(ST_NONE)

    ,   mpImpl(new Implementation(*this))

    ,   mpParentWindow(pParentWindow)

    ,   mpWindowUpdater(new ::sd::WindowUpdater())

{

    OSL_ASSERT (GetViewShell()!=nullptr);

    if (IsMainViewShell())

        GetDocSh()->Connect (this);

    mpContentWindow.reset(VclPtr< ::sd::Window >::Create(GetParentWindow()));

    SetActiveWindow (mpContentWindow.get());

    GetParentWindow()->SetBackground(Application::GetSettings().GetStyleSettings().GetFaceColor());

    mpContentWindow->SetBackground (Wallpaper());

    mpContentWindow->SetCenterAllowed(true);

    mpContentWindow->SetViewShell(this);

    mpContentWindow->SetPosSizePixel(

        GetParentWindow()->GetPosPixel(),GetParentWindow()->GetSizePixel());

    if ( ! GetDocSh()->IsPreview())

    {

        // Create scroll bars and the filler between the scroll bars.

        mpHorizontalScrollBar.reset (VclPtr<ScrollAdaptor>::Create(GetParentWindow(), true));

        mpHorizontalScrollBar->EnableRTL (false);

        mpHorizontalScrollBar->SetRange(Range(0, 32000));

        mpHorizontalScrollBar->SetScrollHdl(LINK(this, ViewShell, HScrollHdl));

        mpVerticalScrollBar.reset (VclPtr<ScrollAdaptor>::Create(GetParentWindow(), false));

        mpVerticalScrollBar->SetRange(Range(0, 32000));

        mpVerticalScrollBar->SetScrollHdl(LINK(this, ViewShell, VScrollHdl));

    }

    SetName (u"ViewShell"_ustr);

    GetDoc()->StartOnlineSpelling(false);

    mpWindowUpdater->SetDocument (GetDoc());

    // Re-initialize the spell dialog.

    ::sd::SpellDialogChildWindow* pSpellDialog =

          static_cast< ::sd::SpellDialogChildWindow*> (

              GetViewFrame()->GetChildWindow (

                  ::sd::SpellDialogChildWindow::GetChildWindowId()));

    if (pSpellDialog != nullptr)

        pSpellDialog->InvalidateSpellDialog();

    // Register the sub shell factory.

    mpImpl->mpSubShellFactory = std::make_shared<ViewShellObjectBarFactory>(*this);

    GetViewShellBase().GetViewShellManager()->AddSubShellFactory(this,mpImpl->mpSubShellFactory);

    // Compare size of all pages to set SdDrawDocument's mbResizeAllPages after document load

    // instead of setting it true unconditionally.

    sal_uInt16 nPageCnt = GetDoc()->GetSdPageCount(PageKind::Standard);

    if (nPageCnt > 0)

    {

        Size aSize1 = GetDoc()->GetSdPage(0, PageKind::Standard)->GetSize();

        for (sal_uInt16 i = 1; i < nPageCnt; i++)

        {

            Size aSize2 = GetDoc()->GetSdPage(i, PageKind::Standard)->GetSize();

            if (aSize1 != aSize2)

                GetDoc()->SetResizeAllPages(false);

        }

    }

}

ViewShell::~ViewShell()

{

    // Keep the content window from accessing in its destructor the

    // WindowUpdater.

    if (mpContentWindow)

        suppress_fun_call_w_exception(mpContentWindow->SetViewShell(nullptr));

    mpZoomList.reset();

    mpLayerTabBar.disposeAndClear();

    if (mpImpl->mpSubShellFactory)

        GetViewShellBase().GetViewShellManager()->RemoveSubShellFactory(

            this,mpImpl->mpSubShellFactory);

    if (mpContentWindow)

    {

        SAL_INFO(

            "sd.view",

            "destroying mpContentWindow at " << mpContentWindow.get()

                << " with parent " << mpContentWindow->GetParent());

        mpContentWindow.disposeAndClear();

    }

    mpVerticalRuler.disposeAndClear();

    mpHorizontalRuler.disposeAndClear();

    mpVerticalScrollBar.disposeAndClear();

    mpHorizontalScrollBar.disposeAndClear();

}

void ViewShell::doShow()

{

    mpContentWindow->Show();

    static_cast< vcl::Window*>(mpContentWindow.get())->Resize();

    SAL_INFO(

        "sd.view",

        "content window has size " << mpContentWindow->GetSizePixel().Width()

            << " " << mpContentWindow->GetSizePixel().Height());

    if ( ! GetDocSh()->IsPreview())

    {

        // Show scroll bars

        mpHorizontalScrollBar->Show();

        mpVerticalScrollBar->Show();

        maScrBarWH = Size(

            mpVerticalScrollBar->GetSizePixel().Width(),

            mpHorizontalScrollBar->GetSizePixel().Height());

    }

    GetParentWindow()->Show();

}

void ViewShell::Init (bool bIsMainViewShell)

{

    mpImpl->mbIsInitialized = true;

    SetIsMainViewShell(bIsMainViewShell);

    if (bIsMainViewShell)

        SetActiveWindow (mpContentWindow.get());

}

void ViewShell::Exit()

{

    sd::View* pView = GetView();

    if (pView!=nullptr && pView->IsTextEdit())

    {

        pView->SdrEndTextEdit();

        pView->UnmarkAll();

    }

    Deactivate (true);

    if (IsMainViewShell())

        GetDocSh()->Disconnect(this);

    SetIsMainViewShell(false);

}

/**

 * set focus to working window

 */

void ViewShell::Activate(bool bIsMDIActivate)

{

    // Do not forward to SfxShell::Activate()

    /* According to MI, nobody is allowed to call GrabFocus, who does not

       exactly know from which window the focus is grabbed. Since Activate()

       is sent sometimes asynchronous,  it can happen, that the wrong window

       gets the focus. */

    if (mpHorizontalRuler)

        mpHorizontalRuler->SetActive();

    if (mpVerticalRuler)

        mpVerticalRuler->SetActive();

    if (bIsMDIActivate)

    {

        // thus, the Navigator will also get a current status

        SfxBoolItem aItem( SID_NAVIGATOR_INIT, true );

        if (GetDispatcher() != nullptr)

        {

            SfxCallMode nCall = SfxCallMode::RECORD;

            if (comphelper::LibreOfficeKit::isActive())

            {

                // Make sure the LOK case doesn't dispatch async events while switching views, that

                // would lead to a loop, see SfxHintPoster::DoEvent_Impl().

                nCall |= SfxCallMode::SYNCHRON;

            }

            else

            {

                nCall |= SfxCallMode::ASYNCHRON;

            }

            GetDispatcher()->ExecuteList(

                SID_NAVIGATOR_INIT,

                nCall,

                { &aItem });

        }

        SfxViewShell* pViewShell = GetViewShell();

        assert(pViewShell!=nullptr);

        SfxBindings& rBindings = pViewShell->GetViewFrame().GetBindings();

        rBindings.Invalidate( SID_3D_STATE, true );

        rtl::Reference< SlideShow > xSlideShow( SlideShow::GetSlideShow( GetViewShellBase() ) );

        if (xSlideShow.is() && xSlideShow->isRunning()) //IASS

        {

            bool bSuccess = xSlideShow->activate(GetViewShellBase());

            assert(bSuccess && "can only return false with a PresentationViewShell"); (void)bSuccess;

        }

        if(HasCurrentFunction())

            GetCurrentFunction()->Activate();

        if(!GetDocSh()->IsUIActive())

            UpdatePreview( GetActualPage() );

    }

    ReadFrameViewData( mpFrameView );

    if (IsMainViewShell())

        GetDocSh()->Connect(this);

}

void ViewShell::UIActivating( SfxInPlaceClient*  )

{

    OSL_ASSERT (GetViewShell()!=nullptr);

    GetViewShellBase().GetToolBarManager()->ToolBarsDestroyed();

}

void ViewShell::UIDeactivated( SfxInPlaceClient*  )

{

    OSL_ASSERT (GetViewShell()!=nullptr);

    GetViewShellBase().GetToolBarManager()->ToolBarsDestroyed();

    if ( GetDrawView() )

        GetViewShellBase().GetToolBarManager()->SelectionHasChanged(*this, *GetDrawView());

}

void ViewShell::Deactivate(bool bIsMDIActivate)

{

    // remove view from a still active drag'n'drop session

    SdTransferable* pDragTransferable = SdModule::get()->pTransferDrag;

    if (IsMainViewShell())

        GetDocSh()->Disconnect(this);

    if( pDragTransferable )

        pDragTransferable->SetView( nullptr );

    OSL_ASSERT (GetViewShell()!=nullptr);

    // remember view attributes of FrameView

    WriteFrameViewData();

    if (bIsMDIActivate)

    {

        rtl::Reference< SlideShow > xSlideShow( SlideShow::GetSlideShow( GetViewShellBase() ) );

        if(xSlideShow.is() && xSlideShow->isRunning() ) //IASS

            xSlideShow->deactivate();

        if(HasCurrentFunction())

            GetCurrentFunction()->Deactivate();

    }

    if (mpHorizontalRuler)

        mpHorizontalRuler->SetActive(false);

    if (mpVerticalRuler)

        mpVerticalRuler->SetActive(false);

    SfxShell::Deactivate(bIsMDIActivate);

}

void ViewShell::BroadcastContextForActivation(const bool bIsActivated)

{

    auto getFrameworkResourceIdForShell

        = [&]() -> rtl::Reference<framework::ResourceId> const

    {

        DrawController* pDrawController = GetViewShellBase().GetDrawController();

        if (!pDrawController)

            return {};

        rtl::Reference<sd::framework::ConfigurationController> xConfigurationController

            = pDrawController->getConfigurationController();

        if (!xConfigurationController.is())

            return {};

        rtl::Reference<framework::Configuration> xConfiguration

            = xConfigurationController->getCurrentConfiguration();

        if (!xConfiguration.is())

            return {};

        auto aResIdsIndirect

            = xConfiguration->getResources({}, u"", drawing::framework::AnchorBindingMode_INDIRECT);

        for (const rtl::Reference<framework::ResourceId>& rResId : aResIdsIndirect)

        {

            auto pFrameworkHelper = framework::FrameworkHelper::Instance(GetViewShellBase());

            rtl::Reference<sd::framework::AbstractView> xView;

            if (rResId->getResourceURL().match(framework::FrameworkHelper::msViewURLPrefix))

            {

                xView = dynamic_cast<sd::framework::AbstractView*>(xConfigurationController->getResource(rResId).get());

                if (xView.is())

                {

                    if (auto pViewShellWrapper = dynamic_cast<framework::ViewShellWrapper*>(xView.get()))

                    {

                        if (pViewShellWrapper->GetViewShell().get() == this)

                        {

                            return rResId;

                        }

                    }

                }

            }

        }

        return {};

    };

    if (bIsActivated)

    {

        GetViewShellBase().GetEventMultiplexer()->MultiplexEvent(

            EventMultiplexerEventId::FocusShifted, nullptr, getFrameworkResourceIdForShell());

    }

    if (GetDispatcher())

        SfxShell::BroadcastContextForActivation(bIsActivated);

}

void ViewShell::Shutdown()

{

    Exit ();

}

// IASS: Check if commands should be used for SlideShow

// This is the case when IASS is on, SlideShow is active

// and the SlideShow Window has the focus

bool ViewShell::useInputForSlideShow() const

{

    rtl::Reference< SlideShow > xSlideShow(SlideShow::GetSlideShow(GetViewShellBase()));

    if (!xSlideShow.is())

        // no SlideShow, do not use

        return false;

    if (!xSlideShow->isRunning())

        // SlideShow not running, do not use

        return false;

    if(!xSlideShow->IsInteractiveSlideshow())

        // if IASS is deactivated, do what was done before when

        // SlideSHow is running: use for SlideShow

        return true;

    // else, check if SlideShow Window has the focus

    OutputDevice* pShOut(xSlideShow->getShowWindow());

    vcl::Window* pShWin(pShOut ? pShOut->GetOwnerWindow() : nullptr);

    // return true if we got the SlideShow Window and it has the focus

    return nullptr != pShWin && pShWin->HasFocus();

}

bool ViewShell::KeyInput(const KeyEvent& rKEvt, ::sd::Window* pWin)

{

    bool bReturn(false);

    if(pWin)

        SetActiveWindow(pWin);

    // give key input first to SfxViewShell to give CTRL+Key

    // (e.g. CTRL+SHIFT+'+', to front) priority.

    OSL_ASSERT(GetViewShell() != nullptr);

    bReturn = GetViewShell()->KeyInput(rKEvt);

    if (sd::View* pView = GetView())

    {

        const SdrMarkList& rMarkList = pView->GetMarkedObjectList();

        const size_t OriCount = rMarkList.GetMarkCount();

        if(!bReturn)

        {

            if(useInputForSlideShow()) //IASS

            {

                // use for SlideShow

                rtl::Reference< SlideShow > xSlideShow( SlideShow::GetSlideShow( GetViewShellBase() ) );

                bReturn = xSlideShow->keyInput(rKEvt);

            }

            else

            {

                bool bConsumed = false;

                bConsumed = pView->getSmartTags().KeyInput(rKEvt);

                if( !bConsumed )

                {

                    rtl::Reference< sdr::SelectionController > xSelectionController( pView->getSelectionController() );

                    if( !xSelectionController.is() || !xSelectionController->onKeyInput( rKEvt, pWin ) )

                    {

                        if(HasCurrentFunction())

                            bReturn = GetCurrentFunction()->KeyInput(rKEvt);

                    }

                    else

                    {

                        bReturn = true;

                        if (HasCurrentFunction())

                        {

                            FuText* pTextFunction = dynamic_cast<FuText*>(GetCurrentFunction().get());

                            if(pTextFunction != nullptr)

                                pTextFunction->InvalidateBindings();

                        }

                    }

                }

            }

        }

        const size_t EndCount = rMarkList.GetMarkCount();

        // Here, oriCount or endCount must have one value=0, another value > 0, then to switch focus between Document and shape objects

        if(bReturn &&  (OriCount + EndCount > 0) && (OriCount * EndCount == 0))

            SwitchActiveViewFireFocus();

    }

    if(!bReturn && GetActiveWindow())

    {

        vcl::KeyCode aKeyCode = rKEvt.GetKeyCode();

        if (aKeyCode.IsMod1() && aKeyCode.IsShift()

            && aKeyCode.GetCode() == KEY_R)

        {

            InvalidateWindows();

            bReturn = true;

        }

    }

    return bReturn;

}

void ViewShell::MouseButtonDown(const MouseEvent& rMEvt, ::sd::Window* pWin)

{

    // We have to lock tool bar updates while the mouse button is pressed in

    // order to prevent the shape under the mouse to be moved (this happens

    // when the number of docked tool bars changes as result of a changed

    // selection;  this changes the window size and thus the mouse position

    // in model coordinates: with respect to model coordinates the mouse

    // moves.)

    OSL_ASSERT(mpImpl->mpUpdateLockForMouse.expired());

    mpImpl->mpUpdateLockForMouse = ViewShell::Implementation::ToolBarManagerLock::Create(

        GetViewShellBase().GetToolBarManager());

    if ( pWin && !pWin->HasFocus() )

    {

        pWin->GrabFocus();

        SetActiveWindow(pWin);

    }

    ::sd::View* pView = GetView();

    if (!pView)

        return;

    // insert MouseEvent into E3dView

    pView->SetMouseEvent(rMEvt);

    bool bConsumed = false;

    bConsumed = pView->getSmartTags().MouseButtonDown( rMEvt );

    if( bConsumed )

        return;

    rtl::Reference< sdr::SelectionController > xSelectionController( pView->getSelectionController() );

    if( !xSelectionController.is() || !xSelectionController->onMouseButtonDown( rMEvt, pWin ) )

    {

        if(HasCurrentFunction())

            GetCurrentFunction()->MouseButtonDown(rMEvt);

    }

    else

    {

        if (HasCurrentFunction())

        {

            FuText* pTextFunction = dynamic_cast<FuText*>(GetCurrentFunction().get());

            if (pTextFunction != nullptr)

                pTextFunction->InvalidateBindings();

        }

    }

}

void ViewShell::SetCursorMm100Position(const Point& rPosition, bool bPoint, bool bClearMark)

{

    if (SdrView* pSdrView = GetView())

    {

        rtl::Reference<sdr::SelectionController> xSelectionController(GetView()->getSelectionController());

        if (!xSelectionController.is() || !xSelectionController->setCursorLogicPosition(rPosition, bPoint))

        {

            if (pSdrView->GetTextEditObject())

            {

                EditView& rEditView = pSdrView->GetTextEditOutlinerView()->GetEditView();

                rEditView.SetCursorLogicPosition(rPosition, bPoint, bClearMark);

            }

        }

    }

}

uno::Reference<datatransfer::XTransferable> ViewShell::GetSelectionTransferable() const

{

    SdrView* pSdrView = GetView();

    if (!pSdrView)

        return uno::Reference<datatransfer::XTransferable>();

    if (!pSdrView->GetTextEditObject())

        return uno::Reference<datatransfer::XTransferable>();

    EditView& rEditView = pSdrView->GetTextEditOutlinerView()->GetEditView();

    return rEditView.getEditEngine().CreateTransferable(rEditView.GetSelection());

}

void ViewShell::SetGraphicMm100Position(bool bStart, const Point& rPosition)

{

    if (bStart)

    {

        MouseEvent aClickEvent(rPosition, 1, MouseEventModifiers::SIMPLECLICK, MOUSE_LEFT);

        MouseButtonDown(aClickEvent, mpActiveWindow);

        MouseEvent aMoveEvent(Point(rPosition.getX(), rPosition.getY()), 0, MouseEventModifiers::SIMPLEMOVE, MOUSE_LEFT);

        MouseMove(aMoveEvent, mpActiveWindow);

    }

    else

    {

        MouseEvent aMoveEvent(Point(rPosition.getX(), rPosition.getY()), 0, MouseEventModifiers::SIMPLEMOVE, MOUSE_LEFT);

        MouseMove(aMoveEvent, mpActiveWindow);

        MouseEvent aClickEvent(rPosition, 1, MouseEventModifiers::SIMPLECLICK, MOUSE_LEFT);

        MouseButtonUp(aClickEvent, mpActiveWindow);

    }

}

void ViewShell::MouseMove(const MouseEvent& rMEvt, ::sd::Window* pWin)

{

    if (rMEvt.IsLeaveWindow())

    {

        if ( ! mpImpl->mpUpdateLockForMouse.expired())

        {

            std::shared_ptr<ViewShell::Implementation::ToolBarManagerLock> pLock(

                mpImpl->mpUpdateLockForMouse);

            if (pLock != nullptr)

                pLock->Release();

        }

    }

    if ( pWin )

    {

        SetActiveWindow(pWin);

    }

    // insert MouseEvent into E3dView

    if (GetView() != nullptr)

        GetView()->SetMouseEvent(rMEvt);

    if(HasCurrentFunction())

    {

        rtl::Reference< sdr::SelectionController > xSelectionController( GetView()->getSelectionController() );

        if( !xSelectionController.is() || !xSelectionController->onMouseMove( rMEvt, pWin ) )

        {

            if(HasCurrentFunction())

                GetCurrentFunction()->MouseMove(rMEvt);

        }

    }

}

void ViewShell::MouseButtonUp(const MouseEvent& rMEvt, ::sd::Window* pWin)

{

    if ( pWin )

        SetActiveWindow(pWin);

    // insert MouseEvent into E3dView

    if (GetView() != nullptr)

        GetView()->SetMouseEvent(rMEvt);

    if( HasCurrentFunction())

    {

        rtl::Reference< sdr::SelectionController > xSelectionController( GetView()->getSelectionController() );

        if( !xSelectionController.is() || !xSelectionController->onMouseButtonUp( rMEvt, pWin ) )

        {

            if(HasCurrentFunction())

                GetCurrentFunction()->MouseButtonUp(rMEvt);

        }

        else

        {

            if (HasCurrentFunction())

            {

                FuText* pTextFunction = dynamic_cast<FuText*>(GetCurrentFunction().get());

                if (pTextFunction != nullptr)

                    pTextFunction->InvalidateBindings();

            }

        }

    }

    if ( ! mpImpl->mpUpdateLockForMouse.expired())

    {

        std::shared_ptr<ViewShell::Implementation::ToolBarManagerLock> pLock(

            mpImpl->mpUpdateLockForMouse);

        if (pLock != nullptr)

            pLock->Release();

    }

}

void ViewShell::Command(const CommandEvent& rCEvt, ::sd::Window* pWin)

{

    bool bDone = HandleScrollCommand (rCEvt, pWin);

    if( bDone )

        return;

    if( rCEvt.GetCommand() == CommandEventId::InputLanguageChange )

    {

        //#i42732# update state of fontname if input language changes

        GetViewFrame()->GetBindings().Invalidate( SID_ATTR_CHAR_FONT );

        GetViewFrame()->GetBindings().Invalidate( SID_ATTR_CHAR_FONTHEIGHT );

    }

    else

    {

        bool bConsumed = false;

        if( GetView() )

            bConsumed = GetView()->getSmartTags().Command(rCEvt);

        if( !bConsumed && HasCurrentFunction())

            GetCurrentFunction()->Command(rCEvt);

    }

}

bool ViewShell::Notify(NotifyEvent const & rNEvt, ::sd::Window* pWin)

{

    // handle scroll commands when they arrived at child windows

    bool bRet = false;

    if( rNEvt.GetType() == NotifyEventType::COMMAND )

    {

        // note: dynamic_cast is not possible as GetData() returns a void*

        CommandEvent* pCmdEvent = static_cast< CommandEvent* >(rNEvt.GetData());

        bRet = HandleScrollCommand(*pCmdEvent, pWin);

    }

    return bRet;

}

bool ViewShell::HandleScrollCommand(const CommandEvent& rCEvt, ::sd::Window* pWin)

{

    bool bDone = false;

    switch( rCEvt.GetCommand() )

    {

        case CommandEventId::GestureSwipe:

            {

                if(useInputForSlideShow()) //IASS

                {

                    // use for SlideShow

                    rtl::Reference< SlideShow > xSlideShow( SlideShow::GetSlideShow( GetViewShellBase() ) );

                    const CommandGestureSwipeData* pSwipeData = rCEvt.GetGestureSwipeData();

                    bDone = xSlideShow->swipe(*pSwipeData);

                }

            }

            break;

        case CommandEventId::GestureLongPress:

            {

                if(useInputForSlideShow()) //IASS

                {

                    // use for SlideShow

                    rtl::Reference< SlideShow > xSlideShow( SlideShow::GetSlideShow( GetViewShellBase() ) );

                    const CommandGestureLongPressData* pLongPressData = rCEvt.GetLongPressData();

                    bDone = xSlideShow->longpress(*pLongPressData);

                }

            }

            break;

        case CommandEventId::Wheel:

            {

                Reference< XSlideShowController > xSlideShowController( SlideShow::GetSlideShowController(GetViewShellBase() ) );

                if( xSlideShowController.is() )

                {

                    if(useInputForSlideShow()) //IASS

                    {

                        // use for SlideShow

                        // We ignore zooming with control+mouse wheel.

                        const CommandWheelData* pData = rCEvt.GetWheelData();

                        if( pData && !pData->GetModifier() && ( pData->GetMode() == CommandWheelMode::SCROLL ) && !pData->IsHorz() )

                        {

                            ::tools::Long nDelta = pData->GetDelta();

                            if( nDelta > 0 )

                                xSlideShowController->gotoPreviousSlide();

                            else if( nDelta < 0 )

                                xSlideShowController->gotoNextEffect();

                        }

                        break;

                    }

                }

            }

            [[fallthrough]];

        case CommandEventId::StartAutoScroll:

        case CommandEventId::AutoScroll:

        {

            const CommandWheelData* pData = rCEvt.GetWheelData();

            if (pData != nullptr)

            {

                const bool bZoomWithWheel = GetDoc() != nullptr

                    && GetDoc()->GetDocumentType() == DocumentType::Draw

                    && officecfg::Office::Draw::Layout::Display::ZoomWithMouseWheel::get();

                const bool bShouldZoom = pData->IsMod1() != bZoomWithWheel;

                if (bShouldZoom)

                {

                    if( !GetDocSh()->IsUIActive() )

                    {

                        const sal_uInt16  nOldZoom = GetActiveWindow()->GetZoom();

                        sal_uInt16        nNewZoom;

                        Point aOldMousePos = GetActiveWindow()->PixelToLogic(rCEvt.GetMousePosPixel());

                        if( pData->GetDelta() < 0 )

                            nNewZoom = std::max<sal_uInt16>( pWin->GetMinZoom(), basegfx::zoomtools::zoomOut( nOldZoom ));

                        else

                            nNewZoom = std::min<sal_uInt16>( pWin->GetMaxZoom(), basegfx::zoomtools::zoomIn( nOldZoom ));

                        SetZoom( nNewZoom );

                        // Keep mouse at same doc point before zoom

                        Point aNewMousePos = GetActiveWindow()->PixelToLogic(rCEvt.GetMousePosPixel());

                        SetWinViewPos(GetWinViewPos() - (aNewMousePos - aOldMousePos));

                        Invalidate( SID_ATTR_ZOOM );

                        Invalidate( SID_ATTR_ZOOMSLIDER );

                        bDone = true;

                    }

                }

                else

                {

                    if( mpContentWindow.get() == pWin )

                    {

                        double nScrollLines = pData->GetScrollLines();

                        if(IsPageFlipMode())

                            nScrollLines = COMMAND_WHEEL_PAGESCROLL;

                        const sal_uInt16 nScrollModifier

                            = bZoomWithWheel ? (pData->GetModifier() & ~KEY_MOD1)

                                             : pData->GetModifier();

                        constexpr CommandWheelMode eScrollMode = CommandWheelMode::SCROLL;

                        CommandWheelData aWheelData( pData->GetDelta(),pData->GetNotchDelta(),

                            nScrollLines,eScrollMode,nScrollModifier,pData->IsHorz() );

                        CommandEvent aReWrite( rCEvt.GetMousePosPixel(),rCEvt.GetCommand(),

                            rCEvt.IsMouseEvent(),static_cast<const void *>(&aWheelData) );

                        bDone = pWin->HandleScrollCommand( aReWrite,

                            mpHorizontalScrollBar.get(),

                            mpVerticalScrollBar.get());