/* -*- 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 <config_vclplug.h>

#include <officecfg/Office/Common.hxx>

#include <rtl/strbuf.hxx>

#include <sal/log.hxx>

#include <sfx2/app.hxx>

#include <sfx2/bindings.hxx>

#include <sfx2/chalign.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 <tools/mapunit.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

    std::span<sal_uInt16 const>

                         pFilterSIDs;   // sorted Array of SIDs

    SfxDisableFlags      nDisableFlags;

    bool                 bFlushed;

    std::deque< std::deque<SfxToDo_Impl> > aToDoCopyStack;

};

/** This method checks if the stack of the SfxDispatchers is flushed, or if

    push- or pop- commands are pending.

*/

bool SfxDispatcher::IsFlushed() const

{

     return xImp->bFlushed;

}

/** This method performs outstanding push- and pop- commands. For <SfxShell>s,

    which are new on the stack, the <SfxShell::Activate(bool)> is invoked

    with bMDI == sal_True, for SfxShells that are removed from the stack, the

    <SfxShell::Deactivate(bool)> is invoked with bMDI == sal_True

*/

void SfxDispatcher::Flush()

{

    if (!xImp->bFlushed) FlushImpl();

}

/** With this method, a <SfxShell> pushed on to the SfxDispatcher.

    The SfxShell is first marked for push and a timer is set up.

    First when the timer has counted down to zero the push

    ( <SfxDispatcher::Flush()> ) is actually performed and the

    <SfxBindings> is invalidated. While the timer is counting down

    the opposing push and pop commands on the same SfxShell are

    leveled out.

*/

void SfxDispatcher::Push(SfxShell& rShell)

{

    Pop( rShell, SfxDispatcherPopFlags::PUSH );

}

/** This method checks whether a particular <SfxShell> instance is

    on the SfxDispatcher.

    @returns true   The SfxShell instance is on the SfxDispatcher.

             false  The SfxShell instance is not on the SfxDispatcher.

*/

bool SfxDispatcher::IsActive(const SfxShell& rShell)

{

    return CheckVirtualStack(rShell);

}

/** With this method it can be determined whether the SfxDispatcher is

    locked or unlocked. A locked SfxDispatcher does not perform <SfxRequest>s

    and no longer provides any status information. It behaves as if all the

    slots are disabled.

    The dispatcher is also marked as blocked, if all Dispatcher are locked

    (<SfxApplication::LockDispatcher()>) or the associated top frame is in the

    modal-mode and if the specified slot are handled as frame-specific

    (ie, not served by the application).

*/

bool SfxDispatcher::IsLocked() const

{

    return xImp->bLocked;

}

/** With this method it can be determined if the SfxDispacher is the

    applications dispatcher.

    @return bool it is the application dispatcher.

*/

bool SfxDispatcher::IsAppDispatcher() const

{

    return !xImp->pFrame;

}

/** Helper function to check whether a slot can be executed and

    check the execution itself

*/

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(u"DispatchRecorderSupplier"_ustr);

            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(this);

    xImp->aIdle.SetPriority(TaskPriority::HIGH_IDLE );

    xImp->aIdle.SetInvokeHandler( LINK(this, SfxDispatcher, EventHdl_Impl ) );

}

SfxDispatcher::SfxDispatcher()

{

    Construct_Impl();

    xImp->pFrame = nullptr;

}

/** The constructor of the SfxDispatcher class places a stack of empty

    <SfxShell> pointers. It is not initially locked and is considered flushed.

*/

SfxDispatcher::SfxDispatcher(SfxViewFrame *pViewFrame)

{

    Construct_Impl();

    xImp->pFrame = pViewFrame;

}

/** The destructor of the SfxDispatcher class should not be called when the

    SfxDispatcher instance is active. It may, however, still be a <SfxShell>

    pointer on the stack.

*/

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->ClearLink();

    // 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();

    }

}

/** With this method, one or more <SfxShell> are popped from the SfxDispatcher.

    The SfxShell is marked for popping and a timer is set up. Only when the

    timer has reached the end, the pop is actually performed

    ( <SfxDispatcher::Flush()> ) and the <SfxBindings> is invalidated.

    While the timer is running the opposing push and pop commands on one

    SfxShell cancel each other out.

    @param rShell the stack to take the SfxShell instance.

    @param nMode SfxDispatcherPopFlags::POP_UNTIL

                            Also all 'rShell' of SfxShells are taken from the

                            stack.

                 SfxDispatcherPopFlags::POP_DELETE

                            All SfxShells actually taken from the stack

                            will be deleted.

                 SfxDispatcherPopFlags::PUSH (InPlace use only)

                            The Shell is pushed.

*/

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();

        }

    }

}

/** This handler is called after <SfxDispatcher::Invalidate()> or after

    changes on the stack (<SfxDispatcher::Push()> and <SfxDispatcher::Pop())

    It flushes the Stack, if it is dirty, thus it actually executes the

    pending Push and Pop commands.

*/

IMPL_LINK_NOARG( SfxDispatcher, EventHdl_Impl, Timer *, void )

{

    Flush();

    Update_Impl();

    SfxBindings* pBindings = GetBindings();

    if ( pBindings )

        pBindings->StartUpdate_Impl();

}

/** With this method it can be tested whether the <SfxShell> rShell is on the

    stack, when it was flushed. This way the SfxDispatcher is not actually

    flushed.

    This method is intended among other things to make assertions possible

    without the side effect of having to flush the SfxDispatcher.

*/

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;

}

/** Determines the position of a given SfxShell in the stack of the dispatcher.

    If possible this is flushed before.

    [Return value]

    sal_uInt16                  == USRT_MAX

                                The SfxShell is not on this SfxDispatcher.

                                < USHRT_MAX

                                Position of the SfxShell on the Dispatcher

                                from the top count stating with 0.

*/

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;

}

/** Returns a pointer to the <SfxShell> which is at the position nIdx

    (from the top, last pushed is 0) on the stack.

    Thus the SfxDispatcher is not flushed.

    Is the stack not deep enough a NULL-Pointer is returned.

*/

SfxShell *SfxDispatcher::GetShell(sal_uInt16 nIdx) const

{

    sal_uInt16 nShellCount = xImp->aStack.size();

    if ( nIdx < nShellCount )

        return *(xImp->aStack.rbegin() + nIdx);

    return nullptr;

}

/** This method returns a pointer to the <SfxBinding> Instance on which the

    SfxDispatcher is currently bound. A SfxDispatcher is only bound to

    the SfxBindings when it is <UI-aktiv>. If it is not UI-active,

    a NULL-pointer is returned.

    The returned pointer is only valid in the immediate context of the method

    call.

*/

SfxBindings* SfxDispatcher::GetBindings() const

{

    if ( xImp->pFrame )

        return &xImp->pFrame->GetBindings();

    else

        return nullptr;

}

/** Returns a pointer to the <SfxViewFrame> instance, which belongs to

    this SfxDispatcher. If it is about the application dispatcher,

    a NULL-pointer is returned.

*/

SfxViewFrame* SfxDispatcher::GetFrame() const

{

    return xImp->pFrame;

}

/** This method controls the activation of a dispatcher.

    Since the application dispatcher is always active, either as a sub

    dispatcher of the <SfxViewFrame> dispatcher or as itself, it is never

    activated as a whole, instead only its individual <SfxShell>s at

    <SfxDispatcher::Push(SfxShell&)>.

    When activating a SfxDispatcher all of the SfxShells located on its stack

    are called with the handler <SfxShell::Activate(bool)>, starting with

    the lowest.

*/

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();

    }

}

/** This method controls the deactivation of a dispatcher.

    Since the application dispatcher is always active, either as a sub

    dispatcher of the <SfxViewFrame> dispatcher or as itself, it is never

    deactivated as a whole, instead only its individual <SfxShell>s at

    <SfxDispatcher::Pop(SfxShell&)>.

    When deactivating a SfxDispatcher all of the SfxShells located on its stack

    are called with the handler <SfxShell::Deactivate(bool)>, starting with

    the lowest.

*/

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();

}

/** This method searches in SfxDispatcher after <SfxShell> , from the Slot Id

    nSlot currently being handled. For this, the dispatcher is first flushed.

    @param nSlot the searchable Slot-Id

    @param ppShell the SfxShell, which are currently handled the nSlot

    @param ppSlot the SfxSlot, which are currently handled the nSlot

    @return int      sal_True

                     The SfxShell was found, ppShell and ppSlot are valid.

                     sal_False

                     The SfxShell was not found, ppShell and ppSlot are invalid.

*/

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 && *ppShell )

            *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;

}

/** This method performs a request for a cached <Slot-Server>.

    @param rShell to the calling <SfxShell>

    @param rSlot to the calling <SfxSlot>

    @param rReq function to be performed (Id and optional parameters)

    @param eCallMode Synchronously, asynchronously or as shown in the slot

*/

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) );

}

/** Helper function to put from rItem below the Which-ID in the pool of the

    Item Sets rSet.

*/

static void MappedPut_Impl(SfxAllItemSet &rSet, const SfxPoolItem &rItem)

{

    // Put with mapped Which-Id if needed

    if (SfxItemPool::IsSlot(rItem.Which()))

        rSet.PutAsTargetWhich(rItem, rSet.GetPool()->GetWhichIDFromSlotID(rItem.Which()));

    else

        rSet.Put(rItem);

}

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;

}

SfxPoolItemHolder SfxDispatcher::Execute(sal_uInt16 nSlot, SfxCallMode nCall,

        SfxItemSet const * pArgs, SfxItemSet const * pInternalArgs, sal_uInt16 nModi)

{

    if ( IsLocked() )

        return SfxPoolItemHolder();

    SfxShell *pShell = nullptr;

    const SfxSlot *pSlot = nullptr;

    if ( GetShellAndSlot_Impl( nSlot,  &pShell, &pSlot, false, true ) )

    {

        SfxAllItemSet aSet( pShell->GetPool() );

        if ( pArgs )

        {

            for (SfxItemIter aIter( *pArgs ); !aIter.IsAtEnd(); aIter.Next())

                MappedPut_Impl( aSet, *aIter.GetCurItem() );

        }

        SfxRequest aReq(nSlot, nCall, aSet);

        if (pInternalArgs)

            aReq.SetInternalArgs_Impl( *pInternalArgs );

        aReq.SetModifier( nModi );

        Execute_( *pShell, *pSlot, aReq, nCall );

        return aReq.GetReturnValue();

    }

    return SfxPoolItemHolder();

}

/** Method to execute a <SfxSlot>s over the Slot-Id.

    @param nSlot the Id of the executing function

    @param eCall SfxCallMode::SYNCRHON, ..._ASYNCHRON or ..._SLOT

    @param pArgs Zero terminated C-Array of Parameters

    @param pInternalArgs Zero terminated C-Array of Parameters

    @return const SfxPoolItem* Pointer to the SfxPoolItem valid to the next run

                            though the Message-Loop, which contains the return

                            value.

                            Or a NULL-Pointer, when the function was not

                            executed (for example canceled by the user).

*/

SfxPoolItemHolder SfxDispatcher::Execute(sal_uInt16 nSlot, SfxCallMode eCall,

        const SfxPoolItem **pArgs, sal_uInt16 nModi, const SfxPoolItem **pInternalArgs)

{

    if ( IsLocked() )

        return SfxPoolItemHolder();

    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 );

        return pReq->GetReturnValue();

    }

    return SfxPoolItemHolder();

}

/** Method to execute a <SfxSlot>s over the Slot-Id.

    @param nSlot the Id of the executing function

    @param eCall SfxCallMode::SYNCRHON, ..._ASYNCHRON or ..._SLOT

    @param rArgs <SfxItemSet> with the parameters

    @return const SfxPoolItem* Pointer to the SfxPoolItem valid to the next run

                            though the Message-Loop, which contains the return

                            value.

                            Or a NULL-Pointer, when the function was not

                            executed (for example canceled by the user).

*/

SfxPoolItemHolder SfxDispatcher::Execute(sal_uInt16 nSlot, SfxCallMode eCall,

        const SfxItemSet &rArgs)

{

    if ( IsLocked() )

        return SfxPoolItemHolder();

    SfxShell *pShell = nullptr;

    const SfxSlot *pSlot = nullptr;

    if ( GetShellAndSlot_Impl( nSlot,  &pShell, &pSlot, false, true ) )

    {

        SfxAllItemSet aSet( pShell->GetPool() );

        for (SfxItemIter aIter( rArgs ); !aIter.IsAtEnd(); aIter.Next())

            MappedPut_Impl( aSet, *aIter.GetCurItem() );

        SfxRequest aReq( nSlot, eCall, aSet );

        aReq.SetModifier( 0 );

        Execute_( *pShell, *pSlot, aReq, eCall );

        return aReq.GetReturnValue();

    }

    return SfxPoolItemHolder();

}

/** Method to execute a <SfxSlot>s over the Slot-Id.

    [Note]

    The parameters are copied, can therefore be passed on as the address

    of stack objects.

    @param nSlot the Id of the executing function

    @param eCall SfxCallMode::SYNCRHON, ..._ASYNCHRON or ..._SLOT

    @param args  list of SfxPoolItem arguments

    @return                 Pointer to the SfxPoolItem valid to the next run

                            though the Message-Loop, which contains the return

                            value.

                            Or a NULL-Pointer, when the function was not

                            executed (for example canceled by the user).

    [Example]

    pDispatcher->Execute( SID_OPENDOCUMENT, SfxCallMode::SYNCHRON,

        {   &SfxStringItem( SID_FILE_NAME, "\\tmp\\temp.sdd" ),

            &SfxStringItem( SID_FILTER_NAME, "StarDraw Presentation" ),

            &SfxBoolItem( SID_DOC_READONLY, sal_False ),

        });

*/

SfxPoolItemHolder SfxDispatcher::ExecuteList(sal_uInt16 nSlot, SfxCallMode eCall,

        std::initializer_list<SfxPoolItem const*> args,

        std::initializer_list<SfxPoolItem const*> internalargs)

{

    if ( IsLocked() )

        return SfxPoolItemHolder();

    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 SfxPoolItemHolder();

}

/** Helper method to receive the asynchronously executed <SfxRequest>s.

*/

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

        {

            if (SfxShell *pSh = GetShell(aSvr.GetShellLevel()))

            {

                const SfxSlot *pSlot = aSvr.GetSlot();

                // 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 );