ViewShell.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 <rtl/ref.hxx>
 
#include <sfx2/viewsh.hxx>
#include <svl/typedwhich.hxx>
#include <svtools/scrolladaptor.hxx>
#include <vcl/prntypes.hxx>
#include <o3tl/deleter.hxx>
#include <pres.hxx>
#include "View.hxx"
#include "fupoor.hxx"
#include <sddllapi.h>
 
#include <memory>
 
class SdPage;
class SvxRuler;
class SdrOle2Obj;       // for the ones, who have undefined parts of SVDRAW
class SdDrawDocument;
class SvxNumBulletItem;
 
namespace weld
{
    class Window;
}
 
namespace com::sun::star::drawing { class XDrawSubController; }
 
namespace sd {
 
class DrawDocShell;
class FrameView;
class LayerTabBar;
class ViewShellBase;
class Window;
class WindowUpdater;
class ZoomList;
 
#undef OUTPUT_DRAWMODE_COLOR
#undef OUTPUT_DRAWMODE_CONTRAST
 
const DrawModeFlags OUTPUT_DRAWMODE_COLOR = DrawModeFlags::Default;
const DrawModeFlags OUTPUT_DRAWMODE_GRAYSCALE
        = DrawModeFlags::GrayLine | DrawModeFlags::GrayFill
        | DrawModeFlags::BlackText | DrawModeFlags::GrayBitmap
        | DrawModeFlags::GrayGradient;
const DrawModeFlags OUTPUT_DRAWMODE_BLACKWHITE
        = DrawModeFlags::BlackLine | DrawModeFlags::BlackText
        | DrawModeFlags::WhiteFill | DrawModeFlags::GrayBitmap
        | DrawModeFlags::WhiteGradient;
const DrawModeFlags OUTPUT_DRAWMODE_CONTRAST
        = DrawModeFlags::SettingsLine | DrawModeFlags::SettingsFill
        | DrawModeFlags::SettingsText | DrawModeFlags::SettingsGradient;
 
class SAL_DLLPUBLIC_RTTI ViewShell
    : public SfxShell
{
public:
    enum ShellType {
        ST_NONE,
        ST_DRAW,         // The Draw application.
        ST_IMPRESS,      // Main view of the Impress application.
        ST_NOTES,
        ST_HANDOUT,
        ST_OUTLINE,
        ST_SLIDE_SORTER,
        ST_PRESENTATION,
        ST_SIDEBAR
    };
    static const int MAX_HSPLIT_CNT = 1;
    static const int MAX_VSPLIT_CNT = 1;
    static const int MIN_SCROLLBAR_SIZE = 50;
 
 
    ViewShell (
        vcl::Window* pParentWindow,
        ViewShellBase& rViewShellBase);
    virtual ~ViewShell() override;
 
    virtual void Init (bool bIsMainViewShell);
 
    void Exit();
 
    void Cancel();
 
    vcl::Window* GetParentWindow() const { return mpParentWindow; }
 
    sd::Window* GetContentWindow() const;
 
    ::sd::View* GetView() const { return mpView; }
    inline SdrView* GetDrawView() const;
    SD_DLLPUBLIC DrawDocShell* GetDocSh() const;
 
    SdDrawDocument*  GetDoc() const;
 
    SD_DLLPUBLIC SfxViewFrame* GetViewFrame() const;
 
    ::sd::Window* GetActiveWindow() const { return mpActiveWindow;}
    SD_DLLPUBLIC weld::Window* GetFrameWeld() const;
 
    void SetActiveWindow (::sd::Window* pWindow);
 
    const ::tools::Rectangle& GetAllWindowRect();
 
    // Mouse- & Key-Events
    virtual void PrePaint();
    virtual void Paint (const ::tools::Rectangle& rRect, ::sd::Window* pWin);
    virtual bool KeyInput(const KeyEvent& rKEvt, ::sd::Window* pWin);
    virtual void MouseMove(const MouseEvent& rMEvt, ::sd::Window* pWin);
    virtual void MouseButtonUp(const MouseEvent& rMEvt, ::sd::Window* pWin);
    virtual void MouseButtonDown(const MouseEvent& rMEvt, ::sd::Window* pWin);
    virtual void Command(const CommandEvent& rCEvt, ::sd::Window* pWin);
    bool RequestHelp( const HelpEvent& rEvt );
    bool Notify( NotifyEvent const & rNEvt, ::sd::Window* pWin );
 
    bool HandleScrollCommand(const CommandEvent& rCEvt, ::sd::Window* pWin);
 
    void SetUIUnit(FieldUnit eUnit);
    void SetDefTabHRuler( sal_uInt16 nDefTab );
 
    const SvxNumBulletItem* GetNumBulletItem(SfxItemSet& aNewAttr, TypedWhichId<SvxNumBulletItem>& nNumItemId);
 
    bool HasRuler() const { return mbHasRulers;}
    void SetRuler(bool bRuler);
    // Hides horizontal, vertical scrollbar as well as scrollbox
    void SetScrollBarsVisible(bool bVisible);
 
    virtual void UpdateScrollBars();
    void    Scroll(::tools::Long nX, ::tools::Long nY);
    void    ScrollLines(::tools::Long nX, ::tools::Long nY);
    virtual void    SetZoom(::tools::Long nZoom);
    ::tools::Long    GetZoom() const;
    virtual void    SetZoomRect(const ::tools::Rectangle& rZoomRect);
    void    InitWindows(const Point& rViewOrigin, const Size& rViewSize,
                        const Point& rWinPos, bool bUpdate = false);
    void    InvalidateWindows();
    virtual void UpdatePreview (SdPage* pPage);
 
    void    DrawMarkRect(const ::tools::Rectangle& rRect) const;
 
    void    ExecReq( SfxRequest &rReq );
 
    ZoomList* GetZoomList() { return mpZoomList.get();}
 
    FrameView* GetFrameView() { return mpFrameView; }
    void SetFrameView (FrameView* pFrameView);
    virtual void  ReadFrameViewData(FrameView* pView);
    virtual void  WriteFrameViewData();
    void  WriteUserData();
    void  ReadUserData();
 
    virtual bool ActivateObject(SdrOle2Obj* pObj, sal_Int32 nVerb);
 
    virtual SdPage* GetActualPage() = 0;
 
    virtual SdPage* getCurrentPage() const = 0;
 
    const rtl::Reference<FuPoor>& GetOldFunction() const { return mxOldFunction; }
    bool HasOldFunction() const { return mxOldFunction.is(); }
    const rtl::Reference<FuPoor>& GetCurrentFunction() const { return mxCurrentFunction; }
    bool HasCurrentFunction( sal_uInt16 nSID ) { return mxCurrentFunction.is() && (mxCurrentFunction->GetSlotID() == nSID ); }
    bool HasCurrentFunction() const { return mxCurrentFunction.is(); }
 
    void SetCurrentFunction(const rtl::Reference<FuPoor>& xFunction);
    void SetOldFunction(const rtl::Reference<FuPoor>& xFunction);
    void DeactivateCurrentFunction( bool bPermanent = false );
 
    void    SetPageSizeAndBorder(PageKind ePageKind, const Size& rNewSize,
                            ::tools::Long nLeft, ::tools::Long nRight, ::tools::Long nUpper, ::tools::Long nLower,
                            bool bScaleAll, Orientation eOrient, sal_uInt16 nPaperBin,
                            bool bBackgroundFullSize );
 
    void    SetStartShowWithDialog( bool bIn ) { mbStartShowWithDialog = bIn; }
    bool    IsStartShowWithDialog() const { return mbStartShowWithDialog; }
 
    sal_uInt16 GetPrintedHandoutPageNum() const { return mnPrintedHandoutPageNum; }
    void SetPrintedHandoutPageNum (sal_uInt16 nPageNumber) {mnPrintedHandoutPageNum=nPageNumber; }
 
    sal_uInt16 GetPrintedHandoutPageCount() const { return mnPrintedHandoutPageCount; }
    void SetPrintedHandoutPageCount (sal_uInt16 nPageCount) {mnPrintedHandoutPageCount=nPageCount; }
 
    virtual bool PrepareClose( bool bUI = true );
 
    void GetMenuState(SfxItemSet& rSet);
 
    virtual sal_Int8 AcceptDrop( const AcceptDropEvent& rEvt, DropTargetHelper& rTargetHelper,
                                 ::sd::Window* pTargetWindow, sal_uInt16 nPage, SdrLayerID nLayer );
    virtual sal_Int8 ExecuteDrop( const ExecuteDropEvent& rEvt, DropTargetHelper& rTargetHelper,
                                  ::sd::Window* pTargetWindow, sal_uInt16 nPage, SdrLayerID nLayer );
 
    virtual void WriteUserDataSequence ( css::uno::Sequence < css::beans::PropertyValue >& );
    virtual void ReadUserDataSequence ( const css::uno::Sequence < css::beans::PropertyValue >& );
 
    virtual void VisAreaChanged(const ::tools::Rectangle& rRect);
 
    virtual css::uno::Reference<css::accessibility::XAccessible>
        CreateAccessibleDocumentView (::sd::Window* pWindow);
 
    virtual void SwitchViewFireFocus( const css::uno::Reference< css::accessibility::XAccessible >& xAcc );
    void SwitchActiveViewFireFocus( );
    // Move these two methods from DrawViewShell to enable slide show view
    void    NotifyAccUpdate();
    void    fireSwitchCurrentPage(sal_Int32 pageIndex);
    void SetWinViewPos(const Point& rWinPos);
    Point const & GetWinViewPos() const;
    Point const & GetViewOrigin() const;
 
    ::sd::WindowUpdater* GetWindowUpdater() const;
 
    SvBorder GetBorder();
 
    virtual void Resize();
 
    virtual void ArrangeGUIElements();
 
    //  virtual void OuterResizePixel(const Point &rPos, const Size &rSize);
    //  virtual void InnerResizePixel(const Point &rPos, const Size &rSize);
 
    // Exported for unit test
    SD_DLLPUBLIC ViewShellBase& GetViewShellBase() const;
 
    bool IsMainViewShell() const;
 
    void SetIsMainViewShell (bool bIsMainViewShell);
 
    virtual css::uno::Reference<css::drawing::XDrawSubController> CreateSubController() = 0;
 
    SD_DLLPUBLIC ShellType GetShellType() const; //Export for unit test
 
    virtual void Shutdown();
 
    virtual ErrCode DoVerb(sal_Int32 nVerb);
 
    virtual void UIActivating( SfxInPlaceClient* );
    virtual void UIDeactivated( SfxInPlaceClient* );
 
    virtual void ShowUIControls (bool bVisible);
    bool IsPageFlipMode() const;
 
    virtual bool RelocateToParentWindow (vcl::Window* pParentWindow);
 
    virtual SdPage* CreateOrDuplicatePage (
        SfxRequest& rRequest,
        PageKind ePageKind,
        SdPage* pPage,
        const sal_Int32 nInsertPosition = -1);
 
    void SetCursorMm100Position(const Point& rPosition, bool bPoint, bool bClearMark);
    css::uno::Reference<css::datatransfer::XTransferable> GetSelectionTransferable() const;
    void SetGraphicMm100Position(bool bStart, const Point& rPosition);
 
    class Implementation;
 
protected:
    void DisposeFunctions();
 
    friend class ViewShellBase;
 
    VclPtr<sd::Window> mpContentWindow;
 
    VclPtr<ScrollAdaptor> mpHorizontalScrollBar;
    VclPtr<ScrollAdaptor> mpVerticalScrollBar;
    VclPtr<SvxRuler> mpHorizontalRuler;
    VclPtr<SvxRuler> mpVerticalRuler;
    VclPtr<LayerTabBar> mpLayerTabBar;
 
    bool mbHasRulers;
 
    VclPtr< ::sd::Window> mpActiveWindow;
    ::sd::View* mpView;
    FrameView*  mpFrameView;
 
    rtl::Reference<FuPoor>   mxCurrentFunction;
    rtl::Reference<FuPoor>   mxOldFunction;
    std::unique_ptr<ZoomList> mpZoomList;
    double mfLastZoomScale;
    double mfAccumulatedZoom = 0;
 
    Point       maViewPos;
    Size        maViewSize;
    Size        maScrBarWH;
 
    bool        mbStartShowWithDialog;    // presentation is started by dialog
    sal_uInt16      mnPrintedHandoutPageNum; // Page number of the handout page that is to be printed.
    sal_uInt16      mnPrintedHandoutPageCount; // Page count of the handout pages that are to be printed.
 
    //af    bool        bPrintDirectSelected;       // Print only selected objects in direct print
    //afString      sPageRange;                 // pagerange if selected objects in direct print
 
    ::tools::Rectangle maAllWindowRectangle;
 
    ShellType meShellType;
 
    std::unique_ptr<Implementation, o3tl::default_delete<Implementation>> mpImpl;
 
    // Support methods for centralized UNDO/REDO
    virtual SfxUndoManager* ImpGetUndoManager() const;
    void ImpGetUndoStrings(SfxItemSet &rSet) const;
    void ImpGetRedoStrings(SfxItemSet &rSet) const;
    void ImpSidUndo(SfxRequest& rReq);
    void ImpSidRedo(SfxRequest& rReq);
 
    DECL_DLLPRIVATE_LINK( HScrollHdl, weld::Scrollbar&, void );
    DECL_DLLPRIVATE_LINK( VScrollHdl, weld::Scrollbar&, void );
 
    // virtual scroll handler, here, derivative classes can add themselves here
    virtual void VirtHScrollHdl(ScrollAdaptor* pHScroll);
    virtual void VirtVScrollHdl(ScrollAdaptor* pVScroll);
 
    // virtual functions ruler handling
    virtual VclPtr<SvxRuler> CreateHRuler(::sd::Window* pWin);
    virtual VclPtr<SvxRuler> CreateVRuler(::sd::Window* pWin);
    virtual void UpdateHRuler();
    virtual void UpdateVRuler();
 
    virtual void Activate(bool IsMDIActivate) override;
    virtual void Deactivate(bool IsMDIActivate) override;
 
    virtual void SetZoomFactor( const Fraction &rZoomX,
                                const Fraction &rZoomY );
 
    void doShow();
 
private:
    VclPtr<vcl::Window> mpParentWindow;
    ::std::unique_ptr< ::sd::WindowUpdater> mpWindowUpdater;
 
    void construct();
 
    void SetupRulers();
};
 
SdrView* ViewShell::GetDrawView() const
{
    return static_cast<SdrView*>(mpView);
}
 
} // end of namespace sd
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */