diff options
Diffstat (limited to 'sd/source/ui/inc/ViewShell.hxx')
| -rwxr-xr-x | sd/source/ui/inc/ViewShell.hxx | 601 |
1 files changed, 601 insertions, 0 deletions
diff --git a/sd/source/ui/inc/ViewShell.hxx b/sd/source/ui/inc/ViewShell.hxx new file mode 100755 index 000000000000..ffefb9de7359 --- /dev/null +++ b/sd/source/ui/inc/ViewShell.hxx @@ -0,0 +1,601 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef SD_VIEW_SHELL_HXX +#define SD_VIEW_SHELL_HXX + +#include <rtl/ref.hxx> + +#include <vcl/field.hxx> +#include <sfx2/viewsh.hxx> +#include <vcl/field.hxx> +#include <vcl/prntypes.hxx> +#include <svtools/transfer.hxx> +#include <comphelper/implementationreference.hxx> +#include "glob.hxx" +#include "pres.hxx" +#include "cfgids.hxx" +#ifndef _SD_VIEW_HXX +#include "View.hxx" +#endif +#include "sddllapi.h" + +#include <com/sun/star/drawing/XDrawSubController.hpp> +#include <memory> +#include <boost/shared_ptr.hpp> + +class SdPage; +class SvxRuler; +class SdrOle2Obj; // fuer die, die Teile von SVDRAW rausdefiniert haben +class ScrollBarBox; +class SdDrawDocument; +class ScrollBar; +class FmFormShell; +class SdOptionsPrintItem; +class MultiSelection; + +extern const String aEmptyStr; + +namespace com { namespace sun { namespace star { +namespace embed { + class XEmbeddedObject; +}}}} + +namespace css = ::com::sun::star; + +namespace sd { + +class Client; +class DrawDocShell; +class DrawSubController; +class FrameView; +class FuPoor; +class FuSearch; +class SlideShow; +class LayerTabBar; +class View; +class ViewShellBase; +class ViewTabBar; +class Window; +class WindowUpdater; +class ZoomList; + +#undef OUTPUT_DRAWMODE_COLOR +#undef OUTPUT_DRAWMODE_CONTRAST + +/** 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. Beeing a stacked shell rather then 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 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_TASK_PANE + }; + static const int MAX_HSPLIT_CNT = 1; + static const int MAX_VSPLIT_CNT = 1; + static const int MIN_SCROLLBAR_SIZE = 50; + + static const ULONG OUTPUT_DRAWMODE_COLOR = DRAWMODE_DEFAULT; + static const ULONG OUTPUT_DRAWMODE_GRAYSCALE + = DRAWMODE_GRAYLINE | DRAWMODE_GRAYFILL + | DRAWMODE_BLACKTEXT | DRAWMODE_GRAYBITMAP + | DRAWMODE_GRAYGRADIENT; + static const int OUTPUT_DRAWMODE_BLACKWHITE + = DRAWMODE_BLACKLINE | DRAWMODE_BLACKTEXT + | DRAWMODE_WHITEFILL | DRAWMODE_GRAYBITMAP + | DRAWMODE_WHITEGRADIENT; + static const int OUTPUT_DRAWMODE_CONTRAST + = DRAWMODE_SETTINGSLINE | DRAWMODE_SETTINGSFILL + | DRAWMODE_SETTINGSTEXT | DRAWMODE_SETTINGSGRADIENT; + + TYPEINFO(); + + ViewShell ( + SfxViewFrame *pFrame, + ::Window* pParentWindow, + ViewShellBase& rViewShellBase, + bool bAllowCenter = true); + virtual ~ViewShell (void); + + /** 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. + */ + virtual void Exit (void); + + 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. + */ + inline ::Window* GetParentWindow (void) const; + + inline ::sd::View* GetView (void) const; + inline SdrView* GetDrawView (void) const; + SD_DLLPUBLIC DrawDocShell* GetDocSh (void) const; + + SdDrawDocument* GetDoc (void) const; + + SD_DLLPUBLIC SfxViewFrame* GetViewFrame (void) const; + + /** The active window is usually the mpContentWindow. When there is a + show running then the active window is a ShowWindow. + */ + ::sd::Window* GetActiveWindow (void) 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 Rectangle& GetAllWindowRect (void); + + // Mouse- & Key-Events + virtual void PrePaint(); + virtual void Paint (const 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); + virtual BOOL RequestHelp( const HelpEvent& rEvt, ::sd::Window* pWin ); + virtual long Notify( NotifyEvent& rNEvt, ::sd::Window* pWin ); + + BOOL HandleScrollCommand(const CommandEvent& rCEvt, ::sd::Window* pWin); + + virtual void Draw(OutputDevice &rDev, const Region &rReg); + + virtual void SetUIUnit(FieldUnit eUnit); + virtual void SetDefTabHRuler( UINT16 nDefTab ); + + BOOL HasRuler (void); + void SetRuler(BOOL bRuler); + + /** 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); + void Scroll(long nX, long nY); + void ScrollLines(long nX, long nY); + virtual void SetZoom(long nZoom); + virtual void SetZoomRect(const 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, BOOL bInit = FALSE); + + void DrawMarkRect(const Rectangle& rRect) const; + + void ExecReq( SfxRequest &rReq ); + + ZoomList* GetZoomList (void); + + FrameView* GetFrameView (void); + /** 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(); + virtual void WriteUserData(String& rString); + virtual void ReadUserData(const String& rString); + + virtual BOOL ActivateObject(SdrOle2Obj* pObj, long 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; + + FunctionReference GetOldFunction() const { return mxOldFunction; } + bool HasOldFunction() const { return mxOldFunction.is(); } + FunctionReference GetCurrentFunction() const { return mxCurrentFunction; } + bool HasCurrentFunction( USHORT nSID ) { return mxCurrentFunction.is() && (mxCurrentFunction->GetSlotID() == nSID ); } + bool HasCurrentFunction() { return mxCurrentFunction.is(); } + + void SetCurrentFunction(const FunctionReference& xFunction); + void SetOldFunction(const FunctionReference& xFunction); + void DeactivateCurrentFunction( bool bPermanent = false ); + + void SetPageSizeAndBorder(PageKind ePageKind, const Size& rNewSize, + long nLeft, long nRight, long nUpper, long nLower, + BOOL bScaleAll, Orientation eOrient, USHORT nPaperBin, + BOOL bBackgroundFullSize ); + + void SetStartShowWithDialog( BOOL bIn = TRUE ) { mbStartShowWithDialog = bIn; } + BOOL IsStartShowWithDialog() const { return mbStartShowWithDialog; } + + USHORT GetPrintedHandoutPageNum (void) const { return mnPrintedHandoutPageNum; } + void SetPrintedHandoutPageNum (USHORT nPageNumber) {mnPrintedHandoutPageNum=nPageNumber; } + + USHORT GetPrintedHandoutPageCount(void) const { return mnPrintedHandoutPageCount; } + void SetPrintedHandoutPageCount (USHORT nPageCount) {mnPrintedHandoutPageCount=nPageCount; } + + virtual USHORT PrepareClose( BOOL bUI = TRUE, BOOL bForBrowsing = FALSE ); + + void GetMenuState(SfxItemSet& rSet); + + virtual sal_Int8 AcceptDrop( const AcceptDropEvent& rEvt, DropTargetHelper& rTargetHelper, + ::sd::Window* pTargetWindow, USHORT nPage, USHORT nLayer ); + virtual sal_Int8 ExecuteDrop( const ExecuteDropEvent& rEvt, DropTargetHelper& rTargetHelper, + ::sd::Window* pTargetWindow, USHORT nPage, USHORT nLayer ); + + virtual void WriteUserDataSequence ( ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >&, sal_Bool bBrowse = sal_False ); + virtual void ReadUserDataSequence ( const ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >&, sal_Bool bBrowse = sal_False ); + + /** this method is called when the visible area of the view from this viewshell is changed */ + virtual void VisAreaChanged(const Rectangle& rRect); + + /** Create an accessible object representing the specified window. + Overload 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 ::com::sun::star::uno::Reference< + ::com::sun::star::accessibility::XAccessible> + CreateAccessibleDocumentView (::sd::Window* pWindow); + + void SetWinViewPos(const Point& rWinPos, bool bUpdate); + Point GetWinViewPos() const; + Point 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 (void) const; + + /** Return the border that is drawn arround the actual document view. + The border contains typically rulers and scroll bars. + @param bOuterResize + When this flag is <TRUE/> then the border is used for an + OuterResizePixel(), i.e. there is a given window size and the + border elements are placed inside so that the document view has + the given window size minus the border. + When the flag is <FALSE/> then the border is used for an + InnerResizePixel(), i.e. the document view has a given size and + the border is placed outside. In this scenario the parent + window has the size of the document view plus the border. + */ + SvBorder GetBorder (bool bOuterResize); + + /** 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 (void); + + /** Set the position and size of the area which contains the GUI + elements like rulers, sliders, and buttons as well as the document + view. Both size and position are expected to be in pixel + coordinates. The positions and sizes of the mentioned GUI elements + are updated as well. + + <p> This method is implemented by first setting copying the given + values to internal variables and then calling the + <type>ArrangeGUIElements</type> method which performs the actual + work of sizeing and arranging the UI elements accordingly.</p> + @param rPos + The position of the enclosing window relative to the document + window. This is only interesting if a Draw/Impress document + view is embedded as OLE object into another document view. For + normal documents this position is (0,0). + @param rSize + The new size in pixel. + */ + // This is to be replaced by Resize. + // virtual void AdjustPosSizePixel(const Point &rPos, const Size &rSize); + + /** Set position and size of the GUI elements that are controllerd 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 (void); + + // virtual void OuterResizePixel(const Point &rPos, const Size &rSize); + // virtual void InnerResizePixel(const Point &rPos, const Size &rSize); + + ViewShellBase& GetViewShellBase (void) 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 (void) 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 (void) = 0; + + /** Return the type of the shell. + */ + virtual ShellType GetShellType (void) const; + + /** 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 to late when the view shell is not on the + stack anymore.</p> + */ + virtual void Shutdown (void); + + /** This function is called from the underlying ViewShellBase + object to handle a verb execution request. + */ + virtual ErrCode DoVerb (long 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 = true); + BOOL IsPageFlipMode(void) 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 successfull. + */ + virtual bool RelocateToParentWindow (::Window* pParentWindow); + + void AdaptDefaultsForChart( + const ::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject > & xEmbObj ); + + 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. + */ + + ::boost::shared_ptr<sd::Window> mpContentWindow; + + /// Horizontal scroll bar for the current slide is displayed when needed. + ::boost::shared_ptr<ScrollBar> mpHorizontalScrollBar; + /// Vertical scroll bar for whole document is always visible. + ::boost::shared_ptr<ScrollBar> mpVerticalScrollBar; + /// Horizontal ruler is not shown by default. + ::std::auto_ptr<SvxRuler> mpHorizontalRuler; + /// Vertical ruler is not shown by default. + ::std::auto_ptr<SvxRuler> mpVerticalRuler; + /// Filler of the little square enclosed by the two scroll bars. + ::boost::shared_ptr<ScrollBarBox> mpScrollBarBox; + /// Layer tab bar. + ::std::auto_ptr<LayerTabBar> mpLayerTabBar; + + /// This flag controls whether the rulers are visible. + bool mbHasRulers; + + /// The active window. + ::sd::Window* mpActiveWindow; + ::sd::View* mpView; + FrameView* mpFrameView; + + FunctionReference mxCurrentFunction; + FunctionReference mxOldFunction; + ZoomList* mpZoomList; + + Point maViewPos; + Size maViewSize; + Size maScrBarWH; + + BOOL mbCenterAllowed; // wird an Fenster weitergegeben + + BOOL mbStartShowWithDialog; // Praesentation wurde ueber Dialog gestartet + USHORT mnPrintedHandoutPageNum; // Page number of the handout page that is to be printed. + USHORT 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 + + /** 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. + */ + Rectangle maAllWindowRectangle; + + /// The type of the shell. Returned by GetShellType(). + ShellType meShellType; + + ::std::auto_ptr<Implementation> mpImpl; + + // #96090# Support methods for centralized UNDO/REDO + virtual SfxUndoManager* ImpGetUndoManager (void) const; + void ImpGetUndoStrings(SfxItemSet &rSet) const; + void ImpGetRedoStrings(SfxItemSet &rSet) const; + void ImpSidUndo(BOOL bDrawViewShell, SfxRequest& rReq); + void ImpSidRedo(BOOL bDrawViewShell, SfxRequest& rReq); + + DECL_LINK( HScrollHdl, ScrollBar * ); + DECL_LINK( VScrollHdl, ScrollBar * ); + + // virt. Scroll-Handler, hier koennen sich abgeleitete Klassen einklinken + virtual long VirtHScrollHdl(ScrollBar* pHScroll); + virtual long VirtVScrollHdl(ScrollBar* pVScroll); + + // virtuelle Funktionen fuer Lineal-Handling + virtual SvxRuler* CreateHRuler(::sd::Window* pWin, BOOL bIsFirst); + virtual SvxRuler* CreateVRuler(::sd::Window* pWin); + virtual void UpdateHRuler(); + virtual void UpdateVRuler(); + + // Zeiger auf ein zusaetzliches Control im horizontalen ScrollBar + // abgeleiteter Klassen (z.B. ein TabBar) zurueckgeben + virtual long GetHCtrlWidth(); + + virtual void Activate(BOOL IsMDIActivate); + virtual void Deactivate(BOOL IsMDIActivate); + + virtual void SetZoomFactor( const Fraction &rZoomX, + const Fraction &rZoomY ); + + /** 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. + @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); + +private: + ::Window* mpParentWindow; + /** This window updater is used to keep all relevant windows up to date + with reference to the digit langugage used to display digits in text + shapes. + */ + ::std::auto_ptr< ::sd::WindowUpdater> mpWindowUpdater; + + /** Code common to all constructors. It generally is a bad idea + to call this function from outside a constructor. + */ + void construct (void); + + DECL_LINK(FrameWindowEventListener, VclSimpleEvent*); + + /** Create the rulers. + */ + void SetupRulers (void); +}; + + + + +::Window* ViewShell::GetParentWindow (void) const +{ + return mpParentWindow; +} + +::sd::View* ViewShell::GetView (void) const +{ + return mpView; +} + +SdrView* ViewShell::GetDrawView (void) const +{ + return static_cast<SdrView*>(mpView); +} + +} // end of namespace sd + +#endif |