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, 513 insertions, 0 deletions

diff --git a/sd/source/ui/inc/DrawViewShell.hxx b/sd/source/ui/inc/DrawViewShell.hxx
new file mode 100644
index 000000000..c56a0f33e
--- /dev/null
+++ b/sd/source/ui/inc/DrawViewShell.hxx
@@ -0,0 +1,513 @@
+/* -*- 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>
+
+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))
+
+/** Base class of the stacked shells that provide graphical views to
+    Draw and Impress documents and editing functionality.  In contrast
+    to this other stacked shells are responsible for showing an
+    overview over several slides or a textual
+    overview over the text in an Impress document (OutlineViewShell).
+*/
+class SAL_DLLPUBLIC_RTTI DrawViewShell
+    : public ViewShell,
+      public SfxListener,
+      public utl::ConfigurationListener
+{
+public:
+    SFX_DECL_INTERFACE(SD_IF_SDDRAWVIEWSHELL)
+
+private:
+    /// SfxInterface initializer.
+    static void InitInterface_Impl();
+
+public:
+    /** Create a new stackable shell that may take some information
+        (e.g. the frame view) from the given previous shell.
+        @param ePageKind
+            This parameter gives the initial page kind that the new shell
+            will show.
+        @param pFrameView
+            The frame view that makes it possible to pass information from
+            one view shell to the next.
+    */
+    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;
+
+    /** Arrange and resize the GUI elements like rulers, sliders, and
+        buttons as well as the actual document view according to the size of
+        the enclosing window and current sizes of buttons, rulers, and
+        sliders.
+    */
+    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);
+    /** Set the items of the given item set that are related to
+        switching the editing mode to the correct values.
+        <p>This function also sets the states of the mode buttons
+        (those at the upper right corner) accordingly.</p>
+    */
+    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; }
+
+    /// inherited from sd::ViewShell
+    virtual SdPage* getCurrentPage() const override;
+
+    void            ResetActualPage();
+    void            ResetActualLayer();
+    bool            SwitchPage(sal_uInt16 nPage, bool bAllowChangeFocus = true);
+    bool            IsSwitchPageAllowed() const;
+
+    /**
+     * Mark the desired page as selected (1), deselected (0), toggle (2).
+     * nPage refers to the page in question.
+     */
+    bool            SelectPage(sal_uInt16 nPage, sal_uInt16 nSelect);
+    bool            IsSelected(sal_uInt16 nPage);
+    bool            IsVisible(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(); }
+
+    /** Show controls of the UI or hide them, depending on the given flag.
+        Do not call this method directly.  Call the method at ViewShellBase
+        instead.
+    */
+    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;
+
+    /** Create an accessible object representing the specified window.
+        @param pWindow
+            The returned object makes the document displayed in this window
+            accessible.
+        @return
+            Returns an <type>AccessibleDrawDocumentView</type> object.
+   */
+    virtual css::uno::Reference<css::accessibility::XAccessible>
+        CreateAccessibleDocumentView (::sd::Window* pWindow) override;
+
+    /** Return the number of layers managed by the layer tab control.  This
+        will usually differ from the number of layers managed by the layer
+        administrator.
+        @return
+            The number of layers managed by the layer tab control.  The
+            returned value is independent of whether the layer mode is
+            currently active and the tab control is visible.
+    */
+    int GetTabLayerCount() const;
+
+    /** Return the numerical id of the currently active layer as seen by the
+        layer tab control.
+        @return
+            The returned id is a number between zero (inclusive) and the
+            number of layers as returned by the
+            <member>GetTabLayerCount</member> method (exclusive).
+    */
+    int GetActiveTabLayerIndex() const;
+
+    /** Set the active layer at the layer tab control and update the control
+        accordingly to reflect the change on screen.
+        @param nId
+            The id is expected to be a number between zero (inclusive) and
+            the number of layers as returned by the
+            <member>GetTabLayerCount</member> method (exclusive). Note that
+            Invalid values are ignored. No exception is thrown in that case.
+    */
+    void SetActiveTabLayerIndex (int nId);
+
+    /** Return a pointer to the tab control for pages.
+    */
+    TabControl& GetPageTabControl() { return *maTabControl; }
+
+    /** Return a pointer to the tab control for layers.
+    */
+    SD_DLLPUBLIC LayerTabBar* GetLayerTabControl(); // export for unit test
+
+    /** Renames the given slide using an SvxNameDialog
+
+        @param nPageId the index of the page in the SdTabControl.
+        @param rName the new name of the slide.
+
+        @return false, if the new name is invalid for some reason.
+
+        <p>Implemented in <code>drviews8.cxx</code>.</p>
+     */
+    bool RenameSlide( sal_uInt16 nPageId, const OUString & rName );
+
+    /** modifies the given layer with the given values */
+    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(); }
+
+    /** Relocation to a new parent window is not supported for DrawViewShell
+        objects so this method always returns <FALSE/>.
+    */
+    virtual bool RelocateToParentWindow (vcl::Window* pParentWindow) override;
+
+    OUString const & GetSidebarContextName() const;
+
+    bool IsInSwitchPage() const { return mbIsInSwitchPage; }
+
+    //move this method to ViewShell.
+    //void  NotifyAccUpdate();
+protected:
+    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;
+
+                    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:
+    /** This flag controls whether the layer mode is active, i.e. the layer
+        dialog is visible.
+    */
+    bool mbIsLayerModeActive;
+
+    /** This item contains the clipboard formats of the current clipboard
+        content that are supported both by that content and by the
+        DrawViewShell.
+    */
+    ::std::unique_ptr<SvxClipboardFormatItem> mpCurrentClipboardFormats;
+
+    /** On some occasions it is necessary to make SwitchPage calls
+        asynchronously.
+    */
+    tools::AsynchronousCall maAsynchronousSwitchPageCall;
+
+    /** This flag is used to prevent nested calls to SwitchPage().
+    */
+    bool mbIsInSwitchPage;
+
+    RotateTransliteration m_aRotateCase;
+
+    /** Listen for selection changes and broadcast context changes for the sidebar.
+    */
+    ::rtl::Reference<svx::sidebar::SelectionChangeHandler> mpSelectionChangeHandler;
+
+    void Construct (DrawDocShell* pDocSh, PageKind ePageKind);
+
+    /** Depending on the given request create a new page or duplicate an
+        existing one.  See ViewShell::CreateOrDuplicatePage() for more
+        information.
+    */
+    virtual SdPage* CreateOrDuplicatePage (
+        SfxRequest& rRequest,
+        PageKind ePageKind,
+        SdPage* pPage,
+        const sal_Int32 nInsertPosition = -1) override;
+
+    void DuplicateSelectedSlides (SfxRequest& rRequest);
+
+    css::uno::Reference< css::scanner::XScannerManager2 > mxScannerManager;
+    css::uno::Reference< css::lang::XEventListener >      mxScannerListener;
+    rtl::Reference<TransferableClipboardListener>         mxClipEvtLstnr;
+    bool                                                  mbPastePossible;
+    bool                                                  mbMouseButtonDown;
+    bool                                                  mbMouseSelecting;
+
+    virtual void Notify (SfxBroadcaster& rBC, const SfxHint& rHint) override;
+
+    /** Stop a running slide show.
+    */
+    void StopSlideShow();
+
+    /** Show the context menu for snap lines and points.  Because snap lines
+        can not be selected the index of the snap line/point for which the
+        popup menu is opened has to be passed to the processing slot
+        handlers.  This can be done only by manually showing the popup menu.
+        @param pParent
+            The parent for the context menu.
+        @param rRect
+            The location at which to display the context menu.
+        @param rPageView
+            The page view is used to access the help lines.
+        @param nSnapLineIndex
+            Index of the snap line or snap point for which to show the
+            context menu.
+    */
+    void ShowSnapLineContextMenu(weld::Window* pParent, const ::tools::Rectangle& rRect,
+        SdrPageView& rPageView, const sal_uInt16 nSnapLineIndex);
+
+    using ViewShell::Notify;
+
+    ::std::unique_ptr< AnnotationManager > mpAnnotationManager;
+    ::std::unique_ptr< ViewOverlayManager > mpViewOverlayManager;
+
+    std::vector<std::unique_ptr<SdrExternalToolEdit>> m_ExternalEdits;
+
+    virtual void ConfigurationChanged( utl::ConfigurationBroadcaster* pCb, ConfigurationHints ) override;
+
+    void ConfigureAppBackgroundColor( svtools::ColorConfig* pColorConfig = nullptr );
+
+    /// return true if "Edit Hyperlink" in context menu should be disabled
+    bool ShouldDisableEditHyperlink() const;
+    /// force "Edit Hyperlink" to true, with the expectation that SID_EDIT_HYPERLINK is
+    /// later Invalidated to reset it back to its natural value
+    void EnableEditHyperlink();
+
+    // The colour of the area behind the slide (used to be called "Wiese")
+    Color mnAppBackgroundColor;
+};
+
+    /// Merge the background properties together and deposit the result in rMergeAttr
+    void MergePageBackgroundFilling(SdPage *pPage, SdStyleSheet *pStyleSheet, bool bMasterPage, SfxItemSet& rMergedAttr);
+
+} // end of namespace sd
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */