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