| /************************************************************** |
| * |
| * 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_sfx2.hxx" |
| // includes -------------------------------------------------------------- |
| #include <com/sun/star/beans/PropertyValue.hpp> |
| #include <com/sun/star/beans/XPropertyAccess.hpp> |
| #include <com/sun/star/frame/XFrame.hpp> |
| #include <com/sun/star/frame/XModel.hpp> |
| #include <com/sun/star/lang/XMultiServiceFactory.hpp> |
| #include <com/sun/star/ucb/CommandAbortedException.hpp> |
| #include <com/sun/star/uno/Reference.h> |
| #include <com/sun/star/util/XURLTransformer.hpp> |
| #include <com/sun/star/system/SystemMailProvider.hpp> |
| #include <com/sun/star/system/MailClientFlags.hpp> |
| #include <com/sun/star/embed/XStorage.hpp> |
| #include <com/sun/star/embed/ElementModes.hpp> |
| #include <com/sun/star/embed/XTransactedObject.hpp> |
| #include <com/sun/star/container/XContainerQuery.hpp> |
| #include <com/sun/star/util/XModifiable.hpp> |
| #include <com/sun/star/frame/XModuleManager.hpp> |
| #include <com/sun/star/frame/XStorable.hpp> |
| #include <com/sun/star/beans/XPropertySet.hpp> |
| #include <com/sun/star/security/CertificateValidity.hpp> |
| #include <com/sun/star/security/DocumentSignatureInformation.hpp> |
| #include <com/sun/star/security/XDocumentDigitalSignatures.hpp> |
| #include <com/sun/star/frame/XDispatchProvider.hpp> |
| #include <com/sun/star/frame/XDispatch.hpp> |
| #include <com/sun/star/frame/XStatusListener.hpp> |
| #include <com/sun/star/ucb/InsertCommandArgument.hpp> |
| #include <com/sun/star/ui/dialogs/XExecutableDialog.hpp> |
| #include <com/sun/star/document/XExporter.hpp> |
| #include <rtl/textenc.h> |
| #include <rtl/uri.h> |
| #include <rtl/uri.hxx> |
| #include <rtl/ustrbuf.hxx> |
| #include <vcl/msgbox.hxx> |
| |
| #include <sfx2/mailmodelapi.hxx> |
| #include "sfxtypes.hxx" |
| #include "sfx2/sfxresid.hxx" |
| #include <sfx2/sfxsids.hrc> |
| #include "dialog.hrc" |
| |
| #include <unotools/tempfile.hxx> |
| #include <unotools/configitem.hxx> |
| #include <ucbhelper/content.hxx> |
| #include <tools/urlobj.hxx> |
| #include <unotools/useroptions.hxx> |
| #include <comphelper/processfactory.hxx> |
| #include <comphelper/extract.hxx> |
| #include <comphelper/storagehelper.hxx> |
| #include <comphelper/sequenceasvector.hxx> |
| #include <comphelper/sequenceashashmap.hxx> |
| #include <comphelper/mediadescriptor.hxx> |
| #include <toolkit/helper/vclunohelper.hxx> |
| #include <vcl/svapp.hxx> |
| #include <cppuhelper/implbase1.hxx> |
| |
| // -------------------------------------------------------------- |
| using namespace ::com::sun::star; |
| using namespace ::com::sun::star::beans; |
| using namespace ::com::sun::star::frame; |
| using namespace ::com::sun::star::io; |
| using namespace ::com::sun::star::lang; |
| using namespace ::com::sun::star::ucb; |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::util; |
| |
| using ::com::sun::star::system::SystemMailProvider; |
| using ::com::sun::star::system::XMailClient; |
| using ::com::sun::star::system::XMailMessage; |
| using ::com::sun::star::system::XSystemMailProvider; |
| using rtl::OUString; |
| |
| namespace MailClientFlags = ::com::sun::star::system::MailClientFlags; |
| namespace css = ::com::sun::star; |
| |
| |
| // - class PrepareListener_Impl ------------------------------------------ |
| class PrepareListener_Impl : public ::cppu::WeakImplHelper1< css::frame::XStatusListener > |
| { |
| bool m_bState; |
| public: |
| PrepareListener_Impl(); |
| virtual ~PrepareListener_Impl(); |
| |
| // css.frame.XStatusListener |
| virtual void SAL_CALL statusChanged(const css::frame::FeatureStateEvent& aEvent) |
| throw(css::uno::RuntimeException); |
| |
| // css.lang.XEventListener |
| virtual void SAL_CALL disposing(const css::lang::EventObject& aEvent) |
| throw(css::uno::RuntimeException); |
| |
| bool IsSet() const {return m_bState;} |
| }; |
| |
| /*-- 25.08.2010 14:32:49--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| PrepareListener_Impl::PrepareListener_Impl() : |
| m_bState( false ) |
| { |
| } |
| /*-- 25.08.2010 14:32:51--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| PrepareListener_Impl::~PrepareListener_Impl() |
| { |
| } |
| /*-- 25.08.2010 14:32:51--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void PrepareListener_Impl::statusChanged(const css::frame::FeatureStateEvent& rEvent) throw(css::uno::RuntimeException) |
| { |
| if( rEvent.IsEnabled ) |
| rEvent.State >>= m_bState; |
| else |
| m_bState = sal_False; |
| } |
| /*-- 25.08.2010 14:32:52--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void PrepareListener_Impl::disposing(const css::lang::EventObject& /*rEvent*/) throw(css::uno::RuntimeException) |
| { |
| } |
| |
| // class AddressList_Impl ------------------------------------------------ |
| |
| typedef String* AddressItemPtr_Impl; |
| DECLARE_LIST( AddressList_Impl, AddressItemPtr_Impl ) |
| |
| // class SfxMailModel ----------------------------------------------- |
| |
| static const char PDF_DOCUMENT_TYPE[] = "pdf_Portable_Document_Format"; |
| static const sal_uInt32 PDF_DOCUMENT_TYPE_LEN = 28; |
| |
| void SfxMailModel::ClearList( AddressList_Impl* pList ) |
| { |
| if ( pList ) |
| { |
| sal_uIntPtr i, nCount = pList->Count(); |
| for ( i = 0; i < nCount; ++i ) |
| delete pList->GetObject(i); |
| pList->Clear(); |
| } |
| } |
| |
| void SfxMailModel::MakeValueList( AddressList_Impl* pList, String& rValueList ) |
| { |
| rValueList.Erase(); |
| if ( pList ) |
| { |
| sal_uIntPtr i, nCount = pList->Count(); |
| for ( i = 0; i < nCount; ++i ) |
| { |
| if ( rValueList.Len() > 0 ) |
| rValueList += ','; |
| rValueList += *pList->GetObject(i); |
| } |
| } |
| } |
| |
| sal_Bool HasDocumentValidSignature( const css::uno::Reference< css::frame::XModel >& xModel ) |
| { |
| try |
| { |
| css::uno::Reference< css::beans::XPropertySet > xPropSet( xModel, css::uno::UNO_QUERY ); |
| if ( xPropSet.is() ) |
| { |
| Any a = xPropSet->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "HasValidSignatures" ))); |
| sal_Bool bReturn = sal_Bool(); |
| if ( a >>= bReturn ) |
| return bReturn; |
| } |
| } |
| catch ( css::uno::RuntimeException& ) |
| { |
| throw; |
| } |
| catch ( css::uno::Exception& ) |
| { |
| } |
| |
| return sal_False; |
| } |
| |
| SfxMailModel::SaveResult SfxMailModel::ShowFilterOptionsDialog( |
| uno::Reference< lang::XMultiServiceFactory > xSMGR, |
| uno::Reference< frame::XModel > xModel, |
| const rtl::OUString& rFilterName, |
| const rtl::OUString& rType, |
| bool bModified, |
| sal_Int32& rNumArgs, |
| ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue >& rArgs ) |
| { |
| SaveResult eRet( SAVE_ERROR ); |
| |
| try |
| { |
| uno::Sequence < beans::PropertyValue > aProps; |
| ::com::sun::star::uno::Reference< ::com::sun::star::container::XNameAccess > xFilterCFG = |
| uno::Reference< container::XNameAccess >( |
| xSMGR->createInstance( |
| ::rtl::OUString::createFromAscii( "com.sun.star.document.FilterFactory" ) ), uno::UNO_QUERY ); |
| css::uno::Reference< css::util::XModifiable > xModifiable( xModel, css::uno::UNO_QUERY ); |
| |
| if ( !xFilterCFG.is() ) |
| return eRet; |
| |
| uno::Any aAny = xFilterCFG->getByName( rFilterName ); |
| |
| if ( aAny >>= aProps ) |
| { |
| sal_Int32 nPropertyCount = aProps.getLength(); |
| for( sal_Int32 nProperty=0; nProperty < nPropertyCount; ++nProperty ) |
| { |
| if( aProps[nProperty].Name.equals( ::rtl::OUString::createFromAscii( "UIComponent" )) ) |
| { |
| ::rtl::OUString aServiceName; |
| aProps[nProperty].Value >>= aServiceName; |
| if( aServiceName.getLength() ) |
| { |
| uno::Reference< ui::dialogs::XExecutableDialog > xFilterDialog( |
| xSMGR->createInstance( aServiceName ), uno::UNO_QUERY ); |
| uno::Reference< beans::XPropertyAccess > xFilterProperties( |
| xFilterDialog, uno::UNO_QUERY ); |
| |
| if( xFilterDialog.is() && xFilterProperties.is() ) |
| { |
| uno::Sequence< beans::PropertyValue > aPropsForDialog(1); |
| uno::Reference< document::XExporter > xExporter( xFilterDialog, uno::UNO_QUERY ); |
| |
| if ( rType.equalsAsciiL( PDF_DOCUMENT_TYPE, PDF_DOCUMENT_TYPE_LEN )) |
| { |
| //add an internal property, used to tell the dialog we want to set a different |
| //string for the ok button |
| //used in filter/source/pdf/impdialog.cxx |
| String aOkSendText( SfxResId( STR_PDF_EXPORT_SEND )); |
| |
| uno::Sequence< beans::PropertyValue > aFilterDataValue(1); |
| aFilterDataValue[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "_OkButtonString" )); |
| aFilterDataValue[0].Value = css::uno::makeAny( ::rtl::OUString( aOkSendText )); |
| |
| //add to the filterdata property, the only one the PDF export filter dialog will care for |
| aPropsForDialog[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "FilterData" )); |
| aPropsForDialog[0].Value = css::uno::makeAny( aFilterDataValue ); |
| |
| //when executing the dialog will merge the persistent FilterData properties |
| xFilterProperties->setPropertyValues( aPropsForDialog ); |
| } |
| |
| if( xExporter.is() ) |
| xExporter->setSourceDocument( |
| uno::Reference< lang::XComponent >( xModel, uno::UNO_QUERY ) ); |
| |
| if( xFilterDialog->execute() ) |
| { |
| //get the filter data |
| uno::Sequence< beans::PropertyValue > aPropsFromDialog = xFilterProperties->getPropertyValues(); |
| |
| //add them to the args |
| for ( sal_Int32 nInd = 0; nInd < aPropsFromDialog.getLength(); nInd++ ) |
| { |
| if( aPropsFromDialog[ nInd ].Name.equals( ::rtl::OUString::createFromAscii( "FilterData" ) ) ) |
| { |
| //found the filterdata, add to the storing argument |
| rArgs.realloc( ++rNumArgs ); |
| rArgs[rNumArgs-1].Name = aPropsFromDialog[ nInd ].Name; |
| rArgs[rNumArgs-1].Value = aPropsFromDialog[ nInd ].Value; |
| break; |
| } |
| } |
| eRet = SAVE_SUCCESSFULL; |
| } |
| else |
| { |
| // cancel from dialog, then do not send |
| // If the model is not modified, it could be modified by the dispatch calls. |
| // Therefore set back to modified = false. This should not hurt if we call |
| // on a non-modified model. |
| if ( !bModified ) |
| { |
| try |
| { |
| xModifiable->setModified( sal_False ); |
| } |
| catch( com::sun::star::beans::PropertyVetoException& ) |
| { |
| } |
| } |
| eRet = SAVE_CANCELLED; |
| } |
| } |
| break; |
| } |
| } |
| } |
| } |
| } |
| catch( css::uno::RuntimeException& ) |
| { |
| throw; |
| } |
| catch( uno::Exception& ) |
| { |
| } |
| |
| return eRet; |
| } |
| |
| sal_Int32 SfxMailModel::GetCount() const |
| { |
| return maAttachedDocuments.size(); |
| } |
| |
| sal_Bool SfxMailModel::IsEmpty() const |
| { |
| return maAttachedDocuments.empty(); |
| } |
| |
| SfxMailModel::SaveResult SfxMailModel::SaveDocumentAsFormat( |
| const rtl::OUString& aSaveFileName, |
| const css::uno::Reference< css::uno::XInterface >& xFrameOrModel, |
| const rtl::OUString& rType, |
| rtl::OUString& rFileNamePath ) |
| { |
| SaveResult eRet( SAVE_ERROR ); |
| bool bSendAsPDF = (rType.equalsAsciiL( PDF_DOCUMENT_TYPE, PDF_DOCUMENT_TYPE_LEN )); |
| |
| css::uno::Reference< css::lang::XMultiServiceFactory > xSMGR = ::comphelper::getProcessServiceFactory(); |
| if (!xSMGR.is()) |
| return eRet; |
| |
| const rtl::OUString aModuleManager( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.frame.ModuleManager" )); |
| css::uno::Reference< css::frame::XModuleManager > xModuleManager( xSMGR->createInstance( aModuleManager ), css::uno::UNO_QUERY_THROW ); |
| if ( !xModuleManager.is() ) |
| return eRet; |
| |
| rtl::OUString aModule; |
| try |
| { |
| aModule = xModuleManager->identify( xFrameOrModel ); |
| } |
| catch ( css::uno::RuntimeException& ) |
| { |
| throw; |
| } |
| catch ( css::uno::Exception& ) |
| { |
| } |
| |
| css::uno::Reference< css::frame::XFrame > xFrame( xFrameOrModel, css::uno::UNO_QUERY ); |
| css::uno::Reference< css::frame::XModel > xModel( xFrameOrModel, css::uno::UNO_QUERY ); |
| if ( xFrame.is() ) |
| { |
| css::uno::Reference< css::frame::XController > xController = xFrame->getController(); |
| if ( xController.is() ) |
| xModel = xController->getModel(); |
| } |
| |
| // We need at least a valid module name and model reference |
| if (( aModule.getLength() > 0 ) && xModel.is() ) |
| { |
| bool bModified( false ); |
| bool bHasLocation( false ); |
| bool bStoreTo( false ); |
| |
| css::uno::Reference< css::util::XModifiable > xModifiable( xModel, css::uno::UNO_QUERY ); |
| css::uno::Reference< css::frame::XStorable > xStorable( xModel, css::uno::UNO_QUERY ); |
| |
| if ( xModifiable.is() ) |
| bModified = xModifiable->isModified(); |
| if ( xStorable.is() ) |
| { |
| rtl::OUString aLocation = xStorable->getLocation(); |
| INetURLObject aFileObj( aLocation ); |
| |
| bool bPrivateProtocol = ( aFileObj.GetProtocol() == INET_PROT_PRIV_SOFFICE ); |
| |
| bHasLocation = ( aLocation.getLength() > 0 ) && !bPrivateProtocol; |
| OSL_ASSERT( !bPrivateProtocol ); |
| } |
| if ( rType.getLength() > 0 ) |
| bStoreTo = true; |
| |
| if ( xStorable.is() ) |
| { |
| rtl::OUString aFilterName; |
| rtl::OUString aTypeName( rType ); |
| rtl::OUString aFileName; |
| rtl::OUString aExtension; |
| |
| css::uno::Reference< css::container::XContainerQuery > xContainerQuery( |
| xSMGR->createInstance( rtl::OUString( |
| RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.document.FilterFactory" ))), |
| css::uno::UNO_QUERY ); |
| |
| if ( bStoreTo ) |
| { |
| // Retrieve filter from type |
| css::uno::Sequence< css::beans::NamedValue > aQuery( bSendAsPDF ? 3 : 2 ); |
| aQuery[0].Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Type" )); |
| aQuery[0].Value = css::uno::makeAny( aTypeName ); |
| aQuery[1].Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "DocumentService" )); |
| aQuery[1].Value = css::uno::makeAny( aModule ); |
| if( bSendAsPDF ) |
| { |
| // #i91419# |
| // FIXME: we want just an export filter. However currently we need |
| // exact flag value as detailed in the filter configuration to get it |
| // this seems to be a bug |
| // without flags we get an import filter here, which is also unwanted |
| aQuery[2].Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Flags" )); |
| aQuery[2].Value = css::uno::makeAny( sal_Int32(0x80042) ); // EXPORT ALIEN 3RDPARTY |
| } |
| |
| css::uno::Reference< css::container::XEnumeration > xEnumeration = |
| xContainerQuery->createSubSetEnumerationByProperties( aQuery ); |
| |
| if ( xEnumeration->hasMoreElements() ) |
| { |
| ::comphelper::SequenceAsHashMap aFilterPropsHM( xEnumeration->nextElement() ); |
| aFilterName = aFilterPropsHM.getUnpackedValueOrDefault( |
| ::rtl::OUString::createFromAscii( "Name" ), |
| ::rtl::OUString() ); |
| } |
| |
| if ( bHasLocation ) |
| { |
| // Retrieve filter from media descriptor |
| ::comphelper::SequenceAsHashMap aMediaDescrPropsHM( xModel->getArgs() ); |
| rtl::OUString aOrgFilterName = aMediaDescrPropsHM.getUnpackedValueOrDefault( |
| ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "FilterName" )), |
| ::rtl::OUString() ); |
| if ( aOrgFilterName == aFilterName ) |
| { |
| // We should save the document in the original format. Therefore this |
| // is not a storeTo operation. To support signing in this case, reset |
| // bStoreTo flag. |
| bStoreTo = false; |
| } |
| } |
| } |
| else |
| { |
| if ( bHasLocation ) |
| { |
| // Retrieve filter from media descriptor |
| ::comphelper::SequenceAsHashMap aMediaDescrPropsHM( xModel->getArgs() ); |
| aFilterName = aMediaDescrPropsHM.getUnpackedValueOrDefault( |
| ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "FilterName" )), |
| ::rtl::OUString() ); |
| } |
| |
| if ( !bHasLocation || ( aFilterName.getLength() == 0 )) |
| { |
| // Retrieve the user defined default filter |
| css::uno::Reference< css::container::XNameAccess > xNameAccess( xModuleManager, css::uno::UNO_QUERY ); |
| try |
| { |
| ::comphelper::SequenceAsHashMap aFilterPropsHM( xNameAccess->getByName( aModule ) ); |
| aFilterName = aFilterPropsHM.getUnpackedValueOrDefault( |
| ::rtl::OUString::createFromAscii( "ooSetupFactoryDefaultFilter" ), |
| ::rtl::OUString() ); |
| css::uno::Reference< css::container::XNameAccess > xNameAccess2( |
| xContainerQuery, css::uno::UNO_QUERY ); |
| if ( xNameAccess2.is() ) |
| { |
| ::comphelper::SequenceAsHashMap aFilterPropsHM2( xNameAccess2->getByName( aFilterName ) ); |
| aTypeName = aFilterPropsHM2.getUnpackedValueOrDefault( |
| ::rtl::OUString::createFromAscii( "Type" ), |
| ::rtl::OUString() ); |
| } |
| } |
| catch ( css::container::NoSuchElementException& ) |
| { |
| } |
| catch ( css::beans::UnknownPropertyException& ) |
| { |
| } |
| } |
| } |
| |
| // No filter found => error |
| // No type and no location => error |
| if (( aFilterName.getLength() == 0 ) || |
| (( aTypeName.getLength() == 0 ) && !bHasLocation )) |
| return eRet; |
| |
| // Determine filen name and extension |
| if ( bHasLocation && !bStoreTo ) |
| { |
| INetURLObject aFileObj( xStorable->getLocation() ); |
| aExtension = (rtl::OUString)aFileObj.getExtension(); |
| } |
| else |
| { |
| css::uno::Reference< container::XNameAccess > xTypeDetection( |
| xSMGR->createInstance( ::rtl::OUString( |
| RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.document.TypeDetection" ))), |
| css::uno::UNO_QUERY ); |
| |
| |
| if ( xTypeDetection.is() ) |
| { |
| try |
| { |
| ::comphelper::SequenceAsHashMap aTypeNamePropsHM( xTypeDetection->getByName( aTypeName ) ); |
| uno::Sequence< ::rtl::OUString > aExtensions = aTypeNamePropsHM.getUnpackedValueOrDefault( |
| ::rtl::OUString::createFromAscii( "Extensions" ), |
| ::uno::Sequence< ::rtl::OUString >() ); |
| if ( aExtensions.getLength() ) |
| aExtension = aExtensions[0]; |
| } |
| catch ( css::container::NoSuchElementException& ) |
| { |
| } |
| } |
| } |
| |
| // Use provided save file name. If empty determine file name |
| aFileName = aSaveFileName; |
| if ( aFileName.getLength() == 0 ) |
| { |
| if ( !bHasLocation ) |
| { |
| // Create a noname file name with the correct extension |
| const rtl::OUString aNoNameFileName( RTL_CONSTASCII_USTRINGPARAM( "noname" )); |
| aFileName = aNoNameFileName; |
| } |
| else |
| { |
| // Determine file name from model |
| INetURLObject aFileObj( xStorable->getLocation() ); |
| aFileName = aFileObj.getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::NO_DECODE ); |
| } |
| } |
| |
| // No file name => error |
| if ( aFileName.getLength() == 0 ) |
| return eRet; |
| |
| OSL_ASSERT( aFilterName.getLength() > 0 ); |
| OSL_ASSERT( aFileName.getLength() > 0 ); |
| |
| // Creates a temporary directory to store a predefined file into it. |
| // This makes it possible to store the file for "send document as e-mail" |
| // with the original file name. We cannot use the original file as |
| // some mail programs need exclusive access. |
| ::utl::TempFile aTempDir( NULL, sal_True ); |
| |
| INetURLObject aFilePathObj( aTempDir.GetURL() ); |
| aFilePathObj.insertName( aFileName ); |
| aFilePathObj.setExtension( aExtension ); |
| |
| rtl::OUString aFileURL = aFilePathObj.GetMainURL( INetURLObject::NO_DECODE ); |
| |
| sal_Int32 nNumArgs(0); |
| const rtl::OUString aPasswordPropName( RTL_CONSTASCII_USTRINGPARAM( "Password" )); |
| css::uno::Sequence< css::beans::PropertyValue > aArgs( ++nNumArgs ); |
| aArgs[nNumArgs-1].Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "FilterName" )); |
| aArgs[nNumArgs-1].Value = css::uno::makeAny( aFilterName ); |
| |
| ::comphelper::SequenceAsHashMap aMediaDescrPropsHM( xModel->getArgs() ); |
| rtl::OUString aPassword = aMediaDescrPropsHM.getUnpackedValueOrDefault( |
| aPasswordPropName, |
| ::rtl::OUString() ); |
| if ( aPassword.getLength() > 0 ) |
| { |
| aArgs.realloc( ++nNumArgs ); |
| aArgs[nNumArgs-1].Name = aPasswordPropName; |
| aArgs[nNumArgs-1].Value = css::uno::makeAny( aPassword ); |
| } |
| |
| bool bNeedsPreparation = false; |
| css::util::URL aPrepareURL; |
| css::uno::Reference< css::frame::XDispatch > xPrepareDispatch; |
| css::uno::Reference< css::frame::XDispatchProvider > xDispatchProvider( xFrame, css::uno::UNO_QUERY ); |
| css::uno::Reference< css::util::XURLTransformer > xURLTransformer( |
| xSMGR->createInstance( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.util.URLTransformer" ))), |
| css::uno::UNO_QUERY ); |
| if( !bSendAsPDF ) |
| { |
| try |
| { |
| // check if the document needs to be prepared for sending as mail (embedding of links, removal of invisible content) |
| |
| if ( xURLTransformer.is() ) |
| { |
| aPrepareURL.Complete = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:PrepareMailExport" )); |
| xURLTransformer->parseStrict( aPrepareURL ); |
| } |
| |
| if ( xDispatchProvider.is() ) |
| { |
| xPrepareDispatch = css::uno::Reference< css::frame::XDispatch >( |
| xDispatchProvider->queryDispatch( aPrepareURL, ::rtl::OUString(), 0 )); |
| if ( xPrepareDispatch.is() ) |
| { |
| PrepareListener_Impl* pPrepareListener; |
| uno::Reference< css::frame::XStatusListener > xStatusListener = pPrepareListener = new PrepareListener_Impl; |
| xPrepareDispatch->addStatusListener( xStatusListener, aPrepareURL ); |
| bNeedsPreparation = pPrepareListener->IsSet(); |
| xPrepareDispatch->removeStatusListener( xStatusListener, aPrepareURL ); |
| } |
| } |
| } |
| catch ( css::uno::RuntimeException& ) |
| { |
| throw; |
| } |
| catch ( css::uno::Exception& ) |
| { |
| } |
| } |
| |
| if ( bModified || !bHasLocation || bStoreTo || bNeedsPreparation ) |
| { |
| // Document is modified, is newly created or should be stored in a special format |
| try |
| { |
| if( bNeedsPreparation && xPrepareDispatch.is() ) |
| { |
| if ( xPrepareDispatch.is() ) |
| { |
| try |
| { |
| css::uno::Sequence< css::beans::PropertyValue > aDispatchArgs; |
| xPrepareDispatch->dispatch( aPrepareURL, aDispatchArgs ); |
| } |
| catch ( css::uno::RuntimeException& ) |
| { |
| throw; |
| } |
| catch ( css::uno::Exception& ) |
| { |
| } |
| } |
| } |
| |
| //check if this is the pdf otput filter (i#64555) |
| if( bSendAsPDF ) |
| { |
| SaveResult eShowPDFFilterDialog = ShowFilterOptionsDialog( |
| xSMGR, xModel, aFilterName, rType, bModified, nNumArgs, aArgs ); |
| |
| // don't continue on dialog cancel or error |
| if ( eShowPDFFilterDialog != SAVE_SUCCESSFULL ) |
| return eShowPDFFilterDialog; |
| } |
| |
| xStorable->storeToURL( aFileURL, aArgs ); |
| rFileNamePath = aFileURL; |
| eRet = SAVE_SUCCESSFULL; |
| |
| if( !bSendAsPDF ) |
| { |
| css::util::URL aURL; |
| // #i30432# notify that export is finished - the Writer may want to restore removed content |
| if ( xURLTransformer.is() ) |
| { |
| aURL.Complete = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:MailExportFinished" )); |
| xURLTransformer->parseStrict( aURL ); |
| } |
| |
| if ( xDispatchProvider.is() ) |
| { |
| css::uno::Reference< css::frame::XDispatch > xDispatch = css::uno::Reference< css::frame::XDispatch >( |
| xDispatchProvider->queryDispatch( aURL, ::rtl::OUString(), 0 )); |
| if ( xDispatch.is() ) |
| { |
| try |
| { |
| css::uno::Sequence< css::beans::PropertyValue > aDispatchArgs; |
| xDispatch->dispatch( aURL, aDispatchArgs ); |
| } |
| catch ( css::uno::RuntimeException& ) |
| { |
| throw; |
| } |
| catch ( css::uno::Exception& ) |
| { |
| } |
| } |
| } |
| } |
| // If the model is not modified, it could be modified by the dispatch calls. |
| // Therefore set back to modified = false. This should not hurt if we call |
| // on a non-modified model. |
| if ( !bModified ) |
| { |
| try |
| { |
| xModifiable->setModified( sal_False ); |
| } |
| catch( com::sun::star::beans::PropertyVetoException& ) |
| { |
| } |
| } |
| } |
| catch ( com::sun::star::io::IOException& ) |
| { |
| eRet = SAVE_ERROR; |
| } |
| } |
| else |
| { |
| // We need 1:1 copy of the document to preserve an added signature. |
| aArgs.realloc( ++nNumArgs ); |
| aArgs[nNumArgs-1].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "CopyStreamIfPossible" ) ); |
| aArgs[nNumArgs-1].Value = css::uno::makeAny( (sal_Bool)sal_True ); |
| |
| try |
| { |
| xStorable->storeToURL( aFileURL, aArgs ); |
| rFileNamePath = aFileURL; |
| eRet = SAVE_SUCCESSFULL; |
| } |
| catch ( com::sun::star::io::IOException& ) |
| { |
| eRet = SAVE_ERROR; |
| } |
| } |
| } |
| } |
| |
| return eRet; |
| } |
| |
| SfxMailModel::SfxMailModel() : |
| mpToList ( NULL ), |
| mpCcList ( NULL ), |
| mpBccList ( NULL ), |
| mePriority ( PRIO_NORMAL ), |
| mbLoadDone ( sal_True ) |
| { |
| } |
| |
| SfxMailModel::~SfxMailModel() |
| { |
| ClearList( mpToList ); |
| delete mpToList; |
| ClearList( mpCcList ); |
| delete mpCcList; |
| ClearList( mpBccList ); |
| delete mpBccList; |
| } |
| |
| void SfxMailModel::AddAddress( const String& rAddress, AddressRole eRole ) |
| { |
| // don't add a empty address |
| if ( rAddress.Len() > 0 ) |
| { |
| AddressList_Impl* pList = NULL; |
| if ( ROLE_TO == eRole ) |
| { |
| if ( !mpToList ) |
| // create the list |
| mpToList = new AddressList_Impl; |
| pList = mpToList; |
| } |
| else if ( ROLE_CC == eRole ) |
| { |
| if ( !mpCcList ) |
| // create the list |
| mpCcList = new AddressList_Impl; |
| pList = mpCcList; |
| } |
| else if ( ROLE_BCC == eRole ) |
| { |
| if ( !mpBccList ) |
| // create the list |
| mpBccList = new AddressList_Impl; |
| pList = mpBccList; |
| } |
| else |
| { |
| DBG_ERRORFILE( "invalid address role" ); |
| } |
| |
| if ( pList ) |
| { |
| // add address to list |
| AddressItemPtr_Impl pAddress = new String( rAddress ); |
| pList->Insert( pAddress, LIST_APPEND ); |
| } |
| } |
| } |
| |
| SfxMailModel::SendMailResult SfxMailModel::AttachDocument( |
| const ::rtl::OUString& sDocumentType, |
| const css::uno::Reference< css::uno::XInterface >& xFrameOrModel, |
| const ::rtl::OUString& sAttachmentTitle ) |
| { |
| rtl::OUString sFileName; |
| |
| SaveResult eSaveResult = SaveDocumentAsFormat( sAttachmentTitle, xFrameOrModel, sDocumentType, sFileName ); |
| if ( eSaveResult == SAVE_SUCCESSFULL && ( sFileName.getLength() > 0 ) ) |
| maAttachedDocuments.push_back(sFileName); |
| return eSaveResult == SAVE_SUCCESSFULL ? SEND_MAIL_OK : SEND_MAIL_ERROR; |
| } |
| |
| SfxMailModel::SendMailResult SfxMailModel::Send( const css::uno::Reference< css::frame::XFrame >& xFrame ) |
| { |
| OSL_ENSURE(!maAttachedDocuments.empty(),"No document added!"); |
| SendMailResult eResult = SEND_MAIL_ERROR; |
| if ( !maAttachedDocuments.empty() ) |
| { |
| css::uno::Reference < XComponentContext > xContext = ::comphelper::getProcessComponentContext(); |
| if ( xContext.is() ) |
| { |
| css::uno::Reference< XSystemMailProvider > xSystemMailProvider( SystemMailProvider::create( xContext ) ); |
| |
| if ( xSystemMailProvider.is() ) |
| { |
| css::uno::Reference< XMailClient > xMailClient = xSystemMailProvider->queryMailClient(); |
| |
| if ( !xMailClient.is() ) |
| { |
| // no mail client support => message box! |
| return SEND_MAIL_ERROR; |
| } |
| |
| // we have a simple mail client |
| css::uno::Reference< XMailMessage > xMailMessage = xMailClient->createMailMessage(); |
| if ( xMailMessage.is() ) |
| { |
| sal_Int32 nSendFlags = MailClientFlags::DEFAULTS; |
| if ( maFromAddress.Len() == 0 ) |
| { |
| // from address not set, try figure out users e-mail address |
| CreateFromAddress_Impl( maFromAddress ); |
| } |
| xMailMessage->setOriginator( maFromAddress ); |
| |
| sal_Int32 nToCount = mpToList ? mpToList->Count() : 0; |
| sal_Int32 nCcCount = mpCcList ? mpCcList->Count() : 0; |
| sal_Int32 nCcSeqCount = nCcCount; |
| |
| // set recipient (only one) for this simple mail server!! |
| if ( nToCount > 1 ) |
| { |
| nCcSeqCount = nToCount - 1 + nCcCount; |
| xMailMessage->setRecipient( *mpToList->GetObject( 0 )); |
| nSendFlags = MailClientFlags::NO_USER_INTERFACE; |
| } |
| else if ( nToCount == 1 ) |
| { |
| xMailMessage->setRecipient( *mpToList->GetObject( 0 )); |
| nSendFlags = MailClientFlags::NO_USER_INTERFACE; |
| } |
| |
| // all other recipient must be handled with CC recipients! |
| if ( nCcSeqCount > 0 ) |
| { |
| sal_Int32 nIndex = 0; |
| Sequence< OUString > aCcRecipientSeq; |
| |
| aCcRecipientSeq.realloc( nCcSeqCount ); |
| if ( nCcSeqCount > nCcCount ) |
| { |
| for ( sal_Int32 i = 1; i < nToCount; ++i ) |
| { |
| aCcRecipientSeq[nIndex++] = *mpToList->GetObject(i); |
| } |
| } |
| |
| for ( sal_Int32 i = 0; i < nCcCount; i++ ) |
| { |
| aCcRecipientSeq[nIndex++] = *mpCcList->GetObject(i); |
| } |
| xMailMessage->setCcRecipient( aCcRecipientSeq ); |
| } |
| |
| sal_Int32 nBccCount = mpBccList ? mpBccList->Count() : 0; |
| if ( nBccCount > 0 ) |
| { |
| Sequence< OUString > aBccRecipientSeq( nBccCount ); |
| for ( sal_Int32 i = 0; i < nBccCount; ++i ) |
| { |
| aBccRecipientSeq[i] = *mpBccList->GetObject(i); |
| } |
| xMailMessage->setBccRecipient( aBccRecipientSeq ); |
| } |
| |
| Sequence< OUString > aAttachmentSeq(&(maAttachedDocuments[0]),maAttachedDocuments.size()); |
| |
| xMailMessage->setSubject( maSubject ); |
| xMailMessage->setAttachement( aAttachmentSeq ); |
| |
| sal_Bool bSend( sal_False ); |
| try |
| { |
| xMailClient->sendMailMessage( xMailMessage, nSendFlags ); |
| bSend = sal_True; |
| } |
| catch ( IllegalArgumentException& ) |
| { |
| } |
| catch ( Exception& ) |
| { |
| } |
| |
| if ( bSend == sal_False ) |
| { |
| css::uno::Reference< css::awt::XWindow > xParentWindow = xFrame->getContainerWindow(); |
| |
| ::vos::OGuard aGuard( Application::GetSolarMutex() ); |
| Window* pParentWindow = VCLUnoHelper::GetWindow( xParentWindow ); |
| |
| ErrorBox aBox( pParentWindow, SfxResId( RID_ERRBOX_MAIL_CONFIG )); |
| aBox.Execute(); |
| eResult = SEND_MAIL_CANCELLED; |
| } |
| else |
| eResult = SEND_MAIL_OK; |
| } |
| } |
| } |
| } |
| else |
| eResult = SEND_MAIL_CANCELLED; |
| |
| return eResult; |
| } |
| |
| SfxMailModel::SendMailResult SfxMailModel::SaveAndSend( const css::uno::Reference< css::frame::XFrame >& xFrame, const rtl::OUString& rTypeName ) |
| { |
| SaveResult eSaveResult; |
| SendMailResult eResult = SEND_MAIL_ERROR; |
| rtl::OUString aFileName; |
| |
| eSaveResult = SaveDocumentAsFormat( rtl::OUString(), xFrame, rTypeName, aFileName ); |
| |
| if ( eSaveResult == SAVE_SUCCESSFULL ) |
| { |
| maAttachedDocuments.push_back( aFileName ); |
| return Send( xFrame ); |
| } |
| else if ( eSaveResult == SAVE_CANCELLED ) |
| eResult = SEND_MAIL_CANCELLED; |
| |
| return eResult; |
| } |
| |
| // functions ------------------------------------------------------------- |
| |
| sal_Bool CreateFromAddress_Impl( String& rFrom ) |
| |
| /* [Beschreibung] |
| |
| Diese Funktion versucht mit Hilfe des IniManagers eine From-Adresse |
| zu erzeugen. daf"ur werden die Felder 'Vorname', 'Name' und 'EMail' |
| aus der Applikations-Ini-Datei ausgelesen. Sollten diese Felder |
| nicht gesetzt sein, wird FALSE zur"uckgegeben. |
| |
| [R"uckgabewert] |
| |
| sal_True: Adresse konnte erzeugt werden. |
| sal_False: Adresse konnte nicht erzeugt werden. |
| */ |
| |
| { |
| SvtUserOptions aUserCFG; |
| String aName = aUserCFG.GetLastName (); |
| String aFirstName = aUserCFG.GetFirstName (); |
| if ( aFirstName.Len() || aName.Len() ) |
| { |
| if ( aFirstName.Len() ) |
| { |
| rFrom = TRIM( aFirstName ); |
| |
| if ( aName.Len() ) |
| rFrom += ' '; |
| } |
| rFrom += TRIM( aName ); |
| // unerlaubte Zeichen entfernen |
| rFrom.EraseAllChars( '<' ); |
| rFrom.EraseAllChars( '>' ); |
| rFrom.EraseAllChars( '@' ); |
| } |
| String aEmailName = aUserCFG.GetEmail(); |
| |
| // unerlaubte Zeichen entfernen |
| aEmailName.EraseAllChars( '<' ); |
| aEmailName.EraseAllChars( '>' ); |
| |
| if ( aEmailName.Len() ) |
| { |
| if ( rFrom.Len() ) |
| rFrom += ' '; |
| ( ( rFrom += '<' ) += TRIM( aEmailName ) ) += '>'; |
| } |
| else |
| rFrom.Erase(); |
| return ( rFrom.Len() > 0 ); |
| } |
