return sTitle;
}
+ void DocumentInfo::notifyMacroEventRead(const css::uno::Reference<css::frame::XModel>& rModel)
+ {
+ if (!rModel.is())
+ return;
+
+ // like BreakMacroSignature of XMLScriptContext use XModel::attachResource
+ // to propagate this notification
+ css::uno::Sequence<css::beans::PropertyValue> aMedDescr = rModel->getArgs();
+ sal_Int32 nNewLen = aMedDescr.getLength() + 1;
+ aMedDescr.realloc(nNewLen);
+ aMedDescr[nNewLen-1].Name = "MacroEventRead";
+ aMedDescr[nNewLen-1].Value <<= true;
+ rModel->attachResource(rModel->getURL(), aMedDescr);
+ }
} // namespace comphelper
,m_bSuppressVersionColumns(true)
,m_bModified(false)
,m_bDocumentReadOnly(false)
+ ,m_bMacroCallsSeenWhileLoading(false)
,m_pSharedConnectionManager(nullptr)
,m_nControllerLockCount(0)
{
,m_bSuppressVersionColumns(true)
,m_bModified(false)
,m_bDocumentReadOnly(false)
+ ,m_bMacroCallsSeenWhileLoading(false)
,m_pSharedConnectionManager(nullptr)
,m_nControllerLockCount(0)
{
return ( *m_aEmbeddedMacros != eNoMacros );
}
+bool ODatabaseModelImpl::macroCallsSeenWhileLoading() const
+{
+ return m_bMacroCallsSeenWhileLoading;
+}
+
Reference< XEmbeddedScripts > ODatabaseModelImpl::getEmbeddedDocumentScripts() const
{
return Reference< XEmbeddedScripts >( getModel_noCreate(), UNO_QUERY );
bool ODatabaseDocument::impl_attachResource( const OUString& i_rLogicalDocumentURL,
const Sequence< PropertyValue >& i_rMediaDescriptor, DocumentGuard& _rDocGuard )
{
- if ( ( i_rLogicalDocumentURL == getURL() )
- && ( i_rMediaDescriptor.getLength() == 1 )
- && ( i_rMediaDescriptor[0].Name == "BreakMacroSignature" )
- )
+ if (i_rLogicalDocumentURL == getURL())
{
- // this is a BAD hack of the Basic importer code ... there should be a dedicated API for this,
- // not this bad mis-using of existing interfaces
- return false;
- // (we do not support macro signatures, so we can ignore this call)
+ ::comphelper::NamedValueCollection aArgs(i_rMediaDescriptor);
+
+ // this misuse of attachresource is a hack of the Basic importer code
+ // repurposing existing interfaces for uses it probably wasn't intended
+ // for
+
+ // we do not support macro signatures, so we can ignore that request
+ aArgs.remove("BreakMacroSignature");
+
+ bool bMacroEventRead = false;
+ if ((aArgs.get( "MacroEventRead" ) >>= bMacroEventRead) && bMacroEventRead)
+ m_pImpl->m_bMacroCallsSeenWhileLoading = true;
+ aArgs.remove( "MacroEventRead" );
+
+ if (aArgs.empty())
+ return false;
}
// if no URL has been provided, the caller was lazy enough to not call our getURL - which is not allowed anymore,
bool m_bSuppressVersionColumns : 1;
bool m_bModified : 1;
bool m_bDocumentReadOnly : 1;
+ bool m_bMacroCallsSeenWhileLoading : 1;
css::uno::Reference< css::beans::XPropertyBag >
m_xSettings;
css::uno::Sequence< OUString > m_aTableFilter;
virtual void setCurrentMacroExecMode( sal_uInt16 ) override;
virtual OUString getDocumentLocation() const override;
virtual bool documentStorageHasMacros() const override;
+ virtual bool macroCallsSeenWhileLoading() const override;
virtual css::uno::Reference< css::document::XEmbeddedScripts > getEmbeddedDocumentScripts() const override;
virtual SignatureState getScriptingSignatureState() override;
virtual bool hasTrustedScriptingSignature( bool bAllowUIToAddAuthor ) override;
/** retrieves the UI title of the given document
*/
COMPHELPER_DLLPUBLIC OUString getDocumentTitle( const css::uno::Reference< css::frame::XModel >& _rxDocument );
- }
+ /** notify that this document contains a macro event handler
+ */
+ COMPHELPER_DLLPUBLIC void notifyMacroEventRead( const css::uno::Reference< css::frame::XModel >& _rxDocument );
+ }
} // namespace comphelper
PropertySet const & rPropSet,
sal_Int32& nOrientation );
+ const css::uno::Reference<css::frame::XModel> GetDocModel() const { return mxDocModel; }
+
private:
css::uno::Reference< css::frame::XModel > mxDocModel;
const GraphicHelper& mrGraphicHelper;
virtual bool
documentStorageHasMacros() const = 0;
+ /** checks whether the document's contained calls to macros or scripts after loading
+
+ */
+ virtual bool
+ macroCallsSeenWhileLoading() const = 0;
+
/** provides access to the XEmbeddedScripts interface of the document
Implementations are allowed to return <NULL/> here if and only if they
@see isMacroExecutionDisallowed
@see IMacroDocumentAccess::documentStorageHasMacros
+ @see IMacroDocumentAccess::macroCallsSeenWhileLoading
@see hasMacroLibrary
@see IMacroDocumentAccess::checkForBrokenScriptingSignatures
*/
sal_uInt32 GetModifyPasswordHash() const;
bool SetModifyPasswordHash( sal_uInt32 nHash );
+ void SetMacroCallsSeenWhileLoading();
+ bool GetMacroCallsSeenWhileLoading() const;
+
const css::uno::Sequence< css::beans::PropertyValue >& GetModifyPasswordInfo() const;
bool SetModifyPasswordInfo( const css::uno::Sequence< css::beans::PropertyValue >& aInfo );
protected:
bool mbIsFormsSupported;
bool mbIsTableShapeSupported;
+ bool mbNotifyMacroEventRead;
// Create top-level element context.
// This method is called after the namespace map has been updated, but
bool embeddedFontAlreadyProcessed( const OUString& url );
virtual void NotifyEmbeddedFontRead() {};
+ // something referencing a macro/script was imported
+ void NotifyMacroEventRead();
bool needFixPositionAfterZ() const;
};
#include <com/sun/star/uno/XComponentContext.hpp>
#include <comphelper/configurationhelper.hxx>
#include <comphelper/string.hxx>
+#include <comphelper/documentinfo.hxx>
#include <comphelper/storagehelper.hxx>
#include <osl/diagnose.h>
#include <rtl/tencinfo.h>
{
if( !maMacroAttachers.empty() && mxContext.is() ) try
{
+ comphelper::DocumentInfo::notifyMacroEventRead(mxDocModel);
+
Reference< XMultiComponentFactory > xFactory( mxContext->getServiceManager(), UNO_SET_THROW );
Sequence< Any > aArgs( 2 );
aArgs[ 0 ] <<= mxDocModel;
Reference< XVBAMacroResolver > xResolver( xFactory->createInstanceWithArgumentsAndContext(
"com.sun.star.script.vba.VBAMacroResolver", aArgs, mxContext ), UNO_QUERY_THROW );
maMacroAttachers.forEachMem( &VbaMacroAttacherBase::resolveAndAttachMacro, ::std::cref( xResolver ) );
+
}
catch(const Exception& )
{
#include <vcl/wmf.hxx>
#include <comphelper/types.hxx>
#include <comphelper/classids.hxx>
+#include <comphelper/documentinfo.hxx>
#include <toolkit/helper/vclunohelper.hxx>
#include <basegfx/point/b2dpoint.hxx>
#include <basegfx/polygon/b2dpolygon.hxx>
mbSimpleMacro( true ),
mbProcessSdr( true ),
mbInsertSdr( true ),
- mbCustomDff( false )
+ mbCustomDff( false ),
+ mbNotifyMacroEventRead( false )
{
}
return xSdrObj;
}
-void XclImpDrawObjBase::PreProcessSdrObject( XclImpDffConverter& rDffConv, SdrObject& rSdrObj ) const
+void XclImpDrawObjBase::NotifyMacroEventRead()
+{
+ if (mbNotifyMacroEventRead)
+ return;
+ SfxObjectShell* pDocShell = GetDocShell();
+ if (!pDocShell)
+ return;
+ comphelper::DocumentInfo::notifyMacroEventRead(pDocShell->GetModel());
+ mbNotifyMacroEventRead = true;
+}
+
+void XclImpDrawObjBase::PreProcessSdrObject( XclImpDffConverter& rDffConv, SdrObject& rSdrObj )
{
// default: front layer, derived classes may have to set other layer in DoPreProcessSdrObj()
rSdrObj.NbcSetLayer( SC_LAYER_FRONT );
{
if( ScMacroInfo* pInfo = ScDrawLayer::GetMacroInfo( &rSdrObj, true ) )
{
- pInfo->SetMacro( XclTools::GetSbMacroUrl( maMacroName, GetDocShell() ) );
+ OUString sMacro = XclTools::GetSbMacroUrl(maMacroName, GetDocShell());
+ if (!sMacro.isEmpty())
+ NotifyMacroEventRead();
+ pInfo->SetMacro(sMacro);
pInfo->SetHlink( maHyperlink );
}
}
XclImpSimpleDffConverter( rRoot, rDffStrm ),
oox::ole::MSConvertOCXControls( rRoot.GetDocShell()->GetModel() ),
maStdFormName( "Standard" ),
- mnOleImpFlags( 0 )
+ mnOleImpFlags( 0 ),
+ mbNotifyMacroEventRead(false)
{
const SvtFilterOptions& rFilterOpt = SvtFilterOptions::Get();
if( rFilterOpt.IsMathType2Math() )
SetModel( &xConvData->mrSdrModel, 1440 );
}
-void XclImpDffConverter::ProcessObject( SdrObjList& rObjList, const XclImpDrawObjBase& rDrawObj )
+void XclImpDffConverter::ProcessObject( SdrObjList& rObjList, XclImpDrawObjBase& rDrawObj )
{
if( rDrawObj.IsProcessSdrObj() )
{
SetModel( &maDataStack.back()->mrSdrModel, 1440 );
}
+void XclImpDffConverter::NotifyMacroEventRead()
+{
+ if (mbNotifyMacroEventRead)
+ return;
+ comphelper::DocumentInfo::notifyMacroEventRead(mxModel);
+ mbNotifyMacroEventRead = true;
+}
+
SdrObjectPtr XclImpDffConverter::CreateSdrObject( const XclImpTbxObjBase& rTbxObj, const tools::Rectangle& rAnchorRect )
{
SdrObjectPtr xSdrObj;
ScriptEventDescriptor aDescriptor;
if( (rConvData.mnLastCtrlIndex >= 0) && rTbxObj.FillMacroDescriptor( aDescriptor ) )
{
+ NotifyMacroEventRead();
Reference< XEventAttacherManager > xEventMgr( rConvData.mxCtrlForm, UNO_QUERY_THROW );
xEventMgr->registerScriptEvent( rConvData.mnLastCtrlIndex, aDescriptor );
}
SdrObjectPtr CreateSdrObject( XclImpDffConverter& rDffConv, const tools::Rectangle& rAnchorRect, bool bIsDff ) const;
/** Additional processing for the passed SdrObject before insertion into
the drawing page (calls virtual DoPreProcessSdrObj() function). */
- void PreProcessSdrObject( XclImpDffConverter& rDffConv, SdrObject& rSdrObj ) const;
+ void PreProcessSdrObject( XclImpDffConverter& rDffConv, SdrObject& rSdrObj );
/** Additional processing for the passed SdrObject after insertion into the
drawing page (calls virtual DoPostProcessSdrObj() function). */
void PostProcessSdrObject( XclImpDffConverter& rDffConv, SdrObject& rSdrObj ) const;
virtual void DoPreProcessSdrObj( XclImpDffConverter& rDffConv, SdrObject& rSdrObj ) const;
/** Derived classes may perform additional processing for the passed SdrObject after insertion. */
virtual void DoPostProcessSdrObj( XclImpDffConverter& rDffConv, SdrObject& rSdrObj ) const;
+
+ /** Notify that the document contains a macro event handler */
+ void NotifyMacroEventRead();
private:
/** Reads the contents of a BIFF3 OBJ record. */
void ImplReadObj3( XclImpStream& rStrm );
bool mbProcessSdr; /// true = Object is valid, do processing and insertion.
bool mbInsertSdr; /// true = Insert the SdrObject into draw page.
bool mbCustomDff; /// true = Recreate SdrObject in DFF import.
+ bool mbNotifyMacroEventRead; /// true == If we have already seen a macro event
};
class XclImpDrawObjVector
/** Initially called before the objects of the passed drawing manager are converted. */
void InitializeDrawing( XclImpDrawing& rDrawing, SdrModel& rSdrModel, SdrPage& rSdrPage );
/** Processes BIFF5 drawing objects without DFF data, inserts into the passed object list. */
- void ProcessObject( SdrObjList& rObjList, const XclImpDrawObjBase& rDrawObj );
+ void ProcessObject( SdrObjList& rObjList, XclImpDrawObjBase& rDrawObj );
/** Processes all objects in the passed list. */
void ProcessDrawing( const XclImpDrawObjVector& rDrawObjs );
/** Processes a drawing container in the passed DFF stream, converts all objects. */
void InsertSdrObject( SdrObjList& rObjList, const XclImpDrawObjBase& rDrawObj, SdrObject* pSdrObj );
/** Initializes the mxCtrlForm referring to the standard controls form. */
void InitControlForm();
+ /** Notify that this document contains a macro event handler */
+ void NotifyMacroEventRead();
private:
typedef std::shared_ptr< ScfProgressBar > ScfProgressBarRef;
XclImpDffConvDataStack maDataStack; /// Stack for registered drawing managers.
sal_uInt32 mnOleImpFlags; /// Application OLE import settings.
sal_Int32 mnDefTextMargin; /// Default margin in text boxes.
+ bool mbNotifyMacroEventRead; /// If we have already seen a macro event
};
// Drawing manager ============================================================
#include <com/sun/star/script/ScriptEventDescriptor.hpp>
#include <com/sun/star/script/XEventAttacherManager.hpp>
#include <com/sun/star/style/VerticalAlignment.hpp>
+#include <comphelper/documentinfo.hxx>
#include <ooo/vba/excel/Constants.hpp>
#include <ooo/vba/excel/XlOrientation.hpp>
#include <ooo/vba/excel/XlPlacement.hpp>
ListenerType eListenerType ) :
ScVbaControlObject_BASE( rxParent, rxContext, rxModel, uno::Reference< drawing::XShape >( rxControlShape, uno::UNO_QUERY_THROW ) ),
mxFormIC( rxFormIC, uno::UNO_SET_THROW ),
- mxControlProps( rxControlShape->getControl(), uno::UNO_QUERY_THROW )
+ mxControlProps( rxControlShape->getControl(), uno::UNO_QUERY_THROW ),
+ mbNotifyMacroEventRead(false)
{
// set listener and event name to be used for OnAction attribute
switch( eListenerType )
return OUString();
}
+void ScVbaControlObjectBase::NotifyMacroEventRead()
+{
+ if (mbNotifyMacroEventRead)
+ return;
+ comphelper::DocumentInfo::notifyMacroEventRead(mxModel);
+ mbNotifyMacroEventRead = true;
+}
+
void SAL_CALL ScVbaControlObjectBase::setOnAction( const OUString& rMacroName )
{
uno::Reference< script::XEventAttacherManager > xEventMgr( mxFormIC, uno::UNO_QUERY_THROW );
aDescriptor.EventMethod = maEventMethod;
aDescriptor.ScriptType = "Script";
aDescriptor.ScriptCode = makeMacroURL( aResolvedMacro.msResolvedMacro );
+ NotifyMacroEventRead();
xEventMgr->registerScriptEvent( nIndex, aDescriptor );
}
}
virtual sal_Bool SAL_CALL getAutoSize() override;
virtual void SAL_CALL setAutoSize( sal_Bool bAutoSize ) override;
+ /// Notify that the document contains a macro event handler
+ void NotifyMacroEventRead();
+
protected:
/// @throws css::uno::RuntimeException
sal_Int32 getModelIndexInForm() const;
css::uno::Reference< css::beans::XPropertySet > mxControlProps;
OUString maListenerType;
OUString maEventMethod;
+ bool mbNotifyMacroEventRead;
};
typedef ::cppu::ImplInheritanceHelper< ScVbaControlObjectBase, ov::excel::XButton > ScVbaButton_BASE;
const URL& aURL, const Sequence < PropertyValue >& lArgs,
const Reference< XDispatchResultListener >& xListener )
{
-
bool bSuccess = false;
Any invokeResult;
bool bCaughtException = false;
{
xListener->dispatchFinished( aEvent ) ;
}
- catch(RuntimeException & e)
+ catch(const RuntimeException &e)
{
SAL_WARN("scripting",
"ScriptProtocolHandler::dispatchWithNotification: caught RuntimeException"
- "while dispatchFinished with failure of the execution "
- << e );
+ "while dispatchFinished with failure of the execution" << e);
}
}
return;
}
else
{
- if ( m_xData->m_rDocumentAccess.documentStorageHasMacros() || hasMacroLibrary() )
+ if (m_xData->m_rDocumentAccess.documentStorageHasMacros() || hasMacroLibrary() || m_xData->m_rDocumentAccess.macroCallsSeenWhileLoading())
{
bAllow = adjustMacroMode( rxInteraction );
}
Any aException;
try
{
- css::uno::Reference<css::uri::XUriReferenceFactory> urifac(
- css::uri::UriReferenceFactory::create(comphelper::getProcessComponentContext()));
- css::uno::Reference<css::uri::XVndSunStarScriptUrlReference> uri(
- urifac->parse(_rScriptURL), css::uno::UNO_QUERY_THROW);
- auto const loc = uri->getParameter("location");
- bool bIsDocumentScript = loc == "document";
- if ( bIsDocumentScript && !lcl_isScriptAccessAllowed_nothrow( _rxScriptContext ) )
+ if ( !lcl_isScriptAccessAllowed_nothrow( _rxScriptContext ) )
return ERRCODE_IO_ACCESSDENIED;
if ( UnTrustedScript(_rScriptURL) )
return ::sfx2::DocumentMacroMode::storageHasMacros( m_xDocStorage );
}
+bool SfxObjectShell_Impl::macroCallsSeenWhileLoading() const
+{
+ return rDocShell.GetMacroCallsSeenWhileLoading();
+}
+
Reference< XEmbeddedScripts > SfxObjectShell_Impl::getEmbeddedDocumentScripts() const
{
return Reference< XEmbeddedScripts >( rDocShell.GetModel(), UNO_QUERY );
pImpl->m_bConfigOptionsChecked = bChecked;
}
+void SfxObjectShell::SetMacroCallsSeenWhileLoading()
+{
+ pImpl->m_bMacroCallsSeenWhileLoading = true;
+}
+
+bool SfxObjectShell::GetMacroCallsSeenWhileLoading() const
+{
+ return pImpl->m_bMacroCallsSeenWhileLoading;
+}
+
bool SfxObjectShell::QuerySaveSizeExceededModules_Impl( const uno::Reference< task::XInteractionHandler >& xHandler )
{
#if !HAVE_FEATURE_SCRIPTING
,m_bSharedXMLFlag( false )
,m_bAllowShareControlFileClean( true )
,m_bConfigOptionsChecked( false )
+ ,m_bMacroCallsSeenWhileLoading( false )
,lErr(ERRCODE_NONE)
,nEventId ( SfxEventHintId::NONE )
,pReloadTimer ( nullptr)
pObjectShell->BreakMacroSign_Impl( bBreakMacroSign );
}
+ bool bMacroEventRead = false;
+ if ((aArgs.get("MacroEventRead") >>= bMacroEventRead) && bMacroEventRead)
+ {
+ pObjectShell->SetMacroCallsSeenWhileLoading();
+ }
+
aArgs.remove( "WinExtent" );
aArgs.remove( "BreakMacroSignature" );
+ aArgs.remove( "MacroEventRead" );
aArgs.remove( "Stream" );
aArgs.remove( "InputStream" );
aArgs.remove( "URL" );
bSaveVersionOnClose:1,
m_bSharedXMLFlag:1, // whether the document should be edited in shared mode
m_bAllowShareControlFileClean:1, // whether the flag should be stored in xml file
- m_bConfigOptionsChecked:1; // whether or not the user options are checked after the Options dialog is closed.
+ m_bConfigOptionsChecked:1, // whether or not the user options are checked after the Options dialog is closed.
+ m_bMacroCallsSeenWhileLoading:1; // whether or not the user options are checked after the Options dialog is closed.
IndexBitSet aBitSet;
ErrCode lErr;
virtual void setCurrentMacroExecMode( sal_uInt16 nMacroMode ) override;
virtual OUString getDocumentLocation() const override;
virtual bool documentStorageHasMacros() const override;
+ virtual bool macroCallsSeenWhileLoading() const override;
virtual css::uno::Reference< css::document::XEmbeddedScripts > getEmbeddedDocumentScripts() const override;
virtual SignatureState getScriptingSignatureState() override;
#include <com/sun/star/beans/PropertyValue.hpp>
+#include <com/sun/star/document/XEmbeddedScripts.hpp>
+#include <com/sun/star/document/XScriptInvocationContext.hpp>
#include <com/sun/star/util/URL.hpp>
-
#include <com/sun/star/frame/Desktop.hpp>
#include <com/sun/star/util/URLTransformer.hpp>
#include <com/sun/star/util/XURLTransformer.hpp>
+#include <com/sun/star/uno/XInterface.hpp>
#include <tools/urlobj.hxx>
#include <tools/diagnose_ex.h>
#include <svl/macitem.hxx>
#include <macroloader.hxx>
using namespace css;
+using namespace ::com::sun::star;
+
// --- XNameReplace ---
return false;
}
+namespace
+{
+ bool lcl_isScriptAccessAllowed_nothrow(const uno::Reference<uno::XInterface>& rxScriptContext)
+ {
+ try
+ {
+ uno::Reference<document::XEmbeddedScripts> xScripts(rxScriptContext, uno::UNO_QUERY);
+ if (!xScripts.is())
+ {
+ uno::Reference<document::XScriptInvocationContext> xContext(rxScriptContext, uno::UNO_QUERY_THROW);
+ xScripts.set(xContext->getScriptContainer(), uno::UNO_SET_THROW);
+ }
+
+ return xScripts->getAllowMacroExecution();
+ }
+ catch( const uno::Exception& )
+ {
+ DBG_UNHANDLED_EXCEPTION("sfx.doc");
+ }
+ return false;
+ }
+}
+
void SfxEvents_Impl::Execute( uno::Any const & aEventData, const document::DocumentEvent& aTrigger, SfxObjectShell* pDoc )
{
uno::Sequence < beans::PropertyValue > aProperties;
- if ( aEventData >>= aProperties )
- {
- OUString aType;
- OUString aScript;
- OUString aLibrary;
- OUString aMacroName;
+ if ( !(aEventData >>= aProperties) )
+ return;
- sal_Int32 nCount = aProperties.getLength();
+ OUString aType;
+ OUString aScript;
+ OUString aLibrary;
+ OUString aMacroName;
- if ( !nCount )
- return;
+ sal_Int32 nCount = aProperties.getLength();
- sal_Int32 nIndex = 0;
- while ( nIndex < nCount )
- {
- if ( aProperties[ nIndex ].Name == PROP_EVENT_TYPE )
- aProperties[ nIndex ].Value >>= aType;
- else if ( aProperties[ nIndex ].Name == PROP_SCRIPT )
- aProperties[ nIndex ].Value >>= aScript;
- else if ( aProperties[ nIndex ].Name == PROP_LIBRARY )
- aProperties[ nIndex ].Value >>= aLibrary;
- else if ( aProperties[ nIndex ].Name == PROP_MACRO_NAME )
- aProperties[ nIndex ].Value >>= aMacroName;
- else {
- OSL_FAIL("Unknown property value!");
- }
- nIndex += 1;
- }
+ if ( !nCount )
+ return;
- if (aType == STAR_BASIC && !aScript.isEmpty())
- {
- uno::Any aAny;
- SfxMacroLoader::loadMacro( aScript, aAny, pDoc );
+ sal_Int32 nIndex = 0;
+ while ( nIndex < nCount )
+ {
+ if ( aProperties[ nIndex ].Name == PROP_EVENT_TYPE )
+ aProperties[ nIndex ].Value >>= aType;
+ else if ( aProperties[ nIndex ].Name == PROP_SCRIPT )
+ aProperties[ nIndex ].Value >>= aScript;
+ else if ( aProperties[ nIndex ].Name == PROP_LIBRARY )
+ aProperties[ nIndex ].Value >>= aLibrary;
+ else if ( aProperties[ nIndex ].Name == PROP_MACRO_NAME )
+ aProperties[ nIndex ].Value >>= aMacroName;
+ else {
+ OSL_FAIL("Unknown property value!");
}
- else if (aType == "Service" ||
- aType == "Script")
- {
- bool bAllowed = false;
- util::URL aURL;
- if (!aScript.isEmpty())
- {
- uno::Reference < util::XURLTransformer > xTrans( util::URLTransformer::create( ::comphelper::getProcessComponentContext() ) );
+ nIndex += 1;
+ }
- aURL.Complete = aScript;
- xTrans->parseStrict( aURL );
+ if (aType.isEmpty())
+ {
+ // Empty type means no active binding for the event. Just ignore do nothing.
+ return;
+ }
- bAllowed = !SfxObjectShell::UnTrustedScript(aURL.Complete);
- }
+ if (aScript.isEmpty())
+ return;
- if (bAllowed)
- {
- SfxViewFrame* pView = pDoc ?
- SfxViewFrame::GetFirst( pDoc ) :
- SfxViewFrame::Current();
+ if (!pDoc)
+ pDoc = SfxObjectShell::Current();
- uno::Reference
- < frame::XDispatchProvider > xProv;
+ if (pDoc && !lcl_isScriptAccessAllowed_nothrow(pDoc->GetModel()))
+ return;
- if ( pView != nullptr )
- {
- xProv = uno::Reference
- < frame::XDispatchProvider > (
- pView->GetFrame().GetFrameInterface(), uno::UNO_QUERY );
- }
- else
- {
- xProv.set( frame::Desktop::create( ::comphelper::getProcessComponentContext() ),
- uno::UNO_QUERY );
- }
+ if (aType == STAR_BASIC)
+ {
+ uno::Any aAny;
+ SfxMacroLoader::loadMacro( aScript, aAny, pDoc );
+ }
+ else if (aType == "Service" || aType == "Script")
+ {
+ util::URL aURL;
+ uno::Reference < util::XURLTransformer > xTrans( util::URLTransformer::create( ::comphelper::getProcessComponentContext() ) );
- uno::Reference < frame::XDispatch > xDisp;
- if ( xProv.is() )
- xDisp = xProv->queryDispatch( aURL, OUString(), 0 );
+ aURL.Complete = aScript;
+ xTrans->parseStrict( aURL );
- if ( xDisp.is() )
- {
+ bool bAllowed = !SfxObjectShell::UnTrustedScript(aURL.Complete);
- beans::PropertyValue aEventParam;
- aEventParam.Value <<= aTrigger;
- uno::Sequence< beans::PropertyValue > aDispatchArgs( &aEventParam, 1 );
- xDisp->dispatch( aURL, aDispatchArgs );
- }
- }
- }
- else if ( aType.isEmpty() )
- {
- // Empty type means no active binding for the event. Just ignore do nothing.
- }
- else
+ if (bAllowed)
{
- SAL_WARN( "sfx.notify", "notifyEvent(): Unsupported event type" );
+ SfxViewFrame* pView = SfxViewFrame::GetFirst(pDoc);
+
+ uno::Reference
+ < frame::XDispatchProvider > xProv;
+
+ if ( pView != nullptr )
+ {
+ xProv = uno::Reference
+ < frame::XDispatchProvider > (
+ pView->GetFrame().GetFrameInterface(), uno::UNO_QUERY );
+ }
+ else
+ {
+ xProv.set( frame::Desktop::create( ::comphelper::getProcessComponentContext() ),
+ uno::UNO_QUERY );
+ }
+
+ uno::Reference < frame::XDispatch > xDisp;
+ if ( xProv.is() )
+ xDisp = xProv->queryDispatch( aURL, OUString(), 0 );
+
+ if ( xDisp.is() )
+ {
+
+ beans::PropertyValue aEventParam;
+ aEventParam.Value <<= aTrigger;
+ uno::Sequence< beans::PropertyValue > aDispatchArgs( &aEventParam, 1 );
+ xDisp->dispatch( aURL, aDispatchArgs );
+ }
}
}
+ else
+ {
+ SAL_WARN( "sfx.notify", "notifyEvent(): Unsupported event type" );
+ }
}
*/
#include <hintids.hxx>
+#include <comphelper/documentinfo.hxx>
#include <comphelper/string.hxx>
#include <vcl/svapp.hxx>
#include <vcl/wrkwin.hxx>
rShape->setSize( aSz );
}
-static void lcl_html_setEvents(
+static bool lcl_html_setEvents(
const uno::Reference< script::XEventAttacherManager > & rEvtMn,
sal_uInt32 nPos, const SvxMacroTableDtor& rMacroTable,
const std::vector<OUString>& rUnoMacroTable,
}
if( 0==nEvents )
- return;
+ return false;
Sequence<script::ScriptEventDescriptor> aDescs( nEvents );
script::ScriptEventDescriptor* pDescs = aDescs.getArray();
}
}
rEvtMn->registerScriptEvents( nPos, aDescs );
+ return true;
}
static void lcl_html_getEvents( const OUString& rOption, const OUString& rValue,
// To prevent previous JavaScript-Events from being called, these events will only be set retroactively
if( !rMacroTable.empty() || !rUnoMacroTable.empty() )
{
- lcl_html_setEvents( m_pFormImpl->GetControlEventManager(),
+ bool bHasEvents = lcl_html_setEvents( m_pFormImpl->GetControlEventManager(),
rFormComps->getCount() - 1,
rMacroTable, rUnoMacroTable, rUnoMacroParamTable,
GetScriptTypeString(m_pFormImpl->GetHeaderAttrs()) );
+ if (bHasEvents)
+ NotifyMacroEventRead();
}
if( bSetFCompPropSet )
Any aAny( &xForm, cppu::UnoType<XForm>::get());
rForms->insertByIndex( rForms->getCount(), aAny );
if( !aMacroTable.empty() )
- lcl_html_setEvents( m_pFormImpl->GetFormEventManager(),
+ {
+ bool bHasEvents = lcl_html_setEvents( m_pFormImpl->GetFormEventManager(),
rForms->getCount() - 1,
aMacroTable, aUnoMacroTable, aUnoMacroParamTable,
rDfltScriptType );
+ if (bHasEvents)
+ NotifyMacroEventRead();
+ }
}
void SwHTMLParser::EndForm( bool bAppend )
#include <memory>
#include <hintids.hxx>
#include <comphelper/string.hxx>
+#include <comphelper/documentinfo.hxx>
#include <vcl/svapp.hxx>
#include <vcl/wrkwin.hxx>
#include <svx/svxids.hrc>
}
if( !aMacroItem.GetMacroTable().empty() )
+ {
+ NotifyMacroEventRead();
pFlyFormat->SetFormatAttr( aMacroItem );
+ }
// tdf#87083 If the graphic has not been loaded yet, then load it now.
// Otherwise it may be loaded during the first paint of the object and it
aINetFormat.SetName( aName );
if( !aMacroTable.empty() )
+ {
+ NotifyMacroEventRead();
aINetFormat.SetMacroTable( &aMacroTable );
+ }
// set the default attribute
InsertAttr(&m_xAttrTab->pINetFormat, aINetFormat, xCntxt.get());
}
}
+void SwHTMLParser::NotifyMacroEventRead()
+{
+ if (m_bNotifyMacroEventRead)
+ return;
+ SwDocShell *pDocSh = m_xDoc->GetDocShell();
+ if (!pDocSh)
+ return;
+ uno::Reference<frame::XModel> const xModel(pDocSh->GetBaseModel());
+ comphelper::DocumentInfo::notifyMacroEventRead(xModel);
+ m_bNotifyMacroEventRead = true;
+}
+
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
m_bRemoveHidden( false ),
m_bBodySeen( false ),
m_bReadingHeaderOrFooter( false ),
+ m_bNotifyMacroEventRead( false ),
m_isInTableStructure(false),
m_nTableDepth( 0 ),
m_pTempViewFrame(nullptr)
bool m_bBodySeen : 1;
bool m_bReadingHeaderOrFooter : 1;
+ bool m_bNotifyMacroEventRead : 1;
bool m_isInTableStructure;
sal_Int32 m_nTableDepth;
}
void DeregisterHTMLTable(HTMLTable* pOld);
+
+ void NotifyMacroEventRead();
+
};
struct SwPendingStackData
cp_vector m_aEndParaPos;
WW8_CP m_aCurrAttrCP;
bool m_bOnLoadingMain:1;
+ bool m_bNotifyMacroEventRead:1;
const SprmReadInfo& GetSprmReadInfo(sal_uInt16 nId) const;
void PostProcessAttrs();
void ReadEmbeddedData(SvStream& rStrm, SwDocShell const * pDocShell, struct HyperLinksTable& hlStr);
+ void NotifyMacroEventRead();
};
bool CanUseRemoteLink(const OUString &rGrfName);
if( aName.isEmpty() )
return eF_ResT::TAGIGN; // makes no sense without Macro-Name
+ NotifyMacroEventRead();
+
//try converting macro symbol according to macro name
bool bApplyWingdings = ConvertMacroSymbol( aName, aVText );
aName = "StarOffice.Standard.Modul1." + aName;
#include <com/sun/star/lang/XSingleComponentFactory.hpp>
#include <com/sun/star/ui/ItemType.hpp>
#include <fstream>
+#include <comphelper/documentinfo.hxx>
#include <comphelper/processfactory.hxx>
#include <comphelper/sequence.hxx>
+#include <sfx2/objsh.hxx>
#include <unotools/configmgr.hxx>
#include <vcl/graph.hxx>
#include <map>
SwCTBWrapper* pCTBWrapper = dynamic_cast< SwCTBWrapper* > ( *it );
if ( pCTBWrapper )
{
+ // tdf#127048 set this flag if we might import something
+ uno::Reference<frame::XModel> const xModel(rDocSh.GetBaseModel());
+ comphelper::DocumentInfo::notifyMacroEventRead(xModel);
+
if ( !pCTBWrapper->ImportCustomToolBar( rDocSh ) )
return false;
}
#include <cppuhelper/supportsservice.hxx>
#include <comphelper/extract.hxx>
#include <comphelper/documentconstants.hxx>
+#include <comphelper/documentinfo.hxx>
#include <comphelper/storagehelper.hxx>
#include <comphelper/propertysequence.hxx>
#include <unotools/fontcvt.hxx>
maNamespaceHandler( new SvXMLImportFastNamespaceHandler() ),
mxFastDocumentHandler( nullptr ),
mbIsFormsSupported( true ),
- mbIsTableShapeSupported( false )
+ mbIsTableShapeSupported( false ),
+ mbNotifyMacroEventRead( false )
{
SAL_WARN_IF( !xContext.is(), "xmloff.core", "got no service manager" );
InitCtor_();
}
}
+void SvXMLImport::NotifyMacroEventRead()
+{
+ if (mbNotifyMacroEventRead)
+ return;
+
+ comphelper::DocumentInfo::notifyMacroEventRead(mxModel);
+
+ mbNotifyMacroEventRead = true;
+}
+
SvXMLImportFastNamespaceHandler::SvXMLImportFastNamespaceHandler()
{
}
{
}
-
XMLEventImportHelper::~XMLEventImportHelper()
{
// delete factories
const OUString& rXmlEventName,
const OUString& rLanguage)
{
+ rImport.NotifyMacroEventRead();
+
SvXMLImportContext* pContext = nullptr;
// translate event name form xml to api
projects / libreoffice.git / commitdiff