| /************************************************************** | |
| * | |
| * 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_desktop.hxx" | |
| #include "dispatchwatcher.hxx" | |
| #include <rtl/ustring.hxx> | |
| #include <tools/string.hxx> | |
| #include <comphelper/processfactory.hxx> | |
| #include <comphelper/synchronousdispatch.hxx> | |
| #include <com/sun/star/util/XCloseable.hpp> | |
| #include <com/sun/star/util/CloseVetoException.hpp> | |
| #include <com/sun/star/task/XInteractionHandler.hpp> | |
| #include <com/sun/star/util/URL.hpp> | |
| #include <com/sun/star/frame/XDesktop.hpp> | |
| #include <com/sun/star/container/XEnumeration.hpp> | |
| #include <com/sun/star/frame/XFramesSupplier.hpp> | |
| #include <com/sun/star/frame/XDispatch.hpp> | |
| #include <com/sun/star/frame/XComponentLoader.hpp> | |
| #include <com/sun/star/beans/PropertyValue.hpp> | |
| #include <com/sun/star/view/XPrintable.hpp> | |
| #include <com/sun/star/frame/XDispatchProvider.hpp> | |
| #include <com/sun/star/util/XURLTransformer.hpp> | |
| #include <com/sun/star/document/MacroExecMode.hpp> | |
| #include <com/sun/star/document/UpdateDocMode.hpp> | |
| #include <tools/urlobj.hxx> | |
| #include <comphelper/mediadescriptor.hxx> | |
| #include <vector> | |
| using namespace ::rtl; | |
| using namespace ::osl; | |
| using namespace ::com::sun::star::uno; | |
| using namespace ::com::sun::star::util; | |
| using namespace ::com::sun::star::lang; | |
| using namespace ::com::sun::star::frame; | |
| using namespace ::com::sun::star::container; | |
| using namespace ::com::sun::star::beans; | |
| using namespace ::com::sun::star::view; | |
| namespace desktop | |
| { | |
| String GetURL_Impl( | |
| const String& rName, boost::optional< rtl::OUString > const & cwdUrl ); | |
| struct DispatchHolder | |
| { | |
| DispatchHolder( const URL& rURL, Reference< XDispatch >& rDispatch ) : | |
| aURL( rURL ), xDispatch( rDispatch ) {} | |
| URL aURL; | |
| rtl::OUString cwdUrl; | |
| Reference< XDispatch > xDispatch; | |
| }; | |
| Mutex* DispatchWatcher::pWatcherMutex = NULL; | |
| Mutex& DispatchWatcher::GetMutex() | |
| { | |
| if ( !pWatcherMutex ) | |
| { | |
| ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() ); | |
| if ( !pWatcherMutex ) | |
| pWatcherMutex = new osl::Mutex(); | |
| } | |
| return *pWatcherMutex; | |
| } | |
| // Create or get the dispatch watcher implementation. This implementation must be | |
| // a singleton to prevent access to the framework after it wants to terminate. | |
| DispatchWatcher* DispatchWatcher::GetDispatchWatcher() | |
| { | |
| static Reference< XInterface > xDispatchWatcher; | |
| static DispatchWatcher* pDispatchWatcher = NULL; | |
| if ( !xDispatchWatcher.is() ) | |
| { | |
| ::osl::MutexGuard aGuard( GetMutex() ); | |
| if ( !xDispatchWatcher.is() ) | |
| { | |
| pDispatchWatcher = new DispatchWatcher(); | |
| // We have to hold a reference to ourself forever to prevent our own destruction. | |
| xDispatchWatcher = static_cast< cppu::OWeakObject *>( pDispatchWatcher ); | |
| } | |
| } | |
| return pDispatchWatcher; | |
| } | |
| DispatchWatcher::DispatchWatcher() | |
| : m_nRequestCount(0) | |
| { | |
| } | |
| DispatchWatcher::~DispatchWatcher() | |
| { | |
| } | |
| sal_Bool DispatchWatcher::executeDispatchRequests( const DispatchList& aDispatchRequestsList, bool bNoTerminate ) | |
| { | |
| Reference< XComponentLoader > xDesktop( ::comphelper::getProcessServiceFactory()->createInstance( | |
| OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.frame.Desktop")) ), | |
| UNO_QUERY ); | |
| DispatchList::const_iterator p; | |
| std::vector< DispatchHolder > aDispatches; | |
| ::rtl::OUString aAsTemplateArg( RTL_CONSTASCII_USTRINGPARAM( "AsTemplate")); | |
| for ( p = aDispatchRequestsList.begin(); p != aDispatchRequestsList.end(); p++ ) | |
| { | |
| String aPrinterName; | |
| const DispatchRequest& aDispatchRequest = *p; | |
| // create parameter array | |
| sal_Int32 nCount = 4; | |
| if ( aDispatchRequest.aPreselectedFactory.getLength() ) | |
| nCount++; | |
| // we need more properties for a print/print to request | |
| if ( aDispatchRequest.aRequestType == REQUEST_PRINT || | |
| aDispatchRequest.aRequestType == REQUEST_PRINTTO ) | |
| nCount++; | |
| Sequence < PropertyValue > aArgs( nCount ); | |
| // mark request as user interaction from outside | |
| aArgs[0].Name = ::rtl::OUString::createFromAscii("Referer"); | |
| aArgs[0].Value <<= ::rtl::OUString::createFromAscii("private:OpenEvent"); | |
| if ( aDispatchRequest.aRequestType == REQUEST_PRINT || | |
| aDispatchRequest.aRequestType == REQUEST_PRINTTO ) | |
| { | |
| aArgs[1].Name = ::rtl::OUString::createFromAscii("ReadOnly"); | |
| aArgs[2].Name = ::rtl::OUString::createFromAscii("OpenNewView"); | |
| aArgs[3].Name = ::rtl::OUString::createFromAscii("Hidden"); | |
| aArgs[4].Name = ::rtl::OUString::createFromAscii("Silent"); | |
| } | |
| else | |
| { | |
| Reference < com::sun::star::task::XInteractionHandler > xInteraction( | |
| ::comphelper::getProcessServiceFactory()->createInstance( OUString::createFromAscii("com.sun.star.task.InteractionHandler") ), | |
| com::sun::star::uno::UNO_QUERY ); | |
| aArgs[1].Name = OUString::createFromAscii( "InteractionHandler" ); | |
| aArgs[1].Value <<= xInteraction; | |
| sal_Int16 nMacroExecMode = ::com::sun::star::document::MacroExecMode::USE_CONFIG; | |
| aArgs[2].Name = OUString::createFromAscii( "MacroExecutionMode" ); | |
| aArgs[2].Value <<= nMacroExecMode; | |
| sal_Int16 nUpdateDoc = ::com::sun::star::document::UpdateDocMode::ACCORDING_TO_CONFIG; | |
| aArgs[3].Name = OUString::createFromAscii( "UpdateDocMode" ); | |
| aArgs[3].Value <<= nUpdateDoc; | |
| } | |
| if ( aDispatchRequest.aPreselectedFactory.getLength() ) | |
| { | |
| aArgs[nCount-1].Name = ::comphelper::MediaDescriptor::PROP_DOCUMENTSERVICE(); | |
| aArgs[nCount-1].Value <<= aDispatchRequest.aPreselectedFactory; | |
| } | |
| String aName( GetURL_Impl( aDispatchRequest.aURL, aDispatchRequest.aCwdUrl ) ); | |
| ::rtl::OUString aTarget( RTL_CONSTASCII_USTRINGPARAM("_default") ); | |
| if ( aDispatchRequest.aRequestType == REQUEST_PRINT || | |
| aDispatchRequest.aRequestType == REQUEST_PRINTTO ) | |
| { | |
| // documents opened for printing are opened readonly because they must be opened as a new document and this | |
| // document could be open already | |
| aArgs[1].Value <<= sal_True; | |
| // always open a new document for printing, because it must be disposed afterwards | |
| aArgs[2].Value <<= sal_True; | |
| // printing is done in a hidden view | |
| aArgs[3].Value <<= sal_True; | |
| // load document for printing without user interaction | |
| aArgs[4].Value <<= sal_True; | |
| // hidden documents should never be put into open tasks | |
| aTarget = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("_blank") ); | |
| } | |
| // load the document ... if they are loadable! | |
| // Otherwise try to dispatch it ... | |
| Reference < XPrintable > xDoc; | |
| if( | |
| ( aName.CompareToAscii( ".uno" , 4 ) == COMPARE_EQUAL ) || | |
| ( aName.CompareToAscii( "slot:" , 5 ) == COMPARE_EQUAL ) || | |
| ( aName.CompareToAscii( "macro:", 6 ) == COMPARE_EQUAL ) || | |
| ( aName.CompareToAscii("vnd.sun.star.script", 19) == COMPARE_EQUAL) | |
| ) | |
| { | |
| // Attention: URL must be parsed full. Otherwise some detections on it will fail! | |
| // It doesn't matter, if parser isn't available. Because; We try loading of URL then ... | |
| URL aURL ; | |
| aURL.Complete = aName; | |
| Reference < XDispatch > xDispatcher ; | |
| Reference < XDispatchProvider > xProvider ( xDesktop, UNO_QUERY ); | |
| Reference < XURLTransformer > xParser ( ::comphelper::getProcessServiceFactory()->createInstance( OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.util.URLTransformer")) ), ::com::sun::star::uno::UNO_QUERY ); | |
| if( xParser.is() == sal_True ) | |
| xParser->parseStrict( aURL ); | |
| if( xProvider.is() == sal_True ) | |
| xDispatcher = xProvider->queryDispatch( aURL, ::rtl::OUString(), 0 ); | |
| if( xDispatcher.is() == sal_True ) | |
| { | |
| { | |
| ::osl::ClearableMutexGuard aGuard( GetMutex() ); | |
| // Remember request so we can find it in statusChanged! | |
| m_aRequestContainer.insert( DispatchWatcherHashMap::value_type( aURL.Complete, (sal_Int32)1 ) ); | |
| m_nRequestCount++; | |
| } | |
| // Use local vector to store dispatcher because we have to fill our request container before | |
| // we can dispatch. Otherwise it would be possible that statusChanged is called before we dispatched all requests!! | |
| aDispatches.push_back( DispatchHolder( aURL, xDispatcher )); | |
| } | |
| } | |
| else if ( ( aName.CompareToAscii( "service:" , 8 ) == COMPARE_EQUAL ) ) | |
| { | |
| // TODO: the dispatch has to be done for loadComponentFromURL as well. Please ask AS for more details. | |
| URL aURL ; | |
| aURL.Complete = aName; | |
| Reference < XDispatch > xDispatcher ; | |
| Reference < XDispatchProvider > xProvider ( xDesktop, UNO_QUERY ); | |
| Reference < XURLTransformer > xParser ( ::comphelper::getProcessServiceFactory()->createInstance( OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.util.URLTransformer")) ), ::com::sun::star::uno::UNO_QUERY ); | |
| if( xParser.is() == sal_True ) | |
| xParser->parseStrict( aURL ); | |
| if( xProvider.is() == sal_True ) | |
| xDispatcher = xProvider->queryDispatch( aURL, ::rtl::OUString(), 0 ); | |
| if( xDispatcher.is() == sal_True ) | |
| { | |
| try | |
| { | |
| // We have to be listener to catch errors during dispatching URLs. | |
| // Otherwise it would be possible to have an office running without an open | |
| // window!! | |
| Sequence < PropertyValue > aArgs2(1); | |
| aArgs2[0].Name = ::rtl::OUString::createFromAscii("SynchronMode"); | |
| aArgs2[0].Value <<= sal_True; | |
| Reference < XNotifyingDispatch > xDisp( xDispatcher, UNO_QUERY ); | |
| if ( xDisp.is() ) | |
| xDisp->dispatchWithNotification( aURL, aArgs2, DispatchWatcher::GetDispatchWatcher() ); | |
| else | |
| xDispatcher->dispatch( aURL, aArgs2 ); | |
| } | |
| catch ( ::com::sun::star::uno::Exception& ) | |
| { | |
| OUString aMsg = OUString::createFromAscii( | |
| "Desktop::OpenDefault() IllegalArgumentException while calling XNotifyingDispatch: "); | |
| OSL_ENSURE( sal_False, OUStringToOString(aMsg, RTL_TEXTENCODING_ASCII_US).getStr()); | |
| } | |
| } | |
| } | |
| else | |
| { | |
| INetURLObject aObj( aName ); | |
| if ( aObj.GetProtocol() == INET_PROT_PRIVATE ) | |
| aTarget = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("_default") ); | |
| // Set "AsTemplate" argument according to request type | |
| if ( aDispatchRequest.aRequestType == REQUEST_FORCENEW || | |
| aDispatchRequest.aRequestType == REQUEST_FORCEOPEN ) | |
| { | |
| sal_Int32 nIndex = aArgs.getLength(); | |
| aArgs.realloc( nIndex+1 ); | |
| aArgs[nIndex].Name = aAsTemplateArg; | |
| if ( aDispatchRequest.aRequestType == REQUEST_FORCENEW ) | |
| aArgs[nIndex].Value <<= sal_True; | |
| else | |
| aArgs[nIndex].Value <<= sal_False; | |
| } | |
| // if we are called in viewmode, open document read-only | |
| // #95425# | |
| if(aDispatchRequest.aRequestType == REQUEST_VIEW) { | |
| sal_Int32 nIndex = aArgs.getLength(); | |
| aArgs.realloc(nIndex+1); | |
| aArgs[nIndex].Name = OUString::createFromAscii("ReadOnly"); | |
| aArgs[nIndex].Value <<= sal_True; | |
| } | |
| // if we are called with -start set Start in mediadescriptor | |
| if(aDispatchRequest.aRequestType == REQUEST_START) { | |
| sal_Int32 nIndex = aArgs.getLength(); | |
| aArgs.realloc(nIndex+1); | |
| aArgs[nIndex].Name = OUString::createFromAscii("StartPresentation"); | |
| aArgs[nIndex].Value <<= sal_True; | |
| } | |
| // This is a synchron loading of a component so we don't have to deal with our statusChanged listener mechanism. | |
| try | |
| { | |
| xDoc = Reference < XPrintable >( ::comphelper::SynchronousDispatch::dispatch( xDesktop, aName, aTarget, 0, aArgs ), UNO_QUERY ); | |
| //xDoc = Reference < XPrintable >( xDesktop->loadComponentFromURL( aName, aTarget, 0, aArgs ), UNO_QUERY ); | |
| } | |
| catch ( ::com::sun::star::lang::IllegalArgumentException& iae) | |
| { | |
| OUString aMsg = OUString::createFromAscii( | |
| "Dispatchwatcher IllegalArgumentException while calling loadComponentFromURL: ") | |
| + iae.Message; | |
| OSL_ENSURE( sal_False, OUStringToOString(aMsg, RTL_TEXTENCODING_ASCII_US).getStr()); | |
| } | |
| catch (com::sun::star::io::IOException& ioe) | |
| { | |
| OUString aMsg = OUString::createFromAscii( | |
| "Dispatchwatcher IOException while calling loadComponentFromURL: ") | |
| + ioe.Message; | |
| OSL_ENSURE( sal_False, OUStringToOString(aMsg, RTL_TEXTENCODING_ASCII_US).getStr()); | |
| } | |
| if ( aDispatchRequest.aRequestType == REQUEST_OPEN || | |
| aDispatchRequest.aRequestType == REQUEST_VIEW || | |
| aDispatchRequest.aRequestType == REQUEST_START || | |
| aDispatchRequest.aRequestType == REQUEST_FORCEOPEN || | |
| aDispatchRequest.aRequestType == REQUEST_FORCENEW ) | |
| { | |
| // request is completed | |
| OfficeIPCThread::RequestsCompleted( 1 ); | |
| } | |
| else if ( aDispatchRequest.aRequestType == REQUEST_PRINT || | |
| aDispatchRequest.aRequestType == REQUEST_PRINTTO ) | |
| { | |
| if ( xDoc.is() ) | |
| { | |
| if ( aDispatchRequest.aRequestType == REQUEST_PRINTTO ) | |
| { | |
| // create the printer | |
| Sequence < PropertyValue > aPrinterArgs( 1 ); | |
| aPrinterArgs[0].Name = ::rtl::OUString::createFromAscii("Name"); | |
| aPrinterArgs[0].Value <<= ::rtl::OUString( aDispatchRequest.aPrinterName ); | |
| xDoc->setPrinter( aPrinterArgs ); | |
| } | |
| // print ( also without user interaction ) | |
| Sequence < PropertyValue > aPrinterArgs( 1 ); | |
| aPrinterArgs[0].Name = ::rtl::OUString::createFromAscii("Wait"); | |
| aPrinterArgs[0].Value <<= ( sal_Bool ) sal_True; | |
| xDoc->print( aPrinterArgs ); | |
| } | |
| else | |
| { | |
| // place error message here ... | |
| } | |
| // remove the document | |
| try | |
| { | |
| Reference < XCloseable > xClose( xDoc, UNO_QUERY ); | |
| if ( xClose.is() ) | |
| xClose->close( sal_True ); | |
| else | |
| { | |
| Reference < XComponent > xComp( xDoc, UNO_QUERY ); | |
| if ( xComp.is() ) | |
| xComp->dispose(); | |
| } | |
| } | |
| catch ( com::sun::star::util::CloseVetoException& ) | |
| { | |
| } | |
| // request is completed | |
| OfficeIPCThread::RequestsCompleted( 1 ); | |
| } | |
| } | |
| } | |
| if ( aDispatches.size() > 0 ) | |
| { | |
| // Execute all asynchronous dispatches now after we placed them into our request container! | |
| Sequence < PropertyValue > aArgs( 2 ); | |
| aArgs[0].Name = ::rtl::OUString::createFromAscii("Referer"); | |
| aArgs[0].Value <<= ::rtl::OUString::createFromAscii("private:OpenEvent"); | |
| aArgs[1].Name = ::rtl::OUString::createFromAscii("SynchronMode"); | |
| aArgs[1].Value <<= sal_True; | |
| for ( sal_uInt32 n = 0; n < aDispatches.size(); n++ ) | |
| { | |
| Reference< XDispatch > xDispatch = aDispatches[n].xDispatch; | |
| Reference < XNotifyingDispatch > xDisp( xDispatch, UNO_QUERY ); | |
| if ( xDisp.is() ) | |
| xDisp->dispatchWithNotification( aDispatches[n].aURL, aArgs, this ); | |
| else | |
| { | |
| ::osl::ClearableMutexGuard aGuard( GetMutex() ); | |
| m_nRequestCount--; | |
| aGuard.clear(); | |
| xDispatch->dispatch( aDispatches[n].aURL, aArgs ); | |
| } | |
| } | |
| } | |
| ::osl::ClearableMutexGuard aGuard( GetMutex() ); | |
| bool bEmpty = (m_nRequestCount == 0); | |
| aGuard.clear(); | |
| // No more asynchronous requests? | |
| // The requests are removed from the request container after they called back to this | |
| // implementation via statusChanged!! | |
| if ( bEmpty && !bNoTerminate /*m_aRequestContainer.empty()*/ ) | |
| { | |
| // We have to check if we have an open task otherwise we have to shutdown the office. | |
| Reference< XFramesSupplier > xTasksSupplier( xDesktop, UNO_QUERY ); | |
| aGuard.clear(); | |
| Reference< XElementAccess > xList( xTasksSupplier->getFrames(), UNO_QUERY ); | |
| if ( !xList->hasElements() ) | |
| { | |
| // We don't have any task open so we have to shutdown ourself!! | |
| Reference< XDesktop > xDesktop2( xTasksSupplier, UNO_QUERY ); | |
| if ( xDesktop2.is() ) | |
| return xDesktop2->terminate(); | |
| } | |
| } | |
| return sal_False; | |
| } | |
| void SAL_CALL DispatchWatcher::disposing( const ::com::sun::star::lang::EventObject& ) | |
| { | |
| } | |
| void SAL_CALL DispatchWatcher::dispatchFinished( const DispatchResultEvent& ) | |
| { | |
| osl::ClearableMutexGuard aGuard( GetMutex() ); | |
| sal_Int16 nCount = --m_nRequestCount; | |
| aGuard.clear(); | |
| OfficeIPCThread::RequestsCompleted( 1 ); | |
| /* | |
| // Find request in our hash map and remove it as a pending request | |
| DispatchWatcherHashMap::iterator pDispatchEntry = m_aRequestContainer.find( rEvent.FeatureURL.Complete ) ; | |
| if ( pDispatchEntry != m_aRequestContainer.end() ) | |
| { | |
| m_aRequestContainer.erase( pDispatchEntry ); | |
| aGuard.clear(); | |
| OfficeIPCThread::RequestsCompleted( 1 ); | |
| } | |
| else | |
| aGuard.clear(); | |
| */ | |
| if ( !nCount && !OfficeIPCThread::AreRequestsPending() ) | |
| { | |
| // We have to check if we have an open task otherwise we have to shutdown the office. | |
| Reference< XFramesSupplier > xTasksSupplier( ::comphelper::getProcessServiceFactory()->createInstance( | |
| OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.frame.Desktop")) ), | |
| UNO_QUERY ); | |
| Reference< XElementAccess > xList( xTasksSupplier->getFrames(), UNO_QUERY ); | |
| if ( !xList->hasElements() ) | |
| { | |
| // We don't have any task open so we have to shutdown ourself!! | |
| Reference< XDesktop > xDesktop( xTasksSupplier, UNO_QUERY ); | |
| if ( xDesktop.is() ) | |
| xDesktop->terminate(); | |
| } | |
| } | |
| } | |
| } |