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 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 if(!bReturn) 483 { 484 rtl::Reference< SlideShow > xSlideShow( SlideShow::GetSlideShow( GetViewShellBase() ) ); 485 if(xSlideShow.is() && xSlideShow->isRunning()) 486 { 487 bReturn = xSlideShow->keyInput(rKEvt); 488 } 489 else 490 { 491 bool bConsumed = false; 492 if( GetView() ) 493 bConsumed = GetView()->getSmartTags().KeyInput(rKEvt); 494 495 496 if( !bConsumed ) 497 { 498 rtl::Reference< sdr::SelectionController > xSelectionController( GetView()->getSelectionController() ); 499 if( !xSelectionController.is() || !xSelectionController->onKeyInput( rKEvt, pWin ) ) 500 { 501 if(HasCurrentFunction()) 502 bReturn = GetCurrentFunction()->KeyInput(rKEvt); 503 } 504 else 505 { 506 bReturn = sal_True; 507 } 508 } 509 } 510 } 511 512 if(!bReturn && GetActiveWindow()) 513 { 514 KeyCode aKeyCode = rKEvt.GetKeyCode(); 515 516 if (aKeyCode.IsMod1() && aKeyCode.IsShift() 517 && aKeyCode.GetCode() == KEY_R) 518 { 519 InvalidateWindows(); 520 bReturn = sal_True; 521 } 522 } 523 524 return(bReturn); 525 } 526 527 /************************************************************************* 528 |* 529 |* MouseButtonDown event 530 |* 531 \************************************************************************/ 532 533 void ViewShell::MouseButtonDown(const MouseEvent& rMEvt, ::sd::Window* pWin) 534 { 535 // We have to lock tool bar updates while the mouse button is pressed in 536 // order to prevent the shape under the mouse to be moved (this happens 537 // when the number of docked tool bars changes as result of a changed 538 // selection; this changes the window size and thus the mouse position 539 // in model coordinates: with respect to model coordinates the mouse 540 // moves.) 541 OSL_ASSERT(mpImpl->mpUpdateLockForMouse.expired()); 542 mpImpl->mpUpdateLockForMouse = ViewShell::Implementation::ToolBarManagerLock::Create( 543 GetViewShellBase().GetToolBarManager()); 544 545 if ( pWin && !pWin->HasFocus() ) 546 { 547 pWin->GrabFocus(); 548 SetActiveWindow(pWin); 549 // GetViewFrame()->GetWindow().GrabFocus(); 550 } 551 552 // MouseEvent in E3dView eintragen 553 if (GetView() != NULL) 554 GetView()->SetMouseEvent(rMEvt); 555 556 bool bConsumed = false; 557 if( GetView() ) 558 bConsumed = GetView()->getSmartTags().MouseButtonDown( rMEvt ); 559 560 if( !bConsumed ) 561 { 562 rtl::Reference< sdr::SelectionController > xSelectionController( GetView()->getSelectionController() ); 563 if( !xSelectionController.is() || !xSelectionController->onMouseButtonDown( rMEvt, pWin ) ) 564 { 565 if(HasCurrentFunction()) 566 { 567 GetCurrentFunction()->MouseButtonDown(rMEvt); 568 } 569 } 570 } 571 } 572 573 /************************************************************************* 574 |* 575 |* MouseMove event 576 |* 577 \************************************************************************/ 578 579 void ViewShell::MouseMove(const MouseEvent& rMEvt, ::sd::Window* pWin) 580 { 581 if (rMEvt.IsLeaveWindow()) 582 { 583 if ( ! mpImpl->mpUpdateLockForMouse.expired()) 584 { 585 ::boost::shared_ptr<ViewShell::Implementation::ToolBarManagerLock> pLock( 586 mpImpl->mpUpdateLockForMouse); 587 if (pLock.get() != NULL) 588 pLock->Release(); 589 } 590 } 591 592 if ( pWin ) 593 { 594 SetActiveWindow(pWin); 595 } 596 597 // MouseEvent in E3dView eintragen 598 if (GetView() != NULL) 599 GetView()->SetMouseEvent(rMEvt); 600 601 if(HasCurrentFunction()) 602 { 603 rtl::Reference< sdr::SelectionController > xSelectionController( GetView()->getSelectionController() ); 604 if( !xSelectionController.is() || !xSelectionController->onMouseMove( rMEvt, pWin ) ) 605 { 606 if(HasCurrentFunction()) 607 GetCurrentFunction()->MouseMove(rMEvt); 608 } 609 } 610 } 611 612 /************************************************************************* 613 |* 614 |* MouseButtonUp event 615 |* 616 \************************************************************************/ 617 618 void ViewShell::MouseButtonUp(const MouseEvent& rMEvt, ::sd::Window* pWin) 619 { 620 if ( pWin ) 621 { 622 SetActiveWindow(pWin); 623 } 624 625 // MouseEvent in E3dView eintragen 626 if (GetView() != NULL) 627 GetView()->SetMouseEvent(rMEvt); 628 629 if( HasCurrentFunction()) 630 { 631 rtl::Reference< sdr::SelectionController > xSelectionController( GetView()->getSelectionController() ); 632 if( !xSelectionController.is() || !xSelectionController->onMouseButtonUp( rMEvt, pWin ) ) 633 { 634 if(HasCurrentFunction()) 635 GetCurrentFunction()->MouseButtonUp(rMEvt); 636 } 637 } 638 639 if ( ! mpImpl->mpUpdateLockForMouse.expired()) 640 { 641 ::boost::shared_ptr<ViewShell::Implementation::ToolBarManagerLock> pLock( 642 mpImpl->mpUpdateLockForMouse); 643 if (pLock.get() != NULL) 644 pLock->Release(); 645 } 646 } 647 648 649 /************************************************************************* 650 |* 651 |* Command event 652 |* 653 \************************************************************************/ 654 655 void ViewShell::Command(const CommandEvent& rCEvt, ::sd::Window* pWin) 656 { 657 sal_Bool bDone = HandleScrollCommand (rCEvt, pWin); 658 659 if( !bDone ) 660 { 661 if( rCEvt.GetCommand() == COMMAND_INPUTLANGUAGECHANGE ) 662 { 663 //#i42732# update state of fontname if input language changes 664 GetViewFrame()->GetBindings().Invalidate( SID_ATTR_CHAR_FONT ); 665 GetViewFrame()->GetBindings().Invalidate( SID_ATTR_CHAR_FONTHEIGHT ); 666 } 667 else 668 { 669 bool bConsumed = false; 670 if( GetView() ) 671 { 672 bConsumed = GetView()->getSmartTags().Command(rCEvt); 673 } 674 675 if( !bConsumed && HasCurrentFunction()) 676 { 677 GetCurrentFunction()->Command(rCEvt); 678 } 679 } 680 } 681 } 682 683 long ViewShell::Notify(NotifyEvent& rNEvt, ::sd::Window* pWin) 684 { 685 // handle scroll commands when they arrived at child windows 686 long nRet = sal_False; 687 if( rNEvt.GetType() == EVENT_COMMAND ) 688 { 689 // note: dynamic_cast is not possible as GetData() returns a void* 690 CommandEvent* pCmdEvent = reinterpret_cast< CommandEvent* >(rNEvt.GetData()); 691 nRet = HandleScrollCommand(*pCmdEvent, pWin); 692 } 693 return nRet; 694 } 695 696 697 bool ViewShell::HandleScrollCommand(const CommandEvent& rCEvt, ::sd::Window* pWin) 698 { 699 bool bDone = false; 700 701 switch( rCEvt.GetCommand() ) 702 { 703 case COMMAND_WHEEL: 704 { 705 Reference< XSlideShowController > xSlideShowController( SlideShow::GetSlideShowController(GetViewShellBase() ) ); 706 if( xSlideShowController.is() ) 707 { 708 // We ignore zooming with control+mouse wheel. 709 const CommandWheelData* pData = rCEvt.GetWheelData(); 710 if( pData && !pData->GetModifier() && ( pData->GetMode() == COMMAND_WHEEL_SCROLL ) && !pData->IsHorz() ) 711 { 712 long nDelta = pData->GetDelta(); 713 if( nDelta > 0 ) 714 { 715 xSlideShowController->gotoPreviousSlide(); 716 } 717 else if( nDelta < 0 ) 718 { 719 xSlideShowController->gotoNextEffect(); 720 } 721 } 722 break; 723 } 724 } 725 // fall through when not running slideshow 726 case COMMAND_STARTAUTOSCROLL: 727 case COMMAND_AUTOSCROLL: 728 { 729 const CommandWheelData* pData = rCEvt.GetWheelData(); 730 731 if (pData != NULL) 732 { 733 if (pData->IsMod1()) 734 { 735 if( !GetDocSh()->IsUIActive() ) 736 { 737 const long nOldZoom = GetActiveWindow()->GetZoom(); 738 long nNewZoom; 739 740 if( pData->GetDelta() < 0L ) 741 nNewZoom = Max( (long) pWin->GetMinZoom(), (long)(nOldZoom - DELTA_ZOOM) ); 742 else 743 nNewZoom = Min( (long) pWin->GetMaxZoom(), (long)(nOldZoom + DELTA_ZOOM) ); 744 745 SetZoom( nNewZoom ); 746 Invalidate( SID_ATTR_ZOOM ); 747 Invalidate( SID_ATTR_ZOOMSLIDER ); 748 749 bDone = true; 750 } 751 } 752 else 753 { 754 if( mpContentWindow.get() == pWin ) 755 { 756 sal_uLong nScrollLines = pData->GetScrollLines(); 757 if(IsPageFlipMode()) 758 nScrollLines = COMMAND_WHEEL_PAGESCROLL; 759 CommandWheelData aWheelData( pData->GetDelta(),pData->GetNotchDelta(), 760 nScrollLines,pData->GetMode(),pData->GetModifier(),pData->IsHorz() ); 761 CommandEvent aReWrite( rCEvt.GetMousePosPixel(),rCEvt.GetCommand(), 762 rCEvt.IsMouseEvent(),(const void *) &aWheelData ); 763 bDone = pWin->HandleScrollCommand( aReWrite, 764 mpHorizontalScrollBar.get(), 765 mpVerticalScrollBar.get()) == sal_True; 766 } 767 } 768 } 769 } 770 break; 771 772 default: 773 break; 774 } 775 776 return bDone; 777 } 778 779 780 781 void ViewShell::SetupRulers (void) 782 { 783 if(mbHasRulers && (mpContentWindow.get() != NULL) && !SlideShow::IsRunning(GetViewShellBase())) 784 { 785 long nHRulerOfs = 0; 786 787 if ( mpVerticalRuler.get() == NULL ) 788 { 789 mpVerticalRuler.reset(CreateVRuler(GetActiveWindow())); 790 if ( mpVerticalRuler.get() != NULL ) 791 { 792 nHRulerOfs = mpVerticalRuler->GetSizePixel().Width(); 793 mpVerticalRuler->SetActive(sal_True); 794 mpVerticalRuler->Show(); 795 } 796 } 797 if ( mpHorizontalRuler.get() == NULL ) 798 { 799 mpHorizontalRuler.reset(CreateHRuler(GetActiveWindow(), sal_True)); 800 if ( mpHorizontalRuler.get() != NULL ) 801 { 802 mpHorizontalRuler->SetWinPos(nHRulerOfs); 803 mpHorizontalRuler->SetActive(sal_True); 804 mpHorizontalRuler->Show(); 805 } 806 } 807 } 808 } 809 810 const SfxPoolItem* ViewShell::GetNumBulletItem(SfxItemSet& aNewAttr, sal_uInt16& nNumItemId) 811 { 812 const SfxPoolItem* pTmpItem = NULL; 813 814 if(aNewAttr.GetItemState(nNumItemId, sal_False, &pTmpItem) == SFX_ITEM_SET) 815 { 816 return pTmpItem; 817 } 818 else 819 { 820 nNumItemId = aNewAttr.GetPool()->GetWhich(SID_ATTR_NUMBERING_RULE); 821 SfxItemState eState = aNewAttr.GetItemState(nNumItemId, sal_False, &pTmpItem); 822 if (eState == SFX_ITEM_SET) 823 return pTmpItem; 824 else 825 { 826 sal_Bool bOutliner = sal_False; 827 sal_Bool bTitle = sal_False; 828 829 if( mpView ) 830 { 831 const SdrMarkList& rMarkList = mpView->GetMarkedObjectList(); 832 const sal_uInt32 nCount = rMarkList.GetMarkCount(); 833 834 for(sal_uInt32 nNum = 0; nNum < nCount; nNum++) 835 { 836 SdrObject* pObj = rMarkList.GetMark(nNum)->GetMarkedSdrObj(); 837 if( pObj->GetObjInventor() == SdrInventor ) 838 { 839 switch(pObj->GetObjIdentifier()) 840 { 841 case OBJ_TITLETEXT: 842 bTitle = sal_True; 843 break; 844 case OBJ_OUTLINETEXT: 845 bOutliner = sal_True; 846 break; 847 } 848 } 849 } 850 } 851 852 const SvxNumBulletItem *pItem = NULL; 853 if(bOutliner) 854 { 855 SfxStyleSheetBasePool* pSSPool = mpView->GetDocSh()->GetStyleSheetPool(); 856 String aStyleName((SdResId(STR_LAYOUT_OUTLINE))); 857 aStyleName.AppendAscii( RTL_CONSTASCII_STRINGPARAM( " 1" ) ); 858 SfxStyleSheetBase* pFirstStyleSheet = pSSPool->Find( aStyleName, SD_STYLE_FAMILY_PSEUDO); 859 if( pFirstStyleSheet ) 860 pFirstStyleSheet->GetItemSet().GetItemState(EE_PARA_NUMBULLET, sal_False, (const SfxPoolItem**)&pItem); 861 } 862 863 if( pItem == NULL ) 864 pItem = (SvxNumBulletItem*) aNewAttr.GetPool()->GetSecondaryPool()->GetPoolDefaultItem(EE_PARA_NUMBULLET); 865 866 aNewAttr.Put(*pItem, EE_PARA_NUMBULLET); 867 868 if(bTitle && aNewAttr.GetItemState(EE_PARA_NUMBULLET,sal_True) == SFX_ITEM_ON ) 869 { 870 SvxNumBulletItem* pItem = (SvxNumBulletItem*)aNewAttr.GetItem(EE_PARA_NUMBULLET,sal_True); 871 SvxNumRule* pRule = pItem->GetNumRule(); 872 if(pRule) 873 { 874 SvxNumRule aNewRule( *pRule ); 875 aNewRule.SetFeatureFlag( NUM_NO_NUMBERS, sal_True ); 876 877 SvxNumBulletItem aNewItem( aNewRule, EE_PARA_NUMBULLET ); 878 aNewAttr.Put(aNewItem); 879 } 880 } 881 882 SfxItemState eState = aNewAttr.GetItemState(nNumItemId, sal_False, &pTmpItem); 883 if (eState == SFX_ITEM_SET) 884 return pTmpItem; 885 886 } 887 } 888 return pTmpItem; 889 } 890 891 892 sal_Bool ViewShell::HasRuler (void) 893 { 894 return mbHasRulers; 895 } 896 897 898 899 900 void ViewShell::Resize (void) 901 { 902 SetupRulers (); 903 904 if (mpParentWindow == NULL) 905 return; 906 907 // Make sure that the new size is not degenerate. 908 const Size aSize (mpParentWindow->GetSizePixel()); 909 if (aSize.Width()==0 || aSize.Height()==0) 910 return; 911 912 // Remember the new position and size. 913 maViewPos = Point(0,0); //mpParentWindow->GetPosPixel(); 914 maViewSize = aSize; 915 916 // Rearrange the UI elements to take care of the new position and size. 917 ArrangeGUIElements (); 918 // end of included AdjustPosSizePixel. 919 920 Size aS (GetParentWindow()->GetOutputSizePixel()); 921 Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel(); 922 Rectangle aVisArea = GetParentWindow()->PixelToLogic( 923 Rectangle( Point(0,0), aVisSizePixel)); 924 Rectangle aCurrentVisArea (GetDocSh()->GetVisArea(ASPECT_CONTENT)); 925 Rectangle aWindowRect = GetActiveWindow()->LogicToPixel(aCurrentVisArea); 926 if (GetDocSh()->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED 927 && IsMainViewShell()) 928 { 929 // GetDocSh()->SetVisArea(aVisArea); 930 } 931 932 // VisAreaChanged(aVisArea); 933 934 ::sd::View* pView = GetView(); 935 936 if (pView) 937 { 938 pView->VisAreaChanged(GetActiveWindow()); 939 } 940 } 941 942 SvBorder ViewShell::GetBorder (bool ) 943 { 944 SvBorder aBorder; 945 946 // Horizontal scrollbar. 947 if (mpHorizontalScrollBar.get()!=NULL 948 && mpHorizontalScrollBar->IsVisible()) 949 { 950 aBorder.Bottom() = maScrBarWH.Height(); 951 } 952 953 // Vertical scrollbar. 954 if (mpVerticalScrollBar.get()!=NULL 955 && mpVerticalScrollBar->IsVisible()) 956 { 957 aBorder.Right() = maScrBarWH.Width(); 958 } 959 960 // Place horizontal ruler below tab bar. 961 if (mbHasRulers && mpContentWindow.get() != NULL) 962 { 963 SetupRulers(); 964 if (mpHorizontalRuler.get() != NULL) 965 aBorder.Top() = mpHorizontalRuler->GetSizePixel().Height(); 966 if (mpVerticalRuler.get() != NULL) 967 aBorder.Left() = mpVerticalRuler->GetSizePixel().Width(); 968 } 969 970 return aBorder; 971 } 972 973 974 975 976 void ViewShell::ArrangeGUIElements (void) 977 { 978 if (mpImpl->mbArrangeActive) 979 return; 980 mpImpl->mbArrangeActive = true; 981 982 // Calculate border for in-place editing. 983 long nLeft = maViewPos.X(); 984 long nTop = maViewPos.Y(); 985 long nRight = maViewPos.X() + maViewSize.Width(); 986 long nBottom = maViewPos.Y() + maViewSize.Height(); 987 988 // Horizontal scrollbar. 989 if (mpHorizontalScrollBar.get()!=NULL 990 && mpHorizontalScrollBar->IsVisible()) 991 { 992 int nLocalLeft = nLeft; 993 if (mpLayerTabBar.get()!=NULL && mpLayerTabBar->IsVisible()) 994 nLocalLeft += mpLayerTabBar->GetSizePixel().Width(); 995 nBottom -= maScrBarWH.Height(); 996 mpHorizontalScrollBar->SetPosSizePixel ( 997 Point(nLocalLeft,nBottom), 998 Size(nRight-nLocalLeft-maScrBarWH.Width(),maScrBarWH.Height())); 999 } 1000 1001 // Vertical scrollbar. 1002 if (mpVerticalScrollBar.get()!=NULL 1003 && mpVerticalScrollBar->IsVisible()) 1004 { 1005 nRight -= maScrBarWH.Width(); 1006 mpVerticalScrollBar->SetPosSizePixel ( 1007 Point(nRight,nTop), 1008 Size (maScrBarWH.Width(),nBottom-nTop)); 1009 } 1010 1011 // Filler in the lower right corner. 1012 if (mpScrollBarBox.get() != NULL) 1013 { 1014 if (mpHorizontalScrollBar.get()!=NULL 1015 && mpHorizontalScrollBar->IsVisible() 1016 && mpVerticalScrollBar.get()!=NULL 1017 && mpVerticalScrollBar->IsVisible()) 1018 { 1019 mpScrollBarBox->Show(); 1020 mpScrollBarBox->SetPosSizePixel(Point(nRight, nBottom), maScrBarWH); 1021 } 1022 else 1023 mpScrollBarBox->Hide(); 1024 } 1025 1026 // Place horizontal ruler below tab bar. 1027 if (mbHasRulers && mpContentWindow.get() != NULL) 1028 { 1029 if (mpHorizontalRuler.get() != NULL) 1030 { 1031 Size aRulerSize = mpHorizontalRuler->GetSizePixel(); 1032 aRulerSize.Width() = nRight - nLeft; 1033 mpHorizontalRuler->SetPosSizePixel ( 1034 Point(nLeft,nTop), aRulerSize); 1035 if (mpVerticalRuler.get() != NULL) 1036 mpHorizontalRuler->SetBorderPos( 1037 mpVerticalRuler->GetSizePixel().Width()-1); 1038 nTop += aRulerSize.Height(); 1039 } 1040 if (mpVerticalRuler.get() != NULL) 1041 { 1042 Size aRulerSize = mpVerticalRuler->GetSizePixel(); 1043 aRulerSize.Height() = nBottom - nTop; 1044 mpVerticalRuler->SetPosSizePixel ( 1045 Point (nLeft,nTop), aRulerSize); 1046 nLeft += aRulerSize.Width(); 1047 } 1048 } 1049 1050 rtl::Reference< SlideShow > xSlideShow( SlideShow::GetSlideShow( GetViewShellBase() ) ); 1051 1052 // The size of the window of the center pane is set differently from 1053 // that of the windows in the docking windows. 1054 bool bSlideShowActive = (xSlideShow.is() && xSlideShow->isRunning()) && !xSlideShow->isFullScreen() && xSlideShow->getAnimationMode() == ANIMATIONMODE_SHOW; 1055 if ( !bSlideShowActive) 1056 { 1057 OSL_ASSERT (GetViewShell()!=NULL); 1058 1059 if (mpContentWindow) 1060 mpContentWindow->SetPosSizePixel( 1061 Point(nLeft,nTop), 1062 Size(nRight-nLeft,nBottom-nTop)); 1063 } 1064 1065 // Windows in the center and rulers at the left and top side. 1066 maAllWindowRectangle = Rectangle( 1067 maViewPos, 1068 Size(maViewSize.Width()-maScrBarWH.Width(), 1069 maViewSize.Height()-maScrBarWH.Height())); 1070 1071 if (mpContentWindow.get() != NULL) 1072 { 1073 mpContentWindow->UpdateMapOrigin(); 1074 } 1075 1076 UpdateScrollBars(); 1077 1078 mpImpl->mbArrangeActive = false; 1079 } 1080 1081 1082 1083 1084 void ViewShell::SetUIUnit(FieldUnit eUnit) 1085 { 1086 // Set unit at horizontal and vertical rulers. 1087 if (mpHorizontalRuler.get() != NULL) 1088 mpHorizontalRuler->SetUnit(eUnit); 1089 1090 1091 if (mpVerticalRuler.get() != NULL) 1092 mpVerticalRuler->SetUnit(eUnit); 1093 } 1094 1095 /************************************************************************* 1096 |* 1097 |* DefTab an den horizontalen Linealen setzen 1098 |* 1099 \************************************************************************/ 1100 void ViewShell::SetDefTabHRuler( sal_uInt16 nDefTab ) 1101 { 1102 if (mpHorizontalRuler.get() != NULL) 1103 mpHorizontalRuler->SetDefTabDist( nDefTab ); 1104 } 1105 1106 1107 1108 1109 /** Tell the FmFormShell that the view shell is closing. Give it the 1110 oportunity to prevent that. 1111 */ 1112 sal_uInt16 ViewShell::PrepareClose (sal_Bool bUI, sal_Bool bForBrowsing) 1113 { 1114 sal_uInt16 nResult = sal_True; 1115 1116 FmFormShell* pFormShell = GetViewShellBase().GetFormShellManager()->GetFormShell(); 1117 if (pFormShell != NULL) 1118 nResult = pFormShell->PrepareClose (bUI, bForBrowsing); 1119 1120 return nResult; 1121 } 1122 1123 1124 1125 1126 void ViewShell::UpdatePreview (SdPage*, sal_Bool ) 1127 { 1128 // Do nothing. After the actual preview has been removed, 1129 // OutlineViewShell::UpdatePreview() is the place where something 1130 // usefull is still done. 1131 } 1132 1133 ::svl::IUndoManager* ViewShell::ImpGetUndoManager (void) const 1134 { 1135 const ViewShell* pMainViewShell = GetViewShellBase().GetMainViewShell().get(); 1136 1137 if( pMainViewShell == 0 ) 1138 pMainViewShell = this; 1139 1140 ::sd::View* pView = pMainViewShell->GetView(); 1141 1142 // check for text edit our outline view 1143 if( pView ) 1144 { 1145 if( pMainViewShell->GetShellType() == ViewShell::ST_OUTLINE ) 1146 { 1147 OutlineView* pOlView = dynamic_cast< OutlineView* >( pView ); 1148 if( pOlView ) 1149 { 1150 ::Outliner* pOutl = pOlView->GetOutliner(); 1151 if( pOutl ) 1152 return &pOutl->GetUndoManager(); 1153 } 1154 } 1155 else if( pView->IsTextEdit() ) 1156 { 1157 SdrOutliner* pOL = pView->GetTextEditOutliner(); 1158 if( pOL ) 1159 return &pOL->GetUndoManager(); 1160 } 1161 } 1162 1163 if( GetDocSh() ) 1164 return GetDocSh()->GetUndoManager(); 1165 1166 return NULL; 1167 } 1168 1169 1170 1171 1172 void ViewShell::ImpGetUndoStrings(SfxItemSet &rSet) const 1173 { 1174 ::svl::IUndoManager* pUndoManager = ImpGetUndoManager(); 1175 if(pUndoManager) 1176 { 1177 sal_uInt16 nCount(pUndoManager->GetUndoActionCount()); 1178 if(nCount) 1179 { 1180 // prepare list 1181 List aStringList; 1182 sal_uInt16 a; 1183 1184 for( a = 0; a < nCount; a++) 1185 { 1186 // generate one String in list per undo step 1187 String* pInsertString = new String(pUndoManager->GetUndoActionComment(a)); 1188 aStringList.Insert(pInsertString, LIST_APPEND); 1189 } 1190 1191 // set item 1192 rSet.Put(SfxStringListItem(SID_GETUNDOSTRINGS, &aStringList)); 1193 1194 // delete Strings again 1195 for(a = 0; a < nCount; a++) 1196 delete (String*)aStringList.GetObject(a); 1197 } 1198 else 1199 { 1200 rSet.DisableItem(SID_GETUNDOSTRINGS); 1201 } 1202 } 1203 } 1204 1205 // ----------------------------------------------------------------------------- 1206 1207 void ViewShell::ImpGetRedoStrings(SfxItemSet &rSet) const 1208 { 1209 ::svl::IUndoManager* pUndoManager = ImpGetUndoManager(); 1210 if(pUndoManager) 1211 { 1212 sal_uInt16 nCount(pUndoManager->GetRedoActionCount()); 1213 if(nCount) 1214 { 1215 // prepare list 1216 List aStringList; 1217 sal_uInt16 a; 1218 1219 for( a = 0; a < nCount; a++) 1220 { 1221 // generate one String in list per undo step 1222 String* pInsertString = new String(pUndoManager->GetRedoActionComment(a)); 1223 aStringList.Insert(pInsertString, LIST_APPEND); 1224 } 1225 1226 // set item 1227 rSet.Put(SfxStringListItem(SID_GETREDOSTRINGS, &aStringList)); 1228 1229 // delete Strings again 1230 for(a = 0; a < nCount; a++) 1231 delete (String*)aStringList.GetObject(a); 1232 } 1233 else 1234 { 1235 rSet.DisableItem(SID_GETREDOSTRINGS); 1236 } 1237 } 1238 } 1239 1240 // ----------------------------------------------------------------------------- 1241 1242 void ViewShell::ImpSidUndo(sal_Bool, SfxRequest& rReq) 1243 { 1244 ::svl::IUndoManager* pUndoManager = ImpGetUndoManager(); 1245 sal_uInt16 nNumber(1); 1246 const SfxItemSet* pReqArgs = rReq.GetArgs(); 1247 1248 if(pReqArgs) 1249 { 1250 SfxUInt16Item* pUIntItem = (SfxUInt16Item*)&pReqArgs->Get(SID_UNDO); 1251 nNumber = pUIntItem->GetValue(); 1252 } 1253 1254 if(nNumber && pUndoManager) 1255 { 1256 sal_uInt16 nCount(pUndoManager->GetUndoActionCount()); 1257 if(nCount >= nNumber) 1258 { 1259 try 1260 { 1261 // #94637# when UndoStack is cleared by ModifyPageUndoAction 1262 // the nCount may have changed, so test GetUndoActionCount() 1263 while(nNumber-- && pUndoManager->GetUndoActionCount()) 1264 { 1265 pUndoManager->Undo(); 1266 } 1267 } 1268 catch( const Exception& e ) 1269 { 1270 // no need to handle. By definition, the UndoManager handled this by clearing the 1271 // Undo/Redo stacks 1272 } 1273 } 1274 1275 // #91081# refresh rulers, maybe UNDO was move of TAB marker in ruler 1276 if (mbHasRulers) 1277 { 1278 Invalidate(SID_ATTR_TABSTOP); 1279 } 1280 } 1281 1282 // This one is corresponding to the default handling 1283 // of SID_UNDO in sfx2 1284 GetViewFrame()->GetBindings().InvalidateAll(sal_False); 1285 1286 rReq.Done(); 1287 } 1288 1289 // ----------------------------------------------------------------------------- 1290 1291 void ViewShell::ImpSidRedo(sal_Bool, SfxRequest& rReq) 1292 { 1293 ::svl::IUndoManager* pUndoManager = ImpGetUndoManager(); 1294 sal_uInt16 nNumber(1); 1295 const SfxItemSet* pReqArgs = rReq.GetArgs(); 1296 1297 if(pReqArgs) 1298 { 1299 SfxUInt16Item* pUIntItem = (SfxUInt16Item*)&pReqArgs->Get(SID_REDO); 1300 nNumber = pUIntItem->GetValue(); 1301 } 1302 1303 if(nNumber && pUndoManager) 1304 { 1305 sal_uInt16 nCount(pUndoManager->GetRedoActionCount()); 1306 if(nCount >= nNumber) 1307 { 1308 try 1309 { 1310 // #94637# when UndoStack is cleared by ModifyPageRedoAction 1311 // the nCount may have changed, so test GetRedoActionCount() 1312 while(nNumber-- && pUndoManager->GetRedoActionCount()) 1313 { 1314 pUndoManager->Redo(); 1315 } 1316 } 1317 catch( const Exception& e ) 1318 { 1319 // no need to handle. By definition, the UndoManager handled this by clearing the 1320 // Undo/Redo stacks 1321 } 1322 } 1323 1324 // #91081# refresh rulers, maybe REDO was move of TAB marker in ruler 1325 if (mbHasRulers) 1326 { 1327 Invalidate(SID_ATTR_TABSTOP); 1328 } 1329 } 1330 1331 // This one is corresponding to the default handling 1332 // of SID_UNDO in sfx2 1333 GetViewFrame()->GetBindings().InvalidateAll(sal_False); 1334 1335 rReq.Done(); 1336 } 1337 1338 // ----------------------------------------------------------------------------- 1339 1340 void ViewShell::ExecReq( SfxRequest& rReq ) 1341 { 1342 sal_uInt16 nSlot = rReq.GetSlot(); 1343 switch( nSlot ) 1344 { 1345 case SID_MAIL_SCROLLBODY_PAGEDOWN: 1346 { 1347 FunctionReference xFunc( GetCurrentFunction() ); 1348 if( xFunc.is() ) 1349 { 1350 xFunc->ScrollStart(); 1351 ScrollLines( 0, -1 ); 1352 xFunc->ScrollEnd(); 1353 } 1354 1355 rReq.Done(); 1356 } 1357 break; 1358 1359 case SID_OUTPUT_QUALITY_COLOR: 1360 case SID_OUTPUT_QUALITY_GRAYSCALE: 1361 case SID_OUTPUT_QUALITY_BLACKWHITE: 1362 case SID_OUTPUT_QUALITY_CONTRAST: 1363 { 1364 sal_uLong nMode = OUTPUT_DRAWMODE_COLOR; 1365 1366 switch( nSlot ) 1367 { 1368 case SID_OUTPUT_QUALITY_COLOR: nMode = OUTPUT_DRAWMODE_COLOR; break; 1369 case SID_OUTPUT_QUALITY_GRAYSCALE: nMode = OUTPUT_DRAWMODE_GRAYSCALE; break; 1370 case SID_OUTPUT_QUALITY_BLACKWHITE: nMode = OUTPUT_DRAWMODE_BLACKWHITE; break; 1371 case SID_OUTPUT_QUALITY_CONTRAST: nMode = OUTPUT_DRAWMODE_CONTRAST; break; 1372 } 1373 1374 GetActiveWindow()->SetDrawMode( nMode ); 1375 mpFrameView->SetDrawMode( nMode ); 1376 // #110094#-7 1377 // GetView()->ReleaseMasterPagePaintCache(); 1378 GetActiveWindow()->Invalidate(); 1379 1380 Invalidate(); 1381 rReq.Done(); 1382 break; 1383 } 1384 } 1385 } 1386 1387 1388 1389 1390 /** This default implemenation returns only an empty reference. See derived 1391 classes for more interesting examples. 1392 */ 1393 ::com::sun::star::uno::Reference< 1394 ::com::sun::star::accessibility::XAccessible> 1395 ViewShell::CreateAccessibleDocumentView (::sd::Window* ) 1396 { 1397 return ::com::sun::star::uno::Reference< 1398 ::com::sun::star::accessibility::XAccessible> (); 1399 } 1400 1401 1402 1403 ::sd::WindowUpdater* ViewShell::GetWindowUpdater (void) const 1404 { 1405 return mpWindowUpdater.get(); 1406 } 1407 1408 1409 1410 1411 ViewShellBase& ViewShell::GetViewShellBase (void) const 1412 { 1413 return *static_cast<ViewShellBase*>(GetViewShell()); 1414 } 1415 1416 1417 1418 1419 ViewShell::ShellType ViewShell::GetShellType (void) const 1420 { 1421 return meShellType; 1422 } 1423 1424 1425 1426 1427 DrawDocShell* ViewShell::GetDocSh (void) const 1428 { 1429 return GetViewShellBase().GetDocShell(); 1430 } 1431 1432 1433 1434 1435 SdDrawDocument* ViewShell::GetDoc (void) const 1436 { 1437 return GetViewShellBase().GetDocument(); 1438 } 1439 1440 ErrCode ViewShell::DoVerb (long ) 1441 { 1442 return ERRCODE_NONE; 1443 } 1444 1445 void ViewShell::SetCurrentFunction( const FunctionReference& xFunction) 1446 { 1447 if( mxCurrentFunction.is() && (mxOldFunction != mxCurrentFunction) ) 1448 mxCurrentFunction->Dispose(); 1449 FunctionReference xTemp( mxCurrentFunction ); 1450 mxCurrentFunction = xFunction; 1451 } 1452 1453 void ViewShell::SetOldFunction(const FunctionReference& xFunction) 1454 { 1455 if( mxOldFunction.is() && (xFunction != mxOldFunction) && (mxCurrentFunction != mxOldFunction) ) 1456 mxOldFunction->Dispose(); 1457 1458 FunctionReference xTemp( mxOldFunction ); 1459 mxOldFunction = xFunction; 1460 } 1461 1462 /** this method deactivates the current function. If an old function is 1463 saved, this will become activated and current function. 1464 */ 1465 void ViewShell::Cancel() 1466 { 1467 if(mxCurrentFunction.is() && (mxCurrentFunction != mxOldFunction )) 1468 { 1469 FunctionReference xTemp( mxCurrentFunction ); 1470 mxCurrentFunction.clear(); 1471 xTemp->Deactivate(); 1472 xTemp->Dispose(); 1473 } 1474 1475 if(mxOldFunction.is()) 1476 { 1477 mxCurrentFunction = mxOldFunction; 1478 mxCurrentFunction->Activate(); 1479 } 1480 } 1481 1482 void ViewShell::DeactivateCurrentFunction( bool bPermanent /* == false */ ) 1483 { 1484 if( mxCurrentFunction.is() ) 1485 { 1486 if(bPermanent && (mxOldFunction == mxCurrentFunction)) 1487 mxOldFunction.clear(); 1488 1489 mxCurrentFunction->Deactivate(); 1490 if( mxCurrentFunction != mxOldFunction ) 1491 mxCurrentFunction->Dispose(); 1492 1493 FunctionReference xTemp( mxCurrentFunction ); 1494 mxCurrentFunction.clear(); 1495 } 1496 } 1497 1498 void ViewShell::DisposeFunctions() 1499 { 1500 if(mxCurrentFunction.is()) 1501 { 1502 FunctionReference xTemp( mxCurrentFunction ); 1503 mxCurrentFunction.clear(); 1504 xTemp->Deactivate(); 1505 xTemp->Dispose(); 1506 } 1507 1508 if(mxOldFunction.is()) 1509 { 1510 FunctionReference xTemp( mxOldFunction ); 1511 mxOldFunction->Dispose(); 1512 mxOldFunction.clear(); 1513 } 1514 } 1515 1516 bool ViewShell::IsMainViewShell (void) const 1517 { 1518 return mpImpl->mbIsMainViewShell; 1519 // return GetViewShellBase().GetMainViewShell() == this; 1520 } 1521 1522 void ViewShell::SetIsMainViewShell (bool bIsMainViewShell) 1523 { 1524 if (bIsMainViewShell != mpImpl->mbIsMainViewShell) 1525 { 1526 mpImpl->mbIsMainViewShell = bIsMainViewShell; 1527 if (bIsMainViewShell) 1528 { 1529 GetDocSh()->Connect (this); 1530 } 1531 else 1532 { 1533 GetDocSh()->Disconnect (this); 1534 } 1535 } 1536 } 1537 1538 1539 1540 1541 ::sd::Window* ViewShell::GetActiveWindow (void) const 1542 { 1543 return mpActiveWindow; 1544 } 1545 1546 1547 1548 1549 void ViewShell::PrePaint() 1550 { 1551 } 1552 1553 1554 1555 1556 void ViewShell::Paint (const Rectangle&, ::sd::Window* ) 1557 { 1558 } 1559 1560 1561 1562 1563 void ViewShell::Draw(OutputDevice &, const Region &) 1564 { 1565 } 1566 1567 1568 1569 1570 ZoomList* ViewShell::GetZoomList (void) 1571 { 1572 return mpZoomList; 1573 } 1574 1575 1576 1577 1578 void ViewShell::ShowUIControls (bool bVisible) 1579 { 1580 mpImpl->mbIsShowingUIControls = bVisible; 1581 1582 if (mbHasRulers) 1583 { 1584 if (mpHorizontalRuler.get() != NULL) 1585 mpHorizontalRuler->Show( bVisible ); 1586 1587 if (mpVerticalRuler.get() != NULL) 1588 mpVerticalRuler->Show( bVisible ); 1589 } 1590 1591 if (mpVerticalScrollBar.get() != NULL) 1592 mpVerticalScrollBar->Show( bVisible ); 1593 1594 if (mpHorizontalScrollBar.get() != NULL) 1595 mpHorizontalScrollBar->Show( bVisible ); 1596 1597 if (mpScrollBarBox.get() != NULL) 1598 mpScrollBarBox->Show(bVisible); 1599 1600 if (mpContentWindow.get() != NULL) 1601 mpContentWindow->Show( bVisible ); 1602 } 1603 1604 1605 1606 1607 1608 bool ViewShell::RelocateToParentWindow (::Window* pParentWindow) 1609 { 1610 mpParentWindow = pParentWindow; 1611 1612 mpParentWindow->SetBackground (Wallpaper()); 1613 1614 if (mpContentWindow.get() != NULL) 1615 mpContentWindow->SetParent(pParentWindow); 1616 1617 if (mpHorizontalScrollBar.get() != NULL) 1618 mpHorizontalScrollBar->SetParent(mpParentWindow); 1619 if (mpVerticalScrollBar.get() != NULL) 1620 mpVerticalScrollBar->SetParent(mpParentWindow); 1621 if (mpScrollBarBox.get() != NULL) 1622 mpScrollBarBox->SetParent(mpParentWindow); 1623 1624 return true; 1625 } 1626 1627 1628 1629 } // end of namespace sd 1630 1631 1632 1633 1634 1635 //===== ViewShellObjectBarFactory ============================================= 1636 1637 namespace { 1638 1639 ViewShellObjectBarFactory::ViewShellObjectBarFactory ( 1640 ::sd::ViewShell& rViewShell) 1641 : mrViewShell (rViewShell) 1642 { 1643 } 1644 1645 1646 1647 1648 ViewShellObjectBarFactory::~ViewShellObjectBarFactory (void) 1649 { 1650 for (ShellCache::iterator aI(maShellCache.begin()); 1651 aI!=maShellCache.end(); 1652 aI++) 1653 { 1654 delete aI->second; 1655 } 1656 } 1657 1658 1659 1660 1661 SfxShell* ViewShellObjectBarFactory::CreateShell ( 1662 ::sd::ShellId nId, 1663 ::Window*, 1664 ::sd::FrameView* ) 1665 { 1666 SfxShell* pShell = NULL; 1667 1668 ShellCache::iterator aI (maShellCache.find(nId)); 1669 if (aI == maShellCache.end() || aI->second==NULL) 1670 { 1671 ::sd::View* pView = mrViewShell.GetView(); 1672 switch (nId) 1673 { 1674 case RID_BEZIER_TOOLBOX: 1675 pShell = new ::sd::BezierObjectBar(&mrViewShell, pView); 1676 break; 1677 1678 case RID_DRAW_TEXT_TOOLBOX: 1679 pShell = new ::sd::TextObjectBar( 1680 &mrViewShell, mrViewShell.GetDoc()->GetPool(), pView); 1681 break; 1682 1683 case RID_DRAW_GRAF_TOOLBOX: 1684 pShell = new ::sd::GraphicObjectBar(&mrViewShell, pView); 1685 break; 1686 1687 case RID_DRAW_MEDIA_TOOLBOX: 1688 pShell = new ::sd::MediaObjectBar(&mrViewShell, pView); 1689 break; 1690 1691 case RID_DRAW_TABLE_TOOLBOX: 1692 pShell = ::sd::ui::table::CreateTableObjectBar( mrViewShell, pView ); 1693 break; 1694 1695 case RID_SVX_EXTRUSION_BAR: 1696 pShell = new ::svx::ExtrusionBar( 1697 &mrViewShell.GetViewShellBase()); 1698 break; 1699 1700 case RID_SVX_FONTWORK_BAR: 1701 pShell = new ::svx::FontworkBar( 1702 &mrViewShell.GetViewShellBase()); 1703 break; 1704 1705 default: 1706 pShell = NULL; 1707 break; 1708 } 1709 } 1710 else 1711 pShell = aI->second; 1712 1713 return pShell; 1714 } 1715 1716 1717 1718 1719 void ViewShellObjectBarFactory::ReleaseShell (SfxShell* pShell) 1720 { 1721 if (pShell != NULL) 1722 delete pShell; 1723 } 1724 1725 } // end of anonymous namespace 1726