/* -*- 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 <comphelper/OAccessible.hxx>

#include <rtl/ref.hxx>

#include <sfx2/viewsh.hxx>

#include <svl/typedwhich.hxx>

#include <svtools/scrolladaptor.hxx>

#include <vcl/prntypes.hxx>

#include <vcl/rendercontext/DrawModeFlags.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;

/** Base class of the stacked shell hierarchy.

    <p>Despite its name this class is not a descendant of SfxViewShell

    but of SfxShell.  Its name expresses the fact that it acts like a

    view shell.  Being a stacked shell rather than being an actual view shell

    there can be several instances of this class that

    <ul>

    <li>all are based on the same view shell and thus show the same

    document and share common view functionality and</li>

    <li>are all visible at the same time and live in the same

    frame.</li>

    <ul></p>

    <p>This class replaces the former ViewShell class.</p>

*/

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,

        ST_NOTESPANEL

    };

    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;

    /** The Init method has to be called from the outside directly

        after a new object of this class has been created.  It can be

        used for that part of the initialisation that can be run only

        after the creation of the new object is finished.  This

        includes registration as listener at event broadcasters.

        Derived classes should call this method at the head of their

        Init() methods.

        @param bIsMainViewShell

            This flag tells the Init() method whether the new ViewShell will

            be the main view shell.

    */

    virtual void Init (bool bIsMainViewShell);

    /** The Exit() method has to be called before the destructor so that the

        view shell is still a valid object and can safely call methods that

        rely on that.

    */

    void Exit();

    void Cancel();

    /** Return the window that is the parent of all controls of this view

        shell.  This may or may not be the window of the frame.

    */

    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;

    SAL_RET_MAYBENULL SD_DLLPUBLIC SfxViewFrame* GetViewFrame() const;

    /** The active window is usually the mpContentWindow.  When there is a

        show running then the active window is a ShowWindow.

    */

    ::sd::Window* GetActiveWindow() const { return mpActiveWindow;}

    SD_DLLPUBLIC weld::Window* GetFrameWeld() const;

    /** Set the active window.  When the shell is displayed in the center

        pane then the window of the ViewShellBase is also set to the given

        window.

    */

    void SetActiveWindow (::sd::Window* pWindow);

    /** Return the rectangle that encloses all windows of the view.  That

        excludes the controls in the frame like rulers, scroll bars, tab

        bar, and buttons.

        @return

            The rectangle is returned in screen coordinates, i.e. pixel

            values relative to the upper left corner of the screen?.

    */

    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);

    /** Set internal values of all scroll bars that determine thumb size and

        position.  The external values like size and position of the scroll

        bar controls are not modified.

    */

    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();

    /** This method is still used by the OutlineViewShell to update the

        model according to the content of the outline view.  This in turn

        updates the previews in the slide sorter.

    */

    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; }

    /** Setting a frame view triggers ReadFrameViewData() for the new

        frame.

        @param pFrameView

            The new frame view that replaces the old one.

    */

    void SetFrameView (FrameView* pFrameView);

    virtual void  ReadFrameViewData(FrameView* pView);

    virtual void  WriteFrameViewData();

    void  WriteUserData();

    void  ReadUserData();

    virtual bool ActivateObject(SdrOle2Obj* pObj, sal_Int32 nVerb);

    /** @returns

            current or selected page or 0. This method

            will fail in master page mode.

        @deprecated, please use getCurrentPage();

    */

    virtual SdPage* GetActualPage() = 0;

    /** @returns

            current or selected page or 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 >& );

    /** this method is called when the visible area of the view from this viewshell is changed */

    virtual void VisAreaChanged(const ::tools::Rectangle& rRect);

    /** Create an accessible object representing the specified window.

        Override this method to provide view mode specific objects.  The

        default implementation returns an empty reference.

        @param pWindow

            Make the document displayed in this window accessible.

        @return

            This default implementation returns an empty reference.

    */

    virtual rtl::Reference<comphelper::OAccessible>

    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;

    /** Return the window updater of this view shell.

        @return

            In rare circumstances the returned pointer may be <null/>,

            i.e. when no memory is available anymore.

    */

    ::sd::WindowUpdater* GetWindowUpdater() const;

    /** Return the border that is drawn around the actual document view.

        The border contains typically rulers and scroll bars.

    */

    SvBorder GetBorder();

    /** Notify the view shell that its parent window has been resized.

        The ViewShell places and resizes its UI elements accordingly.

        The new size can be obtained from the parent window.

    */

    virtual void Resize();

    /** Set position and size of the GUI elements that are controlled by

        the view shell like rulers and scroll bars as well as the actual

        document view according to the position and size that were given

        with the last Resize() call.

    */

    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;

    /** Return <TRUE/> when the called view shell is the main sub shell of

        its ViewShellBase object, i.e. is display in the center pane.  This

        convenience function is equivalent to comparing the this pointer to

        the result of ViewShellBase::GetViewShell(PT_CENTER).

    */

    bool IsMainViewShell() const;

    /** Set or reset the flag that indicates whether the called shell is the

        one displayed in the center pane.  By default this flag is set to

        <FALSE/>.  For the main view shell it thus has to be set to <TRUE/>.

    */

    void SetIsMainViewShell (bool bIsMainViewShell);

    /** Return a sub controller that implements the view shell specific

        part of the DrawController.

    */

    virtual css::uno::Reference<css::drawing::XDrawSubController> CreateSubController() = 0;

    /** Return the type of the shell.

    */

    SD_DLLPUBLIC ShellType GetShellType() const; //Export for unit test

    /** This method is more or less an alias to Deactivate().  It is called

        before an object of this class is taken from the stack of view

        shells.

        <p>When this method is not called before a view shell is taken from

        a stack then the Deactivate() call from the SFX as a response to

        RemoveSubShell() comes too late when the view shell is not on the

        stack anymore.</p>

    */

    virtual void Shutdown();

    /** This function is called from the underlying ViewShellBase

        object to handle a verb execution request.

    */

    virtual ErrCode DoVerb(sal_Int32 nVerb);

    virtual void UIActivating( SfxInPlaceClient* );

    virtual void UIDeactivated( SfxInPlaceClient* );

    /** Show controls of the UI or hide them, depending on the given flag.

        As a result the border is adapted.

    */

    virtual void ShowUIControls (bool bVisible);

    bool IsPageFlipMode() const;

    bool CanPanAcrossPages() const;

    /** Set the given window as new parent window.  This is not possible for

        all views, so the return value tells the caller if the relocation

        was successful.

    */

    virtual bool RelocateToParentWindow (vcl::Window* pParentWindow);

    /** Depending on the given request create a new page or duplicate an

        existing one.  A new page is created behind the given slide.

        @param rRequest

            The request as passed to an Execute() method.  Its arguments are

            evaluated.  Its slot id determines whether to create or

            duplicate a slide.

        @param pPage

            This page is either duplicated or becomes the predecessor of the

            new slide.  If NULL a duplication request is ignored.  A new

            slide is inserted as first slide.

        @param nInsertPosition

            When -1 (the default) then insert after pPage.  Otherwise insert

            before the given index (of a standard page).

        @return

            The new slide is returned.  If for some reason a new page can

            not be created then NULL is returned.

    */

    virtual SdPage* CreateOrDuplicatePage (

        SfxRequest& rRequest,

        PageKind ePageKind,

        SdPage* pPage,

        const sal_Int32 nInsertPosition = -1);

    /** Called by sd::Window::LoseFocus to enable sd::ViewShell to take action

        when focus is lost.

        e.g. overridden by NotesPanelViewShell

     */

    virtual void onLoseFocus(){};

    /** Called by sd::Window::GrabFocus to enable sd::ViewShell to take action

        when focus is grabbed.

        e.g. overridden by NotesPanelViewShell

     */

    virtual void onGrabFocus(){};

    virtual void RememberCanvasPageVisArea(const ::tools::Rectangle & /*aRect*/) {};

    /// Allows adjusting the point or mark of the selection to a document coordinate.

    void SetCursorMm100Position(const Point& rPosition, bool bPoint, bool bClearMark);

    /// Gets the current selection

    css::uno::Reference<css::datatransfer::XTransferable> GetSelectionTransferable() const;

    /// Allows starting or ending a graphic move or resize action.

    void SetGraphicMm100Position(bool bStart, const Point& rPosition);

    sal_uInt16 GetPageZoom() const;

    void RememberPageZoom(const sal_uInt16 nZoom);

    class Implementation;

protected:

    /** must be called in the beginning of each subclass d'tor.

        disposes and clears both current and old function. */

    void DisposeFunctions();

    friend class ViewShellBase;

    /** Window inside the rulers and scroll bars that shows a view of the

        document.

    */

    VclPtr<sd::Window> mpContentWindow;

    /// Horizontal scroll bar for the current slide is displayed when needed.

    VclPtr<ScrollAdaptor> mpHorizontalScrollBar;

    /// Vertical scroll bar for whole document is always visible.

    VclPtr<ScrollAdaptor> mpVerticalScrollBar;

    /// Horizontal ruler is not shown by default.

    VclPtr<SvxRuler> mpHorizontalRuler;

    /// Vertical ruler is not shown by default.

    VclPtr<SvxRuler> mpVerticalRuler;

    /// Layer tab bar.

    VclPtr<LayerTabBar> mpLayerTabBar;

    /// This flag controls whether the rulers are visible.

    bool mbHasRulers;

    /// The active window.

    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.

    sal_uInt16            mnCanvasPageZoom = 20;

    sal_uInt16            mnNonCanvasPageZoom = 100;

    //af    bool        bPrintDirectSelected;       // Print only selected objects in direct print

    //afString      sPageRange;                 // pagerange if selected objects in direct print

    /** Area covered by all windows, i.e. the area of the parent window

        without the controls at the borders like rulers, scroll bars, tab

        bar, buttons.

        This rectangle may be set in window coordinates (i.e. pixel values

        relative to the parent window).  It is transformed by every call to

        GetAllWindowRectangle() into screen coordinates (relative to the

        upper left corner of the screen.

    */

    ::tools::Rectangle maAllWindowRectangle;

    /// The type of the shell.  Returned by GetShellType().

    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 BroadcastContextForActivation (const bool bIsActivated) override;

    virtual void SetZoomFactor( double fZoomX, double fZoomY );

    /**

        This must be called after the ctor, but before anything else.

        It's the part of construction that is dependent

        on showing the top-level window.

        Showing a window with a11y enabled causes various callbacks

        to be triggered.

        Due to the "virtual methods are not virtual during constructors"

        problem, this is a disaster to call from the ctor

        i.e. construct calls Show, and if a11y is enabled this

        reenters the not-fully constructed object and calls

        CreateAccessibleDocumentView, so if construct is called

        from the ctor then if a derived class is constructed the base-case

        CreateAccessibleDocumentView is used, not the derived

        CreateAccessibleDocumentView. i.e. run smoketest under a11y with

        debugging assertions enabled

    */

    void doShow();

private:

    VclPtr<vcl::Window> mpParentWindow;

    /** This window updater is used to keep all relevant windows up to date

        with reference to the digit language used to display digits in text

        shapes.

    */

    ::std::unique_ptr< ::sd::WindowUpdater> mpWindowUpdater;

    /** Create the rulers.

    */

    void SetupRulers();

    // IASS: Check if commands should be used for SlideShow

    bool useInputForSlideShow() const;

};

SdrView* ViewShell::GetDrawView() const

{

    return static_cast<SdrView*>(mpView);

}

} // end of namespace sd

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */