| /************************************************************** | |
| * | |
| * 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 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| // MARKER(update_precomp.py): autogen include statement, do not remove | |
| #include "precompiled_basic.hxx" | |
| //#include <stl_queue.h> | |
| #include <osl/mutex.hxx> | |
| #include <comphelper/processfactory.hxx> | |
| #include <com/sun/star/script/XEventAttacher.hpp> | |
| #include <com/sun/star/script/XAllListener.hpp> | |
| #include <com/sun/star/script/XScriptEventsSupplier.hpp> | |
| #include <com/sun/star/script/XScriptEventsAttacher.hpp> | |
| #include <com/sun/star/script/ScriptEventDescriptor.hpp> | |
| #include <com/sun/star/script/XLibraryContainer.hpp> | |
| #include <com/sun/star/beans/XPropertySet.hpp> | |
| #include <com/sun/star/container/XNameContainer.hpp> | |
| #include <com/sun/star/resource/XStringResourceSupplier.hpp> | |
| #include <com/sun/star/resource/XStringResourceManager.hpp> | |
| #include <com/sun/star/awt/XControlContainer.hpp> | |
| #include <com/sun/star/awt/XControlModel.hpp> | |
| #include <com/sun/star/awt/XControl.hpp> | |
| #include <com/sun/star/awt/XDialog.hpp> | |
| #include <com/sun/star/awt/XWindow.hpp> | |
| #include <com/sun/star/script/provider/XScriptProviderFactory.hpp> | |
| #include <com/sun/star/script/provider/XScriptProviderSupplier.hpp> | |
| #include <com/sun/star/script/provider/XScriptProvider.hpp> | |
| #include <com/sun/star/awt/XDialogProvider.hpp> | |
| #include <com/sun/star/frame/XModel.hpp> | |
| #include <com/sun/star/frame/XDesktop.hpp> | |
| #include <com/sun/star/container/XEnumerationAccess.hpp> | |
| #include <basic/basicmanagerrepository.hxx> | |
| #include <basic/basmgr.hxx> | |
| //================================================================================================== | |
| #include <xmlscript/xmldlg_imexp.hxx> | |
| #include <sbunoobj.hxx> | |
| #include <basic/sbstar.hxx> | |
| #include <basic/sbmeth.hxx> | |
| #include <basic/sbuno.hxx> | |
| #include <runtime.hxx> | |
| #include <sbintern.hxx> | |
| #include <cppuhelper/implbase1.hxx> | |
| using namespace ::com::sun::star; | |
| using namespace ::com::sun::star::uno; | |
| using namespace ::com::sun::star::script; | |
| using namespace ::com::sun::star::resource; | |
| using namespace ::com::sun::star::uno; | |
| using namespace ::com::sun::star::lang; | |
| using namespace ::com::sun::star::beans; | |
| using namespace ::com::sun::star::script; | |
| using namespace ::com::sun::star::container; | |
| using namespace ::com::sun::star::reflection; | |
| using namespace ::com::sun::star::awt; | |
| using namespace ::com::sun::star::io; | |
| using namespace ::cppu; | |
| using namespace ::osl; | |
| void SFURL_firing_impl( const ScriptEvent& aScriptEvent, Any* pRet, const Reference< frame::XModel >& xModel ) | |
| { | |
| OSL_TRACE("SFURL_firing_impl() processing script url %s", | |
| ::rtl::OUStringToOString( aScriptEvent.ScriptCode, | |
| RTL_TEXTENCODING_ASCII_US ).pData->buffer ); | |
| try | |
| { | |
| Reference< provider::XScriptProvider > xScriptProvider; | |
| if ( xModel.is() ) | |
| { | |
| Reference< provider::XScriptProviderSupplier > xSupplier( xModel, UNO_QUERY ); | |
| OSL_ENSURE( xSupplier.is(), "SFURL_firing_impl: failed to get script provider supplier" ); | |
| if ( xSupplier.is() ) | |
| xScriptProvider.set( xSupplier->getScriptProvider() ); | |
| } | |
| else | |
| { | |
| Reference< XComponentContext > xContext; | |
| Reference< XPropertySet > xProps( ::comphelper::getProcessServiceFactory(), UNO_QUERY ); | |
| OSL_ASSERT( xProps.is() ); | |
| OSL_VERIFY( xProps->getPropertyValue( ::rtl::OUString::createFromAscii( "DefaultContext" ) ) >>= xContext ); | |
| if ( xContext.is() ) | |
| { | |
| Reference< provider::XScriptProviderFactory > xFactory( | |
| xContext->getValueByName( | |
| ::rtl::OUString::createFromAscii( "/singletons/com.sun.star.script.provider.theMasterScriptProviderFactory" ) ), | |
| UNO_QUERY ); | |
| OSL_ENSURE( xFactory.is(), "SFURL_firing_impl: failed to get master script provider factory" ); | |
| if ( xFactory.is() ) | |
| { | |
| Any aCtx; | |
| aCtx <<= ::rtl::OUString::createFromAscii( "user" ); | |
| xScriptProvider.set( xFactory->createScriptProvider( aCtx ), UNO_QUERY ); | |
| } | |
| } | |
| } | |
| if ( !xScriptProvider.is() ) | |
| { | |
| OSL_TRACE("SFURL_firing_impl() Failed to create msp"); | |
| return; | |
| } | |
| Sequence< Any > inArgs( 0 ); | |
| Sequence< Any > outArgs( 0 ); | |
| Sequence< sal_Int16 > outIndex; | |
| // get Arguments for script | |
| inArgs = aScriptEvent.Arguments; | |
| Reference< provider::XScript > xScript = xScriptProvider->getScript( aScriptEvent.ScriptCode ); | |
| if ( !xScript.is() ) | |
| { | |
| OSL_TRACE("SFURL_firing_impl() Failed to obtain XScript"); | |
| return; | |
| } | |
| Any result = xScript->invoke( inArgs, outIndex, outArgs ); | |
| if ( pRet ) | |
| { | |
| *pRet = result; | |
| } | |
| } | |
| catch ( RuntimeException& re ) | |
| { | |
| OSL_TRACE("SFURL_firing_impl() Caught RuntimeException reason %s.", | |
| ::rtl::OUStringToOString( re.Message, | |
| RTL_TEXTENCODING_ASCII_US ).pData->buffer ); | |
| } | |
| catch ( Exception& e ) | |
| { | |
| OSL_TRACE("SFURL_firing_impl() Caught Exception reason %s.", | |
| ::rtl::OUStringToOString( e.Message, | |
| RTL_TEXTENCODING_ASCII_US ).pData->buffer ); | |
| } | |
| } | |
| class BasicScriptListener_Impl : public WeakImplHelper1< XScriptListener > | |
| { | |
| StarBASICRef maBasicRef; | |
| Reference< frame::XModel > m_xModel; | |
| virtual void firing_impl(const ScriptEvent& aScriptEvent, Any* pRet); | |
| public: | |
| BasicScriptListener_Impl( StarBASIC* pBasic, const Reference< frame::XModel >& xModel ) | |
| : maBasicRef( pBasic ), m_xModel( xModel ) {} | |
| // Methods of XAllListener | |
| virtual void SAL_CALL firing(const ScriptEvent& aScriptEvent); | |
| virtual Any SAL_CALL approveFiring(const ScriptEvent& aScriptEvent); | |
| // Methods of XEventListener | |
| virtual void SAL_CALL disposing(const EventObject& Source); | |
| }; | |
| // Methods XAllListener | |
| void BasicScriptListener_Impl::firing( const ScriptEvent& aScriptEvent ) | |
| { | |
| firing_impl( aScriptEvent, NULL ); | |
| } | |
| Any BasicScriptListener_Impl::approveFiring( const ScriptEvent& aScriptEvent ) | |
| { | |
| Any aRetAny; | |
| firing_impl( aScriptEvent, &aRetAny ); | |
| return aRetAny; | |
| } | |
| // Methods XEventListener | |
| void BasicScriptListener_Impl::disposing(const EventObject& ) | |
| { | |
| // TODO: ??? | |
| //vos::OGuard guard( Application::GetSolarMutex() ); | |
| //xSbxObj.Clear(); | |
| } | |
| void BasicScriptListener_Impl::firing_impl( const ScriptEvent& aScriptEvent, Any* pRet ) | |
| { | |
| //Guard< Mutex > aGuard( Mutex::getGlobalMutex() ); | |
| //{ | |
| if( aScriptEvent.ScriptType.compareToAscii( "StarBasic" ) == 0 ) | |
| { | |
| // Full qualified name? | |
| String aMacro( aScriptEvent.ScriptCode ); | |
| String aLibName; | |
| String aLocation; | |
| if( aMacro.GetTokenCount( '.' ) == 3 ) | |
| { | |
| sal_uInt16 nLast = 0; | |
| ::rtl::OUString aFullLibName = aMacro.GetToken( 0, '.', nLast ); | |
| sal_Int32 nIndex = aFullLibName.indexOf( (sal_Unicode)':' ); | |
| if (nIndex >= 0) | |
| { | |
| aLocation = aFullLibName.copy( 0, nIndex ); | |
| aLibName = aFullLibName.copy( nIndex + 1 ); | |
| } | |
| String aModul = aMacro.GetToken( 0, '.', nLast ); | |
| aMacro.Erase( 0, nLast ); | |
| } | |
| SbxObject* p = maBasicRef; | |
| SbxObject* pParent = p->GetParent(); | |
| SbxObject* pParentParent = pParent ? pParent->GetParent() : NULL; | |
| StarBASICRef xAppStandardBasic; | |
| StarBASICRef xDocStandardBasic; | |
| if( pParentParent ) | |
| { | |
| // Own basic must be document library | |
| xAppStandardBasic = (StarBASIC*)pParentParent; | |
| xDocStandardBasic = (StarBASIC*)pParent; | |
| } | |
| else if( pParent ) | |
| { | |
| String aName = p->GetName(); | |
| if( aName.EqualsAscii("Standard") ) | |
| { | |
| // Own basic is doc standard lib | |
| xDocStandardBasic = (StarBASIC*)p; | |
| } | |
| xAppStandardBasic = (StarBASIC*)pParent; | |
| } | |
| else | |
| { | |
| xAppStandardBasic = (StarBASIC*)p; | |
| } | |
| sal_Bool bSearchLib = true; | |
| StarBASICRef xLibSearchBasic; | |
| if( aLocation.EqualsAscii("application") ) | |
| xLibSearchBasic = xAppStandardBasic; | |
| else if( aLocation.EqualsAscii("document") ) | |
| xLibSearchBasic = xDocStandardBasic; | |
| else | |
| bSearchLib = false; | |
| SbxVariable* pMethVar = NULL; | |
| // Be still tolerant and make default search if no search basic exists | |
| if( bSearchLib && xLibSearchBasic.Is() ) | |
| { | |
| StarBASICRef xLibBasic; | |
| sal_Int16 nCount = xLibSearchBasic->GetObjects()->Count(); | |
| for( sal_Int16 nObj = -1; nObj < nCount ; nObj++ ) | |
| { | |
| StarBASIC* pBasic; | |
| if( nObj == -1 ) | |
| { | |
| pBasic = (StarBASIC*)xLibSearchBasic; | |
| } | |
| else | |
| { | |
| SbxVariable* pVar = xLibSearchBasic->GetObjects()->Get( nObj ); | |
| pBasic = PTR_CAST(StarBASIC,pVar); | |
| } | |
| if( pBasic ) | |
| { | |
| String aName = pBasic->GetName(); | |
| if( aName == aLibName ) | |
| { | |
| // Search only in the lib, not automatically in application basic | |
| sal_uInt16 nFlags = pBasic->GetFlags(); | |
| pBasic->ResetFlag( SBX_GBLSEARCH ); | |
| pMethVar = pBasic->Find( aMacro, SbxCLASS_DONTCARE ); | |
| pBasic->SetFlags( nFlags ); | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| // Default: Be tolerant and search everywhere | |
| if( (!pMethVar || !pMethVar->ISA(SbMethod)) && maBasicRef.Is() ) | |
| pMethVar = maBasicRef->FindQualified( aMacro, SbxCLASS_DONTCARE ); | |
| SbMethod* pMeth = PTR_CAST(SbMethod,pMethVar); | |
| if( !pMeth ) | |
| return; | |
| // Setup parameters | |
| SbxArrayRef xArray; | |
| String aTmp; | |
| sal_Int32 nCnt = aScriptEvent.Arguments.getLength(); | |
| if( nCnt ) | |
| { | |
| xArray = new SbxArray; | |
| const Any *pArgs = aScriptEvent.Arguments.getConstArray(); | |
| for( sal_Int32 i = 0; i < nCnt; i++ ) | |
| { | |
| SbxVariableRef xVar = new SbxVariable( SbxVARIANT ); | |
| unoToSbxValue( (SbxVariable*)xVar, pArgs[i] ); | |
| xArray->Put( xVar, sal::static_int_cast< sal_uInt16 >(i+1) ); | |
| } | |
| } | |
| // Call method | |
| SbxVariableRef xValue = pRet ? new SbxVariable : 0; | |
| if( xArray.Is() ) | |
| pMeth->SetParameters( xArray ); | |
| pMeth->Call( xValue ); | |
| if( pRet ) | |
| *pRet = sbxToUnoValue( xValue ); | |
| pMeth->SetParameters( NULL ); | |
| } | |
| else // scripting framework script | |
| { | |
| //callBasic via scripting framework | |
| SFURL_firing_impl( aScriptEvent, pRet, m_xModel ); | |
| } | |
| } | |
| Any implFindDialogLibForDialog( const Any& rDlgAny, SbxObject* pBasic ) | |
| { | |
| Any aRetDlgLibAny; | |
| SbxVariable* pDlgLibContVar = pBasic->Find | |
| ( String::CreateFromAscii("DialogLibraries"), SbxCLASS_OBJECT ); | |
| if( pDlgLibContVar && pDlgLibContVar->ISA(SbUnoObject) ) | |
| { | |
| SbUnoObject* pDlgLibContUnoObj = (SbUnoObject*)(SbxBase*)pDlgLibContVar; | |
| Any aDlgLibContAny = pDlgLibContUnoObj->getUnoAny(); | |
| Reference< XLibraryContainer > xDlgLibContNameAccess( aDlgLibContAny, UNO_QUERY ); | |
| OSL_ENSURE( xDlgLibContNameAccess.is(), "implFindDialogLibForDialog: no lib container for the given dialog!" ); | |
| if( xDlgLibContNameAccess.is() ) | |
| { | |
| Sequence< ::rtl::OUString > aLibNames = xDlgLibContNameAccess->getElementNames(); | |
| const ::rtl::OUString* pLibNames = aLibNames.getConstArray(); | |
| sal_Int32 nLibNameCount = aLibNames.getLength(); | |
| for( sal_Int32 iLib = 0 ; iLib < nLibNameCount ; iLib++ ) | |
| { | |
| if ( !xDlgLibContNameAccess->isLibraryLoaded( pLibNames[ iLib ] ) ) | |
| // if the library isn't loaded, then the dialog cannot originate from this lib | |
| continue; | |
| Any aDlgLibAny = xDlgLibContNameAccess->getByName( pLibNames[ iLib ] ); | |
| Reference< XNameAccess > xDlgLibNameAccess( aDlgLibAny, UNO_QUERY ); | |
| OSL_ENSURE( xDlgLibNameAccess.is(), "implFindDialogLibForDialog: invalid dialog lib!" ); | |
| if( xDlgLibNameAccess.is() ) | |
| { | |
| Sequence< ::rtl::OUString > aDlgNames = xDlgLibNameAccess->getElementNames(); | |
| const ::rtl::OUString* pDlgNames = aDlgNames.getConstArray(); | |
| sal_Int32 nDlgNameCount = aDlgNames.getLength(); | |
| for( sal_Int32 iDlg = 0 ; iDlg < nDlgNameCount ; iDlg++ ) | |
| { | |
| Any aDlgAny = xDlgLibNameAccess->getByName( pDlgNames[ iDlg ] ); | |
| if( aDlgAny == rDlgAny ) | |
| { | |
| aRetDlgLibAny = aDlgLibAny; | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| return aRetDlgLibAny; | |
| } | |
| Any implFindDialogLibForDialogBasic( const Any& aAnyISP, SbxObject* pBasic, StarBASIC*& pFoundBasic ) | |
| { | |
| Any aDlgLibAny; | |
| // Find dialog library for dialog, direct access is not possible here | |
| StarBASIC* pStartedBasic = (StarBASIC*)pBasic; | |
| SbxObject* pParentBasic = pStartedBasic ? pStartedBasic->GetParent() : NULL; | |
| SbxObject* pParentParentBasic = pParentBasic ? pParentBasic->GetParent() : NULL; | |
| SbxObject* pSearchBasic1 = NULL; | |
| SbxObject* pSearchBasic2 = NULL; | |
| if( pParentParentBasic ) | |
| { | |
| pSearchBasic1 = pParentBasic; | |
| pSearchBasic2 = pParentParentBasic; | |
| } | |
| else | |
| { | |
| pSearchBasic1 = pStartedBasic; | |
| pSearchBasic2 = pParentBasic; | |
| } | |
| if( pSearchBasic1 ) | |
| { | |
| aDlgLibAny = implFindDialogLibForDialog( aAnyISP, pSearchBasic1 ); | |
| if ( aDlgLibAny.hasValue() ) | |
| pFoundBasic = (StarBASIC*)pSearchBasic1; | |
| else if( pSearchBasic2 ) | |
| { | |
| aDlgLibAny = implFindDialogLibForDialog( aAnyISP, pSearchBasic2 ); | |
| if ( aDlgLibAny.hasValue() ) | |
| pFoundBasic = (StarBASIC*)pSearchBasic2; | |
| } | |
| } | |
| return aDlgLibAny; | |
| } | |
| static ::rtl::OUString aDecorationPropName = | |
| ::rtl::OUString::createFromAscii( "Decoration" ); | |
| static ::rtl::OUString aTitlePropName = | |
| ::rtl::OUString::createFromAscii( "Title" ); | |
| void RTL_Impl_CreateUnoDialog( StarBASIC* pBasic, SbxArray& rPar, sal_Bool bWrite ) | |
| { | |
| static ::rtl::OUString aResourceResolverPropName = ::rtl::OUString::createFromAscii( "ResourceResolver" ); | |
| (void)pBasic; | |
| (void)bWrite; | |
| Reference< XMultiServiceFactory > xMSF( comphelper::getProcessServiceFactory() ); | |
| if( !xMSF.is() ) | |
| return; | |
| // We need at least 1 parameter | |
| if ( rPar.Count() < 2 ) | |
| { | |
| StarBASIC::Error( SbERR_BAD_ARGUMENT ); | |
| return; | |
| } | |
| // Get dialog | |
| SbxBaseRef pObj = (SbxBase*)rPar.Get( 1 )->GetObject(); | |
| if( !(pObj && pObj->ISA(SbUnoObject)) ) | |
| { | |
| StarBASIC::Error( SbERR_BAD_ARGUMENT ); | |
| return; | |
| } | |
| SbUnoObject* pUnoObj = (SbUnoObject*)(SbxBase*)pObj; | |
| Any aAnyISP = pUnoObj->getUnoAny(); | |
| TypeClass eType = aAnyISP.getValueType().getTypeClass(); | |
| if( eType != TypeClass_INTERFACE ) | |
| { | |
| StarBASIC::Error( SbERR_BAD_ARGUMENT ); | |
| return; | |
| } | |
| // Create new uno dialog | |
| Reference< XNameContainer > xDialogModel( xMSF->createInstance | |
| ( ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.awt.UnoControlDialogModel" ) ) ), | |
| UNO_QUERY ); | |
| if( !xDialogModel.is() ) | |
| return; | |
| Reference< XInputStreamProvider > xISP; | |
| aAnyISP >>= xISP; | |
| if( !xISP.is() ) | |
| return; | |
| Reference< XComponentContext > xContext; | |
| Reference< XPropertySet > xProps( xMSF, UNO_QUERY ); | |
| OSL_ASSERT( xProps.is() ); | |
| OSL_VERIFY( xProps->getPropertyValue( ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DefaultContext")) ) >>= xContext ); | |
| // Import the DialogModel | |
| Reference< XInputStream > xInput( xISP->createInputStream() ); | |
| // i83963 Force decoration | |
| uno::Reference< beans::XPropertySet > xDlgModPropSet( xDialogModel, uno::UNO_QUERY ); | |
| if( xDlgModPropSet.is() ) | |
| { | |
| bool bDecoration = true; | |
| try | |
| { | |
| Any aDecorationAny = xDlgModPropSet->getPropertyValue( aDecorationPropName ); | |
| aDecorationAny >>= bDecoration; | |
| if( !bDecoration ) | |
| { | |
| xDlgModPropSet->setPropertyValue( aDecorationPropName, makeAny( true ) ); | |
| xDlgModPropSet->setPropertyValue( aTitlePropName, makeAny( ::rtl::OUString() ) ); | |
| } | |
| } | |
| catch( UnknownPropertyException& ) | |
| {} | |
| } | |
| Any aDlgLibAny; | |
| bool bDocDialog = false; | |
| StarBASIC* pFoundBasic = NULL; | |
| OSL_TRACE("About to try get a hold of ThisComponent"); | |
| Reference< frame::XModel > xModel = StarBASIC::GetModelFromBasic( pINST->GetBasic() ) ; | |
| aDlgLibAny = implFindDialogLibForDialogBasic( aAnyISP, pINST->GetBasic(), pFoundBasic ); | |
| // If we found the dialog then it belongs to the Search basic | |
| if ( !pFoundBasic ) | |
| { | |
| Reference< frame::XDesktop > xDesktop( xMSF->createInstance | |
| ( ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.frame.Desktop" ) ) ), | |
| UNO_QUERY ); | |
| Reference< container::XEnumeration > xModels; | |
| if ( xDesktop.is() ) | |
| { | |
| Reference< container::XEnumerationAccess > xComponents( xDesktop->getComponents(), UNO_QUERY ); | |
| if ( xComponents.is() ) | |
| xModels.set( xComponents->createEnumeration(), UNO_QUERY ); | |
| if ( xModels.is() ) | |
| { | |
| while ( xModels->hasMoreElements() ) | |
| { | |
| Reference< frame::XModel > xNextModel( xModels->nextElement(), UNO_QUERY ); | |
| if ( xNextModel.is() ) | |
| { | |
| BasicManager* pMgr = basic::BasicManagerRepository::getDocumentBasicManager( xNextModel ); | |
| if ( pMgr ) | |
| aDlgLibAny = implFindDialogLibForDialogBasic( aAnyISP, pMgr->GetLib(0), pFoundBasic ); | |
| if ( aDlgLibAny.hasValue() ) | |
| { | |
| bDocDialog = true; | |
| xModel = xNextModel; | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| if ( pFoundBasic ) | |
| bDocDialog = pFoundBasic->IsDocBasic(); | |
| Reference< XScriptListener > xScriptListener = new BasicScriptListener_Impl( pINST->GetBasic(), xModel ); | |
| Sequence< Any > aArgs( 4 ); | |
| if( bDocDialog ) | |
| aArgs[ 0 ] <<= xModel; | |
| else | |
| aArgs[ 0 ] <<= uno::Reference< uno::XInterface >(); | |
| aArgs[ 1 ] <<= xInput; | |
| aArgs[ 2 ] = aDlgLibAny; | |
| aArgs[ 3 ] <<= xScriptListener; | |
| // Create a "living" Dialog | |
| Reference< XControl > xCntrl; | |
| try | |
| { | |
| Reference< XDialogProvider > xDlgProv( xMSF->createInstanceWithArguments( ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.scripting.DialogProvider" ) ), aArgs ), UNO_QUERY ); | |
| xCntrl.set( xDlgProv->createDialog( rtl::OUString() ), UNO_QUERY_THROW ); | |
| // Add dialog model to dispose vector | |
| Reference< XComponent > xDlgComponent( xCntrl->getModel(), UNO_QUERY ); | |
| pINST->getComponentVector().push_back( xDlgComponent ); | |
| // need ThisCompoent from calling script | |
| } | |
| // preserve existing bad behaviour, it's possible... but probably | |
| // illegal to open 2 dialogs ( they ARE modal ) when this happens, sometimes | |
| // create dialog fails. So, in this case let's not throw, just leave basic | |
| // detect the unset object. | |
| catch( uno::Exception& ) | |
| { | |
| } | |
| // Return dialog | |
| Any aRetVal; | |
| aRetVal <<= xCntrl; | |
| SbxVariableRef refVar = rPar.Get(0); | |
| unoToSbxValue( (SbxVariable*)refVar, aRetVal ); | |
| } | |
| //=================================================================== |