sd/source/ui/view/ToolBarManager.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 <ToolBarManager.hxx>
  21
  22 #include <DrawViewShell.hxx>
  23 #include <EventMultiplexer.hxx>
  24 #include <ViewShellBase.hxx>
  25 #include <ViewShellManager.hxx>
  26 #include <com/sun/star/beans/XPropertySet.hpp>
  27 #include <com/sun/star/frame/XLayoutManager.hpp>
  28
  29 #include <sal/log.hxx>
  30 #include <osl/mutex.hxx>
  31 #include <o3tl/deleter.hxx>
  32 #include <o3tl/enumrange.hxx>
  33 #include <sfx2/docfile.hxx>
  34 #include <sfx2/objsh.hxx>
  35 #include <sfx2/toolbarids.hxx>
  36 #include <sfx2/viewfrm.hxx>
  37 #include <svl/eitem.hxx>
  38 #include <svx/svxids.hrc>
  39 #include <svx/extrusionbar.hxx>
  40 #include <svx/fontworkbar.hxx>
  41 #include <tools/debug.hxx>
  42 #include <tools/link.hxx>
  43 #include <vcl/svapp.hxx>
  44
  45 #include <map>
  46 #include <utility>
  47 #include <memory>
  48 #include <vector>
  49
  50 using namespace ::com::sun::star;
  51 using namespace ::com::sun::star::uno;
  52
  53 namespace {
  54
  55 using namespace sd;
  56
  57 class ToolBarRules;
  58
  59 /** Lock of the frame::XLayoutManager.
  60 */
  61 class LayouterLock
  62 {
  63     Reference<frame::XLayoutManager> mxLayouter;
  64 public:
  65     explicit LayouterLock (const Reference<frame::XLayoutManager>& rxLayouter);
  66     ~LayouterLock();
  67     bool is() const { return mxLayouter.is(); }
  68 };
  69
  70 /** Store a list of tool bars for each of the tool bar groups.  From
  71     this the list of requested tool bars is built.
  72 */
  73 class ToolBarList
  74 {
  75 public:
  76     ToolBarList();
  77
  78     void ClearGroup (sd::ToolBarManager::ToolBarGroup eGroup);
  79     void AddToolBar (sd::ToolBarManager::ToolBarGroup eGroup, const OUString& rsName);
  80     bool RemoveToolBar (sd::ToolBarManager::ToolBarGroup eGroup, const OUString& rsName);
  81
  82     void GetToolBarsToActivate (std::vector<OUString>& rToolBars) const;
  83     void GetToolBarsToDeactivate (std::vector<OUString>& rToolBars) const;
  84
  85     void MarkToolBarAsActive (const OUString& rsName);
  86     void MarkToolBarAsNotActive (const OUString& rsName);
  87     void MarkAllToolBarsAsNotActive();
  88
  89 private:
  90     typedef ::std::map<sd::ToolBarManager::ToolBarGroup, std::vector<OUString> > Groups;
  91     Groups maGroups;
  92     std::vector<OUString> maActiveToolBars;
  93
  94     void MakeRequestedToolBarList (std::vector<OUString>& rToolBars) const;
  95 };
  96
  97 /** Manage tool bars that are implemented as sub shells of a view shell.
  98     The typical procedure of updating the sub shells of a view shell is to
  99     rebuild a list of sub shells that the caller would like to have active.
 100     The methods ClearGroup() and AddShellId() allow the caller to do that.  A
 101     final call to UpdateShells() activates the requested shells that are not
 102     active and deactivates the active shells that are not requested .
 103
 104     This is done by maintaining two lists.  One (the current list)
 105     reflects the current state.  The other (the requested list) contains the
 106     currently requested shells.  UpdateShells() makes the requested
 107     list the current list and clears the current list.
 108
 109     Each shell belongs to one group.  Different groups can be modified
 110     separately.
 111 */
 112 class ToolBarShellList
 113 {
 114 public:
 115     /** Create a new object with an empty current list and an empty
 116         requested list.
 117     */
 118     ToolBarShellList();
 119
 120     /** Remove all shells from a group.  Calling this method should normally
 121         not be necessary because after the construction or after a call to
 122         UpdateShells() the requested list is empty.
 123         @param eGroup
 124             The group to clear. Shells in other groups are not modified.
 125     */
 126     void ClearGroup (sd::ToolBarManager::ToolBarGroup eGroup);
 127
 128     /** Add a shell. When the specified shell has already been requested
 129         for another group then it is moved to this group.
 130         @param eGroup
 131             The group to which to add the shell.
 132         @param nId
 133             The id of the shell to add.
 134     */
 135     void AddShellId (sd::ToolBarManager::ToolBarGroup eGroup, sd::ShellId nId);
 136
 137     /** Releasing all shells means that the given ToolBarRules object is
 138         informed that every shell managed by the called ToolBarShellList is
 139         about to be removed and that the associated framework tool bars can
 140         be removed as well.  The caller still has to call UpdateShells().
 141     */
 142     void ReleaseAllShells (ToolBarRules& rRules);
 143
 144     /** The requested list is made the current list by activating  all
 145         shells in the requested list and by deactivating the shells in the
 146         current list that are not in the requested list.
 147         @param pMainViewShell
 148             The shells that are activated or deactivated are sub shells of
 149             this view shell.
 150         @param rManager
 151             This ViewShellManager is used to activate or deactivate shells.
 152     */
 153     void UpdateShells (
 154         const std::shared_ptr<ViewShell>& rpMainViewShell,
 155         const std::shared_ptr<ViewShellManager>& rpManager);
 156
 157 private:
 158     class ShellDescriptor
 159     {public:
 160         ShellDescriptor (ShellId nId,sd::ToolBarManager::ToolBarGroup eGroup);
 161         ShellId mnId;
 162         sd::ToolBarManager::ToolBarGroup meGroup;
 163         friend bool operator<(const ShellDescriptor& r1, const ShellDescriptor& r2)
 164         { return r1.mnId < r2.mnId; }
 165     };
 166
 167     /** The requested list of tool bar shells that will be active after the
 168         next call to UpdateShells().
 169     */
 170     typedef ::std::set<ShellDescriptor> GroupedShellList;
 171     GroupedShellList maNewList;
 172
 173     /** The list of tool bar shells that are currently on the shell stack.
 174         Using a GroupedShellList is not strictly necessary but it makes
 175         things easier and does not waste too much memory.
 176     */
 177     GroupedShellList maCurrentList;
 178 };
 179
 180 /** This class concentrates the knowledge about when to show what tool bars
 181     in one place.
 182 */
 183 class ToolBarRules
 184 {
 185 public:
 186     ToolBarRules (
 187         const std::shared_ptr<ToolBarManager>& rpToolBarManager,
 188         const std::shared_ptr<ViewShellManager>& rpViewShellManager);
 189
 190     /** This method calls MainViewShellChanged() and SelectionHasChanged()
 191         for the current main view shell and its view.
 192     */
 193     void Update (ViewShellBase const & rBase);
 194
 195     /** Reset all tool bars in all groups and add tool bars and tool bar
 196         shells to the ToolBarGroup::Permanent group for the specified ViewShell type.
 197     */
 198     void MainViewShellChanged (ViewShell::ShellType nShellType);
 199
 200     /** Reset all tool bars in all groups and add tool bars and tool bar
 201         shells to the ToolBarGroup::Permanent group for the specified ViewShell.
 202     */
 203     void MainViewShellChanged (const ViewShell& rMainViewShell);
 204
 205     /** Reset all tool bars in the ToolBarGroup::Function group and add tool bars and tool bar
 206         shells to this group for the current selection.
 207     */
 208     void SelectionHasChanged (
 209         const ::sd::ViewShell& rViewShell,
 210         const SdrView& rView);
 211
 212     /** Add a tool bar for the specified tool bar shell.
 213     */
 214     void SubShellAdded (
 215         ::sd::ToolBarManager::ToolBarGroup eGroup,
 216         sd::ShellId nShellId);
 217
 218     /** Remove a tool bar for the specified tool bar shell.
 219     */
 220     void SubShellRemoved (
 221         ::sd::ToolBarManager::ToolBarGroup eGroup,
 222         sd::ShellId nShellId);
 223
 224 private:
 225     std::shared_ptr<ToolBarManager> mpToolBarManager;
 226     std::shared_ptr<ViewShellManager> mpViewShellManager;
 227 };
 228
 229 } // end of anonymous namespace
 230
 231 namespace sd {
 232
 233 //===== ToolBarManager::Implementation ========================================
 234
 235 class ToolBarManager::Implementation
 236 {
 237 public:
 238     /** This constructor takes three arguments even though the
 239         ToolBarManager could be taken from the ViewShellBase.  This is so to
 240         state explicitly which information has to be present when this
 241         constructor is called.  The ViewShellBase may not have been fully
 242         initialized at this point and must not be asked for this values.
 243     */
 244     Implementation (
 245         ViewShellBase& rBase,
 246         const std::shared_ptr<sd::tools::EventMultiplexer>& rpMultiplexer,
 247         const std::shared_ptr<ViewShellManager>& rpViewShellManager,
 248         const std::shared_ptr<ToolBarManager>& rpToolBarManager);
 249     ~Implementation();
 250
 251     void SetValid (bool bValid);
 252
 253     void ResetToolBars (ToolBarGroup eGroup);
 254     void ResetAllToolBars();
 255     void AddToolBar (ToolBarGroup eGroup, const OUString& rsToolBarName);
 256     void AddToolBarShell (ToolBarGroup eGroup, ShellId nToolBarId);
 257     void RemoveToolBar (ToolBarGroup eGroup, const OUString& rsToolBarName);
 258
 259     /** Release all tool bar shells and the associated framework tool bars.
 260         Typically called when the main view shell is being replaced by
 261         another, all tool bar shells are released.  In that process the
 262         shells are destroyed anyway and without calling this method they
 263         would still be referenced.
 264     */
 265     void ReleaseAllToolBarShells();
 266
 267     void ToolBarsDestroyed();
 268
 269     void RequestUpdate();
 270
 271     void PreUpdate();
 272     void PostUpdate();
 273     /** Tell the XLayoutManager about the tool bars that we would like to be
 274         shown.
 275         @param rpLayouterLock
 276             This typically is the mpSynchronousLayouterLock that is used in
 277             this method and that is either released at its end or assigned
 278             to mpAsynchronousLock in order to be unlocked later.
 279     */
 280     void Update (::std::unique_ptr<LayouterLock> pLayouterLock);
 281
 282     class UpdateLockImplementation
 283     {
 284     public:
 285         explicit UpdateLockImplementation (Implementation& rImplementation)
 286             : mrImplementation(rImplementation) { mrImplementation.LockUpdate();  }
 287         ~UpdateLockImplementation() { mrImplementation.UnlockUpdate(); }
 288     private:
 289         Implementation& mrImplementation;
 290     };
 291
 292     void LockViewShellManager();
 293     void LockUpdate();
 294     void UnlockUpdate();
 295
 296     ToolBarRules& GetToolBarRules() { return maToolBarRules;}
 297
 298 private:
 299     mutable ::osl::Mutex maMutex;
 300     ViewShellBase& mrBase;
 301     std::shared_ptr<sd::tools::EventMultiplexer> mpEventMultiplexer;
 302     bool mbIsValid;
 303     ToolBarList maToolBarList;
 304     ToolBarShellList maToolBarShellList;
 305     Reference<frame::XLayoutManager> mxLayouter;
 306     sal_Int32 mnLockCount;
 307     bool mbPreUpdatePending;
 308     bool mbPostUpdatePending;
 309     /** The layouter locks manage the locking of the XLayoutManager.  The
 310         lock() and unlock() functions are not called directly because the
 311         (final) unlocking  is usually done asynchronously *after* the
 312         list of requested toolbars is updated.
 313     */
 314     ::std::unique_ptr<LayouterLock> mpSynchronousLayouterLock;
 315     ::std::unique_ptr<LayouterLock> mpAsynchronousLayouterLock;
 316     ::std::unique_ptr<ViewShellManager::UpdateLock, o3tl::default_delete<ViewShellManager::UpdateLock>> mpViewShellManagerLock;
 317     ImplSVEvent * mnPendingUpdateCall;
 318     ImplSVEvent * mnPendingSetValidCall;
 319     ToolBarRules maToolBarRules;
 320
 321     static OUString GetToolBarResourceName (const OUString& rsBaseName);
 322     bool CheckPlugInMode (const OUString& rsName) const;
 323
 324     DECL_LINK(UpdateCallback, void *, void);
 325     DECL_LINK(EventMultiplexerCallback, sd::tools::EventMultiplexerEvent&, void);
 326     DECL_LINK(SetValidCallback, void*, void);
 327 };
 328
 329 //===== ToolBarManager ========================================================
 330
 331 std::shared_ptr<ToolBarManager> ToolBarManager::Create (
 332     ViewShellBase& rBase,
 333     const std::shared_ptr<sd::tools::EventMultiplexer>& rpMultiplexer,
 334     const std::shared_ptr<ViewShellManager>& rpViewShellManager)
 335 {
 336     std::shared_ptr<ToolBarManager> pManager (new ToolBarManager());
 337     pManager->mpImpl.reset(
 338         new Implementation(rBase,rpMultiplexer,rpViewShellManager,pManager));
 339     return pManager;
 340 }
 341
 342 ToolBarManager::ToolBarManager()
 343         : mpImpl()
 344 {
 345 }
 346
 347 ToolBarManager::~ToolBarManager()
 348 {
 349 }
 350
 351 void ToolBarManager::Shutdown()
 352 {
 353     if (mpImpl != nullptr)
 354         mpImpl.reset();
 355 }
 356
 357 void ToolBarManager::ResetToolBars (ToolBarGroup eGroup)
 358 {
 359     if (mpImpl != nullptr)
 360     {
 361         UpdateLock aLock (shared_from_this());
 362         mpImpl->ResetToolBars(eGroup);
 363     }
 364 }
 365
 366 void ToolBarManager::ResetAllToolBars()
 367 {
 368     if (mpImpl != nullptr)
 369     {
 370         UpdateLock aLock (shared_from_this());
 371         mpImpl->ResetAllToolBars();
 372     }
 373 }
 374
 375 void ToolBarManager::AddToolBar (
 376     ToolBarGroup eGroup,
 377     const OUString& rsToolBarName)
 378 {
 379     if (mpImpl != nullptr)
 380     {
 381         UpdateLock aLock (shared_from_this());
 382         mpImpl->AddToolBar(eGroup,rsToolBarName);
 383     }
 384 }
 385
 386 void ToolBarManager::AddToolBarShell (
 387     ToolBarGroup eGroup,
 388     ShellId nToolBarId)
 389 {
 390     if (mpImpl != nullptr)
 391     {
 392         UpdateLock aLock (shared_from_this());
 393         mpImpl->AddToolBarShell(eGroup,nToolBarId);
 394     }
 395 }
 396
 397 void ToolBarManager::RemoveToolBar (
 398     ToolBarGroup eGroup,
 399     const OUString& rsToolBarName)
 400 {
 401     if (mpImpl != nullptr)
 402     {
 403         UpdateLock aLock (shared_from_this());
 404         mpImpl->RemoveToolBar(eGroup,rsToolBarName);
 405     }
 406 }
 407
 408 void ToolBarManager::SetToolBar (
 409     ToolBarGroup eGroup,
 410     const OUString& rsToolBarName)
 411 {
 412     if (mpImpl != nullptr)
 413     {
 414         UpdateLock aLock (shared_from_this());
 415         mpImpl->ResetToolBars(eGroup);
 416         mpImpl->AddToolBar(eGroup,rsToolBarName);
 417     }
 418 }
 419
 420 void ToolBarManager::SetToolBarShell (
 421     ToolBarGroup eGroup,
 422     ShellId nToolBarId)
 423 {
 424     if (mpImpl != nullptr)
 425     {
 426         UpdateLock aLock (shared_from_this());
 427         mpImpl->ResetToolBars(eGroup);
 428         mpImpl->AddToolBarShell(eGroup,nToolBarId);
 429     }
 430 }
 431
 432 void ToolBarManager::PreUpdate()
 433 {
 434     if (mpImpl != nullptr)
 435         mpImpl->PreUpdate();
 436 }
 437
 438 void ToolBarManager::RequestUpdate()
 439 {
 440     if (mpImpl != nullptr)
 441         mpImpl->RequestUpdate();
 442 }
 443
 444 void ToolBarManager::LockViewShellManager()
 445 {
 446     if (mpImpl != nullptr)
 447         mpImpl->LockViewShellManager();
 448 }
 449
 450 void ToolBarManager::LockUpdate()
 451 {
 452     if (mpImpl != nullptr)
 453         mpImpl->LockUpdate();
 454 }
 455
 456 void ToolBarManager::UnlockUpdate()
 457 {
 458     if (mpImpl != nullptr)
 459         mpImpl->UnlockUpdate();
 460 }
 461
 462 void ToolBarManager::MainViewShellChanged ()
 463 {
 464     if (mpImpl != nullptr)
 465     {
 466         mpImpl->ReleaseAllToolBarShells();
 467         mpImpl->GetToolBarRules().MainViewShellChanged(ViewShell::ST_NONE);
 468     }
 469 }
 470
 471 void ToolBarManager::MainViewShellChanged (const ViewShell& rMainViewShell)
 472 {
 473     if (mpImpl != nullptr)
 474     {
 475         mpImpl->ReleaseAllToolBarShells();
 476         mpImpl->GetToolBarRules().MainViewShellChanged(rMainViewShell);
 477     }
 478 }
 479
 480 void ToolBarManager::SelectionHasChanged (
 481     const ViewShell& rViewShell,
 482     const SdrView& rView)
 483 {
 484     if (mpImpl != nullptr)
 485         mpImpl->GetToolBarRules().SelectionHasChanged(rViewShell,rView);
 486 }
 487
 488 void ToolBarManager::ToolBarsDestroyed()
 489 {
 490     if (mpImpl != nullptr)
 491         mpImpl->ToolBarsDestroyed();
 492 }
 493
 494 //===== ToolBarManager::Implementation =======================================
 495
 496 ToolBarManager::Implementation::Implementation (
 497     ViewShellBase& rBase,
 498     const std::shared_ptr<sd::tools::EventMultiplexer>& rpMultiplexer,
 499     const std::shared_ptr<ViewShellManager>& rpViewShellManager,
 500     const std::shared_ptr<ToolBarManager>& rpToolBarManager)
 501     : maMutex(),
 502       mrBase(rBase),
 503       mpEventMultiplexer(rpMultiplexer),
 504       mbIsValid(false),
 505       maToolBarList(),
 506       maToolBarShellList(),
 507       mnLockCount(0),
 508       mbPreUpdatePending(false),
 509       mbPostUpdatePending(false),
 510       mpSynchronousLayouterLock(),
 511       mpAsynchronousLayouterLock(),
 512       mpViewShellManagerLock(),
 513       mnPendingUpdateCall(nullptr),
 514       mnPendingSetValidCall(nullptr),
 515       maToolBarRules(rpToolBarManager,rpViewShellManager)
 516 {
 517     Link<tools::EventMultiplexerEvent&,void> aLink (LINK(this,ToolBarManager::Implementation,EventMultiplexerCallback));
 518     mpEventMultiplexer->AddEventListener( aLink );
 519 }
 520
 521 /** The order of statements is important.
 522     First unregister listeners, which may post user events.
 523     Then remove pending user events.
 524 */
 525 ToolBarManager::Implementation::~Implementation()
 526 {
 527     // Unregister at broadcasters.
 528     Link<tools::EventMultiplexerEvent&,void> aLink (LINK(this,ToolBarManager::Implementation,EventMultiplexerCallback));
 529     mpEventMultiplexer->RemoveEventListener(aLink);
 530
 531     // Abort pending user calls.
 532     if (mnPendingUpdateCall != nullptr)
 533         Application::RemoveUserEvent(mnPendingUpdateCall);
 534     if (mnPendingSetValidCall != nullptr)
 535         Application::RemoveUserEvent(mnPendingSetValidCall);
 536 }
 537
 538 void ToolBarManager::Implementation::ToolBarsDestroyed()
 539 {
 540     maToolBarList.MarkAllToolBarsAsNotActive();
 541 }
 542
 543 void ToolBarManager::Implementation::SetValid (bool bValid)
 544 {
 545     ::osl::MutexGuard aGuard(maMutex);
 546
 547     if (mbIsValid == bValid)
 548         return;
 549
 550     UpdateLockImplementation aUpdateLock (*this);
 551
 552     mbIsValid = bValid;
 553     if (mbIsValid)
 554     {
 555         Reference<frame::XFrame> xFrame;
 556         if (mrBase.GetViewFrame() != nullptr)
 557             xFrame = mrBase.GetViewFrame()->GetFrame().GetFrameInterface();
 558         try
 559         {
 560             Reference<beans::XPropertySet> xFrameProperties (xFrame, UNO_QUERY_THROW);
 561             Any aValue (xFrameProperties->getPropertyValue("LayoutManager"));
 562             aValue >>= mxLayouter;
 563             // tdf#119997 if mpSynchronousLayouterLock was created before mxLayouter was
 564             // set then update it now that its available
 565             if (mpSynchronousLayouterLock && !mpSynchronousLayouterLock->is())
 566                 mpSynchronousLayouterLock.reset(new LayouterLock(mxLayouter));
 567         }
 568         catch (const RuntimeException&)
 569         {
 570         }
 571
 572         GetToolBarRules().Update(mrBase);
 573     }
 574     else
 575     {
 576         ResetAllToolBars();
 577         mxLayouter = nullptr;
 578     }
 579 }
 580
 581 void ToolBarManager::Implementation::ResetToolBars (ToolBarGroup eGroup)
 582 {
 583     ::osl::MutexGuard aGuard(maMutex);
 584
 585     maToolBarList.ClearGroup(eGroup);
 586     maToolBarShellList.ClearGroup(eGroup);
 587
 588     mbPreUpdatePending = true;
 589 }
 590
 591 void ToolBarManager::Implementation::ResetAllToolBars()
 592 {
 593     SAL_INFO("sd.view", __func__ << ": resetting all tool bars");
 594     for (auto i : o3tl::enumrange<ToolBarGroup>())
 595         ResetToolBars(i);
 596 }
 597
 598 void ToolBarManager::Implementation::AddToolBar (
 599     ToolBarGroup eGroup,
 600     const OUString& rsToolBarName)
 601 {
 602     ::osl::MutexGuard aGuard(maMutex);
 603
 604     if (CheckPlugInMode(rsToolBarName))
 605     {
 606         maToolBarList.AddToolBar(eGroup,rsToolBarName);
 607
 608         mbPostUpdatePending = true;
 609         if (mnLockCount == 0)
 610             PostUpdate();
 611     }
 612 }
 613
 614 void ToolBarManager::Implementation::RemoveToolBar (
 615     ToolBarGroup eGroup,
 616     const OUString& rsToolBarName)
 617 {
 618     ::osl::MutexGuard aGuard(maMutex);
 619
 620     if (maToolBarList.RemoveToolBar(eGroup,rsToolBarName))
 621     {
 622         mbPreUpdatePending = true;
 623         if (mnLockCount == 0)
 624             PreUpdate();
 625     }
 626 }
 627
 628 void ToolBarManager::Implementation::AddToolBarShell (
 629     ToolBarGroup eGroup,
 630     ShellId nToolBarId)
 631 {
 632     ViewShell* pMainViewShell = mrBase.GetMainViewShell().get();
 633     if (pMainViewShell != nullptr)
 634     {
 635         maToolBarShellList.AddShellId(eGroup,nToolBarId);
 636         GetToolBarRules().SubShellAdded(eGroup, nToolBarId);
 637     }
 638 }
 639
 640 void ToolBarManager::Implementation::ReleaseAllToolBarShells()
 641 {
 642     maToolBarShellList.ReleaseAllShells(GetToolBarRules());
 643     maToolBarShellList.UpdateShells(mrBase.GetMainViewShell(), mrBase.GetViewShellManager());
 644 }
 645
 646 void ToolBarManager::Implementation::RequestUpdate()
 647 {
 648     if (mnPendingUpdateCall == nullptr)
 649     {
 650         mnPendingUpdateCall = Application::PostUserEvent(
 651             LINK(this,ToolBarManager::Implementation,UpdateCallback));
 652     }
 653 }
 654
 655 void ToolBarManager::Implementation::PreUpdate()
 656 {
 657     ::osl::MutexGuard aGuard(maMutex);
 658
 659     if (!(mbIsValid
 660         && mbPreUpdatePending
 661         && mxLayouter.is()))
 662         return;
 663
 664     mbPreUpdatePending = false;
 665
 666     SAL_INFO("sd.view", __func__ << ": ToolBarManager::PreUpdate [");
 667
 668     // Get the list of tool bars that are not used anymore and are to be
 669     // deactivated.
 670     std::vector<OUString> aToolBars;
 671     maToolBarList.GetToolBarsToDeactivate(aToolBars);
 672
 673     // Turn off the tool bars.
 674     for (const auto& aToolBar : aToolBars)
 675     {
 676         OUString sFullName (GetToolBarResourceName(aToolBar));
 677         SAL_INFO("sd.view", __func__ << ":    turning off tool bar " << sFullName);
 678         mxLayouter->destroyElement(sFullName);
 679         maToolBarList.MarkToolBarAsNotActive(aToolBar);
 680     }
 681
 682     SAL_INFO("sd.view", __func__ << ": ToolBarManager::PreUpdate ]");
 683 }
 684
 685 void ToolBarManager::Implementation::PostUpdate()
 686 {
 687     ::osl::MutexGuard aGuard(maMutex);
 688
 689     if (!(mbIsValid
 690         && mbPostUpdatePending
 691         && mxLayouter.is()))
 692         return;
 693
 694     mbPostUpdatePending = false;
 695
 696     // Create the list of requested tool bars.
 697     std::vector<OUString> aToolBars;
 698     maToolBarList.GetToolBarsToActivate(aToolBars);
 699
 700     SAL_INFO("sd.view", __func__ << ": ToolBarManager::PostUpdate [");
 701
 702     // Turn on the tool bars that are visible in the new context.
 703     for (const auto& aToolBar : aToolBars)
 704     {
 705         OUString sFullName (GetToolBarResourceName(aToolBar));
 706         SAL_INFO("sd.view", __func__ << ":    turning on tool bar " << sFullName);
 707         mxLayouter->requestElement(sFullName);
 708         maToolBarList.MarkToolBarAsActive(aToolBar);
 709     }
 710
 711     SAL_INFO("sd.view", __func__ << ": ToolBarManager::PostUpdate ]");
 712 }
 713
 714 void ToolBarManager::Implementation::LockViewShellManager()
 715 {
 716     if (mpViewShellManagerLock == nullptr)
 717         mpViewShellManagerLock.reset(
 718             new ViewShellManager::UpdateLock(mrBase.GetViewShellManager()));
 719 }
 720
 721 void ToolBarManager::Implementation::LockUpdate()
 722 {
 723     SAL_INFO("sd.view", __func__ << ": LockUpdate " << mnLockCount);
 724     ::osl::MutexGuard aGuard(maMutex);
 725
 726     DBG_ASSERT(mnLockCount<100, "ToolBarManager lock count unusually high");
 727     if (mnLockCount == 0)
 728     {
 729         OSL_ASSERT(mpSynchronousLayouterLock == nullptr);
 730
 731         mpSynchronousLayouterLock.reset(new LayouterLock(mxLayouter));
 732     }
 733     ++mnLockCount;
 734 }
 735
 736 void ToolBarManager::Implementation::UnlockUpdate()
 737 {
 738     SAL_INFO("sd.view", __func__ << ": UnlockUpdate " << mnLockCount);
 739     ::osl::MutexGuard aGuard(maMutex);
 740
 741     OSL_ASSERT(mnLockCount>0);
 742     --mnLockCount;
 743     if (mnLockCount == 0)
 744     {
 745         Update(std::move(mpSynchronousLayouterLock));
 746     }
 747 }
 748
 749 void ToolBarManager::Implementation::Update (
 750     ::std::unique_ptr<LayouterLock> pLocalLayouterLock)
 751 {
 752     // When the lock is released and there are pending changes to the set of
 753     // tool bars then update this set now.
 754     if (mnLockCount != 0)
 755         return;
 756
 757     // During creation of ViewShellBase we may have the situation that
 758     // the controller has already been created and attached to the frame
 759     // but that the ToolBarManager has not yet completed its
 760     // initialization (by initializing the mxLayouter member.)  We do
 761     // this here so that we do not have to wait for the next Update()
 762     // call to show the tool bars.
 763     if (mnPendingSetValidCall != nullptr)
 764     {
 765         Application::RemoveUserEvent(mnPendingSetValidCall);
 766         mnPendingSetValidCall = nullptr;
 767         SetValid(true);
 768     }
 769
 770     if (mbIsValid && mxLayouter.is() && (mbPreUpdatePending || mbPostUpdatePending))
 771     {
 772         // 1) Release UNO tool bars that are no longer used.  Do this
 773         // now so that they are not updated when the SFX shell stack is
 774         // modified.
 775         if (mbPreUpdatePending)
 776             PreUpdate();
 777
 778         // 2) Update the requested shells that represent tool bar
 779         // functionality. Those that are not used anymore are
 780         // deactivated now.  Those that are missing are activated in the
 781         // next step together with the view shells.
 782         if (mpViewShellManagerLock == nullptr)
 783             mpViewShellManagerLock.reset(
 784                 new ViewShellManager::UpdateLock(mrBase.GetViewShellManager()));
 785         maToolBarShellList.UpdateShells(
 786             mrBase.GetMainViewShell(),
 787             mrBase.GetViewShellManager());
 788
 789         // 3) Unlock the ViewShellManager::UpdateLock.  This updates the
 790         // shell stack.
 791         mpViewShellManagerLock.reset();
 792
 793         // 4) Make the UNO tool bars visible.  The outstanding call to
 794         // PostUpdate() is done via PostUserEvent() so that it is
 795         // guaranteed to be executed when the SFX shell stack has been
 796         // updated (under the assumption that our lock to the
 797         // ViewShellManager was the only one open.  If that is not the
 798         // case then all should still be well but not as fast.)
 799
 800         // Note that the lock count may have been increased since
 801         // entering this method.  In that case one of the next
 802         // UnlockUpdate() calls will post the UpdateCallback.
 803         if (mnLockCount==0)
 804         {
 805             mpAsynchronousLayouterLock = std::move(pLocalLayouterLock);
 806             if (mnPendingUpdateCall==nullptr)
 807             {
 808                 mnPendingUpdateCall = Application::PostUserEvent(
 809                     LINK(this,ToolBarManager::Implementation,UpdateCallback));
 810             }
 811         }
 812     }
 813     else
 814     {
 815         mpViewShellManagerLock.reset();
 816         pLocalLayouterLock.reset();
 817     }
 818 }
 819
 820 IMPL_LINK_NOARG(ToolBarManager::Implementation, UpdateCallback, void*, void)
 821 {
 822     mnPendingUpdateCall = nullptr;
 823     if (mnLockCount == 0)
 824     {
 825         if (mbPreUpdatePending)
 826             PreUpdate();
 827         if (mbPostUpdatePending)
 828             PostUpdate();
 829         if (mbIsValid && mxLayouter.is())
 830             mpAsynchronousLayouterLock.reset();
 831     }
 832 }
 833
 834 IMPL_LINK(ToolBarManager::Implementation,EventMultiplexerCallback,
 835     sd::tools::EventMultiplexerEvent&, rEvent, void)
 836 {
 837     SolarMutexGuard g;
 838     switch (rEvent.meEventId)
 839     {
 840         case EventMultiplexerEventId::ControllerAttached:
 841             if (mnPendingSetValidCall == nullptr)
 842                 mnPendingSetValidCall
 843                     = Application::PostUserEvent(LINK(this,Implementation,SetValidCallback));
 844             break;
 845
 846         case EventMultiplexerEventId::ControllerDetached:
 847             SetValid(false);
 848             break;
 849
 850         default: break;
 851     }
 852 }
 853
 854 IMPL_LINK_NOARG(ToolBarManager::Implementation, SetValidCallback, void*, void)
 855 {
 856     mnPendingSetValidCall = nullptr;
 857     SetValid(true);
 858 }
 859
 860 OUString ToolBarManager::Implementation::GetToolBarResourceName (
 861     const OUString& rsBaseName)
 862 {
 863     return "private:resource/toolbar/" + rsBaseName;
 864 }
 865
 866 bool ToolBarManager::Implementation::CheckPlugInMode (const OUString& rsName) const
 867 {
 868     bool bValid (false);
 869
 870     // Determine the plug in mode.
 871     bool bIsPlugInMode (false);
 872     do
 873     {
 874         SfxObjectShell* pObjectShell = mrBase.GetObjectShell();
 875         if (pObjectShell == nullptr)
 876             break;
 877
 878         SfxMedium* pMedium = pObjectShell->GetMedium();
 879         if (pMedium == nullptr)
 880             break;
 881
 882         const SfxBoolItem* pViewOnlyItem = SfxItemSet::GetItem<SfxBoolItem>(pMedium->GetItemSet(), SID_VIEWONLY, false);
 883         if (pViewOnlyItem == nullptr)
 884             break;
 885
 886         bIsPlugInMode = pViewOnlyItem->GetValue();
 887     }
 888     while (false);
 889
 890     if (rsName == msViewerToolBar)
 891         bValid = bIsPlugInMode;
 892     else
 893         bValid = ! bIsPlugInMode;
 894
 895     return bValid;
 896 }
 897
 898 } // end of namespace sd
 899
 900 namespace {
 901
 902 using namespace ::sd;
 903
 904 //===== LayouterLock ==========================================================
 905
 906 LayouterLock::LayouterLock (const Reference<frame::XLayoutManager>& rxLayouter)
 907     : mxLayouter(rxLayouter)
 908 {
 909     SAL_INFO("sd.view", __func__ << ": LayouterLock " << (mxLayouter.is() ? 1 :0));
 910     if (mxLayouter.is())
 911         mxLayouter->lock();
 912 }
 913
 914 LayouterLock::~LayouterLock()
 915 {
 916     SAL_INFO("sd.view", __func__ << ": ~LayouterLock " << (mxLayouter.is() ? 1 :0));
 917     if (mxLayouter.is())
 918         mxLayouter->unlock();
 919 }
 920
 921 //===== ToolBarRules ==========================================================
 922
 923 ToolBarRules::ToolBarRules (
 924     const std::shared_ptr<sd::ToolBarManager>& rpToolBarManager,
 925     const std::shared_ptr<sd::ViewShellManager>& rpViewShellManager)
 926     : mpToolBarManager(rpToolBarManager),
 927       mpViewShellManager(rpViewShellManager)
 928 {
 929 }
 930
 931 void ToolBarRules::Update (ViewShellBase const & rBase)
 932 {
 933     ViewShell* pMainViewShell = rBase.GetMainViewShell().get();
 934     if (pMainViewShell != nullptr)
 935     {
 936         MainViewShellChanged(pMainViewShell->GetShellType());
 937         if (pMainViewShell->GetView())
 938             SelectionHasChanged (*pMainViewShell, *pMainViewShell->GetView());
 939     }
 940     else
 941         MainViewShellChanged(ViewShell::ST_NONE);
 942 }
 943
 944 void ToolBarRules::MainViewShellChanged (ViewShell::ShellType nShellType)
 945 {
 946     ::sd::ToolBarManager::UpdateLock aToolBarManagerLock (mpToolBarManager);
 947     ::sd::ViewShellManager::UpdateLock aViewShellManagerLock (mpViewShellManager);
 948
 949     mpToolBarManager->ResetAllToolBars();
 950
 951     switch(nShellType)
 952     {
 953         case ::sd::ViewShell::ST_IMPRESS:
 954         case ::sd::ViewShell::ST_NOTES:
 955         case ::sd::ViewShell::ST_HANDOUT:
 956             mpToolBarManager->AddToolBar(
 957                 ToolBarManager::ToolBarGroup::Permanent,
 958                 ToolBarManager::msToolBar);
 959             mpToolBarManager->AddToolBar(
 960                 ToolBarManager::ToolBarGroup::Permanent,
 961                 ToolBarManager::msOptionsToolBar);
 962             mpToolBarManager->AddToolBar(
 963                 ToolBarManager::ToolBarGroup::Permanent,
 964                 ToolBarManager::msViewerToolBar);
 965             break;
 966
 967         case ::sd::ViewShell::ST_DRAW:
 968             mpToolBarManager->AddToolBar(
 969                 ToolBarManager::ToolBarGroup::Permanent,
 970                 ToolBarManager::msToolBar);
 971             mpToolBarManager->AddToolBar(
 972                 ToolBarManager::ToolBarGroup::Permanent,
 973                 ToolBarManager::msOptionsToolBar);
 974             mpToolBarManager->AddToolBar(
 975                 ToolBarManager::ToolBarGroup::Permanent,
 976                 ToolBarManager::msViewerToolBar);
 977             break;
 978
 979         case ViewShell::ST_OUTLINE:
 980             mpToolBarManager->AddToolBar(
 981                 ToolBarManager::ToolBarGroup::Permanent,
 982                 ToolBarManager::msOutlineToolBar);
 983             mpToolBarManager->AddToolBar(
 984                 ToolBarManager::ToolBarGroup::Permanent,
 985                 ToolBarManager::msViewerToolBar);
 986             mpToolBarManager->AddToolBarShell(
 987                 ToolBarManager::ToolBarGroup::Permanent, ToolbarId::Draw_Text_Toolbox_Sd);
 988             break;
 989
 990         case ViewShell::ST_SLIDE_SORTER:
 991             mpToolBarManager->AddToolBar(
 992                 ToolBarManager::ToolBarGroup::Permanent,
 993                 ToolBarManager::msViewerToolBar);
 994             mpToolBarManager->AddToolBar(
 995                 ToolBarManager::ToolBarGroup::Permanent,
 996                 ToolBarManager::msSlideSorterToolBar);
 997             mpToolBarManager->AddToolBar(
 998                 ToolBarManager::ToolBarGroup::Permanent,
 999                 ToolBarManager::msSlideSorterObjectBar);
1000             break;
1001
1002         case ViewShell::ST_NONE:
1003         case ViewShell::ST_PRESENTATION:
1004         case ViewShell::ST_SIDEBAR:
1005         default:
1006             break;
1007     }
1008 }
1009
1010 void ToolBarRules::MainViewShellChanged (const ViewShell& rMainViewShell)
1011 {
1012     ::sd::ToolBarManager::UpdateLock aToolBarManagerLock (mpToolBarManager);
1013     ::sd::ViewShellManager::UpdateLock aViewShellManagerLock (mpViewShellManager);
1014
1015     MainViewShellChanged(rMainViewShell.GetShellType());
1016     switch(rMainViewShell.GetShellType())
1017     {
1018         case ::sd::ViewShell::ST_IMPRESS:
1019         case ::sd::ViewShell::ST_DRAW:
1020         case ::sd::ViewShell::ST_NOTES:
1021         {
1022             const DrawViewShell* pDrawViewShell
1023                 = dynamic_cast<const DrawViewShell*>(&rMainViewShell);
1024             if (pDrawViewShell != nullptr)
1025             {
1026                 if (pDrawViewShell->GetEditMode() == EditMode::MasterPage)
1027                     mpToolBarManager->AddToolBar(
1028                         ToolBarManager::ToolBarGroup::MasterMode,
1029                         ToolBarManager::msMasterViewToolBar);
1030                 else if ( rMainViewShell.GetShellType() != ::sd::ViewShell::ST_DRAW )
1031                     mpToolBarManager->AddToolBar(
1032                         ToolBarManager::ToolBarGroup::CommonTask,
1033                         ToolBarManager::msCommonTaskToolBar);
1034             }
1035             break;
1036         }
1037
1038         default:
1039             break;
1040     }
1041 }
1042
1043 void ToolBarRules::SelectionHasChanged (
1044     const ::sd::ViewShell& rViewShell,
1045     const SdrView& rView)
1046 {
1047     ::sd::ToolBarManager::UpdateLock aLock (mpToolBarManager);
1048     mpToolBarManager->LockViewShellManager();
1049     bool bTextEdit = rView.IsTextEdit();
1050
1051     mpToolBarManager->ResetToolBars(ToolBarManager::ToolBarGroup::Function);
1052
1053     switch (rView.GetContext())
1054     {
1055         case SdrViewContext::Graphic:
1056             if( !bTextEdit )
1057                 mpToolBarManager->SetToolBarShell(ToolBarManager::ToolBarGroup::Function, ToolbarId::Draw_Graf_Toolbox);
1058             break;
1059
1060         case SdrViewContext::Media:
1061             if( !bTextEdit )
1062                 mpToolBarManager->SetToolBarShell(ToolBarManager::ToolBarGroup::Function, ToolbarId::Draw_Media_Toolbox);
1063             break;
1064
1065         case SdrViewContext::Table:
1066             mpToolBarManager->SetToolBarShell(ToolBarManager::ToolBarGroup::Function, ToolbarId::Draw_Table_Toolbox);
1067             bTextEdit = true;
1068             break;
1069
1070         case SdrViewContext::Standard:
1071         default:
1072             if( !bTextEdit )
1073             {
1074                 switch(rViewShell.GetShellType())
1075                 {
1076                     case ::sd::ViewShell::ST_IMPRESS:
1077                     case ::sd::ViewShell::ST_DRAW:
1078                     case ::sd::ViewShell::ST_NOTES:
1079                     case ::sd::ViewShell::ST_HANDOUT:
1080                         mpToolBarManager->SetToolBar(
1081                             ToolBarManager::ToolBarGroup::Function,
1082                             ToolBarManager::msDrawingObjectToolBar);
1083                         break;
1084                     default:
1085                         break;
1086                 }
1087                 break;
1088             }
1089     }
1090
1091     if( bTextEdit )
1092         mpToolBarManager->AddToolBarShell(ToolBarManager::ToolBarGroup::Function, ToolbarId::Draw_Text_Toolbox_Sd);
1093
1094     SdrView* pView = &const_cast<SdrView&>(rView);
1095     // Check if the extrusion tool bar and the fontwork tool bar have to
1096     // be activated.
1097     if (svx::checkForSelectedCustomShapes(pView, true /* bOnlyExtruded */ ))
1098         mpToolBarManager->AddToolBarShell(ToolBarManager::ToolBarGroup::Function, ToolbarId::Svx_Extrusion_Bar);
1099     sal_uInt32 nCheckStatus = 0;
1100     if (svx::checkForSelectedFontWork(pView, nCheckStatus))
1101         mpToolBarManager->AddToolBarShell(ToolBarManager::ToolBarGroup::Function, ToolbarId::Svx_Fontwork_Bar);
1102
1103     // Switch on additional context-sensitive tool bars.
1104     if (rView.GetContext() == SdrViewContext::PointEdit)
1105         mpToolBarManager->AddToolBarShell(ToolBarManager::ToolBarGroup::Function, ToolbarId::Bezier_Toolbox_Sd);
1106 }
1107
1108 void ToolBarRules::SubShellAdded (
1109     ::sd::ToolBarManager::ToolBarGroup eGroup,
1110     sd::ShellId nShellId)
1111 {
1112     // For some tool bar shells (those defined in sd) we have to add the
1113     // actual tool bar here.
1114     switch (nShellId)
1115     {
1116         case ToolbarId::Draw_Graf_Toolbox:
1117             mpToolBarManager->AddToolBar(eGroup, ToolBarManager::msGraphicObjectBar);
1118             break;
1119
1120         case ToolbarId::Draw_Media_Toolbox:
1121             mpToolBarManager->AddToolBar(eGroup, ToolBarManager::msMediaObjectBar);
1122             break;
1123
1124         case ToolbarId::Draw_Text_Toolbox_Sd:
1125             mpToolBarManager->AddToolBar(eGroup, ToolBarManager::msTextObjectBar);
1126             break;
1127
1128         case ToolbarId::Bezier_Toolbox_Sd:
1129             mpToolBarManager->AddToolBar(eGroup, ToolBarManager::msBezierObjectBar);
1130             break;
1131
1132         case ToolbarId::Draw_Table_Toolbox:
1133             mpToolBarManager->AddToolBar(eGroup, ToolBarManager::msTableObjectBar);
1134             break;
1135
1136         default:
1137             break;
1138     }
1139 }
1140
1141 void ToolBarRules::SubShellRemoved (
1142     ::sd::ToolBarManager::ToolBarGroup eGroup,
1143     sd::ShellId nShellId)
1144 {
1145     // For some tool bar shells (those defined in sd) we have to add the
1146     // actual tool bar here.
1147     switch (nShellId)
1148     {
1149         case ToolbarId::Draw_Graf_Toolbox:
1150             mpToolBarManager->RemoveToolBar(eGroup, ToolBarManager::msGraphicObjectBar);
1151             break;
1152
1153         case ToolbarId::Draw_Media_Toolbox:
1154             mpToolBarManager->RemoveToolBar(eGroup, ToolBarManager::msMediaObjectBar);
1155             break;
1156
1157         case ToolbarId::Draw_Text_Toolbox_Sd:
1158             mpToolBarManager->RemoveToolBar(eGroup, ToolBarManager::msTextObjectBar);
1159             break;
1160
1161         case ToolbarId::Bezier_Toolbox_Sd:
1162             mpToolBarManager->RemoveToolBar(eGroup, ToolBarManager::msBezierObjectBar);
1163             break;
1164
1165         case ToolbarId::Draw_Table_Toolbox:
1166             mpToolBarManager->RemoveToolBar(eGroup, ToolBarManager::msTableObjectBar);
1167             break;
1168
1169         default:
1170             break;
1171     }
1172 }
1173
1174 //===== ToolBarList ===========================================================
1175
1176 ToolBarList::ToolBarList()
1177     : maGroups(),
1178       maActiveToolBars()
1179 {
1180 }
1181
1182 void ToolBarList::ClearGroup (sd::ToolBarManager::ToolBarGroup eGroup)
1183 {
1184     Groups::iterator iGroup (maGroups.find(eGroup));
1185     if (iGroup != maGroups.end())
1186     {
1187         iGroup->second.clear();
1188     }
1189 }
1190
1191 void ToolBarList::AddToolBar (
1192     sd::ToolBarManager::ToolBarGroup eGroup,
1193     const OUString& rsName)
1194 {
1195     Groups::iterator iGroup (maGroups.find(eGroup));
1196     if (iGroup == maGroups.end())
1197         iGroup = maGroups.emplace(eGroup,std::vector<OUString>()).first;
1198
1199     if (iGroup != maGroups.end())
1200     {
1201         auto iBar (std::find(iGroup->second.cbegin(),iGroup->second.cend(),rsName));
1202         if (iBar == iGroup->second.cend())
1203         {
1204             iGroup->second.push_back(rsName);
1205         }
1206     }
1207 }
1208
1209 bool ToolBarList::RemoveToolBar (
1210     sd::ToolBarManager::ToolBarGroup eGroup,
1211     const OUString& rsName)
1212 {
1213     Groups::iterator iGroup (maGroups.find(eGroup));
1214     if (iGroup != maGroups.end())
1215     {
1216         auto iBar (std::find(iGroup->second.begin(),iGroup->second.end(),rsName));
1217         if (iBar != iGroup->second.end())
1218         {
1219             iGroup->second.erase(iBar);
1220             return true;
1221         }
1222     }
1223     return false;
1224 }
1225
1226 void ToolBarList::MakeRequestedToolBarList (std::vector<OUString>& rRequestedToolBars) const
1227 {
1228     for (auto eGroup : o3tl::enumrange<sd::ToolBarManager::ToolBarGroup>())
1229     {
1230         Groups::const_iterator iGroup (maGroups.find(eGroup));
1231         if (iGroup != maGroups.end())
1232             rRequestedToolBars.insert( rRequestedToolBars.end(),
1233                 iGroup->second.begin(),
1234                 iGroup->second.end() );
1235     }
1236 }
1237
1238 void ToolBarList::GetToolBarsToActivate (std::vector<OUString>& rToolBars) const
1239 {
1240     std::vector<OUString> aRequestedToolBars;
1241     MakeRequestedToolBarList(aRequestedToolBars);
1242
1243     for (const auto& aToolBar : aRequestedToolBars)
1244     {
1245         if (::std::find(maActiveToolBars.begin(),maActiveToolBars.end(),aToolBar)
1246             == maActiveToolBars.end())
1247         {
1248             rToolBars.push_back(aToolBar);
1249         }
1250     }
1251 }
1252
1253 void ToolBarList::GetToolBarsToDeactivate (std::vector<OUString>& rToolBars) const
1254 {
1255     std::vector<OUString> aRequestedToolBars;
1256     MakeRequestedToolBarList(aRequestedToolBars);
1257
1258     for (auto& aToolBar : maActiveToolBars)
1259     {
1260         if (::std::find(aRequestedToolBars.begin(),aRequestedToolBars.end(),aToolBar)
1261             == aRequestedToolBars.end())
1262         {
1263             rToolBars.push_back(aToolBar);
1264         }
1265     }
1266 }
1267
1268 void ToolBarList::MarkToolBarAsActive (const OUString& rsName)
1269 {
1270     maActiveToolBars.push_back(rsName);
1271 }
1272
1273 void ToolBarList::MarkToolBarAsNotActive (const OUString& rsName)
1274 {
1275     maActiveToolBars.erase(
1276         ::std::find(maActiveToolBars.begin(),maActiveToolBars.end(), rsName));
1277 }
1278
1279 void ToolBarList::MarkAllToolBarsAsNotActive()
1280 {
1281     maActiveToolBars.clear();
1282 }
1283
1284 //===== ToolBarShellList ======================================================
1285
1286 ToolBarShellList::ShellDescriptor::ShellDescriptor (
1287     ShellId nId,
1288     sd::ToolBarManager::ToolBarGroup eGroup)
1289     : mnId(nId),
1290       meGroup(eGroup)
1291 {
1292 }
1293
1294 ToolBarShellList::ToolBarShellList()
1295 : maNewList()
1296 , maCurrentList()
1297 {
1298 }
1299
1300 void ToolBarShellList::ClearGroup (sd::ToolBarManager::ToolBarGroup eGroup)
1301 {
1302     for (GroupedShellList::iterator iDescriptor = maNewList.begin(); iDescriptor != maNewList.end(); )
1303         if (iDescriptor->meGroup == eGroup)
1304             iDescriptor = maNewList.erase(iDescriptor);
1305         else
1306             ++iDescriptor;
1307 }
1308
1309 void ToolBarShellList::AddShellId (sd::ToolBarManager::ToolBarGroup eGroup, sd::ShellId nId)
1310 {
1311     // Make sure that the shell is not added twice (and possibly in
1312     // different groups.)
1313     ShellDescriptor aDescriptor (nId,eGroup);
1314     GroupedShellList::iterator iDescriptor (maNewList.find(aDescriptor));
1315     if (iDescriptor != maNewList.end())
1316     {
1317         // The shell is already requested.
1318         if (iDescriptor->meGroup != eGroup)
1319         {
1320             // It is now being requested for another group.
1321             // (Is this an error?)
1322             // Move it to that group.
1323             maNewList.erase(iDescriptor);
1324             maNewList.insert(aDescriptor);
1325         }
1326         // else nothing to do.
1327     }
1328     else
1329         maNewList.insert(aDescriptor);
1330 }
1331
1332 void ToolBarShellList::ReleaseAllShells (ToolBarRules& rRules)
1333 {
1334     // Release the currently active tool bars.
1335     GroupedShellList aList (maCurrentList);
1336     for (const auto& rDescriptor : aList)
1337     {
1338         rRules.SubShellRemoved(rDescriptor.meGroup, rDescriptor.mnId);
1339     }
1340
1341     // Clear the list of requested tool bars.
1342     maNewList.clear();
1343 }
1344
1345 void ToolBarShellList::UpdateShells (
1346     const std::shared_ptr<ViewShell>& rpMainViewShell,
1347     const std::shared_ptr<ViewShellManager>& rpManager)
1348 {
1349     if (rpMainViewShell == nullptr)
1350         return;
1351
1352     GroupedShellList aList;
1353
1354     // Deactivate shells that are in maCurrentList, but not in
1355     // maNewList.
1356     ::std::set_difference(maCurrentList.begin(), maCurrentList.end(),
1357         maNewList.begin(), maNewList.end(),
1358         std::insert_iterator<GroupedShellList>(aList,aList.begin()));
1359     for (const auto& rShell : aList)
1360     {
1361         SAL_INFO("sd.view", __func__ << ": deactivating tool bar shell " << static_cast<sal_uInt32>(rShell.mnId));
1362         rpManager->DeactivateSubShell(*rpMainViewShell, rShell.mnId);
1363     }
1364
1365     // Activate shells that are in maNewList, but not in
1366     // maCurrentList.
1367     aList.clear();
1368     ::std::set_difference(maNewList.begin(), maNewList.end(),
1369         maCurrentList.begin(), maCurrentList.end(),
1370         std::insert_iterator<GroupedShellList>(aList,aList.begin()));
1371     for (const auto& rShell : aList)
1372     {
1373         SAL_INFO("sd.view", __func__ << ": activating tool bar shell " << static_cast<sal_uInt32>(rShell.mnId));
1374         rpManager->ActivateSubShell(*rpMainViewShell, rShell.mnId);
1375     }
1376
1377     // The maNewList now reflects the current state and thus is made
1378     // maCurrentList.
1379     maCurrentList = maNewList;
1380 }
1381
1382 } // end of anonymous namespace
1383
1384 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */