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