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

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

1 files changed, 1634 insertions, 0 deletions

diff --git a/sd/source/ui/view/viewshel.cxx b/sd/source/ui/view/viewshel.cxx
new file mode 100644
index 000000000..866b79461
--- /dev/null
+++ b/sd/source/ui/view/viewshel.cxx
@@ -0,0 +1,1634 @@
+/* -*- 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 <ViewShell.hxx>
+#include <ViewShellImplementation.hxx>
+#include <createtableobjectbar.hxx>
+
+#include <ViewShellBase.hxx>
+#include <ShellFactory.hxx>
+#include <DrawController.hxx>
+#include <LayerTabBar.hxx>
+
+#include <sal/log.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <sfx2/bindings.hxx>
+#include <sfx2/dispatch.hxx>
+#include <vcl/commandevent.hxx>
+#include <vcl/scrbar.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 <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 <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 <svl/itempool.hxx>
+#include <svl/intitem.hxx>
+#include <svl/poolitem.hxx>
+#include <strings.hxx>
+#include <sdmod.hxx>
+#include <AccessibleDocumentViewBase.hxx>
+
+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 {
+
+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)
+,   mpParentWindow(pParentWindow)
+{
+    construct();
+}
+
+ViewShell::~ViewShell()
+{
+    // Keep the content window from accessing in its destructor the
+    // WindowUpdater.
+    if (mpContentWindow)
+        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();
+    }
+
+    mpScrollBarBox.disposeAndClear();
+    mpVerticalRuler.disposeAndClear();
+    mpHorizontalRuler.disposeAndClear();
+    mpVerticalScrollBar.disposeAndClear();
+    mpHorizontalScrollBar.disposeAndClear();
+}
+
+/**
+ * common initialization part of both constructors
+ */
+void ViewShell::construct()
+{
+    mbHasRulers = false;
+    mpActiveWindow = nullptr;
+    mpView = nullptr;
+    mpFrameView = nullptr;
+    mpZoomList = nullptr;
+    mbStartShowWithDialog = false;
+    mnPrintedHandoutPageNum = 1;
+    mnPrintedHandoutPageCount = 0;
+    mpWindowUpdater.reset( new ::sd::WindowUpdater() );
+    mpImpl.reset(new Implementation(*this));
+    meShellType = ST_NONE;
+
+    OSL_ASSERT (GetViewShell()!=nullptr);
+
+    if (IsMainViewShell())
+        GetDocSh()->Connect (this);
+
+    mpZoomList.reset( new ZoomList( this ) );
+
+    mpContentWindow.reset(VclPtr< ::sd::Window >::Create(GetParentWindow()));
+    SetActiveWindow (mpContentWindow.get());
+
+    GetParentWindow()->SetBackground (Wallpaper());
+    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<ScrollBar>::Create(GetParentWindow(), WinBits(WB_HSCROLL | WB_DRAG)));
+        mpHorizontalScrollBar->EnableRTL (false);
+        mpHorizontalScrollBar->SetRange(Range(0, 32000));
+        mpHorizontalScrollBar->SetScrollHdl(LINK(this, ViewShell, HScrollHdl));
+
+        mpVerticalScrollBar.reset (VclPtr<ScrollBar>::Create(GetParentWindow(), WinBits(WB_VSCROLL | WB_DRAG)));
+        mpVerticalScrollBar->SetRange(Range(0, 32000));
+        mpVerticalScrollBar->SetScrollHdl(LINK(this, ViewShell, VScrollHdl));
+
+        mpScrollBarBox.reset(VclPtr<ScrollBarBox>::Create(GetParentWindow(), WB_SIZEABLE));
+    }
+
+    SetName ("ViewShell");
+
+    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);
+}
+
+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());
+
+        mpScrollBarBox->Show();
+    }
+
+    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)
+            GetDispatcher()->ExecuteList(
+                SID_NAVIGATOR_INIT,
+                SfxCallMode::ASYNCHRON | SfxCallMode::RECORD,
+                { &aItem });
+
+        SfxViewShell* pViewShell = GetViewShell();
+        OSL_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())
+        {
+            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 = SD_MOD()->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() )
+            xSlideShow->deactivate();
+
+        if(HasCurrentFunction())
+            GetCurrentFunction()->Deactivate();
+    }
+
+    if (mpHorizontalRuler)
+        mpHorizontalRuler->SetActive(false);
+    if (mpVerticalRuler)
+        mpVerticalRuler->SetActive(false);
+
+    SfxShell::Deactivate(bIsMDIActivate);
+}
+
+void ViewShell::Shutdown()
+{
+    Exit ();
+}
+
+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);
+
+    const size_t OriCount = GetView()->GetMarkedObjectList().GetMarkCount();
+    if(!bReturn)
+    {
+        rtl::Reference< SlideShow > xSlideShow( SlideShow::GetSlideShow( GetViewShellBase() ) );
+        if(xSlideShow.is() && xSlideShow->isRunning())
+        {
+            bReturn = xSlideShow->keyInput(rKEvt);
+        }
+        else
+        {
+            bool bConsumed = false;
+            if( GetView() )
+                bConsumed = GetView()->getSmartTags().KeyInput(rKEvt);
+
+            if( !bConsumed )
+            {
+                rtl::Reference< sdr::SelectionController > xSelectionController( GetView()->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 = GetView()->GetMarkedObjectList().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);
+    }
+
+    // insert MouseEvent into E3dView
+    if (GetView() != nullptr)
+        GetView()->SetMouseEvent(rMEvt);
+
+    bool bConsumed = false;
+    if( GetView() )
+        bConsumed = GetView()->getSmartTags().MouseButtonDown( rMEvt );
+
+    if( bConsumed )
+        return;
+
+    rtl::Reference< sdr::SelectionController > xSelectionController( GetView()->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::GetSelectionTransferrable() 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() == MouseNotifyEvent::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::Swipe:
+            {
+                rtl::Reference< SlideShow > xSlideShow( SlideShow::GetSlideShow( GetViewShellBase() ) );
+                if (xSlideShow.is())
+                {
+                    const CommandSwipeData* pSwipeData = rCEvt.GetSwipeData();
+                    bDone = xSlideShow->swipe(*pSwipeData);
+                }
+            }
+            break;
+        case CommandEventId::LongPress:
+            {
+                rtl::Reference< SlideShow > xSlideShow( SlideShow::GetSlideShow( GetViewShellBase() ) );
+                if (xSlideShow.is())
+                {
+                    const CommandLongPressData* pLongPressData = rCEvt.GetLongPressData();
+                    bDone = xSlideShow->longpress(*pLongPressData);
+                }
+            }
+            break;
+
+        case CommandEventId::Wheel:
+            {
+                Reference< XSlideShowController > xSlideShowController( SlideShow::GetSlideShowController(GetViewShellBase() ) );
+                if( xSlideShowController.is() )
+                {
+                    // 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)
+            {
+                if (pData->IsMod1())
+                {
+                    if( !GetDocSh()->IsUIActive() )
+                    {
+                        const ::tools::Long  nOldZoom = GetActiveWindow()->GetZoom();
+                        ::tools::Long        nNewZoom;
+                        Point aOldMousePos = GetActiveWindow()->PixelToLogic(rCEvt.GetMousePosPixel());
+
+                        if( pData->GetDelta() < 0 )
+                            nNewZoom = std::max<::tools::Long>( pWin->GetMinZoom(), basegfx::zoomtools::zoomOut( nOldZoom ));
+                        else
+                            nNewZoom = std::min<::tools::Long>( 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 )
+                    {
+                        sal_uLong nScrollLines = pData->GetScrollLines();
+                        if(IsPageFlipMode())
+                            nScrollLines = COMMAND_WHEEL_PAGESCROLL;
+                        CommandWheelData aWheelData( pData->GetDelta(),pData->GetNotchDelta(),
+                            nScrollLines,pData->GetMode(),pData->GetModifier(),pData->IsHorz() );
+                        CommandEvent aReWrite( rCEvt.GetMousePosPixel(),rCEvt.GetCommand(),
+                            rCEvt.IsMouseEvent(),static_cast<const void *>(&aWheelData) );
+                        bDone = pWin->HandleScrollCommand( aReWrite,
+                            mpHorizontalScrollBar.get(),
+                            mpVerticalScrollBar.get());
+                    }
+                }
+            }
+        }
+        break;
+
+        default:
+        break;
+    }
+
+    return bDone;
+}
+
+void ViewShell::SetupRulers()
+{
+    if(!mbHasRulers || !mpContentWindow || SlideShow::IsRunning(GetViewShellBase()))
+        return;
+
+    ::tools::Long nHRulerOfs = 0;
+
+    if ( !mpVerticalRuler )
+    {
+        mpVerticalRuler.reset(CreateVRuler(GetActiveWindow()));
+        if ( mpVerticalRuler )
+        {
+            nHRulerOfs = mpVerticalRuler->GetSizePixel().Width();
+            mpVerticalRuler->SetActive();
+            mpVerticalRuler->Show();
+        }
+    }
+    if ( !mpHorizontalRuler )
+    {
+        mpHorizontalRuler.reset(CreateHRuler(GetActiveWindow()));
+        if ( mpHorizontalRuler )
+        {
+            mpHorizontalRuler->SetWinPos(nHRulerOfs);
+            mpHorizontalRuler->SetActive();
+            mpHorizontalRuler->Show();
+        }
+    }
+}
+
+const SvxNumBulletItem* ViewShell::GetNumBulletItem(SfxItemSet& aNewAttr, TypedWhichId<SvxNumBulletItem>& nNumItemId)
+{
+    const SvxNumBulletItem* pTmpItem = aNewAttr.GetItemIfSet(nNumItemId, false);
+    if(pTmpItem)
+        return pTmpItem;
+
+    nNumItemId = aNewAttr.GetPool()->GetWhich(SID_ATTR_NUMBERING_RULE);
+    pTmpItem = aNewAttr.GetItemIfSet(nNumItemId, false);
+    if(pTmpItem)
+        return pTmpItem;
+
+    bool bOutliner = false;
+    bool bTitle = false;
+
+    if( mpView )
+    {
+        const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
+        const size_t nCount = rMarkList.GetMarkCount();
+
+        for(size_t nNum = 0; nNum < nCount; ++nNum)
+        {
+            SdrObject* pObj = rMarkList.GetMark(nNum)->GetMarkedSdrObj();
+            if( pObj->GetObjInventor() == SdrInventor::Default )
+            {
+                switch(pObj->GetObjIdentifier())
+                {
+                case SdrObjKind::TitleText:
+                    bTitle = true;
+                    break;
+                case SdrObjKind::OutlineText:
+                    bOutliner = true;
+                    break;
+                default:
+                    break;
+                }
+            }
+        }
+    }
+
+    const SvxNumBulletItem *pItem = nullptr;
+    if(bOutliner)
+    {
+        SfxStyleSheetBasePool* pSSPool = mpView->GetDocSh()->GetStyleSheetPool();
+        SfxStyleSheetBase* pFirstStyleSheet = pSSPool->Find( STR_LAYOUT_OUTLINE + " 1", SfxStyleFamily::Pseudo);
+        if( pFirstStyleSheet )
+            pItem = pFirstStyleSheet->GetItemSet().GetItemIfSet(EE_PARA_NUMBULLET, false);
+    }
+
+    if( pItem == nullptr )
+        pItem = aNewAttr.GetPool()->GetSecondaryPool()->GetPoolDefaultItem(EE_PARA_NUMBULLET);
+
+    aNewAttr.Put(pItem->CloneSetWhich(EE_PARA_NUMBULLET));
+
+    if(bTitle && aNewAttr.GetItemState(EE_PARA_NUMBULLET) == SfxItemState::SET )
+    {
+        const SvxNumBulletItem* pBulletItem = aNewAttr.GetItem(EE_PARA_NUMBULLET);
+        const SvxNumRule& rRule = pBulletItem->GetNumRule();
+        SvxNumRule aNewRule( rRule );
+        aNewRule.SetFeatureFlag( SvxNumRuleFlags::NO_NUMBERS );
+
+        SvxNumBulletItem aNewItem( std::move(aNewRule), EE_PARA_NUMBULLET );
+        aNewAttr.Put(aNewItem);
+    }
+
+    pTmpItem = aNewAttr.GetItemIfSet(nNumItemId, false);
+
+    return pTmpItem;
+}
+
+void ViewShell::Resize()
+{
+    SetupRulers ();
+
+    if (mpParentWindow == nullptr)
+        return;
+
+    // Make sure that the new size is not degenerate.
+    const Size aSize (mpParentWindow->GetSizePixel());
+    if (aSize.IsEmpty())
+        return;
+
+    // Remember the new position and size.
+    maViewPos = Point(0,0);
+    maViewSize = aSize;
+
+    // Rearrange the UI elements to take care of the new position and size.
+    ArrangeGUIElements ();
+    // end of included AdjustPosSizePixel.
+
+    ::sd::View* pView = GetView();
+
+    if (pView)
+        pView->VisAreaChanged(GetActiveWindow()->GetOutDev());
+}
+
+SvBorder ViewShell::GetBorder()
+{
+    SvBorder aBorder;
+
+    // Horizontal scrollbar.
+    if (mpHorizontalScrollBar
+        && mpHorizontalScrollBar->IsVisible())
+    {
+        aBorder.Bottom() = maScrBarWH.Height();
+    }
+
+    // Vertical scrollbar.
+    if (mpVerticalScrollBar
+        && mpVerticalScrollBar->IsVisible())
+    {
+        aBorder.Right() = maScrBarWH.Width();
+    }
+
+    // Place horizontal ruler below tab bar.
+    if (mbHasRulers && mpContentWindow)
+    {
+        SetupRulers();
+        if (mpHorizontalRuler)
+            aBorder.Top() = mpHorizontalRuler->GetSizePixel().Height();
+        if (mpVerticalRuler)
+            aBorder.Left() = mpVerticalRuler->GetSizePixel().Width();
+    }
+
+    return aBorder;
+}
+
+void ViewShell::ArrangeGUIElements()
+{
+    if (mpImpl->mbArrangeActive)
+        return;
+    if (maViewSize.IsEmpty())
+        return;
+    mpImpl->mbArrangeActive = true;
+
+    // Calculate border for in-place editing.
+    ::tools::Long nLeft = maViewPos.X();
+    ::tools::Long nTop  = maViewPos.Y();
+    ::tools::Long nRight = maViewPos.X() + maViewSize.Width();
+    ::tools::Long nBottom = maViewPos.Y() + maViewSize.Height();
+
+    // Horizontal scrollbar.
+    if (mpHorizontalScrollBar
+        && mpHorizontalScrollBar->IsVisible())
+    {
+        nBottom -= maScrBarWH.Height();
+        if (mpLayerTabBar && mpLayerTabBar->IsVisible())
+            nBottom -= mpLayerTabBar->GetSizePixel().Height();
+        mpHorizontalScrollBar->SetPosSizePixel (
+            Point(nLeft, nBottom),
+            Size(nRight - nLeft - maScrBarWH.Width(), maScrBarWH.Height()));
+    }
+
+    // Vertical scrollbar.
+    if (mpVerticalScrollBar
+        && mpVerticalScrollBar->IsVisible())
+    {
+        nRight -= maScrBarWH.Width();
+        mpVerticalScrollBar->SetPosSizePixel (
+            Point(nRight,nTop),
+            Size (maScrBarWH.Width(), nBottom-nTop));
+    }
+
+    // Filler in the lower right corner.
+    if (mpScrollBarBox)
+    {
+        if (mpHorizontalScrollBar
+            && mpHorizontalScrollBar->IsVisible()
+            && mpVerticalScrollBar
+            && mpVerticalScrollBar->IsVisible())
+        {
+            mpScrollBarBox->Show();
+            mpScrollBarBox->SetPosSizePixel(Point(nRight, nBottom), maScrBarWH);
+        }
+        else
+            mpScrollBarBox->Hide();
+    }
+
+    // Place horizontal ruler below tab bar.
+    if (mbHasRulers && mpContentWindow)
+    {
+        if (mpHorizontalRuler)
+        {
+            Size aRulerSize = mpHorizontalRuler->GetSizePixel();
+            aRulerSize.setWidth( nRight - nLeft );
+            mpHorizontalRuler->SetPosSizePixel (
+                Point(nLeft,nTop), aRulerSize);
+            if (mpVerticalRuler)
+                mpHorizontalRuler->SetBorderPos(
+                    mpVerticalRuler->GetSizePixel().Width()-1);
+            nTop += aRulerSize.Height();
+        }
+        if (mpVerticalRuler)
+        {
+            Size aRulerSize = mpVerticalRuler->GetSizePixel();
+            aRulerSize.setHeight( nBottom  - nTop );
+            mpVerticalRuler->SetPosSizePixel (
+                Point (nLeft,nTop), aRulerSize);
+            nLeft += aRulerSize.Width();
+        }
+    }
+
+    rtl::Reference< SlideShow > xSlideShow( SlideShow::GetSlideShow( GetViewShellBase() ) );
+
+    // The size of the window of the center pane is set differently from
+    // that of the windows in the docking windows.
+    bool bSlideShowActive = (xSlideShow.is() && xSlideShow->isRunning()) && !xSlideShow->isFullScreen() && xSlideShow->getAnimationMode() == ANIMATIONMODE_SHOW;
+    if ( !bSlideShowActive)
+    {
+        OSL_ASSERT (GetViewShell()!=nullptr);
+
+        if (mpContentWindow)
+            mpContentWindow->SetPosSizePixel(
+                Point(nLeft,nTop),
+                Size(nRight-nLeft,nBottom-nTop));
+    }
+
+    // Windows in the center and rulers at the left and top side.
+    maAllWindowRectangle = ::tools::Rectangle(
+        maViewPos,
+        Size(maViewSize.Width()-maScrBarWH.Width(),
+            maViewSize.Height()-maScrBarWH.Height()));
+
+    if (mpContentWindow)
+        mpContentWindow->UpdateMapOrigin();
+
+    UpdateScrollBars();
+
+    mpImpl->mbArrangeActive = false;
+}
+
+void ViewShell::SetUIUnit(FieldUnit eUnit)
+{
+    // Set unit at horizontal and vertical rulers.
+    if (mpHorizontalRuler)
+        mpHorizontalRuler->SetUnit(eUnit);
+
+    if (mpVerticalRuler)
+        mpVerticalRuler->SetUnit(eUnit);
+}
+
+/**
+ * set DefTab at horizontal rulers
+ */
+void ViewShell::SetDefTabHRuler( sal_uInt16 nDefTab )
+{
+    if (mpHorizontalRuler)
+        mpHorizontalRuler->SetDefTabDist( nDefTab );
+}
+
+/** Tell the FmFormShell that the view shell is closing.  Give it the
+    opportunity to prevent that.
+*/
+bool ViewShell::PrepareClose (bool bUI)
+{
+    bool bResult = true;
+
+    FmFormShell* pFormShell = GetViewShellBase().GetFormShellManager()->GetFormShell();
+    if (pFormShell != nullptr)
+        bResult = pFormShell->PrepareClose (bUI);
+
+    return bResult;
+}
+
+void ViewShell::UpdatePreview (SdPage*)
+{
+    // Do nothing.  After the actual preview has been removed,
+    // OutlineViewShell::UpdatePreview() is the place where something
+    // useful is still done.
+}
+
+SfxUndoManager* ViewShell::ImpGetUndoManager() const
+{
+    const ViewShell* pMainViewShell = GetViewShellBase().GetMainViewShell().get();
+
+    if( pMainViewShell == nullptr )
+        pMainViewShell = this;
+
+    ::sd::View* pView = pMainViewShell->GetView();
+
+    // check for text edit our outline view
+    if( pView )
+    {
+        if( pMainViewShell->GetShellType() == ViewShell::ST_OUTLINE )
+        {
+            OutlineView* pOlView = dynamic_cast< OutlineView* >( pView );
+            if( pOlView )
+            {
+                ::Outliner& rOutl = pOlView->GetOutliner();
+                return &rOutl.GetUndoManager();
+            }
+        }
+        else if( pView->IsTextEdit() )
+        {
+            SdrOutliner* pOL = pView->GetTextEditOutliner();
+            if( pOL )
+                return &pOL->GetUndoManager();
+        }
+    }
+
+    if( GetDocSh() )
+        return GetDocSh()->GetUndoManager();
+
+    return nullptr;
+}
+
+void ViewShell::ImpGetUndoStrings(SfxItemSet &rSet) const
+{
+    SfxUndoManager* pUndoManager = ImpGetUndoManager();
+    if(!pUndoManager)
+        return;
+
+    sal_uInt16 nCount(pUndoManager->GetUndoActionCount());
+    if(nCount)
+    {
+        // prepare list
+        std::vector<OUString> aStringList;
+        aStringList.reserve(nCount);
+        for (sal_uInt16 a = 0; a < nCount; ++a)
+        {
+            // generate one String in list per undo step
+            aStringList.push_back( pUndoManager->GetUndoActionComment(a) );
+        }
+
+        // set item
+        rSet.Put(SfxStringListItem(SID_GETUNDOSTRINGS, &aStringList));
+    }
+    else
+    {
+        rSet.DisableItem(SID_GETUNDOSTRINGS);
+    }
+}
+
+void ViewShell::ImpGetRedoStrings(SfxItemSet &rSet) const
+{
+    SfxUndoManager* pUndoManager = ImpGetUndoManager();
+    if(!pUndoManager)
+        return;
+
+    sal_uInt16 nCount(pUndoManager->GetRedoActionCount());
+    if(nCount)
+    {
+        // prepare list
+        ::std::vector< OUString > aStringList;
+        aStringList.reserve(nCount);
+        for(sal_uInt16 a = 0; a < nCount; a++)
+            // generate one String in list per undo step
+            aStringList.push_back( pUndoManager->GetRedoActionComment(a) );
+
+        // set item
+        rSet.Put(SfxStringListItem(SID_GETREDOSTRINGS, &aStringList));
+    }
+    else
+    {
+        rSet.DisableItem(SID_GETREDOSTRINGS);
+    }
+}
+
+namespace {
+
+class KeepSlideSorterInSyncWithPageChanges
+{
+    sd::slidesorter::view::SlideSorterView::DrawLock m_aDrawLock;
+    sd::slidesorter::controller::SlideSorterController::ModelChangeLock m_aModelLock;
+    sd::slidesorter::controller::PageSelector::UpdateLock m_aUpdateLock;
+    sd::slidesorter::controller::SelectionObserver::Context m_aContext;
+
+public:
+    explicit KeepSlideSorterInSyncWithPageChanges(sd::slidesorter::SlideSorter const & rSlideSorter)
+        : m_aDrawLock(rSlideSorter)
+        , m_aModelLock(rSlideSorter.GetController())
+        , m_aUpdateLock(rSlideSorter)
+        , m_aContext(rSlideSorter)
+    {
+    }
+};
+
+}
+
+void ViewShell::ImpSidUndo(SfxRequest& rReq)
+{
+    //The xWatcher keeps the SlideSorter selection in sync
+    //with the page insertions/deletions that Undo may introduce
+    std::unique_ptr<KeepSlideSorterInSyncWithPageChanges, o3tl::default_delete<KeepSlideSorterInSyncWithPageChanges>> xWatcher;
+    slidesorter::SlideSorterViewShell* pSlideSorterViewShell
+        = slidesorter::SlideSorterViewShell::GetSlideSorter(GetViewShellBase());
+    if (pSlideSorterViewShell)
+        xWatcher.reset(new KeepSlideSorterInSyncWithPageChanges(pSlideSorterViewShell->GetSlideSorter()));
+
+    SfxUndoManager* pUndoManager = ImpGetUndoManager();
+    sal_uInt16 nNumber(1);
+    const SfxItemSet* pReqArgs = rReq.GetArgs();
+    bool bRepair = false;
+
+    if(pReqArgs)
+    {
+        const SfxUInt16Item* pUIntItem = static_cast<const SfxUInt16Item*>(&pReqArgs->Get(SID_UNDO));
+        nNumber = pUIntItem->GetValue();
+
+        // Repair mode: allow undo/redo of all undo actions, even if access would
+        // be limited based on the view shell ID.
+        if (const SfxBoolItem* pRepairItem = pReqArgs->GetItemIfSet(SID_REPAIRPACKAGE, false))
+            bRepair = pRepairItem->GetValue();
+    }
+
+    if(nNumber && pUndoManager)
+    {
+        sal_uInt16 nCount(pUndoManager->GetUndoActionCount());
+        if(nCount >= nNumber)
+        {
+            if (comphelper::LibreOfficeKit::isActive() && !bRepair)
+            {
+                // If another view created the first undo action, prevent redoing it from this view.
+                const SfxUndoAction* pAction = pUndoManager->GetUndoAction();
+                if (pAction->GetViewShellId() != GetViewShellBase().GetViewShellId())
+                {
+                    rReq.SetReturnValue(SfxUInt32Item(SID_UNDO, static_cast<sal_uInt32>(SID_REPAIRPACKAGE)));
+                    return;
+                }
+            }
+
+            try
+            {
+                // when UndoStack is cleared by ModifyPageUndoAction
+                // the nCount may have changed, so test GetUndoActionCount()
+                while(nNumber-- && pUndoManager->GetUndoActionCount())
+                    pUndoManager->Undo();
+            }
+            catch( const Exception& )
+            {
+                // no need to handle. By definition, the UndoManager handled this by clearing the
+                // Undo/Redo stacks
+            }
+        }
+
+        // refresh rulers, maybe UNDO was move of TAB marker in ruler
+        if (mbHasRulers)
+            Invalidate(SID_ATTR_TABSTOP);
+    }
+
+    // This one is corresponding to the default handling
+    // of SID_UNDO in sfx2
+    GetViewFrame()->GetBindings().InvalidateAll(false);
+
+    rReq.Done();
+}
+
+void ViewShell::ImpSidRedo(SfxRequest& rReq)
+{
+    //The xWatcher keeps the SlideSorter selection in sync
+    //with the page insertions/deletions that Undo may introduce
+    std::unique_ptr<KeepSlideSorterInSyncWithPageChanges, o3tl::default_delete<KeepSlideSorterInSyncWithPageChanges>> xWatcher;
+    slidesorter::SlideSorterViewShell* pSlideSorterViewShell
+        = slidesorter::SlideSorterViewShell::GetSlideSorter(GetViewShellBase());
+    if (pSlideSorterViewShell)
+        xWatcher.reset(new KeepSlideSorterInSyncWithPageChanges(pSlideSorterViewShell->GetSlideSorter()));
+
+    SfxUndoManager* pUndoManager = ImpGetUndoManager();
+    sal_uInt16 nNumber(1);
+    const SfxItemSet* pReqArgs = rReq.GetArgs();
+    bool bRepair = false;
+
+    if(pReqArgs)
+    {
+        const SfxUInt16Item* pUIntItem = static_cast<const SfxUInt16Item*>(&pReqArgs->Get(SID_REDO));
+        nNumber = pUIntItem->GetValue();
+        // Repair mode: allow undo/redo of all undo actions, even if access would
+        // be limited based on the view shell ID.
+        if (const SfxBoolItem* pRepairItem = pReqArgs->GetItemIfSet(SID_REPAIRPACKAGE, false))
+            bRepair = pRepairItem->GetValue();
+    }
+
+    if(nNumber && pUndoManager)
+    {
+        sal_uInt16 nCount(pUndoManager->GetRedoActionCount());
+        if(nCount >= nNumber)
+        {
+            if (comphelper::LibreOfficeKit::isActive() && !bRepair)
+            {
+                // If another view created the first undo action, prevent redoing it from this view.
+                const SfxUndoAction* pAction = pUndoManager->GetRedoAction();
+                if (pAction->GetViewShellId() != GetViewShellBase().GetViewShellId())
+                {
+                    rReq.SetReturnValue(SfxUInt32Item(SID_REDO, static_cast<sal_uInt32>(SID_REPAIRPACKAGE)));
+                    return;
+                }
+            }
+
+            try
+            {
+                // when UndoStack is cleared by ModifyPageRedoAction
+                // the nCount may have changed, so test GetRedoActionCount()
+                while(nNumber-- && pUndoManager->GetRedoActionCount())
+                    pUndoManager->Redo();
+            }
+            catch( const Exception& )
+            {
+                // no need to handle. By definition, the UndoManager handled this by clearing the
+                // Undo/Redo stacks
+            }
+        }
+
+        // refresh rulers, maybe REDO was move of TAB marker in ruler
+        if (mbHasRulers)
+        {
+            Invalidate(SID_ATTR_TABSTOP);
+        }
+    }
+
+    // This one is corresponding to the default handling
+    // of SID_UNDO in sfx2
+    GetViewFrame()->GetBindings().InvalidateAll(false);
+
+    rReq.Done();
+}
+
+void ViewShell::ExecReq( SfxRequest& rReq )
+{
+    sal_uInt16 nSlot = rReq.GetSlot();
+    switch( nSlot )
+    {
+        case SID_MAIL_SCROLLBODY_PAGEDOWN:
+        {
+            rtl::Reference<FuPoor> xFunc( GetCurrentFunction() );
+            if( xFunc.is() )
+                ScrollLines( 0, -1 );
+
+            rReq.Done();
+        }
+        break;
+
+        case SID_OUTPUT_QUALITY_COLOR:
+        case SID_OUTPUT_QUALITY_GRAYSCALE:
+        case SID_OUTPUT_QUALITY_BLACKWHITE:
+        case SID_OUTPUT_QUALITY_CONTRAST:
+        {
+            DrawModeFlags nMode = OUTPUT_DRAWMODE_COLOR;
+
+            switch( nSlot )
+            {
+                case SID_OUTPUT_QUALITY_COLOR: nMode = OUTPUT_DRAWMODE_COLOR; break;
+                case SID_OUTPUT_QUALITY_GRAYSCALE: nMode = OUTPUT_DRAWMODE_GRAYSCALE; break;
+                case SID_OUTPUT_QUALITY_BLACKWHITE: nMode = OUTPUT_DRAWMODE_BLACKWHITE; break;
+                case SID_OUTPUT_QUALITY_CONTRAST: nMode = OUTPUT_DRAWMODE_CONTRAST; break;
+            }
+
+            GetActiveWindow()->GetOutDev()->SetDrawMode( nMode );
+            mpFrameView->SetDrawMode( nMode );
+
+            GetActiveWindow()->Invalidate();
+
+            Invalidate();
+            rReq.Done();
+            break;
+        }
+    }
+}
+
+/** This default implementation returns only an empty reference.  See derived
+    classes for more interesting examples.
+*/
+css::uno::Reference<css::accessibility::XAccessible>
+ViewShell::CreateAccessibleDocumentView (::sd::Window* )
+{
+    OSL_FAIL("ViewShell::CreateAccessibleDocumentView should not be called!, perhaps Meyers, 3rd edition, Item 9:");
+
+    return css::uno::Reference<css::accessibility::XAccessible> ();
+}
+
+::sd::WindowUpdater* ViewShell::GetWindowUpdater() const
+{
+    return mpWindowUpdater.get();
+}
+
+ViewShellBase& ViewShell::GetViewShellBase() const
+{
+    return *static_cast<ViewShellBase*>(GetViewShell());
+}
+
+ViewShell::ShellType ViewShell::GetShellType() const
+{
+    return meShellType;
+}
+
+DrawDocShell* ViewShell::GetDocSh() const
+{
+    return GetViewShellBase().GetDocShell();
+}
+
+SdDrawDocument* ViewShell::GetDoc() const
+{
+    return GetViewShellBase().GetDocument();
+}
+
+ErrCode ViewShell::DoVerb(sal_Int32 /*nVerb*/)
+{
+    return ERRCODE_NONE;
+}
+
+void ViewShell::SetCurrentFunction( const rtl::Reference<FuPoor>& xFunction)
+{
+    if( mxCurrentFunction.is() && (mxOldFunction != mxCurrentFunction) )
+        mxCurrentFunction->Dispose();
+    rtl::Reference<FuPoor> xDisposeAfterNewOne( mxCurrentFunction );
+    mxCurrentFunction = xFunction;
+}
+
+void ViewShell::SetOldFunction(const rtl::Reference<FuPoor>& xFunction)
+{
+    if( mxOldFunction.is() && (xFunction != mxOldFunction) && (mxCurrentFunction != mxOldFunction) )
+        mxOldFunction->Dispose();
+
+    rtl::Reference<FuPoor> xDisposeAfterNewOne( mxOldFunction );
+    mxOldFunction = xFunction;
+}
+
+/** this method deactivates the current function. If an old function is
+    saved, this will become activated and current function.
+*/
+void ViewShell::Cancel()
+{
+    if(mxCurrentFunction.is() && (mxCurrentFunction != mxOldFunction ))
+    {
+        rtl::Reference<FuPoor> xTemp( mxCurrentFunction );
+        mxCurrentFunction.clear();
+        xTemp->Deactivate();
+        xTemp->Dispose();
+    }
+
+    if(mxOldFunction.is())
+    {
+        mxCurrentFunction = mxOldFunction;
+        mxCurrentFunction->Activate();
+    }
+}
+
+void ViewShell::DeactivateCurrentFunction( bool bPermanent /* == false */ )
+{
+    if( mxCurrentFunction.is() )
+    {
+        if(bPermanent && (mxOldFunction == mxCurrentFunction))
+            mxOldFunction.clear();
+
+        mxCurrentFunction->Deactivate();
+        if( mxCurrentFunction != mxOldFunction )
+            mxCurrentFunction->Dispose();
+
+        rtl::Reference<FuPoor> xDisposeAfterNewOne( mxCurrentFunction );
+        mxCurrentFunction.clear();
+    }
+}
+
+void ViewShell::DisposeFunctions()
+{
+    if(mxCurrentFunction.is())
+    {
+        rtl::Reference<FuPoor> xTemp( mxCurrentFunction );
+        mxCurrentFunction.clear();
+        xTemp->Deactivate();
+        xTemp->Dispose();
+    }
+
+    if(mxOldFunction.is())
+    {
+        rtl::Reference<FuPoor> xDisposeAfterNewOne( mxOldFunction );
+        mxOldFunction->Dispose();
+        mxOldFunction.clear();
+    }
+}
+
+bool ViewShell::IsMainViewShell() const
+{
+    return mpImpl->mbIsMainViewShell;
+}
+
+void ViewShell::SetIsMainViewShell (bool bIsMainViewShell)
+{
+    if (bIsMainViewShell != mpImpl->mbIsMainViewShell)
+    {
+        mpImpl->mbIsMainViewShell = bIsMainViewShell;
+        if (bIsMainViewShell)
+            GetDocSh()->Connect (this);
+        else
+            GetDocSh()->Disconnect (this);
+    }
+}
+
+void ViewShell::PrePaint()
+{
+}
+
+void ViewShell::Paint (const ::tools::Rectangle&, ::sd::Window* )
+{
+}
+
+void ViewShell::ShowUIControls (bool bVisible)
+{
+    if (mbHasRulers)
+    {
+        if (mpHorizontalRuler)
+            mpHorizontalRuler->Show( bVisible );
+
+        if (mpVerticalRuler)
+            mpVerticalRuler->Show( bVisible );
+    }
+
+    if (mpVerticalScrollBar)
+        mpVerticalScrollBar->Show( bVisible );
+
+    if (mpHorizontalScrollBar)
+        mpHorizontalScrollBar->Show( bVisible );
+
+    if (mpScrollBarBox)
+        mpScrollBarBox->Show(bVisible);
+
+    if (mpContentWindow)
+        mpContentWindow->Show( bVisible );
+}
+
+bool ViewShell::RelocateToParentWindow (vcl::Window* pParentWindow)
+{
+    mpParentWindow = pParentWindow;
+
+    mpParentWindow->SetBackground (Wallpaper());
+
+    if (mpContentWindow)
+        mpContentWindow->SetParent(pParentWindow);
+
+    if (mpHorizontalScrollBar)
+        mpHorizontalScrollBar->SetParent(mpParentWindow);
+    if (mpVerticalScrollBar)
+        mpVerticalScrollBar->SetParent(mpParentWindow);
+    if (mpScrollBarBox)
+        mpScrollBarBox->SetParent(mpParentWindow);
+
+    return true;
+}
+
+void ViewShell::SwitchViewFireFocus(const css::uno::Reference< css::accessibility::XAccessible >& xAcc )
+{
+    if (xAcc)
+    {
+        ::accessibility::AccessibleDocumentViewBase* pBase = static_cast< ::accessibility::AccessibleDocumentViewBase* >(xAcc.get());
+        if (pBase)
+            pBase->SwitchViewActivated();
+    }
+}
+void ViewShell::SwitchActiveViewFireFocus()
+{
+    if (mpContentWindow)
+    {
+        SwitchViewFireFocus(mpContentWindow->GetAccessible(false));
+    }
+}
+// move these two methods from DrawViewShell.
+void ViewShell::fireSwitchCurrentPage(sal_Int32 pageIndex)
+{
+    GetViewShellBase().GetDrawController().fireSwitchCurrentPage(pageIndex);
+}
+void ViewShell::NotifyAccUpdate( )
+{
+    GetViewShellBase().GetDrawController().NotifyAccUpdate();
+}
+
+weld::Window* ViewShell::GetFrameWeld() const
+{
+    return mpActiveWindow ? mpActiveWindow->GetFrameWeld() : nullptr;
+}
+
+sd::Window* ViewShell::GetContentWindow() const
+{
+    return mpContentWindow.get();
+}
+
+} // end of namespace sd
+
+//===== ViewShellObjectBarFactory =============================================
+
+namespace {
+
+ViewShellObjectBarFactory::ViewShellObjectBarFactory (
+    ::sd::ViewShell& rViewShell)
+    : mrViewShell (rViewShell)
+{
+}
+
+SfxShell* ViewShellObjectBarFactory::CreateShell( ::sd::ShellId nId )
+{
+    SfxShell* pShell = nullptr;
+
+    ::sd::View* pView = mrViewShell.GetView();
+    switch (nId)
+    {
+        case ToolbarId::Bezier_Toolbox_Sd:
+            pShell = new ::sd::BezierObjectBar(&mrViewShell, pView);
+            break;
+
+        case ToolbarId::Draw_Text_Toolbox_Sd:
+            pShell = new ::sd::TextObjectBar(
+                &mrViewShell, mrViewShell.GetDoc()->GetPool(), pView);
+            break;
+
+        case ToolbarId::Draw_Graf_Toolbox:
+            pShell = new ::sd::GraphicObjectBar(&mrViewShell, pView);
+            break;
+
+        case ToolbarId::Draw_Media_Toolbox:
+            pShell = new ::sd::MediaObjectBar(&mrViewShell, pView);
+            break;
+
+        case ToolbarId::Draw_Table_Toolbox:
+            pShell = ::sd::ui::table::CreateTableObjectBar( mrViewShell, pView );
+            break;
+
+        case ToolbarId::Svx_Extrusion_Bar:
+            pShell = new svx::ExtrusionBar(
+                &mrViewShell.GetViewShellBase());
+            break;
+
+         case ToolbarId::Svx_Fontwork_Bar:
+            pShell = new svx::FontworkBar(
+                &mrViewShell.GetViewShellBase());
+            break;
+
+        default:
+            pShell = nullptr;
+            break;
+    }
+
+    return pShell;
+}
+
+void ViewShellObjectBarFactory::ReleaseShell (SfxShell* pShell)
+{
+    delete pShell;
+}
+
+} // end of anonymous namespace
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */