sd/source/ui/view/drviews1.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 #include "DrawViewShell.hxx"
  21 #include "ViewShellImplementation.hxx"
  22
  23 #include "DrawController.hxx"
  24 #include <com/sun/star/embed/EmbedStates.hpp>
  25
  26 #include "comphelper/anytostring.hxx"
  27 #include "comphelper/scopeguard.hxx"
  28 #include "cppuhelper/exc_hlp.hxx"
  29 #include "rtl/ref.hxx"
  30
  31 #include <svx/svxids.hrc>
  32 #include <svx/svdpagv.hxx>
  33 #include <sfx2/viewfrm.hxx>
  34 #include <sfx2/bindings.hxx>
  35 #include <svx/svdoole2.hxx>
  36 #include <sfx2/dispatch.hxx>
  37 #include <vcl/scrbar.hxx>
  38 #include <svx/svdograf.hxx>
  39 #include <svx/svdopage.hxx>
  40 #include <vcl/msgbox.hxx>
  41 #include <sot/storage.hxx>
  42 #include <svx/fmshell.hxx>
  43 #include <svx/globl3d.hxx>
  44 #include <svx/fmglob.hxx>
  45 #include <editeng/outliner.hxx>
  46 #include <svx/dialogs.hrc>
  47
  48 #include "view/viewoverlaymanager.hxx"
  49
  50 #include "glob.hrc"
  51 #include "app.hrc"
  52 #include "res_bmp.hrc"
  53 #include "strings.hrc"
  54 #include "helpids.h"
  55
  56 #include "sdmod.hxx"
  57 #include "fupoor.hxx"
  58 #include "sdresid.hxx"
  59 #include "fusel.hxx"
  60 #include "sdpage.hxx"
  61 #include "FrameView.hxx"
  62 #include "stlpool.hxx"
  63 #include "Window.hxx"
  64 #include "drawview.hxx"
  65 #include "drawdoc.hxx"
  66 #include "DrawDocShell.hxx"
  67 #include "Ruler.hxx"
  68 #include "Client.hxx"
  69 #include "slideshow.hxx"
  70 #include "optsitem.hxx"
  71 #include "fusearch.hxx"
  72 #include "Outliner.hxx"
  73 #include "AnimationChildWindow.hxx"
  74 #include "SdUnoDrawView.hxx"
  75 #include "ToolBarManager.hxx"
  76 #include "FormShellManager.hxx"
  77 #include "ViewShellBase.hxx"
  78 #include "LayerTabBar.hxx"
  79 #include "ViewShellManager.hxx"
  80 #include "ViewShellHint.hxx"
  81
  82 #include <sfx2/request.hxx>
  83 #include <boost/bind.hpp>
  84
  85 using namespace com::sun::star;
  86
  87 namespace sd {
  88
  89 void DrawViewShell::Activate(bool bIsMDIActivate)
  90 {
  91     ViewShell::Activate(bIsMDIActivate);
  92
  93     // When the mode is switched to normal the main view shell grabs focus.
  94     // This is done for getting cut/copy/paste commands on slides in the left
  95     // pane (slide sorter view shell) to work properly.
  96     SfxShell* pTopViewShell = this->GetViewShellBase().GetViewShellManager()->GetTopViewShell();
  97     if (pTopViewShell && pTopViewShell == this)
  98     {
  99         this->GetActiveWindow()->GrabFocus();
 100     }
 101 }
 102
 103 void DrawViewShell::UIActivating( SfxInPlaceClient* pCli )
 104 {
 105     ViewShell::UIActivating(pCli);
 106
 107     // Disable own controls
 108     maTabControl->Disable();
 109     if (GetLayerTabControl() != NULL)
 110         GetLayerTabControl()->Disable();
 111 }
 112
 113 void DrawViewShell::UIDeactivated( SfxInPlaceClient* pCli )
 114 {
 115     // Enable own controls
 116     maTabControl->Enable();
 117     if (GetLayerTabControl() != NULL)
 118         GetLayerTabControl()->Enable();
 119
 120     ViewShell::UIDeactivated(pCli);
 121 }
 122
 123 void DrawViewShell::Deactivate(bool bIsMDIActivate)
 124 {
 125     // Temporarily disable context broadcasting while the Deactivate()
 126     // call is forwarded to our base class.
 127     const bool bIsContextBroadcasterEnabled (SfxShell::SetContextBroadcasterEnabled(false));
 128
 129     ViewShell::Deactivate(bIsMDIActivate);
 130
 131     SfxShell::SetContextBroadcasterEnabled(bIsContextBroadcasterEnabled);
 132 }
 133
 134 namespace
 135 {
 136     class LockUI
 137     {
 138     private:
 139         void Lock(bool bLock);
 140         SfxViewFrame *mpFrame;
 141     public:
 142         LockUI(SfxViewFrame *pFrame) : mpFrame(pFrame) { Lock(true); }
 143         ~LockUI() { Lock(false); }
 144
 145     };
 146
 147     void LockUI::Lock(bool bLock)
 148     {
 149         if (!mpFrame)
 150             return;
 151         mpFrame->Enable( !bLock );
 152     }
 153 }
 154
 155 /**
 156  * Called, if state of selection of view is changed
 157  */
 158
 159 void DrawViewShell::SelectionHasChanged()
 160 {
 161     Invalidate();
 162
 163     //Update3DWindow(); // 3D-Controller
 164     SfxBoolItem aItem( SID_3D_STATE, true );
 165     GetViewFrame()->GetDispatcher()->Execute(
 166         SID_3D_STATE, SfxCallMode::ASYNCHRON | SfxCallMode::RECORD, &aItem, 0L );
 167
 168     SdrOle2Obj* pOleObj = NULL;
 169
 170     if ( mpDrawView->AreObjectsMarked() )
 171     {
 172         const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList();
 173
 174         if (rMarkList.GetMarkCount() == 1)
 175         {
 176             SdrMark* pMark = rMarkList.GetMark(0);
 177             SdrObject* pObj = pMark->GetMarkedSdrObj();
 178
 179             sal_uInt32 nInv = pObj->GetObjInventor();
 180             sal_uInt16 nSdrObjKind = pObj->GetObjIdentifier();
 181
 182             if (nInv == SdrInventor && nSdrObjKind == OBJ_OLE2)
 183             {
 184                 pOleObj = static_cast<SdrOle2Obj*>(pObj);
 185                 UpdateIMapDlg( pObj );
 186             }
 187             else if (nSdrObjKind == OBJ_GRAF)
 188                 UpdateIMapDlg( pObj );
 189         }
 190     }
 191
 192     ViewShellBase& rBase = GetViewShellBase();
 193     rBase.SetVerbs( uno::Sequence< embed::VerbDescriptor >() );
 194
 195     try
 196     {
 197         Client* pIPClient = static_cast<Client*>(rBase.GetIPClient());
 198         if ( pIPClient && pIPClient->IsObjectInPlaceActive() )
 199         {
 200             // as appropriate take ole-objects into account and deactivate
 201
 202             // this means we recently deselected an inplace active ole object so
 203             // we need to deselect it now
 204             if (!pOleObj)
 205             {
 206                 //#i47279# disable frame until after object has completed unload
 207                 LockUI aUILock(GetViewFrame());
 208                 pIPClient->DeactivateObject();
 209                 //HMHmpDrView->ShowMarkHdl();
 210             }
 211             else
 212             {
 213                 uno::Reference < embed::XEmbeddedObject > xObj = pOleObj->GetObjRef();
 214                 if ( xObj.is() )
 215                 {
 216                     rBase.SetVerbs( xObj->getSupportedVerbs() );
 217                 }
 218                 else
 219                 {
 220                     rBase.SetVerbs( uno::Sequence < embed::VerbDescriptor >() );
 221                 }
 222             }
 223         }
 224         else
 225         {
 226             if ( pOleObj )
 227             {
 228                 uno::Reference < embed::XEmbeddedObject > xObj = pOleObj->GetObjRef();
 229                 if ( xObj.is() )
 230                 {
 231                     rBase.SetVerbs( xObj->getSupportedVerbs() );
 232                 }
 233                 else
 234                 {
 235                     rBase.SetVerbs( uno::Sequence < embed::VerbDescriptor >() );
 236                 }
 237             }
 238             else
 239             {
 240                 rBase.SetVerbs( uno::Sequence < embed::VerbDescriptor >() );
 241             }
 242         }
 243     }
 244     catch( ::com::sun::star::uno::Exception& )
 245     {
 246         OSL_FAIL(
 247             OString(OString("sd::DrawViewShell::SelectionHasChanged(), "
 248                     "exception caught: ") +
 249             OUStringToOString(
 250                 comphelper::anyToString( cppu::getCaughtException() ),
 251                 RTL_TEXTENCODING_UTF8 )).getStr() );
 252     }
 253
 254     if( HasCurrentFunction() )
 255     {
 256         GetCurrentFunction()->SelectionHasChanged();
 257     }
 258     else
 259     {
 260         GetViewShellBase().GetToolBarManager()->SelectionHasChanged(*this,*mpDrawView);
 261     }
 262
 263     // Invalidate for every subshell
 264     GetViewShellBase().GetViewShellManager()->InvalidateAllSubShells(this);
 265
 266     mpDrawView->UpdateSelectionClipboard( false );
 267
 268     GetViewShellBase().GetDrawController().FireSelectionChangeListener();
 269 }
 270
 271 /**
 272  * set zoom factor
 273  */
 274 void DrawViewShell::SetZoom( long nZoom )
 275 {
 276     // Make sure that the zoom factor will not be recalculated on
 277     // following window resizings.
 278     mbZoomOnPage = false;
 279     ViewShell::SetZoom( nZoom );
 280     GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOM );
 281     GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOMSLIDER );
 282     mpViewOverlayManager->onZoomChanged();
 283 }
 284
 285 /**
 286  * Set zoom rectangle for active window
 287  */
 288
 289 void DrawViewShell::SetZoomRect( const Rectangle& rZoomRect )
 290 {
 291     ViewShell::SetZoomRect( rZoomRect );
 292     GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOM );
 293     GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOMSLIDER );
 294     mpViewOverlayManager->onZoomChanged();
 295 }
 296
 297 /**
 298  * PrepareClose, as appropriate end text input, so other viewshells
 299  * discover an refreshed text objext.
 300  */
 301
 302 bool DrawViewShell::PrepareClose( bool bUI )
 303 {
 304     if ( !ViewShell::PrepareClose(bUI) )
 305         return false;
 306
 307     if( HasCurrentFunction() )
 308     {
 309         sal_uInt16 nID = GetCurrentFunction()->GetSlotID();
 310         if (nID == SID_TEXTEDIT || nID == SID_ATTR_CHAR)
 311         {
 312             mpDrawView->SdrEndTextEdit();
 313         }
 314     }
 315
 316     return true;
 317 }
 318
 319 /**
 320  * Set status (enabled/disabled) of menu SfxSlots
 321  */
 322
 323 void DrawViewShell::ChangeEditMode(EditMode eEMode, bool bIsLayerModeActive)
 324 {
 325     if (meEditMode != eEMode || mbIsLayerModeActive != bIsLayerModeActive)
 326     {
 327         ViewShellManager::UpdateLock aLock (GetViewShellBase().GetViewShellManager());
 328
 329         sal_uInt16 nActualPageNum = 0;
 330
 331         GetViewShellBase().GetDrawController().FireChangeEditMode (eEMode == EM_MASTERPAGE);
 332         GetViewShellBase().GetDrawController().FireChangeLayerMode (bIsLayerModeActive);
 333
 334         if ( mpDrawView->IsTextEdit() )
 335         {
 336             mpDrawView->SdrEndTextEdit();
 337         }
 338
 339         LayerTabBar* pLayerBar = GetLayerTabControl();
 340         if (pLayerBar != NULL)
 341             pLayerBar->EndEditMode();
 342         maTabControl->EndEditMode();
 343
 344         if (mePageKind == PK_HANDOUT)
 345         {
 346             // at handouts only allow MasterPage
 347             eEMode = EM_MASTERPAGE;
 348         }
 349
 350         GetViewShellBase().GetDrawController().BroadcastContextChange();
 351
 352         meEditMode = eEMode;
 353
 354         if(pLayerBar)
 355         {
 356             // #i87182# only switch activation mode of LayerTabBar when there is one,
 357             // else it will not get initialized with the current set of Layers as needed
 358             mbIsLayerModeActive = bIsLayerModeActive;
 359         }
 360
 361         // Determine whether to show the master view toolbar.  The master
 362         // page mode has to be active and the shell must not be a handout
 363         // view.
 364         bool bShowMasterViewToolbar (meEditMode == EM_MASTERPAGE
 365              && GetShellType() != ViewShell::ST_HANDOUT);
 366         bool bShowPresentationToolbar (meEditMode != EM_MASTERPAGE
 367              && GetShellType() != ViewShell::ST_HANDOUT
 368              && GetShellType() != ViewShell::ST_DRAW);
 369
 370         // If the master view toolbar is not shown we hide it before
 371         // switching the edit mode.
 372         if (::sd::ViewShell::mpImpl->mbIsInitialized
 373             && IsMainViewShell())
 374         {
 375             if ( !bShowMasterViewToolbar )
 376                 GetViewShellBase().GetToolBarManager()->ResetToolBars(ToolBarManager::TBG_MASTER_MODE);
 377             if ( !bShowPresentationToolbar )
 378                 GetViewShellBase().GetToolBarManager()->ResetToolBars(ToolBarManager::TBG_COMMON_TASK);
 379         }
 380
 381         if (meEditMode == EM_PAGE)
 382         {
 383             /******************************************************************
 384             * PAGEMODE
 385             ******************************************************************/
 386
 387             maTabControl->Clear();
 388
 389             SdPage* pPage;
 390             sal_uInt16 nPageCnt = GetDoc()->GetSdPageCount(mePageKind);
 391
 392             for (sal_uInt16 i = 0; i < nPageCnt; i++)
 393             {
 394                 pPage = GetDoc()->GetSdPage(i, mePageKind);
 395                 OUString aPageName = pPage->GetName();
 396                 maTabControl->InsertPage(i + 1, aPageName);
 397
 398                 if ( pPage->IsSelected() && nActualPageNum == 0 )
 399                 {
 400                     nActualPageNum = i;
 401                 }
 402             }
 403
 404             maTabControl->SetCurPageId(nActualPageNum + 1);
 405
 406             SwitchPage(nActualPageNum);
 407         }
 408         else
 409         {
 410             /******************************************************************
 411             * MASTERPAGE
 412             ******************************************************************/
 413             GetViewFrame()->SetChildWindow(
 414                 AnimationChildWindow::GetChildWindowId(), false );
 415
 416             if (!mpActualPage)
 417             {
 418                 // as long as there is no mpActualPage, take first
 419                 mpActualPage = GetDoc()->GetSdPage(0, mePageKind);
 420             }
 421
 422             maTabControl->Clear();
 423             sal_uInt16 nActualMasterPageNum = 0;
 424             sal_uInt16 nMasterPageCnt = GetDoc()->GetMasterSdPageCount(mePageKind);
 425
 426             for (sal_uInt16 i = 0; i < nMasterPageCnt; i++)
 427             {
 428                 SdPage* pMaster = GetDoc()->GetMasterSdPage(i, mePageKind);
 429                 OUString aLayoutName = pMaster->GetLayoutName();
 430                 sal_Int32 nPos = aLayoutName.indexOf(SD_LT_SEPARATOR);
 431                 if (nPos != -1)
 432                     aLayoutName = aLayoutName.copy(0, nPos);
 433
 434                 maTabControl->InsertPage(i + 1, aLayoutName);
 435
 436                 if (&(mpActualPage->TRG_GetMasterPage()) == pMaster)
 437                 {
 438                     nActualMasterPageNum = i;
 439                 }
 440             }
 441
 442             maTabControl->SetCurPageId(nActualMasterPageNum + 1);
 443             SwitchPage(nActualMasterPageNum);
 444         }
 445
 446         // If the master view toolbar is to be shown we turn it on after the
 447         // edit mode has been changed.
 448         if (::sd::ViewShell::mpImpl->mbIsInitialized
 449             && IsMainViewShell())
 450         {
 451             if (bShowMasterViewToolbar)
 452                 GetViewShellBase().GetToolBarManager()->SetToolBar(
 453                     ToolBarManager::TBG_MASTER_MODE,
 454                     ToolBarManager::msMasterViewToolBar);
 455             if (bShowPresentationToolbar)
 456                 GetViewShellBase().GetToolBarManager()->SetToolBar(
 457                     ToolBarManager::TBG_COMMON_TASK,
 458                     ToolBarManager::msCommonTaskToolBar);
 459         }
 460
 461         if ( ! mbIsLayerModeActive)
 462         {
 463             maTabControl->Show();
 464             // Set the tab control only for draw pages.  For master page
 465             // this has been done already above.
 466             if (meEditMode == EM_PAGE)
 467                 maTabControl->SetCurPageId (nActualPageNum + 1);
 468         }
 469
 470         ResetActualLayer();
 471
 472         Invalidate( SID_PAGEMODE );
 473         Invalidate( SID_LAYERMODE );
 474         Invalidate( SID_MASTERPAGE );
 475         Invalidate( SID_DELETE_MASTER_PAGE );
 476         Invalidate( SID_DELETE_PAGE );
 477         Invalidate( SID_SLIDE_MASTERPAGE );
 478         Invalidate( SID_TITLE_MASTERPAGE );
 479         Invalidate( SID_NOTES_MASTERPAGE );
 480         Invalidate( SID_HANDOUT_MASTERPAGE );
 481
 482         SetContextName(GetSidebarContextName());
 483     }
 484 }
 485
 486 /**
 487  * Generate horizontal ruler
 488  */
 489
 490 SvxRuler* DrawViewShell::CreateHRuler (::sd::Window* pWin, bool bIsFirst)
 491 {
 492     Ruler* pRuler;
 493     WinBits  aWBits;
 494     SvxRulerSupportFlags nFlags = SvxRulerSupportFlags::OBJECT;
 495
 496     if ( bIsFirst )
 497     {
 498         aWBits  = WB_HSCROLL | WB_3DLOOK | WB_BORDER | WB_EXTRAFIELD;
 499         nFlags |= ( SvxRulerSupportFlags::SET_NULLOFFSET |
 500                     SvxRulerSupportFlags::TABS |
 501                     SvxRulerSupportFlags::PARAGRAPH_MARGINS ); // Neu
 502     }
 503     else
 504         aWBits = WB_HSCROLL | WB_3DLOOK | WB_BORDER;
 505
 506     pRuler = VclPtr<Ruler>::Create(*this, GetParentWindow(), pWin, nFlags,
 507         GetViewFrame()->GetBindings(), aWBits);
 508
 509     pRuler->SetSourceUnit(pWin->GetMapMode().GetMapUnit());
 510
 511     // Metric ...
 512     sal_uInt16 nMetric = (sal_uInt16)GetDoc()->GetUIUnit();
 513
 514     if( nMetric == 0xffff )
 515         nMetric = (sal_uInt16)GetViewShellBase().GetViewFrame()->GetDispatcher()->GetModule()->GetFieldUnit();
 516
 517     pRuler->SetUnit( FieldUnit( nMetric ) );
 518
 519     // ... and also set DefTab at the ruler
 520     pRuler->SetDefTabDist( GetDoc()->GetDefaultTabulator() ); // new
 521
 522     Fraction aUIScale(pWin->GetMapMode().GetScaleX());
 523     aUIScale *= GetDoc()->GetUIScale();
 524     pRuler->SetZoom(aUIScale);
 525
 526     return pRuler;
 527 }
 528
 529 /**
 530  * Generate vertical ruler
 531  */
 532
 533 SvxRuler* DrawViewShell::CreateVRuler(::sd::Window* pWin)
 534 {
 535     Ruler* pRuler;
 536     WinBits  aWBits = WB_VSCROLL | WB_3DLOOK | WB_BORDER;
 537     SvxRulerSupportFlags nFlags = SvxRulerSupportFlags::OBJECT;
 538
 539     pRuler = VclPtr<Ruler>::Create(*this, GetParentWindow(), pWin, nFlags,
 540         GetViewFrame()->GetBindings(), aWBits);
 541     pRuler->SetSourceUnit(pWin->GetMapMode().GetMapUnit());
 542
 543     // Metric same as HRuler, use document setting
 544     sal_uInt16 nMetric = (sal_uInt16)GetDoc()->GetUIUnit();
 545
 546     if( nMetric == 0xffff )
 547         nMetric = (sal_uInt16)GetViewShellBase().GetViewFrame()->GetDispatcher()->GetModule()->GetFieldUnit();
 548
 549     pRuler->SetUnit( FieldUnit( nMetric ) );
 550
 551     Fraction aUIScale(pWin->GetMapMode().GetScaleY());
 552     aUIScale *= GetDoc()->GetUIScale();
 553     pRuler->SetZoom(aUIScale);
 554
 555     return pRuler;
 556 }
 557
 558 /**
 559  * Refresh horizontal ruler
 560  */
 561
 562 void DrawViewShell::UpdateHRuler()
 563 {
 564     Invalidate( SID_ATTR_LONG_LRSPACE );
 565     Invalidate( SID_RULER_PAGE_POS );
 566     Invalidate( SID_RULER_OBJECT );
 567     Invalidate( SID_RULER_TEXT_RIGHT_TO_LEFT );
 568
 569     if (mpHorizontalRuler.get() != NULL)
 570         mpHorizontalRuler->ForceUpdate();
 571 }
 572
 573 /**
 574  * Refresh vertical ruler
 575  */
 576
 577 void DrawViewShell::UpdateVRuler()
 578 {
 579     Invalidate( SID_ATTR_LONG_LRSPACE );
 580     Invalidate( SID_RULER_PAGE_POS );
 581     Invalidate( SID_RULER_OBJECT );
 582
 583     if (mpVerticalRuler.get() != NULL)
 584         mpVerticalRuler->ForceUpdate();
 585 }
 586
 587 /**
 588  * Set metric
 589  */
 590
 591 void DrawViewShell::SetUIUnit(FieldUnit eUnit)
 592 {
 593     ViewShell::SetUIUnit(eUnit);
 594 }
 595
 596 /**
 597  * Refresh TabControl on splitter change
 598  */
 599
 600 IMPL_LINK( DrawViewShell, TabSplitHdl, TabBar *, pTab )
 601 {
 602     const long int nMax = maViewSize.Width() - maScrBarWH.Width()
 603         - maTabControl->GetPosPixel().X() ;
 604
 605     Size aTabSize = maTabControl->GetSizePixel();
 606     aTabSize.Width() = std::min(pTab->GetSplitSize(), (long)(nMax-1));
 607
 608     maTabControl->SetSizePixel(aTabSize);
 609
 610     if(GetLayerTabControl()) // #i87182#
 611     {
 612         GetLayerTabControl()->SetSizePixel(aTabSize);
 613     }
 614
 615     Point aPos = maTabControl->GetPosPixel();
 616     aPos.X() += aTabSize.Width();
 617
 618     Size aScrSize(nMax - aTabSize.Width(), maScrBarWH.Height());
 619     mpHorizontalScrollBar->SetPosSizePixel(aPos, aScrSize);
 620
 621     return 0;
 622 }
 623
 624 /// inherited from sd::ViewShell
 625 SdPage* DrawViewShell::getCurrentPage() const
 626 {
 627     const sal_Int32 nPageCount = (meEditMode == EM_PAGE)?
 628                                     GetDoc()->GetSdPageCount(mePageKind):
 629                                     GetDoc()->GetMasterSdPageCount(mePageKind);
 630
 631     sal_Int32 nCurrentPage = maTabControl->GetCurPageId() - 1;
 632     DBG_ASSERT( (nPageCount>0) && (nCurrentPage<nPageCount), "sd::DrawViewShell::getCurrentPage(), illegal page index!" );
 633     if( (nPageCount < 0) || (nCurrentPage>=nPageCount) )
 634         nCurrentPage = 0; // play safe here
 635
 636     if (meEditMode == EM_PAGE)
 637     {
 638         return GetDoc()->GetSdPage((sal_uInt16)nCurrentPage, mePageKind);
 639     }
 640     else // EM_MASTERPAGE
 641     {
 642         return GetDoc()->GetMasterSdPage((sal_uInt16)nCurrentPage, mePageKind);
 643     }
 644 }
 645
 646 /**
 647  * Select new refreshed page, in case of a page order change (eg. by undo)
 648  */
 649
 650 void DrawViewShell::ResetActualPage()
 651 {
 652     if (!GetDoc())
 653         return;
 654
 655     sal_uInt16 nCurrentPage = maTabControl->GetCurPageId() - 1;
 656     sal_uInt16 nPageCount   = (meEditMode == EM_PAGE)?GetDoc()->GetSdPageCount(mePageKind):GetDoc()->GetMasterSdPageCount(mePageKind);
 657     if (nPageCount > 0)
 658         nCurrentPage = std::min((sal_uInt16)(nPageCount - 1), nCurrentPage);
 659     else
 660         nCurrentPage = 0;
 661
 662     if (meEditMode == EM_PAGE)
 663     {
 664
 665         // Update for TabControl
 666         maTabControl->Clear();
 667
 668         SdPage* pPage = NULL;
 669
 670         for (sal_uInt16 i = 0; i < nPageCount; i++)
 671         {
 672             pPage = GetDoc()->GetSdPage(i, mePageKind);
 673             OUString aPageName = pPage->GetName();
 674             maTabControl->InsertPage(i + 1, aPageName);
 675
 676             // correct selection recognition of the pages
 677             GetDoc()->SetSelected(pPage, i == nCurrentPage);
 678         }
 679
 680         maTabControl->SetCurPageId(nCurrentPage + 1);
 681     }
 682     else // EM_MASTERPAGE
 683     {
 684         SdPage* pActualPage = GetDoc()->GetMasterSdPage(nCurrentPage, mePageKind);
 685         maTabControl->Clear();
 686         sal_uInt16 nActualMasterPageNum = 0;
 687
 688         sal_uInt16 nMasterPageCnt = GetDoc()->GetMasterSdPageCount(mePageKind);
 689         for (sal_uInt16 i = 0; i < nMasterPageCnt; i++)
 690         {
 691             SdPage* pMaster = GetDoc()->GetMasterSdPage(i, mePageKind);
 692             OUString aLayoutName = pMaster->GetLayoutName();
 693             sal_Int32 nPos = aLayoutName.indexOf(SD_LT_SEPARATOR);
 694             if (nPos != -1)
 695                 aLayoutName = aLayoutName.copy(0, nPos);
 696             maTabControl->InsertPage(i + 1, aLayoutName);
 697
 698             if (pActualPage == pMaster)
 699                 nActualMasterPageNum = i;
 700         }
 701
 702         maTabControl->SetCurPageId(nActualMasterPageNum + 1);
 703         SwitchPage(nActualMasterPageNum);
 704     }
 705
 706     GetViewFrame()->GetDispatcher()->Execute(SID_SWITCHPAGE,
 707                 SfxCallMode::ASYNCHRON | SfxCallMode::RECORD);
 708 }
 709
 710 /**
 711  * Apply "Verb" on OLE-object.
 712  */
 713
 714 ErrCode DrawViewShell::DoVerb(long nVerb)
 715 {
 716     if ( mpDrawView->AreObjectsMarked() )
 717     {
 718         const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList();
 719
 720         if (rMarkList.GetMarkCount() == 1)
 721         {
 722             SdrMark* pMark = rMarkList.GetMark(0);
 723             SdrObject* pObj = pMark->GetMarkedSdrObj();
 724
 725             sal_uInt32 nInv = pObj->GetObjInventor();
 726             sal_uInt16 nSdrObjKind = pObj->GetObjIdentifier();
 727
 728             if (nInv == SdrInventor && nSdrObjKind == OBJ_OLE2)
 729             {
 730                 ActivateObject( static_cast<SdrOle2Obj*>(pObj), nVerb);
 731             }
 732         }
 733     }
 734
 735     return 0;
 736 }
 737
 738 /**
 739  * Activate OLE-object
 740  */
 741
 742 bool DrawViewShell::ActivateObject(SdrOle2Obj* pObj, long nVerb)
 743 {
 744     bool bActivated = false;
 745
 746     if ( !GetDocSh()->IsUIActive() )
 747     {
 748         ToolBarManager::UpdateLock aLock (GetViewShellBase().GetToolBarManager());
 749
 750         bActivated = ViewShell::ActivateObject(pObj, nVerb);
 751
 752         OSL_ASSERT(GetViewShell()!=NULL);
 753         Client* pClient = static_cast<Client*>(GetViewShell()->GetIPClient());
 754         if (pClient)
 755             pClient->SetSdrGrafObj(NULL);
 756     }
 757
 758     return bActivated;
 759 }
 760
 761 /**
 762  * Switch to desired page.
 763  * nSelectPage refers to the current EditMode
 764  */
 765
 766 void LclResetFlag (bool& rbFlag) {rbFlag = false;}
 767
 768 bool DrawViewShell::SwitchPage(sal_uInt16 nSelectedPage)
 769 {
 770     /** Under some circumstances there are nested calls to SwitchPage() and
 771         may crash the application (activation of form controls when the
 772         shell of the edit view is not on top of the shell stack, see issue
 773         83888 for details.)  Therefore the nested calls are ignored (they
 774         would jump to the wrong page anyway.)
 775     */
 776     if (mbIsInSwitchPage)
 777         return false;
 778     mbIsInSwitchPage = true;
 779     comphelper::ScopeGuard aGuard (::boost::bind(LclResetFlag, ::boost::ref(mbIsInSwitchPage)));
 780
 781     if (GetActiveWindow()->IsInPaint())
 782     {
 783         // Switching the current page while a Paint is being executed is
 784         // dangerous.  So, post it for later execution and return.
 785         maAsynchronousSwitchPageCall.Post(::boost::bind(
 786             ::std::mem_fun(&DrawViewShell::SwitchPage),
 787             this,
 788             nSelectedPage));
 789         return false;
 790     }
 791
 792     bool bOK = false;
 793
 794     // With the current implementation of FuSlideShow there is a problem
 795     // when it dsplays the show in a window: When the show is stopped it
 796     // returns at one point in time SDRPAGE_NOTFOUND as current page index.
 797     // Because FuSlideShow is currently being rewritten this bug is fixed
 798     // here.
 799     // This is not as bad a hack as it may look because making SwitchPage()
 800     // more robust with respect to invalid page numbers is a good thing
 801     // anyway.
 802     if (nSelectedPage == SDRPAGE_NOTFOUND)
 803     {
 804         nSelectedPage = 0;
 805     }
 806     else
 807     {
 808         // Make sure that the given page index points to an existing page.  Move
 809         // the index into the valid range if necessary.
 810         sal_uInt16 nPageCount = (meEditMode == EM_PAGE)
 811             ? GetDoc()->GetSdPageCount(mePageKind)
 812             : GetDoc()->GetMasterSdPageCount(mePageKind);
 813         if (nSelectedPage >= nPageCount)
 814             nSelectedPage = nPageCount-1;
 815     }
 816
 817     if (IsSwitchPageAllowed())
 818     {
 819         ModifyGuard aGuard2( GetDoc() );
 820
 821         bOK = true;
 822
 823         if (mpActualPage)
 824         {
 825             SdPage* pNewPage = NULL;
 826
 827             if (meEditMode == EM_MASTERPAGE)
 828             {
 829                 if( GetDoc()->GetMasterSdPageCount(mePageKind) > nSelectedPage )
 830                     pNewPage = GetDoc()->GetMasterSdPage(nSelectedPage, mePageKind);
 831
 832                 if( pNewPage )
 833                 {
 834                     SdrPageView* pPV = mpDrawView->GetSdrPageView();
 835                     OUString sPageText(pNewPage->GetLayoutName());
 836                     sal_Int32 nPos = sPageText.indexOf(SD_LT_SEPARATOR);
 837                     if (nPos != -1)
 838                         sPageText = sPageText.copy(0, nPos);
 839                     if (pPV
 840                         && pNewPage == dynamic_cast< SdPage* >( pPV->GetPage() )
 841                         && sPageText == maTabControl->GetPageText(nSelectedPage+1))
 842                     {
 843                         // this slide is already visible
 844                         return true;
 845                     }
 846                 }
 847             }
 848             else
 849             {
 850                 OSL_ASSERT(mpFrameView!=NULL);
 851                 mpFrameView->SetSelectedPage(nSelectedPage);
 852
 853                 if (GetDoc()->GetSdPageCount(mePageKind) > nSelectedPage)
 854                     pNewPage = GetDoc()->GetSdPage(nSelectedPage, mePageKind);
 855
 856                 if (mpActualPage == pNewPage)
 857                 {
 858                     SdrPageView* pPV = mpDrawView->GetSdrPageView();
 859
 860                     SdPage* pCurrentPage = pPV ? dynamic_cast<SdPage*>(pPV->GetPage()) : NULL;
 861                     if (pCurrentPage
 862                         && pNewPage == pCurrentPage
 863                         && maTabControl->GetPageText(nSelectedPage+1).equals(pNewPage->GetName()))
 864                     {
 865                         // this slide is already visible
 866                         return true;
 867                     }
 868                 }
 869             }
 870         }
 871
 872         mpDrawView->SdrEndTextEdit();
 873
 874         mpActualPage = NULL;
 875
 876         if (meEditMode == EM_PAGE)
 877         {
 878             mpActualPage = GetDoc()->GetSdPage(nSelectedPage, mePageKind);
 879         }
 880         else
 881         {
 882             SdPage* pMaster = GetDoc()->GetMasterSdPage(nSelectedPage, mePageKind);
 883
 884             // does the selected page fit to the masterpage?
 885             sal_uInt16 nPageCount = GetDoc()->GetSdPageCount(mePageKind);
 886             for (sal_uInt16 i = 0; i < nPageCount; i++)
 887             {
 888                 SdPage* pPage = GetDoc()->GetSdPage(i, mePageKind);
 889                 if(pPage && pPage->IsSelected() && pMaster == &(pPage->TRG_GetMasterPage()))
 890                 {
 891                     mpActualPage = pPage;
 892                     break;
 893                 }
 894             }
 895
 896             if (!mpActualPage)
 897             {
 898                 // take the first page, that fits to the masterpage
 899                 for (sal_uInt16 i = 0; i < nPageCount; i++)
 900                 {
 901                     SdPage* pPage = GetDoc()->GetSdPage(i, mePageKind);
 902                     if(pPage && pMaster == &(pPage->TRG_GetMasterPage()))
 903                     {
 904                         mpActualPage = pPage;
 905                         break;
 906                     }
 907                 }
 908             }
 909         }
 910
 911         for (sal_uInt16 i = 0; i < GetDoc()->GetSdPageCount(mePageKind); i++)
 912         {
 913             // deselect all pages
 914             GetDoc()->SetSelected( GetDoc()->GetSdPage(i, mePageKind), false);
 915         }
 916
 917         if (!mpActualPage)
 918         {
 919             // as far as there is no mpActualPage, take the first
 920             mpActualPage = GetDoc()->GetSdPage(0, mePageKind);
 921         }
 922
 923         // also select this page (mpActualPage always points at a drawing page,
 924         // never at a masterpage)
 925         GetDoc()->SetSelected(mpActualPage, true);
 926
 927         rtl::Reference< sd::SlideShow > xSlideshow( SlideShow::GetSlideShow( GetDoc() ) );
 928         if( !xSlideshow.is() || !xSlideshow->isRunning() || ( xSlideshow->getAnimationMode() != ANIMATIONMODE_SHOW ) )
 929         {
 930             // tighten VisArea, to possibly deactivate objects
 931             // !!! only if we are not in presentation mode (#96279) !!!
 932             OSL_ASSERT (GetViewShell()!=NULL);
 933             GetViewShell()->DisconnectAllClients();
 934             VisAreaChanged(Rectangle(Point(), Size(1, 1)));
 935         }
 936
 937         if (meEditMode == EM_PAGE)
 938         {
 939             /**********************************************************************
 940             * PAGEMODE
 941             **********************************************************************/
 942             GetDoc()->SetSelected(mpActualPage, true);
 943
 944             SdrPageView* pPageView = mpDrawView->GetSdrPageView();
 945
 946             if (pPageView)
 947             {
 948                 mpFrameView->SetVisibleLayers( pPageView->GetVisibleLayers() );
 949                 mpFrameView->SetPrintableLayers( pPageView->GetPrintableLayers() );
 950                 mpFrameView->SetLockedLayers( pPageView->GetLockedLayers() );
 951
 952                 if (mePageKind == PK_NOTES)
 953                 {
 954                     mpFrameView->SetNotesHelpLines( pPageView->GetHelpLines() );
 955                 }
 956                 else if (mePageKind == PK_HANDOUT)
 957                 {
 958                     mpFrameView->SetHandoutHelpLines( pPageView->GetHelpLines() );
 959                 }
 960                 else
 961                 {
 962                     mpFrameView->SetStandardHelpLines( pPageView->GetHelpLines() );
 963                 }
 964             }
 965
 966             mpDrawView->HideSdrPage();
 967             mpDrawView->ShowSdrPage(mpActualPage);
 968             GetViewShellBase().GetDrawController().FireSwitchCurrentPage(mpActualPage);
 969
 970             SdrPageView* pNewPageView = mpDrawView->GetSdrPageView();
 971
 972             if (pNewPageView)
 973             {
 974                 pNewPageView->SetVisibleLayers( mpFrameView->GetVisibleLayers() );
 975                 pNewPageView->SetPrintableLayers( mpFrameView->GetPrintableLayers() );
 976                 pNewPageView->SetLockedLayers( mpFrameView->GetLockedLayers() );
 977
 978                 if (mePageKind == PK_NOTES)
 979                 {
 980                     pNewPageView->SetHelpLines( mpFrameView->GetNotesHelpLines() );
 981                 }
 982                 else if (mePageKind == PK_HANDOUT)
 983                 {
 984                     pNewPageView->SetHelpLines( mpFrameView->GetHandoutHelpLines() );
 985                 }
 986                 else
 987                 {
 988                     pNewPageView->SetHelpLines( mpFrameView->GetStandardHelpLines() );
 989                 }
 990             }
 991
 992             maTabControl->SetCurPageId(nSelectedPage+1);
 993             OUString aPageName = mpActualPage->GetName();
 994
 995             if (maTabControl->GetPageText(nSelectedPage+1) != aPageName)
 996             {
 997                 maTabControl->SetPageText(nSelectedPage+1, aPageName);
 998             }
 999         }
1000         else
1001         {
1002             /**********************************************************************
1003             * MASTERPAGE
1004             **********************************************************************/
1005             SdrPageView* pPageView = mpDrawView->GetSdrPageView();
1006
1007             if (pPageView)
1008             {
1009                 mpFrameView->SetVisibleLayers( pPageView->GetVisibleLayers() );
1010                 mpFrameView->SetPrintableLayers( pPageView->GetPrintableLayers() );
1011                 mpFrameView->SetLockedLayers( pPageView->GetLockedLayers() );
1012
1013                 if (mePageKind == PK_NOTES)
1014                 {
1015                     mpFrameView->SetNotesHelpLines( pPageView->GetHelpLines() );
1016                 }
1017                 else if (mePageKind == PK_HANDOUT)
1018                 {
1019                     mpFrameView->SetHandoutHelpLines( pPageView->GetHelpLines() );
1020                 }
1021                 else
1022                 {
1023                     mpFrameView->SetStandardHelpLines( pPageView->GetHelpLines() );
1024                 }
1025             }
1026
1027             mpDrawView->HideSdrPage();
1028
1029             SdPage* pMaster = GetDoc()->GetMasterSdPage(nSelectedPage, mePageKind);
1030
1031             if( !pMaster )              // if this page should not exist
1032                 pMaster = GetDoc()->GetMasterSdPage(0, mePageKind);
1033
1034             sal_uInt16 nNum = pMaster->GetPageNum();
1035             mpDrawView->ShowSdrPage(mpDrawView->GetModel()->GetMasterPage(nNum));
1036
1037             GetViewShellBase().GetDrawController().FireSwitchCurrentPage(pMaster);
1038
1039             SdrPageView* pNewPageView = mpDrawView->GetSdrPageView();
1040
1041             if (pNewPageView)
1042             {
1043                 pNewPageView->SetVisibleLayers( mpFrameView->GetVisibleLayers() );
1044                 pNewPageView->SetPrintableLayers( mpFrameView->GetPrintableLayers() );
1045                 pNewPageView->SetLockedLayers( mpFrameView->GetLockedLayers() );
1046
1047                 if (mePageKind == PK_NOTES)
1048                 {
1049                     pNewPageView->SetHelpLines( mpFrameView->GetNotesHelpLines() );
1050                 }
1051                 else if (mePageKind == PK_HANDOUT)
1052                 {
1053                     pNewPageView->SetHelpLines( mpFrameView->GetHandoutHelpLines() );
1054                 }
1055                 else
1056                 {
1057                     pNewPageView->SetHelpLines( mpFrameView->GetStandardHelpLines() );
1058                 }
1059             }
1060
1061             OUString aLayoutName(pMaster->GetLayoutName());
1062             sal_Int32 nPos = aLayoutName.indexOf(SD_LT_SEPARATOR);
1063             if (nPos != -1)
1064                 aLayoutName = aLayoutName.copy(0, nPos);
1065
1066             maTabControl->SetCurPageId(nSelectedPage+1);
1067
1068             if (maTabControl->GetPageText(nSelectedPage+1) != aLayoutName)
1069             {
1070                 maTabControl->SetPageText(nSelectedPage+1, aLayoutName);
1071             }
1072
1073             if( mePageKind == PK_HANDOUT )
1074             {
1075                 // set pages for all available handout presentation objects
1076                 sd::ShapeList& rShapeList = pMaster->GetPresentationShapeList();
1077                 SdrObject* pObj = 0;
1078                 rShapeList.seekShape(0);
1079
1080                 while( (pObj = rShapeList.getNextShape()) )
1081                 {
1082                     if( pMaster->GetPresObjKind(pObj) == PRESOBJ_HANDOUT )
1083                     {
1084                         // #i105146# We want no content to be displayed for PK_HANDOUT,
1085                         // so just never set a page as content
1086                         static_cast<SdrPageObj*>(pObj)->SetReferencedPage(0);
1087                     }
1088                 }
1089             }
1090         }
1091
1092         Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel();
1093         Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), aVisSizePixel) );
1094         VisAreaChanged(aVisAreaWin);
1095         mpDrawView->VisAreaChanged(GetActiveWindow());
1096
1097         // so navigator (and effect window) notice that
1098         SfxBindings& rBindings = GetViewFrame()->GetBindings();
1099         rBindings.Invalidate(SID_NAVIGATOR_PAGENAME, true, false);
1100         rBindings.Invalidate(SID_STATUS_PAGE, true, false);
1101         rBindings.Invalidate(SID_DELETE_MASTER_PAGE, true, false);
1102         rBindings.Invalidate(SID_DELETE_PAGE, true, false);
1103         rBindings.Invalidate(SID_ASSIGN_LAYOUT, true, false);
1104         rBindings.Invalidate(SID_INSERTPAGE, true, false);
1105         UpdatePreview( mpActualPage );
1106
1107         mpDrawView->AdjustMarkHdl();
1108     }
1109
1110     return bOK;
1111 }
1112
1113 /**
1114  * Check if page change is allowed
1115  */
1116
1117 bool DrawViewShell::IsSwitchPageAllowed() const
1118 {
1119     bool bOK = true;
1120
1121     FmFormShell* pFormShell = GetViewShellBase().GetFormShellManager()->GetFormShell();
1122     if (pFormShell != NULL && !pFormShell->PrepareClose(false))
1123         bOK = false;
1124
1125     return bOK;
1126 }
1127
1128 /**
1129  * Select new refreshed page, in case of a page order change (eg. by undo)
1130  */
1131
1132 void DrawViewShell::ResetActualLayer()
1133 {
1134     LayerTabBar* pLayerBar = GetLayerTabControl();
1135     if (pLayerBar != NULL)
1136     {
1137         // remember old layer cound and current layer id
1138         // this is needed when one layer is renamed to
1139         // restore current layer
1140         sal_uInt16 nOldLayerCnt = pLayerBar->GetPageCount();
1141         sal_uInt16 nOldLayerId = pLayerBar->GetCurPageId();
1142
1143         /**
1144          * Update for LayerTab
1145          */
1146         pLayerBar->Clear();
1147
1148         OUString aName;
1149         OUString aActiveLayer = mpDrawView->GetActiveLayer();
1150         OUString aBackgroundLayer = SD_RESSTR(STR_LAYER_BCKGRND);
1151         OUString aBackgroundObjLayer = SD_RESSTR(STR_LAYER_BCKGRNDOBJ);
1152         OUString aLayoutLayer = SD_RESSTR(STR_LAYER_LAYOUT);
1153         OUString aControlsLayer = SD_RESSTR(STR_LAYER_CONTROLS);
1154         OUString aMeasureLinesLayer = SD_RESSTR(STR_LAYER_MEASURELINES);
1155         sal_uInt16 nActiveLayer = SDRLAYER_NOTFOUND;
1156         SdrLayerAdmin& rLayerAdmin = GetDoc()->GetLayerAdmin();
1157         sal_uInt16 nLayerCnt = rLayerAdmin.GetLayerCount();
1158
1159         for ( sal_uInt16 nLayer = 0; nLayer < nLayerCnt; nLayer++ )
1160         {
1161             aName = rLayerAdmin.GetLayer(nLayer)->GetName();
1162
1163             if ( aName == aActiveLayer )
1164             {
1165                 nActiveLayer = nLayer;
1166             }
1167
1168             if ( aName != aBackgroundLayer )
1169             {
1170                 if (meEditMode == EM_MASTERPAGE)
1171                 {
1172                     // don't show page layer onto the masterpage
1173                     if (aName != aLayoutLayer   &&
1174                         aName != aControlsLayer &&
1175                         aName != aMeasureLinesLayer)
1176                     {
1177                         pLayerBar->InsertPage(nLayer+1, aName);
1178
1179                         TabBarPageBits nBits = 0;
1180                         SdrPageView* pPV = mpDrawView->GetSdrPageView();
1181
1182                         if (pPV && !pPV->IsLayerVisible(aName))
1183                         {
1184                             // invisible layers are displayed differently
1185                             nBits = TPB_SPECIAL;
1186                         }
1187
1188                         pLayerBar->SetPageBits(nLayer+1, nBits);
1189                     }
1190                 }
1191                 else
1192                 {
1193                     // don't show masterpage layer onto the page
1194                     if ( aName != aBackgroundObjLayer )
1195                     {
1196                         pLayerBar->InsertPage(nLayer+1, aName);
1197
1198                         TabBarPageBits nBits = 0;
1199
1200                         if (!mpDrawView->GetSdrPageView()->IsLayerVisible(aName))
1201                         {
1202                             // invisible layers are displayed differently
1203                             nBits = TPB_SPECIAL;
1204                         }
1205
1206                         pLayerBar->SetPageBits(nLayer+1, nBits);
1207                     }
1208                 }
1209             }
1210         }
1211
1212         if ( nActiveLayer == SDRLAYER_NOTFOUND )
1213         {
1214             if( nOldLayerCnt == pLayerBar->GetPageCount() )
1215             {
1216                 nActiveLayer = nOldLayerId - 1;
1217             }
1218             else
1219             {
1220                 nActiveLayer = ( meEditMode == EM_MASTERPAGE ) ? 2 : 0;
1221             }
1222
1223             mpDrawView->SetActiveLayer( pLayerBar->GetPageText(nActiveLayer + 1) );
1224         }
1225
1226         pLayerBar->SetCurPageId(nActiveLayer + 1);
1227         GetViewFrame()->GetBindings().Invalidate( SID_MODIFYLAYER );
1228         GetViewFrame()->GetBindings().Invalidate( SID_DELETE_LAYER );
1229     }
1230 }
1231
1232 /**
1233  * AcceptDrop
1234  */
1235
1236 sal_Int8 DrawViewShell::AcceptDrop (
1237     const AcceptDropEvent& rEvt,
1238     DropTargetHelper& rTargetHelper,
1239     ::sd::Window* pTargetWindow,
1240     sal_uInt16 nPage,
1241     sal_uInt16 nLayer )
1242 {
1243     if( nPage != SDRPAGE_NOTFOUND )
1244         nPage = GetDoc()->GetSdPage( nPage, mePageKind )->GetPageNum();
1245
1246     if( SlideShow::IsRunning( GetViewShellBase() ) )
1247         return DND_ACTION_NONE;
1248
1249     return mpDrawView->AcceptDrop( rEvt, rTargetHelper, pTargetWindow, nPage, nLayer );
1250 }
1251
1252 /**
1253  * ExecuteDrop
1254  */
1255
1256 sal_Int8 DrawViewShell::ExecuteDrop (
1257     const ExecuteDropEvent& rEvt,
1258     DropTargetHelper& rTargetHelper,
1259     ::sd::Window* pTargetWindow,
1260     sal_uInt16 nPage,
1261     sal_uInt16 nLayer)
1262 {
1263     if( nPage != SDRPAGE_NOTFOUND )
1264         nPage = GetDoc()->GetSdPage( nPage, mePageKind )->GetPageNum();
1265
1266     if( SlideShow::IsRunning( GetViewShellBase() ) )
1267         return DND_ACTION_NONE;
1268
1269     Broadcast(ViewShellHint(ViewShellHint::HINT_COMPLEX_MODEL_CHANGE_START));
1270     sal_Int8 nResult (mpDrawView->ExecuteDrop( rEvt, rTargetHelper, pTargetWindow, nPage, nLayer ));
1271     Broadcast(ViewShellHint(ViewShellHint::HINT_COMPLEX_MODEL_CHANGE_END));
1272
1273     return nResult;
1274 }
1275
1276 } // end of namespace sd
1277
1278 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */