sfx2/source/dialog/mailmodel.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <com/sun/star/beans/PropertyValue.hpp>
  21 #include <com/sun/star/beans/XPropertyAccess.hpp>
  22 #include <com/sun/star/container/XContainerQuery.hpp>
  23 #include <com/sun/star/document/XExporter.hpp>
  24 #include <com/sun/star/embed/XStorage.hpp>
  25 #include <com/sun/star/frame/XDispatchProvider.hpp>
  26 #include <com/sun/star/frame/XDispatch.hpp>
  27 #include <com/sun/star/frame/XStatusListener.hpp>
  28 #include <com/sun/star/frame/XFrame.hpp>
  29 #include <com/sun/star/frame/XModel.hpp>
  30 #include <com/sun/star/frame/ModuleManager.hpp>
  31 #include <com/sun/star/frame/XStorable.hpp>
  32 #include <com/sun/star/io/IOException.hpp>
  33 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  34 #include <com/sun/star/system/SimpleSystemMail.hpp>
  35 #include <com/sun/star/system/SimpleCommandMail.hpp>
  36 #include <com/sun/star/system/XSimpleMailClientSupplier.hpp>
  37 #include <com/sun/star/system/SimpleMailClientFlags.hpp>
  38 #include <com/sun/star/ucb/CommandAbortedException.hpp>
  39 #include <com/sun/star/ui/dialogs/XExecutableDialog.hpp>
  40 #include <com/sun/star/uno/Reference.h>
  41 #include <com/sun/star/util/URLTransformer.hpp>
  42 #include <com/sun/star/util/XURLTransformer.hpp>
  43 #include <com/sun/star/util/XModifiable.hpp>
  44 #include <vcl/weld.hxx>
  45 #include <osl/diagnose.h>
  46
  47 #include <sfx2/mailmodelapi.hxx>
  48 #include <sfx2/sfxresid.hxx>
  49 #include <sfx2/strings.hrc>
  50
  51 #include <unotools/tempfile.hxx>
  52 #include <tools/urlobj.hxx>
  53 #include <unotools/useroptions.hxx>
  54 #include <comphelper/processfactory.hxx>
  55 #include <comphelper/propertyvalue.hxx>
  56 #include <comphelper/sequenceashashmap.hxx>
  57 #include <comphelper/string.hxx>
  58 #include <vcl/svapp.hxx>
  59 #include <cppuhelper/implbase.hxx>
  60
  61
  62 using namespace ::com::sun::star;
  63 using namespace ::com::sun::star::beans;
  64 using namespace ::com::sun::star::frame;
  65 using namespace ::com::sun::star::io;
  66 using namespace ::com::sun::star::lang;
  67 using namespace ::com::sun::star::uno;
  68 using namespace ::com::sun::star::util;
  69 using namespace ::com::sun::star::system;
  70
  71 namespace {
  72
  73 // - class PrepareListener_Impl ------------------------------------------
  74 class PrepareListener_Impl : public ::cppu::WeakImplHelper< css::frame::XStatusListener >
  75 {
  76     bool m_bState;
  77 public:
  78         PrepareListener_Impl();
  79
  80         // css.frame.XStatusListener
  81         virtual void SAL_CALL statusChanged(const css::frame::FeatureStateEvent& aEvent) override;
  82
  83         // css.lang.XEventListener
  84         virtual void SAL_CALL disposing(const css::lang::EventObject& aEvent) override;
  85
  86         bool IsSet() const {return m_bState;}
  87 };
  88
  89 }
  90
  91 PrepareListener_Impl::PrepareListener_Impl() :
  92     m_bState( false )
  93 {
  94 }
  95
  96 void PrepareListener_Impl::statusChanged(const css::frame::FeatureStateEvent& rEvent)
  97 {
  98     if( rEvent.IsEnabled )
  99         rEvent.State >>= m_bState;
 100     else
 101         m_bState = false;
 102 }
 103
 104 void PrepareListener_Impl::disposing(const css::lang::EventObject& /*rEvent*/)
 105 {
 106 }
 107
 108 // class SfxMailModel -----------------------------------------------
 109
 110 const char16_t   PDF_DOCUMENT_TYPE[]   = u"pdf_Portable_Document_Format";
 111
 112 SfxMailModel::SaveResult SfxMailModel::ShowFilterOptionsDialog(
 113     const uno::Reference< lang::XMultiServiceFactory >& xSMGR,
 114     const uno::Reference< frame::XModel >& xModel,
 115     const OUString& rFilterName,
 116     std::u16string_view rType,
 117     bool bModified,
 118     sal_Int32& rNumArgs,
 119     css::uno::Sequence< css::beans::PropertyValue >& rArgs )
 120 {
 121     SaveResult eRet( SAVE_ERROR );
 122
 123     try
 124     {
 125         uno::Sequence < beans::PropertyValue > aProps;
 126         css::uno::Reference< css::container::XNameAccess > xFilterCFG(
 127                     xSMGR->createInstance( u"com.sun.star.document.FilterFactory"_ustr ), uno::UNO_QUERY );
 128         css::uno::Reference< css::util::XModifiable > xModifiable( xModel, css::uno::UNO_QUERY );
 129
 130         if ( !xFilterCFG.is() )
 131             return eRet;
 132
 133         uno::Any aAny = xFilterCFG->getByName( rFilterName );
 134
 135         if ( aAny >>= aProps )
 136         {
 137             for (const auto& rProp : aProps)
 138             {
 139                 if( rProp.Name == "UIComponent" )
 140                 {
 141                     OUString aServiceName;
 142                     rProp.Value >>= aServiceName;
 143                     if( !aServiceName.isEmpty() )
 144                     {
 145                         uno::Reference< ui::dialogs::XExecutableDialog > xFilterDialog(
 146                             xSMGR->createInstance( aServiceName ), uno::UNO_QUERY );
 147                         uno::Reference< beans::XPropertyAccess > xFilterProperties(
 148                             xFilterDialog, uno::UNO_QUERY );
 149
 150                         if( xFilterDialog.is() && xFilterProperties.is() )
 151                         {
 152                             uno::Reference< document::XExporter > xExporter( xFilterDialog, uno::UNO_QUERY );
 153
 154                             if ( rType == PDF_DOCUMENT_TYPE )
 155                             {
 156                                 //add an internal property, used to tell the dialog we want to set a different
 157                                 //string for the ok button
 158                                 //used in filter/source/pdf/impdialog.cxx
 159                                 uno::Sequence< beans::PropertyValue > aFilterDataValue{
 160                                     comphelper::makePropertyValue(u"_OkButtonString"_ustr,
 161                                                                   SfxResId(STR_PDF_EXPORT_SEND ))
 162                                 };
 163
 164                                 //add to the filterdata property, the only one the PDF export filter dialog will care for
 165                                 uno::Sequence< beans::PropertyValue > aPropsForDialog{
 166                                     comphelper::makePropertyValue(u"FilterData"_ustr, aFilterDataValue)
 167                                 };
 168
 169                                 //when executing the dialog will merge the persistent FilterData properties
 170                                 xFilterProperties->setPropertyValues( aPropsForDialog );
 171                             }
 172
 173                             if( xExporter.is() )
 174                                 xExporter->setSourceDocument( xModel );
 175
 176                             if( xFilterDialog->execute() )
 177                             {
 178                                 //get the filter data
 179                                 const uno::Sequence< beans::PropertyValue > aPropsFromDialog = xFilterProperties->getPropertyValues();
 180
 181                                 //add them to the args
 182                                 auto pProp = std::find_if(aPropsFromDialog.begin(), aPropsFromDialog.end(),
 183                                     [](const beans::PropertyValue& rDialogProp) { return rDialogProp.Name == "FilterData"; });
 184                                 if (pProp != aPropsFromDialog.end())
 185                                 {
 186                                     //found the filterdata, add to the storing argument
 187                                     rArgs.realloc( ++rNumArgs );
 188                                     auto pArgs = rArgs.getArray();
 189                                     pArgs[rNumArgs-1].Name = pProp->Name;
 190                                     pArgs[rNumArgs-1].Value = pProp->Value;
 191                                 }
 192                                 eRet = SAVE_SUCCESSFUL;
 193                             }
 194                             else
 195                             {
 196                                 // cancel from dialog, then do not send
 197                                 // If the model is not modified, it could be modified by the dispatch calls.
 198                                 // Therefore set back to modified = false. This should not hurt if we call
 199                                 // on a non-modified model.
 200                                 if ( !bModified )
 201                                 {
 202                                     try
 203                                     {
 204                                         xModifiable->setModified( false );
 205                                     }
 206                                     catch( css::beans::PropertyVetoException& )
 207                                     {
 208                                     }
 209                                 }
 210                                 eRet = SAVE_CANCELLED;
 211                             }
 212                         }
 213                         break;
 214                     }
 215                 }
 216             }
 217         }
 218     }
 219     catch( css::uno::RuntimeException& )
 220     {
 221         throw;
 222     }
 223     catch( uno::Exception& )
 224     {
 225     }
 226
 227     return eRet;
 228 }
 229
 230 bool SfxMailModel::IsEmpty() const
 231 {
 232     return maAttachedDocuments.empty();
 233 }
 234
 235 SfxMailModel::SaveResult SfxMailModel::SaveDocumentAsFormat(
 236     const OUString& aSaveFileName,
 237     const css::uno::Reference< css::uno::XInterface >& xFrameOrModel,
 238     const OUString& rType,
 239     OUString& rFileNamePath )
 240 {
 241     SaveResult  eRet( SAVE_ERROR );
 242     bool        bSendAsPDF = ( rType == PDF_DOCUMENT_TYPE );
 243
 244     css::uno::Reference< css::lang::XMultiServiceFactory > xSMGR  = ::comphelper::getProcessServiceFactory();
 245     const css::uno::Reference< css::uno::XComponentContext >& xContext  = ::comphelper::getProcessComponentContext();
 246     if (!xContext.is())
 247         return eRet;
 248
 249     css::uno::Reference< css::frame::XModuleManager2 > xModuleManager( css::frame::ModuleManager::create(xContext) );
 250
 251     OUString aModule;
 252     try
 253     {
 254          aModule = xModuleManager->identify( xFrameOrModel );
 255     }
 256     catch ( css::uno::RuntimeException& )
 257     {
 258         throw;
 259     }
 260     catch ( css::uno::Exception& )
 261     {
 262     }
 263
 264     css::uno::Reference< css::frame::XFrame > xFrame( xFrameOrModel, css::uno::UNO_QUERY );
 265     css::uno::Reference< css::frame::XModel > xModel( xFrameOrModel, css::uno::UNO_QUERY );
 266     if ( xFrame.is() )
 267     {
 268         css::uno::Reference< css::frame::XController > xController = xFrame->getController();
 269         if ( xController.is() )
 270             xModel = xController->getModel();
 271     }
 272
 273     // We need at least a valid module name and model reference
 274     if ( !aModule.isEmpty()  && xModel.is() )
 275     {
 276         bool bModified( false );
 277         bool bHasLocation( false );
 278         bool bStoreTo( false );
 279
 280         css::uno::Reference< css::util::XModifiable > xModifiable( xModel, css::uno::UNO_QUERY );
 281         css::uno::Reference< css::frame::XStorable > xStorable( xModel, css::uno::UNO_QUERY );
 282
 283         if ( xModifiable.is() )
 284             bModified = xModifiable->isModified();
 285         if ( xStorable.is() )
 286         {
 287             OUString aLocation = xStorable->getLocation();
 288             INetURLObject aFileObj( aLocation );
 289
 290             bool bPrivateProtocol = ( aFileObj.GetProtocol() == INetProtocol::PrivSoffice );
 291
 292             bHasLocation =  !aLocation.isEmpty() && !bPrivateProtocol;
 293             OSL_ASSERT( !bPrivateProtocol );
 294         }
 295         if ( !rType.isEmpty() )
 296             bStoreTo = true;
 297
 298         if ( xStorable.is() )
 299         {
 300             OUString aFilterName;
 301             OUString aTypeName( rType );
 302             OUString aFileName;
 303             OUString aExtension;
 304
 305             css::uno::Reference< css::container::XContainerQuery > xContainerQuery(
 306                 xSMGR->createInstance( u"com.sun.star.document.FilterFactory"_ustr ),
 307                 css::uno::UNO_QUERY );
 308
 309             if ( bStoreTo )
 310             {
 311                 // Retrieve filter from type
 312                 css::uno::Sequence< css::beans::NamedValue > aQuery( bSendAsPDF ? 3 : 2 );
 313                 auto pQuery = aQuery.getArray();
 314                 pQuery[0].Name  = "Type";
 315                 pQuery[0].Value <<= aTypeName;
 316                 pQuery[1].Name  = "DocumentService";
 317                 pQuery[1].Value <<= aModule;
 318                 if( bSendAsPDF )
 319                 {
 320                     // #i91419#
 321                     // FIXME: we want just an export filter. However currently we need
 322                     // exact flag value as detailed in the filter configuration to get it
 323                     // this seems to be a bug
 324                     // without flags we get an import filter here, which is also unwanted
 325                     pQuery[2].Name  = "Flags";
 326                     pQuery[2].Value <<= sal_Int32(0x80042); // SfxFilterFlags: EXPORT ALIEN 3RDPARTY
 327                 }
 328
 329                 css::uno::Reference< css::container::XEnumeration > xEnumeration =
 330                     xContainerQuery->createSubSetEnumerationByProperties( aQuery );
 331
 332                 if ( xEnumeration->hasMoreElements() )
 333                 {
 334                     ::comphelper::SequenceAsHashMap aFilterPropsHM( xEnumeration->nextElement() );
 335                     aFilterName = aFilterPropsHM.getUnpackedValueOrDefault(
 336                                                 u"Name"_ustr,
 337                                                 OUString() );
 338                 }
 339
 340                 if ( bHasLocation )
 341                 {
 342                     // Retrieve filter from media descriptor
 343                     ::comphelper::SequenceAsHashMap aMediaDescrPropsHM( xModel->getArgs() );
 344                     OUString aOrgFilterName = aMediaDescrPropsHM.getUnpackedValueOrDefault(
 345                                     u"FilterName"_ustr,
 346                                     OUString() );
 347                     if ( aOrgFilterName == aFilterName )
 348                     {
 349                         // We should save the document in the original format. Therefore this
 350                         // is not a storeTo operation. To support signing in this case, reset
 351                         // bStoreTo flag.
 352                         bStoreTo = false;
 353                     }
 354                 }
 355             }
 356             else
 357             {
 358                 if ( bHasLocation )
 359                 {
 360                     // Retrieve filter from media descriptor
 361                     ::comphelper::SequenceAsHashMap aMediaDescrPropsHM( xModel->getArgs() );
 362                     aFilterName = aMediaDescrPropsHM.getUnpackedValueOrDefault(
 363                                     u"FilterName"_ustr,
 364                                     OUString() );
 365                 }
 366
 367                 if ( !bHasLocation ||  aFilterName.isEmpty())
 368                 {
 369                     // Retrieve the user defined default filter
 370                     try
 371                     {
 372                         ::comphelper::SequenceAsHashMap aFilterPropsHM( xModuleManager->getByName( aModule ) );
 373                         aFilterName = aFilterPropsHM.getUnpackedValueOrDefault(
 374                                                     u"ooSetupFactoryDefaultFilter"_ustr,
 375                                                     OUString() );
 376                         css::uno::Reference< css::container::XNameAccess > xNameAccess(
 377                             xContainerQuery, css::uno::UNO_QUERY );
 378                         if ( xNameAccess.is() )
 379                         {
 380                             ::comphelper::SequenceAsHashMap aFilterPropsHM2( xNameAccess->getByName( aFilterName ) );
 381                             aTypeName = aFilterPropsHM2.getUnpackedValueOrDefault(
 382                                                         u"Type"_ustr,
 383                                                         OUString() );
 384                         }
 385                     }
 386                     catch ( css::container::NoSuchElementException& )
 387                     {
 388                     }
 389                     catch ( css::beans::UnknownPropertyException& )
 390                     {
 391                     }
 392                 }
 393             }
 394
 395             // No filter found => error
 396             // No type and no location => error
 397             if (( aFilterName.isEmpty() ) ||
 398                 ( aTypeName.isEmpty()  && !bHasLocation ))
 399                 return eRet;
 400
 401             // Determine file name and extension
 402             if ( bHasLocation && !bStoreTo )
 403             {
 404                 INetURLObject aFileObj( xStorable->getLocation() );
 405                 aExtension = aFileObj.getExtension();
 406             }
 407             else
 408             {
 409                 css::uno::Reference< container::XNameAccess > xTypeDetection(
 410                     xSMGR->createInstance( u"com.sun.star.document.TypeDetection"_ustr ),
 411                     css::uno::UNO_QUERY );
 412
 413
 414                 if ( xTypeDetection.is() )
 415                 {
 416                     try
 417                     {
 418                         ::comphelper::SequenceAsHashMap aTypeNamePropsHM( xTypeDetection->getByName( aTypeName ) );
 419                         uno::Sequence< OUString > aExtensions = aTypeNamePropsHM.getUnpackedValueOrDefault(
 420                                                         u"Extensions"_ustr,
 421                                                         ::uno::Sequence< OUString >() );
 422                         if ( aExtensions.hasElements() )
 423                             aExtension = aExtensions[0];
 424                     }
 425                     catch ( css::container::NoSuchElementException& )
 426                     {
 427                     }
 428                 }
 429             }
 430
 431             // Use provided save file name. If empty determine file name
 432             aFileName = aSaveFileName;
 433             if ( aFileName.isEmpty() )
 434             {
 435                 if ( !bHasLocation )
 436                 {
 437                     // Create a noname file name with the correct extension
 438                     aFileName = "noname";
 439                 }
 440                 else
 441                 {
 442                     // Determine file name from model
 443                     INetURLObject aFileObj( xStorable->getLocation() );
 444                     aFileName = aFileObj.getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DecodeMechanism::NONE );
 445                 }
 446             }
 447
 448             // No file name => error
 449             if ( aFileName.isEmpty() )
 450                 return eRet;
 451
 452             OSL_ASSERT( !aFilterName.isEmpty() );
 453             OSL_ASSERT( !aFileName.isEmpty() );
 454
 455             // Creates a temporary directory to store a predefined file into it.
 456             // This makes it possible to store the file for "send document as e-mail"
 457             // with the original file name. We cannot use the original file as
 458             // some mail programs need exclusive access.
 459             INetURLObject aFilePathObj( ::utl::CreateTempURL(nullptr, true) );
 460             aFilePathObj.insertName( aFileName );
 461             aFilePathObj.setExtension( aExtension );
 462
 463             OUString aFileURL = aFilePathObj.GetMainURL( INetURLObject::DecodeMechanism::NONE );
 464
 465             sal_Int32 nNumArgs(1);
 466             static constexpr OUString aPasswordPropName( u"Password"_ustr );
 467             css::uno::Sequence< css::beans::PropertyValue > aArgs{ comphelper::makePropertyValue(
 468                 u"FilterName"_ustr, aFilterName) };
 469
 470             ::comphelper::SequenceAsHashMap aMediaDescrPropsHM( xModel->getArgs() );
 471             OUString aPassword = aMediaDescrPropsHM.getUnpackedValueOrDefault(
 472                                             aPasswordPropName,
 473                                             OUString() );
 474             if ( !aPassword.isEmpty() )
 475             {
 476                 aArgs.realloc( ++nNumArgs );
 477                 auto pArgs = aArgs.getArray();
 478                 pArgs[nNumArgs-1].Name = aPasswordPropName;
 479                 pArgs[nNumArgs-1].Value <<= aPassword;
 480             }
 481
 482             bool bNeedsPreparation = false;
 483             css::util::URL aPrepareURL;
 484             css::uno::Reference< css::frame::XDispatch > xPrepareDispatch;
 485             css::uno::Reference< css::frame::XDispatchProvider > xDispatchProvider( xFrame, css::uno::UNO_QUERY );
 486             css::uno::Reference< css::util::XURLTransformer > xURLTransformer( css::util::URLTransformer::create( xContext ) );
 487             if( !bSendAsPDF )
 488             {
 489                 try
 490                 {
 491                     // check if the document needs to be prepared for sending as mail (embedding of links, removal of invisible content)
 492
 493                     aPrepareURL.Complete = ".uno:PrepareMailExport";
 494                     xURLTransformer->parseStrict( aPrepareURL );
 495
 496                     if ( xDispatchProvider.is() )
 497                     {
 498                         xPrepareDispatch.set( xDispatchProvider->queryDispatch( aPrepareURL, OUString(), 0 ));
 499                         if ( xPrepareDispatch.is() )
 500                         {
 501                                 rtl::Reference<PrepareListener_Impl> pPrepareListener = new PrepareListener_Impl;
 502                                 xPrepareDispatch->addStatusListener( pPrepareListener, aPrepareURL );
 503                                 bNeedsPreparation = pPrepareListener->IsSet();
 504                                 xPrepareDispatch->removeStatusListener( pPrepareListener, aPrepareURL );
 505                         }
 506                     }
 507                 }
 508                 catch ( css::uno::RuntimeException& )
 509                 {
 510                     throw;
 511                 }
 512                 catch ( css::uno::Exception& )
 513                 {
 514                 }
 515             }
 516
 517             if ( bModified || !bHasLocation || bStoreTo || bNeedsPreparation )
 518             {
 519                 // Document is modified, is newly created or should be stored in a special format
 520                 try
 521                 {
 522                     if( bNeedsPreparation && xPrepareDispatch.is() )
 523                     {
 524                         try
 525                         {
 526                             css::uno::Sequence< css::beans::PropertyValue > aDispatchArgs;
 527                             xPrepareDispatch->dispatch( aPrepareURL, aDispatchArgs );
 528                         }
 529                         catch ( css::uno::RuntimeException& )
 530                         {
 531                             throw;
 532                         }
 533                         catch ( css::uno::Exception& )
 534                         {
 535                         }
 536                     }
 537
 538                     //check if this is the pdf output filter (i#64555)
 539                     if( bSendAsPDF )
 540                     {
 541                         SaveResult eShowPDFFilterDialog = ShowFilterOptionsDialog(
 542                                                             xSMGR, xModel, aFilterName, rType, bModified, nNumArgs, aArgs );
 543
 544                         // don't continue on dialog cancel or error
 545                         if ( eShowPDFFilterDialog != SAVE_SUCCESSFUL )
 546                             return eShowPDFFilterDialog;
 547                     }
 548
 549                     xStorable->storeToURL( aFileURL, aArgs );
 550                     rFileNamePath = aFileURL;
 551                     eRet = SAVE_SUCCESSFUL;
 552
 553                     if( !bSendAsPDF )
 554                     {
 555                         css::util::URL aURL;
 556                         // #i30432# notify that export is finished - the Writer may want to restore removed content
 557                         aURL.Complete = ".uno:MailExportFinished";
 558                         xURLTransformer->parseStrict( aURL );
 559
 560                         if ( xDispatchProvider.is() )
 561                         {
 562                             css::uno::Reference< css::frame::XDispatch > xDispatch(
 563                                 xDispatchProvider->queryDispatch( aURL, OUString(), 0 ));
 564                             if ( xDispatch.is() )
 565                             {
 566                                 try
 567                                 {
 568                                     css::uno::Sequence< css::beans::PropertyValue > aDispatchArgs;
 569                                     xDispatch->dispatch( aURL, aDispatchArgs );
 570                                 }
 571                                 catch ( css::uno::RuntimeException& )
 572                                 {
 573                                     throw;
 574                                 }
 575                                 catch ( css::uno::Exception& )
 576                                 {
 577                                 }
 578                             }
 579                         }
 580                     }
 581                     // If the model is not modified, it could be modified by the dispatch calls.
 582                     // Therefore set back to modified = false. This should not hurt if we call
 583                     // on a non-modified model.
 584                     if ( !bModified )
 585                     {
 586                         try
 587                         {
 588                             xModifiable->setModified( false );
 589                         }
 590                         catch( css::beans::PropertyVetoException& )
 591                         {
 592                         }
 593                     }
 594                 }
 595                 catch ( css::io::IOException& )
 596                 {
 597                     eRet = SAVE_ERROR;
 598                 }
 599             }
 600             else
 601             {
 602                 // We need 1:1 copy of the document to preserve an added signature.
 603                 aArgs.realloc( ++nNumArgs );
 604                 auto pArgs = aArgs.getArray();
 605                 pArgs[nNumArgs-1].Name = "CopyStreamIfPossible";
 606                 pArgs[nNumArgs-1].Value <<= true;
 607
 608                 try
 609                 {
 610                     xStorable->storeToURL( aFileURL, aArgs );
 611                     rFileNamePath = aFileURL;
 612                     eRet = SAVE_SUCCESSFUL;
 613                 }
 614                 catch ( css::io::IOException& )
 615                 {
 616                     eRet = SAVE_ERROR;
 617                 }
 618             }
 619         }
 620     }
 621
 622     return eRet;
 623 }
 624
 625 SfxMailModel::SfxMailModel()
 626 {
 627 }
 628
 629 SfxMailModel::~SfxMailModel()
 630 {
 631 }
 632
 633 void SfxMailModel::AddToAddress( const OUString& rAddress )
 634 {
 635     // don't add an empty address
 636     if ( !rAddress.isEmpty() )
 637     {
 638         if ( !mpToList )
 639             // create the list
 640             mpToList.reset(new AddressList_Impl);
 641
 642         // add address to list
 643         mpToList->push_back( rAddress );
 644     }
 645 }
 646
 647 SfxMailModel::SendMailResult SfxMailModel::AttachDocument(
 648     const css::uno::Reference< css::uno::XInterface >& xFrameOrModel,
 649     const OUString& sAttachmentTitle )
 650 {
 651     OUString sFileName;
 652
 653     SaveResult eSaveResult = SaveDocumentAsFormat( sAttachmentTitle, xFrameOrModel, OUString()/*sDocumentType*/, sFileName );
 654     if ( eSaveResult == SAVE_SUCCESSFUL &&  !sFileName.isEmpty() )
 655         maAttachedDocuments.push_back(sFileName);
 656     return eSaveResult == SAVE_SUCCESSFUL ? SEND_MAIL_OK : SEND_MAIL_ERROR;
 657 }
 658
 659 SfxMailModel::SendMailResult SfxMailModel::Send( const css::uno::Reference< css::frame::XFrame >& xFrame )
 660 {
 661     OSL_ENSURE(!maAttachedDocuments.empty(),"No document added!");
 662     SendMailResult  eResult = SEND_MAIL_ERROR;
 663     if ( !maAttachedDocuments.empty() )
 664     {
 665         const css::uno::Reference < XComponentContext >& xContext = ::comphelper::getProcessComponentContext();
 666
 667         css::uno::Reference< XSimpleMailClientSupplier >    xSimpleMailClientSupplier;
 668
 669         // Prefer the SimpleSystemMail service if available
 670         try {
 671             xSimpleMailClientSupplier = SimpleSystemMail::create( xContext );
 672         }
 673         catch ( const uno::Exception & )
 674         {}
 675
 676         if ( ! xSimpleMailClientSupplier.is() )
 677         {
 678             try {
 679                 xSimpleMailClientSupplier = SimpleCommandMail::create( xContext );
 680             }
 681             catch ( const uno::Exception & )
 682             {}
 683         }
 684
 685         if ( xSimpleMailClientSupplier.is() )
 686         {
 687             css::uno::Reference< XSimpleMailClient > xSimpleMailClient = xSimpleMailClientSupplier->querySimpleMailClient();
 688
 689             if ( !xSimpleMailClient.is() )
 690             {
 691                 // no mail client support => message box!
 692                 return SEND_MAIL_ERROR;
 693             }
 694
 695             // we have a simple mail client
 696             css::uno::Reference< XSimpleMailMessage > xSimpleMailMessage = xSimpleMailClient->createSimpleMailMessage();
 697             if ( xSimpleMailMessage.is() )
 698             {
 699                 sal_Int32 nSendFlags = SimpleMailClientFlags::DEFAULTS;
 700                 if ( maFromAddress.isEmpty() )
 701                 {
 702                     // from address not set, try figure out users e-mail address
 703                     CreateFromAddress_Impl( maFromAddress );
 704                 }
 705                 xSimpleMailMessage->setOriginator( maFromAddress );
 706
 707                 size_t nToCount     = mpToList ? mpToList->size() : 0;
 708
 709                 // set recipient (only one) for this simple mail server!!
 710                 if ( nToCount >= 1 )
 711                 {
 712                     xSimpleMailMessage->setRecipient( mpToList->at( 0 ) );
 713                     nSendFlags = SimpleMailClientFlags::NO_USER_INTERFACE;
 714                 }
 715
 716                 // all other recipient must be handled with CC recipients!
 717                 if ( nToCount > 1 )
 718                 {
 719                     Sequence< OUString >    aCcRecipientSeq( nToCount - 1 );
 720                     std::copy_n(std::next(mpToList->begin()), aCcRecipientSeq.getLength(),
 721                                 aCcRecipientSeq.getArray());
 722                     xSimpleMailMessage->setCcRecipient( aCcRecipientSeq );
 723                 }
 724
 725                 Sequence< OUString > aAttachmentSeq(maAttachedDocuments.data(),maAttachedDocuments.size());
 726
 727                 if ( xSimpleMailMessage->getSubject().isEmpty() ) {
 728                     INetURLObject url(
 729                         maAttachedDocuments[0], INetURLObject::EncodeMechanism::WasEncoded);
 730                     OUString subject(
 731                         url.getBase(
 732                             INetURLObject::LAST_SEGMENT, false,
 733                             INetURLObject::DecodeMechanism::WithCharset));
 734                     if (subject.isEmpty()) {
 735                         subject = maAttachedDocuments[0];
 736                     }
 737                     if ( maAttachedDocuments.size() > 1 )
 738                         subject += ", ...";
 739                     xSimpleMailMessage->setSubject( subject );
 740                 }
 741                 xSimpleMailMessage->setAttachement( aAttachmentSeq );
 742
 743                 bool bSend( false );
 744                 try
 745                 {
 746                     xSimpleMailClient->sendSimpleMailMessage( xSimpleMailMessage, nSendFlags );
 747                     bSend = true;
 748                 }
 749                 catch ( IllegalArgumentException& )
 750                 {
 751                 }
 752                 catch ( Exception& )
 753                 {
 754                 }
 755
 756                 if ( !bSend )
 757                 {
 758                     css::uno::Reference< css::awt::XWindow > xParentWindow = xFrame->getContainerWindow();
 759
 760                     SolarMutexGuard aGuard;
 761
 762                     std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(Application::GetFrameWeld(xParentWindow), u"sfx/ui/errorfindemaildialog.ui"_ustr));
 763                     std::unique_ptr<weld::MessageDialog> xBox(xBuilder->weld_message_dialog(u"ErrorFindEmailDialog"_ustr));
 764                     xBox->run();
 765                     eResult = SEND_MAIL_CANCELLED;
 766                 }
 767                 else
 768                     eResult = SEND_MAIL_OK;
 769             }
 770         }
 771     }
 772     else
 773         eResult = SEND_MAIL_CANCELLED;
 774
 775     return eResult;
 776 }
 777
 778 SfxMailModel::SendMailResult SfxMailModel::SaveAndSend( const css::uno::Reference< css::frame::XFrame >& xFrame, const OUString& rTypeName )
 779 {
 780     SaveResult      eSaveResult;
 781     SendMailResult  eResult = SEND_MAIL_ERROR;
 782     OUString   aFileName;
 783
 784     eSaveResult = SaveDocumentAsFormat( OUString(), xFrame, rTypeName, aFileName );
 785
 786     if ( eSaveResult == SAVE_SUCCESSFUL )
 787     {
 788         maAttachedDocuments.push_back( aFileName );
 789         return Send( xFrame );
 790     }
 791     else if ( eSaveResult == SAVE_CANCELLED )
 792         eResult = SEND_MAIL_CANCELLED;
 793
 794     return eResult;
 795 }
 796
 797 // functions -------------------------------------------------------------
 798
 799 bool CreateFromAddress_Impl( OUString& rFrom )
 800
 801 /* [Description]
 802
 803     This function tries to create a From-address with the help of IniManagers.
 804     For this the fields 'first name', 'Name' and 'Email' are read from the
 805     application-ini-data. If these fields are not set, FALSE is returned.
 806
 807     [Return value]
 808
 809     sal_True:       Address could be created.
 810     sal_False:      Address could not be created.
 811 */
 812
 813 {
 814     SvtUserOptions aUserCFG;
 815     OUString aName        = aUserCFG.GetLastName  ();
 816     OUString aFirstName   = aUserCFG.GetFirstName ();
 817     if ( !aFirstName.isEmpty() || !aName.isEmpty() )
 818     {
 819         if ( !aFirstName.isEmpty() )
 820         {
 821             rFrom = comphelper::string::strip(aFirstName, ' ');
 822
 823             if ( !aName.isEmpty() )
 824                 rFrom += " ";
 825         }
 826         rFrom += comphelper::string::strip(aName, ' ');
 827         // remove illegal characters
 828         rFrom = rFrom.replaceAll("<", "").replaceAll(">", "").replaceAll("@", "");
 829     }
 830     OUString aEmailName = aUserCFG.GetEmail();
 831
 832     // remove illegal characters
 833     aEmailName = aEmailName.replaceAll("<", "").replaceAll(">", "");
 834
 835     if ( !aEmailName.isEmpty() )
 836     {
 837         if ( !rFrom.isEmpty() )
 838             rFrom += " ";
 839         rFrom += "<" + comphelper::string::strip(aEmailName, ' ') + ">";
 840     }
 841     else
 842         rFrom.clear();
 843     return !rFrom.isEmpty();
 844 }
 845
 846 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */