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