LCOV - code coverage report
Current view: top level - sd/source/ui/view - ToolBarManager.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 534 0.0 %
Date: 2014-04-14 Functions: 0 79 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10