sd/source/ui/view/viewshel.cxx

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