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 //IAccessibility2 Implementation 2009----- 321 virtual void SwitchViewFireFocus( ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > xAcc ); 322 virtual void SwitchActiveViewFireFocus( ); 323 // Move these two methods from DrawViewShell to enable slide show view 324 void NotifyAccUpdate(); 325 void fireSwitchCurrentPage(sal_Int32 pageIndex); 326 //-----IAccessibility2 Implementation 2009 327 void SetWinViewPos(const Point& rWinPos, bool bUpdate); 328 Point GetWinViewPos() const; 329 Point GetViewOrigin() const; 330 331 /** Return the window updater of this view shell. 332 @return 333 In rare circumstances the returned pointer may be <null/>, 334 i.e. when no memory is available anymore. 335 */ 336 ::sd::WindowUpdater* GetWindowUpdater (void) const; 337 338 /** Return the border that is drawn arround the actual document view. 339 The border contains typically rulers and scroll bars. 340 @param bOuterResize 341 When this flag is <TRUE/> then the border is used for an 342 OuterResizePixel(), i.e. there is a given window size and the 343 border elements are placed inside so that the document view has 344 the given window size minus the border. 345 When the flag is <FALSE/> then the border is used for an 346 InnerResizePixel(), i.e. the document view has a given size and 347 the border is placed outside. In this scenario the parent 348 window has the size of the document view plus the border. 349 */ 350 SvBorder GetBorder (bool bOuterResize); 351 352 /** Notify the view shell that its parent window has been resized. 353 The ViewShell places and resizes its UI elements accordingly. 354 The new size can be obtained from the parent window. 355 */ 356 virtual void Resize (void); 357 358 /** Set the position and size of the area which contains the GUI 359 elements like rulers, sliders, and buttons as well as the document 360 view. Both size and position are expected to be in pixel 361 coordinates. The positions and sizes of the mentioned GUI elements 362 are updated as well. 363 364 <p> This method is implemented by first setting copying the given 365 values to internal variables and then calling the 366 <type>ArrangeGUIElements</type> method which performs the actual 367 work of sizeing and arranging the UI elements accordingly.</p> 368 @param rPos 369 The position of the enclosing window relative to the document 370 window. This is only interesting if a Draw/Impress document 371 view is embedded as OLE object into another document view. For 372 normal documents this position is (0,0). 373 @param rSize 374 The new size in pixel. 375 */ 376 // This is to be replaced by Resize. 377 // virtual void AdjustPosSizePixel(const Point &rPos, const Size &rSize); 378 379 /** Set position and size of the GUI elements that are controllerd by 380 the view shell like rulers and scroll bars as well as the actual 381 document view according to the position and size that were given 382 with the last Resize() call. 383 */ 384 virtual void ArrangeGUIElements (void); 385 386 // virtual void OuterResizePixel(const Point &rPos, const Size &rSize); 387 // virtual void InnerResizePixel(const Point &rPos, const Size &rSize); 388 389 ViewShellBase& GetViewShellBase (void) const; 390 391 /** Return <TRUE/> when the called view shell is the main sub shell of 392 its ViewShellBase object, i.e. is display in the center pane. This 393 convenience function is equivalent to comparing the this pointer to 394 the result of ViewShellBase::GetViewShell(PT_CENTER). 395 */ 396 bool IsMainViewShell (void) const; 397 398 /** Set or reset the flag that indicates whether the called shell is the 399 one displayed in the center pane. By default this flag is set to 400 <FALSE/>. For the main view shell it thus has to be set to <TRUE/>. 401 */ 402 void SetIsMainViewShell (bool bIsMainViewShell); 403 404 /** Return a sub controller that implements the view shell specific 405 part of the DrawController. 406 */ 407 virtual css::uno::Reference<css::drawing::XDrawSubController> CreateSubController (void) = 0; 408 409 /** Return the type of the shell. 410 */ 411 virtual ShellType GetShellType (void) const; 412 413 /** This method is more or less an alias to Deactivate(). It is called 414 before an object of this class is taken from the stack of view 415 shells. 416 417 <p>When this method is not called before a view shell is taken from 418 a stack then the Deactivate() call from the SFX as a response to 419 RemoveSubShell() comes to late when the view shell is not on the 420 stack anymore.</p> 421 */ 422 virtual void Shutdown (void); 423 424 /** This function is called from the underlying ViewShellBase 425 object to handle a verb execution request. 426 */ 427 virtual ErrCode DoVerb (long nVerb); 428 429 virtual void UIActivating( SfxInPlaceClient* ); 430 virtual void UIDeactivated( SfxInPlaceClient* ); 431 432 /** Show controls of the UI or hide them, depending on the given flag. 433 As a result the border is adapted. 434 */ 435 virtual void ShowUIControls (bool bVisible = true); 436 sal_Bool IsPageFlipMode(void) const; 437 438 /** Set the given window as new parent window. This is not possible for 439 all views, so the return value tells the caller if the relocation 440 was successfull. 441 */ 442 virtual bool RelocateToParentWindow (::Window* pParentWindow); 443 444 /** Depending on the given request create a new page or duplicate an 445 existing one. A new page is created behind the given slide. 446 @param rRequest 447 The request as passed to an Execute() method. Its arguments are 448 evaluated. Its slot id determines whether to create or 449 duplicate a slide. 450 @param pPage 451 This page is either duplicated or becomes the predecessor of the 452 new slide. If NULL a duplication request is ignored. A new 453 slide is inserted as first slide. 454 @param nInsertPosition 455 When -1 (the default) then insert after pPage. Otherwise insert 456 before the given index (of a standard page). 457 @return 458 The new slide is returned. If for some reason a new page can 459 not be created then NULL is returned. 460 */ 461 virtual SdPage* CreateOrDuplicatePage ( 462 SfxRequest& rRequest, 463 PageKind ePageKind, 464 SdPage* pPage, 465 const sal_Int32 nInsertPosition = -1); 466 467 468 class Implementation; 469 470 protected: 471 /** must be called in the beginning of each subclass d'tor. 472 disposes and clears both current and old function. */ 473 void DisposeFunctions(); 474 475 friend class ViewShellBase; 476 477 /** Window inside the rulers and scroll bars that shows a view of the 478 document. 479 */ 480 481 ::boost::shared_ptr<sd::Window> mpContentWindow; 482 483 /// Horizontal scroll bar for the current slide is displayed when needed. 484 ::boost::shared_ptr<ScrollBar> mpHorizontalScrollBar; 485 /// Vertical scroll bar for whole document is always visible. 486 ::boost::shared_ptr<ScrollBar> mpVerticalScrollBar; 487 /// Horizontal ruler is not shown by default. 488 ::std::auto_ptr<SvxRuler> mpHorizontalRuler; 489 /// Vertical ruler is not shown by default. 490 ::std::auto_ptr<SvxRuler> mpVerticalRuler; 491 /// Filler of the little square enclosed by the two scroll bars. 492 ::boost::shared_ptr<ScrollBarBox> mpScrollBarBox; 493 /// Layer tab bar. 494 ::std::auto_ptr<LayerTabBar> mpLayerTabBar; 495 496 /// This flag controls whether the rulers are visible. 497 bool mbHasRulers; 498 499 /// The active window. 500 ::sd::Window* mpActiveWindow; 501 ::sd::View* mpView; 502 FrameView* mpFrameView; 503 504 FunctionReference mxCurrentFunction; 505 FunctionReference mxOldFunction; 506 ZoomList* mpZoomList; 507 508 Point maViewPos; 509 Size maViewSize; 510 Size maScrBarWH; 511 512 sal_Bool mbCenterAllowed; // wird an Fenster weitergegeben 513 514 sal_Bool mbStartShowWithDialog; // Praesentation wurde ueber Dialog gestartet 515 sal_uInt16 mnPrintedHandoutPageNum; // Page number of the handout page that is to be printed. 516 sal_uInt16 mnPrintedHandoutPageCount; // Page count of the handout pages that are to be printed. 517 518 //af sal_Bool bPrintDirectSelected; // Print only selected objects in direct print 519 //afString sPageRange; // pagerange if selected objects in direct print 520 521 /** Area covered by all windows, i.e. the area of the parent window 522 without the controls at the borders like rulers, scroll bars, tab 523 bar, buttons. 524 This rectangle may be set in window coordinates (i.e. pixel values 525 relative to the parent window). It is transformed by every call to 526 GetAllWindowRectangle() into screen coordinates (relative to the 527 upper left corner of the screen. 528 */ 529 Rectangle maAllWindowRectangle; 530 531 /// The type of the shell. Returned by GetShellType(). 532 ShellType meShellType; 533 534 ::std::auto_ptr<Implementation> mpImpl; 535 536 // #96090# Support methods for centralized UNDO/REDO 537 virtual ::svl::IUndoManager* ImpGetUndoManager (void) const; 538 void ImpGetUndoStrings(SfxItemSet &rSet) const; 539 void ImpGetRedoStrings(SfxItemSet &rSet) const; 540 void ImpSidUndo(sal_Bool bDrawViewShell, SfxRequest& rReq); 541 void ImpSidRedo(sal_Bool bDrawViewShell, SfxRequest& rReq); 542 543 DECL_LINK( HScrollHdl, ScrollBar * ); 544 DECL_LINK( VScrollHdl, ScrollBar * ); 545 546 // virt. Scroll-Handler, hier koennen sich abgeleitete Klassen einklinken 547 virtual long VirtHScrollHdl(ScrollBar* pHScroll); 548 virtual long VirtVScrollHdl(ScrollBar* pVScroll); 549 550 // virtuelle Funktionen fuer Lineal-Handling 551 virtual SvxRuler* CreateHRuler(::sd::Window* pWin, sal_Bool bIsFirst); 552 virtual SvxRuler* CreateVRuler(::sd::Window* pWin); 553 virtual void UpdateHRuler(); 554 virtual void UpdateVRuler(); 555 556 // Zeiger auf ein zusaetzliches Control im horizontalen ScrollBar 557 // abgeleiteter Klassen (z.B. ein TabBar) zurueckgeben 558 virtual long GetHCtrlWidth(); 559 560 virtual void Activate(sal_Bool IsMDIActivate); 561 virtual void Deactivate(sal_Bool IsMDIActivate); 562 563 virtual void SetZoomFactor( const Fraction &rZoomX, 564 const Fraction &rZoomY ); 565 566 private: 567 ::Window* mpParentWindow; 568 /** This window updater is used to keep all relevant windows up to date 569 with reference to the digit langugage used to display digits in text 570 shapes. 571 */ 572 ::std::auto_ptr< ::sd::WindowUpdater> mpWindowUpdater; 573 574 /** Code common to all constructors. It generally is a bad idea 575 to call this function from outside a constructor. 576 */ 577 void construct (void); 578 579 DECL_LINK(FrameWindowEventListener, VclSimpleEvent*); 580 581 /** Create the rulers. 582 */ 583 void SetupRulers (void); 584 }; 585 586 587 588 589 ::Window* ViewShell::GetParentWindow (void) const 590 { 591 return mpParentWindow; 592 } 593 594 ::sd::View* ViewShell::GetView (void) const 595 { 596 return mpView; 597 } 598 599 SdrView* ViewShell::GetDrawView (void) const 600 { 601 return static_cast<SdrView*>(mpView); 602 } 603 604 } // end of namespace sd 605 606 #endif 607