Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1767 insertions, 0 deletions

diff --git a/sfx2/source/control/bindings.cxx b/sfx2/source/control/bindings.cxx
new file mode 100644
index 000000000..1baa03845
--- /dev/null
+++ b/sfx2/source/control/bindings.cxx
@@ -0,0 +1,1767 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sal/config.h>
+
+#include <iomanip>
+
+#include <sal/log.hxx>
+#include <svl/itempool.hxx>
+#include <svl/itemiter.hxx>
+#include <svl/eitem.hxx>
+#include <svl/intitem.hxx>
+#include <svl/stritem.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/timer.hxx>
+#include <com/sun/star/frame/XDispatch.hpp>
+#include <com/sun/star/frame/XDispatchProvider.hpp>
+#include <com/sun/star/frame/DispatchResultState.hpp>
+#include <itemdel.hxx>
+
+//Includes below due to nInReschedule
+#include <sfx2/bindings.hxx>
+#include <sfx2/msg.hxx>
+#include <statcach.hxx>
+#include <sfx2/ctrlitem.hxx>
+#include <sfx2/app.hxx>
+#include <sfx2/dispatch.hxx>
+#include <sfx2/module.hxx>
+#include <sfx2/request.hxx>
+#include <workwin.hxx>
+#include <unoctitm.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <sfx2/objsh.hxx>
+#include <sfx2/msgpool.hxx>
+
+#include <cstddef>
+#include <memory>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::util;
+
+#define TIMEOUT_FIRST       300
+#define TIMEOUT_UPDATING     20
+
+typedef std::unordered_map< sal_uInt16, bool > InvalidateSlotMap;
+
+struct SfxFoundCache_Impl
+{
+    sal_uInt16      nWhichId;  // If available: Which-Id, else: nSlotId
+    const SfxSlot*  pSlot;     // Pointer to <Master-Slot>
+    SfxStateCache&  rCache;    // Pointer to StatusCache
+
+    SfxFoundCache_Impl(sal_uInt16 nW, const SfxSlot *pS, SfxStateCache& rC)
+        : nWhichId(nW)
+        , pSlot(pS)
+        , rCache(rC)
+    {}
+};
+
+class SfxFoundCacheArr_Impl
+{
+    typedef std::vector<std::unique_ptr<SfxFoundCache_Impl> > DataType;
+    DataType maData;
+
+public:
+
+    SfxFoundCache_Impl& operator[] ( size_t i )
+    {
+        return *maData[i];
+    }
+
+    size_t size() const
+    {
+        return maData.size();
+    }
+
+    void push_back( SfxFoundCache_Impl* p )
+    {
+        maData.push_back(std::unique_ptr<SfxFoundCache_Impl>(p));
+    }
+};
+
+class SfxBindings_Impl
+{
+public:
+    css::uno::Reference< css::frame::XDispatchRecorder > xRecorder;
+    css::uno::Reference< css::frame::XDispatchProvider >  xProv;
+    SfxWorkWindow*          pWorkWin;
+    SfxBindings*            pSubBindings;
+    std::vector<std::unique_ptr<SfxStateCache>> pCaches; // One cache for each binding
+    std::size_t             nCachedFunc1;   // index for the last one called
+    std::size_t             nCachedFunc2;   // index for the second last called
+    std::size_t             nMsgPos;        // Message-Position relative the one to be updated
+    bool                    bContextChanged;
+    bool                    bMsgDirty;      // Has a MessageServer been invalidated?
+    bool                    bAllMsgDirty;   //  Has a MessageServer been invalidated?
+    bool                    bAllDirty;      // After InvalidateAll
+    bool                    bCtrlReleased;  // while EnterRegistrations
+    AutoTimer               aAutoTimer;     // for volatile Slots
+    bool                    bInUpdate;      // for Assertions
+    bool                    bInNextJob;     // for Assertions
+    bool                    bFirstRound;    // First round in Update
+    sal_uInt16              nOwnRegLevel;   // Counts the real Locks, except those of the Super Bindings
+    InvalidateSlotMap       m_aInvalidateSlots; // store slots which are invalidated while in update
+};
+
+SfxBindings::SfxBindings()
+:   pImpl(new SfxBindings_Impl),
+    pDispatcher(nullptr),
+    nRegLevel(1)    // first becomes 0, when the Dispatcher is set
+
+{
+    pImpl->nMsgPos = 0;
+    pImpl->bAllMsgDirty = true;
+    pImpl->bContextChanged = false;
+    pImpl->bMsgDirty = true;
+    pImpl->bAllDirty = true;
+    pImpl->nCachedFunc1 = 0;
+    pImpl->nCachedFunc2 = 0;
+    pImpl->bCtrlReleased = false;
+    pImpl->bFirstRound = false;
+    pImpl->bInNextJob = false;
+    pImpl->bInUpdate = false;
+    pImpl->pSubBindings = nullptr;
+    pImpl->pWorkWin = nullptr;
+    pImpl->nOwnRegLevel = nRegLevel;
+
+    // all caches are valid (no pending invalidate-job)
+    // create the list of caches
+    pImpl->aAutoTimer.SetInvokeHandler( LINK(this, SfxBindings, NextJob) );
+    pImpl->aAutoTimer.SetDebugName( "sfx::SfxBindings aAutoTimer" );
+}
+
+
+SfxBindings::~SfxBindings()
+
+/*  [Description]
+
+    Destructor of the SfxBindings class. The one, for each <SfxApplication>
+    existing Instance is automatically destroyed by the <SfxApplication>
+    after the execution of <SfxApplication::Exit()>.
+
+    The still existing <SfxControllerItem> instances, which are registered
+    by the SfxBindings instance, are automatically destroyed in the Destructor.
+    These are usually the Floating-Toolboxen, Value-Sets
+    etc. Arrays of SfxControllerItems may at this time no longer exist.
+*/
+
+{
+    // The SubBindings should not be locked!
+    pImpl->pSubBindings = nullptr;
+
+    ENTERREGISTRATIONS();
+
+    pImpl->aAutoTimer.Stop();
+    DeleteControllers_Impl();
+
+    // Delete Caches
+    pImpl->pCaches.clear();
+
+    DELETEZ( pImpl->pWorkWin );
+}
+
+
+void SfxBindings::DeleteControllers_Impl()
+{
+    // in the first round delete Controllers
+    std::size_t nCount = pImpl->pCaches.size();
+    std::size_t nCache;
+    for ( nCache = 0; nCache < nCount; ++nCache )
+    {
+        // Remember were you are
+        SfxStateCache *pCache = pImpl->pCaches[nCache].get();
+        sal_uInt16 nSlotId = pCache->GetId();
+
+        // Re-align, because the cache may have been reduced
+        std::size_t nNewCount = pImpl->pCaches.size();
+        if ( nNewCount < nCount )
+        {
+            nCache = GetSlotPos(nSlotId);
+            if ( nCache >= nNewCount ||
+                 nSlotId != pImpl->pCaches[nCache]->GetId() )
+                --nCache;
+            nCount = nNewCount;
+        }
+    }
+
+    // Delete all Caches
+    for ( nCache = pImpl->pCaches.size(); nCache > 0; --nCache )
+    {
+        // Get Cache via css::sdbcx::Index
+        SfxStateCache *pCache = pImpl->pCaches[ nCache-1 ].get();
+
+        // unbind all controllers in the cache
+        SfxControllerItem *pNext;
+        for ( SfxControllerItem *pCtrl = pCache->GetItemLink();
+              pCtrl; pCtrl = pNext )
+        {
+            pNext = pCtrl->GetItemLink();
+            pCtrl->UnBind();
+        }
+
+        if ( pCache->GetInternalController() )
+            pCache->GetInternalController()->UnBind();
+
+        // Delete Cache
+        pImpl->pCaches.erase(pImpl->pCaches.begin() + nCache - 1);
+    }
+}
+
+
+void SfxBindings::HidePopups( bool bHide )
+{
+    // Hide SfxChildWindows
+    DBG_ASSERT( pDispatcher, "HidePopups not allowed without dispatcher" );
+    if ( pImpl->pWorkWin )
+        pImpl->pWorkWin->HidePopups_Impl( bHide );
+}
+
+void SfxBindings::Update_Impl(SfxStateCache& rCache /*The up to date SfxStatusCache*/)
+{
+    if (rCache.GetDispatch().is() && rCache.GetItemLink())
+    {
+        rCache.SetCachedState(true);
+        if (!rCache.GetInternalController())
+            return;
+    }
+
+    if ( !pDispatcher )
+        return;
+
+    // gather together all with the same status method which are dirty
+    SfxDispatcher &rDispat = *pDispatcher;
+    const SfxSlot *pRealSlot = nullptr;
+    const SfxSlotServer* pMsgServer = nullptr;
+    SfxFoundCacheArr_Impl aFound;
+    std::unique_ptr<SfxItemSet> pSet = CreateSet_Impl(rCache, pRealSlot, &pMsgServer, aFound);
+    bool bUpdated = false;
+    if ( pSet )
+    {
+        // Query Status
+        if ( rDispat.FillState_( *pMsgServer, *pSet, pRealSlot ) )
+        {
+            // Post Status
+            for ( size_t nPos = 0; nPos < aFound.size(); ++nPos )
+            {
+                const SfxFoundCache_Impl& rFound = aFound[nPos];
+                sal_uInt16 nWhich = rFound.nWhichId;
+                const SfxPoolItem *pItem = nullptr;
+                SfxItemState eState = pSet->GetItemState(nWhich, true, &pItem);
+                if ( eState == SfxItemState::DEFAULT && SfxItemPool::IsWhich(nWhich) )
+                    pItem = &pSet->Get(nWhich);
+                UpdateControllers_Impl( rFound, pItem, eState );
+            }
+            bUpdated = true;
+        }
+
+        pSet.reset();
+    }
+
+    if (!bUpdated)
+    {
+        SfxFoundCache_Impl aFoundCache(0, pRealSlot, rCache);
+        UpdateControllers_Impl( aFoundCache, nullptr, SfxItemState::DISABLED);
+    }
+}
+
+void SfxBindings::InvalidateSlotsInMap_Impl()
+{
+    for (auto const& slot : pImpl->m_aInvalidateSlots)
+        Invalidate( slot.first );
+
+    pImpl->m_aInvalidateSlots.clear();
+}
+
+
+void SfxBindings::AddSlotToInvalidateSlotsMap_Impl( sal_uInt16 nId )
+{
+    pImpl->m_aInvalidateSlots[nId] = true;
+}
+
+
+void SfxBindings::Update
+(
+    sal_uInt16      nId     // the bound and up-to-date Slot-Id
+)
+{
+    if ( pDispatcher )
+        pDispatcher->Flush();
+
+    if ( pImpl->pSubBindings )
+        pImpl->pSubBindings->Update( nId );
+
+    SfxStateCache* pCache = GetStateCache( nId );
+    if ( !pCache )
+        return;
+
+    pImpl->bInUpdate = true;
+    if ( pImpl->bMsgDirty )
+    {
+        UpdateSlotServer_Impl();
+        pCache = GetStateCache( nId );
+    }
+
+    if (pCache)
+    {
+        bool bInternalUpdate = true;
+        if( pCache->GetDispatch().is() && pCache->GetItemLink() )
+        {
+            pCache->SetCachedState(true);
+            bInternalUpdate = ( pCache->GetInternalController() != nullptr );
+        }
+
+        if ( bInternalUpdate )
+        {
+            // Query Status
+            const SfxSlotServer* pMsgServer = pDispatcher ? pCache->GetSlotServer(*pDispatcher, pImpl->xProv) : nullptr;
+            if ( !pCache->IsControllerDirty() )
+            {
+                pImpl->bInUpdate = false;
+                InvalidateSlotsInMap_Impl();
+                return;
+            }
+            if (!pMsgServer)
+            {
+                pCache->SetState(SfxItemState::DISABLED, nullptr);
+                pImpl->bInUpdate = false;
+                InvalidateSlotsInMap_Impl();
+                return;
+            }
+
+            Update_Impl(*pCache);
+        }
+
+        pImpl->bAllDirty = false;
+    }
+
+    pImpl->bInUpdate = false;
+    InvalidateSlotsInMap_Impl();
+}
+
+
+void SfxBindings::Update()
+{
+    if ( pImpl->pSubBindings )
+        pImpl->pSubBindings->Update();
+
+    if ( !pDispatcher )
+        return;
+
+    if ( nRegLevel )
+        return;
+
+    pImpl->bInUpdate = true;
+    pDispatcher->Flush();
+    pDispatcher->Update_Impl();
+    while ( !NextJob_Impl(nullptr) )
+        ; // loop
+    pImpl->bInUpdate = false;
+    InvalidateSlotsInMap_Impl();
+}
+
+
+void SfxBindings::SetState
+(
+    const SfxItemSet&   rSet    // status values to be set
+)
+{
+    // when locked then only invalidate
+    if ( nRegLevel )
+    {
+        SfxItemIter aIter(rSet);
+        for ( const SfxPoolItem *pItem = aIter.GetCurItem();
+              pItem;
+              pItem = aIter.NextItem() )
+            Invalidate( pItem->Which() );
+    }
+    else
+    {
+        // Status may be accepted only if all slot-pointers are set
+        if ( pImpl->bMsgDirty )
+            UpdateSlotServer_Impl();
+
+        // Iterate over the itemset, update if the slot bound
+        //! Bug: Use WhichIter and possibly send VoidItems up
+        SfxItemIter aIter(rSet);
+        for ( const SfxPoolItem *pItem = aIter.GetCurItem();
+              pItem;
+              pItem = aIter.NextItem() )
+        {
+            SfxStateCache* pCache =
+                    GetStateCache( rSet.GetPool()->GetSlotId(pItem->Which()) );
+            if ( pCache )
+            {
+                // Update status
+                if ( !pCache->IsControllerDirty() )
+                    pCache->Invalidate(false);
+                pCache->SetState( SfxItemState::DEFAULT, pItem );
+
+                //! Not implemented: Updates from EnumSlots via master slots
+            }
+        }
+    }
+}
+
+
+void SfxBindings::SetState
+(
+    const SfxPoolItem&  rItem   // Status value to be set
+)
+{
+    if ( nRegLevel )
+    {
+        Invalidate( rItem.Which() );
+    }
+    else
+    {
+        // Status may be accepted only if all slot-pointers are set
+        if ( pImpl->bMsgDirty )
+            UpdateSlotServer_Impl();
+
+        //update if the slot bound
+        DBG_ASSERT( SfxItemPool::IsSlot( rItem.Which() ),
+                    "cannot set items with which-id" );
+        SfxStateCache* pCache = GetStateCache( rItem.Which() );
+        if ( pCache )
+        {
+            // Update Status
+            if ( !pCache->IsControllerDirty() )
+                pCache->Invalidate(false);
+            pCache->SetState( SfxItemState::DEFAULT, &rItem );
+
+            //! Not implemented: Updates from EnumSlots via master slots
+        }
+    }
+}
+
+
+SfxStateCache* SfxBindings::GetAnyStateCache_Impl( sal_uInt16 nId )
+{
+    SfxStateCache* pCache = GetStateCache( nId );
+    if ( !pCache && pImpl->pSubBindings )
+        return pImpl->pSubBindings->GetAnyStateCache_Impl( nId );
+    return pCache;
+}
+
+SfxStateCache* SfxBindings::GetStateCache
+(
+    sal_uInt16   nId   /*  Slot-Id, which SfxStatusCache is to be found */
+)
+{
+    return GetStateCache(nId, nullptr);
+}
+
+SfxStateCache* SfxBindings::GetStateCache
+(
+    sal_uInt16   nId,   /*  Slot-Id, which SfxStatusCache is to be found */
+    std::size_t * pPos  /*  NULL for instance the position from which the
+                           bindings are to be searched binary. Returns the
+                           position back for where the nId was found,
+                           or where it was inserted. */
+)
+{
+    // is the specified function bound?
+    const std::size_t nStart = ( pPos ? *pPos : 0 );
+    const std::size_t nPos = GetSlotPos( nId, nStart );
+
+    if ( nPos < pImpl->pCaches.size() &&
+         pImpl->pCaches[nPos]->GetId() == nId )
+    {
+        if ( pPos )
+            *pPos = nPos;
+        return pImpl->pCaches[nPos].get();
+    }
+    return nullptr;
+}
+
+
+void SfxBindings::InvalidateAll
+(
+    bool  bWithMsg  /* true   Mark Slot Server as invalid
+                       false  Slot Server remains valid */
+)
+{
+    DBG_ASSERT( !pImpl->bInUpdate, "SfxBindings::Invalidate while in update" );
+
+    if ( pImpl->pSubBindings )
+        pImpl->pSubBindings->InvalidateAll( bWithMsg );
+
+    // everything is already set dirty or downing => nothing to do
+    if ( !pDispatcher ||
+         ( pImpl->bAllDirty && ( !bWithMsg || pImpl->bAllMsgDirty ) ) ||
+         SfxGetpApp()->IsDowning() )
+    {
+        return;
+    }
+
+    pImpl->bAllMsgDirty = pImpl->bAllMsgDirty || bWithMsg;
+    pImpl->bMsgDirty = pImpl->bMsgDirty || pImpl->bAllMsgDirty || bWithMsg;
+    pImpl->bAllDirty = true;
+
+    for (std::unique_ptr<SfxStateCache>& pCache : pImpl->pCaches)
+        pCache->Invalidate(bWithMsg);
+
+    pImpl->nMsgPos = 0;
+    if ( !nRegLevel )
+    {
+        pImpl->aAutoTimer.Stop();
+        pImpl->aAutoTimer.SetTimeout(TIMEOUT_FIRST);
+        pImpl->aAutoTimer.Start();
+    }
+}
+
+
+void SfxBindings::Invalidate
+(
+    const sal_uInt16* pIds /* numerically sorted NULL-terminated array of
+                              slot IDs (individual, not as a couple!) */
+)
+{
+    if ( pImpl->bInUpdate )
+    {
+        sal_Int32 i = 0;
+        while ( pIds[i] != 0 )
+            AddSlotToInvalidateSlotsMap_Impl( pIds[i++] );
+
+        if ( pImpl->pSubBindings )
+            pImpl->pSubBindings->Invalidate( pIds );
+        return;
+    }
+
+    if ( pImpl->pSubBindings )
+        pImpl->pSubBindings->Invalidate( pIds );
+
+    // everything is already set dirty or downing => nothing to do
+    if ( !pDispatcher || pImpl->bAllDirty || SfxGetpApp()->IsDowning() )
+        return;
+
+    // Search binary in always smaller areas
+    for ( std::size_t n = GetSlotPos(*pIds);
+          *pIds && n < pImpl->pCaches.size();
+          n = GetSlotPos(*pIds, n) )
+    {
+        // If SID is ever bound, then invalidate the cache
+        SfxStateCache *pCache = pImpl->pCaches[n].get();
+        if ( pCache->GetId() == *pIds )
+            pCache->Invalidate(false);
+
+        // Next SID
+        if ( !*++pIds )
+            break;
+        assert( *pIds > *(pIds-1) );
+    }
+
+    // if not enticed to start update timer
+    pImpl->nMsgPos = 0;
+    if ( !nRegLevel )
+    {
+        pImpl->aAutoTimer.Stop();
+        pImpl->aAutoTimer.SetTimeout(TIMEOUT_FIRST);
+        pImpl->aAutoTimer.Start();
+    }
+}
+
+
+void SfxBindings::InvalidateShell
+(
+    const SfxShell&  rSh,  /* <SfxShell> whose Slot-Ids should be
+                              invalidated */
+    bool             bDeep /* true
+                              also the SfxShell's inherited slot IDs are invalidated
+
+                              false
+                              the inherited and not overridden Slot-Ids are
+                              invalidated */
+                             // for now always bDeep
+)
+{
+    DBG_ASSERT( !pImpl->bInUpdate, "SfxBindings::Invalidate while in update" );
+
+    if ( pImpl->pSubBindings )
+        pImpl->pSubBindings->InvalidateShell( rSh, bDeep );
+
+    if ( !pDispatcher || pImpl->bAllDirty || SfxGetpApp()->IsDowning() )
+        return;
+
+    // flush now already, it is done in GetShellLevel (rsh) anyway,
+    // important so that is set correctly: pImpl-> ball(Msg)Dirty
+    pDispatcher->Flush();
+
+    if ((pImpl->bAllDirty && pImpl->bAllMsgDirty) || SfxGetpApp()->IsDowning())
+    {
+        // if the next one is anyway, then all the servers are collected
+        return;
+    }
+
+    // Find Level
+    sal_uInt16 nLevel = pDispatcher->GetShellLevel(rSh);
+    if ( nLevel == USHRT_MAX )
+        return;
+
+    for (std::unique_ptr<SfxStateCache>& pCache : pImpl->pCaches)
+    {
+        const SfxSlotServer *pMsgServer =
+            pCache->GetSlotServer(*pDispatcher, pImpl->xProv);
+        if ( pMsgServer && pMsgServer->GetShellLevel() == nLevel )
+            pCache->Invalidate(false);
+    }
+    pImpl->nMsgPos = 0;
+    if ( !nRegLevel )
+    {
+        pImpl->aAutoTimer.Stop();
+        pImpl->aAutoTimer.SetTimeout(TIMEOUT_FIRST);
+        pImpl->aAutoTimer.Start();
+        pImpl->bFirstRound = true;
+    }
+}
+
+
+void SfxBindings::Invalidate
+(
+    sal_uInt16 nId              // Status value to be set
+)
+{
+    if ( pImpl->bInUpdate )
+    {
+        AddSlotToInvalidateSlotsMap_Impl( nId );
+        if ( pImpl->pSubBindings )
+            pImpl->pSubBindings->Invalidate( nId );
+        return;
+    }
+
+    if ( pImpl->pSubBindings )
+        pImpl->pSubBindings->Invalidate( nId );
+
+    if ( !pDispatcher || pImpl->bAllDirty || SfxGetpApp()->IsDowning() )
+        return;
+
+    SfxStateCache* pCache = GetStateCache(nId);
+    if ( pCache )
+    {
+        pCache->Invalidate(false);
+        pImpl->nMsgPos = std::min(GetSlotPos(nId), pImpl->nMsgPos);
+        if ( !nRegLevel )
+        {
+            pImpl->aAutoTimer.Stop();
+            pImpl->aAutoTimer.SetTimeout(TIMEOUT_FIRST);
+            pImpl->aAutoTimer.Start();
+        }
+    }
+}
+
+
+void SfxBindings::Invalidate
+(
+    sal_uInt16  nId,                // Status value to be set
+    bool        bWithItem,          // Clear StateCache?
+    bool        bWithMsg            // Get new SlotServer?
+)
+{
+    DBG_ASSERT( !pImpl->bInUpdate, "SfxBindings::Invalidate while in update" );
+
+    if ( pImpl->pSubBindings )
+        pImpl->pSubBindings->Invalidate( nId, bWithItem, bWithMsg );
+
+    if ( SfxGetpApp()->IsDowning() )
+        return;
+
+    SfxStateCache* pCache = GetStateCache(nId);
+    if ( !pCache )
+        return;
+
+    if ( bWithItem )
+        pCache->ClearCache();
+    pCache->Invalidate(bWithMsg);
+
+    if ( !pDispatcher || pImpl->bAllDirty )
+        return;
+
+    pImpl->nMsgPos = std::min(GetSlotPos(nId), pImpl->nMsgPos);
+    if ( !nRegLevel )
+    {
+        pImpl->aAutoTimer.Stop();
+        pImpl->aAutoTimer.SetTimeout(TIMEOUT_FIRST);
+        pImpl->aAutoTimer.Start();
+    }
+}
+
+
+std::size_t SfxBindings::GetSlotPos( sal_uInt16 nId, std::size_t nStartSearchAt )
+{
+    // answer immediately if a function-seek comes repeated
+    if ( pImpl->nCachedFunc1 < pImpl->pCaches.size() &&
+         pImpl->pCaches[pImpl->nCachedFunc1]->GetId() == nId )
+    {
+        return pImpl->nCachedFunc1;
+    }
+    if ( pImpl->nCachedFunc2 < pImpl->pCaches.size() &&
+         pImpl->pCaches[pImpl->nCachedFunc2]->GetId() == nId )
+    {
+        // swap the caches
+        std::swap(pImpl->nCachedFunc1, pImpl->nCachedFunc2);
+        return pImpl->nCachedFunc1;
+    }
+
+    // binary search, if not found, seek to target-position
+    if ( pImpl->pCaches.size() <= nStartSearchAt )
+    {
+        return 0;
+    }
+    if ( pImpl->pCaches.size() == (nStartSearchAt+1) )
+    {
+        return pImpl->pCaches[nStartSearchAt]->GetId() >= nId ? 0 : 1;
+    }
+    std::size_t nLow = nStartSearchAt;
+    std::size_t nMid = 0;
+    std::size_t nHigh = 0;
+    bool bFound = false;
+    nHigh = pImpl->pCaches.size() - 1;
+    while ( !bFound && nLow <= nHigh )
+    {
+        nMid = (nLow + nHigh) >> 1;
+        DBG_ASSERT( nMid < pImpl->pCaches.size(), "bsearch is buggy" );
+        int nDiff = static_cast<int>(nId) - static_cast<int>( (pImpl->pCaches[nMid])->GetId() );
+        if ( nDiff < 0)
+        {   if ( nMid == 0 )
+                break;
+            nHigh = nMid - 1;
+        }
+        else if ( nDiff > 0 )
+        {   nLow = nMid + 1;
+            if ( nLow == 0 )
+                break;
+        }
+        else
+            bFound = true;
+    }
+    std::size_t nPos = bFound ? nMid : nLow;
+    DBG_ASSERT( nPos <= pImpl->pCaches.size(), "" );
+    DBG_ASSERT( nPos == pImpl->pCaches.size() ||
+                nId <= pImpl->pCaches[nPos]->GetId(), "" );
+    DBG_ASSERT( nPos == nStartSearchAt ||
+                nId > pImpl->pCaches[nPos-1]->GetId(), "" );
+    DBG_ASSERT( ( (nPos+1) >= pImpl->pCaches.size() ) ||
+                nId < pImpl->pCaches[nPos+1]->GetId(), "" );
+    pImpl->nCachedFunc2 = pImpl->nCachedFunc1;
+    pImpl->nCachedFunc1 = nPos;
+    return nPos;
+}
+
+void SfxBindings::RegisterInternal_Impl( SfxControllerItem& rItem )
+{
+    Register_Impl( rItem, true );
+
+}
+
+void SfxBindings::Register( SfxControllerItem& rItem )
+{
+    Register_Impl( rItem, false );
+}
+
+void SfxBindings::Register_Impl( SfxControllerItem& rItem, bool bInternal )
+{
+//    DBG_ASSERT( nRegLevel > 0, "registration without EnterRegistrations" );
+    DBG_ASSERT( !pImpl->bInNextJob, "SfxBindings::Register while status-updating" );
+
+    // insert new cache if it does not already exist
+    sal_uInt16 nId = rItem.GetId();
+    std::size_t nPos = GetSlotPos(nId);
+    if ( nPos >= pImpl->pCaches.size() ||
+         pImpl->pCaches[nPos]->GetId() != nId )
+    {
+        pImpl->pCaches.insert( pImpl->pCaches.begin() + nPos, std::make_unique<SfxStateCache>(nId) );
+        DBG_ASSERT( nPos == 0 ||
+                    pImpl->pCaches[nPos]->GetId() >
+                        pImpl->pCaches[nPos-1]->GetId(), "" );
+        DBG_ASSERT( (nPos == pImpl->pCaches.size()-1) ||
+                    pImpl->pCaches[nPos]->GetId() <
+                        pImpl->pCaches[nPos+1]->GetId(), "" );
+        pImpl->bMsgDirty = true;
+    }
+
+    // enqueue the new binding
+    if ( bInternal )
+    {
+        pImpl->pCaches[nPos]->SetInternalController( &rItem );
+    }
+    else
+    {
+        SfxControllerItem *pOldItem = pImpl->pCaches[nPos]->ChangeItemLink(&rItem);
+        rItem.ChangeItemLink(pOldItem);
+    }
+}
+
+
+void SfxBindings::Release( SfxControllerItem& rItem )
+{
+    DBG_ASSERT( !pImpl->bInNextJob, "SfxBindings::Release while status-updating" );
+    ENTERREGISTRATIONS();
+
+    // find the bound function
+    sal_uInt16 nId = rItem.GetId();
+    std::size_t nPos = GetSlotPos(nId);
+    SfxStateCache* pCache = (nPos < pImpl->pCaches.size()) ? pImpl->pCaches[nPos].get() : nullptr;
+    if ( pCache && pCache->GetId() == nId )
+    {
+        if ( pCache->GetInternalController() == &rItem )
+        {
+            pCache->ReleaseInternalController();
+        }
+        else
+        {
+            // is this the first binding in the list?
+            SfxControllerItem* pItem = pCache->GetItemLink();
+            if ( pItem == &rItem )
+                pCache->ChangeItemLink( rItem.GetItemLink() );
+            else
+            {
+                // search the binding in the list
+                while ( pItem && pItem->GetItemLink() != &rItem )
+                    pItem = pItem->GetItemLink();
+
+                // unlink it if it was found
+                if ( pItem )
+                    pItem->ChangeItemLink( rItem.GetItemLink() );
+            }
+        }
+
+        // was this the last controller?
+        if ( pCache->GetItemLink() == nullptr && !pCache->GetInternalController() )
+        {
+            pImpl->bCtrlReleased = true;
+        }
+    }
+
+    LEAVEREGISTRATIONS();
+}
+
+
+const SfxPoolItem* SfxBindings::ExecuteSynchron( sal_uInt16 nId, const SfxPoolItem** ppItems )
+{
+    if( !nId || !pDispatcher )
+        return nullptr;
+
+    return Execute_Impl( nId, ppItems, 0, SfxCallMode::SYNCHRON, nullptr );
+}
+
+bool SfxBindings::Execute( sal_uInt16 nId, const SfxPoolItem** ppItems, SfxCallMode nCallMode )
+{
+    if( !nId || !pDispatcher )
+        return false;
+
+    const SfxPoolItem* pRet = Execute_Impl( nId, ppItems, 0, nCallMode, nullptr );
+    return ( pRet != nullptr );
+}
+
+const SfxPoolItem* SfxBindings::Execute_Impl( sal_uInt16 nId, const SfxPoolItem** ppItems, sal_uInt16 nModi, SfxCallMode nCallMode,
+                        const SfxPoolItem **ppInternalArgs, bool bGlobalOnly )
+{
+    SfxStateCache *pCache = GetStateCache( nId );
+    if ( !pCache )
+    {
+        SfxBindings *pBind = pImpl->pSubBindings;
+        while ( pBind )
+        {
+            if ( pBind->GetStateCache( nId ) )
+                return pBind->Execute_Impl( nId, ppItems, nModi, nCallMode, ppInternalArgs, bGlobalOnly );
+            pBind = pBind->pImpl->pSubBindings;
+        }
+    }
+
+    SfxDispatcher &rDispatcher = *pDispatcher;
+    rDispatcher.Flush();
+
+    // get SlotServer (Slot+ShellLevel) and Shell from cache
+    std::unique_ptr<SfxStateCache> xCache;
+    if ( !pCache )
+    {
+        // Execution of non cached slots (Accelerators don't use Controllers)
+        // slot is uncached, use SlotCache to handle external dispatch providers
+        xCache.reset(new SfxStateCache(nId));
+        pCache = xCache.get();
+        pCache->GetSlotServer( rDispatcher, pImpl->xProv );
+    }
+
+    if ( pCache->GetDispatch().is() )
+    {
+        DBG_ASSERT( !ppInternalArgs, "Internal args get lost when dispatched!" );
+
+        SfxItemPool &rPool = GetDispatcher()->GetFrame()->GetObjectShell()->GetPool();
+        SfxRequest aReq( nId, nCallMode, rPool );
+        aReq.SetModifier( nModi );
+        if( ppItems )
+            while( *ppItems )
+                aReq.AppendItem( **ppItems++ );
+
+        // cache binds to an external dispatch provider
+        sal_Int16 eRet = pCache->Dispatch( aReq.GetArgs(), nCallMode == SfxCallMode::SYNCHRON );
+        std::unique_ptr<SfxPoolItem> pPool;
+        if ( eRet == css::frame::DispatchResultState::DONTKNOW )
+            pPool.reset( new SfxVoidItem( nId ) );
+        else
+            pPool.reset( new SfxBoolItem( nId, eRet == css::frame::DispatchResultState::SUCCESS) );
+
+        auto pTemp = pPool.get();
+        DeleteItemOnIdle( std::move(pPool) );
+        return pTemp;
+    }
+
+    // slot is handled internally by SfxDispatcher
+    if ( pImpl->bMsgDirty )
+        UpdateSlotServer_Impl();
+
+    SfxShell *pShell=nullptr;
+    const SfxSlot *pSlot=nullptr;
+
+    const SfxSlotServer* pServer = pCache->GetSlotServer( rDispatcher, pImpl->xProv );
+    if ( !pServer )
+    {
+        return nullptr;
+    }
+    else
+    {
+        pShell = rDispatcher.GetShell( pServer->GetShellLevel() );
+        pSlot = pServer->GetSlot();
+    }
+
+    if ( bGlobalOnly )
+        if ( dynamic_cast< const SfxModule *>( pShell ) == nullptr && dynamic_cast< const SfxApplication *>( pShell ) == nullptr && dynamic_cast< const SfxViewFrame *>( pShell ) == nullptr )
+            return nullptr;
+
+    SfxItemPool &rPool = pShell->GetPool();
+    SfxRequest aReq( nId, nCallMode, rPool );
+    aReq.SetModifier( nModi );
+    if( ppItems )
+        while( *ppItems )
+            aReq.AppendItem( **ppItems++ );
+    if ( ppInternalArgs )
+    {
+        SfxAllItemSet aSet( rPool );
+        for ( const SfxPoolItem **pArg = ppInternalArgs; *pArg; ++pArg )
+            aSet.Put( **pArg );
+        aReq.SetInternalArgs_Impl( aSet );
+    }
+
+    Execute_Impl( aReq, pSlot, pShell );
+
+    const SfxPoolItem* pRet = aReq.GetReturnValue();
+    if ( !pRet )
+    {
+        std::unique_ptr<SfxPoolItem> pVoid(new SfxVoidItem( nId ));
+        pRet = pVoid.get();
+        DeleteItemOnIdle( std::move(pVoid) );
+    }
+
+    return pRet;
+}
+
+void SfxBindings::Execute_Impl( SfxRequest& aReq, const SfxSlot* pSlot, SfxShell* pShell )
+{
+    SfxItemPool &rPool = pShell->GetPool();
+
+    if ( SfxSlotKind::Attribute == pSlot->GetKind() )
+    {
+        // Which value has to be mapped for Attribute slots
+        const sal_uInt16 nSlotId = pSlot->GetSlotId();
+        aReq.SetSlot( nSlotId );
+        if ( pSlot->IsMode(SfxSlotMode::TOGGLE) )
+        {
+            // The value is attached to a toggleable attribute (Bools)
+            sal_uInt16 nWhich = pSlot->GetWhich(rPool);
+            SfxItemSet aSet(rPool, {{nWhich, nWhich}});
+            SfxStateFunc aFunc  = pSlot->GetStateFnc();
+            pShell->CallState( aFunc, aSet );
+            const SfxPoolItem *pOldItem;
+            SfxItemState eState = aSet.GetItemState(nWhich, true, &pOldItem);
+            if ( eState == SfxItemState::DISABLED )
+                return;
+
+            if ( SfxItemState::DEFAULT == eState && SfxItemPool::IsWhich(nWhich) )
+                pOldItem = &aSet.Get(nWhich);
+
+            if ( SfxItemState::SET == eState ||
+                 ( SfxItemState::DEFAULT == eState &&
+                   SfxItemPool::IsWhich(nWhich) &&
+                   pOldItem ) )
+            {
+                if ( auto pOldBoolItem = dynamic_cast< const SfxBoolItem *>( pOldItem ) )
+                {
+                    // we can toggle Bools
+                    bool bOldValue = pOldBoolItem->GetValue();
+                    std::unique_ptr<SfxBoolItem> pNewItem(static_cast<SfxBoolItem*>(pOldItem->Clone()));
+                    pNewItem->SetValue( !bOldValue );
+                    aReq.AppendItem( *pNewItem );
+                }
+                else if ( dynamic_cast< const SfxEnumItemInterface *>( pOldItem ) !=  nullptr &&
+                        static_cast<const SfxEnumItemInterface *>(pOldItem)->HasBoolValue())
+                {
+                    // and Enums with Bool-Interface
+                    std::unique_ptr<SfxEnumItemInterface> pNewItem(
+                        static_cast<SfxEnumItemInterface*>(pOldItem->Clone()));
+                    pNewItem->SetBoolValue(!static_cast<const SfxEnumItemInterface *>(pOldItem)->GetBoolValue());
+                    aReq.AppendItem( *pNewItem );
+                }
+                else {
+                    OSL_FAIL( "Toggle only for Enums and Bools allowed" );
+                }
+            }
+            else if ( SfxItemState::DONTCARE == eState )
+            {
+                // Create one Status-Item for each Factory
+                std::unique_ptr<SfxPoolItem> pNewItem = pSlot->GetType()->CreateItem();
+                DBG_ASSERT( pNewItem, "Toggle to slot without ItemFactory" );
+                pNewItem->SetWhich( nWhich );
+
+                if ( auto pNewBoolItem = dynamic_cast<SfxBoolItem *>( pNewItem.get() ) )
+                {
+                  // we can toggle Bools
+                    pNewBoolItem->SetValue( true );
+                    aReq.AppendItem( *pNewItem );
+                }
+                else if ( dynamic_cast< const SfxEnumItemInterface *>( pNewItem.get() ) !=  nullptr &&
+                        static_cast<SfxEnumItemInterface *>(pNewItem.get())->HasBoolValue())
+                {
+                    // and Enums with Bool-Interface
+                    static_cast<SfxEnumItemInterface*>(pNewItem.get())->SetBoolValue(true);
+                    aReq.AppendItem( *pNewItem );
+                }
+                else {
+                    OSL_FAIL( "Toggle only for Enums and Bools allowed" );
+                }
+            }
+            else {
+                OSL_FAIL( "suspicious Toggle-Slot" );
+            }
+        }
+
+        pDispatcher->Execute_( *pShell, *pSlot, aReq, aReq.GetCallMode() | SfxCallMode::RECORD );
+    }
+    else
+        pDispatcher->Execute_( *pShell, *pSlot, aReq, aReq.GetCallMode() | SfxCallMode::RECORD );
+}
+
+
+void SfxBindings::UpdateSlotServer_Impl()
+{
+    // synchronize
+    pDispatcher->Flush();
+
+    if ( pImpl->bAllMsgDirty )
+    {
+        if ( !nRegLevel )
+        {
+            pImpl->bContextChanged = false;
+        }
+        else
+            pImpl->bContextChanged = true;
+    }
+
+    for (std::unique_ptr<SfxStateCache>& pCache : pImpl->pCaches)
+    {
+        //GetSlotServer can modify pImpl->pCaches
+        pCache->GetSlotServer(*pDispatcher, pImpl->xProv);
+    }
+    pImpl->bMsgDirty = pImpl->bAllMsgDirty = false;
+
+    Broadcast( SfxHint(SfxHintId::DocChanged) );
+}
+
+
+std::unique_ptr<SfxItemSet> SfxBindings::CreateSet_Impl
+(
+    SfxStateCache&          rCache,     // in: Status-Cache from nId
+    const SfxSlot*&         pRealSlot,  // out: RealSlot to nId
+    const SfxSlotServer**   pMsgServer, // out: Slot-Server to nId
+    SfxFoundCacheArr_Impl&  rFound      // out: List of Caches for Siblings
+)
+{
+    DBG_ASSERT( !pImpl->bMsgDirty, "CreateSet_Impl with dirty MessageServer" );
+    assert(pDispatcher);
+
+    const SfxSlotServer* pMsgSvr = rCache.GetSlotServer(*pDispatcher, pImpl->xProv);
+    if (!pMsgSvr)
+        return nullptr;
+
+    pRealSlot = nullptr;
+    *pMsgServer = pMsgSvr;
+
+    sal_uInt16 nShellLevel = pMsgSvr->GetShellLevel();
+    SfxShell *pShell = pDispatcher->GetShell( nShellLevel );
+    if ( !pShell ) // rare GPF when browsing through update from Inet-Notify
+        return nullptr;
+
+    SfxItemPool &rPool = pShell->GetPool();
+
+    // get the status method, which is served by the rCache
+    SfxStateFunc pFnc = nullptr;
+    pRealSlot = pMsgSvr->GetSlot();
+
+    pFnc = pRealSlot->GetStateFnc();
+
+    // the RealSlot is always on
+    SfxFoundCache_Impl *pFound = new SfxFoundCache_Impl(
+        pRealSlot->GetWhich(rPool), pRealSlot, rCache);
+    rFound.push_back( pFound );
+
+    // Search through the bindings for slots served by the same function. This ,    // will only affect slots which are present in the found interface.
+
+    // The position of the  Statecaches in StateCache-Array
+    std::size_t nCachePos = pImpl->nMsgPos;
+    const SfxSlot *pSibling = pRealSlot->GetNextSlot();
+
+    // the Slots ODF and interfaces are linked in a circle
+    while ( pSibling > pRealSlot )
+    {
+        SfxStateFunc pSiblingFnc=nullptr;
+        SfxStateCache *pSiblingCache =
+                GetStateCache( pSibling->GetSlotId(), &nCachePos );
+
+        // Is the slot cached ?
+        if ( pSiblingCache )
+        {
+            const SfxSlotServer *pServ = pSiblingCache->GetSlotServer(*pDispatcher, pImpl->xProv);
+            if ( pServ && pServ->GetShellLevel() == nShellLevel )
+                pSiblingFnc = pServ->GetSlot()->GetStateFnc();
+        }
+
+        // Does the slot have to be updated at all?
+        bool bInsert = pSiblingCache && pSiblingCache->IsControllerDirty();
+
+        // It is not enough to ask for the same shell!!
+        bool bSameMethod = pSiblingCache && pFnc == pSiblingFnc;
+
+        if ( bInsert && bSameMethod )
+        {
+            SfxFoundCache_Impl *pFoundCache = new SfxFoundCache_Impl(
+                pSibling->GetWhich(rPool),
+                pSibling, *pSiblingCache);
+
+            rFound.push_back( pFoundCache );
+        }
+
+        pSibling = pSibling->GetNextSlot();
+    }
+
+    // Create a Set from the ranges
+    std::unique_ptr<sal_uInt16[]> pRanges(new sal_uInt16[rFound.size() * 2 + 1]);
+    int j = 0;
+    size_t i = 0;
+    while ( i < rFound.size() )
+    {
+        pRanges[j++] = rFound[i].nWhichId;
+            // consecutive numbers
+        for ( ; i < rFound.size()-1; ++i )
+            if ( rFound[i].nWhichId+1 != rFound[i+1].nWhichId )
+                break;
+        pRanges[j++] = rFound[i++].nWhichId;
+    }
+    pRanges[j] = 0; // terminating NULL
+    std::unique_ptr<SfxItemSet> pSet(new SfxItemSet(rPool, pRanges.get()));
+    pRanges.reset();
+    return pSet;
+}
+
+
+void SfxBindings::UpdateControllers_Impl
+(
+    const SfxFoundCache_Impl&   rFound, // Cache, Slot, Which etc.
+    const SfxPoolItem*          pItem,  // item to send to controller
+    SfxItemState                eState  // state of item
+)
+{
+    SfxStateCache& rCache = rFound.rCache;
+    const SfxSlot* pSlot = rFound.pSlot;
+    DBG_ASSERT( !pSlot || rCache.GetId() == pSlot->GetSlotId(), "SID mismatch" );
+
+    // bound until now, the Controller to update the Slot.
+    if (!rCache.IsControllerDirty())
+        return;
+
+    if ( SfxItemState::DONTCARE == eState )
+    {
+        // ambiguous
+        rCache.SetState( SfxItemState::DONTCARE, INVALID_POOL_ITEM );
+    }
+    else if ( SfxItemState::DEFAULT == eState &&
+              SfxItemPool::IsSlot(rFound.nWhichId) )
+    {
+        // no Status or Default but without Pool
+        SfxVoidItem aVoid(0);
+        rCache.SetState( SfxItemState::UNKNOWN, &aVoid );
+    }
+    else if ( SfxItemState::DISABLED == eState )
+        rCache.SetState(SfxItemState::DISABLED, nullptr);
+    else
+        rCache.SetState(SfxItemState::DEFAULT, pItem);
+}
+
+IMPL_LINK( SfxBindings, NextJob, Timer *, pTimer, void )
+{
+    NextJob_Impl(pTimer);
+}
+
+bool SfxBindings::NextJob_Impl(Timer const * pTimer)
+{
+    const unsigned MAX_INPUT_DELAY = 200;
+
+    if ( Application::GetLastInputInterval() < MAX_INPUT_DELAY && pTimer )
+    {
+        pImpl->aAutoTimer.SetTimeout(TIMEOUT_UPDATING);
+        return true;
+    }
+
+    SfxApplication *pSfxApp = SfxGetpApp();
+
+    if( pDispatcher )
+        pDispatcher->Update_Impl();
+
+    // modifying the SfxObjectInterface-stack without SfxBindings => nothing to do
+    SfxViewFrame* pFrame = pDispatcher ? pDispatcher->GetFrame() : nullptr;
+    if ( (pFrame && !pFrame->GetObjectShell()->AcceptStateUpdate()) || pSfxApp->IsDowning() || pImpl->pCaches.empty() )
+    {
+        return true;
+    }
+    if ( !pDispatcher || !pDispatcher->IsFlushed() )
+    {
+        return true;
+    }
+
+    // if possible Update all server / happens in its own time slice
+    if ( pImpl->bMsgDirty )
+    {
+        UpdateSlotServer_Impl();
+        return false;
+    }
+
+    pImpl->bAllDirty = false;
+    pImpl->aAutoTimer.SetTimeout(TIMEOUT_UPDATING);
+
+    // at least 10 loops and further if more jobs are available but no input
+    bool bPreEmptive = pTimer;
+    sal_uInt16 nLoops = 10;
+    pImpl->bInNextJob = true;
+    const std::size_t nCount = pImpl->pCaches.size();
+    while ( pImpl->nMsgPos < nCount )
+    {
+        // iterate through the bound functions
+        bool bJobDone = false;
+        while ( !bJobDone )
+        {
+            SfxStateCache* pCache = pImpl->pCaches[pImpl->nMsgPos].get();
+            DBG_ASSERT( pCache, "invalid SfxStateCache-position in job queue" );
+            bool bWasDirty = pCache->IsControllerDirty();
+            if ( bWasDirty )
+            {
+                Update_Impl(*pCache);
+                DBG_ASSERT(nCount == pImpl->pCaches.size(), "Reschedule in StateChanged => buff");
+            }
+
+            // skip to next function binding
+            ++pImpl->nMsgPos;
+
+            // keep job if it is not completed, but any input is available
+            bJobDone = pImpl->nMsgPos >= nCount;
+            if ( bJobDone && pImpl->bFirstRound )
+            {
+
+                // Update of the  preferred shell has been done, now may
+                // also the others shells be updated
+                bJobDone = false;
+                pImpl->bFirstRound = false;
+                pImpl->nMsgPos = 0;
+            }
+
+            if ( bWasDirty && !bJobDone && bPreEmptive && (--nLoops == 0) )
+            {
+                pImpl->bInNextJob = false;
+                return false;
+            }
+        }
+    }
+
+    pImpl->nMsgPos = 0;
+
+    pImpl->aAutoTimer.Stop();
+
+    // Update round is finished
+    pImpl->bInNextJob = false;
+    Broadcast(SfxHint(SfxHintId::UpdateDone));
+    return true;
+}
+
+
+sal_uInt16 SfxBindings::EnterRegistrations(const char *pFile, int nLine)
+{
+    SAL_INFO(
+        "sfx.control",
+        std::setw(std::min(nRegLevel, sal_uInt16(8))) << ' ' << "this = " << this
+            << " Level = " << nRegLevel << " SfxBindings::EnterRegistrations "
+            << (pFile
+                ? SAL_STREAM("File: " << pFile << " Line: " << nLine) : ""));
+
+    // When bindings are locked, also lock sub bindings.
+    if ( pImpl->pSubBindings )
+    {
+        pImpl->pSubBindings->ENTERREGISTRATIONS();
+
+        // These EnterRegistrations are not "real" for the SubBindings
+        pImpl->pSubBindings->pImpl->nOwnRegLevel--;
+
+        // Synchronize Bindings
+        pImpl->pSubBindings->nRegLevel = nRegLevel + pImpl->pSubBindings->pImpl->nOwnRegLevel + 1;
+    }
+
+    pImpl->nOwnRegLevel++;
+
+    // check if this is the outer most level
+    if ( ++nRegLevel == 1 )
+    {
+        // stop background-processing
+        pImpl->aAutoTimer.Stop();
+
+        // flush the cache
+        pImpl->nCachedFunc1 = 0;
+        pImpl->nCachedFunc2 = 0;
+
+        // Mark if the all of the Caches have disappeared.
+        pImpl->bCtrlReleased = false;
+    }
+
+    return nRegLevel;
+}
+
+
+void SfxBindings::LeaveRegistrations( const char *pFile, int nLine )
+{
+    DBG_ASSERT( nRegLevel, "Leave without Enter" );
+
+    // Only when the SubBindings are still locked by the Superbindings,
+    // remove this lock (i.e. if there are more locks than "real" ones)
+    if ( pImpl->pSubBindings && pImpl->pSubBindings->nRegLevel > pImpl->pSubBindings->pImpl->nOwnRegLevel )
+    {
+        // Synchronize Bindings
+        pImpl->pSubBindings->nRegLevel = nRegLevel + pImpl->pSubBindings->pImpl->nOwnRegLevel;
+
+        // This LeaveRegistrations is not "real" for SubBindings
+        pImpl->pSubBindings->pImpl->nOwnRegLevel++;
+        pImpl->pSubBindings->LEAVEREGISTRATIONS();
+    }
+
+    pImpl->nOwnRegLevel--;
+
+    // check if this is the outer most level
+    if ( --nRegLevel == 0 && SfxGetpApp() && !SfxGetpApp()->IsDowning() )
+    {
+        if ( pImpl->bContextChanged )
+        {
+            pImpl->bContextChanged = false;
+        }
+
+        SfxViewFrame* pFrame = pDispatcher->GetFrame();
+
+        // If possible remove unused Caches, for example prepare PlugInInfo
+        if ( pImpl->bCtrlReleased )
+        {
+            for ( sal_uInt16 nCache = pImpl->pCaches.size(); nCache > 0; --nCache )
+            {
+                // Get Cache via css::sdbcx::Index
+                SfxStateCache *pCache = pImpl->pCaches[nCache-1].get();
+
+                // No interested Controller present
+                if ( pCache->GetItemLink() == nullptr && !pCache->GetInternalController() )
+                {
+                    // Remove Cache. Safety: first remove and then delete
+                    pImpl->pCaches.erase(pImpl->pCaches.begin() + nCache - 1);
+                }
+            }
+        }
+
+        // restart background-processing
+        pImpl->nMsgPos = 0;
+        if ( !pFrame || !pFrame->GetObjectShell() )
+            return;
+        if ( !pImpl->pCaches.empty() )
+        {
+            pImpl->aAutoTimer.Stop();
+            pImpl->aAutoTimer.SetTimeout(TIMEOUT_FIRST);
+            pImpl->aAutoTimer.Start();
+        }
+    }
+
+    SAL_INFO(
+        "sfx.control",
+        std::setw(std::min(nRegLevel, sal_uInt16(8))) << ' ' << "this = " << this
+            << " Level = " << nRegLevel << " SfxBindings::LeaveRegistrations "
+            << (pFile
+                ? SAL_STREAM("File: " << pFile << " Line: " << nLine) : ""));
+}
+
+
+void SfxBindings::SetDispatcher( SfxDispatcher *pDisp )
+{
+    SfxDispatcher *pOldDispat = pDispatcher;
+    if ( pDisp == pDispatcher )
+        return;
+
+    if ( pOldDispat )
+    {
+        SfxBindings* pBind = pOldDispat->GetBindings();
+        while ( pBind )
+        {
+            if ( pBind->pImpl->pSubBindings == this && pBind->pDispatcher != pDisp )
+                pBind->SetSubBindings_Impl( nullptr );
+            pBind = pBind->pImpl->pSubBindings;
+        }
+    }
+
+    pDispatcher = pDisp;
+
+    css::uno::Reference < css::frame::XDispatchProvider > xProv;
+    if ( pDisp )
+        xProv.set( pDisp->GetFrame()->GetFrame().GetFrameInterface(), UNO_QUERY );
+
+    SetDispatchProvider_Impl( xProv );
+    InvalidateAll( true );
+
+    if ( pDispatcher && !pOldDispat )
+    {
+        if ( pImpl->pSubBindings && pImpl->pSubBindings->pDispatcher != pOldDispat )
+        {
+            OSL_FAIL( "SubBindings already set before activating!" );
+            pImpl->pSubBindings->ENTERREGISTRATIONS();
+        }
+        LEAVEREGISTRATIONS();
+    }
+    else if( !pDispatcher )
+    {
+        ENTERREGISTRATIONS();
+        if ( pImpl->pSubBindings && pImpl->pSubBindings->pDispatcher != pOldDispat )
+        {
+            OSL_FAIL( "SubBindings still set even when deactivating!" );
+            pImpl->pSubBindings->LEAVEREGISTRATIONS();
+        }
+    }
+
+    Broadcast( SfxHint( SfxHintId::DataChanged ) );
+
+    if ( !pDisp )
+        return;
+
+    SfxBindings* pBind = pDisp->GetBindings();
+    while ( pBind && pBind != this )
+    {
+        if ( !pBind->pImpl->pSubBindings )
+        {
+            pBind->SetSubBindings_Impl( this );
+            break;
+        }
+
+        pBind = pBind->pImpl->pSubBindings;
+    }
+}
+
+
+void SfxBindings::ClearCache_Impl( sal_uInt16 nSlotId )
+{
+    SfxStateCache* pCache = GetStateCache(nSlotId);
+    if (!pCache)
+        return;
+    pCache->ClearCache();
+}
+
+
+void SfxBindings::StartUpdate_Impl( bool bComplete )
+{
+    if ( pImpl->pSubBindings )
+        pImpl->pSubBindings->StartUpdate_Impl( bComplete );
+
+    if ( !bComplete )
+        // Update may be interrupted
+        NextJob_Impl(&pImpl->aAutoTimer);
+    else
+        // Update all slots in a row
+        NextJob_Impl(nullptr);
+}
+
+
+SfxItemState SfxBindings::QueryState( sal_uInt16 nSlot, std::unique_ptr<SfxPoolItem> &rpState )
+{
+    css::uno::Reference< css::frame::XDispatch >  xDisp;
+    SfxStateCache *pCache = GetStateCache( nSlot );
+    if ( pCache )
+        xDisp = pCache->GetDispatch();
+    if ( xDisp.is() || !pCache )
+    {
+        const SfxSlot* pSlot = SfxSlotPool::GetSlotPool( pDispatcher->GetFrame() ).GetSlot( nSlot );
+        if ( !pSlot || !pSlot->pUnoName )
+            return SfxItemState::DISABLED;
+
+        css::util::URL aURL;
+        OUString aCmd( ".uno:" );
+        aURL.Protocol = aCmd;
+        aURL.Path = OUString::createFromAscii(pSlot->GetUnoName());
+        aCmd += aURL.Path;
+        aURL.Complete = aCmd;
+        aURL.Main = aCmd;
+
+        if ( !xDisp.is() )
+            xDisp = pImpl->xProv->queryDispatch( aURL, OUString(), 0 );
+
+        if ( xDisp.is() )
+        {
+            css::uno::Reference< css::lang::XUnoTunnel > xTunnel( xDisp, css::uno::UNO_QUERY );
+            SfxOfficeDispatch* pDisp = nullptr;
+            if ( xTunnel.is() )
+            {
+                sal_Int64 nImplementation = xTunnel->getSomething(SfxOfficeDispatch::impl_getStaticIdentifier());
+                pDisp = reinterpret_cast< SfxOfficeDispatch* >( sal::static_int_cast< sal_IntPtr >( nImplementation ));
+            }
+
+            if ( !pDisp )
+            {
+                bool bDeleteCache = false;
+                if ( !pCache )
+                {
+                    pCache = new SfxStateCache( nSlot );
+                    pCache->GetSlotServer( *GetDispatcher_Impl(), pImpl->xProv );
+                    bDeleteCache = true;
+                }
+
+                SfxItemState eState = SfxItemState::SET;
+                rtl::Reference<BindDispatch_Impl> xBind(new BindDispatch_Impl( xDisp, aURL, pCache, pSlot ));
+                xDisp->addStatusListener( xBind.get(), aURL );
+                if ( !xBind->GetStatus().IsEnabled )
+                {
+                    eState = SfxItemState::DISABLED;
+                }
+                else
+                {
+                    css::uno::Any aAny = xBind->GetStatus().State;
+                    const css::uno::Type& aType = aAny.getValueType();
+
+                    if ( aType == cppu::UnoType<bool>::get() )
+                    {
+                        bool bTemp = false;
+                        aAny >>= bTemp ;
+                        rpState.reset(new SfxBoolItem( nSlot, bTemp ));
+                    }
+                    else if ( aType == ::cppu::UnoType< ::cppu::UnoUnsignedShortType >::get() )
+                    {
+                        sal_uInt16 nTemp = 0;
+                        aAny >>= nTemp ;
+                        rpState.reset(new SfxUInt16Item( nSlot, nTemp ));
+                    }
+                    else if ( aType == cppu::UnoType<sal_uInt32>::get() )
+                    {
+                        sal_uInt32 nTemp = 0;
+                        aAny >>= nTemp ;
+                        rpState.reset(new SfxUInt32Item( nSlot, nTemp ));
+                    }
+                    else if ( aType == cppu::UnoType<OUString>::get() )
+                    {
+                        OUString sTemp ;
+                        aAny >>= sTemp ;
+                        rpState.reset(new SfxStringItem( nSlot, sTemp ));
+                    }
+                    else
+                        rpState.reset(new SfxVoidItem( nSlot ));
+                }
+
+                xDisp->removeStatusListener( xBind.get(), aURL );
+                xBind->Release();
+                xBind.clear();
+                if ( bDeleteCache )
+                    DELETEZ( pCache );
+                return eState;
+            }
+        }
+    }
+
+    // Then test at the dispatcher to check if the returned items from
+    // there are always DELETE_ON_IDLE, a copy of it has to be made in
+    // order to allow for transition of ownership.
+    const SfxPoolItem *pItem = nullptr;
+    SfxItemState eState = pDispatcher->QueryState( nSlot, pItem );
+    if ( eState == SfxItemState::SET )
+    {
+        DBG_ASSERT( pItem, "SfxItemState::SET but no item!" );
+        if ( pItem )
+            rpState.reset(pItem->Clone());
+    }
+    else if ( eState == SfxItemState::DEFAULT && pItem )
+    {
+        rpState.reset(pItem->Clone());
+    }
+
+    return eState;
+}
+
+void SfxBindings::QueryControlState( sal_uInt16 nSlot, boost::property_tree::ptree& rState )
+{
+    if ( SfxGetpApp()->IsDowning() )
+        return;
+
+    if ( pDispatcher )
+        pDispatcher->Flush();
+
+    if ( pImpl->pSubBindings )
+        pImpl->pSubBindings->QueryControlState( nSlot, rState );
+
+    SfxStateCache* pCache = GetStateCache( nSlot );
+    if ( pCache )
+    {
+        if ( pImpl->bMsgDirty )
+        {
+            UpdateSlotServer_Impl();
+            pCache = GetStateCache( nSlot );
+        }
+
+        if (pCache && pCache->GetItemLink() )
+        {
+            pCache->GetState(rState);
+        }
+    }
+}
+
+void SfxBindings::SetSubBindings_Impl( SfxBindings *pSub )
+{
+    if ( pImpl->pSubBindings )
+    {
+        pImpl->pSubBindings->SetDispatchProvider_Impl( css::uno::Reference< css::frame::XDispatchProvider > () );
+    }
+
+    pImpl->pSubBindings = pSub;
+
+    if ( pSub )
+    {
+        pImpl->pSubBindings->SetDispatchProvider_Impl( pImpl->xProv );
+    }
+}
+
+SfxBindings* SfxBindings::GetSubBindings_Impl() const
+{
+    return pImpl->pSubBindings;
+}
+
+void SfxBindings::SetWorkWindow_Impl( SfxWorkWindow* pWork )
+{
+    pImpl->pWorkWin = pWork;
+}
+
+SfxWorkWindow* SfxBindings::GetWorkWindow_Impl() const
+{
+    return pImpl->pWorkWin;
+}
+
+bool SfxBindings::IsInUpdate() const
+{
+    bool bInUpdate = pImpl->bInUpdate;
+    if ( !bInUpdate && pImpl->pSubBindings )
+        bInUpdate = pImpl->pSubBindings->IsInUpdate();
+    return bInUpdate;
+}
+
+void SfxBindings::SetVisibleState( sal_uInt16 nId, bool bShow )
+{
+    SfxStateCache *pCache = GetStateCache( nId );
+    if ( pCache )
+        pCache->SetVisibleState( bShow );
+}
+
+void SfxBindings::SetActiveFrame( const css::uno::Reference< css::frame::XFrame > & rFrame )
+{
+    if ( rFrame.is() || !pDispatcher )
+        SetDispatchProvider_Impl( css::uno::Reference< css::frame::XDispatchProvider > ( rFrame, css::uno::UNO_QUERY ) );
+    else
+        SetDispatchProvider_Impl( css::uno::Reference< css::frame::XDispatchProvider > (
+            pDispatcher->GetFrame()->GetFrame().GetFrameInterface(), css::uno::UNO_QUERY ) );
+}
+
+css::uno::Reference< css::frame::XFrame > SfxBindings::GetActiveFrame() const
+{
+    const css::uno::Reference< css::frame::XFrame > xFrame( pImpl->xProv, css::uno::UNO_QUERY );
+    if ( xFrame.is() || !pDispatcher )
+        return xFrame;
+    else
+        return pDispatcher->GetFrame()->GetFrame().GetFrameInterface();
+}
+
+void SfxBindings::SetDispatchProvider_Impl( const css::uno::Reference< css::frame::XDispatchProvider > & rProv )
+{
+    bool bInvalidate = ( rProv != pImpl->xProv );
+    if ( bInvalidate )
+    {
+        pImpl->xProv = rProv;
+        InvalidateAll( true );
+    }
+
+    if ( pImpl->pSubBindings )
+        pImpl->pSubBindings->SetDispatchProvider_Impl( pImpl->xProv );
+}
+
+const css::uno::Reference< css::frame::XDispatchRecorder >& SfxBindings::GetRecorder() const
+{
+    return pImpl->xRecorder;
+}
+
+void SfxBindings::SetRecorder_Impl( css::uno::Reference< css::frame::XDispatchRecorder > const & rRecorder )
+{
+    pImpl->xRecorder = rRecorder;
+}
+
+void SfxBindings::ContextChanged_Impl()
+{
+    if ( !pImpl->bInUpdate && ( !pImpl->bContextChanged || !pImpl->bAllMsgDirty ) )
+    {
+        InvalidateAll( true );
+    }
+}
+
+uno::Reference < frame::XDispatch > SfxBindings::GetDispatch( const SfxSlot* pSlot, const util::URL& aURL, bool bMasterCommand )
+{
+    uno::Reference < frame::XDispatch > xRet;
+    SfxStateCache* pCache = GetStateCache( pSlot->nSlotId );
+    if ( pCache && !bMasterCommand )
+        xRet = pCache->GetInternalDispatch();
+    if ( !xRet.is() )
+    {
+        // dispatches for slaves are unbound, they don't have a state
+        SfxOfficeDispatch* pDispatch = bMasterCommand ?
+            new SfxOfficeDispatch( pDispatcher, pSlot, aURL ) :
+            new SfxOfficeDispatch( *this, pDispatcher, pSlot, aURL );
+
+        pDispatch->SetMasterUnoCommand( bMasterCommand );
+        xRet.set( pDispatch );
+        if ( !pCache )
+            pCache = GetStateCache( pSlot->nSlotId );
+
+        DBG_ASSERT( pCache, "No cache for OfficeDispatch!" );
+        if ( pCache && !bMasterCommand )
+            pCache->SetInternalDispatch( xRet );
+    }
+
+    return xRet;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */