sd/source/ui/framework/tools/FrameworkHelper.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 <osl/time.h>
  21
  22 #include <framework/FrameworkHelper.hxx>
  23
  24 #include <framework/ConfigurationController.hxx>
  25 #include <framework/ResourceId.hxx>
  26 #include <framework/ViewShellWrapper.hxx>
  27 #include <ViewShellBase.hxx>
  28 #include <DrawViewShell.hxx>
  29 #include <ViewShellHint.hxx>
  30 #include <app.hrc>
  31 #include <com/sun/star/drawing/framework/XControllerManager.hpp>
  32 #include <cppuhelper/compbase.hxx>
  33 #include <svl/lstner.hxx>
  34
  35 #include <sfx2/request.hxx>
  36
  37 #include <MutexOwner.hxx>
  38 #include <vcl/svapp.hxx>
  39 #include <osl/doublecheckedlocking.h>
  40 #include <osl/getglobalmutex.hxx>
  41 #include <tools/diagnose_ex.h>
  42 #include <memory>
  43 #include <unordered_map>
  44
  45 using namespace ::com::sun::star;
  46 using namespace ::com::sun::star::uno;
  47 using namespace ::com::sun::star::drawing::framework;
  48
  49 namespace {
  50
  51 //----- CallbackCaller --------------------------------------------------------
  52
  53 typedef ::cppu::WeakComponentImplHelper <
  54     css::drawing::framework::XConfigurationChangeListener
  55     > CallbackCallerInterfaceBase;
  56
  57 /** A CallbackCaller registers as listener at an XConfigurationController
  58     object and waits for the notification of one type of event.  When that
  59     event is received, or when the CallbackCaller detects at its
  60     construction that the event will not be sent in the near future, the
  61     actual callback object is called and the CallbackCaller destroys itself.
  62 */
  63 class CallbackCaller
  64     : public ::sd::MutexOwner,
  65       public CallbackCallerInterfaceBase
  66 {
  67 public:
  68     /** Create a new CallbackCaller object.  This object controls its own
  69         lifetime by acquiring a reference to itself in the constructor.
  70         When it detects that the event will not be notified in the near
  71         future (because the queue of pending configuration change operations
  72         is empty and therefore no event will be sent int the near future, it
  73         does not acquires a reference and thus initiates its destruction in
  74         the constructor.)
  75         @param rBase
  76             This ViewShellBase object is used to determine the
  77             XConfigurationController at which to register.
  78         @param rsEventType
  79             The event type which the callback is waiting for.
  80         @param pCallback
  81             The callback object which is to be notified.  The caller will
  82             typically release his reference to the caller so that when the
  83             CallbackCaller dies (after having called the callback) the
  84             callback is destroyed.
  85     */
  86     CallbackCaller (
  87         const ::sd::ViewShellBase& rBase,
  88         const OUString& rsEventType,
  89         const ::sd::framework::FrameworkHelper::ConfigurationChangeEventFilter& rFilter,
  90         const ::sd::framework::FrameworkHelper::Callback& rCallback);
  91
  92     virtual void SAL_CALL disposing() override;
  93     // XEventListener
  94     virtual void SAL_CALL disposing (const lang::EventObject& rEvent) override;
  95     // XConfigurationChangeListener
  96     virtual void SAL_CALL notifyConfigurationChange (const ConfigurationChangeEvent& rEvent) override;
  97
  98 private:
  99     OUString const msEventType;
 100     Reference<XConfigurationController> mxConfigurationController;
 101     ::sd::framework::FrameworkHelper::ConfigurationChangeEventFilter const maFilter;
 102     ::sd::framework::FrameworkHelper::Callback const maCallback;
 103 };
 104
 105 //----- LifetimeController ----------------------------------------------------
 106
 107 typedef ::cppu::WeakComponentImplHelper <
 108     css::lang::XEventListener
 109     > LifetimeControllerInterfaceBase;
 110
 111 /** This class helps controlling the lifetime of the
 112     FrameworkHelper. Register at a ViewShellBase object and an XController
 113     object and call Dispose() at the associated FrameworkHelper object when
 114     one of them and Release() when both of them are destroyed.
 115 */
 116 class LifetimeController
 117     : public ::sd::MutexOwner,
 118       public LifetimeControllerInterfaceBase,
 119       public SfxListener
 120 {
 121 public:
 122     explicit LifetimeController (::sd::ViewShellBase& rBase);
 123     virtual ~LifetimeController() override;
 124
 125     virtual void SAL_CALL disposing() override;
 126
 127     /** XEventListener.  This method is called when the frame::XController
 128         is being destroyed.
 129     */
 130     virtual void SAL_CALL disposing (const lang::EventObject& rEvent) override;
 131
 132     /** This method is called when the ViewShellBase is being destroyed.
 133     */
 134     virtual void Notify (SfxBroadcaster& rBroadcaster, const SfxHint& rHint) override;
 135
 136 private:
 137     ::sd::ViewShellBase& mrBase;
 138     bool mbListeningToViewShellBase;
 139     bool mbListeningToController;
 140
 141     /** When one or both of the mbListeningToViewShellBase and
 142         mbListeningToController members were modified then call this method
 143         to either dispose or release the associated FrameworkHelper.
 144     */
 145     void Update();
 146 };
 147
 148 } // end of anonymous namespace
 149
 150 namespace sd { namespace framework {
 151
 152 namespace {
 153
 154     class FrameworkHelperAllPassFilter
 155     {
 156     public:
 157         bool operator() (const css::drawing::framework::ConfigurationChangeEvent&) { return true; }
 158     };
 159
 160     class FrameworkHelperResourceIdFilter
 161     {
 162     public:
 163         explicit FrameworkHelperResourceIdFilter (
 164             const css::uno::Reference<css::drawing::framework::XResourceId>& rxResourceId);
 165         bool operator() (const css::drawing::framework::ConfigurationChangeEvent& rEvent)
 166         { return mxResourceId.is() && rEvent.ResourceId.is()
 167                 && mxResourceId->compareTo(rEvent.ResourceId) == 0; }
 168     private:
 169         css::uno::Reference<css::drawing::framework::XResourceId> mxResourceId;
 170     };
 171
 172 } // end of anonymous namespace
 173
 174 // Pane URLS.
 175
 176 const OUString FrameworkHelper::msPaneURLPrefix("private:resource/pane/");
 177 const OUString FrameworkHelper::msCenterPaneURL( msPaneURLPrefix + "CenterPane");
 178 const OUString FrameworkHelper::msFullScreenPaneURL( msPaneURLPrefix + "FullScreenPane");
 179 const OUString FrameworkHelper::msLeftImpressPaneURL( msPaneURLPrefix + "LeftImpressPane");
 180 const OUString FrameworkHelper::msLeftDrawPaneURL( msPaneURLPrefix + "LeftDrawPane");
 181 const OUString FrameworkHelper::msSidebarPaneURL( msPaneURLPrefix + "SidebarPane");
 182
 183 // View URLs.
 184
 185 const OUString FrameworkHelper::msViewURLPrefix("private:resource/view/");
 186 const OUString FrameworkHelper::msImpressViewURL( msViewURLPrefix + "ImpressView");
 187 const OUString FrameworkHelper::msDrawViewURL( msViewURLPrefix + "GraphicView");
 188 const OUString FrameworkHelper::msOutlineViewURL( msViewURLPrefix + "OutlineView");
 189 const OUString FrameworkHelper::msNotesViewURL( msViewURLPrefix + "NotesView");
 190 const OUString FrameworkHelper::msHandoutViewURL( msViewURLPrefix + "HandoutView");
 191 const OUString FrameworkHelper::msSlideSorterURL( msViewURLPrefix + "SlideSorter");
 192 const OUString FrameworkHelper::msPresentationViewURL( msViewURLPrefix + "PresentationView");
 193 const OUString FrameworkHelper::msSidebarViewURL( msViewURLPrefix + "SidebarView");
 194
 195 // Tool bar URLs.
 196
 197 const OUString FrameworkHelper::msToolBarURLPrefix("private:resource/toolbar/");
 198 const OUString FrameworkHelper::msViewTabBarURL( msToolBarURLPrefix + "ViewTabBar");
 199
 200 // Task panel URLs.
 201 const OUString FrameworkHelper::msTaskPanelURLPrefix( "private:resource/toolpanel/" );
 202 const OUString FrameworkHelper::msAllMasterPagesTaskPanelURL( msTaskPanelURLPrefix + "AllMasterPages" );
 203 const OUString FrameworkHelper::msRecentMasterPagesTaskPanelURL( msTaskPanelURLPrefix + "RecentMasterPages" );
 204 const OUString FrameworkHelper::msUsedMasterPagesTaskPanelURL( msTaskPanelURLPrefix + "UsedMasterPages" );
 205 const OUString FrameworkHelper::msLayoutTaskPanelURL( msTaskPanelURLPrefix + "Layouts" );
 206 const OUString FrameworkHelper::msTableDesignPanelURL( msTaskPanelURLPrefix + "TableDesign" );
 207 const OUString FrameworkHelper::msCustomAnimationTaskPanelURL( msTaskPanelURLPrefix + "CustomAnimations" );
 208 const OUString FrameworkHelper::msSlideTransitionTaskPanelURL( msTaskPanelURLPrefix + "SlideTransitions" );
 209
 210 // Event URLs.
 211 const OUString FrameworkHelper::msResourceActivationRequestEvent( "ResourceActivationRequested" );
 212 const OUString FrameworkHelper::msResourceDeactivationRequestEvent( "ResourceDeactivationRequest" );
 213 const OUString FrameworkHelper::msResourceActivationEvent( "ResourceActivation" );
 214 const OUString FrameworkHelper::msResourceDeactivationEvent( "ResourceDeactivation" );
 215 const OUString FrameworkHelper::msResourceDeactivationEndEvent( "ResourceDeactivationEnd" );
 216 const OUString FrameworkHelper::msConfigurationUpdateStartEvent( "ConfigurationUpdateStart" );
 217 const OUString FrameworkHelper::msConfigurationUpdateEndEvent( "ConfigurationUpdateEnd" );
 218
 219 // Service names of controllers.
 220 const OUString FrameworkHelper::msModuleControllerService("com.sun.star.drawing.framework.ModuleController");
 221 const OUString FrameworkHelper::msConfigurationControllerService("com.sun.star.drawing.framework.ConfigurationController");
 222
 223 //----- helper ----------------------------------------------------------------
 224 namespace
 225 {
 226     ::std::shared_ptr< ViewShell > lcl_getViewShell( const Reference< XResource >& i_rViewShellWrapper )
 227     {
 228         ::std::shared_ptr< ViewShell > pViewShell;
 229         if ( !i_rViewShellWrapper.is() )
 230             return pViewShell;
 231
 232         try
 233         {
 234             Reference<lang::XUnoTunnel> xViewTunnel( i_rViewShellWrapper, UNO_QUERY_THROW );
 235             pViewShell = reinterpret_cast< ViewShellWrapper* >(
 236                 xViewTunnel->getSomething( ViewShellWrapper::getUnoTunnelId() ) )->GetViewShell();
 237         }
 238         catch( const Exception& )
 239         {
 240             DBG_UNHANDLED_EXCEPTION("sd");
 241         }
 242         return pViewShell;
 243     }
 244     Reference< XResource > lcl_getFirstViewInPane( const Reference< XConfigurationController >& i_rConfigController,
 245         const Reference< XResourceId >& i_rPaneId )
 246     {
 247         try
 248         {
 249             Reference< XConfiguration > xConfiguration( i_rConfigController->getRequestedConfiguration(), UNO_SET_THROW );
 250             Sequence< Reference< XResourceId > > aViewIds( xConfiguration->getResources(
 251                 i_rPaneId, FrameworkHelper::msViewURLPrefix, AnchorBindingMode_DIRECT ) );
 252             if ( aViewIds.hasElements() )
 253                 return i_rConfigController->getResource( aViewIds[0] );
 254         }
 255         catch( const Exception& )
 256         {
 257             DBG_UNHANDLED_EXCEPTION("sd");
 258         }
 259         return nullptr;
 260     }
 261 }
 262
 263 //----- FrameworkHelper::ViewURLMap -------------------------------------------
 264
 265 /** The ViewURLMap is used to translate between the view URLs used by the
 266     drawing framework and the enums defined in the ViewShell class.
 267 */
 268 class FrameworkHelper::ViewURLMap
 269     : public std::unordered_map<
 270           OUString,
 271           ViewShell::ShellType>
 272 {
 273 public:
 274     ViewURLMap() {}
 275 };
 276
 277 //----- Framework::DiposeListener ---------------------------------------------
 278
 279 namespace {
 280     typedef ::cppu::WeakComponentImplHelper <
 281         css::lang::XEventListener
 282         > FrameworkHelperDisposeListenerInterfaceBase;
 283 }
 284
 285 class FrameworkHelper::DisposeListener
 286     : public ::sd::MutexOwner,
 287       public FrameworkHelperDisposeListenerInterfaceBase
 288 {
 289 public:
 290     explicit DisposeListener (const ::std::shared_ptr<FrameworkHelper>& rpHelper);
 291
 292     virtual void SAL_CALL disposing() override;
 293
 294     virtual void SAL_CALL disposing (const lang::EventObject& rEventObject) override;
 295
 296 private:
 297     ::std::shared_ptr<FrameworkHelper> mpHelper;
 298 };
 299
 300 //----- FrameworkHelper::Deleter ----------------------------------------------
 301
 302 class FrameworkHelper::Deleter
 303 {
 304 public:
 305     void operator()(FrameworkHelper* pObject)
 306     {
 307         delete pObject;
 308     }
 309 };
 310
 311 //----- FrameworkHelper -------------------------------------------------------
 312
 313 std::unique_ptr<FrameworkHelper::ViewURLMap> FrameworkHelper::mpViewURLMap(new ViewURLMap());
 314
 315 FrameworkHelper::InstanceMap FrameworkHelper::maInstanceMap;
 316
 317 ::std::shared_ptr<FrameworkHelper> FrameworkHelper::Instance (ViewShellBase& rBase)
 318 {
 319
 320     ::std::shared_ptr<FrameworkHelper> pHelper;
 321
 322     InstanceMap::const_iterator iHelper (maInstanceMap.find(&rBase));
 323     if (iHelper == maInstanceMap.end())
 324     {
 325         ::osl::GetGlobalMutex aMutexFunctor;
 326         ::osl::MutexGuard aGuard (aMutexFunctor());
 327         if (iHelper == maInstanceMap.end())
 328         {
 329             pHelper = ::std::shared_ptr<FrameworkHelper>(
 330                 new FrameworkHelper(rBase),
 331                 FrameworkHelper::Deleter());
 332             pHelper->Initialize();
 333             OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
 334             maInstanceMap[&rBase] = pHelper;
 335         }
 336     }
 337     else
 338     {
 339         OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
 340         pHelper = iHelper->second;
 341     }
 342
 343     return pHelper;
 344 }
 345
 346 void FrameworkHelper::DisposeInstance (const ViewShellBase& rBase)
 347 {
 348     InstanceMap::iterator iHelper (maInstanceMap.find(&rBase));
 349     if (iHelper != maInstanceMap.end())
 350     {
 351         iHelper->second->Dispose();
 352     }
 353 }
 354
 355 void FrameworkHelper::ReleaseInstance (const ViewShellBase& rBase)
 356 {
 357     InstanceMap::iterator iHelper (maInstanceMap.find(&rBase));
 358     if (iHelper != maInstanceMap.end())
 359         maInstanceMap.erase(iHelper);
 360 }
 361
 362 FrameworkHelper::FrameworkHelper (ViewShellBase& rBase)
 363     : mrBase(rBase),
 364       mxConfigurationController(),
 365       mxDisposeListener()
 366
 367 {
 368     Reference<XControllerManager> xControllerManager (rBase.GetController(), UNO_QUERY);
 369     if (xControllerManager.is())
 370     {
 371         mxConfigurationController = xControllerManager->getConfigurationController();
 372     }
 373
 374     new LifetimeController(mrBase);
 375 }
 376
 377 void FrameworkHelper::Initialize()
 378 {
 379     mxDisposeListener = new DisposeListener(shared_from_this());
 380 }
 381
 382 FrameworkHelper::~FrameworkHelper()
 383 {
 384 }
 385
 386 void FrameworkHelper::Dispose()
 387 {
 388     if (mxDisposeListener.is())
 389         mxDisposeListener->dispose();
 390     mxConfigurationController = nullptr;
 391 }
 392
 393 bool FrameworkHelper::IsValid()
 394 {
 395     return mxConfigurationController.is();
 396 }
 397
 398 ::std::shared_ptr<ViewShell> FrameworkHelper::GetViewShell (const OUString& rsPaneURL)
 399 {
 400     if ( !mxConfigurationController.is() )
 401         return ::std::shared_ptr<ViewShell>();
 402
 403     Reference<XResourceId> xPaneId( CreateResourceId( rsPaneURL ) );
 404     return lcl_getViewShell( lcl_getFirstViewInPane( mxConfigurationController, xPaneId ) );
 405 }
 406
 407 ::std::shared_ptr<ViewShell> FrameworkHelper::GetViewShell (const Reference<XView>& rxView)
 408 {
 409     return lcl_getViewShell( rxView.get() );
 410 }
 411
 412 Reference<XView> FrameworkHelper::GetView (const Reference<XResourceId>& rxPaneOrViewId)
 413 {
 414     Reference<XView> xView;
 415
 416     if ( ! rxPaneOrViewId.is() || ! mxConfigurationController.is())
 417         return nullptr;
 418
 419     try
 420     {
 421         if (rxPaneOrViewId->getResourceURL().match(msViewURLPrefix))
 422         {
 423             xView.set( mxConfigurationController->getResource( rxPaneOrViewId ), UNO_QUERY );
 424         }
 425         else
 426         {
 427             xView.set( lcl_getFirstViewInPane( mxConfigurationController, rxPaneOrViewId ), UNO_QUERY );
 428         }
 429     }
 430     catch (lang::DisposedException&)
 431     {
 432         Dispose();
 433     }
 434     catch (RuntimeException&)
 435     {
 436     }
 437
 438     return xView;
 439 }
 440
 441 Reference<XResourceId> FrameworkHelper::RequestView (
 442     const OUString& rsResourceURL,
 443     const OUString& rsAnchorURL)
 444 {
 445     Reference<XResourceId> xViewId;
 446
 447     try
 448     {
 449         if (mxConfigurationController.is())
 450         {
 451             mxConfigurationController->requestResourceActivation(
 452                 CreateResourceId(rsAnchorURL),
 453                 ResourceActivationMode_ADD);
 454             xViewId = CreateResourceId(rsResourceURL, rsAnchorURL);
 455             mxConfigurationController->requestResourceActivation(
 456                 xViewId,
 457                 ResourceActivationMode_REPLACE);
 458         }
 459     }
 460     catch (lang::DisposedException&)
 461     {
 462         Dispose();
 463         xViewId = nullptr;
 464     }
 465     catch (RuntimeException&)
 466     {
 467         xViewId = nullptr;
 468     }
 469
 470     return xViewId;
 471 }
 472
 473 ViewShell::ShellType FrameworkHelper::GetViewId (const OUString& rsViewURL)
 474 {
 475     if (mpViewURLMap->empty())
 476     {
 477         (*mpViewURLMap)[msImpressViewURL] = ViewShell::ST_IMPRESS;
 478         (*mpViewURLMap)[msDrawViewURL] = ViewShell::ST_DRAW;
 479         (*mpViewURLMap)[msOutlineViewURL] = ViewShell::ST_OUTLINE;
 480         (*mpViewURLMap)[msNotesViewURL] = ViewShell::ST_NOTES;
 481         (*mpViewURLMap)[msHandoutViewURL] = ViewShell::ST_HANDOUT;
 482         (*mpViewURLMap)[msSlideSorterURL] = ViewShell::ST_SLIDE_SORTER;
 483         (*mpViewURLMap)[msPresentationViewURL] = ViewShell::ST_PRESENTATION;
 484         (*mpViewURLMap)[msSidebarViewURL] = ViewShell::ST_SIDEBAR;
 485     }
 486     ViewURLMap::const_iterator iView (mpViewURLMap->find(rsViewURL));
 487     if (iView != mpViewURLMap->end())
 488         return iView->second;
 489     else
 490         return ViewShell::ST_NONE;
 491 }
 492
 493 OUString FrameworkHelper::GetViewURL (ViewShell::ShellType eType)
 494 {
 495     switch (eType)
 496     {
 497         case ViewShell::ST_IMPRESS : return msImpressViewURL;
 498         case ViewShell::ST_DRAW : return msDrawViewURL;
 499         case ViewShell::ST_OUTLINE : return msOutlineViewURL;
 500         case ViewShell::ST_NOTES : return msNotesViewURL;
 501         case ViewShell::ST_HANDOUT : return msHandoutViewURL;
 502         case ViewShell::ST_SLIDE_SORTER : return msSlideSorterURL;
 503         case ViewShell::ST_PRESENTATION : return msPresentationViewURL;
 504         case ViewShell::ST_SIDEBAR : return msSidebarViewURL;
 505         default:
 506             return OUString();
 507     }
 508 }
 509
 510 namespace
 511 {
 512
 513 void updateEditMode(const Reference<XView> &xView, const EditMode eEMode, bool updateFrameView)
 514 {
 515     // Ensure we have the expected edit mode
 516     // The check is only for DrawViewShell as OutlineViewShell
 517     // and SlideSorterViewShell have no master mode
 518     const ::std::shared_ptr<ViewShell> pCenterViewShell (FrameworkHelper::GetViewShell(xView));
 519     DrawViewShell* pDrawViewShell
 520         = dynamic_cast<DrawViewShell*>(pCenterViewShell.get());
 521     if (pDrawViewShell != nullptr)
 522     {
 523         pCenterViewShell->Broadcast (
 524             ViewShellHint(ViewShellHint::HINT_CHANGE_EDIT_MODE_START));
 525
 526         pDrawViewShell->ChangeEditMode(eEMode, pDrawViewShell->IsLayerModeActive());
 527         if (updateFrameView)
 528             pDrawViewShell->WriteFrameViewData();
 529
 530         pCenterViewShell->Broadcast (
 531             ViewShellHint(ViewShellHint::HINT_CHANGE_EDIT_MODE_END));
 532     }
 533 }
 534
 535 void asyncUpdateEditMode(FrameworkHelper* const pHelper, const EditMode eEMode)
 536 {
 537     Reference<XResourceId> xPaneId (
 538         FrameworkHelper::CreateResourceId(framework::FrameworkHelper::msCenterPaneURL));
 539     Reference<XView> xView (pHelper->GetView(xPaneId));
 540     updateEditMode(xView, eEMode, true);
 541 }
 542
 543 }
 544
 545 void FrameworkHelper::HandleModeChangeSlot (
 546     sal_uLong nSlotId,
 547     SfxRequest const & rRequest)
 548 {
 549     if ( ! mxConfigurationController.is())
 550         return;
 551
 552     // Parameters are allowed for NotesMasterPage and SlideMasterPage
 553     // for these command, transfor xxxxMasterPage with param = false
 554     // to ActivatexxxxxMode
 555     if (nSlotId == SID_NOTES_MASTER_MODE || nSlotId == SID_SLIDE_MASTER_MODE)
 556     {
 557         const SfxItemSet* pRequestArguments = rRequest.GetArgs();
 558         if (pRequestArguments)
 559         {
 560             const SfxBoolItem* pIsActive = rRequest.GetArg<SfxBoolItem>(static_cast<sal_uInt16>(nSlotId));
 561             if (!pIsActive->GetValue ())
 562             {
 563                 if (nSlotId == SID_NOTES_MASTER_MODE)
 564                     nSlotId = SID_NOTES_MODE;
 565                 else
 566                     nSlotId = SID_NORMAL_MULTI_PANE_GUI;
 567             }
 568         }
 569     }
 570
 571     try
 572     {
 573         if ( ! mxConfigurationController.is())
 574             throw RuntimeException();
 575
 576         Reference<XResourceId> xPaneId (
 577             CreateResourceId(framework::FrameworkHelper::msCenterPaneURL));
 578         Reference<XView> xView (GetView(xPaneId));
 579
 580         // Compute requested view
 581         OUString sRequestedView;
 582         switch (nSlotId)
 583         {
 584             // draw
 585             case SID_DRAWINGMODE:
 586             // impress
 587             case SID_NORMAL_MULTI_PANE_GUI:
 588             case SID_SLIDE_MASTER_MODE:
 589                 sRequestedView = FrameworkHelper::msImpressViewURL;
 590                 break;
 591
 592             case SID_NOTES_MODE:
 593             case SID_NOTES_MASTER_MODE:
 594                 sRequestedView = FrameworkHelper::msNotesViewURL;
 595             break;
 596
 597             case SID_HANDOUT_MASTER_MODE:
 598                 sRequestedView = FrameworkHelper::msHandoutViewURL;
 599                 break;
 600
 601             case SID_SLIDE_SORTER_MULTI_PANE_GUI:
 602             case SID_SLIDE_SORTER_MODE:
 603                 sRequestedView = FrameworkHelper::msSlideSorterURL;
 604                 break;
 605
 606             case SID_OUTLINE_MODE:
 607                 sRequestedView = FrameworkHelper::msOutlineViewURL;
 608                 break;
 609         }
 610
 611         // Compute requested mode
 612         EditMode eEMode = EditMode::Page;
 613         if (nSlotId == SID_SLIDE_MASTER_MODE
 614             || nSlotId == SID_NOTES_MASTER_MODE
 615             || nSlotId == SID_HANDOUT_MASTER_MODE)
 616             eEMode = EditMode::MasterPage;
 617         // Ensure we have the expected view shell
 618         if (!(xView.is() && xView->getResourceId()->getResourceURL() == sRequestedView))
 619
 620         {
 621             const auto xId = CreateResourceId(sRequestedView, msCenterPaneURL);
 622             mxConfigurationController->requestResourceActivation(
 623                 xId,
 624                 ResourceActivationMode_REPLACE);
 625             RunOnResourceActivation(xId, std::bind(&asyncUpdateEditMode, this, eEMode));
 626         }
 627         else
 628         {
 629             updateEditMode(xView, eEMode, false);
 630         }
 631     }
 632     catch (RuntimeException&)
 633     {
 634         DBG_UNHANDLED_EXCEPTION("sd");
 635     }
 636 }
 637
 638 void FrameworkHelper::RunOnConfigurationEvent(
 639     const OUString& rsEventType,
 640     const Callback& rCallback)
 641 {
 642     RunOnEvent(
 643         rsEventType,
 644         FrameworkHelperAllPassFilter(),
 645         rCallback);
 646 }
 647
 648 void FrameworkHelper::RunOnResourceActivation(
 649     const css::uno::Reference<css::drawing::framework::XResourceId>& rxResourceId,
 650     const Callback& rCallback)
 651 {
 652     if (mxConfigurationController.is()
 653         && mxConfigurationController->getResource(rxResourceId).is())
 654     {
 655         rCallback(false);
 656     }
 657     else
 658     {
 659         RunOnEvent(
 660             msResourceActivationEvent,
 661             FrameworkHelperResourceIdFilter(rxResourceId),
 662             rCallback);
 663     }
 664 }
 665
 666 /** A callback that sets a flag to a specified value when the callback is
 667     called.
 668 */
 669 class FlagUpdater
 670 {
 671 public:
 672     explicit FlagUpdater (bool& rFlag) : mrFlag(rFlag) {}
 673     void operator() (bool) const {mrFlag = true;}
 674 private:
 675     bool& mrFlag;
 676 };
 677
 678 void FrameworkHelper::RequestSynchronousUpdate()
 679 {
 680     rtl::Reference<ConfigurationController> pCC (
 681         dynamic_cast<ConfigurationController*>(mxConfigurationController.get()));
 682     if (pCC.is())
 683         pCC->RequestSynchronousUpdate();
 684 }
 685
 686 void FrameworkHelper::WaitForEvent (const OUString& rsEventType) const
 687 {
 688     bool bConfigurationUpdateSeen (false);
 689
 690     RunOnEvent(
 691         rsEventType,
 692         FrameworkHelperAllPassFilter(),
 693         FlagUpdater(bConfigurationUpdateSeen));
 694
 695     sal_uInt32 nStartTime = osl_getGlobalTimer();
 696     while ( ! bConfigurationUpdateSeen)
 697     {
 698         Application::Reschedule();
 699
 700         if( (osl_getGlobalTimer() - nStartTime) > 60000  )
 701         {
 702             OSL_FAIL("FrameworkHelper::WaitForEvent(), no event for a minute? giving up!");
 703             break;
 704         }
 705     }
 706 }
 707
 708 void FrameworkHelper::WaitForUpdate() const
 709 {
 710     WaitForEvent(msConfigurationUpdateEndEvent);
 711 }
 712
 713 void FrameworkHelper::RunOnEvent(
 714     const OUString& rsEventType,
 715     const ConfigurationChangeEventFilter& rFilter,
 716     const Callback& rCallback) const
 717 {
 718     new CallbackCaller(mrBase,rsEventType,rFilter,rCallback);
 719 }
 720
 721 void FrameworkHelper::disposing (const lang::EventObject& rEventObject)
 722 {
 723     if (rEventObject.Source == mxConfigurationController)
 724         mxConfigurationController = nullptr;
 725 }
 726
 727 void FrameworkHelper::UpdateConfiguration()
 728 {
 729     if (!mxConfigurationController.is())
 730         return;
 731
 732     try
 733     {
 734         if (mxConfigurationController.is())
 735             mxConfigurationController->update();
 736     }
 737     catch (lang::DisposedException&)
 738     {
 739         Dispose();
 740     }
 741     catch (RuntimeException&)
 742     {
 743         DBG_UNHANDLED_EXCEPTION("sd");
 744     }
 745 }
 746
 747 OUString FrameworkHelper::ResourceIdToString (const Reference<XResourceId>& rxResourceId)
 748 {
 749     OUStringBuffer sString;
 750     if (rxResourceId.is())
 751     {
 752         sString.append(rxResourceId->getResourceURL());
 753         if (rxResourceId->hasAnchor())
 754         {
 755             const Sequence<OUString> aAnchorURLs (rxResourceId->getAnchorURLs());
 756             for (const auto& rAnchorURL : aAnchorURLs)
 757             {
 758                 sString.append(" | ");
 759                 sString.append(rAnchorURL);
 760             }
 761         }
 762     }
 763     return sString.makeStringAndClear();
 764 }
 765
 766 Reference<XResourceId> FrameworkHelper::CreateResourceId (const OUString& rsResourceURL)
 767 {
 768     return new ::sd::framework::ResourceId(rsResourceURL);
 769 }
 770
 771 Reference<XResourceId> FrameworkHelper::CreateResourceId (
 772     const OUString& rsResourceURL,
 773     const OUString& rsAnchorURL)
 774 {
 775     return new ::sd::framework::ResourceId(rsResourceURL, rsAnchorURL);
 776 }
 777
 778 Reference<XResourceId> FrameworkHelper::CreateResourceId (
 779     const OUString& rsResourceURL,
 780     const Reference<XResourceId>& rxAnchorId)
 781 {
 782     if (rxAnchorId.is())
 783         return new ::sd::framework::ResourceId(
 784             rsResourceURL,
 785             rxAnchorId->getResourceURL(),
 786             rxAnchorId->getAnchorURLs());
 787     else
 788         return new ::sd::framework::ResourceId(rsResourceURL);
 789 }
 790
 791 //----- FrameworkHelper::DisposeListener --------------------------------------
 792
 793 FrameworkHelper::DisposeListener::DisposeListener (
 794     const ::std::shared_ptr<FrameworkHelper>& rpHelper)
 795     : FrameworkHelperDisposeListenerInterfaceBase(maMutex),
 796       mpHelper(rpHelper)
 797 {
 798     Reference<XComponent> xComponent (mpHelper->mxConfigurationController, UNO_QUERY);
 799     if (xComponent.is())
 800         xComponent->addEventListener(this);
 801 }
 802
 803 void SAL_CALL FrameworkHelper::DisposeListener::disposing()
 804 {
 805     Reference<XComponent> xComponent (mpHelper->mxConfigurationController, UNO_QUERY);
 806     if (xComponent.is())
 807         xComponent->removeEventListener(this);
 808
 809     mpHelper.reset();
 810 }
 811
 812 void SAL_CALL FrameworkHelper::DisposeListener::disposing (const lang::EventObject& rEventObject)
 813 {
 814     if (mpHelper != nullptr)
 815         mpHelper->disposing(rEventObject);
 816 }
 817
 818 //===== FrameworkHelperResourceIdFilter =======================================
 819
 820 FrameworkHelperResourceIdFilter::FrameworkHelperResourceIdFilter (
 821     const Reference<XResourceId>& rxResourceId)
 822     : mxResourceId(rxResourceId)
 823 {
 824 }
 825
 826 } } // end of namespace sd::framework
 827
 828 namespace {
 829
 830 //===== CallbackCaller ========================================================
 831
 832 CallbackCaller::CallbackCaller (
 833     const ::sd::ViewShellBase& rBase,
 834     const OUString& rsEventType,
 835     const ::sd::framework::FrameworkHelper::ConfigurationChangeEventFilter& rFilter,
 836     const ::sd::framework::FrameworkHelper::Callback& rCallback)
 837     : CallbackCallerInterfaceBase(MutexOwner::maMutex),
 838       msEventType(rsEventType),
 839       mxConfigurationController(),
 840       maFilter(rFilter),
 841       maCallback(rCallback)
 842 {
 843     try
 844     {
 845         Reference<XControllerManager> xControllerManager (rBase.GetController(), UNO_QUERY_THROW);
 846         mxConfigurationController = xControllerManager->getConfigurationController();
 847         if (mxConfigurationController.is())
 848         {
 849             if (mxConfigurationController->hasPendingRequests())
 850                 mxConfigurationController->addConfigurationChangeListener(this,msEventType,Any());
 851             else
 852             {
 853                 // There are no requests waiting to be processed.  Therefore
 854                 // no event, especially not the one we are waiting for, will
 855                 // be sent in the near future and the callback would never be
 856                 // called.
 857                 // Call the callback now and tell him that the event it is
 858                 // waiting for was not sent.
 859                 mxConfigurationController = nullptr;
 860                 maCallback(false);
 861             }
 862         }
 863     }
 864     catch (RuntimeException&)
 865     {
 866         DBG_UNHANDLED_EXCEPTION("sd");
 867     }
 868 }
 869
 870 void CallbackCaller::disposing()
 871 {
 872     try
 873     {
 874         if (mxConfigurationController.is())
 875         {
 876             Reference<XConfigurationController> xCC (mxConfigurationController);
 877             mxConfigurationController = nullptr;
 878             xCC->removeConfigurationChangeListener(this);
 879         }
 880     }
 881     catch (RuntimeException&)
 882     {
 883         DBG_UNHANDLED_EXCEPTION("sd");
 884     }
 885 }
 886
 887 void SAL_CALL CallbackCaller::disposing (const lang::EventObject& rEvent)
 888 {
 889     if (rEvent.Source == mxConfigurationController)
 890     {
 891         mxConfigurationController = nullptr;
 892         maCallback(false);
 893     }
 894 }
 895
 896 void SAL_CALL CallbackCaller::notifyConfigurationChange (
 897     const ConfigurationChangeEvent& rEvent)
 898 {
 899     if (!(rEvent.Type == msEventType && maFilter(rEvent)))
 900         return;
 901
 902     maCallback(true);
 903     if (mxConfigurationController.is())
 904     {
 905         // Reset the reference to the configuration controller so that
 906         // dispose() will not try to remove the listener a second time.
 907         Reference<XConfigurationController> xCC (mxConfigurationController);
 908         mxConfigurationController = nullptr;
 909
 910         // Removing this object from the controller may very likely lead
 911         // to its destruction, so no calls after that.
 912         xCC->removeConfigurationChangeListener(this);
 913     }
 914 }
 915
 916 //----- LifetimeController -------------------------------------------------
 917
 918 LifetimeController::LifetimeController (::sd::ViewShellBase& rBase)
 919     : LifetimeControllerInterfaceBase(maMutex),
 920       mrBase(rBase),
 921       mbListeningToViewShellBase(false),
 922       mbListeningToController(false)
 923 {
 924     // Register as listener at the ViewShellBase.  Because that is not done
 925     // via a reference we have to increase the reference count manually.
 926     // This is necessary even though listening to the XController did
 927     // increase the reference count because the controller may release its
 928     // reference to us before the ViewShellBase is destroyed.
 929     StartListening(mrBase);
 930     acquire();
 931     mbListeningToViewShellBase = true;
 932
 933     Reference<XComponent> xComponent = rBase.GetController();
 934     if (xComponent.is())
 935     {
 936         xComponent->addEventListener(this);
 937         mbListeningToController = true;
 938     }
 939 }
 940
 941 LifetimeController::~LifetimeController()
 942 {
 943     OSL_ASSERT(!mbListeningToController && !mbListeningToViewShellBase);
 944 }
 945
 946 void LifetimeController::disposing()
 947 {
 948 }
 949
 950 void SAL_CALL LifetimeController::disposing (const lang::EventObject&)
 951 {
 952     mbListeningToController = false;
 953     Update();
 954 }
 955
 956 void LifetimeController::Notify (SfxBroadcaster&, const SfxHint& rHint)
 957 {
 958     if (rHint.GetId() == SfxHintId::Dying)
 959     {
 960         mbListeningToViewShellBase = false;
 961         Update();
 962         release();
 963     }
 964 }
 965
 966 void LifetimeController::Update()
 967 {
 968     if (mbListeningToViewShellBase && mbListeningToController)
 969     {
 970         // Both the controller and the ViewShellBase are alive.  Keep
 971         // waiting for their destruction.
 972     }
 973     else if (mbListeningToViewShellBase)
 974     {
 975         // The controller has been destroyed but the ViewShellBase is still
 976         // alive.  Dispose the associated FrameworkHelper but keep it around
 977         // so that no new instance is created for the dying framework.
 978         ::sd::framework::FrameworkHelper::DisposeInstance(mrBase);
 979     }
 980     else
 981     {
 982         // Both the controller and the ViewShellBase have been destroyed.
 983         // Remove the FrameworkHelper so that the next call its Instance()
 984         // method can create a new instance.
 985         ::sd::framework::FrameworkHelper::ReleaseInstance(mrBase);
 986     }
 987 }
 988
 989 } // end of anonymous namespace.
 990
 991 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */