xref: /aoo41x/main/sd/source/ui/inc/ViewShell.hxx (revision 4d7c9de0)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 #ifndef SD_VIEW_SHELL_HXX
25 #define SD_VIEW_SHELL_HXX
26 
27 #include <rtl/ref.hxx>
28 
29 #include <vcl/field.hxx>
30 #include <sfx2/viewsh.hxx>
31 #include <vcl/field.hxx>
32 #include <vcl/prntypes.hxx>
33 #include <svtools/transfer.hxx>
34 #include <comphelper/implementationreference.hxx>
35 #include "glob.hxx"
36 #include "pres.hxx"
37 #include "cfgids.hxx"
38 #include "View.hxx"
39 #include "sddllapi.h"
40 
41 #include <com/sun/star/drawing/XDrawSubController.hpp>
42 #include <memory>
43 #include <boost/shared_ptr.hpp>
44 
45 class SdPage;
46 class SvxRuler;
47 class SdrOle2Obj;		// fuer die, die Teile von SVDRAW rausdefiniert haben
48 class ScrollBarBox;
49 class SdDrawDocument;
50 class ScrollBar;
51 class FmFormShell;
52 class SdOptionsPrintItem;
53 class MultiSelection;
54 
55 extern const String aEmptyStr;
56 
57 namespace com { namespace sun { namespace star {
58 namespace embed {
59     class XEmbeddedObject;
60 }}}}
61 
62 namespace css = ::com::sun::star;
63 
64 namespace sd {
65 
66 class Client;
67 class DrawDocShell;
68 class DrawSubController;
69 class FrameView;
70 class FuPoor;
71 class FuSearch;
72 class SlideShow;
73 class LayerTabBar;
74 class View;
75 class ViewShellBase;
76 class ViewTabBar;
77 class Window;
78 class WindowUpdater;
79 class ZoomList;
80 
81 #undef OUTPUT_DRAWMODE_COLOR
82 #undef OUTPUT_DRAWMODE_CONTRAST
83 
84 /** Base class of the stacked shell hierarchy.
85 
86     <p>Despite its name this class is not a descendant of SfxViewShell
87     but of SfxShell.  Its name expresses the fact that it acts like a
88     view shell.  Beeing a stacked shell rather then being an actual view shell
89     there can be several instances of this class that
90     <ul>
91     <li>all are based on the same view shell and thus show the same
92     document and share common view functionality and</li>
93     <li>are all visible at the same time and live in the same
94     frame.</li>
95     <ul></p>
96 
97     <p>This class replaces the former ViewShell class.</p>
98 */
99 class ViewShell
100     : public SfxShell
101 {
102 public:
103     enum ShellType {
104         ST_NONE,
105         ST_DRAW,         // The Draw application.
106         ST_IMPRESS,      // Main view of the Impress application.
107         ST_NOTES,
108         ST_HANDOUT,
109         ST_OUTLINE,
110         ST_SLIDE_SORTER,
111         ST_PRESENTATION,
112         ST_SIDEBAR
113     };
114     static const int MAX_HSPLIT_CNT = 1;
115     static const int MAX_VSPLIT_CNT = 1;
116     static const int MIN_SCROLLBAR_SIZE	= 50;
117 
118     static const sal_uLong OUTPUT_DRAWMODE_COLOR = DRAWMODE_DEFAULT;
119     static const sal_uLong OUTPUT_DRAWMODE_GRAYSCALE
120         = DRAWMODE_GRAYLINE | DRAWMODE_GRAYFILL
121         | DRAWMODE_BLACKTEXT | DRAWMODE_GRAYBITMAP
122         | DRAWMODE_GRAYGRADIENT;
123     static const int  OUTPUT_DRAWMODE_BLACKWHITE
124         = DRAWMODE_BLACKLINE | DRAWMODE_BLACKTEXT
125         | DRAWMODE_WHITEFILL | DRAWMODE_GRAYBITMAP
126         | DRAWMODE_WHITEGRADIENT;
127     static const int OUTPUT_DRAWMODE_CONTRAST
128         = DRAWMODE_SETTINGSLINE | DRAWMODE_SETTINGSFILL
129         | DRAWMODE_SETTINGSTEXT | DRAWMODE_SETTINGSGRADIENT;
130 
131     TYPEINFO();
132 
133     ViewShell (
134         SfxViewFrame *pFrame,
135         ::Window* pParentWindow,
136         ViewShellBase& rViewShellBase,
137         bool bAllowCenter = true);
138     virtual ~ViewShell (void);
139 
140     /** The Init method has to be called from the outside directly
141         after a new object of this class has been created.  It can be
142         used for that part of the initialisation that can be run only
143         after the creation of the new object is finished.  This
144         includes registration as listener at event broadcasters.
145 
146         Derived classes should call this method at the head of their
147         Init() methods.
148         @param bIsMainViewShell
149             This flag tells the Init() method whether the new ViewShell will
150             be the main view shell.
151     */
152     virtual void Init (bool bIsMainViewShell);
153 
154     /** The Exit() method has to be called before the destructor so that the
155         view shell is still a valid object and can safely call methods that
156         rely on that.
157     */
158     virtual void Exit (void);
159 
160 	void Cancel();
161 
162     /** Return the window that is the parent of all controls of this view
163         shell.  This may or may not be the window of the frame.
164     */
165     inline ::Window* GetParentWindow (void) const;
166 
167 	inline ::sd::View* GetView (void) const;
168 	inline SdrView* GetDrawView (void) const;
169 	SD_DLLPUBLIC DrawDocShell* GetDocSh (void) const;
170 
171 	SdDrawDocument*  GetDoc (void) const;
172 
173     SD_DLLPUBLIC SfxViewFrame* GetViewFrame (void) const;
174 
175     /** The active window is usually the mpContentWindow.  When there is a
176         show running then the active window is a ShowWindow.
177     */
178 	::sd::Window* GetActiveWindow (void) const;
179 
180     /** Set the active window.  When the shell is displayed in the center
181         pane then the window of the ViewShellBase is also set to the given
182         window.
183     */
184 	void SetActiveWindow (::sd::Window* pWindow);
185 
186     /** Return the rectangle that encloses all windows of the view.  That
187         excludes the controls in the frame like rulers, scroll bars, tab
188         bar, and buttons.
189         @return
190             The rectangle is returned in screen coordinates, i.e. pixel
191             values relative to the upper left corner of the screen?.
192     */
193 	const Rectangle& GetAllWindowRect (void);
194 
195 	// Mouse- & Key-Events
196 	virtual void PrePaint();
197 	virtual void Paint (const Rectangle& rRect, ::sd::Window* pWin);
198 	virtual sal_Bool KeyInput(const KeyEvent& rKEvt, ::sd::Window* pWin);
199 	virtual void MouseMove(const MouseEvent& rMEvt, ::sd::Window* pWin);
200 	virtual void MouseButtonUp(const MouseEvent& rMEvt, ::sd::Window* pWin);
201 	virtual void MouseButtonDown(const MouseEvent& rMEvt, ::sd::Window* pWin);
202 	virtual void Command(const CommandEvent& rCEvt, ::sd::Window* pWin);
203 	virtual sal_Bool RequestHelp( const HelpEvent& rEvt, ::sd::Window* pWin );
204     virtual long Notify( NotifyEvent& rNEvt, ::sd::Window* pWin );
205 
206     virtual bool HandleScrollCommand(const CommandEvent& rCEvt, ::sd::Window* pWin);
207 
208 	virtual void Draw(OutputDevice &rDev, const Region &rReg);
209 
210 	virtual void SetUIUnit(FieldUnit eUnit);
211 	virtual void SetDefTabHRuler( sal_uInt16 nDefTab );
212 
213 	const SfxPoolItem* GetNumBulletItem(SfxItemSet& aNewAttr, sal_uInt16& nNumItemId);
214 
215     sal_Bool HasRuler (void);
216 	void SetRuler(sal_Bool bRuler);
217 
218     /** Set internal values of all scroll bars that determine thumb size and
219         position.  The external values like size and position of the scroll
220         bar controls are not modified.
221     */
222 	virtual void UpdateScrollBars (void);
223 	void	Scroll(long nX, long nY);
224 	void	ScrollLines(long nX, long nY);
225 	virtual void	SetZoom(long nZoom);
226 	virtual void	SetZoomRect(const Rectangle& rZoomRect);
227 	void	InitWindows(const Point& rViewOrigin, const Size& rViewSize,
228 						const Point& rWinPos, sal_Bool bUpdate = sal_False);
229 	void	InvalidateWindows();
230     /** This method is still used by the OutlineViewShell to update the
231         model according to the content of the outline view.  This in turn
232         updates the previews in the slide sorter.
233     */
234  	virtual void UpdatePreview (SdPage* pPage, sal_Bool bInit = sal_False);
235 
236 	void    DrawMarkRect(const Rectangle& rRect) const;
237 
238 	void	ExecReq( SfxRequest &rReq );
239 
240 	ZoomList* GetZoomList (void);
241 
242 	FrameView* GetFrameView (void);
243     /** Setting a frame view triggers ReadFrameViewData() for the new
244         frame.
245         @param pFrameView
246             The new frame view that replaces the old one.
247     */
248     void SetFrameView (FrameView* pFrameView);
249 	virtual void  ReadFrameViewData(FrameView* pView);
250 	virtual void  WriteFrameViewData();
251 	virtual void  WriteUserData(String& rString);
252 	virtual void  ReadUserData(const String& rString);
253 
254 	virtual sal_Bool  ActivateObject(SdrOle2Obj* pObj, long nVerb);
255 
256 	/** @returns
257 			current or selected page or 0. This method
258 			will fail in master page mode.
259 
260 		@deprecated, please use getCurrentPage();
261 	*/
262 	virtual SdPage*	GetActualPage() = 0;
263 
264 	/** @returns
265 			current or selected page or 0.
266 	*/
267 	virtual SdPage* getCurrentPage() const = 0;
268 
GetOldFunction() const269 	FunctionReference GetOldFunction() const { return mxOldFunction; }
HasOldFunction() const270 	bool HasOldFunction() const { return mxOldFunction.is(); }
GetCurrentFunction() const271 	FunctionReference GetCurrentFunction() const { return mxCurrentFunction; }
HasCurrentFunction(sal_uInt16 nSID)272 	bool HasCurrentFunction( sal_uInt16 nSID ) { return mxCurrentFunction.is() && (mxCurrentFunction->GetSlotID() == nSID ); }
HasCurrentFunction()273 	bool HasCurrentFunction() { return mxCurrentFunction.is(); }
274 
275     void SetCurrentFunction(const FunctionReference& xFunction);
276     void SetOldFunction(const FunctionReference& xFunction);
277 	void DeactivateCurrentFunction( bool bPermanent = false );
278 
279 	void	SetPageSizeAndBorder(PageKind ePageKind, const Size& rNewSize,
280 							long nLeft, long nRight, long nUpper, long nLower,
281 							sal_Bool bScaleAll, Orientation eOrient, sal_uInt16 nPaperBin,
282 							sal_Bool bBackgroundFullSize );
283 
SetStartShowWithDialog(sal_Bool bIn=sal_True)284 	void	SetStartShowWithDialog( sal_Bool bIn = sal_True ) { mbStartShowWithDialog = bIn; }
IsStartShowWithDialog() const285 	sal_Bool	IsStartShowWithDialog() const { return mbStartShowWithDialog; }
286 
GetPrintedHandoutPageNum(void) const287 	sal_uInt16 GetPrintedHandoutPageNum (void) const { return mnPrintedHandoutPageNum; }
SetPrintedHandoutPageNum(sal_uInt16 nPageNumber)288 	void SetPrintedHandoutPageNum (sal_uInt16 nPageNumber) {mnPrintedHandoutPageNum=nPageNumber; }
289 
GetPrintedHandoutPageCount(void) const290     sal_uInt16 GetPrintedHandoutPageCount(void) const { return mnPrintedHandoutPageCount; }
SetPrintedHandoutPageCount(sal_uInt16 nPageCount)291     void SetPrintedHandoutPageCount (sal_uInt16 nPageCount) {mnPrintedHandoutPageCount=nPageCount; }
292 
293 	virtual sal_uInt16 PrepareClose( sal_Bool bUI = sal_True, sal_Bool bForBrowsing = sal_False );
294 
295 	void GetMenuState(SfxItemSet& rSet);
296 
297 	virtual sal_Int8 AcceptDrop( const AcceptDropEvent& rEvt, DropTargetHelper& rTargetHelper,
298                                  ::sd::Window* pTargetWindow, sal_uInt16 nPage, sal_uInt16 nLayer );
299 	virtual sal_Int8 ExecuteDrop( const ExecuteDropEvent& rEvt, DropTargetHelper& rTargetHelper,
300                                   ::sd::Window* pTargetWindow, sal_uInt16 nPage, sal_uInt16 nLayer );
301 
302     virtual void WriteUserDataSequence ( ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >&, sal_Bool bBrowse = sal_False );
303     virtual void ReadUserDataSequence ( const ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >&, sal_Bool bBrowse = sal_False );
304 
305 	/** this method is called when the visible area of the view from this viewshell is changed */
306 	virtual void VisAreaChanged(const Rectangle& rRect);
307 
308     /** Create an accessible object representing the specified window.
309 	    Overload this method to provide view mode specific objects.  The
310 	    default implementation returns an empty reference.
311         @param pWindow
312             Make the document displayed in this window accessible.
313         @return
314             This default implementation returns an empty reference.
315     */
316     virtual ::com::sun::star::uno::Reference<
317         ::com::sun::star::accessibility::XAccessible>
318         CreateAccessibleDocumentView (::sd::Window* pWindow);
319 
320 	virtual void SwitchViewFireFocus( ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > xAcc );
321 	virtual void SwitchActiveViewFireFocus( );
322 	// Move these two methods from DrawViewShell to enable slide show view
323 	void	NotifyAccUpdate();
324 	void	fireSwitchCurrentPage(sal_Int32 pageIndex);
325 	void SetWinViewPos(const Point& rWinPos, bool bUpdate);
326 	Point GetWinViewPos() const;
327 	Point GetViewOrigin() const;
328 
329     /** Return the window updater of this view shell.
330         @return
331             In rare circumstances the returned pointer may be <null/>,
332             i.e. when no memory is available anymore.
333     */
334     ::sd::WindowUpdater* GetWindowUpdater (void) const;
335 
336     /** Return the border that is drawn arround the actual document view.
337         The border contains typically rulers and scroll bars.
338         @param bOuterResize
339             When this flag is <TRUE/> then the border is used for an
340             OuterResizePixel(), i.e. there is a given window size and the
341             border elements are placed inside so that the document view has
342             the given window size minus the border.
343             When the flag is <FALSE/> then the border is used for an
344             InnerResizePixel(), i.e. the document view has a given size and
345             the border is placed outside.  In this scenario the parent
346             window has the size of the document view plus the border.
347     */
348     SvBorder GetBorder (bool bOuterResize);
349 
350     /** Notify the view shell that its parent window has been resized.
351         The ViewShell places and resizes its UI elements accordingly.
352         The new size can be obtained from the parent window.
353     */
354     virtual void Resize (void);
355 
356     /** Set the position and size of the area which contains the GUI
357         elements like rulers, sliders, and buttons as well as the document
358         view.  Both size and position are expected to be in pixel
359         coordinates.  The positions and sizes of the mentioned GUI elements
360         are updated as well.
361 
362         <p> This method is implemented by first setting copying the given
363         values to internal variables and then calling the
364         <type>ArrangeGUIElements</type> method which performs the actual
365         work of sizeing and arranging the UI elements accordingly.</p>
366         @param rPos
367             The position of the enclosing window relative to the document
368             window.  This is only interesting if a Draw/Impress document
369             view is embedded as OLE object into another document view.  For
370             normal documents this position is (0,0).
371         @param rSize
372             The new size in pixel.
373     */
374     // This is to be replaced by Resize.
375     //	virtual void AdjustPosSizePixel(const Point &rPos, const Size &rSize);
376 
377     /** Set position and size of the GUI elements that are controllerd by
378         the view shell like rulers and scroll bars as well as the actual
379         document view according to the position and size that were given
380         with the last Resize() call.
381     */
382     virtual void ArrangeGUIElements (void);
383 
384     //	virtual void OuterResizePixel(const Point &rPos, const Size &rSize);
385     //	virtual void InnerResizePixel(const Point &rPos, const Size &rSize);
386 
387     ViewShellBase& GetViewShellBase (void) const;
388 
389     /** Return <TRUE/> when the called view shell is the main sub shell of
390         its ViewShellBase object, i.e. is display in the center pane.  This
391         convenience function is equivalent to comparing the this pointer to
392         the result of ViewShellBase::GetViewShell(PT_CENTER).
393     */
394     bool IsMainViewShell (void) const;
395 
396     /** Set or reset the flag that indicates whether the called shell is the
397         one displayed in the center pane.  By default this flag is set to
398         <FALSE/>.  For the main view shell it thus has to be set to <TRUE/>.
399     */
400     void SetIsMainViewShell (bool bIsMainViewShell);
401 
402     /** Return a sub controller that implements the view shell specific
403         part of the DrawController.
404     */
405     virtual css::uno::Reference<css::drawing::XDrawSubController> CreateSubController (void) = 0;
406 
407     /** Return the type of the shell.
408     */
409     virtual ShellType GetShellType (void) const;
410 
411     /** This method is more or less an alias to Deactivate().  It is called
412         before an object of this class is taken from the stack of view
413         shells.
414 
415         <p>When this method is not called before a view shell is taken from
416         a stack then the Deactivate() call from the SFX as a response to
417         RemoveSubShell() comes to late when the view shell is not on the
418         stack anymore.</p>
419     */
420     virtual void Shutdown (void);
421 
422     /** This function is called from the underlying ViewShellBase
423         object to handle a verb execution request.
424     */
425     virtual ErrCode DoVerb (long nVerb);
426 
427     virtual void UIActivating( SfxInPlaceClient* );
428     virtual void UIDeactivated( SfxInPlaceClient* );
429 
430     /** Show controls of the UI or hide them, depending on the given flag.
431         As a result the border is adapted.
432     */
433 	virtual void ShowUIControls (bool bVisible = true);
434 	sal_Bool IsPageFlipMode(void) const;
435 
436     /** Set the given window as new parent window.  This is not possible for
437         all views, so the return value tells the caller if the relocation
438         was successfull.
439     */
440     virtual bool RelocateToParentWindow (::Window* pParentWindow);
441 
442     /** Depending on the given request create a new page or duplicate an
443         existing one.  A new page is created behind the given slide.
444         @param rRequest
445             The request as passed to an Execute() method.  Its arguments are
446             evaluated.  Its slot id determines whether to create or
447             duplicate a slide.
448         @param pPage
449             This page is either duplicated or becomes the predecessor of the
450             new slide.  If NULL a duplication request is ignored.  A new
451             slide is inserted as first slide.
452         @param nInsertPosition
453             When -1 (the default) then insert after pPage.  Otherwise insert
454             before the given index (of a standard page).
455         @return
456             The new slide is returned.  If for some reason a new page can
457             not be created then NULL is returned.
458     */
459     virtual SdPage* CreateOrDuplicatePage (
460         SfxRequest& rRequest,
461         PageKind ePageKind,
462         SdPage* pPage,
463         const sal_Int32 nInsertPosition = -1);
464 
465 
466     class Implementation;
467 
468 protected:
469 	/** must be called in the beginning of each subclass d'tor.
470 		disposes and clears both current and old function. */
471 	void DisposeFunctions();
472 
473     friend class ViewShellBase;
474 
475     /** Window inside the rulers and scroll bars that shows a view of the
476         document.
477     */
478 
479     ::boost::shared_ptr<sd::Window> mpContentWindow;
480 
481     /// Horizontal scroll bar for the current slide is displayed when needed.
482     ::boost::shared_ptr<ScrollBar> mpHorizontalScrollBar;
483     /// Vertical scroll bar for whole document is always visible.
484     ::boost::shared_ptr<ScrollBar> mpVerticalScrollBar;
485 	/// Horizontal ruler is not shown by default.
486 	::std::auto_ptr<SvxRuler> mpHorizontalRuler;
487     /// Vertical ruler is not shown by default.
488 	::std::auto_ptr<SvxRuler> mpVerticalRuler;
489     /// Filler of the little square enclosed by the two scroll bars.
490     ::boost::shared_ptr<ScrollBarBox> mpScrollBarBox;
491     /// Layer tab bar.
492     ::std::auto_ptr<LayerTabBar> mpLayerTabBar;
493 
494     /// This flag controls whether the rulers are visible.
495 	bool mbHasRulers;
496 
497 	/// The active window.
498 	::sd::Window* mpActiveWindow;
499 	::sd::View* mpView;
500 	FrameView*	mpFrameView;
501 
502 	FunctionReference	mxCurrentFunction;
503 	FunctionReference	mxOldFunction;
504 	ZoomList*	mpZoomList;
505 
506 	Point		maViewPos;
507 	Size		maViewSize;
508 	Size		maScrBarWH;
509 
510 	sal_Bool		mbCenterAllowed; 		  // wird an Fenster weitergegeben
511 
512 	sal_Bool		mbStartShowWithDialog;	// Praesentation wurde ueber Dialog gestartet
513 	sal_uInt16		mnPrintedHandoutPageNum; // Page number of the handout page that is to be printed.
514     sal_uInt16      mnPrintedHandoutPageCount; // Page count of the handout pages that are to be printed.
515 
516     //af	sal_Bool		bPrintDirectSelected;		// Print only selected objects in direct print
517 	//afString		sPageRange;					// pagerange if selected objects in direct print
518 
519     /** Area covered by all windows, i.e. the area of the parent window
520         without the controls at the borders like rulers, scroll bars, tab
521         bar, buttons.
522         This rectangle may be set in window coordinates (i.e. pixel values
523         relative to the parent window).  It is transformed by every call to
524         GetAllWindowRectangle() into screen coordinates (relative to the
525         upper left corner of the screen.
526     */
527     Rectangle maAllWindowRectangle;
528 
529     /// The type of the shell.  Returned by GetShellType().
530     ShellType meShellType;
531 
532     ::std::auto_ptr<Implementation> mpImpl;
533 
534 	// #96090# Support methods for centralized UNDO/REDO
535 	virtual ::svl::IUndoManager* ImpGetUndoManager (void) const;
536 	void ImpGetUndoStrings(SfxItemSet &rSet) const;
537 	void ImpGetRedoStrings(SfxItemSet &rSet) const;
538 	void ImpSidUndo(sal_Bool bDrawViewShell, SfxRequest& rReq);
539 	void ImpSidRedo(sal_Bool bDrawViewShell, SfxRequest& rReq);
540 
541 	DECL_LINK( HScrollHdl, ScrollBar * );
542 	DECL_LINK( VScrollHdl, ScrollBar * );
543 
544 	// virt. Scroll-Handler, hier koennen sich abgeleitete Klassen einklinken
545 	virtual long VirtHScrollHdl(ScrollBar* pHScroll);
546 	virtual long VirtVScrollHdl(ScrollBar* pVScroll);
547 
548 	// virtuelle Funktionen fuer Lineal-Handling
549 	virtual SvxRuler* CreateHRuler(::sd::Window* pWin, sal_Bool bIsFirst);
550 	virtual SvxRuler* CreateVRuler(::sd::Window* pWin);
551 	virtual void UpdateHRuler();
552 	virtual void UpdateVRuler();
553 
554 	// Zeiger auf ein zusaetzliches Control im horizontalen ScrollBar
555 	// abgeleiteter Klassen (z.B. ein TabBar) zurueckgeben
556 	virtual long GetHCtrlWidth();
557 
558 	virtual void Activate(sal_Bool IsMDIActivate);
559 	virtual void Deactivate(sal_Bool IsMDIActivate);
560 
561 	virtual void SetZoomFactor( const Fraction &rZoomX,
562 								const Fraction &rZoomY );
563 
564 private:
565     ::Window* mpParentWindow;
566     /** This window updater is used to keep all relevant windows up to date
567         with reference to the digit langugage used to display digits in text
568         shapes.
569     */
570     ::std::auto_ptr< ::sd::WindowUpdater> mpWindowUpdater;
571 
572     /** Code common to all constructors.  It generally is a bad idea
573         to call this function from outside a constructor.
574     */
575 	void construct (void);
576 
577     DECL_LINK(FrameWindowEventListener, VclSimpleEvent*);
578 
579     /** Create the rulers.
580     */
581     void SetupRulers (void);
582 };
583 
584 
585 
586 
GetParentWindow(void) const587 ::Window* ViewShell::GetParentWindow (void) const
588 {
589     return mpParentWindow;
590 }
591 
GetView(void) const592 ::sd::View* ViewShell::GetView (void) const
593 {
594     return mpView;
595 }
596 
GetDrawView(void) const597 SdrView* ViewShell::GetDrawView (void) const
598 {
599     return static_cast<SdrView*>(mpView);
600 }
601 
602 } // end of namespace sd
603 
604 #endif
605