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 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_sd.hxx" 26 27 #include "ViewShell.hxx" 28 #include "ViewShellImplementation.hxx" 29 30 #ifndef _COM_SUN_STAR_EMBED_EMBEDSTATE_HPP_ 31 #include <com/sun/star/embed/EmbedStates.hpp> 32 #endif 33 #include "ViewShellBase.hxx" 34 #include "ShellFactory.hxx" 35 #include "DrawController.hxx" 36 #include "LayerTabBar.hxx" 37 38 #include <sfx2/viewfrm.hxx> 39 #include <sfx2/bindings.hxx> 40 #include <sfx2/dispatch.hxx> 41 #ifndef _SCRBAR_HXX //autogen 42 #include <vcl/scrbar.hxx> 43 #endif 44 #include <svl/eitem.hxx> 45 #include <svx/ruler.hxx> 46 #ifndef _SVXIDS_HXX 47 #include <svx/svxids.hrc> 48 #endif 49 #include <svx/fmshell.hxx> 50 #ifndef SD_WINDOW_UPDATER_HXX 51 #include "WindowUpdater.hxx" 52 #endif 53 #include "GraphicViewShell.hxx" 54 #include <sfx2/childwin.hxx> 55 #include <sdxfer.hxx> 56 #include "GraphicViewShell.hxx" 57 #include <sfx2/childwin.hxx> 58 59 #include "app.hrc" 60 #include "helpids.h" 61 #include "strings.hrc" 62 #include "res_bmp.hrc" 63 #include "OutlineView.hxx" 64 #include "Client.hxx" 65 #include "sdresid.hxx" 66 #include "DrawDocShell.hxx" 67 #include "slideshow.hxx" 68 #include "drawdoc.hxx" 69 #include "sdpage.hxx" 70 #include "zoomlist.hxx" 71 #include "FrameView.hxx" 72 #include "optsitem.hxx" 73 #include "BezierObjectBar.hxx" 74 #include "TextObjectBar.hxx" 75 #include "GraphicObjectBar.hxx" 76 #include "MediaObjectBar.hxx" 77 #include "ViewShellManager.hxx" 78 #include "FormShellManager.hxx" 79 #include <svx/fmshell.hxx> 80 #include <svx/dialogs.hrc> 81 #include <svx/extrusionbar.hxx> 82 #include <svx/fontworkbar.hxx> 83 #include <svx/svdoutl.hxx> 84 #include <tools/diagnose_ex.h> 85 86 // #96090# 87 #include <svl/slstitm.hxx> 88 #include <sfx2/request.hxx> 89 #include "SpellDialogChildWindow.hxx" 90 91 #include "Window.hxx" 92 #include "fupoor.hxx" 93 94 #include <editeng/numitem.hxx> 95 #include <editeng/eeitem.hxx> 96 #include <svl/poolitem.hxx> 97 #include <glob.hrc> 98 #include "AccessibleDocumentViewBase.hxx" 99 #ifndef SO2_DECL_SVINPLACEOBJECT_DEFINED 100 #define SO2_DECL_SVINPLACEOBJECT_DEFINED 101 SO2_DECL_REF(SvInPlaceObject) 102 #endif 103 104 namespace sd { namespace ui { namespace table { 105 extern SfxShell* CreateTableObjectBar( ViewShell& rShell, ::sd::View* pView ); 106 } } } 107 108 using namespace ::com::sun::star; 109 using namespace ::com::sun::star::uno; 110 using namespace ::com::sun::star::presentation; 111 112 namespace { 113 114 class ViewShellObjectBarFactory 115 : public ::sd::ShellFactory<SfxShell> 116 { 117 public: 118 ViewShellObjectBarFactory (::sd::ViewShell& rViewShell); 119 virtual ~ViewShellObjectBarFactory (void); 120 virtual SfxShell* CreateShell ( 121 ::sd::ShellId nId, 122 ::Window* pParentWindow, 123 ::sd::FrameView* pFrameView); 124 virtual void ReleaseShell (SfxShell* pShell); 125 private: 126 ::sd::ViewShell& mrViewShell; 127 /** This cache holds the already created object bars. 128 */ 129 typedef ::std::map< ::sd::ShellId,SfxShell*> ShellCache; 130 ShellCache maShellCache; 131 }; 132 133 134 } // end of anonymous namespace 135 136 137 namespace sd { 138 139 static const int DELTA_ZOOM = 10; 140 141 sal_Bool ViewShell::IsPageFlipMode(void) const 142 { 143 return this->ISA(DrawViewShell) && mpContentWindow.get() != NULL && 144 mpContentWindow->GetVisibleHeight() >= 1.0; 145 } 146 147 SfxViewFrame* ViewShell::GetViewFrame (void) const 148 { 149 const SfxViewShell* pViewShell = GetViewShell(); 150 if (pViewShell != NULL) 151 { 152 return pViewShell->GetViewFrame(); 153 } 154 else 155 { 156 OSL_ASSERT (GetViewShell()!=NULL); 157 return NULL; 158 } 159 } 160 161 162 /************************************************************************* 163 |* 164 |* SFX-Slotmap und Standardinterface deklarieren 165 |* 166 \************************************************************************/ 167 TYPEINIT1(ViewShell, SfxShell); 168 169 170 ViewShell::ViewShell( SfxViewFrame*, ::Window* pParentWindow, ViewShellBase& rViewShellBase, bool bAllowCenter) 171 : SfxShell(&rViewShellBase) 172 , mbCenterAllowed(bAllowCenter) 173 , mpParentWindow(pParentWindow) 174 { 175 construct(); 176 } 177 178 ViewShell::~ViewShell() 179 { 180 // Keep the content window from accessing in its destructor the 181 // WindowUpdater. 182 if (mpContentWindow) 183 mpContentWindow->SetViewShell(NULL); 184 185 delete mpZoomList; 186 187 mpLayerTabBar.reset(); 188 189 if (mpImpl->mpSubShellFactory.get() != NULL) 190 GetViewShellBase().GetViewShellManager()->RemoveSubShellFactory( 191 this,mpImpl->mpSubShellFactory); 192 193 if (mpContentWindow) 194 { 195 OSL_TRACE("destroying mpContentWindow at %x with parent %x", mpContentWindow.get(), 196 mpContentWindow->GetParent()); 197 mpContentWindow.reset(); 198 } 199 } 200 201 202 /************************************************************************* 203 |* 204 |* gemeinsamer Initialiserungsanteil der beiden Konstruktoren 205 |* 206 \************************************************************************/ 207 208 void ViewShell::construct(void) 209 { 210 mbHasRulers = false; 211 mpActiveWindow = 0; 212 mpView = 0; 213 mpFrameView = 0; 214 mpZoomList = 0; 215 mbStartShowWithDialog = sal_False; 216 mnPrintedHandoutPageNum = 1; 217 mnPrintedHandoutPageCount = 0; 218 mpWindowUpdater.reset( new ::sd::WindowUpdater() ); 219 mpImpl.reset(new Implementation(*this)); 220 meShellType = ST_NONE; 221 222 OSL_ASSERT (GetViewShell()!=NULL); 223 224 if (IsMainViewShell()) 225 GetDocSh()->Connect (this); 226 227 mpZoomList = new ZoomList( this ); 228 229 mpContentWindow.reset(new ::sd::Window(GetParentWindow())); 230 SetActiveWindow (mpContentWindow.get()); 231 232 GetParentWindow()->SetBackground (Wallpaper()); 233 mpContentWindow->SetBackground (Wallpaper()); 234 mpContentWindow->SetCenterAllowed(mbCenterAllowed); 235 mpContentWindow->SetViewShell(this); 236 mpContentWindow->SetPosSizePixel( 237 GetParentWindow()->GetPosPixel(),GetParentWindow()->GetSizePixel()); 238 mpContentWindow->Show(); 239 static_cast< ::Window*>(mpContentWindow.get())->Resize(); 240 OSL_TRACE("content window has size %d %d", 241 mpContentWindow->GetSizePixel().Width(), 242 mpContentWindow->GetSizePixel().Height()); 243 244 if ( ! GetDocSh()->IsPreview()) 245 { 246 // Create scroll bars and the filler between the scroll bars. 247 mpHorizontalScrollBar.reset (new ScrollBar(GetParentWindow(), WinBits(WB_HSCROLL | WB_DRAG))); 248 mpHorizontalScrollBar->EnableRTL (sal_False); 249 mpHorizontalScrollBar->SetRange(Range(0, 32000)); 250 mpHorizontalScrollBar->SetScrollHdl(LINK(this, ViewShell, HScrollHdl)); 251 mpHorizontalScrollBar->Show(); 252 253 mpVerticalScrollBar.reset (new ScrollBar(GetParentWindow(), WinBits(WB_VSCROLL | WB_DRAG))); 254 mpVerticalScrollBar->SetRange(Range(0, 32000)); 255 mpVerticalScrollBar->SetScrollHdl(LINK(this, ViewShell, VScrollHdl)); 256 mpVerticalScrollBar->Show(); 257 maScrBarWH = Size( 258 mpVerticalScrollBar->GetSizePixel().Width(), 259 mpHorizontalScrollBar->GetSizePixel().Height()); 260 261 mpScrollBarBox.reset(new ScrollBarBox(GetParentWindow(), WB_SIZEABLE)); 262 mpScrollBarBox->Show(); 263 } 264 265 String aName( RTL_CONSTASCII_USTRINGPARAM( "ViewShell" )); 266 SetName (aName); 267 268 GetDoc()->StartOnlineSpelling(sal_False); 269 270 mpWindowUpdater->SetViewShell (*this); 271 mpWindowUpdater->SetDocument (GetDoc()); 272 273 // Re-initialize the spell dialog. 274 ::sd::SpellDialogChildWindow* pSpellDialog = 275 static_cast< ::sd::SpellDialogChildWindow*> ( 276 GetViewFrame()->GetChildWindow ( 277 ::sd::SpellDialogChildWindow::GetChildWindowId())); 278 if (pSpellDialog != NULL) 279 pSpellDialog->InvalidateSpellDialog(); 280 281 // Register the sub shell factory. 282 mpImpl->mpSubShellFactory.reset(new ViewShellObjectBarFactory(*this)); 283 GetViewShellBase().GetViewShellManager()->AddSubShellFactory(this,mpImpl->mpSubShellFactory); 284 285 GetParentWindow()->Show(); 286 } 287 288 289 290 291 void ViewShell::Init (bool bIsMainViewShell) 292 { 293 mpImpl->mbIsInitialized = true; 294 SetIsMainViewShell(bIsMainViewShell); 295 if (bIsMainViewShell) 296 SetActiveWindow (mpContentWindow.get()); 297 } 298 299 300 301 302 void ViewShell::Exit (void) 303 { 304 sd::View* pView = GetView(); 305 if (pView!=NULL && pView->IsTextEdit()) 306 { 307 pView->SdrEndTextEdit(); 308 pView->UnmarkAll(); 309 } 310 311 Deactivate (sal_True); 312 313 if (IsMainViewShell()) 314 { 315 GetDocSh()->Disconnect(this); 316 } 317 318 SetIsMainViewShell(false); 319 } 320 321 322 323 324 /************************************************************************* 325 |* 326 |* Aktivierung: Arbeitsfenster den Fokus zuweisen 327 |* 328 \************************************************************************/ 329 330 void ViewShell::Activate(sal_Bool bIsMDIActivate) 331 { 332 // Do not forward to SfxShell::Activate() 333 334 // Laut MI darf keiner GrabFocus rufen, der nicht genau weiss von 335 // welchem Window der Focus gegrabt wird. Da Activate() vom SFX teilweise 336 // asynchron verschickt wird, kann es sein, dass ein falsches Window 337 // den Focus hat (#29682#): 338 //GetViewFrame()->GetWindow().GrabFocus(); 339 340 if (mpHorizontalRuler.get() != NULL) 341 mpHorizontalRuler->SetActive(sal_True); 342 if (mpVerticalRuler.get() != NULL) 343 mpVerticalRuler->SetActive(sal_True); 344 345 if (bIsMDIActivate) 346 { 347 // Damit der Navigator auch einen aktuellen Status bekommt 348 SfxBoolItem aItem( SID_NAVIGATOR_INIT, sal_True ); 349 if (GetDispatcher() != NULL) 350 GetDispatcher()->Execute( 351 SID_NAVIGATOR_INIT, 352 SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD, 353 &aItem, 354 0L); 355 356 SfxViewShell* pViewShell = GetViewShell(); 357 OSL_ASSERT (pViewShell!=NULL); 358 SfxBindings& rBindings = pViewShell->GetViewFrame()->GetBindings(); 359 rBindings.Invalidate( SID_3D_STATE, sal_True, sal_False ); 360 361 rtl::Reference< SlideShow > xSlideShow( SlideShow::GetSlideShow( GetViewShellBase() ) ); 362 if(xSlideShow.is() && xSlideShow->isRunning() ) 363 { 364 xSlideShow->activate(GetViewShellBase()); 365 } 366 if(HasCurrentFunction()) 367 { 368 GetCurrentFunction()->Activate(); 369 } 370 371 if(!GetDocSh()->IsUIActive()) 372 UpdatePreview( GetActualPage(), sal_True ); 373 374 //HMH::sd::View* pView = GetView(); 375 376 //HMHif (pView) 377 //HMH{ 378 //HMH pView->ShowMarkHdl(); 379 //HMH} 380 } 381 382 ReadFrameViewData( mpFrameView ); 383 384 if (IsMainViewShell()) 385 GetDocSh()->Connect(this); 386 } 387 388 void ViewShell::UIActivating( SfxInPlaceClient* ) 389 { 390 OSL_ASSERT (GetViewShell()!=NULL); 391 GetViewShellBase().GetToolBarManager()->ToolBarsDestroyed(); 392 } 393 394 395 396 void ViewShell::UIDeactivated( SfxInPlaceClient* ) 397 { 398 OSL_ASSERT (GetViewShell()!=NULL); 399 GetViewShellBase().GetToolBarManager()->ToolBarsDestroyed(); 400 if ( GetDrawView() ) 401 GetViewShellBase().GetToolBarManager()->SelectionHasChanged(*this, *GetDrawView()); 402 } 403 404 /************************************************************************* 405 |* 406 |* Deaktivierung 407 |* 408 \************************************************************************/ 409 410 void ViewShell::Deactivate(sal_Bool bIsMDIActivate) 411 { 412 // remove view from a still active drag'n'drop session 413 SdTransferable* pDragTransferable = SD_MOD()->pTransferDrag; 414 415 if (IsMainViewShell()) 416 GetDocSh()->Disconnect(this); 417 418 if( pDragTransferable ) 419 pDragTransferable->SetView( NULL ); 420 421 OSL_ASSERT (GetViewShell()!=NULL); 422 423 // View-Attribute an der FrameView merken 424 WriteFrameViewData(); 425 426 if (bIsMDIActivate) 427 { 428 rtl::Reference< SlideShow > xSlideShow( SlideShow::GetSlideShow( GetViewShellBase() ) ); 429 if(xSlideShow.is() && xSlideShow->isRunning() ) 430 { 431 xSlideShow->deactivate(GetViewShellBase()); 432 } 433 if(HasCurrentFunction()) 434 { 435 GetCurrentFunction()->Deactivate(); 436 } 437 } 438 439 if (mpHorizontalRuler.get() != NULL) 440 mpHorizontalRuler->SetActive(sal_False); 441 if (mpVerticalRuler.get() != NULL) 442 mpVerticalRuler->SetActive(sal_False); 443 444 SfxShell::Deactivate(bIsMDIActivate); 445 } 446 447 448 449 450 void ViewShell::Shutdown (void) 451 { 452 Exit (); 453 } 454 455 456 457 458 /************************************************************************* 459 |* 460 |* Keyboard event 461 |* 462 \************************************************************************/ 463 464 sal_Bool ViewShell::KeyInput(const KeyEvent& rKEvt, ::sd::Window* pWin) 465 { 466 sal_Bool bReturn(sal_False); 467 468 if(pWin) 469 { 470 SetActiveWindow(pWin); 471 } 472 473 if(!bReturn) 474 { 475 // #76008# 476 // give key input first to SfxViewShell to give CTRL+Key 477 // (e.g. CTRL+SHIFT+'+', to front) priority. 478 OSL_ASSERT (GetViewShell()!=NULL); 479 bReturn = (sal_Bool)GetViewShell()->KeyInput(rKEvt); 480 } 481 482 sal_Int32 OriCount = GetView()->GetMarkedObjectList().GetMarkCount(); 483 if(!bReturn) 484 { 485 rtl::Reference< SlideShow > xSlideShow( SlideShow::GetSlideShow( GetViewShellBase() ) ); 486 if(xSlideShow.is() && xSlideShow->isRunning()) 487 { 488 bReturn = xSlideShow->keyInput(rKEvt); 489 } 490 else 491 { 492 bool bConsumed = false; 493 if( GetView() ) 494 bConsumed = GetView()->getSmartTags().KeyInput(rKEvt); 495 496 497 if( !bConsumed ) 498 { 499 rtl::Reference< sdr::SelectionController > xSelectionController( GetView()->getSelectionController() ); 500 if( !xSelectionController.is() || !xSelectionController->onKeyInput( rKEvt, pWin ) ) 501 { 502 if(HasCurrentFunction()) 503 bReturn = GetCurrentFunction()->KeyInput(rKEvt); 504 } 505 else 506 { 507 bReturn = sal_True; 508 } 509 } 510 } 511 } 512 sal_Int32 EndCount = GetView()->GetMarkedObjectList().GetMarkCount(); 513 // Here, oriCount or endCount must have one value=0, another value > 0, then to switch focus between Document and shape objects 514 if(bReturn && (OriCount + EndCount > 0) && (OriCount * EndCount == 0)) 515 { 516 SwitchActiveViewFireFocus(); 517 } 518 519 if(!bReturn && GetActiveWindow()) 520 { 521 KeyCode aKeyCode = rKEvt.GetKeyCode(); 522 523 if (aKeyCode.IsMod1() && aKeyCode.IsShift() 524 && aKeyCode.GetCode() == KEY_R) 525 { 526 InvalidateWindows(); 527 bReturn = sal_True; 528 } 529 } 530 531 return(bReturn); 532 } 533 534 /************************************************************************* 535 |* 536 |* MouseButtonDown event 537 |* 538 \************************************************************************/ 539 540 void ViewShell::MouseButtonDown(const MouseEvent& rMEvt, ::sd::Window* pWin) 541 { 542 // We have to lock tool bar updates while the mouse button is pressed in 543 // order to prevent the shape under the mouse to be moved (this happens 544 // when the number of docked tool bars changes as result of a changed 545 // selection; this changes the window size and thus the mouse position 546 // in model coordinates: with respect to model coordinates the mouse 547 // moves.) 548 OSL_ASSERT(mpImpl->mpUpdateLockForMouse.expired()); 549 mpImpl->mpUpdateLockForMouse = ViewShell::Implementation::ToolBarManagerLock::Create( 550 GetViewShellBase().GetToolBarManager()); 551 552 if ( pWin && !pWin->HasFocus() ) 553 { 554 pWin->GrabFocus(); 555 SetActiveWindow(pWin); 556 // GetViewFrame()->GetWindow().GrabFocus(); 557 } 558 559 // MouseEvent in E3dView eintragen 560 if (GetView() != NULL) 561 GetView()->SetMouseEvent(rMEvt); 562 563 bool bConsumed = false; 564 if( GetView() ) 565 bConsumed = GetView()->getSmartTags().MouseButtonDown( rMEvt ); 566 567 if( !bConsumed ) 568 { 569 rtl::Reference< sdr::SelectionController > xSelectionController( GetView()->getSelectionController() ); 570 if( !xSelectionController.is() || !xSelectionController->onMouseButtonDown( rMEvt, pWin ) ) 571 { 572 if(HasCurrentFunction()) 573 { 574 GetCurrentFunction()->MouseButtonDown(rMEvt); 575 } 576 } 577 } 578 } 579 580 /************************************************************************* 581 |* 582 |* MouseMove event 583 |* 584 \************************************************************************/ 585 586 void ViewShell::MouseMove(const MouseEvent& rMEvt, ::sd::Window* pWin) 587 { 588 if (rMEvt.IsLeaveWindow()) 589 { 590 if ( ! mpImpl->mpUpdateLockForMouse.expired()) 591 { 592 ::boost::shared_ptr<ViewShell::Implementation::ToolBarManagerLock> pLock( 593 mpImpl->mpUpdateLockForMouse); 594 if (pLock.get() != NULL) 595 pLock->Release(); 596 } 597 } 598 599 if ( pWin ) 600 { 601 SetActiveWindow(pWin); 602 } 603 604 // MouseEvent in E3dView eintragen 605 if (GetView() != NULL) 606 GetView()->SetMouseEvent(rMEvt); 607 608 if(HasCurrentFunction()) 609 { 610 rtl::Reference< sdr::SelectionController > xSelectionController( GetView()->getSelectionController() ); 611 if( !xSelectionController.is() || !xSelectionController->onMouseMove( rMEvt, pWin ) ) 612 { 613 if(HasCurrentFunction()) 614 GetCurrentFunction()->MouseMove(rMEvt); 615 } 616 } 617 } 618 619 /************************************************************************* 620 |* 621 |* MouseButtonUp event 622 |* 623 \************************************************************************/ 624 625 void ViewShell::MouseButtonUp(const MouseEvent& rMEvt, ::sd::Window* pWin) 626 { 627 if ( pWin ) 628 { 629 SetActiveWindow(pWin); 630 } 631 632 // MouseEvent in E3dView eintragen 633 if (GetView() != NULL) 634 GetView()->SetMouseEvent(rMEvt); 635 636 if( HasCurrentFunction()) 637 { 638 rtl::Reference< sdr::SelectionController > xSelectionController( GetView()->getSelectionController() ); 639 if( !xSelectionController.is() || !xSelectionController->onMouseButtonUp( rMEvt, pWin ) ) 640 { 641 if(HasCurrentFunction()) 642 GetCurrentFunction()->MouseButtonUp(rMEvt); 643 } 644 } 645 646 if ( ! mpImpl->mpUpdateLockForMouse.expired()) 647 { 648 ::boost::shared_ptr<ViewShell::Implementation::ToolBarManagerLock> pLock( 649 mpImpl->mpUpdateLockForMouse); 650 if (pLock.get() != NULL) 651 pLock->Release(); 652 } 653 } 654 655 656 /************************************************************************* 657 |* 658 |* Command event 659 |* 660 \************************************************************************/ 661 662 void ViewShell::Command(const CommandEvent& rCEvt, ::sd::Window* pWin) 663 { 664 sal_Bool bDone = HandleScrollCommand (rCEvt, pWin); 665 666 if( !bDone ) 667 { 668 if( rCEvt.GetCommand() == COMMAND_INPUTLANGUAGECHANGE ) 669 { 670 //#i42732# update state of fontname if input language changes 671 GetViewFrame()->GetBindings().Invalidate( SID_ATTR_CHAR_FONT ); 672 GetViewFrame()->GetBindings().Invalidate( SID_ATTR_CHAR_FONTHEIGHT ); 673 } 674 else 675 { 676 bool bConsumed = false; 677 if( GetView() ) 678 { 679 bConsumed = GetView()->getSmartTags().Command(rCEvt); 680 } 681 682 if( !bConsumed && HasCurrentFunction()) 683 { 684 GetCurrentFunction()->Command(rCEvt); 685 } 686 } 687 } 688 } 689 690 long ViewShell::Notify(NotifyEvent& rNEvt, ::sd::Window* pWin) 691 { 692 // handle scroll commands when they arrived at child windows 693 long nRet = sal_False; 694 if( rNEvt.GetType() == EVENT_COMMAND ) 695 { 696 // note: dynamic_cast is not possible as GetData() returns a void* 697 CommandEvent* pCmdEvent = reinterpret_cast< CommandEvent* >(rNEvt.GetData()); 698 nRet = HandleScrollCommand(*pCmdEvent, pWin); 699 } 700 return nRet; 701 } 702 703 704 bool ViewShell::HandleScrollCommand(const CommandEvent& rCEvt, ::sd::Window* pWin) 705 { 706 bool bDone = false; 707 708 switch( rCEvt.GetCommand() ) 709 { 710 case COMMAND_WHEEL: 711 { 712 Reference< XSlideShowController > xSlideShowController( SlideShow::GetSlideShowController(GetViewShellBase() ) ); 713 if( xSlideShowController.is() ) 714 { 715 // We ignore zooming with control+mouse wheel. 716 const CommandWheelData* pData = rCEvt.GetWheelData(); 717 if( pData && !pData->GetModifier() && ( pData->GetMode() == COMMAND_WHEEL_SCROLL ) && !pData->IsHorz() ) 718 { 719 long nDelta = pData->GetDelta(); 720 if( nDelta > 0 ) 721 { 722 xSlideShowController->gotoPreviousSlide(); 723 } 724 else if( nDelta < 0 ) 725 { 726 xSlideShowController->gotoNextEffect(); 727 } 728 } 729 break; 730 } 731 } 732 // fall through when not running slideshow 733 case COMMAND_STARTAUTOSCROLL: 734 case COMMAND_AUTOSCROLL: 735 { 736 const CommandWheelData* pData = rCEvt.GetWheelData(); 737 738 if (pData != NULL) 739 { 740 if (pData->IsMod1()) 741 { 742 if( !GetDocSh()->IsUIActive() ) 743 { 744 const long nOldZoom = GetActiveWindow()->GetZoom(); 745 long nNewZoom; 746 747 if( pData->GetDelta() < 0L ) 748 nNewZoom = Max( (long) pWin->GetMinZoom(), (long)(nOldZoom - DELTA_ZOOM) ); 749 else 750 nNewZoom = Min( (long) pWin->GetMaxZoom(), (long)(nOldZoom + DELTA_ZOOM) ); 751 752 SetZoom( nNewZoom ); 753 Invalidate( SID_ATTR_ZOOM ); 754 Invalidate( SID_ATTR_ZOOMSLIDER ); 755 756 bDone = true; 757 } 758 } 759 else 760 { 761 if( mpContentWindow.get() == pWin ) 762 { 763 sal_uLong nScrollLines = pData->GetScrollLines(); 764 if(IsPageFlipMode()) 765 nScrollLines = COMMAND_WHEEL_PAGESCROLL; 766 CommandWheelData aWheelData( pData->GetDelta(),pData->GetNotchDelta(), 767 nScrollLines,pData->GetMode(),pData->GetModifier(),pData->IsHorz() ); 768 CommandEvent aReWrite( rCEvt.GetMousePosPixel(),rCEvt.GetCommand(), 769 rCEvt.IsMouseEvent(),(const void *) &aWheelData ); 770 bDone = pWin->HandleScrollCommand( aReWrite, 771 mpHorizontalScrollBar.get(), 772 mpVerticalScrollBar.get()) == sal_True; 773 } 774 } 775 } 776 } 777 break; 778 779 default: 780 break; 781 } 782 783 return bDone; 784 } 785 786 787 788 void ViewShell::SetupRulers (void) 789 { 790 if(mbHasRulers && (mpContentWindow.get() != NULL) && !SlideShow::IsRunning(GetViewShellBase())) 791 { 792 long nHRulerOfs = 0; 793 794 if ( mpVerticalRuler.get() == NULL ) 795 { 796 mpVerticalRuler.reset(CreateVRuler(GetActiveWindow())); 797 if ( mpVerticalRuler.get() != NULL ) 798 { 799 nHRulerOfs = mpVerticalRuler->GetSizePixel().Width(); 800 mpVerticalRuler->SetActive(sal_True); 801 mpVerticalRuler->Show(); 802 } 803 } 804 if ( mpHorizontalRuler.get() == NULL ) 805 { 806 mpHorizontalRuler.reset(CreateHRuler(GetActiveWindow(), sal_True)); 807 if ( mpHorizontalRuler.get() != NULL ) 808 { 809 mpHorizontalRuler->SetWinPos(nHRulerOfs); 810 mpHorizontalRuler->SetActive(sal_True); 811 mpHorizontalRuler->Show(); 812 } 813 } 814 } 815 } 816 817 const SfxPoolItem* ViewShell::GetNumBulletItem(SfxItemSet& aNewAttr, sal_uInt16& nNumItemId) 818 { 819 const SfxPoolItem* pTmpItem = NULL; 820 821 if(aNewAttr.GetItemState(nNumItemId, sal_False, &pTmpItem) == SFX_ITEM_SET) 822 { 823 return pTmpItem; 824 } 825 else 826 { 827 nNumItemId = aNewAttr.GetPool()->GetWhich(SID_ATTR_NUMBERING_RULE); 828 SfxItemState eState = aNewAttr.GetItemState(nNumItemId, sal_False, &pTmpItem); 829 if (eState == SFX_ITEM_SET) 830 return pTmpItem; 831 else 832 { 833 sal_Bool bOutliner = sal_False; 834 sal_Bool bTitle = sal_False; 835 836 if( mpView ) 837 { 838 const SdrMarkList& rMarkList = mpView->GetMarkedObjectList(); 839 const sal_uInt32 nCount = rMarkList.GetMarkCount(); 840 841 for(sal_uInt32 nNum = 0; nNum < nCount; nNum++) 842 { 843 SdrObject* pObj = rMarkList.GetMark(nNum)->GetMarkedSdrObj(); 844 if( pObj->GetObjInventor() == SdrInventor ) 845 { 846 switch(pObj->GetObjIdentifier()) 847 { 848 case OBJ_TITLETEXT: 849 bTitle = sal_True; 850 break; 851 case OBJ_OUTLINETEXT: 852 bOutliner = sal_True; 853 break; 854 } 855 } 856 } 857 } 858 859 const SvxNumBulletItem *pItem = NULL; 860 if(bOutliner) 861 { 862 SfxStyleSheetBasePool* pSSPool = mpView->GetDocSh()->GetStyleSheetPool(); 863 String aStyleName((SdResId(STR_LAYOUT_OUTLINE))); 864 aStyleName.AppendAscii( RTL_CONSTASCII_STRINGPARAM( " 1" ) ); 865 SfxStyleSheetBase* pFirstStyleSheet = pSSPool->Find( aStyleName, SD_STYLE_FAMILY_PSEUDO); 866 if( pFirstStyleSheet ) 867 pFirstStyleSheet->GetItemSet().GetItemState(EE_PARA_NUMBULLET, sal_False, (const SfxPoolItem**)&pItem); 868 } 869 870 if( pItem == NULL ) 871 pItem = (SvxNumBulletItem*) aNewAttr.GetPool()->GetSecondaryPool()->GetPoolDefaultItem(EE_PARA_NUMBULLET); 872 873 aNewAttr.Put(*pItem, EE_PARA_NUMBULLET); 874 875 if(bTitle && aNewAttr.GetItemState(EE_PARA_NUMBULLET,sal_True) == SFX_ITEM_ON ) 876 { 877 SvxNumBulletItem* pItem = (SvxNumBulletItem*)aNewAttr.GetItem(EE_PARA_NUMBULLET,sal_True); 878 SvxNumRule* pRule = pItem->GetNumRule(); 879 if(pRule) 880 { 881 SvxNumRule aNewRule( *pRule ); 882 aNewRule.SetFeatureFlag( NUM_NO_NUMBERS, sal_True ); 883 884 SvxNumBulletItem aNewItem( aNewRule, EE_PARA_NUMBULLET ); 885 aNewAttr.Put(aNewItem); 886 } 887 } 888 889 SfxItemState eState = aNewAttr.GetItemState(nNumItemId, sal_False, &pTmpItem); 890 if (eState == SFX_ITEM_SET) 891 return pTmpItem; 892 893 } 894 } 895 return pTmpItem; 896 } 897 898 899 sal_Bool ViewShell::HasRuler (void) 900 { 901 return mbHasRulers; 902 } 903 904 905 906 907 void ViewShell::Resize (void) 908 { 909 SetupRulers (); 910 911 if (mpParentWindow == NULL) 912 return; 913 914 // Make sure that the new size is not degenerate. 915 const Size aSize (mpParentWindow->GetSizePixel()); 916 if (aSize.Width()==0 || aSize.Height()==0) 917 return; 918 919 // Remember the new position and size. 920 maViewPos = Point(0,0); //mpParentWindow->GetPosPixel(); 921 maViewSize = aSize; 922 923 // Rearrange the UI elements to take care of the new position and size. 924 ArrangeGUIElements (); 925 // end of included AdjustPosSizePixel. 926 927 Size aS (GetParentWindow()->GetOutputSizePixel()); 928 Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel(); 929 Rectangle aVisArea = GetParentWindow()->PixelToLogic( 930 Rectangle( Point(0,0), aVisSizePixel)); 931 Rectangle aCurrentVisArea (GetDocSh()->GetVisArea(ASPECT_CONTENT)); 932 Rectangle aWindowRect = GetActiveWindow()->LogicToPixel(aCurrentVisArea); 933 if (GetDocSh()->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED 934 && IsMainViewShell()) 935 { 936 // GetDocSh()->SetVisArea(aVisArea); 937 } 938 939 // VisAreaChanged(aVisArea); 940 941 ::sd::View* pView = GetView(); 942 943 if (pView) 944 { 945 pView->VisAreaChanged(GetActiveWindow()); 946 } 947 } 948 949 SvBorder ViewShell::GetBorder (bool ) 950 { 951 SvBorder aBorder; 952 953 // Horizontal scrollbar. 954 if (mpHorizontalScrollBar.get()!=NULL 955 && mpHorizontalScrollBar->IsVisible()) 956 { 957 aBorder.Bottom() = maScrBarWH.Height(); 958 } 959 960 // Vertical scrollbar. 961 if (mpVerticalScrollBar.get()!=NULL 962 && mpVerticalScrollBar->IsVisible()) 963 { 964 aBorder.Right() = maScrBarWH.Width(); 965 } 966 967 // Place horizontal ruler below tab bar. 968 if (mbHasRulers && mpContentWindow.get() != NULL) 969 { 970 SetupRulers(); 971 if (mpHorizontalRuler.get() != NULL) 972 aBorder.Top() = mpHorizontalRuler->GetSizePixel().Height(); 973 if (mpVerticalRuler.get() != NULL) 974 aBorder.Left() = mpVerticalRuler->GetSizePixel().Width(); 975 } 976 977 return aBorder; 978 } 979 980 981 982 983 void ViewShell::ArrangeGUIElements (void) 984 { 985 if (mpImpl->mbArrangeActive) 986 return; 987 mpImpl->mbArrangeActive = true; 988 989 // Calculate border for in-place editing. 990 long nLeft = maViewPos.X(); 991 long nTop = maViewPos.Y(); 992 long nRight = maViewPos.X() + maViewSize.Width(); 993 long nBottom = maViewPos.Y() + maViewSize.Height(); 994 995 // Horizontal scrollbar. 996 if (mpHorizontalScrollBar.get()!=NULL 997 && mpHorizontalScrollBar->IsVisible()) 998 { 999 int nLocalLeft = nLeft; 1000 if (mpLayerTabBar.get()!=NULL && mpLayerTabBar->IsVisible()) 1001 nLocalLeft += mpLayerTabBar->GetSizePixel().Width(); 1002 nBottom -= maScrBarWH.Height(); 1003 mpHorizontalScrollBar->SetPosSizePixel ( 1004 Point(nLocalLeft,nBottom), 1005 Size(nRight-nLocalLeft-maScrBarWH.Width(),maScrBarWH.Height())); 1006 } 1007 1008 // Vertical scrollbar. 1009 if (mpVerticalScrollBar.get()!=NULL 1010 && mpVerticalScrollBar->IsVisible()) 1011 { 1012 nRight -= maScrBarWH.Width(); 1013 mpVerticalScrollBar->SetPosSizePixel ( 1014 Point(nRight,nTop), 1015 Size (maScrBarWH.Width(),nBottom-nTop)); 1016 } 1017 1018 // Filler in the lower right corner. 1019 if (mpScrollBarBox.get() != NULL) 1020 { 1021 if (mpHorizontalScrollBar.get()!=NULL 1022 && mpHorizontalScrollBar->IsVisible() 1023 && mpVerticalScrollBar.get()!=NULL 1024 && mpVerticalScrollBar->IsVisible()) 1025 { 1026 mpScrollBarBox->Show(); 1027 mpScrollBarBox->SetPosSizePixel(Point(nRight, nBottom), maScrBarWH); 1028 } 1029 else 1030 mpScrollBarBox->Hide(); 1031 } 1032 1033 // Place horizontal ruler below tab bar. 1034 if (mbHasRulers && mpContentWindow.get() != NULL) 1035 { 1036 if (mpHorizontalRuler.get() != NULL) 1037 { 1038 Size aRulerSize = mpHorizontalRuler->GetSizePixel(); 1039 aRulerSize.Width() = nRight - nLeft; 1040 mpHorizontalRuler->SetPosSizePixel ( 1041 Point(nLeft,nTop), aRulerSize); 1042 if (mpVerticalRuler.get() != NULL) 1043 mpHorizontalRuler->SetBorderPos( 1044 mpVerticalRuler->GetSizePixel().Width()-1); 1045 nTop += aRulerSize.Height(); 1046 } 1047 if (mpVerticalRuler.get() != NULL) 1048 { 1049 Size aRulerSize = mpVerticalRuler->GetSizePixel(); 1050 aRulerSize.Height() = nBottom - nTop; 1051 mpVerticalRuler->SetPosSizePixel ( 1052 Point (nLeft,nTop), aRulerSize); 1053 nLeft += aRulerSize.Width(); 1054 } 1055 } 1056 1057 rtl::Reference< SlideShow > xSlideShow( SlideShow::GetSlideShow( GetViewShellBase() ) ); 1058 1059 // The size of the window of the center pane is set differently from 1060 // that of the windows in the docking windows. 1061 bool bSlideShowActive = (xSlideShow.is() && xSlideShow->isRunning()) && !xSlideShow->isFullScreen() && xSlideShow->getAnimationMode() == ANIMATIONMODE_SHOW; 1062 if ( !bSlideShowActive) 1063 { 1064 OSL_ASSERT (GetViewShell()!=NULL); 1065 1066 if (mpContentWindow) 1067 mpContentWindow->SetPosSizePixel( 1068 Point(nLeft,nTop), 1069 Size(nRight-nLeft,nBottom-nTop)); 1070 } 1071 1072 // Windows in the center and rulers at the left and top side. 1073 maAllWindowRectangle = Rectangle( 1074 maViewPos, 1075 Size(maViewSize.Width()-maScrBarWH.Width(), 1076 maViewSize.Height()-maScrBarWH.Height())); 1077 1078 if (mpContentWindow.get() != NULL) 1079 { 1080 mpContentWindow->UpdateMapOrigin(); 1081 } 1082 1083 UpdateScrollBars(); 1084 1085 mpImpl->mbArrangeActive = false; 1086 } 1087 1088 1089 1090 1091 void ViewShell::SetUIUnit(FieldUnit eUnit) 1092 { 1093 // Set unit at horizontal and vertical rulers. 1094 if (mpHorizontalRuler.get() != NULL) 1095 mpHorizontalRuler->SetUnit(eUnit); 1096 1097 1098 if (mpVerticalRuler.get() != NULL) 1099 mpVerticalRuler->SetUnit(eUnit); 1100 } 1101 1102 /************************************************************************* 1103 |* 1104 |* DefTab an den horizontalen Linealen setzen 1105 |* 1106 \************************************************************************/ 1107 void ViewShell::SetDefTabHRuler( sal_uInt16 nDefTab ) 1108 { 1109 if (mpHorizontalRuler.get() != NULL) 1110 mpHorizontalRuler->SetDefTabDist( nDefTab ); 1111 } 1112 1113 1114 1115 1116 /** Tell the FmFormShell that the view shell is closing. Give it the 1117 oportunity to prevent that. 1118 */ 1119 sal_uInt16 ViewShell::PrepareClose (sal_Bool bUI, sal_Bool bForBrowsing) 1120 { 1121 sal_uInt16 nResult = sal_True; 1122 1123 FmFormShell* pFormShell = GetViewShellBase().GetFormShellManager()->GetFormShell(); 1124 if (pFormShell != NULL) 1125 nResult = pFormShell->PrepareClose (bUI, bForBrowsing); 1126 1127 return nResult; 1128 } 1129 1130 1131 1132 1133 void ViewShell::UpdatePreview (SdPage*, sal_Bool ) 1134 { 1135 // Do nothing. After the actual preview has been removed, 1136 // OutlineViewShell::UpdatePreview() is the place where something 1137 // usefull is still done. 1138 } 1139 1140 ::svl::IUndoManager* ViewShell::ImpGetUndoManager (void) const 1141 { 1142 const ViewShell* pMainViewShell = GetViewShellBase().GetMainViewShell().get(); 1143 1144 if( pMainViewShell == 0 ) 1145 pMainViewShell = this; 1146 1147 ::sd::View* pView = pMainViewShell->GetView(); 1148 1149 // check for text edit our outline view 1150 if( pView ) 1151 { 1152 if( pMainViewShell->GetShellType() == ViewShell::ST_OUTLINE ) 1153 { 1154 OutlineView* pOlView = dynamic_cast< OutlineView* >( pView ); 1155 if( pOlView ) 1156 { 1157 ::Outliner* pOutl = pOlView->GetOutliner(); 1158 if( pOutl ) 1159 return &pOutl->GetUndoManager(); 1160 } 1161 } 1162 else if( pView->IsTextEdit() ) 1163 { 1164 SdrOutliner* pOL = pView->GetTextEditOutliner(); 1165 if( pOL ) 1166 return &pOL->GetUndoManager(); 1167 } 1168 } 1169 1170 if( GetDocSh() ) 1171 return GetDocSh()->GetUndoManager(); 1172 1173 return NULL; 1174 } 1175 1176 1177 1178 1179 void ViewShell::ImpGetUndoStrings(SfxItemSet &rSet) const 1180 { 1181 ::svl::IUndoManager* pUndoManager = ImpGetUndoManager(); 1182 if(pUndoManager) 1183 { 1184 sal_uInt16 nCount(pUndoManager->GetUndoActionCount()); 1185 if(nCount) 1186 { 1187 // prepare list 1188 List aStringList; 1189 sal_uInt16 a; 1190 1191 for( a = 0; a < nCount; a++) 1192 { 1193 // generate one String in list per undo step 1194 String* pInsertString = new String(pUndoManager->GetUndoActionComment(a)); 1195 aStringList.Insert(pInsertString, LIST_APPEND); 1196 } 1197 1198 // set item 1199 rSet.Put(SfxStringListItem(SID_GETUNDOSTRINGS, &aStringList)); 1200 1201 // delete Strings again 1202 for(a = 0; a < nCount; a++) 1203 delete (String*)aStringList.GetObject(a); 1204 } 1205 else 1206 { 1207 rSet.DisableItem(SID_GETUNDOSTRINGS); 1208 } 1209 } 1210 } 1211 1212 // ----------------------------------------------------------------------------- 1213 1214 void ViewShell::ImpGetRedoStrings(SfxItemSet &rSet) const 1215 { 1216 ::svl::IUndoManager* pUndoManager = ImpGetUndoManager(); 1217 if(pUndoManager) 1218 { 1219 sal_uInt16 nCount(pUndoManager->GetRedoActionCount()); 1220 if(nCount) 1221 { 1222 // prepare list 1223 List aStringList; 1224 sal_uInt16 a; 1225 1226 for( a = 0; a < nCount; a++) 1227 { 1228 // generate one String in list per undo step 1229 String* pInsertString = new String(pUndoManager->GetRedoActionComment(a)); 1230 aStringList.Insert(pInsertString, LIST_APPEND); 1231 } 1232 1233 // set item 1234 rSet.Put(SfxStringListItem(SID_GETREDOSTRINGS, &aStringList)); 1235 1236 // delete Strings again 1237 for(a = 0; a < nCount; a++) 1238 delete (String*)aStringList.GetObject(a); 1239 } 1240 else 1241 { 1242 rSet.DisableItem(SID_GETREDOSTRINGS); 1243 } 1244 } 1245 } 1246 1247 // ----------------------------------------------------------------------------- 1248 1249 void ViewShell::ImpSidUndo(sal_Bool, SfxRequest& rReq) 1250 { 1251 ::svl::IUndoManager* pUndoManager = ImpGetUndoManager(); 1252 sal_uInt16 nNumber(1); 1253 const SfxItemSet* pReqArgs = rReq.GetArgs(); 1254 1255 if(pReqArgs) 1256 { 1257 SfxUInt16Item* pUIntItem = (SfxUInt16Item*)&pReqArgs->Get(SID_UNDO); 1258 nNumber = pUIntItem->GetValue(); 1259 } 1260 1261 if(nNumber && pUndoManager) 1262 { 1263 sal_uInt16 nCount(pUndoManager->GetUndoActionCount()); 1264 if(nCount >= nNumber) 1265 { 1266 try 1267 { 1268 // #94637# when UndoStack is cleared by ModifyPageUndoAction 1269 // the nCount may have changed, so test GetUndoActionCount() 1270 while(nNumber-- && pUndoManager->GetUndoActionCount()) 1271 { 1272 pUndoManager->Undo(); 1273 } 1274 } 1275 catch( const Exception& e ) 1276 { 1277 // no need to handle. By definition, the UndoManager handled this by clearing the 1278 // Undo/Redo stacks 1279 } 1280 } 1281 1282 // #91081# refresh rulers, maybe UNDO was move of TAB marker in ruler 1283 if (mbHasRulers) 1284 { 1285 Invalidate(SID_ATTR_TABSTOP); 1286 } 1287 } 1288 1289 // This one is corresponding to the default handling 1290 // of SID_UNDO in sfx2 1291 GetViewFrame()->GetBindings().InvalidateAll(sal_False); 1292 1293 rReq.Done(); 1294 } 1295 1296 // ----------------------------------------------------------------------------- 1297 1298 void ViewShell::ImpSidRedo(sal_Bool, SfxRequest& rReq) 1299 { 1300 ::svl::IUndoManager* pUndoManager = ImpGetUndoManager(); 1301 sal_uInt16 nNumber(1); 1302 const SfxItemSet* pReqArgs = rReq.GetArgs(); 1303 1304 if(pReqArgs) 1305 { 1306 SfxUInt16Item* pUIntItem = (SfxUInt16Item*)&pReqArgs->Get(SID_REDO); 1307 nNumber = pUIntItem->GetValue(); 1308 } 1309 1310 if(nNumber && pUndoManager) 1311 { 1312 sal_uInt16 nCount(pUndoManager->GetRedoActionCount()); 1313 if(nCount >= nNumber) 1314 { 1315 try 1316 { 1317 // #94637# when UndoStack is cleared by ModifyPageRedoAction 1318 // the nCount may have changed, so test GetRedoActionCount() 1319 while(nNumber-- && pUndoManager->GetRedoActionCount()) 1320 { 1321 pUndoManager->Redo(); 1322 } 1323 } 1324 catch( const Exception& e ) 1325 { 1326 // no need to handle. By definition, the UndoManager handled this by clearing the 1327 // Undo/Redo stacks 1328 } 1329 } 1330 1331 // #91081# refresh rulers, maybe REDO was move of TAB marker in ruler 1332 if (mbHasRulers) 1333 { 1334 Invalidate(SID_ATTR_TABSTOP); 1335 } 1336 } 1337 1338 // This one is corresponding to the default handling 1339 // of SID_UNDO in sfx2 1340 GetViewFrame()->GetBindings().InvalidateAll(sal_False); 1341 1342 rReq.Done(); 1343 } 1344 1345 // ----------------------------------------------------------------------------- 1346 1347 void ViewShell::ExecReq( SfxRequest& rReq ) 1348 { 1349 sal_uInt16 nSlot = rReq.GetSlot(); 1350 switch( nSlot ) 1351 { 1352 case SID_MAIL_SCROLLBODY_PAGEDOWN: 1353 { 1354 FunctionReference xFunc( GetCurrentFunction() ); 1355 if( xFunc.is() ) 1356 { 1357 xFunc->ScrollStart(); 1358 ScrollLines( 0, -1 ); 1359 xFunc->ScrollEnd(); 1360 } 1361 1362 rReq.Done(); 1363 } 1364 break; 1365 1366 case SID_OUTPUT_QUALITY_COLOR: 1367 case SID_OUTPUT_QUALITY_GRAYSCALE: 1368 case SID_OUTPUT_QUALITY_BLACKWHITE: 1369 case SID_OUTPUT_QUALITY_CONTRAST: 1370 { 1371 sal_uLong nMode = OUTPUT_DRAWMODE_COLOR; 1372 1373 switch( nSlot ) 1374 { 1375 case SID_OUTPUT_QUALITY_COLOR: nMode = OUTPUT_DRAWMODE_COLOR; break; 1376 case SID_OUTPUT_QUALITY_GRAYSCALE: nMode = OUTPUT_DRAWMODE_GRAYSCALE; break; 1377 case SID_OUTPUT_QUALITY_BLACKWHITE: nMode = OUTPUT_DRAWMODE_BLACKWHITE; break; 1378 case SID_OUTPUT_QUALITY_CONTRAST: nMode = OUTPUT_DRAWMODE_CONTRAST; break; 1379 } 1380 1381 GetActiveWindow()->SetDrawMode( nMode ); 1382 mpFrameView->SetDrawMode( nMode ); 1383 // #110094#-7 1384 // GetView()->ReleaseMasterPagePaintCache(); 1385 GetActiveWindow()->Invalidate(); 1386 1387 Invalidate(); 1388 rReq.Done(); 1389 break; 1390 } 1391 } 1392 } 1393 1394 1395 1396 1397 /** This default implemenation returns only an empty reference. See derived 1398 classes for more interesting examples. 1399 */ 1400 ::com::sun::star::uno::Reference< 1401 ::com::sun::star::accessibility::XAccessible> 1402 ViewShell::CreateAccessibleDocumentView (::sd::Window* ) 1403 { 1404 return ::com::sun::star::uno::Reference< 1405 ::com::sun::star::accessibility::XAccessible> (); 1406 } 1407 1408 1409 1410 ::sd::WindowUpdater* ViewShell::GetWindowUpdater (void) const 1411 { 1412 return mpWindowUpdater.get(); 1413 } 1414 1415 1416 1417 1418 ViewShellBase& ViewShell::GetViewShellBase (void) const 1419 { 1420 return *static_cast<ViewShellBase*>(GetViewShell()); 1421 } 1422 1423 1424 1425 1426 ViewShell::ShellType ViewShell::GetShellType (void) const 1427 { 1428 return meShellType; 1429 } 1430 1431 1432 1433 1434 DrawDocShell* ViewShell::GetDocSh (void) const 1435 { 1436 return GetViewShellBase().GetDocShell(); 1437 } 1438 1439 1440 1441 1442 SdDrawDocument* ViewShell::GetDoc (void) const 1443 { 1444 return GetViewShellBase().GetDocument(); 1445 } 1446 1447 ErrCode ViewShell::DoVerb (long ) 1448 { 1449 return ERRCODE_NONE; 1450 } 1451 1452 void ViewShell::SetCurrentFunction( const FunctionReference& xFunction) 1453 { 1454 if( mxCurrentFunction.is() && (mxOldFunction != mxCurrentFunction) ) 1455 mxCurrentFunction->Dispose(); 1456 FunctionReference xTemp( mxCurrentFunction ); 1457 mxCurrentFunction = xFunction; 1458 } 1459 1460 void ViewShell::SetOldFunction(const FunctionReference& xFunction) 1461 { 1462 if( mxOldFunction.is() && (xFunction != mxOldFunction) && (mxCurrentFunction != mxOldFunction) ) 1463 mxOldFunction->Dispose(); 1464 1465 FunctionReference xTemp( mxOldFunction ); 1466 mxOldFunction = xFunction; 1467 } 1468 1469 /** this method deactivates the current function. If an old function is 1470 saved, this will become activated and current function. 1471 */ 1472 void ViewShell::Cancel() 1473 { 1474 if(mxCurrentFunction.is() && (mxCurrentFunction != mxOldFunction )) 1475 { 1476 FunctionReference xTemp( mxCurrentFunction ); 1477 mxCurrentFunction.clear(); 1478 xTemp->Deactivate(); 1479 xTemp->Dispose(); 1480 } 1481 1482 if(mxOldFunction.is()) 1483 { 1484 mxCurrentFunction = mxOldFunction; 1485 mxCurrentFunction->Activate(); 1486 } 1487 } 1488 1489 void ViewShell::DeactivateCurrentFunction( bool bPermanent /* == false */ ) 1490 { 1491 if( mxCurrentFunction.is() ) 1492 { 1493 if(bPermanent && (mxOldFunction == mxCurrentFunction)) 1494 mxOldFunction.clear(); 1495 1496 mxCurrentFunction->Deactivate(); 1497 if( mxCurrentFunction != mxOldFunction ) 1498 mxCurrentFunction->Dispose(); 1499 1500 FunctionReference xTemp( mxCurrentFunction ); 1501 mxCurrentFunction.clear(); 1502 } 1503 } 1504 1505 void ViewShell::DisposeFunctions() 1506 { 1507 if(mxCurrentFunction.is()) 1508 { 1509 FunctionReference xTemp( mxCurrentFunction ); 1510 mxCurrentFunction.clear(); 1511 xTemp->Deactivate(); 1512 xTemp->Dispose(); 1513 } 1514 1515 if(mxOldFunction.is()) 1516 { 1517 FunctionReference xTemp( mxOldFunction ); 1518 mxOldFunction->Dispose(); 1519 mxOldFunction.clear(); 1520 } 1521 } 1522 1523 bool ViewShell::IsMainViewShell (void) const 1524 { 1525 return mpImpl->mbIsMainViewShell; 1526 // return GetViewShellBase().GetMainViewShell() == this; 1527 } 1528 1529 void ViewShell::SetIsMainViewShell (bool bIsMainViewShell) 1530 { 1531 if (bIsMainViewShell != mpImpl->mbIsMainViewShell) 1532 { 1533 mpImpl->mbIsMainViewShell = bIsMainViewShell; 1534 if (bIsMainViewShell) 1535 { 1536 GetDocSh()->Connect (this); 1537 } 1538 else 1539 { 1540 GetDocSh()->Disconnect (this); 1541 } 1542 } 1543 } 1544 1545 1546 1547 1548 ::sd::Window* ViewShell::GetActiveWindow (void) const 1549 { 1550 return mpActiveWindow; 1551 } 1552 1553 1554 1555 1556 void ViewShell::PrePaint() 1557 { 1558 } 1559 1560 1561 1562 1563 void ViewShell::Paint (const Rectangle&, ::sd::Window* ) 1564 { 1565 } 1566 1567 1568 1569 1570 void ViewShell::Draw(OutputDevice &, const Region &) 1571 { 1572 } 1573 1574 1575 1576 1577 ZoomList* ViewShell::GetZoomList (void) 1578 { 1579 return mpZoomList; 1580 } 1581 1582 1583 1584 1585 void ViewShell::ShowUIControls (bool bVisible) 1586 { 1587 mpImpl->mbIsShowingUIControls = bVisible; 1588 1589 if (mbHasRulers) 1590 { 1591 if (mpHorizontalRuler.get() != NULL) 1592 mpHorizontalRuler->Show( bVisible ); 1593 1594 if (mpVerticalRuler.get() != NULL) 1595 mpVerticalRuler->Show( bVisible ); 1596 } 1597 1598 if (mpVerticalScrollBar.get() != NULL) 1599 mpVerticalScrollBar->Show( bVisible ); 1600 1601 if (mpHorizontalScrollBar.get() != NULL) 1602 mpHorizontalScrollBar->Show( bVisible ); 1603 1604 if (mpScrollBarBox.get() != NULL) 1605 mpScrollBarBox->Show(bVisible); 1606 1607 if (mpContentWindow.get() != NULL) 1608 mpContentWindow->Show( bVisible ); 1609 } 1610 1611 1612 1613 1614 1615 bool ViewShell::RelocateToParentWindow (::Window* pParentWindow) 1616 { 1617 mpParentWindow = pParentWindow; 1618 1619 mpParentWindow->SetBackground (Wallpaper()); 1620 1621 if (mpContentWindow.get() != NULL) 1622 mpContentWindow->SetParent(pParentWindow); 1623 1624 if (mpHorizontalScrollBar.get() != NULL) 1625 mpHorizontalScrollBar->SetParent(mpParentWindow); 1626 if (mpVerticalScrollBar.get() != NULL) 1627 mpVerticalScrollBar->SetParent(mpParentWindow); 1628 if (mpScrollBarBox.get() != NULL) 1629 mpScrollBarBox->SetParent(mpParentWindow); 1630 1631 return true; 1632 } 1633 1634 void ViewShell::SwitchViewFireFocus(::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > xAcc ) 1635 { 1636 if (xAcc.get()) 1637 { 1638 ::accessibility::AccessibleDocumentViewBase* pBase = static_cast< ::accessibility::AccessibleDocumentViewBase* >(xAcc.get()); 1639 if (pBase) 1640 { 1641 pBase->SwitchViewActivated(); 1642 } 1643 } 1644 } 1645 void ViewShell::SwitchActiveViewFireFocus() 1646 { 1647 if (mpContentWindow) 1648 { 1649 SwitchViewFireFocus(mpContentWindow->GetAccessible(sal_False)); 1650 } 1651 } 1652 // move these two methods from DrawViewShell. 1653 void ViewShell::fireSwitchCurrentPage(sal_Int32 pageIndex) 1654 { 1655 GetViewShellBase().GetDrawController().fireSwitchCurrentPage(pageIndex); 1656 } 1657 void ViewShell::NotifyAccUpdate( ) 1658 { 1659 GetViewShellBase().GetDrawController().NotifyAccUpdate(); 1660 } 1661 1662 1663 } // end of namespace sd 1664 1665 1666 1667 1668 1669 //===== ViewShellObjectBarFactory ============================================= 1670 1671 namespace { 1672 1673 ViewShellObjectBarFactory::ViewShellObjectBarFactory ( 1674 ::sd::ViewShell& rViewShell) 1675 : mrViewShell (rViewShell) 1676 { 1677 } 1678 1679 1680 1681 1682 ViewShellObjectBarFactory::~ViewShellObjectBarFactory (void) 1683 { 1684 for (ShellCache::iterator aI(maShellCache.begin()); 1685 aI!=maShellCache.end(); 1686 aI++) 1687 { 1688 delete aI->second; 1689 } 1690 } 1691 1692 1693 1694 1695 SfxShell* ViewShellObjectBarFactory::CreateShell ( 1696 ::sd::ShellId nId, 1697 ::Window*, 1698 ::sd::FrameView* ) 1699 { 1700 SfxShell* pShell = NULL; 1701 1702 ShellCache::iterator aI (maShellCache.find(nId)); 1703 if (aI == maShellCache.end() || aI->second==NULL) 1704 { 1705 ::sd::View* pView = mrViewShell.GetView(); 1706 switch (nId) 1707 { 1708 case RID_BEZIER_TOOLBOX: 1709 pShell = new ::sd::BezierObjectBar(&mrViewShell, pView); 1710 break; 1711 1712 case RID_DRAW_TEXT_TOOLBOX: 1713 pShell = new ::sd::TextObjectBar( 1714 &mrViewShell, mrViewShell.GetDoc()->GetPool(), pView); 1715 break; 1716 1717 case RID_DRAW_GRAF_TOOLBOX: 1718 pShell = new ::sd::GraphicObjectBar(&mrViewShell, pView); 1719 break; 1720 1721 case RID_DRAW_MEDIA_TOOLBOX: 1722 pShell = new ::sd::MediaObjectBar(&mrViewShell, pView); 1723 break; 1724 1725 case RID_DRAW_TABLE_TOOLBOX: 1726 pShell = ::sd::ui::table::CreateTableObjectBar( mrViewShell, pView ); 1727 break; 1728 1729 case RID_SVX_EXTRUSION_BAR: 1730 pShell = new ::svx::ExtrusionBar( 1731 &mrViewShell.GetViewShellBase()); 1732 break; 1733 1734 case RID_SVX_FONTWORK_BAR: 1735 pShell = new ::svx::FontworkBar( 1736 &mrViewShell.GetViewShellBase()); 1737 break; 1738 1739 default: 1740 pShell = NULL; 1741 break; 1742 } 1743 } 1744 else 1745 pShell = aI->second; 1746 1747 return pShell; 1748 } 1749 1750 1751 1752 1753 void ViewShellObjectBarFactory::ReleaseShell (SfxShell* pShell) 1754 { 1755 if (pShell != NULL) 1756 delete pShell; 1757 } 1758 1759 } // end of anonymous namespace 1760