DrawViewShell.hxx

Go to the documentation of this file.

/* -*- 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 .
 */
 
#pragma once
 
#include <memory>
#include "ViewShell.hxx"
#include "tools/AsynchronousCall.hxx"
#include "TabControl.hxx"
#include <glob.hxx>
#include <pres.hxx>
#include <unotools/caserotate.hxx>
#include <unotools/options.hxx>
#include <sddllapi.h>
#include <viewopt.hxx>
 
namespace svx::sidebar { class SelectionChangeHandler; }
namespace com::sun::star::lang { class XEventListener; }
namespace com::sun::star::scanner { class XScannerManager2; }
 
class Outliner;
class SdPage;
class SdStyleSheet;
class SdrExternalToolEdit;
class TabBar;
class SdrObject;
class SdrPageView;
class TransferableDataHelper;
class TransferableClipboardListener;
class AbstractSvxNameDialog;
class SdrLayer;
class SvxClipboardFormatItem;
struct ESelection;
class AbstractSvxObjectNameDialog;
 
namespace sd {
 
class DrawView;
class LayerTabBar;
class Ruler;
class AnnotationManager;
class ViewOverlayManager;
 
#define CHECK_RANGE(nMin, nValue, nMax) ((nValue >= nMin) && (nValue <= nMax))
 
class SAL_DLLPUBLIC_RTTI DrawViewShell
    : public ViewShell,
      public SfxListener,
      public utl::ConfigurationListener
{
public:
    SFX_DECL_INTERFACE(SD_IF_SDDRAWVIEWSHELL)
 
private:
    static void InitInterface_Impl();
 
public:
    DrawViewShell (
        ViewShellBase& rViewShellBase,
        vcl::Window* pParentWindow,
        PageKind ePageKind,
        FrameView* pFrameView);
 
    virtual ~DrawViewShell() override;
 
    virtual void Init (bool bIsMainViewShell) override;
 
    virtual void Shutdown() override;
 
    void PrePaint() override;
    virtual void Paint(const ::tools::Rectangle& rRect, ::sd::Window* pWin) override;
 
    virtual void    ArrangeGUIElements() override;
 
    void            HidePage();
 
    virtual bool    KeyInput(const KeyEvent& rKEvt, ::sd::Window* pWin) override;
    virtual void    MouseMove(const MouseEvent& rMEvt, ::sd::Window* pWin) override;
    virtual void    MouseButtonUp(const MouseEvent& rMEvt, ::sd::Window* pWin) override;
    virtual void    MouseButtonDown(const MouseEvent& rMEvt, ::sd::Window* pWin) override;
    virtual void    Command(const CommandEvent& rCEvt, ::sd::Window* pWin) override;
    bool            IsMouseButtonDown() const { return mbMouseButtonDown; }
    bool            IsMouseSelecting() const { return mbMouseSelecting; }
 
    virtual void    Resize() override;
 
    void            ShowMousePosInfo(const ::tools::Rectangle& rRect, ::sd::Window const * pWin);
 
    virtual void    ChangeEditMode (EditMode eMode, bool bIsLayerModeActive);
 
    virtual void    SetZoom( ::tools::Long nZoom ) override;
    virtual void    SetZoomRect( const ::tools::Rectangle& rZoomRect ) override;
 
    void            InsertURLField(const OUString& rURL, const OUString& rText, const OUString& rTarget);
    void            InsertURLButton(const OUString& rURL, const OUString& rText, const OUString& rTarget,
                                    const Point* pPos);
 
    void            SelectionHasChanged();
    void            ModelHasChanged();
    virtual void    Activate(bool bIsMDIActivate) override;
    virtual void    Deactivate(bool IsMDIActivate) override;
    virtual void    UIActivating( SfxInPlaceClient* ) override;
    virtual void    UIDeactivated( SfxInPlaceClient* ) override;
    OUString        GetSelectionText( bool bCompleteWords );
    bool            HasSelection( bool bText ) const;
 
    //If we are editing a PresObjKind::Outline return the Outliner and fill rSel
    //with the current selection
    ::Outliner*     GetOutlinerForMasterPageOutlineTextObj(ESelection &rSel);
 
    void            ExecCtrl(SfxRequest& rReq);
    void            GetCtrlState(SfxItemSet& rSet);
    void            GetDrawAttrState(SfxItemSet& rSet);
    void            GetMenuState(SfxItemSet& rSet);
    void            GetTableMenuState(SfxItemSet& rSet);
    void            GetModeSwitchingMenuState (SfxItemSet &rSet);
    void            GetAttrState(SfxItemSet& rSet);
    void            GetSnapItemState(SfxItemSet& rSet);
 
    void            SetPageProperties (SfxRequest& rReq);
    void            GetPageProperties(SfxItemSet& rSet);
    void            GetMarginProperties(SfxItemSet& rSet);
 
    void            GetState (SfxItemSet& rSet);
    void            Execute (SfxRequest& rReq);
 
    void            ExecStatusBar(SfxRequest& rReq);
    void            GetStatusBarState(SfxItemSet& rSet);
 
    void            ExecOptionsBar(SfxRequest& rReq);
    void            GetOptionsBarState(SfxItemSet& rSet);
 
    void            ExecRuler(SfxRequest& rReq);
    void            GetRulerState(SfxItemSet& rSet);
 
    void            ExecFormText(SfxRequest& rReq);
    void            GetFormTextState(SfxItemSet& rSet);
 
    void            ExecAnimationWin(SfxRequest& rReq);
    void            GetAnimationWinState(SfxItemSet& rSet);
 
    void            ExecNavigatorWin(SfxRequest& rReq);
    void            GetNavigatorWinState(SfxItemSet& rSet);
 
    void            ExecutePropPanelAttr (SfxRequest const & rReq);
    void            GetStatePropPanelAttr(SfxItemSet& rSet);
 
    void            ExecEffectWin(SfxRequest& rReq);
 
    void            Update3DWindow();
    void            AssignFrom3DWindow();
 
    void            ExecGallery(SfxRequest const & rReq);
 
    void            ExecBmpMask( SfxRequest const & rReq );
    void            GetBmpMaskState( SfxItemSet& rSet );
 
    void            ExecIMap( SfxRequest const & rReq );
    void            GetIMapState( SfxItemSet& rSet );
 
    void            FuTemporary(SfxRequest& rReq);
    void            FuPermanent(SfxRequest& rReq);
    void            FuSupport(SfxRequest& rReq);
    void            FuDeleteSelectedObjects();
    void            FuSupportRotate(SfxRequest const & rReq);
    void            FuTable(SfxRequest& rReq);
 
    void            AttrExec (SfxRequest& rReq);
    void            AttrState (SfxItemSet& rSet);
 
    void            ExecGoToNextPage (SfxRequest& rReq);
    void            GetStateGoToNextPage (SfxItemSet& rSet);
 
    void            ExecGoToPreviousPage (SfxRequest& rReq);
    void            GetStateGoToPreviousPage (SfxItemSet& rSet);
 
    void            ExecGoToFirstPage (SfxRequest& rReq);
    void            GetStateGoToFirstPage (SfxItemSet& rSet);
 
    void            ExecGoToLastPage (SfxRequest& rReq);
    void            GetStateGoToLastPage (SfxItemSet& rSet);
 
    SD_DLLPUBLIC void ExecChar(SfxRequest& rReq);
 
    void            ExecuteAnnotation (SfxRequest const & rRequest);
    void            GetAnnotationState (SfxItemSet& rItemSet);
 
    void            StartRulerDrag (const Ruler& rRuler, const MouseEvent& rMEvt);
 
    virtual bool    PrepareClose( bool bUI = true ) override;
 
    PageKind        GetPageKind() const { return mePageKind; }
    void            SetPageKind( PageKind ePageKind ) { mePageKind = ePageKind; }
    const Point&    GetMousePos() const { return maMousePos; }
 
    EditMode        GetEditMode() const { return meEditMode; }
    virtual SdPage* GetActualPage() override { return mpActualPage; }
 
    virtual SdPage* getCurrentPage() const override;
 
    void            ResetActualPage();
    void            ResetActualLayer();
    bool            SwitchPage(sal_uInt16 nPage, bool bAllowChangeFocus = true);
    bool            IsSwitchPageAllowed() const;
 
    bool            SelectPage(sal_uInt16 nPage, sal_uInt16 nSelect);
    bool            IsSelected(sal_uInt16 nPage);
 
    void            GotoBookmark(std::u16string_view rBookmark);
    //Realize multi-selection of objects, If object is marked, the
    //corresponding entry is set true, else the corresponding entry is set
    //false.
    void            FreshNavigatrTree();
    void            MakeVisible(const ::tools::Rectangle& rRect, vcl::Window& rWin);
 
    virtual void    ReadFrameViewData(FrameView* pView) override;
    virtual void    WriteFrameViewData() override;
 
    virtual ErrCode DoVerb(sal_Int32 nVerb) override;
    virtual bool    ActivateObject(SdrOle2Obj* pObj, sal_Int32 nVerb) override;
 
    void            SetZoomOnPage( bool bZoom ) { mbZoomOnPage = bZoom; }
    bool            IsZoomOnPage() const { return mbZoomOnPage; }
    static void     CheckLineTo (SfxRequest& rReq);
    void            SetChildWindowState( SfxItemSet& rSet );
 
    void            UpdateIMapDlg( SdrObject* pObj );
 
    void            LockInput();
    void            UnlockInput();
    bool            IsInputLocked() const { return mnLockCount > 0; }
 
    sal_uInt16      GetCurPagePos() const { return maTabControl->GetCurPagePos(); }
 
    virtual void    ShowUIControls (bool bVisible) override;
 
    void            ScannerEvent();
 
    bool            IsLayerModeActive() const { return mbIsLayerModeActive;}
 
    virtual sal_Int8    AcceptDrop( const AcceptDropEvent& rEvt, DropTargetHelper& rTargetHelper,
                                    ::sd::Window* pTargetWindow, sal_uInt16 nPage, SdrLayerID nLayer ) override;
    virtual sal_Int8    ExecuteDrop( const ExecuteDropEvent& rEvt, DropTargetHelper& rTargetHelper,
                                    ::sd::Window* pTargetWindow, sal_uInt16 nPage, SdrLayerID nLayer ) override;
 
    virtual void    WriteUserDataSequence ( css::uno::Sequence < css::beans::PropertyValue >& ) override;
    virtual void    ReadUserDataSequence ( const css::uno::Sequence < css::beans::PropertyValue >& ) override;
 
    virtual void    VisAreaChanged(const ::tools::Rectangle& rRect) override;
 
    virtual css::uno::Reference<css::accessibility::XAccessible>
        CreateAccessibleDocumentView (::sd::Window* pWindow) override;
 
    int GetTabLayerCount() const;
 
    int GetActiveTabLayerIndex() const;
 
    void SetActiveTabLayerIndex (int nId);
 
    TabControl& GetPageTabControl() { return *maTabControl; }
 
    SD_DLLPUBLIC LayerTabBar* GetLayerTabControl(); // export for unit test
 
    bool RenameSlide( sal_uInt16 nPageId, const OUString & rName );
 
    void ModifyLayer( SdrLayer* pLayer, const OUString& rLayerName, const OUString& rLayerTitle, const OUString& rLayerDesc, bool bIsVisible, bool bIsLocked, bool bIsPrintable );
 
    virtual css::uno::Reference<css::drawing::XDrawSubController> CreateSubController() override;
 
    DrawView*   GetDrawView() const { return mpDrawView.get(); }
 
    virtual bool RelocateToParentWindow (vcl::Window* pParentWindow) override;
 
    OUString const & GetSidebarContextName() const;
 
    bool IsInSwitchPage() const { return mbIsInSwitchPage; }
 
    const SdViewOptions& GetViewOptions() const { return maViewOptions; }
    //move this method to ViewShell.
    //void  NotifyAccUpdate();
protected:
                    DECL_DLLPRIVATE_LINK( ClipboardChanged, TransferableDataHelper*, void );
                    DECL_DLLPRIVATE_LINK( TabSplitHdl, TabBar *, void );
                    DECL_DLLPRIVATE_LINK( NameObjectHdl, AbstractSvxObjectNameDialog&, bool );
                    DECL_DLLPRIVATE_LINK( RenameSlideHdl, AbstractSvxNameDialog&, bool );
 
    void            DeleteActualPage();
    void            DeleteActualLayer();
 
    virtual VclPtr<SvxRuler> CreateHRuler(::sd::Window* pWin) override;
    virtual VclPtr<SvxRuler> CreateVRuler(::sd::Window* pWin) override;
    virtual void    UpdateHRuler() override;
    virtual void    UpdateVRuler() override;
    virtual void    SetZoomFactor(const Fraction& rZoomX, const Fraction& rZoomY) override;
 
    void            SetupPage( Size const &rSize, ::tools::Long nLeft, ::tools::Long nRight, ::tools::Long nUpper, ::tools::Long nLower,
                               bool bSize, bool bMargin, bool bScaleAll );
 
    void            GetMenuStateSel(SfxItemSet& rSet);
 
private:
    DrawViewShell(const DrawViewShell&) = delete;
    DrawViewShell& operator=(const DrawViewShell&) = delete;
 
    void Construct (DrawDocShell* pDocSh, PageKind ePageKind);
 
    void ImplDestroy();
 
    virtual SdPage* CreateOrDuplicatePage (
        SfxRequest& rRequest,
        PageKind ePageKind,
        SdPage* pPage,
        const sal_Int32 nInsertPosition = -1) override;
 
    void DuplicateSelectedSlides (SfxRequest& rRequest);
 
    virtual void Notify (SfxBroadcaster& rBC, const SfxHint& rHint) override;
 
    void StopSlideShow();
 
    void ShowSnapLineContextMenu(weld::Window* pParent, const ::tools::Rectangle& rRect,
        SdrPageView& rPageView, const sal_uInt16 nSnapLineIndex);
 
    using ViewShell::Notify;
 
    virtual void ConfigurationChanged( utl::ConfigurationBroadcaster* pCb, ConfigurationHints ) override;
 
    void ConfigureAppBackgroundColor( svtools::ColorConfig* pColorConfig = nullptr );
 
    bool ShouldDisableEditHyperlink() const;
    void EnableEditHyperlink();
 
private:
    std::unique_ptr<DrawView> mpDrawView;
    SdPage*             mpActualPage;
    ::tools::Rectangle           maMarkRect;
    Point               maMousePos;
    VclPtr<TabControl>  maTabControl;
    EditMode            meEditMode;
    PageKind            mePageKind;
    // tdf#137445 at context menu popup time set if the EditHyperlink entry
    // should be disabled and use that state if queried about it if
    // EditHyperlink is dispatched from the menu. So ignoring where the mouse
    // currently happens to be when the menu was dismissed.
    std::optional<bool> moAtContextMenu_DisableEditHyperlink;
    bool                mbZoomOnPage;
    bool                mbIsRulerDrag;
    sal_uLong           mnLockCount;
    bool                mbReadOnly;
    static bool         mbPipette;
    bool mbFirstTimeActivation = true;
    bool mbIsLayerModeActive;
    ::std::unique_ptr<SvxClipboardFormatItem> mpCurrentClipboardFormats;
    tools::AsynchronousCall maAsynchronousSwitchPageCall;
    bool mbIsInSwitchPage;
    RotateTransliteration m_aRotateCase;
    ::rtl::Reference<svx::sidebar::SelectionChangeHandler> mpSelectionChangeHandler;
    css::uno::Reference< css::scanner::XScannerManager2 > mxScannerManager;
    css::uno::Reference< css::lang::XEventListener >      mxScannerListener;
    rtl::Reference<TransferableClipboardListener>         mxClipEvtLstnr;
    bool                                                  mbPastePossible;
    bool                                                  mbMouseButtonDown;
    bool                                                  mbMouseSelecting;
    ::std::unique_ptr< AnnotationManager > mpAnnotationManager;
    ::std::unique_ptr< ViewOverlayManager > mpViewOverlayManager;
    std::vector<std::unique_ptr<SdrExternalToolEdit>> m_ExternalEdits;
    SdViewOptions maViewOptions;
};
 
    void MergePageBackgroundFilling(SdPage *pPage, SdStyleSheet *pStyleSheet, bool bMasterPage, SfxItemSet& rMergedAttr);
 
} // end of namespace sd
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */