diff options
Diffstat (limited to '')
| -rw-r--r-- | sd/source/ui/view/viewshel.cxx | 1659 |
1 files changed, 1659 insertions, 0 deletions
diff --git a/sd/source/ui/view/viewshel.cxx b/sd/source/ui/view/viewshel.cxx new file mode 100644 index 0000000000..09c1f95102 --- /dev/null +++ b/sd/source/ui/view/viewshel.cxx @@ -0,0 +1,1659 @@ +/* -*- 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 <Outliner.hxx> + +#include <sal/log.hxx> +#include <sfx2/viewfrm.hxx> +#include <sfx2/bindings.hxx> +#include <sfx2/dispatch.hxx> +#include <vcl/commandevent.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 <editeng/editund2.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) + 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(); +} + +/** + * common initialization part of both constructors + */ +void ViewShell::construct() +{ + mbHasRulers = false; + mpActiveWindow = nullptr; + mpView = nullptr; + mpFrameView = nullptr; + mpZoomList = nullptr; + mfLastZoomScale = 0; + 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(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 ("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()); + } + + 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::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: + { + rtl::Reference< SlideShow > xSlideShow( SlideShow::GetSlideShow( GetViewShellBase() ) ); + if (xSlideShow.is()) + { + const CommandGestureSwipeData* pSwipeData = rCEvt.GetGestureSwipeData(); + bDone = xSlideShow->swipe(*pSwipeData); + } + } + break; + case CommandEventId::GestureLongPress: + { + rtl::Reference< SlideShow > xSlideShow( SlideShow::GetSlideShow( GetViewShellBase() ) ); + if (xSlideShow.is()) + { + const CommandGestureLongPressData* 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 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; + 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; + + case CommandEventId::GestureZoom: + { + const CommandGestureZoomData* pData = rCEvt.GetGestureZoomData(); + + Reference<XSlideShowController> xSlideShowController(SlideShow::GetSlideShowController(GetViewShellBase())); + + if (pData->meEventType == GestureEventZoomType::Begin) + { + mfLastZoomScale = pData->mfScaleDelta; + bDone = true; + break; + } + + if (pData->meEventType == GestureEventZoomType::Update) + { + double deltaBetweenEvents = (pData->mfScaleDelta - mfLastZoomScale) / mfLastZoomScale; + mfLastZoomScale = pData->mfScaleDelta; + + if (!GetDocSh()->IsUIActive() && !xSlideShowController.is()) + { + const ::tools::Long nOldZoom = GetActiveWindow()->GetZoom(); + ::tools::Long nNewZoom; + Point aOldMousePos = GetActiveWindow()->PixelToLogic(rCEvt.GetMousePosPixel()); + + // Accumulate fractional zoom to avoid small zoom changes from being ignored + mfAccumulatedZoom += deltaBetweenEvents; + int nZoomChangePercent = mfAccumulatedZoom * 100; + mfAccumulatedZoom -= nZoomChangePercent / 100.0; + + nNewZoom = nOldZoom + nZoomChangePercent; + nNewZoom = std::max<::tools::Long>(pWin->GetMinZoom(), nNewZoom); + nNewZoom = std::min<::tools::Long>(pWin->GetMaxZoom(), nNewZoom); + + 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; + } + 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)); + } + + // 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 (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); + + 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: */ |