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/sequenceashashmap.hxx>
  56 #include <comphelper/string.hxx>
  57 #include <vcl/svapp.hxx>
  58 #include <cppuhelper/implbase.hxx>
  59
  60
  61 using namespace ::com::sun::star;
  62 using namespace ::com::sun::star::beans;
  63 using namespace ::com::sun::star::frame;
  64 using namespace ::com::sun::star::io;
  65 using namespace ::com::sun::star::lang;
  66 using namespace ::com::sun::star::ucb;
  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 char       PDF_DOCUMENT_TYPE[]   = "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     const OUString& 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( "com.sun.star.document.FilterFactory" ), 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 : std::as_const(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::Sequence< beans::PropertyValue > aPropsForDialog(1);
 153                             uno::Reference< document::XExporter > xExporter( xFilterDialog, uno::UNO_QUERY );
 154
 155                             if ( rType == PDF_DOCUMENT_TYPE )
 156                             {
 157                                 //add an internal property, used to tell the dialog we want to set a different
 158                                 //string for the ok button
 159                                 //used in filter/source/pdf/impdialog.cxx
 160                                 uno::Sequence< beans::PropertyValue > aFilterDataValue(1);
 161                                 aFilterDataValue[0].Name = "_OkButtonString";
 162                                 aFilterDataValue[0].Value <<= SfxResId(STR_PDF_EXPORT_SEND );
 163
 164                                 //add to the filterdata property, the only one the PDF export filter dialog will care for
 165                                 aPropsForDialog[0].Name = "FilterData";
 166                                 aPropsForDialog[0].Value <<= aFilterDataValue;
 167
 168                                 //when executing the dialog will merge the persistent FilterData properties
 169                                 xFilterProperties->setPropertyValues( aPropsForDialog );
 170                             }
 171
 172                             if( xExporter.is() )
 173                                 xExporter->setSourceDocument( xModel );
 174
 175                             if( xFilterDialog->execute() )
 176                             {
 177                                 //get the filter data
 178                                 uno::Sequence< beans::PropertyValue > aPropsFromDialog = xFilterProperties->getPropertyValues();
 179
 180                                 //add them to the args
 181                                 auto pProp = std::find_if(aPropsFromDialog.begin(), aPropsFromDialog.end(),
 182                                     [](const beans::PropertyValue& rDialogProp) { return rDialogProp.Name == "FilterData"; });
 183                                 if (pProp != aPropsFromDialog.end())
 184                                 {
 185                                     //found the filterdata, add to the storing argument
 186                                     rArgs.realloc( ++rNumArgs );
 187                                     rArgs[rNumArgs-1].Name = pProp->Name;
 188                                     rArgs[rNumArgs-1].Value = pProp->Value;
 189                                 }
 190                                 eRet = SAVE_SUCCESSFULL;
 191                             }
 192                             else
 193                             {
 194                                 // cancel from dialog, then do not send
 195                                 // If the model is not modified, it could be modified by the dispatch calls.
 196                                 // Therefore set back to modified = false. This should not hurt if we call
 197                                 // on a non-modified model.
 198                                 if ( !bModified )
 199                                 {
 200                                     try
 201                                     {
 202                                         xModifiable->setModified( false );
 203                                     }
 204                                     catch( css::beans::PropertyVetoException& )
 205                                     {
 206                                     }
 207                                 }
 208                                 eRet = SAVE_CANCELLED;
 209                             }
 210                         }
 211                         break;
 212                     }
 213                 }
 214             }
 215         }
 216     }
 217     catch( css::uno::RuntimeException& )
 218     {
 219         throw;
 220     }
 221     catch( uno::Exception& )
 222     {
 223     }
 224
 225     return eRet;
 226 }
 227
 228 bool SfxMailModel::IsEmpty() const
 229 {
 230     return maAttachedDocuments.empty();
 231 }
 232
 233 SfxMailModel::SaveResult SfxMailModel::SaveDocumentAsFormat(
 234     const OUString& aSaveFileName,
 235     const css::uno::Reference< css::uno::XInterface >& xFrameOrModel,
 236     const OUString& rType,
 237     OUString& rFileNamePath )
 238 {
 239     SaveResult  eRet( SAVE_ERROR );
 240     bool        bSendAsPDF = ( rType == PDF_DOCUMENT_TYPE );
 241
 242     css::uno::Reference< css::lang::XMultiServiceFactory > xSMGR  = ::comphelper::getProcessServiceFactory();
 243     css::uno::Reference< css::uno::XComponentContext > xContext  = ::comphelper::getProcessComponentContext();
 244     if (!xContext.is())
 245         return eRet;
 246
 247     css::uno::Reference< css::frame::XModuleManager2 > xModuleManager( css::frame::ModuleManager::create(xContext) );
 248
 249     OUString aModule;
 250     try
 251     {
 252          aModule = xModuleManager->identify( xFrameOrModel );
 253     }
 254     catch ( css::uno::RuntimeException& )
 255     {
 256         throw;
 257     }
 258     catch ( css::uno::Exception& )
 259     {
 260     }
 261
 262     css::uno::Reference< css::frame::XFrame > xFrame( xFrameOrModel, css::uno::UNO_QUERY );
 263     css::uno::Reference< css::frame::XModel > xModel( xFrameOrModel, css::uno::UNO_QUERY );
 264     if ( xFrame.is() )
 265     {
 266         css::uno::Reference< css::frame::XController > xController = xFrame->getController();
 267         if ( xController.is() )
 268             xModel = xController->getModel();
 269     }
 270
 271     // We need at least a valid module name and model reference
 272     if ( !aModule.isEmpty()  && xModel.is() )
 273     {
 274         bool bModified( false );
 275         bool bHasLocation( false );
 276         bool bStoreTo( false );
 277
 278         css::uno::Reference< css::util::XModifiable > xModifiable( xModel, css::uno::UNO_QUERY );
 279         css::uno::Reference< css::frame::XStorable > xStorable( xModel, css::uno::UNO_QUERY );
 280
 281         if ( xModifiable.is() )
 282             bModified = xModifiable->isModified();
 283         if ( xStorable.is() )
 284         {
 285             OUString aLocation = xStorable->getLocation();
 286             INetURLObject aFileObj( aLocation );
 287
 288             bool bPrivateProtocol = ( aFileObj.GetProtocol() == INetProtocol::PrivSoffice );
 289
 290             bHasLocation =  !aLocation.isEmpty() && !bPrivateProtocol;
 291             OSL_ASSERT( !bPrivateProtocol );
 292         }
 293         if ( !rType.isEmpty() )
 294             bStoreTo = true;
 295
 296         if ( xStorable.is() )
 297         {
 298             OUString aFilterName;
 299             OUString aTypeName( rType );
 300             OUString aFileName;
 301             OUString aExtension;
 302
 303             css::uno::Reference< css::container::XContainerQuery > xContainerQuery(
 304                 xSMGR->createInstance( "com.sun.star.document.FilterFactory" ),
 305                 css::uno::UNO_QUERY );
 306
 307             if ( bStoreTo )
 308             {
 309                 // Retrieve filter from type
 310                 css::uno::Sequence< css::beans::NamedValue > aQuery( bSendAsPDF ? 3 : 2 );
 311                 aQuery[0].Name  = "Type";
 312                 aQuery[0].Value <<= aTypeName;
 313                 aQuery[1].Name  = "DocumentService";
 314                 aQuery[1].Value <<= aModule;
 315                 if( bSendAsPDF )
 316                 {
 317                     // #i91419#
 318                     // FIXME: we want just an export filter. However currently we need
 319                     // exact flag value as detailed in the filter configuration to get it
 320                     // this seems to be a bug
 321                     // without flags we get an import filter here, which is also unwanted
 322                     aQuery[2].Name  = "Flags";
 323                     aQuery[2].Value <<= sal_Int32(0x80042); // EXPORT ALIEN 3RDPARTY
 324                 }
 325
 326                 css::uno::Reference< css::container::XEnumeration > xEnumeration =
 327                     xContainerQuery->createSubSetEnumerationByProperties( aQuery );
 328
 329                 if ( xEnumeration->hasMoreElements() )
 330                 {
 331                     ::comphelper::SequenceAsHashMap aFilterPropsHM( xEnumeration->nextElement() );
 332                     aFilterName = aFilterPropsHM.getUnpackedValueOrDefault(
 333                                                 "Name",
 334                                                 OUString() );
 335                 }
 336
 337                 if ( bHasLocation )
 338                 {
 339                     // Retrieve filter from media descriptor
 340                     ::comphelper::SequenceAsHashMap aMediaDescrPropsHM( xModel->getArgs() );
 341                     OUString aOrgFilterName = aMediaDescrPropsHM.getUnpackedValueOrDefault(
 342                                     "FilterName",
 343                                     OUString() );
 344                     if ( aOrgFilterName == aFilterName )
 345                     {
 346                         // We should save the document in the original format. Therefore this
 347                         // is not a storeTo operation. To support signing in this case, reset
 348                         // bStoreTo flag.
 349                         bStoreTo = false;
 350                     }
 351                 }
 352             }
 353             else
 354             {
 355                 if ( bHasLocation )
 356                 {
 357                     // Retrieve filter from media descriptor
 358                     ::comphelper::SequenceAsHashMap aMediaDescrPropsHM( xModel->getArgs() );
 359                     aFilterName = aMediaDescrPropsHM.getUnpackedValueOrDefault(
 360                                     "FilterName",
 361                                     OUString() );
 362                 }
 363
 364                 if ( !bHasLocation ||  aFilterName.isEmpty())
 365                 {
 366                     // Retrieve the user defined default filter
 367                     try
 368                     {
 369                         ::comphelper::SequenceAsHashMap aFilterPropsHM( xModuleManager->getByName( aModule ) );
 370                         aFilterName = aFilterPropsHM.getUnpackedValueOrDefault(
 371                                                     "ooSetupFactoryDefaultFilter",
 372                                                     OUString() );
 373                         css::uno::Reference< css::container::XNameAccess > xNameAccess(
 374                             xContainerQuery, css::uno::UNO_QUERY );
 375                         if ( xNameAccess.is() )
 376                         {
 377                             ::comphelper::SequenceAsHashMap aFilterPropsHM2( xNameAccess->getByName( aFilterName ) );
 378                             aTypeName = aFilterPropsHM2.getUnpackedValueOrDefault(
 379                                                         "Type",
 380                                                         OUString() );
 381                         }
 382                     }
 383                     catch ( css::container::NoSuchElementException& )
 384                     {
 385                     }
 386                     catch ( css::beans::UnknownPropertyException& )
 387                     {
 388                     }
 389                 }
 390             }
 391
 392             // No filter found => error
 393             // No type and no location => error
 394             if (( aFilterName.isEmpty() ) ||
 395                 ( aTypeName.isEmpty()  && !bHasLocation ))
 396                 return eRet;
 397
 398             // Determine file name and extension
 399             if ( bHasLocation && !bStoreTo )
 400             {
 401                 INetURLObject aFileObj( xStorable->getLocation() );
 402                 aExtension = aFileObj.getExtension();
 403             }
 404             else
 405             {
 406                 css::uno::Reference< container::XNameAccess > xTypeDetection(
 407                     xSMGR->createInstance( "com.sun.star.document.TypeDetection" ),
 408                     css::uno::UNO_QUERY );
 409
 410
 411                 if ( xTypeDetection.is() )
 412                 {
 413                     try
 414                     {
 415                         ::comphelper::SequenceAsHashMap aTypeNamePropsHM( xTypeDetection->getByName( aTypeName ) );
 416                         uno::Sequence< OUString > aExtensions = aTypeNamePropsHM.getUnpackedValueOrDefault(
 417                                                         "Extensions",
 418                                                         ::uno::Sequence< OUString >() );
 419                         if ( aExtensions.hasElements() )
 420                             aExtension = aExtensions[0];
 421                     }
 422                     catch ( css::container::NoSuchElementException& )
 423                     {
 424                     }
 425                 }
 426             }
 427
 428             // Use provided save file name. If empty determine file name
 429             aFileName = aSaveFileName;
 430             if ( aFileName.isEmpty() )
 431             {
 432                 if ( !bHasLocation )
 433                 {
 434                     // Create a noname file name with the correct extension
 435                     aFileName = "noname";
 436                 }
 437                 else
 438                 {
 439                     // Determine file name from model
 440                     INetURLObject aFileObj( xStorable->getLocation() );
 441                     aFileName = aFileObj.getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DecodeMechanism::NONE );
 442                 }
 443             }
 444
 445             // No file name => error
 446             if ( aFileName.isEmpty() )
 447                 return eRet;
 448
 449             OSL_ASSERT( !aFilterName.isEmpty() );
 450             OSL_ASSERT( !aFileName.isEmpty() );
 451
 452             // Creates a temporary directory to store a predefined file into it.
 453             // This makes it possible to store the file for "send document as e-mail"
 454             // with the original file name. We cannot use the original file as
 455             // some mail programs need exclusive access.
 456             ::utl::TempFile aTempDir( nullptr, true );
 457
 458             INetURLObject aFilePathObj( aTempDir.GetURL() );
 459             aFilePathObj.insertName( aFileName );
 460             aFilePathObj.setExtension( aExtension );
 461
 462             OUString aFileURL = aFilePathObj.GetMainURL( INetURLObject::DecodeMechanism::NONE );
 463
 464             sal_Int32 nNumArgs(0);
 465             const OUString aPasswordPropName( "Password" );
 466             css::uno::Sequence< css::beans::PropertyValue > aArgs( ++nNumArgs );
 467             aArgs[nNumArgs-1].Name  = "FilterName";
 468             aArgs[nNumArgs-1].Value <<= 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                 aArgs[nNumArgs-1].Name = aPasswordPropName;
 478                 aArgs[nNumArgs-1].Value <<= aPassword;
 479             }
 480
 481             bool bNeedsPreparation = false;
 482             css::util::URL aPrepareURL;
 483             css::uno::Reference< css::frame::XDispatch > xPrepareDispatch;
 484             css::uno::Reference< css::frame::XDispatchProvider > xDispatchProvider( xFrame, css::uno::UNO_QUERY );
 485             css::uno::Reference< css::util::XURLTransformer > xURLTransformer( css::util::URLTransformer::create( xContext ) );
 486             if( !bSendAsPDF )
 487             {
 488                 try
 489                 {
 490                     // check if the document needs to be prepared for sending as mail (embedding of links, removal of invisible content)
 491
 492                     aPrepareURL.Complete = ".uno:PrepareMailExport";
 493                     xURLTransformer->parseStrict( aPrepareURL );
 494
 495                     if ( xDispatchProvider.is() )
 496                     {
 497                         xPrepareDispatch.set( xDispatchProvider->queryDispatch( aPrepareURL, OUString(), 0 ));
 498                         if ( xPrepareDispatch.is() )
 499                         {
 500                                 PrepareListener_Impl* pPrepareListener = new PrepareListener_Impl;
 501                                 uno::Reference< css::frame::XStatusListener > xStatusListener = pPrepareListener;
 502                                 xPrepareDispatch->addStatusListener( xStatusListener, aPrepareURL );
 503                                 bNeedsPreparation = pPrepareListener->IsSet();
 504                                 xPrepareDispatch->removeStatusListener( xStatusListener, 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_SUCCESSFULL )
 546                             return eShowPDFFilterDialog;
 547                     }
 548
 549                     xStorable->storeToURL( aFileURL, aArgs );
 550                     rFileNamePath = aFileURL;
 551                     eRet = SAVE_SUCCESSFULL;
 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                 aArgs[nNumArgs-1].Name = "CopyStreamIfPossible";
 605                 aArgs[nNumArgs-1].Value <<= true;
 606
 607                 try
 608                 {
 609                     xStorable->storeToURL( aFileURL, aArgs );
 610                     rFileNamePath = aFileURL;
 611                     eRet = SAVE_SUCCESSFULL;
 612                 }
 613                 catch ( css::io::IOException& )
 614                 {
 615                     eRet = SAVE_ERROR;
 616                 }
 617             }
 618         }
 619     }
 620
 621     return eRet;
 622 }
 623
 624 SfxMailModel::SfxMailModel()
 625 {
 626 }
 627
 628 SfxMailModel::~SfxMailModel()
 629 {
 630 }
 631
 632 void SfxMailModel::AddToAddress( const OUString& rAddress )
 633 {
 634     // don't add an empty address
 635     if ( !rAddress.isEmpty() )
 636     {
 637         if ( !mpToList )
 638             // create the list
 639             mpToList.reset(new AddressList_Impl);
 640
 641         // add address to list
 642         mpToList->push_back( rAddress );
 643     }
 644 }
 645
 646 SfxMailModel::SendMailResult SfxMailModel::AttachDocument(
 647     const css::uno::Reference< css::uno::XInterface >& xFrameOrModel,
 648     const OUString& sAttachmentTitle )
 649 {
 650     OUString sFileName;
 651
 652     SaveResult eSaveResult = SaveDocumentAsFormat( sAttachmentTitle, xFrameOrModel, OUString()/*sDocumentType*/, sFileName );
 653     if ( eSaveResult == SAVE_SUCCESSFULL &&  !sFileName.isEmpty() )
 654         maAttachedDocuments.push_back(sFileName);
 655     return eSaveResult == SAVE_SUCCESSFULL ? SEND_MAIL_OK : SEND_MAIL_ERROR;
 656 }
 657
 658 SfxMailModel::SendMailResult SfxMailModel::Send( const css::uno::Reference< css::frame::XFrame >& xFrame )
 659 {
 660     OSL_ENSURE(!maAttachedDocuments.empty(),"No document added!");
 661     SendMailResult  eResult = SEND_MAIL_ERROR;
 662     if ( !maAttachedDocuments.empty() )
 663     {
 664         css::uno::Reference < XComponentContext > xContext = ::comphelper::getProcessComponentContext();
 665
 666         css::uno::Reference< XSimpleMailClientSupplier >    xSimpleMailClientSupplier;
 667
 668         // Prefer the SimpleSystemMail service if available
 669         try {
 670             xSimpleMailClientSupplier = SimpleSystemMail::create( xContext );
 671         }
 672         catch ( const uno::Exception & )
 673         {}
 674
 675         if ( ! xSimpleMailClientSupplier.is() )
 676         {
 677             try {
 678                 xSimpleMailClientSupplier = SimpleCommandMail::create( xContext );
 679             }
 680             catch ( const uno::Exception & )
 681             {}
 682         }
 683
 684         if ( xSimpleMailClientSupplier.is() )
 685         {
 686             css::uno::Reference< XSimpleMailClient > xSimpleMailClient = xSimpleMailClientSupplier->querySimpleMailClient();
 687
 688             if ( !xSimpleMailClient.is() )
 689             {
 690                 // no mail client support => message box!
 691                 return SEND_MAIL_ERROR;
 692             }
 693
 694             // we have a simple mail client
 695             css::uno::Reference< XSimpleMailMessage > xSimpleMailMessage = xSimpleMailClient->createSimpleMailMessage();
 696             if ( xSimpleMailMessage.is() )
 697             {
 698                 sal_Int32 nSendFlags = SimpleMailClientFlags::DEFAULTS;
 699                 if ( maFromAddress.isEmpty() )
 700                 {
 701                     // from address not set, try figure out users e-mail address
 702                     CreateFromAddress_Impl( maFromAddress );
 703                 }
 704                 xSimpleMailMessage->setOriginator( maFromAddress );
 705
 706                 size_t nToCount     = mpToList ? mpToList->size() : 0;
 707
 708                 // set recipient (only one) for this simple mail server!!
 709                 if ( nToCount >= 1 )
 710                 {
 711                     xSimpleMailMessage->setRecipient( mpToList->at( 0 ) );
 712                     nSendFlags = SimpleMailClientFlags::NO_USER_INTERFACE;
 713                 }
 714
 715                 // all other recipient must be handled with CC recipients!
 716                 if ( nToCount > 1 )
 717                 {
 718                     Sequence< OUString >    aCcRecipientSeq( nToCount - 1 );
 719                     for ( size_t i = 1; i < nToCount; ++i )
 720                         aCcRecipientSeq[i - 1] = mpToList->at(i);
 721                     xSimpleMailMessage->setCcRecipient( aCcRecipientSeq );
 722                 }
 723
 724                 Sequence< OUString > aAttachmentSeq(maAttachedDocuments.data(),maAttachedDocuments.size());
 725
 726                 if ( xSimpleMailMessage->getSubject().isEmpty() ) {
 727                     INetURLObject url(
 728                         maAttachedDocuments[0], INetURLObject::EncodeMechanism::WasEncoded);
 729                     OUString subject(
 730                         url.getBase(
 731                             INetURLObject::LAST_SEGMENT, false,
 732                             INetURLObject::DecodeMechanism::WithCharset));
 733                     if (subject.isEmpty()) {
 734                         subject = maAttachedDocuments[0];
 735                     }
 736                     if ( maAttachedDocuments.size() > 1 )
 737                         subject += ", ...";
 738                     xSimpleMailMessage->setSubject( subject );
 739                 }
 740                 xSimpleMailMessage->setAttachement( aAttachmentSeq );
 741
 742                 bool bSend( false );
 743                 try
 744                 {
 745                     xSimpleMailClient->sendSimpleMailMessage( xSimpleMailMessage, nSendFlags );
 746                     bSend = true;
 747                 }
 748                 catch ( IllegalArgumentException& )
 749                 {
 750                 }
 751                 catch ( Exception& )
 752                 {
 753                 }
 754
 755                 if ( !bSend )
 756                 {
 757                     css::uno::Reference< css::awt::XWindow > xParentWindow = xFrame->getContainerWindow();
 758
 759                     SolarMutexGuard aGuard;
 760
 761                     std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(Application::GetFrameWeld(xParentWindow), "sfx/ui/errorfindemaildialog.ui"));
 762                     std::unique_ptr<weld::MessageDialog> xBox(xBuilder->weld_message_dialog("ErrorFindEmailDialog"));
 763                     xBox->run();
 764                     eResult = SEND_MAIL_CANCELLED;
 765                 }
 766                 else
 767                     eResult = SEND_MAIL_OK;
 768             }
 769         }
 770     }
 771     else
 772         eResult = SEND_MAIL_CANCELLED;
 773
 774     return eResult;
 775 }
 776
 777 SfxMailModel::SendMailResult SfxMailModel::SaveAndSend( const css::uno::Reference< css::frame::XFrame >& xFrame, const OUString& rTypeName )
 778 {
 779     SaveResult      eSaveResult;
 780     SendMailResult  eResult = SEND_MAIL_ERROR;
 781     OUString   aFileName;
 782
 783     eSaveResult = SaveDocumentAsFormat( OUString(), xFrame, rTypeName, aFileName );
 784
 785     if ( eSaveResult == SAVE_SUCCESSFULL )
 786     {
 787         maAttachedDocuments.push_back( aFileName );
 788         return Send( xFrame );
 789     }
 790     else if ( eSaveResult == SAVE_CANCELLED )
 791         eResult = SEND_MAIL_CANCELLED;
 792
 793     return eResult;
 794 }
 795
 796 // functions -------------------------------------------------------------
 797
 798 bool CreateFromAddress_Impl( OUString& rFrom )
 799
 800 /* [Description]
 801
 802     This function tries to create a From-address with the help of IniManagers.
 803     For this the fields 'first name', 'Name' and 'Email' are read from the
 804     application-ini-data. If these fields are not set, FALSE is returned.
 805
 806     [Return value]
 807
 808     sal_True:       Address could be created.
 809     sal_False:      Address could not be created.
 810 */
 811
 812 {
 813     SvtUserOptions aUserCFG;
 814     OUString aName        = aUserCFG.GetLastName  ();
 815     OUString aFirstName   = aUserCFG.GetFirstName ();
 816     if ( !aFirstName.isEmpty() || !aName.isEmpty() )
 817     {
 818         if ( !aFirstName.isEmpty() )
 819         {
 820             rFrom = comphelper::string::strip(aFirstName, ' ');
 821
 822             if ( !aName.isEmpty() )
 823                 rFrom += " ";
 824         }
 825         rFrom += comphelper::string::strip(aName, ' ');
 826         // remove illegal characters
 827         rFrom = rFrom.replaceAll("<", "").replaceAll(">", "").replaceAll("@", "");
 828     }
 829     OUString aEmailName = aUserCFG.GetEmail();
 830
 831     // remove illegal characters
 832     aEmailName = aEmailName.replaceAll("<", "").replaceAll(">", "");
 833
 834     if ( !aEmailName.isEmpty() )
 835     {
 836         if ( !rFrom.isEmpty() )
 837             rFrom += " ";
 838         rFrom += "<" + comphelper::string::strip(aEmailName, ' ') + ">";
 839     }
 840     else
 841         rFrom.clear();
 842     return !rFrom.isEmpty();
 843 }
 844
 845 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */