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