| /************************************************************** | |
| * | |
| * 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_basctl.hxx" | |
| #include "scriptdocument.hxx" | |
| #include "basobj.hxx" | |
| #include "basidesh.hrc" | |
| #include "iderid.hxx" | |
| #include "dlgeddef.hxx" | |
| #include "localizationmgr.hxx" | |
| #include "doceventnotifier.hxx" | |
| #include "documentenumeration.hxx" | |
| /** === begin UNO includes === **/ | |
| #include <com/sun/star/beans/XPropertySet.hpp> | |
| #include <com/sun/star/script/XLibraryContainer2.hpp> | |
| #include <com/sun/star/lang/XMultiServiceFactory.hpp> | |
| #include <com/sun/star/uri/XUriReferenceFactory.hpp> | |
| #include <com/sun/star/util/XMacroExpander.hpp> | |
| #include <com/sun/star/document/MacroExecMode.hpp> | |
| #include <com/sun/star/document/XEventBroadcaster.hpp> | |
| #include <com/sun/star/frame/XStorable.hpp> | |
| #include <com/sun/star/util/XModifiable.hpp> | |
| #include <com/sun/star/frame/XDispatchProvider.hpp> | |
| #include <com/sun/star/frame/FrameSearchFlag.hpp> | |
| #include <com/sun/star/frame/XDesktop.hpp> | |
| #include <com/sun/star/frame/XModel2.hpp> | |
| #include <com/sun/star/awt/XWindow2.hpp> | |
| #include <com/sun/star/document/XEmbeddedScripts.hpp> | |
| #include <com/sun/star/script/vba/XVBACompatibility.hpp> | |
| #include <com/sun/star/script/vba/XVBAModuleInfo.hpp> | |
| /** === end UNO includes === **/ | |
| #include <sfx2/objsh.hxx> | |
| #include <sfx2/app.hxx> | |
| #include <sfx2/viewfrm.hxx> | |
| #include <sfx2/bindings.hxx> | |
| #include <sfx2/docfile.hxx> | |
| #include <vcl/svapp.hxx> | |
| #include <basic/basicmanagerrepository.hxx> | |
| #include <xmlscript/xmldlg_imexp.hxx> | |
| #include <unotools/syslocale.hxx> | |
| #include <unotools/collatorwrapper.hxx> | |
| #include <tools/diagnose_ex.h> | |
| #include <tools/urlobj.hxx> | |
| #include <comphelper/processfactory.hxx> | |
| #include <comphelper/documentinfo.hxx> | |
| #include <comphelper/componentcontext.hxx> | |
| #include <vos/mutex.hxx> | |
| #include <cppuhelper/implbase1.hxx> | |
| #include <rtl/uri.hxx> | |
| #include <rtl/bootstrap.hxx> | |
| #include <osl/process.h> | |
| #include <osl/file.hxx> | |
| #include <algorithm> | |
| #include <functional> | |
| #include <set> | |
| #include <iterator> | |
| //........................................................................ | |
| namespace basctl | |
| { | |
| //........................................................................ | |
| /** === begin UNO using === **/ | |
| using ::com::sun::star::uno::Sequence; | |
| using ::com::sun::star::uno::Reference; | |
| using ::com::sun::star::frame::XModel; | |
| using ::com::sun::star::beans::XPropertySet; | |
| using ::com::sun::star::script::XLibraryContainer; | |
| using ::com::sun::star::uno::UNO_QUERY_THROW; | |
| using ::com::sun::star::uno::UNO_SET_THROW; | |
| using ::com::sun::star::beans::XPropertySetInfo; | |
| using ::com::sun::star::uno::Exception; | |
| using ::com::sun::star::container::XNameContainer; | |
| using ::com::sun::star::container::NoSuchElementException; | |
| using ::com::sun::star::uno::UNO_QUERY; | |
| using ::com::sun::star::task::XStatusIndicator; | |
| using ::com::sun::star::uno::makeAny; | |
| using ::com::sun::star::script::XLibraryContainer2; | |
| using ::com::sun::star::lang::XMultiServiceFactory; | |
| using ::com::sun::star::uri::XUriReferenceFactory; | |
| using ::com::sun::star::uri::XUriReference; | |
| using ::com::sun::star::uno::XComponentContext; | |
| using ::com::sun::star::util::XMacroExpander; | |
| using ::com::sun::star::io::XInputStreamProvider; | |
| using ::com::sun::star::uno::Any; | |
| using ::com::sun::star::io::XInputStream; | |
| using ::com::sun::star::frame::XStorable; | |
| using ::com::sun::star::util::XModifiable; | |
| using ::com::sun::star::frame::XController; | |
| using ::com::sun::star::frame::XFrame; | |
| using ::com::sun::star::util::URL; | |
| using ::com::sun::star::frame::XDispatchProvider; | |
| using ::com::sun::star::frame::XDispatch; | |
| using ::com::sun::star::beans::PropertyValue; | |
| using ::com::sun::star::frame::XDesktop; | |
| using ::com::sun::star::container::XEnumerationAccess; | |
| using ::com::sun::star::container::XEnumeration; | |
| using ::com::sun::star::frame::XModel2; | |
| using ::com::sun::star::awt::XWindow2; | |
| using ::com::sun::star::document::XEventListener; | |
| using ::com::sun::star::lang::EventObject; | |
| using ::com::sun::star::uno::RuntimeException; | |
| using ::com::sun::star::document::XEventBroadcaster; | |
| using ::com::sun::star::document::XEmbeddedScripts; | |
| using ::com::sun::star::script::ModuleInfo; | |
| using ::com::sun::star::script::vba::XVBACompatibility; | |
| using ::com::sun::star::script::vba::XVBAModuleInfo; | |
| /** === end UNO using === **/ | |
| namespace MacroExecMode = ::com::sun::star::document::MacroExecMode; | |
| namespace FrameSearchFlag = ::com::sun::star::frame::FrameSearchFlag; | |
| //==================================================================== | |
| //= helper | |
| //==================================================================== | |
| namespace | |
| { | |
| //................................................................ | |
| static bool StringCompareLessThan( const String& lhs, const String& rhs ) | |
| { | |
| return ( lhs.CompareIgnoreCaseToAscii( rhs ) == COMPARE_LESS ); | |
| } | |
| //................................................................ | |
| class FilterDocuments : public docs::IDocumentDescriptorFilter | |
| { | |
| public: | |
| FilterDocuments( bool _bFilterInvisible ) : m_bFilterInvisible( _bFilterInvisible ) { } | |
| virtual bool includeDocument( const docs::DocumentDescriptor& _rDocument ) const; | |
| private: | |
| bool impl_isDocumentVisible_nothrow( const docs::DocumentDescriptor& _rDocument ) const; | |
| private: | |
| bool m_bFilterInvisible; | |
| }; | |
| //................................................................ | |
| bool FilterDocuments::impl_isDocumentVisible_nothrow( const docs::DocumentDescriptor& _rDocument ) const | |
| { | |
| try | |
| { | |
| for ( docs::Controllers::const_iterator controller = _rDocument.aControllers.begin(); | |
| controller != _rDocument.aControllers.end(); | |
| ++controller | |
| ) | |
| { | |
| Reference< XFrame > xFrame( (*controller)->getFrame(), UNO_SET_THROW ); | |
| Reference< XWindow2 > xContainer( xFrame->getContainerWindow(), UNO_QUERY_THROW ); | |
| if ( xContainer->isVisible() ) | |
| return true; | |
| } | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| return false; | |
| } | |
| //................................................................ | |
| bool FilterDocuments::includeDocument( const docs::DocumentDescriptor& _rDocument ) const | |
| { | |
| Reference< XEmbeddedScripts > xScripts( _rDocument.xModel, UNO_QUERY ); | |
| if ( !xScripts.is() ) | |
| return false; | |
| if ( !m_bFilterInvisible || impl_isDocumentVisible_nothrow( _rDocument ) ) | |
| return true; | |
| return false; | |
| } | |
| //................................................................ | |
| void lcl_getAllModels_throw( docs::Documents& _out_rModels, bool _bVisibleOnly ) | |
| { | |
| _out_rModels.clear(); | |
| ::comphelper::ComponentContext aContext( ::comphelper::getProcessServiceFactory() ); | |
| FilterDocuments aFilter( _bVisibleOnly ); | |
| docs::DocumentEnumeration aEnum( aContext, &aFilter ); | |
| aEnum.getDocuments( _out_rModels ); | |
| } | |
| } | |
| //==================================================================== | |
| //= ScriptDocument_Impl - declaration | |
| //==================================================================== | |
| class ScriptDocument_Impl : public DocumentEventListener | |
| { | |
| private: | |
| bool m_bIsApplication; | |
| bool m_bValid; | |
| bool m_bDocumentClosed; | |
| Reference< XModel > m_xDocument; | |
| Reference< XModifiable > m_xDocModify; | |
| Reference< XEmbeddedScripts > m_xScriptAccess; | |
| ::std::auto_ptr< DocumentEventNotifier > | |
| m_pDocListener; | |
| public: | |
| ScriptDocument_Impl( ); | |
| ScriptDocument_Impl( const Reference< XModel >& _rxDocument ); | |
| ~ScriptDocument_Impl(); | |
| /** determines whether the instance refers to a valid "document" with script and | |
| dialog libraries | |
| */ | |
| inline bool isValid() const { return m_bValid; } | |
| /** determines whether the instance refers to a non-closed document | |
| */ | |
| inline bool isAlive() const { return m_bValid ? ( m_bIsApplication ? true : !m_bDocumentClosed ) : false; } | |
| /// determines whether the "document" refers to the application in real | |
| inline bool isApplication() const { return m_bValid && m_bIsApplication; } | |
| /// determines whether the document refers to a real document (instead of the application) | |
| inline bool isDocument() const { return m_bValid && !m_bIsApplication; } | |
| /** invalidates the instance | |
| */ | |
| void invalidate(); | |
| const Reference< XModel >& | |
| getDocumentRef() const { return m_xDocument; } | |
| /// returns a library container belonging to the document | |
| Reference< XLibraryContainer > | |
| getLibraryContainer( LibraryContainerType _eType ) const; | |
| /// determines whether a given library is part of the shared installation | |
| bool isLibraryShared( const ::rtl::OUString& _rLibName, LibraryContainerType _eType ); | |
| /** returns the current frame of the document | |
| To be called for documents only, not for the application. | |
| If <FALSE/> is returned, an assertion will be raised in non-product builds. | |
| */ | |
| bool getCurrentFrame( Reference< XFrame >& _out_rxFrame ) const; | |
| // versions with the same signature/semantics as in ScriptDocument itself | |
| bool isReadOnly() const; | |
| bool isInVBAMode() const; | |
| BasicManager* | |
| getBasicManager() const; | |
| Reference< XModel > | |
| getDocument() const; | |
| void setDocumentModified() const; | |
| bool isDocumentModified() const; | |
| bool saveDocument( const Reference< XStatusIndicator >& _rxStatusIndicator ) const; | |
| ::rtl::OUString | |
| getTitle() const; | |
| ::rtl::OUString | |
| getURL() const; | |
| bool allowMacros() const; | |
| Reference< XNameContainer > | |
| getLibrary( LibraryContainerType _eType, const ::rtl::OUString& _rLibName, bool _bLoadLibrary ) const; | |
| bool hasLibrary( LibraryContainerType _eType, const ::rtl::OUString& _rLibName ) const; | |
| Reference< XNameContainer > | |
| getOrCreateLibrary( LibraryContainerType _eType, const ::rtl::OUString& _rLibName ) const; | |
| void loadLibraryIfExists( LibraryContainerType _eType, const ::rtl::OUString& _rLibrary ); | |
| bool removeModuleOrDialog( LibraryContainerType _eType, const ::rtl::OUString& _rLibName, const ::rtl::OUString& _rModuleName ); | |
| bool hasModuleOrDialog( LibraryContainerType _eType, const ::rtl::OUString& _rLibName, const ::rtl::OUString& _rModName ) const; | |
| bool getModuleOrDialog( LibraryContainerType _eType, const ::rtl::OUString& _rLibName, const ::rtl::OUString& _rObjectName, Any& _out_rModuleOrDialog ); | |
| bool renameModuleOrDialog( LibraryContainerType _eType, const ::rtl::OUString& _rLibName, const ::rtl::OUString& _rOldName, const ::rtl::OUString& _rNewName, const Reference< XNameContainer >& _rxExistingDialogModel ); | |
| bool createModule( const ::rtl::OUString& _rLibName, const ::rtl::OUString& _rModName, bool _bCreateMain, ::rtl::OUString& _out_rNewModuleCode ) const; | |
| bool insertModuleOrDialog( LibraryContainerType _eType, const ::rtl::OUString& _rObjectName, const ::rtl::OUString& _rModName, const Any& _rElement ) const; | |
| bool updateModule( const ::rtl::OUString& _rLibName, const ::rtl::OUString& _rModName, const ::rtl::OUString& _rModuleCode ) const; | |
| bool createDialog( const ::rtl::OUString& _rLibName, const ::rtl::OUString& _rDialogName, Reference< XInputStreamProvider >& _out_rDialogProvider ) const; | |
| protected: | |
| // DocumentEventListener | |
| virtual void onDocumentCreated( const ScriptDocument& _rDocument ); | |
| virtual void onDocumentOpened( const ScriptDocument& _rDocument ); | |
| virtual void onDocumentSave( const ScriptDocument& _rDocument ); | |
| virtual void onDocumentSaveDone( const ScriptDocument& _rDocument ); | |
| virtual void onDocumentSaveAs( const ScriptDocument& _rDocument ); | |
| virtual void onDocumentSaveAsDone( const ScriptDocument& _rDocument ); | |
| virtual void onDocumentClosed( const ScriptDocument& _rDocument ); | |
| virtual void onDocumentTitleChanged( const ScriptDocument& _rDocument ); | |
| virtual void onDocumentModeChanged( const ScriptDocument& _rDocument ); | |
| private: | |
| bool impl_initDocument_nothrow( const Reference< XModel >& _rxModel ); | |
| }; | |
| //==================================================================== | |
| //= ScriptDocument_Impl - implementation | |
| //==================================================================== | |
| //-------------------------------------------------------------------- | |
| ScriptDocument_Impl::ScriptDocument_Impl() | |
| :m_bIsApplication( true ) | |
| ,m_bValid( true ) | |
| ,m_bDocumentClosed( false ) | |
| { | |
| } | |
| //-------------------------------------------------------------------- | |
| ScriptDocument_Impl::ScriptDocument_Impl( const Reference< XModel >& _rxDocument ) | |
| :m_bIsApplication( false ) | |
| ,m_bValid( false ) | |
| ,m_bDocumentClosed( false ) | |
| { | |
| if ( _rxDocument.is() ) | |
| { | |
| if ( impl_initDocument_nothrow( _rxDocument ) ) | |
| { | |
| } | |
| } | |
| } | |
| //-------------------------------------------------------------------- | |
| ScriptDocument_Impl::~ScriptDocument_Impl() | |
| { | |
| invalidate(); | |
| } | |
| //-------------------------------------------------------------------- | |
| void ScriptDocument_Impl::invalidate() | |
| { | |
| m_bIsApplication = false; | |
| m_bValid = false; | |
| m_bDocumentClosed = false; | |
| m_xDocument.clear(); | |
| m_xDocModify.clear(); | |
| m_xScriptAccess.clear(); | |
| if ( m_pDocListener.get() ) | |
| m_pDocListener->dispose(); | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument_Impl::impl_initDocument_nothrow( const Reference< XModel >& _rxModel ) | |
| { | |
| try | |
| { | |
| m_xDocument.set ( _rxModel, UNO_SET_THROW ); | |
| m_xDocModify.set ( _rxModel, UNO_QUERY_THROW ); | |
| m_xScriptAccess.set ( _rxModel, UNO_QUERY ); | |
| m_bValid = m_xScriptAccess.is(); | |
| if ( m_bValid ) | |
| m_pDocListener.reset( new DocumentEventNotifier( *this, _rxModel ) ); | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| m_bValid = false; | |
| } | |
| if ( !m_bValid ) | |
| { | |
| invalidate(); | |
| } | |
| return m_bValid; | |
| } | |
| //-------------------------------------------------------------------- | |
| Reference< XLibraryContainer > ScriptDocument_Impl::getLibraryContainer( LibraryContainerType _eType ) const | |
| { | |
| OSL_ENSURE( isValid(), "ScriptDocument_Impl::getLibraryContainer: invalid!" ); | |
| Reference< XLibraryContainer > xContainer; | |
| if ( !isValid() ) | |
| return xContainer; | |
| try | |
| { | |
| if ( isApplication() ) | |
| xContainer.set( _eType == E_SCRIPTS ? SFX_APP()->GetBasicContainer() : SFX_APP()->GetDialogContainer(), UNO_QUERY_THROW ); | |
| else | |
| { | |
| xContainer.set( | |
| _eType == E_SCRIPTS ? m_xScriptAccess->getBasicLibraries() : m_xScriptAccess->getDialogLibraries(), | |
| UNO_QUERY_THROW ); | |
| } | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| return xContainer; | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument_Impl::isReadOnly() const | |
| { | |
| OSL_ENSURE( isValid(), "ScriptDocument_Impl::isReadOnly: invalid state!" ); | |
| OSL_ENSURE( !isApplication(), "ScriptDocument_Impl::isReadOnly: not allowed to be called for the application!" ); | |
| bool bIsReadOnly = true; | |
| if ( isValid() && !isApplication() ) | |
| { | |
| try | |
| { | |
| // note that XStorable is required by the OfficeDocument service | |
| Reference< XStorable > xDocStorable( m_xDocument, UNO_QUERY_THROW ); | |
| bIsReadOnly = xDocStorable->isReadonly(); | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| } | |
| return bIsReadOnly; | |
| } | |
| bool ScriptDocument_Impl::isInVBAMode() const | |
| { | |
| bool bResult = false; | |
| #ifdef FUTURE_VBA_CWS | |
| if ( !isApplication() ) | |
| { | |
| Reference< XVBACompatibility > xVBACompat( getLibraryContainer( E_SCRIPTS ), UNO_QUERY ); | |
| if ( xVBACompat.is() ) | |
| bResult = xVBACompat->getVBACompatibilityMode(); | |
| } | |
| #endif | |
| return bResult; | |
| } | |
| //-------------------------------------------------------------------- | |
| BasicManager* ScriptDocument_Impl::getBasicManager() const | |
| { | |
| OSL_ENSURE( isValid(), "ScriptDocument_Impl::getBasicManager: invalid state!" ); | |
| if ( !isValid() ) | |
| return NULL; | |
| if ( isApplication() ) | |
| return SFX_APP()->GetBasicManager(); | |
| return ::basic::BasicManagerRepository::getDocumentBasicManager( m_xDocument ); | |
| } | |
| //-------------------------------------------------------------------- | |
| Reference< XModel > ScriptDocument_Impl::getDocument() const | |
| { | |
| OSL_ENSURE( isValid(), "ScriptDocument_Impl::getDocument: invalid state!" ); | |
| OSL_ENSURE( isDocument(), "ScriptDocument_Impl::getDocument: for documents only!" ); | |
| if ( !isValid() || !isDocument() ) | |
| return NULL; | |
| return m_xDocument; | |
| } | |
| //-------------------------------------------------------------------- | |
| Reference< XNameContainer > ScriptDocument_Impl::getLibrary( LibraryContainerType _eType, const ::rtl::OUString& _rLibName, bool _bLoadLibrary ) const | |
| { | |
| OSL_ENSURE( isValid(), "ScriptDocument_Impl::getLibrary: invalid state!" ); | |
| Reference< XNameContainer > xContainer; | |
| try | |
| { | |
| Reference< XLibraryContainer > xLibContainer = getLibraryContainer( _eType ); | |
| if ( isValid() ) | |
| { | |
| if ( xLibContainer.is() ) | |
| xContainer.set( xLibContainer->getByName( _rLibName ), UNO_QUERY_THROW ); | |
| } | |
| if ( !xContainer.is() ) | |
| throw NoSuchElementException(); | |
| // load library | |
| if ( _bLoadLibrary && !xLibContainer->isLibraryLoaded( _rLibName ) ) | |
| xLibContainer->loadLibrary( _rLibName ); | |
| } | |
| catch( const NoSuchElementException& ) | |
| { | |
| throw; // allowed to leave | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| return xContainer; | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument_Impl::hasLibrary( LibraryContainerType _eType, const ::rtl::OUString& _rLibName ) const | |
| { | |
| bool bHas = false; | |
| try | |
| { | |
| Reference< XLibraryContainer > xLibContainer = getLibraryContainer( _eType ); | |
| bHas = xLibContainer.is() && xLibContainer->hasByName( _rLibName ); | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| return bHas; | |
| } | |
| //-------------------------------------------------------------------- | |
| Reference< XNameContainer > ScriptDocument_Impl::getOrCreateLibrary( LibraryContainerType _eType, const ::rtl::OUString& _rLibName ) const | |
| { | |
| Reference< XNameContainer > xLibrary; | |
| try | |
| { | |
| Reference< XLibraryContainer > xLibContainer( getLibraryContainer( _eType ), UNO_QUERY_THROW ); | |
| if ( xLibContainer->hasByName( _rLibName ) ) | |
| xLibrary.set( xLibContainer->getByName( _rLibName ), UNO_QUERY_THROW ); | |
| else | |
| xLibrary.set( xLibContainer->createLibrary( _rLibName ), UNO_QUERY_THROW ); | |
| if ( !xLibContainer->isLibraryLoaded( _rLibName ) ) | |
| xLibContainer->loadLibrary( _rLibName ); | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| return xLibrary; | |
| } | |
| //-------------------------------------------------------------------- | |
| void ScriptDocument_Impl::loadLibraryIfExists( LibraryContainerType _eType, const ::rtl::OUString& _rLibrary ) | |
| { | |
| try | |
| { | |
| Reference< XLibraryContainer > xLibContainer( getLibraryContainer( _eType ) ); | |
| if ( xLibContainer.is() && xLibContainer->hasByName( _rLibrary ) && !xLibContainer->isLibraryLoaded( _rLibrary ) ) | |
| xLibContainer->loadLibrary( _rLibrary ); | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument_Impl::removeModuleOrDialog( LibraryContainerType _eType, const ::rtl::OUString& _rLibName, const ::rtl::OUString& _rModuleName ) | |
| { | |
| OSL_ENSURE( isValid(), "ScriptDocument_Impl::removeModuleOrDialog: invalid!" ); | |
| if ( isValid() ) | |
| { | |
| try | |
| { | |
| Reference< XNameContainer > xLib( getLibrary( _eType, _rLibName, sal_True ) ); | |
| if ( xLib.is() ) | |
| { | |
| xLib->removeByName( _rModuleName ); | |
| return true; | |
| } | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| } | |
| return false; | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument_Impl::hasModuleOrDialog( LibraryContainerType _eType, const ::rtl::OUString& _rLibName, const ::rtl::OUString& _rModName ) const | |
| { | |
| OSL_ENSURE( isValid(), "ScriptDocument_Impl::hasModuleOrDialog: invalid!" ); | |
| if ( !isValid() ) | |
| return false; | |
| try | |
| { | |
| Reference< XNameContainer > xLib( getLibrary( _eType, _rLibName, sal_True ) ); | |
| if ( xLib.is() ) | |
| return xLib->hasByName( _rModName ); | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| return false; | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument_Impl::getModuleOrDialog( LibraryContainerType _eType, const ::rtl::OUString& _rLibName, const ::rtl::OUString& _rObjectName, Any& _out_rModuleOrDialog ) | |
| { | |
| OSL_ENSURE( isValid(), "ScriptDocument_Impl::getModuleOrDialog: invalid!" ); | |
| if ( !isValid() ) | |
| return false; | |
| _out_rModuleOrDialog.clear(); | |
| try | |
| { | |
| Reference< XNameContainer > xLib( getLibrary( _eType, _rLibName, sal_True ), UNO_QUERY_THROW ); | |
| if ( xLib->hasByName( _rObjectName ) ) | |
| { | |
| _out_rModuleOrDialog = xLib->getByName( _rObjectName ); | |
| return true; | |
| } | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| return false; | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument_Impl::renameModuleOrDialog( LibraryContainerType _eType, const ::rtl::OUString& _rLibName, | |
| const ::rtl::OUString& _rOldName, const ::rtl::OUString& _rNewName, const Reference< XNameContainer >& _rxExistingDialogModel ) | |
| { | |
| OSL_ENSURE( isValid(), "ScriptDocument_Impl::renameModuleOrDialog: invalid!" ); | |
| if ( !isValid() ) | |
| return false; | |
| try | |
| { | |
| Reference< XNameContainer > xLib( getLibrary( _eType, _rLibName, sal_True ), UNO_QUERY_THROW ); | |
| // get element | |
| Any aElement( xLib->getByName( _rOldName ) ); | |
| // remove element from container | |
| xLib->removeByName( _rOldName ); | |
| // if it's a dialog, import and export, to reflect the new name | |
| if ( _eType == E_DIALOGS ) | |
| { | |
| // create dialog model | |
| ::comphelper::ComponentContext aContext( ::comphelper::getProcessServiceFactory() ); | |
| Reference< XNameContainer > xDialogModel; | |
| if ( _rxExistingDialogModel.is() ) | |
| xDialogModel = _rxExistingDialogModel; | |
| else | |
| if ( !aContext.createComponent( "com.sun.star.awt.UnoControlDialogModel", xDialogModel ) ) | |
| return false; | |
| // import dialog model | |
| Reference< XInputStreamProvider > xISP( aElement, UNO_QUERY_THROW ); | |
| if ( !_rxExistingDialogModel.is() ) | |
| { | |
| Reference< XInputStream > xInput( xISP->createInputStream(), UNO_QUERY_THROW ); | |
| ::xmlscript::importDialogModel( xInput, xDialogModel, aContext.getUNOContext() ); | |
| } | |
| // set new name as property | |
| Reference< XPropertySet > xDlgPSet( xDialogModel, UNO_QUERY_THROW ); | |
| xDlgPSet->setPropertyValue( DLGED_PROP_NAME, makeAny( _rNewName ) ); | |
| // export dialog model | |
| xISP = ::xmlscript::exportDialogModel( xDialogModel, aContext.getUNOContext() ); | |
| aElement <<= xISP; | |
| } | |
| // insert element by new name in container | |
| else if ( _eType == E_SCRIPTS ) | |
| { | |
| Reference< XVBAModuleInfo > xVBAModuleInfo( xLib, UNO_QUERY ); | |
| if ( xVBAModuleInfo->hasModuleInfo( _rOldName ) ) | |
| { | |
| ModuleInfo sModuleInfo = xVBAModuleInfo->getModuleInfo( _rOldName ); | |
| xVBAModuleInfo->removeModuleInfo( _rOldName ); | |
| xVBAModuleInfo->insertModuleInfo( _rNewName, sModuleInfo ); | |
| } | |
| } | |
| xLib->insertByName( _rNewName, aElement ); | |
| return true; | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| return false; | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument_Impl::createModule( const ::rtl::OUString& _rLibName, const ::rtl::OUString& _rModName, bool _bCreateMain, ::rtl::OUString& _out_rNewModuleCode ) const | |
| { | |
| _out_rNewModuleCode = ::rtl::OUString(); | |
| try | |
| { | |
| Reference< XNameContainer > xLib( getLibrary( E_SCRIPTS, _rLibName, sal_True ) ); | |
| if ( !xLib.is() || xLib->hasByName( _rModName ) ) | |
| return false; | |
| // create new module | |
| _out_rNewModuleCode = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "REM ***** BASIC *****\n\n" ) ); | |
| if ( _bCreateMain ) | |
| _out_rNewModuleCode += ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Sub Main\n\nEnd Sub\n" ) ); | |
| // insert module into library | |
| xLib->insertByName( _rModName, makeAny( _out_rNewModuleCode ) ); | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| return false; | |
| } | |
| return true; | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument_Impl::insertModuleOrDialog( LibraryContainerType _eType, const ::rtl::OUString& _rLibName, const ::rtl::OUString& _rObjectName, const Any& _rElement ) const | |
| { | |
| try | |
| { | |
| Reference< XNameContainer > xLib( getOrCreateLibrary( _eType, _rLibName ), UNO_QUERY_THROW ); | |
| if ( xLib->hasByName( _rObjectName ) ) | |
| return false; | |
| xLib->insertByName( _rObjectName, _rElement ); | |
| return true; | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| return false; | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument_Impl::updateModule( const ::rtl::OUString& _rLibName, const ::rtl::OUString& _rModName, const ::rtl::OUString& _rModuleCode ) const | |
| { | |
| try | |
| { | |
| Reference< XNameContainer > xLib( getOrCreateLibrary( E_SCRIPTS, _rLibName ), UNO_QUERY_THROW ); | |
| if ( !xLib->hasByName( _rModName ) ) | |
| return false; | |
| xLib->replaceByName( _rModName, makeAny( _rModuleCode ) ); | |
| return true; | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| return false; | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument_Impl::createDialog( const ::rtl::OUString& _rLibName, const ::rtl::OUString& _rDialogName, Reference< XInputStreamProvider >& _out_rDialogProvider ) const | |
| { | |
| try | |
| { | |
| Reference< XNameContainer > xLib( getLibrary( E_DIALOGS, _rLibName, sal_True ), UNO_QUERY_THROW ); | |
| // create dialog | |
| _out_rDialogProvider.clear(); | |
| if ( xLib->hasByName( _rDialogName ) ) | |
| return false; | |
| // create new dialog model | |
| ::comphelper::ComponentContext aContext( ::comphelper::getProcessServiceFactory() ); | |
| Reference< XNameContainer > xDialogModel; | |
| if ( !aContext.createComponent( "com.sun.star.awt.UnoControlDialogModel", xDialogModel ) ) | |
| return false; | |
| // set name property | |
| Reference< XPropertySet > xDlgPSet( xDialogModel, UNO_QUERY_THROW ); | |
| xDlgPSet->setPropertyValue( DLGED_PROP_NAME, makeAny( _rDialogName ) ); | |
| // export dialog model | |
| _out_rDialogProvider = ::xmlscript::exportDialogModel( xDialogModel, aContext.getUNOContext() ); | |
| // insert dialog into library | |
| xLib->insertByName( _rDialogName, makeAny( _out_rDialogProvider ) ); | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| return _out_rDialogProvider.is(); | |
| } | |
| //-------------------------------------------------------------------- | |
| void ScriptDocument_Impl::setDocumentModified() const | |
| { | |
| OSL_ENSURE( isValid() && isDocument(), "ScriptDocument_Impl::setDocumentModified: only to be called for real documents!" ); | |
| if ( isValid() && isDocument() ) | |
| { | |
| try | |
| { | |
| m_xDocModify->setModified( sal_True ); | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| } | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument_Impl::isDocumentModified() const | |
| { | |
| OSL_ENSURE( isValid() && isDocument(), "ScriptDocument_Impl::isDocumentModified: only to be called for real documents!" ); | |
| bool bIsModified = false; | |
| if ( isValid() && isDocument() ) | |
| { | |
| try | |
| { | |
| bIsModified = m_xDocModify->isModified(); | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| } | |
| return bIsModified; | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument_Impl::saveDocument( const Reference< XStatusIndicator >& _rxStatusIndicator ) const | |
| { | |
| Reference< XFrame > xFrame; | |
| if ( !getCurrentFrame( xFrame ) ) | |
| return false; | |
| Sequence< PropertyValue > aArgs; | |
| if ( _rxStatusIndicator.is() ) | |
| { | |
| aArgs.realloc(1); | |
| aArgs[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "StatusIndicator" ) ); | |
| aArgs[0].Value <<= _rxStatusIndicator; | |
| } | |
| try | |
| { | |
| URL aURL; | |
| aURL.Complete = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:Save" ) ); | |
| aURL.Main = aURL.Complete; | |
| aURL.Protocol = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:" ) ); | |
| aURL.Path = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Save" ) ); | |
| Reference< XDispatchProvider > xDispProv( xFrame, UNO_QUERY_THROW ); | |
| Reference< XDispatch > xDispatch( | |
| xDispProv->queryDispatch( aURL, ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "_self" ) ), FrameSearchFlag::AUTO ), | |
| UNO_SET_THROW ); | |
| xDispatch->dispatch( aURL, aArgs ); | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| return false; | |
| } | |
| return true; | |
| } | |
| //-------------------------------------------------------------------- | |
| ::rtl::OUString ScriptDocument_Impl::getTitle() const | |
| { | |
| OSL_PRECOND( isValid() && isDocument(), "ScriptDocument_Impl::getTitle: for documents only!" ); | |
| ::rtl::OUString sTitle; | |
| if ( isValid() && isDocument() ) | |
| { | |
| sTitle = ::comphelper::DocumentInfo::getDocumentTitle( m_xDocument ); | |
| } | |
| return sTitle; | |
| } | |
| //-------------------------------------------------------------------- | |
| ::rtl::OUString ScriptDocument_Impl::getURL() const | |
| { | |
| OSL_PRECOND( isValid() && isDocument(), "ScriptDocument_Impl::getURL: for documents only!" ); | |
| ::rtl::OUString sURL; | |
| if ( isValid() && isDocument() ) | |
| { | |
| try | |
| { | |
| sURL = m_xDocument->getURL(); | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| } | |
| return sURL; | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument_Impl::allowMacros() const | |
| { | |
| OSL_ENSURE( isValid() && isDocument(), "ScriptDocument_Impl::allowMacros: for documents only!" ); | |
| bool bAllow = false; | |
| if ( isValid() && isDocument() ) | |
| { | |
| try | |
| { | |
| bAllow = m_xScriptAccess->getAllowMacroExecution(); | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| } | |
| return bAllow; | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument_Impl::getCurrentFrame( Reference< XFrame >& _out_rxFrame ) const | |
| { | |
| _out_rxFrame.clear(); | |
| OSL_PRECOND( isValid() && isDocument(), "ScriptDocument_Impl::getCurrentFrame: documents only!" ); | |
| if ( !isValid() || !isDocument() ) | |
| return false; | |
| try | |
| { | |
| Reference< XModel > xDocument( m_xDocument, UNO_SET_THROW ); | |
| Reference< XController > xController( xDocument->getCurrentController(), UNO_SET_THROW ); | |
| _out_rxFrame.set( xController->getFrame(), UNO_SET_THROW ); | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| return _out_rxFrame.is(); | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument_Impl::isLibraryShared( const ::rtl::OUString& _rLibName, LibraryContainerType _eType ) | |
| { | |
| bool bIsShared = false; | |
| try | |
| { | |
| Reference< XLibraryContainer2 > xLibContainer( getLibraryContainer( _eType ), UNO_QUERY_THROW ); | |
| if ( !xLibContainer->hasByName( _rLibName ) || !xLibContainer->isLibraryLink( _rLibName ) ) | |
| return false; | |
| ::rtl::OUString aFileURL; | |
| Reference< XMultiServiceFactory > xMSF( ::comphelper::getProcessServiceFactory() ); | |
| Reference< XUriReferenceFactory > xUriFac; | |
| if ( xMSF.is() ) | |
| { | |
| xUriFac.set( | |
| xMSF->createInstance( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.uri.UriReferenceFactory" ) ) ), | |
| UNO_QUERY_THROW ); | |
| } | |
| ::rtl::OUString aLinkURL( xLibContainer->getLibraryLinkURL( _rLibName ) ); | |
| Reference< XUriReference > xUriRef( xUriFac->parse( aLinkURL ), UNO_QUERY_THROW ); | |
| ::rtl::OUString aScheme = xUriRef->getScheme(); | |
| if ( aScheme.equalsIgnoreAsciiCaseAscii( "file" ) ) | |
| { | |
| aFileURL = aLinkURL; | |
| } | |
| else if ( aScheme.equalsIgnoreAsciiCaseAscii( "vnd.sun.star.pkg" ) ) | |
| { | |
| ::rtl::OUString aAuthority = xUriRef->getAuthority(); | |
| if ( aAuthority.matchIgnoreAsciiCaseAsciiL( RTL_CONSTASCII_STRINGPARAM( "vnd.sun.star.expand:" ) ) ) | |
| { | |
| ::rtl::OUString aDecodedURL( aAuthority.copy( sizeof ( "vnd.sun.star.expand:" ) - 1 ) ); | |
| aDecodedURL = ::rtl::Uri::decode( aDecodedURL, rtl_UriDecodeWithCharset, RTL_TEXTENCODING_UTF8 ); | |
| Reference< XComponentContext > xContext; | |
| Reference< XPropertySet > xProps( xMSF, UNO_QUERY_THROW ); | |
| xContext.set( xProps->getPropertyValue( ::rtl::OUString::createFromAscii( "DefaultContext" ) ), UNO_QUERY_THROW ); | |
| Reference< XMacroExpander > xMacroExpander( | |
| xContext->getValueByName( | |
| ::rtl::OUString::createFromAscii( "/singletons/com.sun.star.util.theMacroExpander" ) ), | |
| UNO_QUERY_THROW ); | |
| aFileURL = xMacroExpander->expandMacros( aDecodedURL ); | |
| } | |
| } | |
| if ( !aFileURL.isEmpty() ) | |
| { | |
| ::osl::DirectoryItem aFileItem; | |
| ::osl::FileStatus aFileStatus( FileStatusMask_FileURL ); | |
| OSL_VERIFY( ::osl::DirectoryItem::get( aFileURL, aFileItem ) == ::osl::FileBase::E_None ); | |
| OSL_VERIFY( aFileItem.getFileStatus( aFileStatus ) == ::osl::FileBase::E_None ); | |
| ::rtl::OUString aCanonicalFileURL( aFileStatus.getFileURL() ); | |
| ::rtl::OUString aSearchURL1( RTL_CONSTASCII_USTRINGPARAM( "share/basic" ) ); | |
| ::rtl::OUString aSearchURL2( RTL_CONSTASCII_USTRINGPARAM( "share/uno_packages" ) ); | |
| ::rtl::OUString aSearchURL3( RTL_CONSTASCII_USTRINGPARAM( "share/extensions" ) ); | |
| if( aCanonicalFileURL.indexOf( aSearchURL1 ) != -1 || | |
| aCanonicalFileURL.indexOf( aSearchURL2 ) != -1 || | |
| aCanonicalFileURL.indexOf( aSearchURL3 ) != -1 ) | |
| bIsShared = true; | |
| } | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| return bIsShared; | |
| } | |
| //-------------------------------------------------------------------- | |
| void ScriptDocument_Impl::onDocumentCreated( const ScriptDocument& /*_rDocument*/ ) | |
| { | |
| // not interested in | |
| } | |
| //-------------------------------------------------------------------- | |
| void ScriptDocument_Impl::onDocumentOpened( const ScriptDocument& /*_rDocument*/ ) | |
| { | |
| // not interested in | |
| } | |
| //-------------------------------------------------------------------- | |
| void ScriptDocument_Impl::onDocumentSave( const ScriptDocument& /*_rDocument*/ ) | |
| { | |
| // not interested in | |
| } | |
| //-------------------------------------------------------------------- | |
| void ScriptDocument_Impl::onDocumentSaveDone( const ScriptDocument& /*_rDocument*/ ) | |
| { | |
| // not interested in | |
| } | |
| //-------------------------------------------------------------------- | |
| void ScriptDocument_Impl::onDocumentSaveAs( const ScriptDocument& /*_rDocument*/ ) | |
| { | |
| // not interested in | |
| } | |
| //-------------------------------------------------------------------- | |
| void ScriptDocument_Impl::onDocumentSaveAsDone( const ScriptDocument& /*_rDocument*/ ) | |
| { | |
| // not interested in | |
| } | |
| //-------------------------------------------------------------------- | |
| void ScriptDocument_Impl::onDocumentClosed( const ScriptDocument& _rDocument ) | |
| { | |
| DBG_TESTSOLARMUTEX(); | |
| OSL_PRECOND( isValid(), "ScriptDocument_Impl::onDocumentClosed: should not be listening if I'm not valid!" ); | |
| bool bMyDocument = m_xDocument == _rDocument.getDocument(); | |
| OSL_PRECOND( bMyDocument, "ScriptDocument_Impl::onDocumentClosed: didn't want to know *this*!" ); | |
| if ( bMyDocument ) | |
| { | |
| m_bDocumentClosed = true; | |
| } | |
| } | |
| //-------------------------------------------------------------------- | |
| void ScriptDocument_Impl::onDocumentTitleChanged( const ScriptDocument& /*_rDocument*/ ) | |
| { | |
| // not interested in | |
| } | |
| //-------------------------------------------------------------------- | |
| void ScriptDocument_Impl::onDocumentModeChanged( const ScriptDocument& /*_rDocument*/ ) | |
| { | |
| // not interested in | |
| } | |
| //==================================================================== | |
| //= ScriptDocument | |
| //==================================================================== | |
| //-------------------------------------------------------------------- | |
| ScriptDocument::ScriptDocument() | |
| :m_pImpl( new ScriptDocument_Impl() ) | |
| { | |
| } | |
| //-------------------------------------------------------------------- | |
| ScriptDocument::ScriptDocument( ScriptDocument::SpecialDocument _eType ) | |
| :m_pImpl( new ScriptDocument_Impl( Reference< XModel >() ) ) | |
| { | |
| OSL_ENSURE( _eType == NoDocument, "ScriptDocument::ScriptDocument: unknown SpecialDocument type!" ); | |
| (void)_eType; | |
| } | |
| //-------------------------------------------------------------------- | |
| ScriptDocument::ScriptDocument( const Reference< XModel >& _rxDocument ) | |
| :m_pImpl( new ScriptDocument_Impl( _rxDocument ) ) | |
| { | |
| OSL_ENSURE( _rxDocument.is(), "ScriptDocument::ScriptDocument: document must not be NULL!" ); | |
| // a NULL document results in an uninitialized instance, and for this | |
| // purpose, there is a dedicated constructor | |
| } | |
| //-------------------------------------------------------------------- | |
| ScriptDocument::ScriptDocument( const ScriptDocument& _rSource ) | |
| :m_pImpl( _rSource.m_pImpl ) | |
| { | |
| } | |
| //-------------------------------------------------------------------- | |
| ScriptDocument::~ScriptDocument() | |
| { | |
| } | |
| //-------------------------------------------------------------------- | |
| const ScriptDocument& ScriptDocument::getApplicationScriptDocument() | |
| { | |
| static ScriptDocument s_aApplicationScripts; | |
| return s_aApplicationScripts; | |
| } | |
| //-------------------------------------------------------------------- | |
| ScriptDocument ScriptDocument::getDocumentForBasicManager( const BasicManager* _pManager ) | |
| { | |
| if ( _pManager == SFX_APP()->GetBasicManager() ) | |
| return getApplicationScriptDocument(); | |
| docs::Documents aDocuments; | |
| lcl_getAllModels_throw( aDocuments, false ); | |
| for ( docs::Documents::const_iterator doc = aDocuments.begin(); | |
| doc != aDocuments.end(); | |
| ++doc | |
| ) | |
| { | |
| const BasicManager* pDocBasicManager = ::basic::BasicManagerRepository::getDocumentBasicManager( doc->xModel ); | |
| if ( ( pDocBasicManager != SFX_APP()->GetBasicManager() ) | |
| && ( pDocBasicManager == _pManager ) | |
| ) | |
| { | |
| return ScriptDocument( doc->xModel ); | |
| } | |
| } | |
| OSL_ENSURE( false, "ScriptDocument::getDocumentForBasicManager: did not find a document for this manager!" ); | |
| return ScriptDocument( NoDocument ); | |
| } | |
| //-------------------------------------------------------------------- | |
| ScriptDocument ScriptDocument::getDocumentWithURLOrCaption( const ::rtl::OUString& _rUrlOrCaption ) | |
| { | |
| ScriptDocument aDocument( getApplicationScriptDocument() ); | |
| if ( _rUrlOrCaption.isEmpty() ) | |
| return aDocument; | |
| docs::Documents aDocuments; | |
| lcl_getAllModels_throw( aDocuments, false ); | |
| for ( docs::Documents::const_iterator doc = aDocuments.begin(); | |
| doc != aDocuments.end(); | |
| ++doc | |
| ) | |
| { | |
| const ScriptDocument aCheck = ScriptDocument( doc->xModel ); | |
| if ( _rUrlOrCaption == aCheck.getTitle() | |
| || _rUrlOrCaption == aCheck.getURL() | |
| ) | |
| { | |
| aDocument = aCheck; | |
| break; | |
| } | |
| } | |
| return aDocument; | |
| } | |
| //-------------------------------------------------------------------- | |
| namespace | |
| { | |
| struct DocumentTitleLess : public ::std::binary_function< ScriptDocument, ScriptDocument, bool > | |
| { | |
| DocumentTitleLess( const CollatorWrapper& _rCollator ) | |
| :m_aCollator( _rCollator ) | |
| { | |
| } | |
| bool operator()( const ScriptDocument& _lhs, const ScriptDocument& _rhs ) const | |
| { | |
| return m_aCollator.compareString( _lhs.getTitle(), _rhs.getTitle() ) < 0; | |
| } | |
| private: | |
| const CollatorWrapper m_aCollator; | |
| }; | |
| } | |
| //-------------------------------------------------------------------- | |
| ScriptDocuments ScriptDocument::getAllScriptDocuments( ScriptDocument::ScriptDocumentList _eListType ) | |
| { | |
| ScriptDocuments aScriptDocs; | |
| // include application? | |
| if ( _eListType == AllWithApplication ) | |
| aScriptDocs.push_back( getApplicationScriptDocument() ); | |
| // obtain documents | |
| try | |
| { | |
| docs::Documents aDocuments; | |
| lcl_getAllModels_throw( aDocuments, true /* exclude invisible */ ); | |
| for ( docs::Documents::const_iterator doc = aDocuments.begin(); | |
| doc != aDocuments.end(); | |
| ++doc | |
| ) | |
| { | |
| // exclude documents without script/library containers | |
| ScriptDocument aDoc( doc->xModel ); | |
| if ( !aDoc.isValid() ) | |
| continue; | |
| aScriptDocs.push_back( aDoc ); | |
| } | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| // sort document list by doc title? | |
| if ( _eListType == DocumentsSorted ) | |
| { | |
| CollatorWrapper aCollator( ::comphelper::getProcessServiceFactory() ); | |
| aCollator.loadDefaultCollator( SvtSysLocale().GetLocaleData().getLocale(), 0 ); | |
| ::std::sort( aScriptDocs.begin(), aScriptDocs.end(), DocumentTitleLess( aCollator ) ); | |
| } | |
| return aScriptDocs; | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument::operator==( const ScriptDocument& _rhs ) const | |
| { | |
| return m_pImpl->getDocumentRef() == _rhs.m_pImpl->getDocumentRef(); | |
| } | |
| //-------------------------------------------------------------------- | |
| sal_Int32 ScriptDocument::hashCode() const | |
| { | |
| return sal::static_int_cast<sal_Int32>(reinterpret_cast< sal_IntPtr >( m_pImpl->getDocumentRef().get() )); | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument::isValid() const | |
| { | |
| return m_pImpl->isValid(); | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument::isAlive() const | |
| { | |
| return m_pImpl->isAlive(); | |
| } | |
| //-------------------------------------------------------------------- | |
| Reference< XLibraryContainer > ScriptDocument::getLibraryContainer( LibraryContainerType _eType ) const | |
| { | |
| return m_pImpl->getLibraryContainer( _eType ); | |
| } | |
| //-------------------------------------------------------------------- | |
| Reference< XNameContainer > ScriptDocument::getLibrary( LibraryContainerType _eType, const ::rtl::OUString& _rLibName, bool _bLoadLibrary ) const | |
| { | |
| return m_pImpl->getLibrary( _eType, _rLibName, _bLoadLibrary ); | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument::hasLibrary( LibraryContainerType _eType, const ::rtl::OUString& _rLibName ) const | |
| { | |
| return m_pImpl->hasLibrary( _eType, _rLibName ); | |
| } | |
| //-------------------------------------------------------------------- | |
| Reference< XNameContainer > ScriptDocument::getOrCreateLibrary( LibraryContainerType _eType, const ::rtl::OUString& _rLibName ) const | |
| { | |
| return m_pImpl->getOrCreateLibrary( _eType, _rLibName ); | |
| } | |
| //-------------------------------------------------------------------- | |
| void ScriptDocument::loadLibraryIfExists( LibraryContainerType _eType, const ::rtl::OUString& _rLibrary ) | |
| { | |
| m_pImpl->loadLibraryIfExists( _eType, _rLibrary ); | |
| } | |
| //-------------------------------------------------------------------- | |
| Sequence< ::rtl::OUString > ScriptDocument::getObjectNames( LibraryContainerType _eType, const ::rtl::OUString& _rLibName ) const | |
| { | |
| Sequence< ::rtl::OUString > aModuleNames; | |
| try | |
| { | |
| if ( hasLibrary( _eType, _rLibName ) ) | |
| { | |
| Reference< XNameContainer > xLib( getLibrary( _eType, _rLibName, false ) ); | |
| if ( xLib.is() ) | |
| aModuleNames = xLib->getElementNames(); | |
| } | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| // sort | |
| ::std::sort( aModuleNames.getArray() , aModuleNames.getArray() + aModuleNames.getLength() , StringCompareLessThan ); | |
| return aModuleNames; | |
| } | |
| //-------------------------------------------------------------------- | |
| ::rtl::OUString ScriptDocument::createObjectName( LibraryContainerType _eType, const ::rtl::OUString& _rLibName ) const | |
| { | |
| ::rtl::OUString aObjectName; | |
| ::rtl::OUString aBaseName = _eType == E_SCRIPTS | |
| ? ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Module" ) ) | |
| : ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Dialog" ) ); | |
| Sequence< ::rtl::OUString > aUsedNames( getObjectNames( _eType, _rLibName ) ); | |
| ::std::set< ::rtl::OUString > aUsedNamesCheck; | |
| ::std::copy( aUsedNames.getConstArray(), aUsedNames.getConstArray() + aUsedNames.getLength(), | |
| ::std::insert_iterator< ::std::set< ::rtl::OUString > >( aUsedNamesCheck, aUsedNamesCheck.begin() ) ); | |
| bool bValid = false; | |
| sal_uInt16 i = 1; | |
| while ( !bValid ) | |
| { | |
| aObjectName = aBaseName; | |
| aObjectName += String::CreateFromInt32( i ); | |
| if ( aUsedNamesCheck.find( aObjectName ) == aUsedNamesCheck.end() ) | |
| bValid = sal_True; | |
| ++i; | |
| } | |
| return aObjectName; | |
| } | |
| //-------------------------------------------------------------------- | |
| Sequence< ::rtl::OUString > ScriptDocument::getLibraryNames() const | |
| { | |
| return BasicIDE::GetMergedLibraryNames( getLibraryContainer( E_SCRIPTS ), getLibraryContainer( E_DIALOGS ) ); | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument::isReadOnly() const | |
| { | |
| return m_pImpl->isReadOnly(); | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument::isApplication() const | |
| { | |
| return m_pImpl->isApplication(); | |
| } | |
| bool ScriptDocument::isInVBAMode() const | |
| { | |
| return m_pImpl->isInVBAMode(); | |
| } | |
| //-------------------------------------------------------------------- | |
| BasicManager* ScriptDocument::getBasicManager() const | |
| { | |
| return m_pImpl->getBasicManager(); | |
| } | |
| //-------------------------------------------------------------------- | |
| Reference< XModel > ScriptDocument::getDocument() const | |
| { | |
| return m_pImpl->getDocument(); | |
| } | |
| //-------------------------------------------------------------------- | |
| Reference< XModel > ScriptDocument::getDocumentOrNull() const | |
| { | |
| if ( isDocument() ) | |
| return m_pImpl->getDocument(); | |
| return NULL; | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument::removeModule( const ::rtl::OUString& _rLibName, const ::rtl::OUString& _rModuleName ) const | |
| { | |
| return m_pImpl->removeModuleOrDialog( E_SCRIPTS, _rLibName, _rModuleName ); | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument::hasModule( const ::rtl::OUString& _rLibName, const ::rtl::OUString& _rModuleName ) const | |
| { | |
| return m_pImpl->hasModuleOrDialog( E_SCRIPTS, _rLibName, _rModuleName ); | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument::getModule( const ::rtl::OUString& _rLibName, const ::rtl::OUString& _rModName, ::rtl::OUString& _out_rModuleSource ) const | |
| { | |
| Any aCode; | |
| if ( !m_pImpl->getModuleOrDialog( E_SCRIPTS, _rLibName, _rModName, aCode ) ) | |
| return false; | |
| OSL_VERIFY( aCode >>= _out_rModuleSource ); | |
| return true; | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument::renameModule( const ::rtl::OUString& _rLibName, const ::rtl::OUString& _rOldName, const ::rtl::OUString& _rNewName ) const | |
| { | |
| return m_pImpl->renameModuleOrDialog( E_SCRIPTS, _rLibName, _rOldName, _rNewName, NULL ); | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument::createModule( const ::rtl::OUString& _rLibName, const ::rtl::OUString& _rModName, bool _bCreateMain, ::rtl::OUString& _out_rNewModuleCode ) const | |
| { | |
| if ( !m_pImpl->createModule( _rLibName, _rModName, _bCreateMain, _out_rNewModuleCode ) ) | |
| return false; | |
| // doc shell modified | |
| BasicIDE::MarkDocumentModified( *const_cast< ScriptDocument* >( this ) ); // here? | |
| return true; | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument::insertModule( const ::rtl::OUString& _rLibName, const ::rtl::OUString& _rModName, const ::rtl::OUString& _rModuleCode ) const | |
| { | |
| return m_pImpl->insertModuleOrDialog( E_SCRIPTS, _rLibName, _rModName, makeAny( _rModuleCode ) ); | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument::updateModule( const ::rtl::OUString& _rLibName, const ::rtl::OUString& _rModName, const ::rtl::OUString& _rModuleCode ) const | |
| { | |
| return m_pImpl->updateModule( _rLibName, _rModName, _rModuleCode ); | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument::removeDialog( const ::rtl::OUString& _rLibName, const ::rtl::OUString& _rDialogName ) const | |
| { | |
| return m_pImpl->removeModuleOrDialog( E_DIALOGS, _rLibName, _rDialogName ); | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument::hasDialog( const ::rtl::OUString& _rLibName, const ::rtl::OUString& _rDialogName ) const | |
| { | |
| return m_pImpl->hasModuleOrDialog( E_DIALOGS, _rLibName, _rDialogName ); | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument::getDialog( const ::rtl::OUString& _rLibName, const ::rtl::OUString& _rDialogName, Reference< XInputStreamProvider >& _out_rDialogProvider ) const | |
| { | |
| Any aCode; | |
| if ( !m_pImpl->getModuleOrDialog( E_DIALOGS, _rLibName, _rDialogName, aCode ) ) | |
| return false; | |
| OSL_VERIFY( aCode >>= _out_rDialogProvider ); | |
| return _out_rDialogProvider.is(); | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument::renameDialog( const ::rtl::OUString& _rLibName, const ::rtl::OUString& _rOldName, const ::rtl::OUString& _rNewName, const Reference< XNameContainer >& _rxExistingDialogModel ) const | |
| { | |
| return m_pImpl->renameModuleOrDialog( E_DIALOGS, _rLibName, _rOldName, _rNewName, _rxExistingDialogModel ); | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument::createDialog( const ::rtl::OUString& _rLibName, const ::rtl::OUString& _rDialogName, Reference< XInputStreamProvider >& _out_rDialogProvider ) const | |
| { | |
| if ( !m_pImpl->createDialog( _rLibName, _rDialogName, _out_rDialogProvider ) ) | |
| return false; | |
| BasicIDE::MarkDocumentModified( *const_cast< ScriptDocument* >( this ) ); // here? | |
| return true; | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument::insertDialog( const ::rtl::OUString& _rLibName, const ::rtl::OUString& _rDialogName, const Reference< XInputStreamProvider >& _rxDialogProvider ) const | |
| { | |
| return m_pImpl->insertModuleOrDialog( E_DIALOGS, _rLibName, _rDialogName, makeAny( _rxDialogProvider ) ); | |
| } | |
| //-------------------------------------------------------------------- | |
| void ScriptDocument::setDocumentModified() const | |
| { | |
| m_pImpl->setDocumentModified(); | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument::isDocumentModified() const | |
| { | |
| return m_pImpl->isDocumentModified(); | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument::saveDocument( const Reference< XStatusIndicator >& _rxStatusIndicator ) const | |
| { | |
| return m_pImpl->saveDocument( _rxStatusIndicator ); | |
| } | |
| //-------------------------------------------------------------------- | |
| LibraryLocation ScriptDocument::getLibraryLocation( const ::rtl::OUString& _rLibName ) const | |
| { | |
| LibraryLocation eLocation = LIBRARY_LOCATION_UNKNOWN; | |
| if ( !_rLibName.isEmpty() ) | |
| { | |
| if ( isDocument() ) | |
| { | |
| eLocation = LIBRARY_LOCATION_DOCUMENT; | |
| } | |
| else | |
| { | |
| if ( ( hasLibrary( E_SCRIPTS, _rLibName ) && !m_pImpl->isLibraryShared( _rLibName, E_SCRIPTS ) ) | |
| || ( hasLibrary( E_DIALOGS, _rLibName ) && !m_pImpl->isLibraryShared( _rLibName, E_DIALOGS ) ) | |
| ) | |
| { | |
| eLocation = LIBRARY_LOCATION_USER; | |
| } | |
| else | |
| { | |
| eLocation = LIBRARY_LOCATION_SHARE; | |
| } | |
| } | |
| } | |
| return eLocation; | |
| } | |
| //-------------------------------------------------------------------- | |
| ::rtl::OUString ScriptDocument::getTitle( LibraryLocation _eLocation, LibraryType _eType ) const | |
| { | |
| ::rtl::OUString aTitle; | |
| switch ( _eLocation ) | |
| { | |
| case LIBRARY_LOCATION_USER: | |
| { | |
| switch ( _eType ) | |
| { | |
| case LIBRARY_TYPE_MODULE: aTitle = String( IDEResId( RID_STR_USERMACROS ) ); break; | |
| case LIBRARY_TYPE_DIALOG: aTitle = String( IDEResId( RID_STR_USERDIALOGS ) ); break; | |
| case LIBRARY_TYPE_ALL: aTitle = String( IDEResId( RID_STR_USERMACROSDIALOGS ) ); break; | |
| default: | |
| break; | |
| } | |
| break; | |
| case LIBRARY_LOCATION_SHARE: | |
| { | |
| switch ( _eType ) | |
| { | |
| case LIBRARY_TYPE_MODULE: aTitle = String( IDEResId( RID_STR_SHAREMACROS ) ); break; | |
| case LIBRARY_TYPE_DIALOG: aTitle = String( IDEResId( RID_STR_SHAREDIALOGS ) ); break; | |
| case LIBRARY_TYPE_ALL: aTitle = String( IDEResId( RID_STR_SHAREMACROSDIALOGS ) ); break; | |
| default: | |
| break; | |
| } | |
| } | |
| break; | |
| case LIBRARY_LOCATION_DOCUMENT: | |
| aTitle = getTitle(); | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| return aTitle; | |
| } | |
| //-------------------------------------------------------------------- | |
| ::rtl::OUString ScriptDocument::getTitle() const | |
| { | |
| return m_pImpl->getTitle(); | |
| } | |
| //-------------------------------------------------------------------- | |
| ::rtl::OUString ScriptDocument::getURL() const | |
| { | |
| return m_pImpl->getURL(); | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument::isActive() const | |
| { | |
| bool bIsActive( false ); | |
| try | |
| { | |
| Reference< XFrame > xFrame; | |
| if ( m_pImpl->getCurrentFrame( xFrame ) ) | |
| bIsActive = xFrame->isActive(); | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| return bIsActive; | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ScriptDocument::allowMacros() const | |
| { | |
| return m_pImpl->allowMacros(); | |
| } | |
| //........................................................................ | |
| } // namespace basctl | |
| //........................................................................ |