sd/source/ui/view/viewshel.cxx

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