summaryrefslogtreecommitdiffstats
path: root/sfx2/source/control/request.cxx
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--sfx2/source/control/request.cxx763
1 files changed, 763 insertions, 0 deletions
diff --git a/sfx2/source/control/request.cxx b/sfx2/source/control/request.cxx
new file mode 100644
index 000000000..b43d1dd99
--- /dev/null
+++ b/sfx2/source/control/request.cxx
@@ -0,0 +1,763 @@
+/* -*- 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 <memory>
+#include <com/sun/star/frame/DispatchStatement.hpp>
+#include <com/sun/star/container/XIndexReplace.hpp>
+#include <com/sun/star/beans/PropertyValue.hpp>
+#include <com/sun/star/uno/Sequence.hxx>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/util/URLTransformer.hpp>
+#include <com/sun/star/util/XURLTransformer.hpp>
+#include <com/sun/star/frame/XDispatchRecorderSupplier.hpp>
+#include <svl/itemiter.hxx>
+#include <sal/log.hxx>
+#include <osl/diagnose.h>
+#include <tools/debug.hxx>
+
+#include <svl/itempool.hxx>
+#include <itemdel.hxx>
+
+#include <comphelper/processfactory.hxx>
+
+#include <svl/hint.hxx>
+
+#include <sfx2/request.hxx>
+#include <sfx2/dispatch.hxx>
+#include <sfx2/msg.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <sfx2/objface.hxx>
+#include <sfx2/sfxuno.hxx>
+
+
+using namespace ::com::sun::star;
+
+struct SfxRequest_Impl: public SfxListener
+
+/* [Description]
+
+ Implementation structure of the <SfxRequest> class.
+*/
+
+{
+ SfxRequest* pAnti; // Owner because of dying pool
+ OUString aTarget; // if possible from target object set by App
+ SfxItemPool* pPool; // ItemSet build with this pool
+ std::unique_ptr<SfxPoolItem> pRetVal; // Return value belongs to itself
+ SfxShell* pShell; // run from this shell
+ const SfxSlot* pSlot; // executed Slot
+ sal_uInt16 nModifier; // which Modifier was pressed?
+ bool bDone; // at all executed
+ bool bIgnored; // Cancelled by the User
+ bool bCancelled; // no longer notify
+ SfxCallMode nCallMode; // Synch/Asynch/API/Record
+ bool bAllowRecording;
+ std::unique_ptr<SfxAllItemSet>
+ pInternalArgs;
+ SfxViewFrame* pViewFrame;
+
+ css::uno::Reference< css::frame::XDispatchRecorder > xRecorder;
+ css::uno::Reference< css::util::XURLTransformer > xTransform;
+
+ explicit SfxRequest_Impl( SfxRequest *pOwner )
+ : pAnti( pOwner)
+ , pPool(nullptr)
+ , pShell(nullptr)
+ , pSlot(nullptr)
+ , nModifier(0)
+ , bDone(false)
+ , bIgnored(false)
+ , bCancelled(false)
+ , nCallMode( SfxCallMode::SYNCHRON )
+ , bAllowRecording( false )
+ , pViewFrame(nullptr)
+ {
+ }
+
+ void SetPool( SfxItemPool *pNewPool );
+ virtual void Notify( SfxBroadcaster &rBC, const SfxHint &rHint ) override;
+ void Record( const uno::Sequence < beans::PropertyValue >& rArgs );
+};
+
+
+void SfxRequest_Impl::Notify( SfxBroadcaster&, const SfxHint &rHint )
+{
+ if ( rHint.GetId() == SfxHintId::Dying )
+ pAnti->Cancel();
+}
+
+
+void SfxRequest_Impl::SetPool( SfxItemPool *pNewPool )
+{
+ if ( pNewPool != pPool )
+ {
+ if ( pPool )
+ EndListening( pPool->BC() );
+ pPool = pNewPool;
+ if ( pNewPool )
+ StartListening( pNewPool->BC() );
+ }
+}
+
+
+SfxRequest::~SfxRequest()
+{
+ // Leave out Done() marked requests with 'rem'
+ if ( pImpl->xRecorder.is() && !pImpl->bDone && !pImpl->bIgnored )
+ pImpl->Record( uno::Sequence < beans::PropertyValue >() );
+
+ // Clear object
+ pArgs.reset();
+ if ( pImpl->pRetVal )
+ DeleteItemOnIdle(std::move(pImpl->pRetVal));
+}
+
+
+SfxRequest::SfxRequest
+(
+ const SfxRequest& rOrig
+)
+: SfxHint( rOrig ),
+ nSlot(rOrig.nSlot),
+ pArgs(rOrig.pArgs? new SfxAllItemSet(*rOrig.pArgs): nullptr),
+ pImpl( new SfxRequest_Impl(this) )
+{
+ pImpl->bAllowRecording = rOrig.pImpl->bAllowRecording;
+ pImpl->bDone = false;
+ pImpl->bIgnored = false;
+ pImpl->pShell = nullptr;
+ pImpl->pSlot = nullptr;
+ pImpl->nCallMode = rOrig.pImpl->nCallMode;
+ pImpl->aTarget = rOrig.pImpl->aTarget;
+ pImpl->nModifier = rOrig.pImpl->nModifier;
+
+ // deep copy needed !
+ pImpl->pInternalArgs.reset( rOrig.pImpl->pInternalArgs ? new SfxAllItemSet(*rOrig.pImpl->pInternalArgs) : nullptr);
+
+ if ( pArgs )
+ pImpl->SetPool( pArgs->GetPool() );
+ else
+ pImpl->SetPool( rOrig.pImpl->pPool );
+
+ // setup macro recording if it was in the original SfxRequest
+ if (!rOrig.pImpl->pViewFrame || !rOrig.pImpl->xRecorder.is())
+ return;
+
+ nSlot = rOrig.nSlot;
+ pImpl->pViewFrame = rOrig.pImpl->pViewFrame;
+ if (pImpl->pViewFrame->GetDispatcher()->GetShellAndSlot_Impl(nSlot, &pImpl->pShell, &pImpl->pSlot, true, true))
+ {
+ pImpl->SetPool( &pImpl->pShell->GetPool() );
+ pImpl->xRecorder = SfxRequest::GetMacroRecorder(pImpl->pViewFrame);
+ if (pImpl->xRecorder)
+ pImpl->xTransform = util::URLTransformer::create(comphelper::getProcessComponentContext());
+ pImpl->aTarget = pImpl->pShell->GetName();
+ }
+ else
+ {
+ SAL_WARN("sfx", "Recording unsupported slot: " << pImpl->pPool->GetSlotId(nSlot));
+ }
+}
+
+
+SfxRequest::SfxRequest
+(
+ SfxViewFrame* pViewFrame,
+ sal_uInt16 nSlotId
+
+)
+
+/* [Description]
+
+ With this constructor events can subsequently be recorded that are not run
+ across SfxDispatcher (eg from KeyInput() or mouse events). For this, a
+ SfxRequest instance is created by this constructor and then proceed
+ exactly as with a SfxRequest that in a <Slot-Execute-Method> is given as a
+ parameter.
+*/
+
+: nSlot(nSlotId),
+ pImpl( new SfxRequest_Impl(this) )
+{
+ pImpl->bDone = false;
+ pImpl->bIgnored = false;
+ pImpl->SetPool( &pViewFrame->GetPool() );
+ pImpl->pShell = nullptr;
+ pImpl->pSlot = nullptr;
+ pImpl->nCallMode = SfxCallMode::SYNCHRON;
+ pImpl->pViewFrame = pViewFrame;
+ if( pImpl->pViewFrame->GetDispatcher()->GetShellAndSlot_Impl( nSlotId, &pImpl->pShell, &pImpl->pSlot, true, true ) )
+ {
+ pImpl->SetPool( &pImpl->pShell->GetPool() );
+ pImpl->xRecorder = SfxRequest::GetMacroRecorder( pViewFrame );
+ if (pImpl->xRecorder)
+ pImpl->xTransform = util::URLTransformer::create(comphelper::getProcessComponentContext());
+ pImpl->aTarget = pImpl->pShell->GetName();
+ }
+ else
+ {
+ SAL_WARN( "sfx", "Recording unsupported slot: " << pImpl->pPool->GetSlotId(nSlotId) );
+ }
+}
+
+
+SfxRequest::SfxRequest
+(
+ sal_uInt16 nSlotId, // executed <Slot-Id>
+ SfxCallMode nMode, // Synch/API/...
+ SfxItemPool& rPool // necessary for the SfxItemSet for parameters
+)
+
+// creates a SfxRequest without arguments
+
+: nSlot(nSlotId),
+ pImpl( new SfxRequest_Impl(this) )
+{
+ pImpl->bDone = false;
+ pImpl->bIgnored = false;
+ pImpl->SetPool( &rPool );
+ pImpl->pShell = nullptr;
+ pImpl->pSlot = nullptr;
+ pImpl->nCallMode = nMode;
+}
+
+SfxRequest::SfxRequest
+(
+ const SfxSlot* pSlot, // executed <Slot-Id>
+ const css::uno::Sequence < css::beans::PropertyValue >& rArgs,
+ SfxCallMode nMode, // Synch/API/...
+ SfxItemPool& rPool // necessary for the SfxItemSet for parameters
+)
+: nSlot(pSlot->GetSlotId()),
+ pArgs(new SfxAllItemSet(rPool)),
+ pImpl( new SfxRequest_Impl(this) )
+{
+ pImpl->bDone = false;
+ pImpl->bIgnored = false;
+ pImpl->SetPool( &rPool );
+ pImpl->pShell = nullptr;
+ pImpl->pSlot = nullptr;
+ pImpl->nCallMode = nMode;
+ TransformParameters( nSlot, rArgs, *pArgs, pSlot );
+}
+
+
+SfxRequest::SfxRequest
+(
+ sal_uInt16 nSlotId,
+ SfxCallMode nMode,
+ const SfxAllItemSet& rSfxArgs
+)
+
+// creates a SfxRequest with arguments
+
+: nSlot(nSlotId),
+ pArgs(new SfxAllItemSet(rSfxArgs)),
+ pImpl( new SfxRequest_Impl(this) )
+{
+ pImpl->bDone = false;
+ pImpl->bIgnored = false;
+ pImpl->SetPool( rSfxArgs.GetPool() );
+ pImpl->pShell = nullptr;
+ pImpl->pSlot = nullptr;
+ pImpl->nCallMode = nMode;
+}
+
+
+SfxRequest::SfxRequest
+(
+ sal_uInt16 nSlotId,
+ SfxCallMode nMode,
+ const SfxAllItemSet& rSfxArgs,
+ const SfxAllItemSet& rSfxInternalArgs
+)
+: SfxRequest(nSlotId, nMode, rSfxArgs)
+{
+ SetInternalArgs_Impl(rSfxInternalArgs);
+}
+
+SfxCallMode SfxRequest::GetCallMode() const
+{
+ return pImpl->nCallMode;
+}
+
+
+bool SfxRequest::IsSynchronCall() const
+{
+ return SfxCallMode::SYNCHRON == ( SfxCallMode::SYNCHRON & pImpl->nCallMode );
+}
+
+
+void SfxRequest::SetSynchronCall( bool bSynchron )
+{
+ if ( bSynchron )
+ pImpl->nCallMode |= SfxCallMode::SYNCHRON;
+ else
+ pImpl->nCallMode &= ~SfxCallMode::SYNCHRON;
+}
+
+void SfxRequest::SetInternalArgs_Impl( const SfxAllItemSet& rArgs )
+{
+ pImpl->pInternalArgs.reset( new SfxAllItemSet( rArgs ) );
+}
+
+const SfxItemSet* SfxRequest::GetInternalArgs_Impl() const
+{
+ return pImpl->pInternalArgs.get();
+}
+
+
+void SfxRequest_Impl::Record
+(
+ const uno::Sequence < beans::PropertyValue >& rArgs // current Parameter
+)
+
+/* [Description]
+
+ Internal helper method to create a repeatable description of the just
+ executed SfxRequest.
+*/
+
+{
+ if(!xRecorder.is())
+ return;
+
+ OUString aCmd = ".uno:" + OUString::createFromAscii( pSlot->GetUnoName() );
+
+ uno::Reference< container::XIndexReplace > xReplace( xRecorder, uno::UNO_QUERY );
+ if ( xReplace.is() && aCmd == ".uno:InsertText" )
+ {
+ sal_Int32 nCount = xReplace->getCount();
+ if ( nCount )
+ {
+ frame::DispatchStatement aStatement;
+ uno::Any aElement = xReplace->getByIndex(nCount-1);
+ if ( (aElement >>= aStatement) && aStatement.aCommand == aCmd )
+ {
+ OUString aStr;
+ OUString aNew;
+ aStatement.aArgs[0].Value >>= aStr;
+ rArgs[0].Value >>= aNew;
+ aStr += aNew;
+ aStatement.aArgs.getArray()[0].Value <<= aStr;
+ aElement <<= aStatement;
+ xReplace->replaceByIndex( nCount-1, aElement );
+ return;
+ }
+ }
+ }
+
+ css::util::URL aURL;
+ aURL.Complete = aCmd;
+ xTransform->parseStrict(aURL);
+
+ if (bDone)
+ xRecorder->recordDispatch(aURL,rArgs);
+ else
+ xRecorder->recordDispatchAsComment(aURL,rArgs);
+}
+
+
+void SfxRequest::Record_Impl
+(
+ SfxShell& rSh, // the <SfxShell>, which has executed the Request
+ const SfxSlot& rSlot, // the <SfxSlot>, which has executed the Request
+ const css::uno::Reference< css::frame::XDispatchRecorder >& xRecorder,
+ SfxViewFrame* pViewFrame
+)
+
+/* [Description]
+
+ This internal method marks the specified SfxMakro SfxRequest as recorded in
+ SfxMakro. Pointer to the parameters in Done() is used again, thus has to
+ still be alive.
+*/
+
+{
+ pImpl->pShell = &rSh;
+ pImpl->pSlot = &rSlot;
+ pImpl->xRecorder = xRecorder;
+ if (pImpl->xRecorder && !pImpl->xTransform)
+ pImpl->xTransform = util::URLTransformer::create(comphelper::getProcessComponentContext());
+ pImpl->aTarget = rSh.GetName();
+ pImpl->pViewFrame = pViewFrame;
+}
+
+
+void SfxRequest::SetArgs( const SfxAllItemSet& rArgs )
+{
+ pArgs.reset(new SfxAllItemSet(rArgs));
+ pImpl->SetPool( pArgs->GetPool() );
+}
+
+
+void SfxRequest::AppendItem(const SfxPoolItem &rItem)
+{
+ if(!pArgs)
+ pArgs.reset( new SfxAllItemSet(*pImpl->pPool) );
+ pArgs->Put(rItem, rItem.Which());
+}
+
+
+void SfxRequest::RemoveItem( sal_uInt16 nID )
+{
+ if (pArgs)
+ {
+ pArgs->ClearItem(nID);
+ if ( !pArgs->Count() )
+ pArgs.reset();
+ }
+}
+
+void SfxRequest::SetReturnValue(const SfxPoolItem &rItem)
+{
+ DBG_ASSERT(!pImpl->pRetVal, "Set Return value multiple times?");
+ pImpl->pRetVal.reset(rItem.Clone());
+}
+
+
+const SfxPoolItem* SfxRequest::GetReturnValue() const
+{
+ return pImpl->pRetVal.get();
+}
+
+
+void SfxRequest::Done
+(
+ const SfxItemSet& rSet /* parameters passed on by the application,
+ that for example were asked for by the user
+ in a dialogue, 0 if no parameters have been
+ set */
+)
+
+/* [Description]
+
+ This method must be called in the <Execute-Method> of the <SfxSlot>s, which
+ has performed the SfxRequest when the execution actually took place. If
+ 'Done()' is not called, then the SfxRequest is considered canceled.
+
+ Any return values are passed only when 'Done()' was called. Similar, when
+ recording a macro only true statements are generated if 'Done()' was
+ called; for SfxRequests that were not identified as such will instead
+ be commented out by inserting ('rem').
+
+ [Note]
+
+ 'Done ()' is not called, for example when a dialog started by the function
+ was canceled by the user or if the execution could not be performed due to
+ a wrong context (without use of separate <SfxShell>s). 'Done ()' will be
+ launched, when executing the function led to a regular error
+ (for example, file could not be opened).
+*/
+
+{
+ Done_Impl( &rSet );
+
+ // Keep items if possible, so they can be queried by StarDraw.
+ if ( !pArgs )
+ {
+ pArgs.reset( new SfxAllItemSet( rSet ) );
+ pImpl->SetPool( pArgs->GetPool() );
+ }
+ else
+ {
+ SfxItemIter aIter(rSet);
+ for (const SfxPoolItem* pItem = aIter.GetCurItem(); pItem; pItem = aIter.NextItem())
+ {
+ if(!IsInvalidItem(pItem))
+ pArgs->Put(*pItem,pItem->Which());
+ }
+ }
+}
+
+
+void SfxRequest::Done( bool bRelease )
+// [<SfxRequest::Done(SfxItemSet&)>]
+{
+ Done_Impl( pArgs.get() );
+ if( bRelease )
+ pArgs.reset();
+}
+
+
+void SfxRequest::ForgetAllArgs()
+{
+ pArgs.reset();
+ pImpl->pInternalArgs.reset();
+}
+
+
+bool SfxRequest::IsCancelled() const
+{
+ return pImpl->bCancelled;
+}
+
+
+void SfxRequest::Cancel()
+
+/* [Description]
+
+ Marks this request as no longer executable. For example, if called when
+ the target (more precisely, its pool) dies.
+*/
+
+{
+ pImpl->bCancelled = true;
+ pImpl->SetPool( nullptr );
+ pArgs.reset();
+}
+
+
+void SfxRequest::Ignore()
+
+/* [Description]
+
+ If this method is called instead of <SfxRequest::Done()>, then this
+ request is not recorded.
+
+ [Example]
+
+ The selecting of tools in StarDraw should not be recorded, but the same
+ slots are to be used from the generation of the tools to the generated
+ objects. Thus can NoRecords not be specified, i.e. should not be recorded.
+*/
+
+{
+ // Mark as actually executed
+ pImpl->bIgnored = true;
+}
+
+
+void SfxRequest::Done_Impl
+(
+ const SfxItemSet* pSet /* parameters passed on by the application,
+ that for example were asked for by the user
+ in a dialogue, 0 if no parameters have been
+ set */
+
+)
+
+/* [Description]
+
+ Internal method to mark SfxRequest with 'done' and to evaluate the
+ parameters in 'pSet' in case it is recorded.
+*/
+
+{
+ // Mark as actually executed
+ pImpl->bDone = true;
+
+ // not Recording
+ if ( !pImpl->xRecorder.is() )
+ return;
+
+ // was running a different slot than requested (Delegation)
+ if ( nSlot != pImpl->pSlot->GetSlotId() )
+ {
+ // Search Slot again
+ pImpl->pSlot = pImpl->pShell->GetInterface()->GetSlot(nSlot);
+ DBG_ASSERT( pImpl->pSlot, "delegated SlotId not found" );
+ if ( !pImpl->pSlot ) // playing it safe
+ return;
+ }
+
+ // recordable?
+ // new Recording uses UnoName!
+ SAL_WARN_IF( !pImpl->pSlot->pUnoName, "sfx", "Recording not exported slot: "
+ << pImpl->pSlot->GetSlotId() );
+
+ if ( !pImpl->pSlot->pUnoName ) // playing it safe
+ return;
+
+ // often required values
+ SfxItemPool &rPool = pImpl->pShell->GetPool();
+
+ // Property-Slot?
+ if ( !pImpl->pSlot->IsMode(SfxSlotMode::METHOD) )
+ {
+ // get the property as SfxPoolItem
+ const SfxPoolItem *pItem(nullptr);
+ const sal_uInt16 nWhich(rPool.GetWhich(pImpl->pSlot->GetSlotId()));
+ const bool bItemStateSet(nullptr != pSet);
+ const SfxItemState eState(bItemStateSet ? pSet->GetItemState( nWhich, false, &pItem ) : SfxItemState::DEFAULT);
+ SAL_WARN_IF( !bItemStateSet || SfxItemState::SET != eState, "sfx", "Recording property not available: "
+ << pImpl->pSlot->GetSlotId() );
+ uno::Sequence < beans::PropertyValue > aSeq;
+
+ if ( bItemStateSet && SfxItemState::SET == eState )
+ TransformItems( pImpl->pSlot->GetSlotId(), *pSet, aSeq, pImpl->pSlot );
+
+ pImpl->Record( aSeq );
+ }
+
+ // record everything in a single statement?
+ else if ( pImpl->pSlot->IsMode(SfxSlotMode::RECORDPERSET) )
+ {
+ uno::Sequence < beans::PropertyValue > aSeq;
+ if ( pSet )
+ TransformItems( pImpl->pSlot->GetSlotId(), *pSet, aSeq, pImpl->pSlot );
+ pImpl->Record( aSeq );
+ }
+
+ // record each item as a single statement
+ else if ( pImpl->pSlot->IsMode(SfxSlotMode::RECORDPERITEM) )
+ {
+ if ( pSet )
+ {
+ // iterate over Items
+ SfxItemIter aIter(*pSet);
+ for ( const SfxPoolItem* pItem = aIter.GetCurItem(); pItem; pItem = aIter.NextItem() )
+ {
+ // to determine the slot ID for the individual item
+ sal_uInt16 nSlotId = rPool.GetSlotId( pItem->Which() );
+ if ( nSlotId == nSlot )
+ {
+ // play it safe; repair the wrong flags
+ OSL_FAIL( "recursion RecordPerItem - use RecordPerSet!" );
+ SfxSlot *pSlot = const_cast<SfxSlot*>(pImpl->pSlot);
+ pSlot->nFlags &= ~SfxSlotMode::RECORDPERITEM;
+ pSlot->nFlags &= SfxSlotMode::RECORDPERSET;
+ }
+
+ // Record a Sub-Request
+ SfxRequest aReq( pImpl->pViewFrame, nSlotId );
+ if ( aReq.pImpl->pSlot )
+ aReq.AppendItem( *pItem );
+ aReq.Done();
+ }
+ }
+ else
+ {
+ //HACK(think about this again)
+ pImpl->Record( uno::Sequence < beans::PropertyValue >() );
+ }
+ }
+}
+
+
+bool SfxRequest::IsDone() const
+
+/* [Description]
+
+ With this method it can be queried whether the SfxRequest was actually
+ executed or not. If a SfxRequest was not executed, then this is for example
+ because it was canceled by the user or the context for this request was
+ wrong, this was not implemented on a separate <SfxShell>.
+
+ SfxRequest instances that return false will not be recorded.
+
+ [Cross-reference]
+
+ <SfxRequest::Done(const SfxItemSet&)>
+ <SfxRequest::Done()>
+*/
+
+{
+ return pImpl->bDone;
+}
+
+
+css::uno::Reference< css::frame::XDispatchRecorder > SfxRequest::GetMacroRecorder( SfxViewFrame const * pView )
+
+/* [Description]
+
+ This recorder is an attempt for dispatch () to get calls from the Frame.
+ This is then available through a property by a supplier but only when
+ recording was turned on.
+
+ (See also SfxViewFrame::MiscExec_Impl() and SID_RECORDING)
+*/
+
+{
+ css::uno::Reference< css::frame::XDispatchRecorder > xRecorder;
+
+ if (!pView)
+ pView = SfxViewFrame::Current();
+
+ if (!pView)
+ return xRecorder;
+
+ css::uno::Reference< css::beans::XPropertySet > xSet(
+ pView->GetFrame().GetFrameInterface(),
+ css::uno::UNO_QUERY);
+
+ if(xSet.is())
+ {
+ css::uno::Any aProp = xSet->getPropertyValue("DispatchRecorderSupplier");
+ css::uno::Reference< css::frame::XDispatchRecorderSupplier > xSupplier;
+ aProp >>= xSupplier;
+ if(xSupplier.is())
+ xRecorder = xSupplier->getDispatchRecorder();
+ }
+
+ return xRecorder;
+}
+
+bool SfxRequest::HasMacroRecorder( SfxViewFrame const * pView )
+{
+ return GetMacroRecorder( pView ).is();
+}
+
+
+bool SfxRequest::IsAPI() const
+
+/* [Description]
+
+ Returns true if this SfxRequest was generated by an API (for example BASIC),
+ otherwise false.
+*/
+
+{
+ return SfxCallMode::API == ( SfxCallMode::API & pImpl->nCallMode );
+}
+
+
+void SfxRequest::SetModifier( sal_uInt16 nModi )
+{
+ pImpl->nModifier = nModi;
+}
+
+
+sal_uInt16 SfxRequest::GetModifier() const
+{
+ return pImpl->nModifier;
+}
+
+
+void SfxRequest::AllowRecording( bool bSet )
+{
+ pImpl->bAllowRecording = bSet;
+}
+
+bool SfxRequest::AllowsRecording() const
+{
+ bool bAllow = pImpl->bAllowRecording;
+ if( !bAllow )
+ bAllow = ( SfxCallMode::API != ( SfxCallMode::API & pImpl->nCallMode ) ) &&
+ ( SfxCallMode::RECORD == ( SfxCallMode::RECORD & pImpl->nCallMode ) );
+ return bAllow;
+}
+
+void SfxRequest::ReleaseArgs()
+{
+ pArgs.reset();
+ pImpl->pInternalArgs.reset();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */