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 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 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 around 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 successful. 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 587 ::Window* ViewShell::GetParentWindow (void) const 588 { 589 return mpParentWindow; 590 } 591 592 ::sd::View* ViewShell::GetView (void) const 593 { 594 return mpView; 595 } 596 597 SdrView* ViewShell::GetDrawView (void) const 598 { 599 return static_cast<SdrView*>(mpView); 600 } 601 602 } // end of namespace sd 603 604 #endif 605