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 #ifndef _SD_VIEW_HXX 39 #include "View.hxx" 40 #endif 41 #include "sddllapi.h" 42 43 #include <com/sun/star/drawing/XDrawSubController.hpp> 44 #include <memory> 45 #include <boost/shared_ptr.hpp> 46 47 class SdPage; 48 class SvxRuler; 49 class SdrOle2Obj; // fuer die, die Teile von SVDRAW rausdefiniert haben 50 class ScrollBarBox; 51 class SdDrawDocument; 52 class ScrollBar; 53 class FmFormShell; 54 class SdOptionsPrintItem; 55 class MultiSelection; 56 57 extern const String aEmptyStr; 58 59 namespace com { namespace sun { namespace star { 60 namespace embed { 61 class XEmbeddedObject; 62 }}}} 63 64 namespace css = ::com::sun::star; 65 66 namespace sd { 67 68 class Client; 69 class DrawDocShell; 70 class DrawSubController; 71 class FrameView; 72 class FuPoor; 73 class FuSearch; 74 class SlideShow; 75 class LayerTabBar; 76 class View; 77 class ViewShellBase; 78 class ViewTabBar; 79 class Window; 80 class WindowUpdater; 81 class ZoomList; 82 83 #undef OUTPUT_DRAWMODE_COLOR 84 #undef OUTPUT_DRAWMODE_CONTRAST 85 86 /** Base class of the stacked shell hierarchy. 87 88 <p>Despite its name this class is not a descendant of SfxViewShell 89 but of SfxShell. Its name expresses the fact that it acts like a 90 view shell. Beeing a stacked shell rather then being an actual view shell 91 there can be several instances of this class that 92 <ul> 93 <li>all are based on the same view shell and thus show the same 94 document and share common view functionality and</li> 95 <li>are all visible at the same time and live in the same 96 frame.</li> 97 <ul></p> 98 99 <p>This class replaces the former ViewShell class.</p> 100 */ 101 class ViewShell 102 : public SfxShell 103 { 104 public: 105 enum ShellType { 106 ST_NONE, 107 ST_DRAW, // The Draw application. 108 ST_IMPRESS, // Main view of the Impress application. 109 ST_NOTES, 110 ST_HANDOUT, 111 ST_OUTLINE, 112 ST_SLIDE_SORTER, 113 ST_PRESENTATION, 114 ST_TASK_PANE 115 }; 116 static const int MAX_HSPLIT_CNT = 1; 117 static const int MAX_VSPLIT_CNT = 1; 118 static const int MIN_SCROLLBAR_SIZE = 50; 119 120 static const sal_uLong OUTPUT_DRAWMODE_COLOR = DRAWMODE_DEFAULT; 121 static const sal_uLong OUTPUT_DRAWMODE_GRAYSCALE 122 = DRAWMODE_GRAYLINE | DRAWMODE_GRAYFILL 123 | DRAWMODE_BLACKTEXT | DRAWMODE_GRAYBITMAP 124 | DRAWMODE_GRAYGRADIENT; 125 static const int OUTPUT_DRAWMODE_BLACKWHITE 126 = DRAWMODE_BLACKLINE | DRAWMODE_BLACKTEXT 127 | DRAWMODE_WHITEFILL | DRAWMODE_GRAYBITMAP 128 | DRAWMODE_WHITEGRADIENT; 129 static const int OUTPUT_DRAWMODE_CONTRAST 130 = DRAWMODE_SETTINGSLINE | DRAWMODE_SETTINGSFILL 131 | DRAWMODE_SETTINGSTEXT | DRAWMODE_SETTINGSGRADIENT; 132 133 TYPEINFO(); 134 135 ViewShell ( 136 SfxViewFrame *pFrame, 137 ::Window* pParentWindow, 138 ViewShellBase& rViewShellBase, 139 bool bAllowCenter = true); 140 virtual ~ViewShell (void); 141 142 /** The Init method has to be called from the outside directly 143 after a new object of this class has been created. It can be 144 used for that part of the initialisation that can be run only 145 after the creation of the new object is finished. This 146 includes registration as listener at event broadcasters. 147 148 Derived classes should call this method at the head of their 149 Init() methods. 150 @param bIsMainViewShell 151 This flag tells the Init() method whether the new ViewShell will 152 be the main view shell. 153 */ 154 virtual void Init (bool bIsMainViewShell); 155 156 /** The Exit() method has to be called before the destructor so that the 157 view shell is still a valid object and can safely call methods that 158 rely on that. 159 */ 160 virtual void Exit (void); 161 162 void Cancel(); 163 164 /** Return the window that is the parent of all controls of this view 165 shell. This may or may not be the window of the frame. 166 */ 167 inline ::Window* GetParentWindow (void) const; 168 169 inline ::sd::View* GetView (void) const; 170 inline SdrView* GetDrawView (void) const; 171 SD_DLLPUBLIC DrawDocShell* GetDocSh (void) const; 172 173 SdDrawDocument* GetDoc (void) const; 174 175 SD_DLLPUBLIC SfxViewFrame* GetViewFrame (void) const; 176 177 /** The active window is usually the mpContentWindow. When there is a 178 show running then the active window is a ShowWindow. 179 */ 180 ::sd::Window* GetActiveWindow (void) const; 181 182 /** Set the active window. When the shell is displayed in the center 183 pane then the window of the ViewShellBase is also set to the given 184 window. 185 */ 186 void SetActiveWindow (::sd::Window* pWindow); 187 188 /** Return the rectangle that encloses all windows of the view. That 189 excludes the controls in the frame like rulers, scroll bars, tab 190 bar, and buttons. 191 @return 192 The rectangle is returned in screen coordinates, i.e. pixel 193 values relative to the upper left corner of the screen?. 194 */ 195 const Rectangle& GetAllWindowRect (void); 196 197 // Mouse- & Key-Events 198 virtual void PrePaint(); 199 virtual void Paint (const Rectangle& rRect, ::sd::Window* pWin); 200 virtual sal_Bool KeyInput(const KeyEvent& rKEvt, ::sd::Window* pWin); 201 virtual void MouseMove(const MouseEvent& rMEvt, ::sd::Window* pWin); 202 virtual void MouseButtonUp(const MouseEvent& rMEvt, ::sd::Window* pWin); 203 virtual void MouseButtonDown(const MouseEvent& rMEvt, ::sd::Window* pWin); 204 virtual void Command(const CommandEvent& rCEvt, ::sd::Window* pWin); 205 virtual sal_Bool RequestHelp( const HelpEvent& rEvt, ::sd::Window* pWin ); 206 virtual long Notify( NotifyEvent& rNEvt, ::sd::Window* pWin ); 207 208 virtual bool HandleScrollCommand(const CommandEvent& rCEvt, ::sd::Window* pWin); 209 210 virtual void Draw(OutputDevice &rDev, const Region &rReg); 211 212 virtual void SetUIUnit(FieldUnit eUnit); 213 virtual void SetDefTabHRuler( sal_uInt16 nDefTab ); 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 269 FunctionReference GetOldFunction() const { return mxOldFunction; } 270 bool HasOldFunction() const { return mxOldFunction.is(); } 271 FunctionReference GetCurrentFunction() const { return mxCurrentFunction; } 272 bool HasCurrentFunction( sal_uInt16 nSID ) { return mxCurrentFunction.is() && (mxCurrentFunction->GetSlotID() == nSID ); } 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 284 void SetStartShowWithDialog( sal_Bool bIn = sal_True ) { mbStartShowWithDialog = bIn; } 285 sal_Bool IsStartShowWithDialog() const { return mbStartShowWithDialog; } 286 287 sal_uInt16 GetPrintedHandoutPageNum (void) const { return mnPrintedHandoutPageNum; } 288 void SetPrintedHandoutPageNum (sal_uInt16 nPageNumber) {mnPrintedHandoutPageNum=nPageNumber; } 289 290 sal_uInt16 GetPrintedHandoutPageCount(void) const { return mnPrintedHandoutPageCount; } 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 void SetWinViewPos(const Point& rWinPos, bool bUpdate); 321 Point GetWinViewPos() const; 322 Point GetViewOrigin() const; 323 324 /** Return the window updater of this view shell. 325 @return 326 In rare circumstances the returned pointer may be <null/>, 327 i.e. when no memory is available anymore. 328 */ 329 ::sd::WindowUpdater* GetWindowUpdater (void) const; 330 331 /** Return the border that is drawn arround the actual document view. 332 The border contains typically rulers and scroll bars. 333 @param bOuterResize 334 When this flag is <TRUE/> then the border is used for an 335 OuterResizePixel(), i.e. there is a given window size and the 336 border elements are placed inside so that the document view has 337 the given window size minus the border. 338 When the flag is <FALSE/> then the border is used for an 339 InnerResizePixel(), i.e. the document view has a given size and 340 the border is placed outside. In this scenario the parent 341 window has the size of the document view plus the border. 342 */ 343 SvBorder GetBorder (bool bOuterResize); 344 345 /** Notify the view shell that its parent window has been resized. 346 The ViewShell places and resizes its UI elements accordingly. 347 The new size can be obtained from the parent window. 348 */ 349 virtual void Resize (void); 350 351 /** Set the position and size of the area which contains the GUI 352 elements like rulers, sliders, and buttons as well as the document 353 view. Both size and position are expected to be in pixel 354 coordinates. The positions and sizes of the mentioned GUI elements 355 are updated as well. 356 357 <p> This method is implemented by first setting copying the given 358 values to internal variables and then calling the 359 <type>ArrangeGUIElements</type> method which performs the actual 360 work of sizeing and arranging the UI elements accordingly.</p> 361 @param rPos 362 The position of the enclosing window relative to the document 363 window. This is only interesting if a Draw/Impress document 364 view is embedded as OLE object into another document view. For 365 normal documents this position is (0,0). 366 @param rSize 367 The new size in pixel. 368 */ 369 // This is to be replaced by Resize. 370 // virtual void AdjustPosSizePixel(const Point &rPos, const Size &rSize); 371 372 /** Set position and size of the GUI elements that are controllerd by 373 the view shell like rulers and scroll bars as well as the actual 374 document view according to the position and size that were given 375 with the last Resize() call. 376 */ 377 virtual void ArrangeGUIElements (void); 378 379 // virtual void OuterResizePixel(const Point &rPos, const Size &rSize); 380 // virtual void InnerResizePixel(const Point &rPos, const Size &rSize); 381 382 ViewShellBase& GetViewShellBase (void) const; 383 384 /** Return <TRUE/> when the called view shell is the main sub shell of 385 its ViewShellBase object, i.e. is display in the center pane. This 386 convenience function is equivalent to comparing the this pointer to 387 the result of ViewShellBase::GetViewShell(PT_CENTER). 388 */ 389 bool IsMainViewShell (void) const; 390 391 /** Set or reset the flag that indicates whether the called shell is the 392 one displayed in the center pane. By default this flag is set to 393 <FALSE/>. For the main view shell it thus has to be set to <TRUE/>. 394 */ 395 void SetIsMainViewShell (bool bIsMainViewShell); 396 397 /** Return a sub controller that implements the view shell specific 398 part of the DrawController. 399 */ 400 virtual css::uno::Reference<css::drawing::XDrawSubController> CreateSubController (void) = 0; 401 402 /** Return the type of the shell. 403 */ 404 virtual ShellType GetShellType (void) const; 405 406 /** This method is more or less an alias to Deactivate(). It is called 407 before an object of this class is taken from the stack of view 408 shells. 409 410 <p>When this method is not called before a view shell is taken from 411 a stack then the Deactivate() call from the SFX as a response to 412 RemoveSubShell() comes to late when the view shell is not on the 413 stack anymore.</p> 414 */ 415 virtual void Shutdown (void); 416 417 /** This function is called from the underlying ViewShellBase 418 object to handle a verb execution request. 419 */ 420 virtual ErrCode DoVerb (long nVerb); 421 422 virtual void UIActivating( SfxInPlaceClient* ); 423 virtual void UIDeactivated( SfxInPlaceClient* ); 424 425 /** Show controls of the UI or hide them, depending on the given flag. 426 As a result the border is adapted. 427 */ 428 virtual void ShowUIControls (bool bVisible = true); 429 sal_Bool IsPageFlipMode(void) const; 430 431 /** Set the given window as new parent window. This is not possible for 432 all views, so the return value tells the caller if the relocation 433 was successfull. 434 */ 435 virtual bool RelocateToParentWindow (::Window* pParentWindow); 436 437 /** Depending on the given request create a new page or duplicate an 438 existing one. A new page is created behind the given slide. 439 @param rRequest 440 The request as passed to an Execute() method. Its arguments are 441 evaluated. Its slot id determines whether to create or 442 duplicate a slide. 443 @param pPage 444 This page is either duplicated or becomes the predecessor of the 445 new slide. If NULL a duplication request is ignored. A new 446 slide is inserted as first slide. 447 @param nInsertPosition 448 When -1 (the default) then insert after pPage. Otherwise insert 449 before the given index (of a standard page). 450 @return 451 The new slide is returned. If for some reason a new page can 452 not be created then NULL is returned. 453 */ 454 virtual SdPage* CreateOrDuplicatePage ( 455 SfxRequest& rRequest, 456 PageKind ePageKind, 457 SdPage* pPage, 458 const sal_Int32 nInsertPosition = -1); 459 460 461 class Implementation; 462 463 protected: 464 /** must be called in the beginning of each subclass d'tor. 465 disposes and clears both current and old function. */ 466 void DisposeFunctions(); 467 468 friend class ViewShellBase; 469 470 /** Window inside the rulers and scroll bars that shows a view of the 471 document. 472 */ 473 474 ::boost::shared_ptr<sd::Window> mpContentWindow; 475 476 /// Horizontal scroll bar for the current slide is displayed when needed. 477 ::boost::shared_ptr<ScrollBar> mpHorizontalScrollBar; 478 /// Vertical scroll bar for whole document is always visible. 479 ::boost::shared_ptr<ScrollBar> mpVerticalScrollBar; 480 /// Horizontal ruler is not shown by default. 481 ::std::auto_ptr<SvxRuler> mpHorizontalRuler; 482 /// Vertical ruler is not shown by default. 483 ::std::auto_ptr<SvxRuler> mpVerticalRuler; 484 /// Filler of the little square enclosed by the two scroll bars. 485 ::boost::shared_ptr<ScrollBarBox> mpScrollBarBox; 486 /// Layer tab bar. 487 ::std::auto_ptr<LayerTabBar> mpLayerTabBar; 488 489 /// This flag controls whether the rulers are visible. 490 bool mbHasRulers; 491 492 /// The active window. 493 ::sd::Window* mpActiveWindow; 494 ::sd::View* mpView; 495 FrameView* mpFrameView; 496 497 FunctionReference mxCurrentFunction; 498 FunctionReference mxOldFunction; 499 ZoomList* mpZoomList; 500 501 Point maViewPos; 502 Size maViewSize; 503 Size maScrBarWH; 504 505 sal_Bool mbCenterAllowed; // wird an Fenster weitergegeben 506 507 sal_Bool mbStartShowWithDialog; // Praesentation wurde ueber Dialog gestartet 508 sal_uInt16 mnPrintedHandoutPageNum; // Page number of the handout page that is to be printed. 509 sal_uInt16 mnPrintedHandoutPageCount; // Page count of the handout pages that are to be printed. 510 511 //af sal_Bool bPrintDirectSelected; // Print only selected objects in direct print 512 //afString sPageRange; // pagerange if selected objects in direct print 513 514 /** Area covered by all windows, i.e. the area of the parent window 515 without the controls at the borders like rulers, scroll bars, tab 516 bar, buttons. 517 This rectangle may be set in window coordinates (i.e. pixel values 518 relative to the parent window). It is transformed by every call to 519 GetAllWindowRectangle() into screen coordinates (relative to the 520 upper left corner of the screen. 521 */ 522 Rectangle maAllWindowRectangle; 523 524 /// The type of the shell. Returned by GetShellType(). 525 ShellType meShellType; 526 527 ::std::auto_ptr<Implementation> mpImpl; 528 529 // #96090# Support methods for centralized UNDO/REDO 530 virtual ::svl::IUndoManager* ImpGetUndoManager (void) const; 531 void ImpGetUndoStrings(SfxItemSet &rSet) const; 532 void ImpGetRedoStrings(SfxItemSet &rSet) const; 533 void ImpSidUndo(sal_Bool bDrawViewShell, SfxRequest& rReq); 534 void ImpSidRedo(sal_Bool bDrawViewShell, SfxRequest& rReq); 535 536 DECL_LINK( HScrollHdl, ScrollBar * ); 537 DECL_LINK( VScrollHdl, ScrollBar * ); 538 539 // virt. Scroll-Handler, hier koennen sich abgeleitete Klassen einklinken 540 virtual long VirtHScrollHdl(ScrollBar* pHScroll); 541 virtual long VirtVScrollHdl(ScrollBar* pVScroll); 542 543 // virtuelle Funktionen fuer Lineal-Handling 544 virtual SvxRuler* CreateHRuler(::sd::Window* pWin, sal_Bool bIsFirst); 545 virtual SvxRuler* CreateVRuler(::sd::Window* pWin); 546 virtual void UpdateHRuler(); 547 virtual void UpdateVRuler(); 548 549 // Zeiger auf ein zusaetzliches Control im horizontalen ScrollBar 550 // abgeleiteter Klassen (z.B. ein TabBar) zurueckgeben 551 virtual long GetHCtrlWidth(); 552 553 virtual void Activate(sal_Bool IsMDIActivate); 554 virtual void Deactivate(sal_Bool IsMDIActivate); 555 556 virtual void SetZoomFactor( const Fraction &rZoomX, 557 const Fraction &rZoomY ); 558 559 private: 560 ::Window* mpParentWindow; 561 /** This window updater is used to keep all relevant windows up to date 562 with reference to the digit langugage used to display digits in text 563 shapes. 564 */ 565 ::std::auto_ptr< ::sd::WindowUpdater> mpWindowUpdater; 566 567 /** Code common to all constructors. It generally is a bad idea 568 to call this function from outside a constructor. 569 */ 570 void construct (void); 571 572 DECL_LINK(FrameWindowEventListener, VclSimpleEvent*); 573 574 /** Create the rulers. 575 */ 576 void SetupRulers (void); 577 }; 578 579 580 581 582 ::Window* ViewShell::GetParentWindow (void) const 583 { 584 return mpParentWindow; 585 } 586 587 ::sd::View* ViewShell::GetView (void) const 588 { 589 return mpView; 590 } 591 592 SdrView* ViewShell::GetDrawView (void) const 593 { 594 return static_cast<SdrView*>(mpView); 595 } 596 597 } // end of namespace sd 598 599 #endif 600