sd/source/ui/view/ViewShellBase.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 <comphelper/processfactory.hxx>
  21
  22 #include <ViewShellBase.hxx>
  23 #include <algorithm>
  24 #include <EventMultiplexer.hxx>
  25 #include <cache/SlsPageCacheManager.hxx>
  26 #include <app.hrc>
  27 #include <slideshow.hxx>
  28 #include <unokywds.hxx>
  29 #include <svx/svxids.hrc>
  30 #include <DrawDocShell.hxx>
  31 #include <ViewShellManager.hxx>
  32 #include <DrawController.hxx>
  33 #include <FrameView.hxx>
  34 #include <ViewTabBar.hxx>
  35 #include <sfx2/event.hxx>
  36 #include <drawdoc.hxx>
  37 #include <sdpage.hxx>
  38 #include <sfx2/dispatch.hxx>
  39 #include <sfx2/request.hxx>
  40 #include <sfx2/printer.hxx>
  41 #include <DrawViewShell.hxx>
  42 #include <FormShellManager.hxx>
  43 #include <ToolBarManager.hxx>
  44 #include <Window.hxx>
  45 #include <framework/ConfigurationController.hxx>
  46 #include <DocumentRenderer.hxx>
  47 #include <optsitem.hxx>
  48 #include <sdmod.hxx>
  49
  50 #include <com/sun/star/document/XViewDataSupplier.hpp>
  51 #include <com/sun/star/container/XIndexAccess.hpp>
  52 #include <com/sun/star/drawing/XDrawPagesSupplier.hpp>
  53 #include <com/sun/star/drawing/XMasterPagesSupplier.hpp>
  54 #include <com/sun/star/drawing/framework/XControllerManager.hpp>
  55 #include <com/sun/star/drawing/framework/XConfigurationController.hpp>
  56 #include <com/sun/star/drawing/framework/ResourceId.hpp>
  57 #include <framework/FrameworkHelper.hxx>
  58
  59 #include <sal/log.hxx>
  60 #include <rtl/ref.hxx>
  61 #include <sfx2/msg.hxx>
  62 #include <sfx2/objface.hxx>
  63 #include <sfx2/viewfrm.hxx>
  64 #include <svl/whiter.hxx>
  65 #include <vcl/commandinfoprovider.hxx>
  66 #include <vcl/settings.hxx>
  67 #include <vcl/svapp.hxx>
  68
  69 #include <sfx2/notebookbar/SfxNotebookBar.hxx>
  70
  71 #include <comphelper/diagnose_ex.hxx>
  72 #include <sfx2/lokhelper.hxx>
  73 #include <LibreOfficeKit/LibreOfficeKitEnums.h>
  74 #include <editeng/editview.hxx>
  75 #include <tools/svborder.hxx>
  76
  77 #include <fubullet.hxx>
  78 #include <drawview.hxx>
  79
  80 using namespace sd;
  81 #define ShellClass_ViewShellBase
  82 #include <sdslots.hxx>
  83
  84 using ::sd::framework::FrameworkHelper;
  85
  86 using namespace com::sun::star;
  87 using namespace com::sun::star::beans;
  88 using namespace com::sun::star::container;
  89 using namespace com::sun::star::drawing::framework;
  90 using namespace com::sun::star::lang;
  91 using namespace com::sun::star::uno;
  92
  93 namespace {
  94
  95 class CurrentPageSetter
  96 {
  97 public:
  98     explicit CurrentPageSetter (ViewShellBase& rBase);
  99     void operator () (bool);
 100 private:
 101     ViewShellBase& mrBase;
 102 };
 103
 104 } // end of anonymous namespace
 105
 106 namespace sd {
 107
 108 class ViewShellBase::Implementation
 109 {
 110 public:
 111     /** Main controller of the view shell.  During the switching from one
 112         stacked shell to another this pointer may be NULL.
 113     */
 114     ::rtl::Reference<DrawController> mpController;
 115
 116     /** The view tab bar is the control for switching between different
 117         views in one pane.
 118     */
 119     ::rtl::Reference<ViewTabBar> mpViewTabBar;
 120
 121     // contains the complete area of the current view relative to the frame window
 122     ::tools::Rectangle maClientArea;
 123
 124     // This is set to true when PrepareClose() is called.
 125     bool mbIsClosing;
 126
 127     /** The view window is the parent of all UI elements that belong to the
 128         view or ViewShell.  This comprises the rulers, the scroll bars, and
 129         the content window.
 130         It does not include the ViewTabBar.
 131     */
 132     VclPtr<vcl::Window> mpViewWindow;
 133     std::shared_ptr<ToolBarManager> mpToolBarManager;
 134     std::shared_ptr<ViewShellManager> mpViewShellManager;
 135     std::shared_ptr<tools::EventMultiplexer> mpEventMultiplexer;
 136     std::shared_ptr<FormShellManager> mpFormShellManager;
 137
 138     explicit Implementation (ViewShellBase& rBase);
 139     ~Implementation();
 140
 141     void LateInit();
 142
 143     /** Show or hide the ViewTabBar.
 144         @param bShow
 145             When <TRUE/> then the ViewTabBar is shown, otherwise it is hidden.
 146     */
 147     void ShowViewTabBar (bool bShow);
 148
 149     void SetUserWantsTabBar(bool inValue);
 150     bool GetUserWantsTabBar() const { return mbUserWantsTabBar; }
 151
 152     /** Common code of ViewShellBase::OuterResizePixel() and
 153         ViewShellBase::InnerResizePixel().
 154     */
 155     void ResizePixel (
 156         const Point& rOrigin,
 157         const Size& rSize,
 158         bool bOuterResize);
 159
 160     /** Show or hide the specified pane.  The visibility state is taken
 161         from the given request.
 162         @param rRequest
 163             The request determines the new visibility state.  The state can
 164             either be toggled or be set to a given value.
 165         @param rsPaneURL
 166             This URL specifies the pane whose visibility state to set.
 167         @param rsViewURL
 168             When the pane becomes visible then this view URL specifies which
 169             type of view to show in it.
 170     */
 171     void SetPaneVisibility (
 172         const SfxRequest& rRequest,
 173         const OUString& rsPaneURL,
 174         const OUString& rsViewURL);
 175
 176     void GetSlotState (SfxItemSet& rSet);
 177
 178     void ProcessRestoreEditingViewSlot();
 179
 180 private:
 181     ViewShellBase& mrBase;
 182     bool mbUserWantsTabBar;
 183     bool mbTabBarShouldBeVisible;
 184     /** Hold a reference to the page cache manager of the slide sorter in
 185         order to ensure that it stays alive while the ViewShellBase is
 186         alive.
 187     */
 188     std::shared_ptr<slidesorter::cache::PageCacheManager> mpPageCacheManager;
 189 };
 190
 191 namespace {
 192 /** The only task of this window is to forward key presses to the content
 193     window of the main view shell.  With the key press it forwards the focus
 194     so that it is not called very often.
 195 */
 196 class FocusForwardingWindow : public vcl::Window
 197 {
 198 public:
 199     FocusForwardingWindow (vcl::Window& rParentWindow, ViewShellBase& rBase);
 200     virtual ~FocusForwardingWindow() override;
 201     virtual void dispose() override;
 202     virtual void KeyInput (const KeyEvent& rEvent) override;
 203     virtual void Command (const CommandEvent& rEvent) override;
 204
 205 private:
 206     ViewShellBase& mrBase;
 207 };
 208 } // end of anonymous namespace
 209
 210 //===== ViewShellBase =========================================================
 211
 212
 213 // We have to expand the SFX_IMPL_VIEWFACTORY macro to call LateInit() after a
 214 // new ViewShellBase object has been constructed.
 215
 216 SFX_IMPL_SUPERCLASS_INTERFACE(ViewShellBase, SfxViewShell)
 217
 218 void ViewShellBase::InitInterface_Impl()
 219 {
 220 }
 221
 222 ViewShellBase::ViewShellBase (
 223     SfxViewFrame& _rFrame,
 224     SfxViewShell*)
 225     : SfxViewShell(_rFrame, SfxViewShellFlags::HAS_PRINTOPTIONS),
 226       mpDocShell (nullptr),
 227       mpDocument (nullptr)
 228 {
 229     mpImpl.reset(new Implementation(*this));
 230     mpImpl->mpViewWindow = VclPtr<FocusForwardingWindow>::Create(_rFrame.GetWindow(),*this);
 231     mpImpl->mpViewWindow->SetBackground(Wallpaper());
 232
 233     _rFrame.GetWindow().SetBackground(Application::GetSettings().GetStyleSettings().GetLightColor());
 234
 235     // Set up the members in the correct order.
 236     if (auto pDrawDocShell = dynamic_cast< DrawDocShell *>( GetViewFrame().GetObjectShell() ))
 237         mpDocShell = pDrawDocShell;
 238     if (mpDocShell != nullptr)
 239         mpDocument = mpDocShell->GetDoc();
 240     mpImpl->mpViewShellManager = std::make_shared<ViewShellManager>(*this);
 241
 242     SetWindow(mpImpl->mpViewWindow.get());
 243
 244     // Hide the window to avoid complaints from Sfx...SwitchViewShell...
 245     _rFrame.GetWindow().Hide();
 246 }
 247
 248 /** In this destructor the order in which some of the members are destroyed
 249     (and/or being prepared to being destroyed) is important.  Change it only
 250     when you know what you are doing.
 251 */
 252 ViewShellBase::~ViewShellBase()
 253 {
 254     // Notify other LOK views that we are going away.
 255     SfxLokHelper::notifyOtherViews(this, LOK_CALLBACK_VIEW_CURSOR_VISIBLE, "visible", "false");
 256     SfxLokHelper::notifyOtherViews(this, LOK_CALLBACK_TEXT_VIEW_SELECTION, "selection", "");
 257     SfxLokHelper::notifyOtherViews(this, LOK_CALLBACK_GRAPHIC_VIEW_SELECTION, "selection", "EMPTY");
 258
 259     sfx2::SfxNotebookBar::CloseMethod(GetFrame()->GetBindings());
 260
 261     rtl::Reference<SlideShow> xSlideShow(SlideShow::GetSlideShow(*this));
 262     if (xSlideShow.is() && xSlideShow->dependsOn(this))
 263         SlideShow::Stop(*this);
 264     xSlideShow.clear();
 265
 266     // Tell the controller that the ViewShellBase is not available anymore.
 267     if (mpImpl->mpController)
 268         mpImpl->mpController->ReleaseViewShellBase();
 269
 270     // We have to hide the main window to prevent SFX complaining after a
 271     // reload about it being already visible.
 272     ViewShell* pShell = GetMainViewShell().get();
 273     if (pShell!=nullptr
 274         && pShell->GetActiveWindow()!=nullptr
 275         && pShell->GetActiveWindow()->GetParent()!=nullptr)
 276     {
 277         pShell->GetActiveWindow()->GetParent()->Hide();
 278     }
 279
 280     mpImpl->mpToolBarManager->Shutdown();
 281     mpImpl->mpViewShellManager->Shutdown();
 282
 283     EndListening(GetViewFrame());
 284     EndListening(*GetDocShell());
 285
 286     SetWindow(nullptr);
 287
 288     mpImpl->mpFormShellManager.reset();
 289 }
 290
 291 void ViewShellBase::LateInit (const OUString& rsDefaultView)
 292 {
 293     StartListening(GetViewFrame(), DuplicateHandling::Prevent);
 294     StartListening(*GetDocShell(), DuplicateHandling::Prevent);
 295     mpImpl->LateInit();
 296     InitializeFramework();
 297
 298     mpImpl->mpEventMultiplexer = std::make_shared<tools::EventMultiplexer>(*this);
 299
 300     mpImpl->mpFormShellManager = std::make_shared<FormShellManager>(*this);
 301
 302     mpImpl->mpToolBarManager = ToolBarManager::Create(
 303         *this,
 304         mpImpl->mpEventMultiplexer,
 305         mpImpl->mpViewShellManager);
 306
 307     try
 308     {
 309         rtl::Reference<::sd::DrawController> xControllerManager (GetDrawController());
 310         Reference<XConfigurationController> xConfigurationController;
 311         if (xControllerManager)
 312             xConfigurationController = xControllerManager->getConfigurationController();
 313         if (xConfigurationController.is())
 314         {
 315             OUString sView (rsDefaultView);
 316             if (sView.isEmpty())
 317                 sView = GetInitialViewShellType();
 318
 319             FrameworkHelper::Instance(*this);
 320
 321             // Create the resource ids for the center pane and view.
 322             const Reference<drawing::framework::XResourceId> xCenterPaneId (
 323                 FrameworkHelper::CreateResourceId(FrameworkHelper::msCenterPaneURL));
 324             const Reference<drawing::framework::XResourceId> xCenterViewId (
 325                 FrameworkHelper::CreateResourceId(sView, xCenterPaneId));
 326
 327             // Request center pane and view.
 328             xConfigurationController->requestResourceActivation(xCenterPaneId, ResourceActivationMode_ADD);
 329             xConfigurationController->requestResourceActivation(xCenterViewId, ResourceActivationMode_REPLACE);
 330
 331             // Process configuration events synchronously until the center view
 332             // has been created.
 333             sd::framework::ConfigurationController* pConfigurationController
 334                 = dynamic_cast<sd::framework::ConfigurationController*>(xConfigurationController.get());
 335             if (pConfigurationController != nullptr)
 336             {
 337                 while (
 338                     ! pConfigurationController->getResource(xCenterViewId).is()
 339                         && pConfigurationController->hasPendingRequests())
 340                 {
 341                     pConfigurationController->ProcessEvent();
 342                 }
 343             }
 344         }
 345     }
 346     catch (const RuntimeException&)
 347     {
 348     }
 349
 350     // AutoLayouts have to be ready.
 351     GetDocument()->StopWorkStartupDelay();
 352
 353     UpdateBorder();
 354
 355     // Remember the type of the current main view shell in the frame view.
 356     ViewShell* pViewShell = GetMainViewShell().get();
 357     if (pViewShell != nullptr)
 358     {
 359         FrameView* pFrameView = pViewShell->GetFrameView();
 360         if (pFrameView != nullptr)
 361             pFrameView->SetViewShellTypeOnLoad(pViewShell->GetShellType());
 362     }
 363     // Show/Hide the TabBar
 364     SdOptions* pOptions = SD_MOD()->GetSdOptions(GetDocument()->GetDocumentType());
 365     bool bIsTabBarVisible = pOptions->IsTabBarVisible();
 366     mpImpl->SetUserWantsTabBar( bIsTabBarVisible );
 367 }
 368
 369 std::shared_ptr<ViewShellManager> const & ViewShellBase::GetViewShellManager() const
 370 {
 371     return mpImpl->mpViewShellManager;
 372 }
 373
 374 std::shared_ptr<ViewShell> ViewShellBase::GetMainViewShell() const
 375 {
 376     std::shared_ptr<ViewShell> pMainViewShell (
 377         framework::FrameworkHelper::Instance(*const_cast<ViewShellBase*>(this))
 378             ->GetViewShell(framework::FrameworkHelper::msCenterPaneURL));
 379     if (pMainViewShell == nullptr)
 380         pMainViewShell = framework::FrameworkHelper::Instance(*const_cast<ViewShellBase*>(this))
 381             ->GetViewShell(framework::FrameworkHelper::msFullScreenPaneURL);
 382     return pMainViewShell;
 383 }
 384
 385 ViewShellBase* ViewShellBase::GetViewShellBase (SfxViewFrame const * pViewFrame)
 386 {
 387     ViewShellBase* pBase = nullptr;
 388
 389     if (pViewFrame != nullptr)
 390     {
 391         // Get the view shell for the frame and cast it to
 392         // sd::ViewShellBase.
 393         SfxViewShell* pSfxViewShell = pViewFrame->GetViewShell();
 394         pBase = dynamic_cast< ::sd::ViewShellBase *>( pSfxViewShell );
 395     }
 396
 397     return pBase;
 398 }
 399
 400 void ViewShellBase::Notify(SfxBroadcaster& rBC, const SfxHint& rHint)
 401 {
 402     SfxViewShell::Notify(rBC, rHint);
 403
 404     const SfxEventHint* pEventHint = dynamic_cast<const SfxEventHint*>(&rHint);
 405     if (pEventHint)
 406     {
 407         switch (pEventHint->GetEventId())
 408         {
 409             case SfxEventHintId::OpenDoc:
 410                 if( GetDocument() && GetDocument()->IsStartWithPresentation() )
 411                 {
 412                     GetViewFrame().GetDispatcher()->Execute(
 413                         SID_PRESENTATION, SfxCallMode::ASYNCHRON );
 414                 }
 415                 break;
 416
 417             default:
 418                 break;
 419         }
 420     }
 421     else
 422     {
 423         const SfxHintId nSlot = rHint.GetId();
 424         switch ( nSlot )
 425         {
 426             case SfxHintId::LanguageChanged:
 427             {
 428                 GetViewFrame().GetBindings().Invalidate(SID_LANGUAGE_STATUS);
 429             }
 430             break;
 431
 432             default:
 433                 break;
 434         }
 435     }
 436 }
 437
 438 void ViewShellBase::InitializeFramework()
 439 {
 440 }
 441
 442 OUString ViewShellBase::GetSelectionText(bool bCompleteWords, bool /*bOnlyASample*/)
 443 {
 444     std::shared_ptr<ViewShell> const pMainShell(GetMainViewShell());
 445     DrawViewShell *const pDrawViewShell(
 446             dynamic_cast<DrawViewShell*>(pMainShell.get()));
 447     return pDrawViewShell
 448         ?   pDrawViewShell->GetSelectionText(bCompleteWords)
 449         :   SfxViewShell::GetSelectionText(bCompleteWords);
 450 }
 451
 452 bool ViewShellBase::HasSelection(bool bText) const
 453 {
 454     std::shared_ptr<ViewShell> const pMainShell(GetMainViewShell());
 455     DrawViewShell *const pDrawViewShell(
 456             dynamic_cast<DrawViewShell*>(pMainShell.get()));
 457     return pDrawViewShell
 458         ?   pDrawViewShell->HasSelection(bText)
 459         :   SfxViewShell::HasSelection(bText);
 460 }
 461
 462 void ViewShellBase::InnerResizePixel (const Point& rOrigin, const Size &rSize, bool)
 463 {
 464     Size aObjSize = GetObjectShell()->GetVisArea().GetSize();
 465     if ( !aObjSize.IsEmpty() )
 466     {
 467         SvBorder aBorder( GetBorderPixel() );
 468         Size aSize( rSize );
 469         aSize.AdjustWidth( -(aBorder.Left() + aBorder.Right()) );
 470         aSize.AdjustHeight( -(aBorder.Top() + aBorder.Bottom()) );
 471         Size aObjSizePixel = mpImpl->mpViewWindow->LogicToPixel(aObjSize, MapMode(MapUnit::Map100thMM));
 472         SfxViewShell::SetZoomFactor(
 473             Fraction( aSize.Width(), std::max( aObjSizePixel.Width(), static_cast<::tools::Long>(1) ) ),
 474             Fraction( aSize.Height(), std::max( aObjSizePixel.Height(), static_cast<::tools::Long>(1)) ) );
 475     }
 476
 477     mpImpl->ResizePixel(rOrigin, rSize, false);
 478 }
 479
 480 void ViewShellBase::OuterResizePixel (const Point& rOrigin, const Size &rSize)
 481 {
 482     mpImpl->ResizePixel (rOrigin, rSize, true);
 483 }
 484
 485 void ViewShellBase::Rearrange()
 486 {
 487     // There is a bug in the communication between embedded objects and the
 488     // framework::LayoutManager that leads to missing resize updates.  The
 489     // following workaround enforces such an update by cycling the border to
 490     // zero and back to the current value.
 491     if (GetWindow() != nullptr)
 492     {
 493         SetBorderPixel(SvBorder());
 494         UpdateBorder(true);
 495     }
 496     else
 497     {
 498         SAL_WARN("sd.view", "Rearrange: window missing");
 499     }
 500
 501     GetViewFrame().Resize(true);
 502 }
 503
 504 ErrCode ViewShellBase::DoVerb(sal_Int32 nVerb)
 505 {
 506     ErrCode aResult = ERRCODE_NONE;
 507
 508     ::sd::ViewShell* pShell = GetMainViewShell().get();
 509     if (pShell != nullptr)
 510         aResult = pShell->DoVerb(nVerb);
 511
 512     return aResult;
 513 }
 514
 515 Reference<view::XRenderable> ViewShellBase::GetRenderable()
 516 {
 517     // Create a new DocumentRenderer on every call.  It observes the life
 518     // time of this ViewShellBase object.
 519     return Reference<view::XRenderable>(new DocumentRenderer(*this));
 520 }
 521
 522 SfxPrinter* ViewShellBase::GetPrinter (bool bCreate)
 523 {
 524     OSL_ASSERT(mpImpl != nullptr);
 525
 526     return GetDocShell()->GetPrinter (bCreate);
 527 }
 528
 529 sal_uInt16 ViewShellBase::SetPrinter (
 530     SfxPrinter* pNewPrinter,
 531     SfxPrinterChangeFlags nDiffFlags)
 532 {
 533     OSL_ASSERT(mpImpl != nullptr);
 534
 535     GetDocShell()->SetPrinter(pNewPrinter);
 536
 537     if ( (nDiffFlags & SfxPrinterChangeFlags::CHG_ORIENTATION ||
 538           nDiffFlags & SfxPrinterChangeFlags::CHG_SIZE) && pNewPrinter  )
 539     {
 540         MapMode aMap = pNewPrinter->GetMapMode();
 541         aMap.SetMapUnit(MapUnit::Map100thMM);
 542         MapMode aOldMap = pNewPrinter->GetMapMode();
 543         pNewPrinter->SetMapMode(aMap);
 544         Size aNewSize = pNewPrinter->GetOutputSize();
 545
 546         std::shared_ptr<DrawViewShell> pDrawViewShell (
 547             std::dynamic_pointer_cast<DrawViewShell>(GetMainViewShell()));
 548         if (pDrawViewShell)
 549         {
 550             SdPage* pPage = GetDocument()->GetSdPage(
 551                 0, PageKind::Standard );
 552             pDrawViewShell->SetPageSizeAndBorder (
 553                 pDrawViewShell->GetPageKind(),
 554                 aNewSize,
 555                 -1,-1,-1,-1,
 556                 false/*bScaleAll*/,
 557                 pNewPrinter->GetOrientation(),
 558                 pPage->GetPaperBin(),
 559                 pPage->IsBackgroundFullSize());
 560         }
 561
 562         pNewPrinter->SetMapMode(aOldMap);
 563     }
 564
 565     return 0;
 566 }
 567
 568 void ViewShellBase::UIActivating( SfxInPlaceClient* pClient )
 569 {
 570     mpImpl->ShowViewTabBar(false);
 571
 572     ViewShell* pViewShell = GetMainViewShell().get();
 573     if ( pViewShell )
 574         pViewShell->UIActivating( pClient );
 575
 576     SfxViewShell::UIActivating( pClient );
 577 }
 578
 579 void ViewShellBase::UIDeactivated( SfxInPlaceClient* pClient )
 580 {
 581     SfxViewShell::UIDeactivated( pClient );
 582
 583     mpImpl->ShowViewTabBar(true);
 584
 585     ViewShell* pViewShell = GetMainViewShell().get();
 586     if ( pViewShell )
 587         pViewShell->UIDeactivated( pClient );
 588 }
 589
 590 SvBorder ViewShellBase::GetBorder (bool )
 591 {
 592     int nTop = 0;
 593     if (mpImpl->mpViewTabBar.is() && mpImpl->mpViewTabBar->GetTabControl()->IsVisible())
 594         nTop = mpImpl->mpViewTabBar->GetHeight();
 595     return SvBorder(0,nTop,0,0);
 596 }
 597
 598 void ViewShellBase::Execute (SfxRequest& rRequest)
 599 {
 600     sal_uInt16 nSlotId = rRequest.GetSlot();
 601
 602     switch (nSlotId)
 603     {
 604         case SID_SWITCH_SHELL:
 605         {
 606             Reference<XControllerManager> xControllerManager (GetController(), UNO_QUERY);
 607             if (xControllerManager.is())
 608             {
 609                 Reference<XConfigurationController> xConfigurationController (
 610                     xControllerManager->getConfigurationController());
 611                 if (xConfigurationController.is())
 612                     xConfigurationController->update();
 613             }
 614         }
 615         break;
 616
 617         case SID_LEFT_PANE_DRAW:
 618             mpImpl->SetPaneVisibility(
 619                 rRequest,
 620                 framework::FrameworkHelper::msLeftDrawPaneURL,
 621                 framework::FrameworkHelper::msSlideSorterURL);
 622             break;
 623
 624         case SID_LEFT_PANE_IMPRESS:
 625             mpImpl->SetPaneVisibility(
 626                 rRequest,
 627                 framework::FrameworkHelper::msLeftImpressPaneURL,
 628                 framework::FrameworkHelper::msSlideSorterURL);
 629             break;
 630
 631         case SID_TOGGLE_TABBAR_VISIBILITY:
 632         {
 633             SdOptions* pOptions = SD_MOD()->GetSdOptions(GetDocument()->GetDocumentType());
 634             bool bIsTabBarVisible = pOptions->IsTabBarVisible();
 635             pOptions->SetTabBarVisible( !bIsTabBarVisible );
 636             mpImpl->SetUserWantsTabBar( !bIsTabBarVisible );
 637             rRequest.Done();
 638         }
 639         break;
 640
 641         // draw
 642         case SID_DRAWINGMODE:
 643         // impress normal
 644         case SID_NORMAL_MULTI_PANE_GUI:
 645         case SID_NOTES_MODE:
 646         case SID_OUTLINE_MODE:
 647         case SID_SLIDE_SORTER_MULTI_PANE_GUI:
 648         case SID_SLIDE_SORTER_MODE:
 649         // impress master
 650         case SID_SLIDE_MASTER_MODE:
 651         case SID_NOTES_MASTER_MODE:
 652         case SID_HANDOUT_MASTER_MODE:
 653             framework::FrameworkHelper::Instance(*this)->HandleModeChangeSlot(nSlotId, rRequest);
 654             break;
 655
 656         case SID_WIN_FULLSCREEN:
 657             // The full screen mode is not supported.  Ignore the request.
 658             break;
 659
 660         case SID_RESTORE_EDITING_VIEW:
 661             mpImpl->ProcessRestoreEditingViewSlot();
 662             break;
 663
 664         default:
 665             // Ignore any other slot.
 666             rRequest.Ignore ();
 667             break;
 668     }
 669 }
 670
 671 void ViewShellBase::GetState (SfxItemSet& rSet)
 672 {
 673     mpImpl->GetSlotState(rSet);
 674
 675     FuBullet::GetSlotState( rSet, nullptr, &GetViewFrame() );
 676 }
 677
 678 void ViewShellBase::WriteUserDataSequence (
 679     css::uno::Sequence< css::beans::PropertyValue >& rSequence)
 680 {
 681     // Forward call to main sub shell.
 682     ViewShell* pShell = GetMainViewShell().get();
 683     if (pShell != nullptr)
 684         pShell->WriteUserDataSequence (rSequence);
 685 }
 686
 687 void ViewShellBase::ReadUserDataSequence (
 688     const css::uno::Sequence< css::beans::PropertyValue >& rSequence)
 689 {
 690     // Forward call to main sub shell.
 691     ViewShell* pShell = GetMainViewShell().get();
 692     if (pShell == nullptr)
 693         return;
 694
 695     pShell->ReadUserDataSequence (rSequence);
 696
 697     // For certain shell types ReadUserDataSequence may have changed the
 698     // type to another one.  Make sure that the center pane shows the
 699     // right view shell.
 700     switch (pShell->GetShellType())
 701     {
 702         case ViewShell::ST_IMPRESS:
 703         case ViewShell::ST_NOTES:
 704         case ViewShell::ST_HANDOUT:
 705         {
 706             OUString sViewURL;
 707             switch (dynamic_cast<DrawViewShell&>(*pShell).GetPageKind())
 708             {
 709                 default:
 710                 case PageKind::Standard:
 711                     sViewURL = framework::FrameworkHelper::msImpressViewURL;
 712                     break;
 713                 case PageKind::Notes:
 714                     sViewURL = framework::FrameworkHelper::msNotesViewURL;
 715                     break;
 716                 case PageKind::Handout:
 717                     sViewURL = framework::FrameworkHelper::msHandoutViewURL;
 718                     break;
 719             }
 720             if (!sViewURL.isEmpty())
 721                 framework::FrameworkHelper::Instance(*this)->RequestView(
 722                     sViewURL,
 723                     framework::FrameworkHelper::msCenterPaneURL);
 724         }
 725         break;
 726
 727         default:
 728             break;
 729     }
 730 }
 731
 732 void ViewShellBase::Activate (bool bIsMDIActivate)
 733 {
 734     SfxViewShell::Activate(bIsMDIActivate);
 735
 736     Reference<XControllerManager> xControllerManager (GetController(), UNO_QUERY);
 737     if (xControllerManager.is())
 738     {
 739         Reference<XConfigurationController> xConfigurationController (
 740             xControllerManager->getConfigurationController());
 741         if (xConfigurationController.is())
 742             xConfigurationController->update();
 743     }
 744     GetToolBarManager()->RequestUpdate();
 745 }
 746
 747 void ViewShellBase::SetZoomFactor (
 748     const Fraction &rZoomX,
 749     const Fraction &rZoomY)
 750 {
 751     SfxViewShell::SetZoomFactor (rZoomX, rZoomY);
 752     // Forward call to main sub shell.
 753     ViewShell* pShell = GetMainViewShell().get();
 754     if (pShell != nullptr)
 755         pShell->SetZoomFactor (rZoomX, rZoomY);
 756 }
 757
 758 bool ViewShellBase::PrepareClose (bool bUI)
 759 {
 760     bool bResult = SfxViewShell::PrepareClose (bUI);
 761
 762     if (bResult)
 763     {
 764         mpImpl->mbIsClosing = true;
 765
 766         // Forward call to main sub shell.
 767         ViewShell* pShell = GetMainViewShell().get();
 768         if (pShell != nullptr)
 769             bResult = pShell->PrepareClose (bUI);
 770     }
 771
 772     return bResult;
 773 }
 774
 775 void ViewShellBase::WriteUserData (OUString& rString, bool bBrowse)
 776 {
 777     SfxViewShell::WriteUserData (rString, bBrowse);
 778
 779     // Forward call to main sub shell.
 780     ViewShell* pShell = GetMainViewShell().get();
 781     if (pShell != nullptr)
 782         pShell->WriteUserData();
 783 }
 784
 785 void ViewShellBase::ReadUserData (const OUString& rString, bool bBrowse)
 786 {
 787     SfxViewShell::ReadUserData (rString, bBrowse);
 788
 789     // Forward call to main sub shell.
 790     ViewShell* pShell = GetMainViewShell().get();
 791     if (pShell != nullptr)
 792         pShell->ReadUserData();
 793 }
 794
 795 SdrView* ViewShellBase::GetDrawView() const
 796 {
 797     // Forward call to main sub shell.
 798     ViewShell* pShell = GetMainViewShell().get();
 799     if (pShell != nullptr)
 800         return pShell->GetDrawView ();
 801     else
 802         return SfxViewShell::GetDrawView();
 803 }
 804
 805 void ViewShellBase::SetBusyState (bool bBusy)
 806 {
 807     if (GetDocShell() != nullptr)
 808         GetDocShell()->SetWaitCursor (bBusy);
 809 }
 810
 811 void ViewShellBase::UpdateBorder ( bool bForce /* = false */ )
 812 {
 813     // The following calls to SetBorderPixel() and InvalidateBorder() are
 814     // made only for the main view shell.  This not only avoids unnecessary
 815     // calls for the views in side panes but prevents calling an already
 816     // dying SfxViewShell base class.
 817     // We have to check the existence of the window, too.
 818     // The SfxViewFrame accesses the window without checking it.
 819     ViewShell* pMainViewShell = GetMainViewShell().get();
 820     if (pMainViewShell == nullptr || GetWindow()==nullptr)
 821         return;
 822
 823     SvBorder aCurrentBorder (GetBorderPixel());
 824     bool bOuterResize ( ! GetDocShell()->IsInPlaceActive());
 825     SvBorder aBorder (GetBorder(bOuterResize));
 826     aBorder += pMainViewShell->GetBorder();
 827
 828     if (bForce || (aBorder != aCurrentBorder))
 829     {
 830         SetBorderPixel (aBorder);
 831         InvalidateBorder();
 832     }
 833 }
 834
 835 void ViewShellBase::ShowUIControls (bool bVisible)
 836 {
 837     mpImpl->ShowViewTabBar(bVisible);
 838
 839     ViewShell* pMainViewShell = GetMainViewShell().get();
 840     if (pMainViewShell != nullptr)
 841         pMainViewShell->ShowUIControls (bVisible);
 842
 843     UpdateBorder();
 844     if (bVisible)
 845         Rearrange();
 846 }
 847
 848 OUString ViewShellBase::GetInitialViewShellType() const
 849 {
 850     OUString sRequestedView (FrameworkHelper::msImpressViewURL);
 851
 852     do
 853     {
 854         Reference<document::XViewDataSupplier> xViewDataSupplier (
 855             GetDocShell()->GetModel(), UNO_QUERY);
 856         if ( ! xViewDataSupplier.is())
 857             break;
 858
 859         Reference<container::XIndexAccess> xViewData (xViewDataSupplier->getViewData());
 860         if ( ! xViewData.is())
 861             break;
 862         if (xViewData->getCount() == 0)
 863             break;
 864
 865         css::uno::Any aAny = xViewData->getByIndex(0);
 866         Sequence<beans::PropertyValue> aProperties;
 867         if ( ! (aAny >>= aProperties))
 868             break;
 869
 870         // Search the properties for the one that tells us what page kind to
 871         // use.
 872         auto pProperty = std::find_if(std::cbegin(aProperties), std::cend(aProperties),
 873             [](const beans::PropertyValue& rProperty) { return rProperty.Name == sUNO_View_PageKind; });
 874         if (pProperty != std::cend(aProperties))
 875         {
 876             sal_Int16 nPageKind = 0;
 877             pProperty->Value >>= nPageKind;
 878             switch (static_cast<PageKind>(nPageKind))
 879             {
 880                 case PageKind::Standard:
 881                     sRequestedView = FrameworkHelper::msImpressViewURL;
 882                     break;
 883
 884                 case PageKind::Handout:
 885                     sRequestedView = FrameworkHelper::msHandoutViewURL;
 886                     break;
 887
 888                 case PageKind::Notes:
 889                     sRequestedView = FrameworkHelper::msNotesViewURL;
 890                     break;
 891
 892                 default:
 893                     // The page kind is invalid.  This is probably an
 894                     // error by the caller.  We use the standard type to
 895                     // keep things going.
 896                     SAL_WARN( "sd.view", "ViewShellBase::GetInitialViewShellType: invalid page kind");
 897                     sRequestedView = FrameworkHelper::msImpressViewURL;
 898                     break;
 899             }
 900         }
 901     }
 902     while (false);
 903
 904     return sRequestedView;
 905 }
 906
 907 std::shared_ptr<tools::EventMultiplexer> const & ViewShellBase::GetEventMultiplexer() const
 908 {
 909     OSL_ASSERT(mpImpl != nullptr);
 910     OSL_ASSERT(mpImpl->mpEventMultiplexer != nullptr);
 911
 912     return mpImpl->mpEventMultiplexer;
 913 }
 914
 915 const ::tools::Rectangle& ViewShellBase::getClientRectangle() const
 916 {
 917     return mpImpl->maClientArea;
 918 }
 919
 920 std::shared_ptr<ToolBarManager> const & ViewShellBase::GetToolBarManager() const
 921 {
 922     OSL_ASSERT(mpImpl != nullptr);
 923     OSL_ASSERT(mpImpl->mpToolBarManager != nullptr);
 924
 925     return mpImpl->mpToolBarManager;
 926 }
 927
 928 std::shared_ptr<FormShellManager> const & ViewShellBase::GetFormShellManager() const
 929 {
 930     OSL_ASSERT(mpImpl != nullptr);
 931     OSL_ASSERT(mpImpl->mpFormShellManager != nullptr);
 932
 933     return mpImpl->mpFormShellManager;
 934 }
 935
 936 DrawController* ViewShellBase::GetDrawController() const
 937 {
 938     OSL_ASSERT(mpImpl != nullptr);
 939
 940     return mpImpl->mpController.get();
 941 }
 942
 943 void ViewShellBase::SetViewTabBar (const ::rtl::Reference<ViewTabBar>& rViewTabBar)
 944 {
 945     OSL_ASSERT(mpImpl != nullptr);
 946
 947     mpImpl->mpViewTabBar = rViewTabBar;
 948 }
 949
 950 vcl::Window* ViewShellBase::GetViewWindow()
 951 {
 952     OSL_ASSERT(mpImpl != nullptr);
 953
 954     return mpImpl->mpViewWindow.get();
 955 }
 956
 957 OUString ViewShellBase::RetrieveLabelFromCommand( const OUString& aCmdURL ) const
 958 {
 959     OUString aModuleName(vcl::CommandInfoProvider::GetModuleIdentifier(GetMainViewShell()->GetViewFrame()->GetFrame().GetFrameInterface()));
 960     auto aProperties = vcl::CommandInfoProvider::GetCommandProperties(aCmdURL, aModuleName);
 961     return vcl::CommandInfoProvider::GetLabelForCommand(aProperties);
 962 }
 963
 964 int ViewShellBase::getPart() const
 965 {
 966     ViewShell* pViewShell = framework::FrameworkHelper::Instance(*const_cast<ViewShellBase*>(this))->GetViewShell(FrameworkHelper::msCenterPaneURL).get();
 967
 968     if (DrawViewShell* pDrawViewShell = dynamic_cast<DrawViewShell*>(pViewShell))
 969     {
 970         return pDrawViewShell->GetCurPagePos();
 971     }
 972
 973     return 0;
 974 }
 975
 976 int ViewShellBase::getEditMode() const
 977 {
 978     ViewShell* pViewShell = framework::FrameworkHelper::Instance(*const_cast<ViewShellBase*>(this))->GetViewShell(FrameworkHelper::msCenterPaneURL).get();
 979
 980     if (DrawViewShell* pDrawViewShell = dynamic_cast<DrawViewShell*>(pViewShell))
 981     {
 982         switch ( pDrawViewShell->GetEditMode() )
 983         {
 984         case EditMode::Page:
 985             return 0;
 986         case EditMode::MasterPage:
 987             return 1;
 988         }
 989     }
 990
 991     return 0;
 992 }
 993
 994 void ViewShellBase::setEditMode(int nMode)
 995 {
 996     ViewShell* pViewShell = framework::FrameworkHelper::Instance(*this)->GetViewShell(FrameworkHelper::msCenterPaneURL).get();
 997
 998     if (DrawViewShell* pDrawViewShell = dynamic_cast<DrawViewShell*>(pViewShell))
 999     {
1000         switch ( nMode )
1001         {
1002         case 0:
1003             pDrawViewShell->ChangeEditMode(EditMode::Page, false);
1004             break;
1005         case 1:
1006             pDrawViewShell->ChangeEditMode(EditMode::MasterPage, false);
1007             break;
1008         }
1009     }
1010 }
1011
1012 void ViewShellBase::afterCallbackRegistered()
1013 {
1014     // TODO: Add theme color palette changed callback
1015 }
1016
1017 void ViewShellBase::NotifyCursor(SfxViewShell* pOtherShell) const
1018 {
1019     ViewShell* pThisShell = framework::FrameworkHelper::Instance(*const_cast<ViewShellBase*>(this))->GetViewShell(FrameworkHelper::msCenterPaneURL).get();
1020
1021     DrawViewShell* pDrawViewShell = dynamic_cast<DrawViewShell*>(pThisShell);
1022     if (!pDrawViewShell)
1023         return;
1024
1025     if (this == pOtherShell)
1026         return;
1027
1028     DrawView* pDrawView = pDrawViewShell->GetDrawView();
1029     if (!pDrawView)
1030         return;
1031
1032     if (pDrawView->GetTextEditObject())
1033     {
1034         // Blinking cursor.
1035         EditView& rEditView = pDrawView->GetTextEditOutlinerView()->GetEditView();
1036         rEditView.RegisterOtherShell(pOtherShell);
1037         rEditView.ShowCursor();
1038         rEditView.RegisterOtherShell(nullptr);
1039         // Text selection, if any.
1040         rEditView.DrawSelectionXOR(pOtherShell);
1041
1042         // Shape text lock.
1043         if (OutlinerView* pOutlinerView = pDrawView->GetTextEditOutlinerView())
1044         {
1045             ::tools::Rectangle aRectangle = pOutlinerView->GetOutputArea();
1046             vcl::Window* pWin = pThisShell->GetActiveWindow();
1047             if (pWin && pWin->GetMapMode().GetMapUnit() == MapUnit::Map100thMM)
1048                 aRectangle = o3tl::toTwips(aRectangle, o3tl::Length::mm100);
1049             OString sRectangle = aRectangle.toString();
1050             SfxLokHelper::notifyOtherView(&pDrawViewShell->GetViewShellBase(), pOtherShell, LOK_CALLBACK_VIEW_LOCK, "rectangle", sRectangle);
1051         }
1052     }
1053     else
1054     {
1055         // Graphic selection.
1056         pDrawView->AdjustMarkHdl(pOtherShell);
1057     }
1058 }
1059
1060 //===== ViewShellBase::Implementation =========================================
1061
1062 ViewShellBase::Implementation::Implementation (ViewShellBase& rBase)
1063     : mbIsClosing(false),
1064       mrBase(rBase),
1065       mbUserWantsTabBar(false),
1066       mbTabBarShouldBeVisible(true),
1067       mpPageCacheManager(slidesorter::cache::PageCacheManager::Instance())
1068 {
1069 }
1070
1071 ViewShellBase::Implementation::~Implementation()
1072 {
1073     mpController = nullptr;
1074     mpViewTabBar = nullptr;
1075     mpViewWindow.disposeAndClear();
1076     mpToolBarManager.reset();
1077 }
1078
1079 void ViewShellBase::Implementation::LateInit()
1080 {
1081     mpController = new DrawController(mrBase);
1082 }
1083
1084 void ViewShellBase::Implementation::ProcessRestoreEditingViewSlot()
1085 {
1086     ViewShell* pViewShell = mrBase.GetMainViewShell().get();
1087     if (pViewShell == nullptr)
1088         return;
1089
1090     FrameView* pFrameView = pViewShell->GetFrameView();
1091     if (pFrameView == nullptr)
1092         return;
1093
1094     // Set view shell, edit mode, and page kind.
1095     // pFrameView->SetViewShEditMode(
1096     //     pFrameView->GetViewShEditModeOnLoad(),
1097     //     pFrameView->GetPageKindOnLoad());
1098     pFrameView->SetViewShEditMode(
1099         pFrameView->GetViewShEditModeOnLoad() );
1100     pFrameView->SetPageKind(
1101         pFrameView->GetPageKindOnLoad());
1102     std::shared_ptr<FrameworkHelper> pHelper (FrameworkHelper::Instance(mrBase));
1103     pHelper->RequestView(
1104         FrameworkHelper::GetViewURL(pFrameView->GetViewShellTypeOnLoad()),
1105         FrameworkHelper::msCenterPaneURL);
1106     pHelper->RunOnConfigurationEvent("ConfigurationUpdateEnd", CurrentPageSetter(mrBase));
1107 }
1108
1109 void ViewShellBase::Implementation::SetUserWantsTabBar(bool inValue)
1110 {
1111     mbUserWantsTabBar = inValue;
1112     // Call ShowViewTabBar to refresh the TabBar visibility
1113     ShowViewTabBar(mbTabBarShouldBeVisible);
1114 }
1115
1116 void ViewShellBase::Implementation::ShowViewTabBar (bool bShow)
1117 {
1118     mbTabBarShouldBeVisible = bShow;
1119     bShow = bShow && mbUserWantsTabBar;
1120
1121     if (mpViewTabBar.is()
1122         && mpViewTabBar->GetTabControl()->IsVisible() != bShow)
1123     {
1124         mpViewTabBar->GetTabControl()->Show(bShow);
1125         mrBase.Rearrange();
1126     }
1127 }
1128
1129 void ViewShellBase::Implementation::ResizePixel (
1130     const Point& rOrigin,
1131     const Size &rSize,
1132     bool bOuterResize)
1133 {
1134     if (mbIsClosing)
1135         return;
1136
1137     // Forward the call to both the base class and the main stacked sub
1138     // shell only when main sub shell exists.
1139     ViewShell* pMainViewShell = mrBase.GetMainViewShell().get();
1140
1141     // Set the ViewTabBar temporarily to full size so that, when asked
1142     // later, it can return its true height.
1143     mrBase.SetWindow (mpViewWindow.get());
1144     if (mpViewTabBar.is() && mpViewTabBar->GetTabControl()->IsVisible())
1145         mpViewTabBar->GetTabControl()->SetPosSizePixel (rOrigin, rSize);
1146
1147     // Calculate and set the border before the controls are placed.
1148     SvBorder aBorder;
1149     if (pMainViewShell != nullptr)
1150         aBorder = pMainViewShell->GetBorder();
1151     aBorder += mrBase.GetBorder(bOuterResize);
1152     if (mrBase.GetBorderPixel() != aBorder)
1153         mrBase.SetBorderPixel(aBorder);
1154
1155     // Place the ViewTabBar at the top.  It is part of the border.
1156     SvBorder aBaseBorder;
1157     if (mpViewTabBar.is() && mpViewTabBar->GetTabControl()->IsVisible())
1158     {
1159         aBaseBorder.Top() = mpViewTabBar->GetHeight();
1160         mpViewTabBar->GetTabControl()->SetPosSizePixel(
1161             rOrigin, Size(rSize.Width(),aBaseBorder.Top()));
1162     }
1163
1164     // The view window gets the remaining space.
1165     Point aViewWindowPosition (
1166         rOrigin.X()+aBaseBorder.Left(),
1167         rOrigin.Y()+aBaseBorder.Top());
1168
1169     Size aViewWindowSize (
1170         rSize.Width() - aBaseBorder.Left() - aBaseBorder.Right(),
1171         rSize.Height() - aBaseBorder.Top() - aBaseBorder.Bottom());
1172     mpViewWindow->SetPosSizePixel(aViewWindowPosition, aViewWindowSize);
1173
1174     maClientArea = ::tools::Rectangle(Point(0,0), aViewWindowSize);
1175 }
1176
1177 void ViewShellBase::Implementation::SetPaneVisibility (
1178     const SfxRequest& rRequest,
1179     const OUString& rsPaneURL,
1180     const OUString& rsViewURL)
1181 {
1182     try
1183     {
1184         Reference<XControllerManager> xControllerManager (mrBase.GetController(), UNO_QUERY_THROW);
1185
1186         const Reference< XComponentContext > xContext(
1187             ::comphelper::getProcessComponentContext() );
1188         Reference<XResourceId> xPaneId (ResourceId::create(
1189             xContext, rsPaneURL));
1190         Reference<XResourceId> xViewId (ResourceId::createWithAnchorURL(
1191             xContext, rsViewURL, rsPaneURL));
1192
1193         // Determine the new visibility state.
1194         const SfxItemSet* pArguments = rRequest.GetArgs();
1195         bool bShowChildWindow;
1196         sal_uInt16 nSlotId = rRequest.GetSlot();
1197         if (pArguments != nullptr)
1198             bShowChildWindow = static_cast<const SfxBoolItem&>(
1199                 pArguments->Get(nSlotId)).GetValue();
1200         else
1201         {
1202             Reference<XConfigurationController> xConfigurationController (
1203                 xControllerManager->getConfigurationController());
1204             if ( ! xConfigurationController.is())
1205                 throw RuntimeException();
1206             Reference<XConfiguration> xConfiguration (
1207                 xConfigurationController->getRequestedConfiguration());
1208             if ( ! xConfiguration.is())
1209                 throw RuntimeException();
1210
1211             bShowChildWindow = ! xConfiguration->hasResource(xPaneId);
1212         }
1213
1214         // Set the desired visibility state at the current configuration
1215         // and update it accordingly.
1216         Reference<XConfigurationController> xConfigurationController (
1217             xControllerManager->getConfigurationController());
1218         if ( ! xConfigurationController.is())
1219             throw RuntimeException();
1220         if (bShowChildWindow)
1221         {
1222             xConfigurationController->requestResourceActivation(
1223                 xPaneId,
1224                 ResourceActivationMode_ADD);
1225             xConfigurationController->requestResourceActivation(
1226                 xViewId,
1227                 ResourceActivationMode_REPLACE);
1228         }
1229         else
1230             xConfigurationController->requestResourceDeactivation(
1231                 xPaneId);
1232     }
1233     catch (const Exception&)
1234     {
1235         DBG_UNHANDLED_EXCEPTION("sd.view");
1236     }
1237 }
1238
1239 void ViewShellBase::Implementation::GetSlotState (SfxItemSet& rSet)
1240 {
1241     try
1242     {
1243         // Get some frequently used values.
1244         Reference<XControllerManager> xControllerManager (mrBase.GetController(), UNO_QUERY_THROW);
1245         Reference<XConfigurationController> xConfigurationController (
1246             xControllerManager->getConfigurationController());
1247         if ( ! xConfigurationController.is())
1248             throw RuntimeException();
1249         Reference<XConfiguration> xConfiguration (
1250             xConfigurationController->getRequestedConfiguration());
1251         if ( ! xConfiguration.is())
1252             throw RuntimeException();
1253
1254         const Reference< XComponentContext > xContext(
1255             ::comphelper::getProcessComponentContext() );
1256         SfxWhichIter aSetIterator (rSet);
1257         sal_uInt16 nItemId (aSetIterator.FirstWhich());
1258
1259         while (nItemId > 0)
1260         {
1261             bool bState (false);
1262             Reference<XResourceId> xResourceId;
1263             try
1264             {
1265                 // Check if the right view is active
1266                 switch (nItemId)
1267                 {
1268                     case SID_LEFT_PANE_IMPRESS:
1269                         xResourceId = ResourceId::create(
1270                             xContext, FrameworkHelper::msLeftImpressPaneURL);
1271                         bState = xConfiguration->hasResource(xResourceId);
1272                         break;
1273
1274                     case SID_LEFT_PANE_DRAW:
1275                         xResourceId = ResourceId::create(
1276                             xContext, FrameworkHelper::msLeftDrawPaneURL);
1277                         bState = xConfiguration->hasResource(xResourceId);
1278                         break;
1279
1280                     case SID_DRAWINGMODE:
1281                     case SID_NORMAL_MULTI_PANE_GUI:
1282                     case SID_SLIDE_MASTER_MODE:
1283                         xResourceId = ResourceId::createWithAnchorURL(
1284                             xContext, FrameworkHelper::msImpressViewURL,
1285                             FrameworkHelper::msCenterPaneURL);
1286                         bState = xConfiguration->hasResource(xResourceId);
1287                         break;
1288
1289                     case SID_SLIDE_SORTER_MULTI_PANE_GUI:
1290                     case SID_SLIDE_SORTER_MODE:
1291                         xResourceId = ResourceId::createWithAnchorURL(
1292                             xContext,
1293                             FrameworkHelper::msSlideSorterURL,
1294                             FrameworkHelper::msCenterPaneURL);
1295                         bState = xConfiguration->hasResource(xResourceId);
1296                         break;
1297
1298                     case SID_OUTLINE_MODE:
1299                         xResourceId = ResourceId::createWithAnchorURL(
1300                             xContext,
1301                             FrameworkHelper::msOutlineViewURL,
1302                             FrameworkHelper::msCenterPaneURL);
1303                         bState = xConfiguration->hasResource(xResourceId);
1304                         break;
1305
1306                     case SID_HANDOUT_MASTER_MODE:
1307                         xResourceId = ResourceId::createWithAnchorURL(
1308                             xContext, FrameworkHelper::msHandoutViewURL,
1309                             FrameworkHelper::msCenterPaneURL);
1310                         bState = xConfiguration->hasResource(xResourceId);
1311                         break;
1312
1313                     case SID_NOTES_MODE:
1314                     case SID_NOTES_MASTER_MODE:
1315                         xResourceId = ResourceId::createWithAnchorURL(
1316                             xContext, FrameworkHelper::msNotesViewURL,
1317                             FrameworkHelper::msCenterPaneURL);
1318                         bState = xConfiguration->hasResource(xResourceId);
1319                         break;
1320
1321                     case SID_TOGGLE_TABBAR_VISIBILITY:
1322                         bState = GetUserWantsTabBar();
1323                         break;
1324
1325                     default:
1326                         // Ignore all other items.  They are not meant to be
1327                         // handled by us.
1328                         break;
1329                 }
1330             }
1331             catch (const DeploymentException&)
1332             {
1333             }
1334
1335             // Check if edit mode fits too
1336             if (bState)
1337             {
1338                 ViewShell* const pCenterViewShell = FrameworkHelper::Instance(mrBase)->GetViewShell(
1339                     FrameworkHelper::msCenterPaneURL).get();
1340                 DrawViewShell* const pShell = dynamic_cast<DrawViewShell*>(pCenterViewShell);
1341                 if (pShell)
1342                 {
1343                     switch (nItemId)
1344                     {
1345                         case SID_DRAWINGMODE:
1346                         case SID_NORMAL_MULTI_PANE_GUI:
1347                         case SID_NOTES_MODE:
1348                             bState = pShell->GetEditMode() == EditMode::Page;
1349                             break;
1350                         case SID_SLIDE_MASTER_MODE:
1351                         case SID_NOTES_MASTER_MODE:
1352                             bState = pShell->GetEditMode() == EditMode::MasterPage;
1353                             break;
1354                     }
1355                 }
1356             }
1357
1358             // And finally set the state.
1359             rSet.Put(SfxBoolItem(nItemId, bState));
1360
1361             nItemId = aSetIterator.NextWhich();
1362         }
1363     }
1364     catch (const RuntimeException&)
1365     {
1366         DBG_UNHANDLED_EXCEPTION("sd.view");
1367     }
1368
1369 }
1370
1371 } // end of namespace sd
1372
1373 //===== CurrentPageSetter ===========================================
1374
1375 namespace {
1376
1377 CurrentPageSetter::CurrentPageSetter (ViewShellBase& rBase)
1378     : mrBase(rBase)
1379 {
1380 }
1381
1382 void CurrentPageSetter::operator() (bool)
1383 {
1384     FrameView* pFrameView = nullptr;
1385
1386     if (mrBase.GetMainViewShell() != nullptr)
1387     {
1388         pFrameView = mrBase.GetMainViewShell()->GetFrameView();
1389     }
1390
1391     if (pFrameView==nullptr)
1392         return;
1393
1394     try
1395     {
1396         // Get the current page either from the DrawPagesSupplier or the
1397         // MasterPagesSupplier.
1398         Any aPage;
1399         if (pFrameView->GetViewShEditModeOnLoad() == EditMode::Page)
1400         {
1401             Reference<drawing::XDrawPagesSupplier> xPagesSupplier (
1402                 mrBase.GetController()->getModel(), UNO_QUERY_THROW);
1403             Reference<container::XIndexAccess> xPages (
1404                 xPagesSupplier->getDrawPages(), UNO_QUERY_THROW);
1405             aPage = xPages->getByIndex(pFrameView->GetSelectedPageOnLoad());
1406         }
1407         else
1408         {
1409             Reference<drawing::XMasterPagesSupplier> xPagesSupplier (
1410                 mrBase.GetController()->getModel(), UNO_QUERY_THROW);
1411             Reference<container::XIndexAccess> xPages (
1412                 xPagesSupplier->getMasterPages(), UNO_QUERY_THROW);
1413             aPage = xPages->getByIndex(pFrameView->GetSelectedPageOnLoad());
1414         }
1415         // Switch to the page last edited by setting the CurrentPage
1416         // property.
1417         Reference<beans::XPropertySet> xSet (mrBase.GetController(), UNO_QUERY_THROW);
1418         xSet->setPropertyValue ("CurrentPage", aPage);
1419     }
1420     catch (const RuntimeException&)
1421     {
1422         // We have not been able to set the current page at the main view.
1423         // This is sad but still leaves us in a valid state.  Therefore,
1424         // this exception is silently ignored.
1425     }
1426     catch (const beans::UnknownPropertyException&)
1427     {
1428         SAL_WARN("sd.view", "CurrentPage property unknown");
1429     }
1430 }
1431
1432 } // end of anonymous namespace
1433
1434 //===== FocusForwardingWindow =================================================
1435
1436 namespace sd {
1437 namespace {
1438
1439 FocusForwardingWindow::FocusForwardingWindow (
1440     vcl::Window& rParentWindow,
1441     ViewShellBase& rBase)
1442     : vcl::Window(&rParentWindow, WinBits(WB_CLIPCHILDREN | WB_DIALOGCONTROL)),
1443         mrBase(rBase)
1444 {
1445     SAL_INFO("sd.view", "created FocusForwardingWindow at " << this);
1446 }
1447
1448 FocusForwardingWindow::~FocusForwardingWindow()
1449 {
1450     disposeOnce();
1451 }
1452
1453 void FocusForwardingWindow::dispose()
1454 {
1455     SAL_INFO("sd.view", "destroyed FocusForwardingWindow at " << this);
1456     vcl::Window::dispose();
1457 }
1458
1459 void FocusForwardingWindow::KeyInput (const KeyEvent& rKEvt)
1460 {
1461     std::shared_ptr<ViewShell> pViewShell = mrBase.GetMainViewShell();
1462     if (pViewShell != nullptr)
1463     {
1464         vcl::Window* pWindow = pViewShell->GetActiveWindow();
1465         if (pWindow != nullptr)
1466         {
1467             // Forward the focus so that the window is called directly the
1468             // next time.
1469             pWindow->GrabFocus();
1470             // Forward the key press as well.
1471             pWindow->KeyInput(rKEvt);
1472         }
1473     }
1474 }
1475
1476 void FocusForwardingWindow::Command (const CommandEvent& rEvent)
1477 {
1478     std::shared_ptr<ViewShell> pViewShell = mrBase.GetMainViewShell();
1479     if (pViewShell != nullptr)
1480     {
1481         vcl::Window* pWindow = pViewShell->GetActiveWindow();
1482         if (pWindow != nullptr)
1483         {
1484             pWindow->Command(rEvent);
1485         }
1486     }
1487 }
1488
1489 } // end of anonymous namespace
1490
1491 } // end of namespace sd
1492
1493 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */