dispatch.cxx

Go to the documentation of this file.

/* -*- 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 <config_feature_desktop.h>
 
#include <algorithm>
#include <cstddef>
#include <deque>
#include <vector>
 
#include <stdlib.h>
 
#include <boost/property_tree/json_parser.hpp>
 
#include <com/sun/star/awt/PopupMenuDirection.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/frame/XDispatchRecorderSupplier.hpp>
#include <com/sun/star/frame/XLayoutManager.hpp>
#include <com/sun/star/frame/XPopupMenuController.hpp>
#include <com/sun/star/uno/XComponentContext.hpp>
#include <com/sun/star/ui/ContextMenuExecuteEvent.hpp>
 
#include <LibreOfficeKit/LibreOfficeKitEnums.h>
#include <comphelper/lok.hxx>
#include <comphelper/processfactory.hxx>
#include <comphelper/propertyvalue.hxx>
#include <rtl/strbuf.hxx>
#include <sal/log.hxx>
#include <sfx2/app.hxx>
#include <sfx2/bindings.hxx>
#include <sfx2/childwin.hxx>
#include <sfx2/dispatch.hxx>
#include <sfx2/docfile.hxx>
#include <hintpost.hxx>
#include <sfx2/ipclient.hxx>
#include <sfx2/module.hxx>
#include <sfx2/msg.hxx>
#include <sfx2/msgpool.hxx>
#include <sfx2/objface.hxx>
#include <sfx2/request.hxx>
#include <sfx2/sfxsids.hrc>
#include <sfx2/viewfrm.hxx>
#include <sfx2/viewsh.hxx>
#include <svl/eitem.hxx>
#include <svl/itemiter.hxx>
#include <svl/itempool.hxx>
#include <toolkit/awt/vclxmenu.hxx>
#include <toolkit/helper/vclunohelper.hxx>
#include <tools/debug.hxx>
#include <vcl/idle.hxx>
#include <vcl/menu.hxx>
 
#include <sfxtypes.hxx>
#include <slotserv.hxx>
#include <workwin.hxx>
 
typedef std::vector<SfxShell*> SfxShellStack_Impl;
 
namespace {
 
struct SfxToDo_Impl
{
    SfxShell*  pCluster;
    bool       bPush;
    bool       bDelete;
    bool       bDeleted;
    bool       bUntil;
 
    SfxToDo_Impl( bool bOpPush, bool bOpDelete, bool bOpUntil, SfxShell& rCluster )
        : pCluster(&rCluster)
        , bPush(bOpPush)
        , bDelete(bOpDelete)
        , bDeleted(false)
        , bUntil(bOpUntil)
                {}
};
 
struct SfxObjectBars_Impl
{
    ToolbarId          eId;      // ConfigId of the Toolbox
    sal_uInt16         nPos;
    SfxVisibilityFlags nFlags;   // special visibility flags
 
    SfxObjectBars_Impl() : eId(ToolbarId::None), nPos(0), nFlags(SfxVisibilityFlags::Invisible) {}
};
 
}
 
struct SfxDispatcher_Impl
{
    //When the dispatched is locked, SfxRequests accumulate in aReqArr for
    //later dispatch when unlocked via Post
 
    //The pointers are typically deleted in Post, only if we never get around
    //to posting them do we delete the unposted requests.
    std::vector<std::unique_ptr<SfxRequest>>
                         aReqArr;
    SfxShellStack_Impl   aStack;        // active functionality
    Idle                 aIdle { "sfx::SfxDispatcher_Impl aIdle" }; // for Flush
    std::deque<SfxToDo_Impl> aToDoStack;    // not processed Push/Pop
    SfxViewFrame*        pFrame;        // NULL or associated Frame
    tools::SvRef<SfxHintPoster>
                         xPoster;       // Execute asynchronous
    bool                 bFlushing;     // sal_True during Flush //?
    bool                 bUpdated;      // Update_Impl has run
    bool                 bLocked;       // No Execute
    bool                 bInvalidateOnUnlock;   // because someone asked
    bool                 bActive;       // not to be confused with set!
    bool*                pInCallAliveFlag;   // view the Destructor Stack
    SfxObjectBars_Impl   aObjBars[SFX_OBJECTBAR_MAX];
    SfxObjectBars_Impl   aFixedObjBars[SFX_OBJECTBAR_MAX];
    std::vector<sal_uInt32> aChildWins;
    bool                 bNoUI;         // UI only from Parent Dispatcher
    bool                 bReadOnly;     // Document is ReadOnly
    bool                 bQuiet;        // Only use parent dispatcher
 
    SfxSlotFilterState   nFilterEnabling; // 1==filter enabled slots,
                                          // 2==ReadOnlyDoc overturned
    o3tl::span<sal_uInt16 const>
                         pFilterSIDs;   // sorted Array of SIDs
    SfxDisableFlags      nDisableFlags;
    bool                 bFlushed;
    std::deque< std::deque<SfxToDo_Impl> > aToDoCopyStack;
};
 
bool SfxDispatcher::IsFlushed() const
{
     return xImp->bFlushed;
}
 
void SfxDispatcher::Flush()
{
    if (!xImp->bFlushed) FlushImpl();
}
 
void SfxDispatcher::Push(SfxShell& rShell)
 
{
    Pop( rShell, SfxDispatcherPopFlags::PUSH );
}
 
bool SfxDispatcher::IsActive(const SfxShell& rShell)
 
{
    return CheckVirtualStack(rShell);
}
 
bool SfxDispatcher::IsLocked() const
{
    return xImp->bLocked;
}
 
bool SfxDispatcher::IsAppDispatcher() const
{
    return !xImp->pFrame;
}
 
void SfxDispatcher::Call_Impl(SfxShell& rShell, const SfxSlot &rSlot, SfxRequest &rReq, bool bRecord)
{
    SFX_STACK(SfxDispatcher::Call_Impl);
 
    // The slot may be called (meaning enabled)
    if ( !rSlot.IsMode(SfxSlotMode::FASTCALL) && !rShell.CanExecuteSlot_Impl(rSlot) && !rShell.IsConditionalFastCall(rReq) )
        return;
 
    if ( GetFrame() )
    {
        // Recording may start
        css::uno::Reference< css::beans::XPropertySet > xSet(
                GetFrame()->GetFrame().GetFrameInterface(),
                css::uno::UNO_QUERY);
 
        if ( xSet.is() )
        {
            css::uno::Any aProp = xSet->getPropertyValue("DispatchRecorderSupplier");
            css::uno::Reference< css::frame::XDispatchRecorderSupplier > xSupplier;
            css::uno::Reference< css::frame::XDispatchRecorder > xRecorder;
            aProp >>= xSupplier;
            if(xSupplier.is())
                xRecorder = xSupplier->getDispatchRecorder();
 
            if ( bRecord && xRecorder.is() && !rSlot.IsMode(SfxSlotMode::NORECORD) )
                rReq.Record_Impl( rShell, rSlot, xRecorder, GetFrame() );
        }
    }
    // Get all that is needed, because the slot may not have survived the
    // Execute if it is a 'pseudo slot' for macros or verbs.
    bool bAutoUpdate = rSlot.IsMode(SfxSlotMode::AUTOUPDATE);
 
    // API-call parentheses and document-lock during the calls
    {
        // 'this' must respond in the Destructor
        bool bThisDispatcherAlive = true;
        bool *pOldInCallAliveFlag = xImp->pInCallAliveFlag;
        xImp->pInCallAliveFlag = &bThisDispatcherAlive;
 
        SfxExecFunc pFunc = rSlot.GetExecFnc();
        (*pFunc)(&rShell, rReq);
 
        // If 'this' is still alive
        if ( bThisDispatcherAlive )
            xImp->pInCallAliveFlag = pOldInCallAliveFlag;
        else
        {
            if ( pOldInCallAliveFlag )
            {
                // also protect nested stack frames
                *pOldInCallAliveFlag = false;
            }
 
            // do nothing after this object is dead
            return;
        }
    }
 
    if ( rReq.IsDone() )
    {
        SfxBindings *pBindings = GetBindings();
 
        // When AutoUpdate update immediately
        if ( bAutoUpdate && pBindings )
        {
            pBindings->Invalidate(rSlot.GetSlotId());
            pBindings->Update(rSlot.GetSlotId());
        }
    }
}
 
void SfxDispatcher::Construct_Impl()
{
    xImp.reset(new SfxDispatcher_Impl);
    xImp->bFlushed = true;
 
    xImp->bFlushing = false;
    xImp->bUpdated = false;
    xImp->bLocked = false;
    xImp->bActive = false;
    xImp->bNoUI = false;
    xImp->bReadOnly = false;
    xImp->bQuiet = false;
    xImp->pInCallAliveFlag = nullptr;
    xImp->nFilterEnabling = SfxSlotFilterState::DISABLED;
    xImp->nDisableFlags = SfxDisableFlags::NONE;
 
    xImp->bInvalidateOnUnlock = false;
 
    for (SfxObjectBars_Impl & rObjBar : xImp->aObjBars)
        rObjBar.eId = ToolbarId::None;
 
    xImp->xPoster = new SfxHintPoster(std::bind(&SfxDispatcher::PostMsgHandler, this, std::placeholders::_1));
 
    xImp->aIdle.SetPriority(TaskPriority::HIGH_IDLE );
    xImp->aIdle.SetInvokeHandler( LINK(this, SfxDispatcher, EventHdl_Impl ) );
}
 
SfxDispatcher::SfxDispatcher()
{
    Construct_Impl();
    xImp->pFrame = nullptr;
}
 
SfxDispatcher::SfxDispatcher(SfxViewFrame *pViewFrame)
{
    Construct_Impl();
    xImp->pFrame = pViewFrame;
}
 
SfxDispatcher::~SfxDispatcher()
{
    SAL_INFO("sfx.control", "Delete Dispatcher " << reinterpret_cast<sal_Int64>(this));
    DBG_ASSERT( !xImp->bActive, "deleting active Dispatcher" );
 
    // So that no timer by Reschedule in PlugComm strikes the LeaveRegistrations
    xImp->aIdle.Stop();
    xImp->xPoster->SetEventHdl( std::function<void (std::unique_ptr<SfxRequest>)>() );
 
    // Notify the stack variables in Call_Impl
    if ( xImp->pInCallAliveFlag )
        *xImp->pInCallAliveFlag = false;
 
    // Get bindings and application
    SfxApplication *pSfxApp = SfxGetpApp();
    SfxBindings* pBindings = GetBindings();
 
    // When not flushed, revive the bindings
    if (pBindings && !pSfxApp->IsDowning() && !xImp->bFlushed)
        pBindings->DLEAVEREGISTRATIONS();
 
    // may unregister the bindings
    while ( pBindings )
    {
        if ( pBindings->GetDispatcher_Impl() == this)
            pBindings->SetDispatcher(nullptr);
        pBindings = pBindings->GetSubBindings_Impl();
    }
}
 
void SfxDispatcher::Pop(SfxShell& rShell, SfxDispatcherPopFlags nMode)
{
    DBG_ASSERT( rShell.GetInterface(),
                "pushing SfxShell without previous RegisterInterface()" );
 
    bool bDelete = bool(nMode & SfxDispatcherPopFlags::POP_DELETE);
    bool bUntil = bool(nMode & SfxDispatcherPopFlags::POP_UNTIL);
    bool bPush = bool(nMode & SfxDispatcherPopFlags::PUSH);
 
    SfxApplication *pSfxApp = SfxGetpApp();
 
    SAL_INFO(
        "sfx.control",
        "-SfxDispatcher(" << this << (bPush ? ")::Push(" : ")::Pop(")
            << (rShell.GetInterface()
                ? rShell.GetInterface()->GetClassName() : SAL_STREAM(&rShell))
            << (bDelete ? ") with delete" : ")")
            << (bUntil ? " (up to)" : ""));
 
    // same shell as on top of the to-do stack?
    if(!xImp->aToDoStack.empty() && xImp->aToDoStack.front().pCluster == &rShell)
    {
        // cancel inverse actions
        if ( xImp->aToDoStack.front().bPush != bPush )
            xImp->aToDoStack.pop_front();
        else
        {
            DBG_ASSERT( bPush, "SfxInterface pushed more than once" );
            DBG_ASSERT( !bPush, "SfxInterface popped more than once" );
        }
    }
    else
    {
        // Remember Action
        xImp->aToDoStack.push_front( SfxToDo_Impl(bPush, bDelete, bUntil, rShell) );
        if (xImp->bFlushed)
        {
            SAL_INFO("sfx.control", "Unflushed dispatcher!");
            xImp->bFlushed = false;
            xImp->bUpdated = false;
 
            // Put bindings to sleep
            SfxBindings* pBindings = GetBindings();
            if ( pBindings )
                pBindings->DENTERREGISTRATIONS();
        }
    }
 
    if(!pSfxApp->IsDowning() && !xImp->aToDoStack.empty())
    {
        // No immediate update is requested
        xImp->aIdle.Start();
    }
    else
    {
        // but to do nothing
        xImp->aIdle.Stop();
 
        // Bindings may wake up again
        if(xImp->aToDoStack.empty())
        {
            SfxBindings* pBindings = GetBindings();
            if ( pBindings )
                pBindings->DLEAVEREGISTRATIONS();
        }
    }
}
 
 
IMPL_LINK_NOARG( SfxDispatcher, EventHdl_Impl, Timer *, void )
{
    Flush();
    Update_Impl();
    SfxBindings* pBindings = GetBindings();
    if ( pBindings )
        pBindings->StartUpdate_Impl();
}
 
bool SfxDispatcher::CheckVirtualStack(const SfxShell& rShell)
{
    SFX_STACK(SfxDispatcher::CheckVirtualStack);
 
    SfxShellStack_Impl aStack( xImp->aStack );
    for(std::deque<SfxToDo_Impl>::reverse_iterator i = xImp->aToDoStack.rbegin(); i != xImp->aToDoStack.rend(); ++i)
    {
        if(i->bPush)
            aStack.push_back(i->pCluster);
        else
        {
            SfxShell* pPopped(nullptr);
            do
            {
                DBG_ASSERT( !aStack.empty(), "popping from empty stack" );
                pPopped = aStack.back();
                aStack.pop_back();
            }
            while(i->bUntil && pPopped != i->pCluster);
            DBG_ASSERT(pPopped == i->pCluster, "popping unpushed SfxInterface");
        }
    }
 
    bool bReturn = std::find(aStack.begin(), aStack.end(), &rShell) != aStack.end();
    return bReturn;
}
 
sal_uInt16 SfxDispatcher::GetShellLevel(const SfxShell& rShell)
{
    SFX_STACK(SfxDispatcher::GetShellLevel);
    Flush();
 
    for ( size_t n = 0; n < xImp->aStack.size(); ++n )
        if ( *( xImp->aStack.rbegin() + n ) == &rShell )
            return n;
 
    return USHRT_MAX;
}
 
SfxShell *SfxDispatcher::GetShell(sal_uInt16 nIdx) const
{
    sal_uInt16 nShellCount = xImp->aStack.size();
    if ( nIdx < nShellCount )
        return *(xImp->aStack.rbegin() + nIdx);
    return nullptr;
}
 
SfxBindings* SfxDispatcher::GetBindings() const
{
    if ( xImp->pFrame )
        return &xImp->pFrame->GetBindings();
    else
        return nullptr;
}
 
SfxViewFrame* SfxDispatcher::GetFrame() const
{
    return xImp->pFrame;
}
 
void SfxDispatcher::DoActivate_Impl(bool bMDI)
{
    SFX_STACK(SfxDispatcher::DoActivate);
    if ( bMDI )
    {
        SAL_INFO("sfx.control", "Activate Dispatcher " << reinterpret_cast<sal_Int64>(this));
        DBG_ASSERT( !xImp->bActive, "Activation error" );
 
        xImp->bActive = true;
        xImp->bUpdated = false;
        SfxBindings* pBindings = GetBindings();
        if ( pBindings )
        {
            pBindings->SetDispatcher(this);
            pBindings->SetActiveFrame( xImp->pFrame->GetFrame().GetFrameInterface() );
        }
    }
    else
    {
        SAL_INFO("sfx.control", "Non-MDI-Activate Dispatcher " << reinterpret_cast<sal_Int64>(this));
    }
 
    if ( IsAppDispatcher() )
        return;
 
    for ( int i = int(xImp->aStack.size()) - 1; i >= 0; --i )
        (*(xImp->aStack.rbegin() + i ))->DoActivate_Impl(xImp->pFrame, bMDI);
 
    if ( bMDI && xImp->pFrame )
    {
        xImp->pFrame->GetFrame().GetWorkWindow_Impl()->HidePopups_Impl( false, 1 );
    }
 
    if(!xImp->aToDoStack.empty())
    {
        // No immediate update is requested
        xImp->aIdle.Start();
    }
}
 
void SfxDispatcher::DoDeactivate_Impl(bool bMDI, SfxViewFrame const * pNew)
{
    SFX_STACK(SfxDispatcher::DoDeactivate);
 
    SfxApplication *pSfxApp = SfxGetpApp();
 
    if ( bMDI )
    {
        SAL_INFO("sfx.control", "Deactivate Dispatcher " << this);
        DBG_ASSERT( xImp->bActive, "Deactivate error" );
        xImp->bActive = false;
 
        if ( xImp->pFrame && !(xImp->pFrame->GetObjectShell()->IsInPlaceActive() ) )
        {
            SfxWorkWindow *pWorkWin = xImp->pFrame->GetFrame().GetWorkWindow_Impl();
            if ( pWorkWin )
            {
                for (size_t n=0; n<xImp->aChildWins.size();)
                {
                    SfxChildWindow *pWin = pWorkWin->GetChildWindow_Impl( static_cast<sal_uInt16>( xImp->aChildWins[n] & 0xFFFF ) );
                    if (!pWin || pWin->GetAlignment() == SfxChildAlignment::NOALIGNMENT)
                        xImp->aChildWins.erase(xImp->aChildWins.begin()+n);
                    else
                        n++;
                }
            }
        }
    }
    else {
        SAL_INFO("sfx.control", "Non-MDI-DeActivate Dispatcher " << this);
    }
 
    if ( IsAppDispatcher() && !pSfxApp->IsDowning() )
        return;
 
    for ( size_t i = 0; i < xImp->aStack.size(); ++i )
        (*(xImp->aStack.rbegin() + i))->DoDeactivate_Impl(xImp->pFrame, bMDI);
 
    bool bHidePopups = bMDI && xImp->pFrame;
    if ( pNew && xImp->pFrame )
    {
        css::uno::Reference< css::frame::XFrame > xOldFrame =
            pNew->GetFrame().GetFrameInterface()->getCreator();
 
        css::uno::Reference< css::frame::XFrame > xMyFrame =
            GetFrame()->GetFrame().GetFrameInterface();
 
        if ( xOldFrame == xMyFrame )
            bHidePopups = false;
    }
 
    if ( bHidePopups )
    {
        xImp->pFrame->GetFrame().GetWorkWindow_Impl()->HidePopups_Impl( true, 1 );
    }
 
    Flush();
}
 
bool SfxDispatcher::GetShellAndSlot_Impl(sal_uInt16 nSlot, SfxShell** ppShell,
        const SfxSlot** ppSlot, bool bOwnShellsOnly, bool bRealSlot)
{
    SFX_STACK(SfxDispatcher::GetShellAndSlot_Impl);
 
    Flush();
    SfxSlotServer aSvr;
    if ( FindServer_(nSlot, aSvr) )
    {
        if ( bOwnShellsOnly && aSvr.GetShellLevel() >= xImp->aStack.size() )
            return false;
 
        *ppShell = GetShell(aSvr.GetShellLevel());
        *ppSlot = aSvr.GetSlot();
        if ( nullptr == (*ppSlot)->GetExecFnc() && bRealSlot )
            *ppSlot = (*ppShell)->GetInterface()->GetRealSlot(*ppSlot);
        // Check only real slots as enum slots don't have an execute function!
        return !bRealSlot || ((nullptr != *ppSlot) && (nullptr != (*ppSlot)->GetExecFnc()) );
    }
 
    return false;
}
 
void SfxDispatcher::Execute_(SfxShell& rShell, const SfxSlot& rSlot,
        SfxRequest& rReq, SfxCallMode eCallMode)
{
    SFX_STACK(SfxDispatcher::Execute_);
    DBG_ASSERT( !xImp->bFlushing, "recursive call to dispatcher" );
    DBG_ASSERT( xImp->aToDoStack.empty(), "unprepared InPlace _Execute" );
 
    if ( IsLocked() )
        return;
 
    if ( bool(eCallMode & SfxCallMode::ASYNCHRON) ||
         ( (eCallMode & SfxCallMode::SYNCHRON) == SfxCallMode::SLOT &&
           rSlot.IsMode(SfxSlotMode::ASYNCHRON) ) )
    {
        sal_uInt16 nShellCount = xImp->aStack.size();
        for ( sal_uInt16 n=0; n<nShellCount; n++ )
        {
            if ( &rShell == *(xImp->aStack.rbegin() + n) )
            {
                if ( bool(eCallMode & SfxCallMode::RECORD) )
                    rReq.AllowRecording( true );
                xImp->xPoster->Post(std::make_unique<SfxRequest>(rReq));
                return;
            }
        }
    }
    else
        Call_Impl( rShell, rSlot, rReq, SfxCallMode::RECORD==(eCallMode&SfxCallMode::RECORD) );
}
 
static void MappedPut_Impl(SfxAllItemSet &rSet, const SfxPoolItem &rItem)
{
    // Put with mapped Which-Id if possible
    const SfxItemPool *pPool = rSet.GetPool();
    sal_uInt16 nWhich = rItem.Which();
    if ( SfxItemPool::IsSlot(nWhich) )
        nWhich = pPool->GetWhich(nWhich);
    rSet.Put( rItem, nWhich );
}
 
const SfxSlot* SfxDispatcher::GetSlot( const OUString& rCommand )
{
    // Count the number of Shells on the linked Dispatcher
    Flush();
    sal_uInt16 nTotCount = xImp->aStack.size();
 
    for ( sal_uInt16 i = 0; i < nTotCount; ++i )
    {
        if (SfxShell *pObjShell = GetShell(i))
        {
            SfxInterface *pIFace = pObjShell->GetInterface();
            const SfxSlot *pSlot = pIFace->GetSlot( rCommand );
            if ( pSlot )
                return pSlot;
        }
    }
 
    return nullptr;
}
 
const SfxPoolItem* SfxDispatcher::Execute(sal_uInt16 nSlot, SfxCallMode nCall,
        SfxItemSet const * pArgs, SfxItemSet const * pInternalArgs, sal_uInt16 nModi)
{
    if ( IsLocked() )
        return nullptr;
 
    SfxShell *pShell = nullptr;
    const SfxSlot *pSlot = nullptr;
    if ( GetShellAndSlot_Impl( nSlot,  &pShell, &pSlot, false, true ) )
    {
        SfxAllItemSet aSet( pShell->GetPool() );
        if ( pArgs )
        {
            SfxItemIter aIter(*pArgs);
            for ( const SfxPoolItem *pArg = aIter.GetCurItem();
                pArg;
                pArg = aIter.NextItem() )
                MappedPut_Impl( aSet, *pArg );
        }
        SfxRequest aReq(nSlot, nCall, aSet);
        if (pInternalArgs)
            aReq.SetInternalArgs_Impl( *pInternalArgs );
        aReq.SetModifier( nModi );
 
        Execute_( *pShell, *pSlot, aReq, nCall );
        return aReq.GetReturnValue();
    }
    return nullptr;
}
 
const SfxPoolItem* SfxDispatcher::Execute(sal_uInt16 nSlot, SfxCallMode eCall,
        const SfxPoolItem **pArgs, sal_uInt16 nModi, const SfxPoolItem **pInternalArgs)
{
    if ( IsLocked() )
        return nullptr;
 
    SfxShell *pShell = nullptr;
    const SfxSlot *pSlot = nullptr;
    if ( GetShellAndSlot_Impl( nSlot,  &pShell, &pSlot, false, true ) )
    {
        std::unique_ptr<SfxRequest> pReq;
        if ( pArgs && *pArgs )
        {
            SfxAllItemSet aSet( pShell->GetPool() );
            for ( const SfxPoolItem **pArg = pArgs; *pArg; ++pArg )
                MappedPut_Impl( aSet, **pArg );
            pReq.reset(new SfxRequest( nSlot, eCall, aSet ));
        }
        else
            pReq.reset(new SfxRequest( nSlot, eCall, pShell->GetPool() ));
        pReq->SetModifier( nModi );
        if( pInternalArgs && *pInternalArgs)
        {
            SfxAllItemSet aSet( SfxGetpApp()->GetPool() );
            for ( const SfxPoolItem **pArg = pInternalArgs; *pArg; ++pArg )
                aSet.Put( **pArg );
            pReq->SetInternalArgs_Impl( aSet );
        }
        Execute_( *pShell, *pSlot, *pReq, eCall );
        const SfxPoolItem* pRet = pReq->GetReturnValue();
        return pRet;
    }
    return nullptr;
}
 
const SfxPoolItem* SfxDispatcher::Execute(sal_uInt16 nSlot, SfxCallMode eCall,
        const SfxItemSet &rArgs)
{
    if ( IsLocked() )
        return nullptr;
 
    SfxShell *pShell = nullptr;
    const SfxSlot *pSlot = nullptr;
    if ( GetShellAndSlot_Impl( nSlot,  &pShell, &pSlot, false, true ) )
    {
        SfxAllItemSet aSet( pShell->GetPool() );
        SfxItemIter aIter(rArgs);
        for ( const SfxPoolItem *pArg = aIter.GetCurItem();
              pArg;
              pArg = aIter.NextItem() )
            MappedPut_Impl( aSet, *pArg );
        SfxRequest aReq( nSlot, eCall, aSet );
        aReq.SetModifier( 0 );
        Execute_( *pShell, *pSlot, aReq, eCall );
        return aReq.GetReturnValue();
    }
    return nullptr;
}
 
const SfxPoolItem* SfxDispatcher::ExecuteList(sal_uInt16 nSlot, SfxCallMode eCall,
        std::initializer_list<SfxPoolItem const*> args,
        std::initializer_list<SfxPoolItem const*> internalargs)
{
    if ( IsLocked() )
        return nullptr;
 
    SfxShell *pShell = nullptr;
    const SfxSlot *pSlot = nullptr;
    if ( GetShellAndSlot_Impl( nSlot, &pShell, &pSlot, false, true ) )
    {
       SfxAllItemSet aSet( pShell->GetPool() );
 
       for (const SfxPoolItem *pArg : args)
       {
           assert(pArg);
           MappedPut_Impl( aSet, *pArg );
       }
 
       SfxRequest aReq(nSlot, eCall, aSet);
 
       if (internalargs.begin() != internalargs.end())
       {
           SfxAllItemSet aInternalSet(SfxGetpApp()->GetPool());
           for (const SfxPoolItem *pArg : internalargs)
           {
               assert(pArg);
               aInternalSet.Put(*pArg);
           }
           aReq.SetInternalArgs_Impl(aInternalSet);
       }
 
       Execute_( *pShell, *pSlot, aReq, eCall );
       return aReq.GetReturnValue();
    }
    return nullptr;
}
 
void SfxDispatcher::PostMsgHandler(std::unique_ptr<SfxRequest> pReq)
{
    DBG_ASSERT( !xImp->bFlushing, "recursive call to dispatcher" );
    SFX_STACK(SfxDispatcher::PostMsgHandler);
 
    // Has also the Pool not yet died?
    if ( pReq->IsCancelled() )
        return;
 
    if ( !IsLocked() )
    {
        Flush();
        SfxSlotServer aSvr;
        if ( FindServer_(pReq->GetSlot(), aSvr ) ) // HACK(x), whatever that was supposed to mean
        {
            const SfxSlot *pSlot = aSvr.GetSlot();
            SfxShell *pSh = GetShell(aSvr.GetShellLevel());
 
            // When the pSlot is a "Pseudoslot" for macros or Verbs, it can
            // be destroyed in the Call_Impl, thus do not use it anymore!
            pReq->SetSynchronCall( false );
            Call_Impl( *pSh, *pSlot, *pReq, pReq->AllowsRecording() ); 
        }
    }
    else
    {
        if ( xImp->bLocked )
            xImp->aReqArr.emplace_back(std::move(pReq));
        else
            xImp->xPoster->Post(std::move(pReq));
    }
}
 
void SfxDispatcher::SetMenu_Impl()
{
#if HAVE_FEATURE_DESKTOP
    if ( !xImp->pFrame )
        return;
 
    SfxViewFrame* pTop = xImp->pFrame->GetTopViewFrame();
    if ( !pTop || pTop->GetBindings().GetDispatcher() != this )
        return;
 
    SfxFrame& rFrame = pTop->GetFrame();
    if ( !rFrame.IsMenuBarOn_Impl() )
        return;
 
    css::uno::Reference < css::beans::XPropertySet > xPropSet( rFrame.GetFrameInterface(), css::uno::UNO_QUERY );
    if ( xPropSet.is() )
    {
        css::uno::Reference< css::frame::XLayoutManager > xLayoutManager;
        css::uno::Any aValue = xPropSet->getPropertyValue("LayoutManager");
        aValue >>= xLayoutManager;
        if ( xLayoutManager.is() )
        {
            OUString aMenuBarURL( "private:resource/menubar/menubar" );
            if ( !xLayoutManager->isElementVisible( aMenuBarURL ) )
                xLayoutManager->createElement( aMenuBarURL );
        }
    }
#endif
}
 
void SfxDispatcher::Update_Impl( bool bForce )
{
    SFX_STACK(SfxDispatcher::Update_Impl);
 
    Flush();
 
    if ( !xImp->pFrame )
        return;
 
    bool bUpdate = bForce;
    if ( xImp->pFrame )
    {
        SfxWorkWindow *pWork = xImp->pFrame->GetFrame().GetWorkWindow_Impl();
        SfxDispatcher *pAct = pWork->GetBindings().GetDispatcher_Impl();
        if (pAct == this)
        {
            if ( !bUpdate )
                bUpdate = !xImp->bUpdated;
            xImp->bUpdated = true;
        }
    }
 
    if ( !bUpdate || xImp->pFrame->GetFrame().IsClosing_Impl() )
        return;
 
    SfxViewFrame* pTop = xImp->pFrame ? xImp->pFrame->GetTopViewFrame() : nullptr;
    bool bUIActive = pTop && pTop->GetBindings().GetDispatcher() == this;
 
    if ( !bUIActive && pTop && GetBindings() == &pTop->GetBindings() )
        // keep own tools internally for collecting
        GetBindings()->GetDispatcher()->xImp->bUpdated = false;
 
    css::uno::Reference< css::frame::XFrame > xFrame;
    SfxBindings* pBindings = GetBindings();
    if (pBindings)
    {
        pBindings->DENTERREGISTRATIONS();
        xFrame = pBindings->GetActiveFrame();
    }
    css::uno::Reference< css::beans::XPropertySet > xPropSet( xFrame, css::uno::UNO_QUERY );
    css::uno::Reference< css::frame::XLayoutManager > xLayoutManager;
    if ( xPropSet.is() )
    {
        try
        {
            css::uno::Any aValue = xPropSet->getPropertyValue("LayoutManager");
            aValue >>= xLayoutManager;
        }
        catch (const css::uno::Exception&)
        {
        }
    }
 
    if ( xLayoutManager.is() )
        xLayoutManager->lock();
 
    bool bIsIPActive = xImp->pFrame && xImp->pFrame->GetObjectShell()->IsInPlaceActive();
    SfxInPlaceClient *pClient = xImp->pFrame ? xImp->pFrame->GetViewShell()->GetUIActiveClient() : nullptr;
    if ( bUIActive && /* !bIsIPActive && */ ( !pClient || !pClient->IsObjectUIActive() ) )
        SetMenu_Impl();
 
    SfxWorkWindow *pWorkWin = xImp->pFrame->GetFrame().GetWorkWindow_Impl();
    pWorkWin->ResetStatusBar_Impl();
 
    {
        SfxWorkWindow *pWork = xImp->pFrame->GetFrame().GetWorkWindow_Impl();
        SfxDispatcher *pAct = pWork->GetBindings().GetDispatcher_Impl();
        if (pAct == this)
        {
            pWork->ResetObjectBars_Impl();
            pWork->ResetChildWindows_Impl();
        }
    }
 
    bool bIsActive = false;
    SfxDispatcher *pActDispat = pWorkWin->GetBindings().GetDispatcher_Impl();
    if ( !bIsActive && this == pActDispat )
        bIsActive = true;
 
    Update_Impl_( bUIActive, !bIsIPActive, bIsIPActive, pWorkWin );
    if (bUIActive || bIsActive)
        pWorkWin->UpdateObjectBars_Impl();
 
    if ( pBindings )
        pBindings->DLEAVEREGISTRATIONS();
 
    if ( xLayoutManager.is() )
        xLayoutManager->unlock();
 
    if ( SfxViewShell::Current() && SfxViewShell::Current()->GetDispatcher() )
    {
        const SfxPoolItem *pItem;
        SfxViewShell::Current()->GetDispatcher()->QueryState(SID_NOTEBOOKBAR, pItem);
    }
}
 
void SfxDispatcher::Update_Impl_( bool bUIActive, bool bIsMDIApp, bool bIsIPOwner, SfxWorkWindow *pTaskWin )
{
    SfxWorkWindow *pWorkWin = xImp->pFrame->GetFrame().GetWorkWindow_Impl();
    bool bIsActive = false;
    SfxDispatcher *pActDispat = pWorkWin->GetBindings().GetDispatcher_Impl();
    if ( pActDispat && !bIsActive )
    {
        if ( this == pActDispat )
            bIsActive = true;
    }
 
    for (SfxObjectBars_Impl & rObjBar : xImp->aObjBars)
        rObjBar.eId = ToolbarId::None;
    xImp->aChildWins.clear();
 
    // bQuiet: own shells aren't considered for UI and SlotServer
    // bNoUI: own Shells aren't considered forms UI
    if ( xImp->bQuiet || xImp->bNoUI || (xImp->pFrame && xImp->pFrame->GetObjectShell()->IsPreview()) )
        return;
 
    StatusBarId eStatBarId = StatusBarId::None;
 
    SfxSlotPool* pSlotPool = &SfxSlotPool::GetSlotPool( GetFrame() );
    sal_uInt16 nTotCount = xImp->aStack.size();
    for ( sal_uInt16 nShell = nTotCount; nShell > 0; --nShell )
    {
        SfxShell *pShell = GetShell( nShell-1 );
        if (!pShell)
            continue;
 
        SfxInterface *pIFace = pShell->GetInterface();
 
        // don't consider shells if "Hidden" or "Quiet"
        bool bReadOnlyShell = IsReadOnlyShell_Impl( nShell-1 );
        sal_uInt16 nNo;
        for ( nNo = 0; pIFace && nNo<pIFace->GetObjectBarCount(); ++nNo )
        {
            sal_uInt16 nPos = pIFace->GetObjectBarPos(nNo);
            SfxVisibilityFlags nFlags = pIFace->GetObjectBarFlags(nNo);
            if ( bReadOnlyShell && !( nFlags & SfxVisibilityFlags::ReadonlyDoc ) )
                continue;
 
            // check whether toolbar needs activation of a special feature
            SfxShellFeature nFeature = pIFace->GetObjectBarFeature(nNo);
            if ((nFeature != SfxShellFeature::NONE) && !pShell->HasUIFeature(nFeature))
                continue;
 
            // check for toolboxes that are exclusively for a viewer
            if ( xImp->pFrame)
            {
                bool bViewerTbx( nFlags & SfxVisibilityFlags::Viewer );
                SfxObjectShell* pSh = xImp->pFrame->GetObjectShell();
                const SfxBoolItem* pItem = pSh->GetMedium()->GetItemSet().GetItem(SID_VIEWONLY, false);
                bool bIsViewer = pItem && pItem->GetValue();
                if ( bIsViewer != bViewerTbx )
                    continue;
            }
 
            // always register toolbars, allows to switch them on
            bool bVisible = pIFace->IsObjectBarVisible(nNo);
            if ( !bVisible )
                nFlags = SfxVisibilityFlags::Invisible;
 
            SfxObjectBars_Impl& rBar = xImp->aObjBars[nPos];
            rBar.nPos = nPos;
            rBar.nFlags = nFlags;
            rBar.eId = pIFace->GetObjectBarId(nNo);
 
            if ( bUIActive || bIsActive )
            {
                pWorkWin->SetObjectBar_Impl(nPos, nFlags, rBar.eId);
            }
 
            if ( !bVisible )
                rBar.eId = ToolbarId::None;
        }
 
        for ( nNo=0; pIFace && nNo<pIFace->GetChildWindowCount(); nNo++ )
        {
            sal_uInt32 nId = pIFace->GetChildWindowId(nNo);
            const SfxSlot *pSlot = pSlotPool->GetSlot( static_cast<sal_uInt16>(nId) );
            SAL_WARN_IF( !pSlot, "sfx.control", "Childwindow slot missing: " << nId );
            if ( bReadOnlyShell )
            {
                // only show ChildWindows if their slot is allowed for readonly documents
                if ( pSlot && !pSlot->IsMode( SfxSlotMode::READONLYDOC ) )
                    continue;
            }
 
            SfxShellFeature nFeature = pIFace->GetChildWindowFeature(nNo);
            if ((nFeature != SfxShellFeature::NONE) && !pShell->HasUIFeature(nFeature))
                continue;
 
            // slot decides whether a ChildWindow is shown when document is OLE server or OLE client
            SfxVisibilityFlags nMode = SfxVisibilityFlags::Standard;
            if( pSlot )
            {
                if ( pSlot->IsMode(SfxSlotMode::CONTAINER) )
                {
                    if ( pWorkWin->IsVisible_Impl( SfxVisibilityFlags::Client ) )
                        nMode |= SfxVisibilityFlags::Client;
                }
                else
                {
                    if ( pWorkWin->IsVisible_Impl( SfxVisibilityFlags::Server ) )
                        nMode |= SfxVisibilityFlags::Server;
                }
            }
 
            if ( bUIActive || bIsActive )
                pWorkWin->SetChildWindowVisible_Impl( nId, true, nMode );
            if ( bUIActive || bIsActive || !pWorkWin->IsFloating( static_cast<sal_uInt16>( nId & 0xFFFF ) ) )
                xImp->aChildWins.push_back( nId );
        }
 
        if ( bIsMDIApp || bIsIPOwner )
        {
            StatusBarId eId = pIFace ? pIFace->GetStatusBarId() : StatusBarId::None;
            if (eId != StatusBarId::None)
                eStatBarId = eId;
        }
    }
 
    for ( sal_uInt16 nPos=0; nPos<SFX_OBJECTBAR_MAX; nPos++ )
    {
        SfxObjectBars_Impl& rFixed = xImp->aFixedObjBars[nPos];
        if (rFixed.eId != ToolbarId::None)
        {
            SfxObjectBars_Impl& rBar = xImp->aObjBars[nPos];
            rBar = rFixed;
            pWorkWin->SetObjectBar_Impl(rFixed.nPos, rFixed.nFlags,
                rFixed.eId);
        }
    }
 
    if ( !pTaskWin || ( !bIsMDIApp && !bIsIPOwner ) )
        return;
 
    bool bIsTaskActive = false;
 
    SfxDispatcher *pActDispatcher = pTaskWin->GetBindings().GetDispatcher_Impl();
    if ( pActDispatcher && !bIsTaskActive )
    {
        if ( this == pActDispatcher )
            bIsTaskActive = true;
    }
 
    if (bIsTaskActive && eStatBarId != StatusBarId::None && xImp->pFrame)
    {
        // internal frames also may control statusbar
        xImp->pFrame->GetFrame().GetWorkWindow_Impl()->SetStatusBar_Impl(eStatBarId);
    }
}
 
void SfxDispatcher::FlushImpl()
{
    SFX_STACK(SfxDispatcher::FlushImpl);
 
    SAL_INFO("sfx.control", "Flushing dispatcher!");
 
    xImp->aIdle.Stop();
 
    xImp->bFlushing = !xImp->bFlushing;
    if ( !xImp->bFlushing )
    {
        xImp->bFlushing = true;
        return;
    }
 
    SfxApplication *pSfxApp = SfxGetpApp();
 
    // Re-build the true stack in the first round
    std::deque<SfxToDo_Impl> aToDoCopy;
    bool bModify = false;
    for(std::deque<SfxToDo_Impl>::reverse_iterator i = xImp->aToDoStack.rbegin(); i != xImp->aToDoStack.rend(); ++i)
    {
        bModify = true;
 
        if(i->bPush)
        {
            // Actually push
            DBG_ASSERT( std::find(xImp->aStack.begin(), xImp->aStack.end(), i->pCluster) == xImp->aStack.end(),
                       "pushed SfxShell already on stack" );
            xImp->aStack.push_back(i->pCluster);
            i->pCluster->SetDisableFlags(xImp->nDisableFlags);
 
            // Mark the moved shell
            aToDoCopy.push_front(*i);
        }
        else
        {
            // Actually pop
            bool bFound = false;
            if (!i->bUntil)
            {
                // pop exactly the requested shell
                if (auto it = std::find(xImp->aStack.begin(), xImp->aStack.end(), i->pCluster);
                    it != xImp->aStack.end())
                {
                    xImp->aStack.erase(it);
                    i->pCluster->SetDisableFlags(SfxDisableFlags::NONE);
                    bFound = true;
 
                    // Mark the moved Shell
                    aToDoCopy.push_front(SfxToDo_Impl(false, i->bDelete, false, *i->pCluster));
                }
            }
            while (!bFound)
            {
                DBG_ASSERT( !xImp->aStack.empty(), "popping from empty stack" );
                SfxShell* pPopped = xImp->aStack.back();
                xImp->aStack.pop_back();
                pPopped->SetDisableFlags( SfxDisableFlags::NONE );
                bFound = (pPopped == i->pCluster);
 
                // Mark the moved Shell
                aToDoCopy.push_front(SfxToDo_Impl(false, i->bDelete, false, *pPopped));
                if (!i->bUntil)
                {
                    // We get here only when the requested shell was not on the stack.
                    // I don't know how correct to pop a single random other shell and exit
                    // in this case, but I just make sure that the previous logic is kept.
                    break;
                }
            }
            DBG_ASSERT( bFound, "wrong SfxShell popped" );
        }
    }
    xImp->aToDoStack.clear();
 
    // Invalidate bindings, if possible
    if ( !pSfxApp->IsDowning() )
    {
        InvalidateBindings_Impl( bModify );
    }
 
    xImp->bFlushing = false;
    xImp->bUpdated = false; // not only when bModify, if Doc/Template-Config
    xImp->bFlushed = true;
    SAL_INFO("sfx.control", "Successfully flushed dispatcher!");
 
    //fdo#70703 FlushImpl may call back into itself so use aToDoCopyStack to talk
    //to outer levels of ourself. If DoActivate_Impl/DoDeactivate_Impl deletes
    //an entry, then they will walk back up aToDoCopyStack and set outer
    //levels's entries to bDeleted
    xImp->aToDoCopyStack.push_back(aToDoCopy);
    std::deque<SfxToDo_Impl>& rToDoCopy = xImp->aToDoCopyStack.back();
    // Activate the Shells and possible delete them in the 2nd round
    for(std::deque<SfxToDo_Impl>::reverse_iterator i = rToDoCopy.rbegin(); i != rToDoCopy.rend(); ++i)
    {
        if (i->bDeleted)
            continue;
        if (!xImp->bActive)
            continue;
        if (i->bPush)
            i->pCluster->DoActivate_Impl(xImp->pFrame, true);
        else
            i->pCluster->DoDeactivate_Impl(xImp->pFrame, true);
    }
 
    aToDoCopy = xImp->aToDoCopyStack.back();
    xImp->aToDoCopyStack.pop_back();
 
    for(std::deque<SfxToDo_Impl>::reverse_iterator i = aToDoCopy.rbegin(); i != aToDoCopy.rend(); ++i)
    {
        if (i->bDelete && !i->bDeleted)
        {
            if (!xImp->aToDoCopyStack.empty())
            {
                //fdo#70703 if there is an outer FlushImpl then inform it that
                //we have deleted this cluster
                for (auto & elem : xImp->aToDoCopyStack)
                {
                    for (auto & subelem : elem)
                    {
                        if (subelem.pCluster == i->pCluster)
                            subelem.bDeleted = true;
                    }
                }
            }
            delete i->pCluster;
        }
    }
    bool bAwakeBindings = !aToDoCopy.empty();
    if( bAwakeBindings )
        aToDoCopy.clear();
 
    // If more changes have occurred on the stack when
    // Activate/Deactivate/Delete:
    if (!xImp->bFlushed)
        // If Push/Pop has been called by someone, then also EnterReg was called!
        FlushImpl();
 
    if( bAwakeBindings && GetBindings() )
        GetBindings()->DLEAVEREGISTRATIONS();
 
    for (SfxObjectBars_Impl & rFixedObjBar : xImp->aFixedObjBars)
        rFixedObjBar.eId = ToolbarId::None;
 
    SAL_INFO("sfx.control", "SfxDispatcher(" << this << ")::Flush() done");
}
 
void SfxDispatcher::SetSlotFilter(SfxSlotFilterState nEnable,
        o3tl::span<sal_uInt16 const> pSIDs)
{
#ifdef DBG_UTIL
    // Check Array
    for ( std::size_t n = 1; n < pSIDs.size(); ++n )
        DBG_ASSERT( pSIDs[n] > pSIDs[n-1], "SetSlotFilter: SIDs not sorted" );
#endif
 
    xImp->nFilterEnabling = nEnable;
    xImp->pFilterSIDs = pSIDs;
 
    GetBindings()->InvalidateAll(true);
}
 
extern "C" {
 
static int SfxCompareSIDs_Impl(const void* pSmaller, const void* pBigger)
{
    return static_cast<tools::Long>(*static_cast<sal_uInt16 const *>(pSmaller)) - static_cast<tools::Long>(*static_cast<sal_uInt16 const *>(pBigger));
}
 
}
 
SfxSlotFilterState SfxDispatcher::IsSlotEnabledByFilter_Impl( sal_uInt16 nSID ) const
{
    // no filter?
    if ( xImp->pFilterSIDs.empty() )
        // => all SIDs allowed
        return SfxSlotFilterState::ENABLED;
 
    // search
    bool bFound = nullptr != bsearch( &nSID, xImp->pFilterSIDs.data(), xImp->pFilterSIDs.size(),
                                sizeof(sal_uInt16), SfxCompareSIDs_Impl );
 
    // even if ReadOnlyDoc
    if ( SfxSlotFilterState::ENABLED_READONLY == xImp->nFilterEnabling )
        return bFound ? SfxSlotFilterState::ENABLED_READONLY : SfxSlotFilterState::ENABLED;
    // Otherwise after Negative/Positive Filter
    else if ( SfxSlotFilterState::ENABLED == xImp->nFilterEnabling )
        return bFound ? SfxSlotFilterState::ENABLED : SfxSlotFilterState::DISABLED;
    else
        return bFound ? SfxSlotFilterState::DISABLED : SfxSlotFilterState::ENABLED;
}
 
bool SfxDispatcher::FindServer_(sal_uInt16 nSlot, SfxSlotServer& rServer)
{
    SFX_STACK(SfxDispatcher::FindServer_);
 
    // Dispatcher locked? (nevertheless let SID_HELP_PI through)
    if ( IsLocked() )
    {
        xImp->bInvalidateOnUnlock = true;
        return false;
    }
 
    // Count the number of Shells in the linked dispatchers.
    Flush();
    sal_uInt16 nTotCount = xImp->aStack.size();
 
    // Verb-Slot?
    if (nSlot >= SID_VERB_START && nSlot <= SID_VERB_END)
    {
        for ( sal_uInt16 nShell = 0;; ++nShell )
        {
            SfxShell *pSh = GetShell(nShell);
            if ( pSh == nullptr )
                return false;
            if ( dynamic_cast< const SfxViewShell *>( pSh ) !=  nullptr )
            {
                const SfxSlot* pSlot = pSh->GetVerbSlot_Impl(nSlot);
                if ( pSlot )
                {
                    rServer.SetShellLevel(nShell);
                    rServer.SetSlot( pSlot );
                    return true;
                }
            }
        }
    }
 
    // SID check against set filter
    SfxSlotFilterState nSlotEnableMode = SfxSlotFilterState::DISABLED;
    if ( xImp->pFrame )
    {
        nSlotEnableMode = IsSlotEnabledByFilter_Impl( nSlot );
        if ( SfxSlotFilterState::DISABLED == nSlotEnableMode )
            return false;
    }
 
    // In Quiet-Mode only Parent-Dispatcher
    if ( xImp->bQuiet )
    {
        return false;
    }
 
    bool bReadOnly = ( SfxSlotFilterState::ENABLED_READONLY != nSlotEnableMode && xImp->bReadOnly );
 
    // search through all the shells of the chained dispatchers
    // from top to bottom
    sal_uInt16 nFirstShell = 0;
    for ( sal_uInt16 i = nFirstShell; i < nTotCount; ++i )
    {
        SfxShell *pObjShell = GetShell(i);
        if (!pObjShell)
            continue;
 
        SfxInterface *pIFace = pObjShell->GetInterface();
        const SfxSlot *pSlot = pIFace->GetSlot(nSlot);
 
        if ( pSlot && pSlot->nDisableFlags != SfxDisableFlags::NONE &&
             ( static_cast<int>(pSlot->nDisableFlags) & static_cast<int>(pObjShell->GetDisableFlags()) ) != 0 )
            return false;
 
        if ( pSlot && !( pSlot->nFlags & SfxSlotMode::READONLYDOC ) && bReadOnly )
            return false;
 
        if ( pSlot )
        {
            // Slot belongs to Container?
            bool bIsContainerSlot = pSlot->IsMode(SfxSlotMode::CONTAINER);
            bool bIsInPlace = xImp->pFrame && xImp->pFrame->GetObjectShell()->IsInPlaceActive();
 
            // Shell belongs to Server?
            // AppDispatcher or IPFrame-Dispatcher
            bool bIsServerShell = !xImp->pFrame || bIsInPlace;
 
            // Of course ShellServer-Slots are also executable even when it is
            // executed on a container dispatcher without an IPClient.
            if ( !bIsServerShell )
            {
                SfxViewShell *pViewSh = xImp->pFrame->GetViewShell();
                bIsServerShell = !pViewSh || !pViewSh->GetUIActiveClient();
            }
 
            // Shell belongs to Container?
            // AppDispatcher or no IPFrameDispatcher
            bool bIsContainerShell = !xImp->pFrame || !bIsInPlace;
            // Shell and Slot match
            if ( !( ( bIsContainerSlot && bIsContainerShell ) ||
                    ( !bIsContainerSlot && bIsServerShell ) ) )
                pSlot = nullptr;
        }
 
        if ( pSlot )
        {
            rServer.SetSlot(pSlot);
            rServer.SetShellLevel(i);
            return true;
        }
    }
 
    return false;
}
 
bool SfxDispatcher::FillState_(const SfxSlotServer& rSvr, SfxItemSet& rState,
        const SfxSlot* pRealSlot)
{
    SFX_STACK(SfxDispatcher::FillState_);
 
    const SfxSlot *pSlot = rSvr.GetSlot();
    if ( pSlot && IsLocked() )
    {
        xImp->bInvalidateOnUnlock = true;
        return false;
    }
 
    if ( pSlot )
    {
        DBG_ASSERT(xImp->bFlushed,
                "Dispatcher not flushed after retrieving slot servers!");
        if (!xImp->bFlushed)
            return false;
 
        // Determine the object and call the Message of this object
        SfxShell *pSh = GetShell(rSvr.GetShellLevel());
        if (!pSh)
            return false;
 
        SfxStateFunc pFunc;
 
        if (pRealSlot)
            pFunc = pRealSlot->GetStateFnc();
        else
            pFunc = pSlot->GetStateFnc();
 
        (*pFunc)(pSh, rState);
#ifdef DBG_UTIL
        // To examine the conformity of IDL (SlotMap) and current Items
        if ( rState.Count() )
        {
            SfxInterface *pIF = pSh->GetInterface();
            SfxItemIter aIter( rState );
            for ( const SfxPoolItem *pItem = aIter.GetCurItem();
                  pItem;
                  pItem = aIter.NextItem() )
            {
                if ( !IsInvalidItem(pItem) && !pItem->IsVoidItem() )
                {
                    sal_uInt16 nSlotId = rState.GetPool()->GetSlotId(pItem->Which());
                    SAL_INFO_IF(
                        typeid(pItem) != *pIF->GetSlot(nSlotId)->GetType()->Type(),
                        "sfx.control",
                        "item-type unequal to IDL (=> no BASIC) with SID: "
                            << nSlotId << " in " << pIF->GetClassName());
                }
            }
        }
#endif
 
        return true;
    }
 
    return false;
}
 
void SfxDispatcher::ExecutePopup( vcl::Window *pWin, const Point *pPos )
{
    SfxDispatcher &rDisp = *SfxGetpApp()->GetDispatcher_Impl();
    sal_uInt16 nShLevel = 0;
    SfxShell *pSh;
 
    if ( rDisp.xImp->bQuiet )
        nShLevel = rDisp.xImp->aStack.size();
 
    for ( pSh = rDisp.GetShell(nShLevel); pSh; ++nShLevel, pSh = rDisp.GetShell(nShLevel) )
    {
        const OUString& rResName = pSh->GetInterface()->GetPopupMenuName();
        if ( !rResName.isEmpty() )
        {
            rDisp.ExecutePopup( rResName, pWin, pPos );
            return;
        }
    }
}
 
namespace {
 
boost::property_tree::ptree fillPopupMenu(Menu* pMenu)
{
    // Activate this menu first
    pMenu->HandleMenuActivateEvent(pMenu);
    pMenu->HandleMenuDeActivateEvent(pMenu);
 
    boost::property_tree::ptree aTree;
    // If last item inserted is some valid text
    bool bIsLastItemText = false;
    sal_uInt16 nCount = pMenu->GetItemCount();
    for (sal_uInt16 nPos = 0; nPos < nCount; nPos++)
    {
        boost::property_tree::ptree aItemTree;
        const MenuItemType aItemType = pMenu->GetItemType(nPos);
 
        if (aItemType == MenuItemType::DONTKNOW)
            continue;
 
        if (aItemType == MenuItemType::SEPARATOR)
        {
            if (bIsLastItemText)
                aItemTree.put("type", "separator");
            bIsLastItemText = false;
        }
        else
        {
            const sal_uInt16 nItemId = pMenu->GetItemId(nPos);
            OUString aCommandURL = pMenu->GetItemCommand(nItemId);
 
            if (aCommandURL.isEmpty())
            {
                const SfxSlot *pSlot = SFX_SLOTPOOL().GetSlot(nItemId);
                if (pSlot)
                    aCommandURL = pSlot->GetCommand();
            }
 
            const OUString aItemText = pMenu->GetItemText(nItemId);
            Menu* pPopupSubmenu = pMenu->GetPopupMenu(nItemId);
 
            if (!aItemText.isEmpty())
                aItemTree.put("text", aItemText.toUtf8().getStr());
 
            if (pPopupSubmenu)
            {
                boost::property_tree::ptree aSubmenu = ::fillPopupMenu(pPopupSubmenu);
                if (aSubmenu.empty())
                    continue;
 
                aItemTree.put("type", "menu");
                if (!aCommandURL.isEmpty())
                    aItemTree.put("command", aCommandURL.toUtf8().getStr());
                aItemTree.push_back(std::make_pair("menu", aSubmenu));
            }
            else
            {
                // no point in exposing choices that don't have the .uno:
                // command
                if (aCommandURL.isEmpty())
                    continue;
 
                aItemTree.put("type", "command");
                aItemTree.put("command", aCommandURL.toUtf8().getStr());
            }
 
            aItemTree.put("enabled", pMenu->IsItemEnabled(nItemId));
 
            MenuItemBits aItemBits = pMenu->GetItemBits(nItemId);
            bool bHasChecks = true;
            if (aItemBits & MenuItemBits::CHECKABLE)
                aItemTree.put("checktype", "checkmark");
            else if (aItemBits & MenuItemBits::RADIOCHECK)
                aItemTree.put("checktype", "radio");
            else if (aItemBits & MenuItemBits::AUTOCHECK)
                aItemTree.put("checktype", "auto");
            else
                bHasChecks = false;
 
            if (bHasChecks)
                aItemTree.put("checked", pMenu->IsItemChecked(nItemId));
        }
 
        if (!aItemTree.empty())
        {
            aTree.push_back(std::make_pair("", aItemTree));
            if (aItemType != MenuItemType::SEPARATOR)
                bIsLastItemText = true;
        }
    }
 
    return aTree;
}
 
}
 
boost::property_tree::ptree SfxDispatcher::fillPopupMenu(const rtl::Reference<VCLXPopupMenu>& rPopupMenu)
{
    PopupMenu* pVCLMenu = static_cast<PopupMenu*>(rPopupMenu->GetMenu());
    return ::fillPopupMenu(pVCLMenu);
}
 
void SfxDispatcher::ExecutePopup( const OUString& rResName, vcl::Window* pWin, const Point* pPos )
{
    css::uno::Sequence< css::uno::Any > aArgs{
        css::uno::Any(comphelper::makePropertyValue( "Value", rResName )),
        css::uno::Any(comphelper::makePropertyValue( "Frame", GetFrame()->GetFrame().GetFrameInterface() )),
        css::uno::Any(comphelper::makePropertyValue( "IsContextMenu", true ))
    };
 
    css::uno::Reference< css::uno::XComponentContext > xContext = comphelper::getProcessComponentContext();
    css::uno::Reference< css::frame::XPopupMenuController > xPopupController(
        xContext->getServiceManager()->createInstanceWithArgumentsAndContext(
        "com.sun.star.comp.framework.ResourceMenuController", aArgs, xContext ), css::uno::UNO_QUERY );
 
    rtl::Reference< VCLXPopupMenu > xPopupMenu = new VCLXPopupMenu();
 
    if ( !xPopupController.is() || !xPopupMenu.is() )
        return;
 
    vcl::Window* pWindow = pWin ? pWin : xImp->pFrame->GetFrame().GetWorkWindow_Impl()->GetWindow();
    Point aPos = pPos ? *pPos : pWindow->GetPointerPosPixel();
 
    css::ui::ContextMenuExecuteEvent aEvent;
    aEvent.SourceWindow = VCLUnoHelper::GetInterface( pWindow );
    aEvent.ExecutePosition.X = aPos.X();
    aEvent.ExecutePosition.Y = aPos.Y();
 
    xPopupController->setPopupMenu( xPopupMenu );
    if (comphelper::LibreOfficeKit::isActive())
    {
        boost::property_tree::ptree aMenu = fillPopupMenu(xPopupMenu);
        boost::property_tree::ptree aRoot;
        aRoot.add_child("menu", aMenu);
 
        std::stringstream aStream;
        boost::property_tree::write_json(aStream, aRoot, true);
        if (SfxViewShell* pViewShell = xImp->pFrame->GetViewShell())
            pViewShell->libreOfficeKitViewCallback(LOK_CALLBACK_CONTEXT_MENU, OString(aStream.str()));
    }
    else
    {
        OUString aMenuURL = "private:resource/popupmenu/" + rResName;
        if (GetFrame()->GetViewShell()->TryContextMenuInterception(xPopupMenu, aMenuURL, aEvent))
        {
            css::uno::Reference<css::awt::XWindowPeer> xParent(aEvent.SourceWindow, css::uno::UNO_QUERY);
            xPopupMenu->execute(xParent, css::awt::Rectangle(aPos.X(), aPos.Y(), 1, 1), css::awt::PopupMenuDirection::EXECUTE_DOWN);
        }
    }
 
    css::uno::Reference< css::lang::XComponent > xComponent( xPopupController, css::uno::UNO_QUERY );
    if ( xComponent.is() )
        xComponent->dispose();
}
 
void SfxDispatcher::Lock( bool bLock )
{
    SfxBindings* pBindings = GetBindings();
    if ( !bLock && xImp->bLocked && xImp->bInvalidateOnUnlock )
    {
        if ( pBindings )
            pBindings->InvalidateAll(true);
        xImp->bInvalidateOnUnlock = false;
    }
    else if ( pBindings )
        pBindings->InvalidateAll(false);
    xImp->bLocked = bLock;
    if ( !bLock )
    {
        for(size_t i = 0; i < xImp->aReqArr.size(); ++i)
            xImp->xPoster->Post(std::move(xImp->aReqArr[i]));
        xImp->aReqArr.clear();
    }
}
 
ToolbarId SfxDispatcher::GetObjectBarId( sal_uInt16 nPos ) const
{
    return xImp->aObjBars[nPos].eId;
}
 
void SfxDispatcher::HideUI( bool bHide )
{
    bool bWasHidden = xImp->bNoUI;
    xImp->bNoUI = bHide;
    if ( xImp->pFrame )
    {
        SfxViewFrame* pTop = xImp->pFrame->GetTopViewFrame();
        if ( pTop && pTop->GetBindings().GetDispatcher() == this )
        {
            SfxFrame& rFrame = pTop->GetFrame();
            if ( rFrame.IsMenuBarOn_Impl() )
            {
                css::uno::Reference < css::beans::XPropertySet > xPropSet( rFrame.GetFrameInterface(), css::uno::UNO_QUERY );
                if ( xPropSet.is() )
                {
                    css::uno::Reference< css::frame::XLayoutManager > xLayoutManager;
                    css::uno::Any aValue = xPropSet->getPropertyValue("LayoutManager");
                    aValue >>= xLayoutManager;
                    if ( xLayoutManager.is() )
                        xLayoutManager->setVisible( !bHide );
                }
            }
        }
    }
 
    if ( bHide != bWasHidden )
        Update_Impl( true );
}
 
void SfxDispatcher::SetReadOnly_Impl( bool bOn )
{
    xImp->bReadOnly = bOn;
}
 
bool SfxDispatcher::GetReadOnly_Impl() const
{
    return xImp->bReadOnly;
}
 
void SfxDispatcher::SetQuietMode_Impl( bool bOn )
{
    xImp->bQuiet = bOn;
    SfxBindings* pBindings = GetBindings();
    if ( pBindings )
        pBindings->InvalidateAll(true);
}
 
SfxItemState SfxDispatcher::QueryState( sal_uInt16 nSlot, const SfxPoolItem* &rpState )
{
    SfxShell *pShell = nullptr;
    const SfxSlot *pSlot = nullptr;
    if ( GetShellAndSlot_Impl( nSlot, &pShell, &pSlot, false, true ) )
    {
        rpState = pShell->GetSlotState(nSlot);
        if ( !rpState )
            return SfxItemState::DISABLED;
        else
            return SfxItemState::DEFAULT;
    }
 
    return SfxItemState::DISABLED;
}
 
SfxItemState SfxDispatcher::QueryState( sal_uInt16 nSID, css::uno::Any& rAny )
{
    SfxShell *pShell = nullptr;
    const SfxSlot *pSlot = nullptr;
    if ( GetShellAndSlot_Impl( nSID, &pShell, &pSlot, false, true ) )
    {
        const SfxPoolItem* pItem = pShell->GetSlotState( nSID );
        if ( !pItem )
            return SfxItemState::DISABLED;
        else
        {
            css::uno::Any aState;
            if ( !pItem->IsVoidItem() )
            {
                sal_uInt16 nSubId( 0 );
                SfxItemPool& rPool = pShell->GetPool();
                sal_uInt16 nWhich = rPool.GetWhich( nSID );
                if ( rPool.GetMetric( nWhich ) == MapUnit::MapTwip )
                    nSubId |= CONVERT_TWIPS;
                pItem->QueryValue( aState, static_cast<sal_uInt8>(nSubId) );
            }
            rAny = aState;
 
            return SfxItemState::DEFAULT;
        }
    }
 
    return SfxItemState::DISABLED;
}
 
bool SfxDispatcher::IsReadOnlyShell_Impl( sal_uInt16 nShell ) const
{
    sal_uInt16 nShellCount = xImp->aStack.size();
    if ( nShell < nShellCount )
    {
        SfxShell* pShell = *( xImp->aStack.rbegin() + nShell );
        if( dynamic_cast< const SfxModule *>( pShell ) != nullptr || dynamic_cast< const SfxApplication *>( pShell ) != nullptr || dynamic_cast< const SfxViewFrame *>( pShell ) !=  nullptr )
            return false;
        else
            return xImp->bReadOnly;
    }
    return true;
}
 
void SfxDispatcher::RemoveShell_Impl( SfxShell& rShell )
{
    Flush();
 
    sal_uInt16 nCount = xImp->aStack.size();
    for ( sal_uInt16 n=0; n<nCount; ++n )
    {
        if ( xImp->aStack[n] == &rShell )
        {
            xImp->aStack.erase( xImp->aStack.begin() + n );
            rShell.SetDisableFlags( SfxDisableFlags::NONE );
            rShell.DoDeactivate_Impl(xImp->pFrame, true);
            break;
        }
    }
 
    if ( !SfxGetpApp()->IsDowning() )
    {
        xImp->bUpdated = false;
        InvalidateBindings_Impl(true);
    }
}
 
void SfxDispatcher::InvalidateBindings_Impl( bool bModify )
{
    // App-Dispatcher?
    if ( IsAppDispatcher() )
    {
        for ( SfxViewFrame *pFrame = SfxViewFrame::GetFirst();
                pFrame;
                pFrame = SfxViewFrame::GetNext( *pFrame ) )
            pFrame->GetBindings().InvalidateAll(bModify);
    }
    else
    {
        SfxDispatcher *pDisp = GetBindings()->GetDispatcher_Impl();
        if ( pDisp == this )
        {
            GetBindings()->InvalidateAll( bModify );
        }
    }
}
 
bool SfxDispatcher::IsUpdated_Impl() const
{
    return xImp->bUpdated;
}
 
void SfxDispatcher::SetDisableFlags( SfxDisableFlags nFlags )
{
    xImp->nDisableFlags = nFlags;
    for ( SfxShellStack_Impl::reverse_iterator it = xImp->aStack.rbegin(); it != xImp->aStack.rend(); ++it )
        (*it)->SetDisableFlags( nFlags );
}
 
SfxDisableFlags SfxDispatcher::GetDisableFlags() const
{
    return xImp->nDisableFlags;
}
 
SfxModule* SfxDispatcher::GetModule() const
{
    for ( sal_uInt16 nShell = 0;; ++nShell )
    {
        SfxShell *pSh = GetShell(nShell);
        if ( pSh == nullptr )
            return nullptr;
        if ( auto pModule = dynamic_cast<SfxModule *>( pSh ) )
            return pModule;
    }
}
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */