sfx2/source/doc/objmisc.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 <config_features.h>
  21 #include <config_folders.h>
  22
  23 #include <tools/inetmsg.hxx>
  24 #include <tools/diagnose_ex.h>
  25 #include <svl/eitem.hxx>
  26 #include <svl/stritem.hxx>
  27 #include <svl/intitem.hxx>
  28 #include <svtools/svparser.hxx>
  29 #include <cppuhelper/exc_hlp.hxx>
  30 #include <sal/log.hxx>
  31
  32 #include <com/sun/star/container/XChild.hpp>
  33 #include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
  34 #include <com/sun/star/document/XDocumentProperties.hpp>
  35 #include <com/sun/star/document/UpdateDocMode.hpp>
  36 #include <com/sun/star/document/MacroExecMode.hpp>
  37 #include <com/sun/star/document/XScriptInvocationContext.hpp>
  38 #include <com/sun/star/embed/EmbedStates.hpp>
  39 #include <com/sun/star/embed/XEmbedPersist.hpp>
  40 #include <com/sun/star/embed/XEmbeddedObject.hpp>
  41 #include <com/sun/star/script/provider/theMasterScriptProviderFactory.hpp>
  42 #include <com/sun/star/script/provider/XScript.hpp>
  43 #include <com/sun/star/script/provider/XScriptProvider.hpp>
  44 #include <com/sun/star/script/provider/XScriptProviderSupplier.hpp>
  45 #include <com/sun/star/ucb/SimpleFileAccess.hpp>
  46 #include <com/sun/star/uri/UriReferenceFactory.hpp>
  47 #include <com/sun/star/uri/XVndSunStarScriptUrlReference.hpp>
  48 #include <com/sun/star/util/XModifiable.hpp>
  49
  50 #include <toolkit/helper/vclunohelper.hxx>
  51
  52 #include <com/sun/star/uno/Reference.h>
  53 #include <com/sun/star/uno/Any.h>
  54 #include <com/sun/star/ucb/XContent.hpp>
  55 #include <com/sun/star/task/ErrorCodeRequest.hpp>
  56 #include <unotools/securityoptions.hxx>
  57
  58 #include <comphelper/processfactory.hxx>
  59 #include <comphelper/string.hxx>
  60
  61 #include <com/sun/star/security/DocumentDigitalSignatures.hpp>
  62 #include <com/sun/star/task/DocumentMacroConfirmationRequest.hpp>
  63 #include <com/sun/star/task/InteractionClassification.hpp>
  64 #include <com/sun/star/frame/XModel.hpp>
  65
  66 #include <basic/sbuno.hxx>
  67 #include <basic/sbstar.hxx>
  68 #include <basic/basmgr.hxx>
  69 #include <basic/sberrors.hxx>
  70 #include <vcl/weld.hxx>
  71 #include <basic/sbx.hxx>
  72 #include <svtools/sfxecode.hxx>
  73 #include <svtools/ehdl.hxx>
  74
  75 #include <unotools/pathoptions.hxx>
  76 #include <unotools/ucbhelper.hxx>
  77 #include <tools/inetmime.hxx>
  78 #include <tools/urlobj.hxx>
  79 #include <svl/inettype.hxx>
  80 #include <svl/sharecontrolfile.hxx>
  81 #include <osl/file.hxx>
  82 #include <rtl/bootstrap.hxx>
  83 #include <vcl/svapp.hxx>
  84 #include <framework/interaction.hxx>
  85 #include <framework/documentundoguard.hxx>
  86 #include <comphelper/interaction.hxx>
  87 #include <comphelper/storagehelper.hxx>
  88 #include <comphelper/documentconstants.hxx>
  89
  90 #include <sfx2/signaturestate.hxx>
  91 #include <sfx2/app.hxx>
  92 #include <appdata.hxx>
  93 #include <sfx2/request.hxx>
  94 #include <sfx2/bindings.hxx>
  95 #include <sfx2/sfxresid.hxx>
  96 #include <sfx2/docfile.hxx>
  97 #include <sfx2/docfilt.hxx>
  98 #include <sfx2/objsh.hxx>
  99 #include <objshimp.hxx>
 100 #include <sfx2/event.hxx>
 101 #include <sfx2/dispatch.hxx>
 102 #include <sfx2/viewfrm.hxx>
 103 #include <sfx2/viewsh.hxx>
 104 #include <sfx2/ctrlitem.hxx>
 105 #include <sfx2/sfxuno.hxx>
 106 #include <arrdecl.hxx>
 107 #include <sfx2/module.hxx>
 108 #include <sfx2/docfac.hxx>
 109 #include <helper.hxx>
 110 #include <sfx2/sfxsids.hrc>
 111 #include <sfx2/strings.hrc>
 112 #include <workwin.hxx>
 113 #include <sfx2/sfxdlg.hxx>
 114 #include <appbaslib.hxx>
 115 #include <openflag.hxx>
 116 #include "objstor.hxx"
 117 #include <appopen.hxx>
 118
 119 #include <memory>
 120
 121 using namespace ::com::sun::star;
 122 using namespace ::com::sun::star::uno;
 123 using namespace ::com::sun::star::ucb;
 124 using namespace ::com::sun::star::document;
 125 using namespace ::com::sun::star::frame;
 126 using namespace ::com::sun::star::script;
 127 using namespace ::com::sun::star::script::provider;
 128 using namespace ::com::sun::star::container;
 129
 130 // class SfxHeaderAttributes_Impl ----------------------------------------
 131
 132 class SfxHeaderAttributes_Impl : public SvKeyValueIterator
 133 {
 134 private:
 135     SfxObjectShell* pDoc;
 136     SvKeyValueIteratorRef xIter;
 137     bool bAlert;
 138
 139 public:
 140     explicit SfxHeaderAttributes_Impl( SfxObjectShell* pSh ) :
 141         SvKeyValueIterator(), pDoc( pSh ),
 142         xIter( pSh->GetMedium()->GetHeaderAttributes_Impl() ),
 143         bAlert( false ) {}
 144
 145     virtual bool GetFirst( SvKeyValue& rKV ) override { return xIter->GetFirst( rKV ); }
 146     virtual bool GetNext( SvKeyValue& rKV ) override { return xIter->GetNext( rKV ); }
 147     virtual void Append( const SvKeyValue& rKV ) override;
 148
 149     void ClearForSourceView() { xIter = new SvKeyValueIterator; bAlert = false; }
 150     void SetAttributes();
 151     void SetAttribute( const SvKeyValue& rKV );
 152 };
 153
 154
 155 sal_uInt16 const aTitleMap_Impl[3][2] =
 156 {
 157                                 //  local               remote
 158     /*  SFX_TITLE_CAPTION   */  {   SFX_TITLE_FILENAME, SFX_TITLE_TITLE },
 159     /*  SFX_TITLE_PICKLIST  */  {   32,                 SFX_TITLE_FULLNAME },
 160     /*  SFX_TITLE_HISTORY   */  {   32,                 SFX_TITLE_FULLNAME }
 161 };
 162
 163
 164 bool SfxObjectShell::IsAbortingImport() const
 165 {
 166     return pImpl->bIsAbortingImport;
 167 }
 168
 169
 170 uno::Reference<document::XDocumentProperties>
 171 SfxObjectShell::getDocProperties()
 172 {
 173     uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
 174         GetModel(), uno::UNO_QUERY_THROW);
 175     uno::Reference<document::XDocumentProperties> xDocProps(
 176         xDPS->getDocumentProperties());
 177     DBG_ASSERT(xDocProps.is(),
 178         "SfxObjectShell: model has no DocumentProperties");
 179     return xDocProps;
 180 }
 181
 182
 183 void SfxObjectShell::DoFlushDocInfo()
 184 {
 185 }
 186
 187
 188 // Note: the only thing that calls this is the modification event handler
 189 // that is installed at the XDocumentProperties
 190 void SfxObjectShell::FlushDocInfo()
 191 {
 192     if ( IsLoading() )
 193         return;
 194
 195     SetModified();
 196     uno::Reference<document::XDocumentProperties> xDocProps(getDocProperties());
 197     DoFlushDocInfo(); // call template method
 198     const OUString url(xDocProps->getAutoloadURL());
 199     sal_Int32 delay(xDocProps->getAutoloadSecs());
 200     SetAutoLoad( INetURLObject(url), delay * 1000,
 201                  (delay > 0) || !url.isEmpty() );
 202 }
 203
 204 void SfxObjectShell::SetError(ErrCode lErr)
 205 {
 206     if (pImpl->lErr==ERRCODE_NONE)
 207     {
 208         pImpl->lErr=lErr;
 209     }
 210 }
 211
 212 ErrCode SfxObjectShell::GetError() const
 213 {
 214     return GetErrorCode().IgnoreWarning();
 215 }
 216
 217 ErrCode SfxObjectShell::GetErrorCode() const
 218 {
 219     ErrCode lError=pImpl->lErr;
 220     if(!lError && GetMedium())
 221         lError=GetMedium()->GetErrorCode();
 222     return lError;
 223 }
 224
 225 void SfxObjectShell::ResetError()
 226 {
 227     pImpl->lErr=ERRCODE_NONE;
 228     SfxMedium * pMed = GetMedium();
 229     if( pMed )
 230         pMed->ResetError();
 231 }
 232
 233 void SfxObjectShell::EnableSetModified( bool bEnable )
 234 {
 235     SAL_INFO_IF( bEnable == pImpl->m_bEnableSetModified, "sfx", "SFX_PERSIST: EnableSetModified 2x called with the same value" );
 236     pImpl->m_bEnableSetModified = bEnable;
 237 }
 238
 239
 240 bool SfxObjectShell::IsEnableSetModified() const
 241 {
 242     return pImpl->m_bEnableSetModified && !IsReadOnly();
 243 }
 244
 245
 246 bool SfxObjectShell::IsModified()
 247 {
 248     if ( pImpl->m_bIsModified )
 249         return true;
 250
 251     if ( !pImpl->m_xDocStorage.is() || IsReadOnly() )
 252     {
 253         // if the document still has no storage and is not set to be modified explicitly it is not modified
 254         // a readonly document is also not modified
 255
 256         return false;
 257     }
 258
 259     if (pImpl->mpObjectContainer)
 260     {
 261         uno::Sequence < OUString > aNames = GetEmbeddedObjectContainer().GetObjectNames();
 262         for ( const auto& rName : aNames )
 263         {
 264             uno::Reference < embed::XEmbeddedObject > xObj = GetEmbeddedObjectContainer().GetEmbeddedObject( rName );
 265             OSL_ENSURE( xObj.is(), "An empty entry in the embedded objects list!" );
 266             if ( xObj.is() )
 267             {
 268                 try
 269                 {
 270                     sal_Int32 nState = xObj->getCurrentState();
 271                     if ( nState != embed::EmbedStates::LOADED )
 272                     {
 273                         uno::Reference< util::XModifiable > xModifiable( xObj->getComponent(), uno::UNO_QUERY );
 274                         if ( xModifiable.is() && xModifiable->isModified() )
 275                             return true;
 276                     }
 277                 }
 278                 catch( uno::Exception& )
 279                 {}
 280             }
 281         }
 282     }
 283
 284     return false;
 285 }
 286
 287
 288 void SfxObjectShell::SetModified( bool bModifiedP )
 289 {
 290     SAL_INFO_IF( !bModifiedP && !IsEnableSetModified(), "sfx",
 291         "SFX_PERSIST: SetModified( sal_False ), although IsEnableSetModified() == sal_False" );
 292
 293     if( !IsEnableSetModified() )
 294         return;
 295
 296     if( pImpl->m_bIsModified != bModifiedP )
 297     {
 298         pImpl->m_bIsModified = bModifiedP;
 299         ModifyChanged();
 300     }
 301 }
 302
 303
 304 void SfxObjectShell::ModifyChanged()
 305 {
 306     if ( pImpl->bClosing )
 307         // SetModified dispose of the models!
 308         return;
 309
 310
 311     SfxViewFrame* pViewFrame = SfxViewFrame::Current();
 312     if ( pViewFrame )
 313         pViewFrame->GetBindings().Invalidate( SID_SAVEDOCS );
 314
 315     Invalidate( SID_SIGNATURE );
 316     Invalidate( SID_MACRO_SIGNATURE );
 317     Broadcast( SfxHint( SfxHintId::TitleChanged ) );    // xmlsec05, signed state might change in title...
 318
 319     SfxGetpApp()->NotifyEvent( SfxEventHint( SfxEventHintId::ModifyChanged, GlobalEventConfig::GetEventName(GlobalEventId::MODIFYCHANGED), this ) );
 320 }
 321
 322
 323 bool SfxObjectShell::IsReadOnlyUI() const
 324
 325 /*  [Description]
 326
 327     Returns sal_True if the document for the UI is treated as r/o. This is
 328     regardless of the actual r/o, which can be checked with <IsReadOnly()>.
 329 */
 330
 331 {
 332     return pImpl->bReadOnlyUI;
 333 }
 334
 335
 336 bool SfxObjectShell::IsReadOnlyMedium() const
 337
 338 /*  [Description]
 339
 340     Returns sal_True when the medium is r/o, for instance when opened as r/o.
 341 */
 342
 343 {
 344     if ( !pMedium )
 345         return true;
 346     return pMedium->IsReadOnly();
 347 }
 348
 349 bool SfxObjectShell::IsOriginallyReadOnlyMedium() const
 350 {
 351     return pMedium == nullptr || pMedium->IsOriginallyReadOnly();
 352 }
 353
 354 bool SfxObjectShell::IsOriginallyLoadedReadOnlyMedium() const
 355 {
 356     return pMedium != nullptr && pMedium->IsOriginallyLoadedReadOnly();
 357 }
 358
 359
 360 void SfxObjectShell::SetReadOnlyUI( bool bReadOnly )
 361
 362 /*  [Description]
 363
 364     Turns the document in an r/o and r/w state respectively without reloading
 365     it and without changing the open mode of the medium.
 366 */
 367
 368 {
 369     if ( bReadOnly != pImpl->bReadOnlyUI )
 370     {
 371         pImpl->bReadOnlyUI = bReadOnly;
 372         Broadcast( SfxHint(SfxHintId::ModeChanged) );
 373     }
 374 }
 375
 376
 377 void SfxObjectShell::SetReadOnly()
 378 {
 379     // Let the document be completely readonly, means that the
 380     // medium open mode is adjusted accordingly, and the write lock
 381     // on the file is removed.
 382
 383     if ( !pMedium || IsReadOnlyMedium() )
 384         return;
 385
 386     bool bWasROUI = IsReadOnly();
 387
 388     pMedium->UnlockFile( false );
 389
 390     // the storage-based mediums are already based on the temporary file
 391     // so UnlockFile has already closed the locking stream
 392     if ( !pMedium->HasStorage_Impl() && IsLoadingFinished() )
 393         pMedium->CloseInStream();
 394
 395     pMedium->SetOpenMode( SFX_STREAM_READONLY, true );
 396     pMedium->GetItemSet()->Put( SfxBoolItem( SID_DOC_READONLY, true ) );
 397
 398     if ( !bWasROUI )
 399         Broadcast( SfxHint(SfxHintId::ModeChanged) );
 400 }
 401
 402
 403 bool SfxObjectShell::IsReadOnly() const
 404 {
 405     return pImpl->bReadOnlyUI || pMedium == nullptr;
 406 }
 407
 408
 409 bool SfxObjectShell::IsInModalMode() const
 410 {
 411     return pImpl->bModalMode || pImpl->bRunningMacro;
 412 }
 413
 414 bool SfxObjectShell::AcceptStateUpdate() const
 415 {
 416     return !IsInModalMode();
 417 }
 418
 419
 420 void SfxObjectShell::SetMacroMode_Impl( bool bModal )
 421 {
 422     if ( !pImpl->bRunningMacro != !bModal )
 423     {
 424         pImpl->bRunningMacro = bModal;
 425         Broadcast( SfxHint( SfxHintId::ModeChanged ) );
 426     }
 427 }
 428
 429
 430 void SfxObjectShell::SetModalMode_Impl( bool bModal )
 431 {
 432     // Broadcast only if modified, or otherwise it will possibly go into
 433     // an endless loop
 434     if ( pImpl->bModalMode == bModal )
 435         return;
 436
 437     // Central count
 438     sal_uInt16 &rDocModalCount = SfxGetpApp()->Get_Impl()->nDocModalMode;
 439     if ( bModal )
 440         ++rDocModalCount;
 441     else
 442         --rDocModalCount;
 443
 444     // Switch
 445     pImpl->bModalMode = bModal;
 446     Broadcast( SfxHint( SfxHintId::ModeChanged ) );
 447 }
 448
 449 #if HAVE_FEATURE_MULTIUSER_ENVIRONMENT
 450
 451 bool SfxObjectShell::SwitchToShared( bool bShared, bool bSave )
 452 {
 453     bool bResult = true;
 454
 455     if ( bShared != IsDocShared() )
 456     {
 457         OUString aOrigURL = GetMedium()->GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE );
 458
 459         if ( aOrigURL.isEmpty() && bSave )
 460         {
 461             // this is a new document, let it be stored before switching to the shared mode;
 462             // the storing should be done without shared flag, since it is possible that the
 463             // target location does not allow to create sharing control file;
 464             // the shared flag will be set later after creation of sharing control file
 465             SfxViewFrame* pViewFrame = SfxViewFrame::GetFirst( this );
 466
 467             if ( pViewFrame )
 468             {
 469                 // TODO/LATER: currently the application guards against the reentrance problem
 470                 const SfxPoolItem* pItem = pViewFrame->GetBindings().ExecuteSynchron( HasName() ? SID_SAVEDOC : SID_SAVEASDOC );
 471                 const SfxBoolItem* pResult = dynamic_cast<const SfxBoolItem*>( pItem  );
 472                 bResult = ( pResult && pResult->GetValue() );
 473                 if ( bResult )
 474                     aOrigURL = GetMedium()->GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE );
 475             }
 476         }
 477
 478         bool bOldValue = HasSharedXMLFlagSet();
 479         SetSharedXMLFlag( bShared );
 480
 481         bool bRemoveEntryOnError = false;
 482         if ( bResult && bShared )
 483         {
 484             try
 485             {
 486                 ::svt::ShareControlFile aControlFile( aOrigURL );
 487                 aControlFile.InsertOwnEntry();
 488                 bRemoveEntryOnError = true;
 489             }
 490             catch( uno::Exception& )
 491             {
 492                 bResult = false;
 493             }
 494         }
 495
 496         if ( bResult && bSave )
 497         {
 498             SfxViewFrame* pViewFrame = SfxViewFrame::GetFirst( this );
 499
 500             if ( pViewFrame )
 501             {
 502                 // TODO/LATER: currently the application guards against the reentrance problem
 503                 SetModified(); // the modified flag has to be set to let the document be stored with the shared flag
 504                 const SfxPoolItem* pItem = pViewFrame->GetBindings().ExecuteSynchron( HasName() ? SID_SAVEDOC : SID_SAVEASDOC );
 505                 const SfxBoolItem* pResult = dynamic_cast<const SfxBoolItem*>( pItem  );
 506                 bResult = ( pResult && pResult->GetValue() );
 507             }
 508         }
 509
 510         if ( bResult )
 511         {
 512             // TODO/LATER: Is it possible that the following calls fail?
 513             if ( bShared )
 514             {
 515                 pImpl->m_aSharedFileURL = aOrigURL;
 516                 GetMedium()->SwitchDocumentToTempFile();
 517             }
 518             else
 519             {
 520                 const OUString aTempFileURL = pMedium->GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE );
 521                 GetMedium()->SwitchDocumentToFile( GetSharedFileURL() );
 522                 pImpl->m_aSharedFileURL.clear();
 523
 524                 // now remove the temporary file the document was based on
 525                 ::utl::UCBContentHelper::Kill( aTempFileURL );
 526
 527                 try
 528                 {
 529                     // aOrigURL can not be used since it contains an old value
 530                     ::svt::ShareControlFile aControlFile( GetMedium()->GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ) );
 531                     aControlFile.RemoveFile();
 532                 }
 533                 catch( uno::Exception& )
 534                 {
 535                 }
 536             }
 537         }
 538         else
 539         {
 540             // the saving has failed!
 541             if ( bRemoveEntryOnError )
 542             {
 543                 try
 544                 {
 545                     ::svt::ShareControlFile aControlFile( aOrigURL );
 546                     aControlFile.RemoveEntry();
 547                 }
 548                 catch( uno::Exception& )
 549                 {}
 550             }
 551
 552             SetSharedXMLFlag( bOldValue );
 553         }
 554     }
 555     else
 556         bResult = false; // the second switch to the same mode
 557
 558     if ( bResult )
 559         SetTitle( "" );
 560
 561     return bResult;
 562 }
 563
 564
 565 void SfxObjectShell::FreeSharedFile( const OUString& aTempFileURL )
 566 {
 567     SetSharedXMLFlag( false );
 568
 569     if ( !IsDocShared() || aTempFileURL.isEmpty()
 570       || ::utl::UCBContentHelper::EqualURLs( aTempFileURL, GetSharedFileURL() ) )
 571         return;
 572
 573     if ( pImpl->m_bAllowShareControlFileClean )
 574     {
 575         try
 576         {
 577             ::svt::ShareControlFile aControlFile( GetSharedFileURL() );
 578             aControlFile.RemoveEntry();
 579         }
 580         catch( uno::Exception& )
 581         {
 582         }
 583     }
 584
 585     // the cleaning is forbidden only once
 586     pImpl->m_bAllowShareControlFileClean = true;
 587
 588     // now remove the temporary file the document is based currently on
 589     ::utl::UCBContentHelper::Kill( aTempFileURL );
 590
 591     pImpl->m_aSharedFileURL.clear();
 592 }
 593
 594
 595 void SfxObjectShell::DoNotCleanShareControlFile()
 596 {
 597     pImpl->m_bAllowShareControlFileClean = false;
 598 }
 599
 600
 601 void SfxObjectShell::SetSharedXMLFlag( bool bFlag ) const
 602 {
 603     pImpl->m_bSharedXMLFlag = bFlag;
 604 }
 605
 606
 607 bool SfxObjectShell::HasSharedXMLFlagSet() const
 608 {
 609     return pImpl->m_bSharedXMLFlag;
 610 }
 611
 612 #endif
 613
 614 bool SfxObjectShell::IsDocShared() const
 615 {
 616 #if HAVE_FEATURE_MULTIUSER_ENVIRONMENT
 617     return ( !pImpl->m_aSharedFileURL.isEmpty() );
 618 #else
 619     return false;
 620 #endif
 621 }
 622
 623
 624 OUString SfxObjectShell::GetSharedFileURL() const
 625 {
 626 #if HAVE_FEATURE_MULTIUSER_ENVIRONMENT
 627     return pImpl->m_aSharedFileURL;
 628 #else
 629     return OUString();
 630 #endif
 631 }
 632
 633 Size SfxObjectShell::GetFirstPageSize()
 634 {
 635     return GetVisArea(ASPECT_THUMBNAIL).GetSize();
 636 }
 637
 638
 639 IndexBitSet& SfxObjectShell::GetNoSet_Impl()
 640 {
 641     return pImpl->aBitSet;
 642 }
 643
 644
 645 // changes the title of the document
 646
 647 void SfxObjectShell::SetTitle
 648 (
 649     const OUString& rTitle                // the new Document Title
 650 )
 651
 652 /*  [Description]
 653
 654     With this method, the title of the document can be set.
 655     This corresponds initially to the full file name. A setting of the
 656     title does not affect the file name, but it will be shown in the
 657     Caption-Bars of the MDI-window.
 658 */
 659
 660 {
 661
 662     // Nothing to do?
 663     if ( ( ( HasName() && pImpl->aTitle == rTitle )
 664         || ( !HasName() && GetTitle() == rTitle ) )
 665       && !IsDocShared() )
 666         return;
 667
 668     SfxApplication *pSfxApp = SfxGetpApp();
 669
 670     // If possible release the unnamed number.
 671     if ( pImpl->bIsNamedVisible && USHRT_MAX != pImpl->nVisualDocumentNumber )
 672     {
 673         pSfxApp->ReleaseIndex(pImpl->nVisualDocumentNumber);
 674         pImpl->bIsNamedVisible = false;
 675     }
 676
 677     // Set Title
 678     pImpl->aTitle = rTitle;
 679
 680     // Notification
 681     if ( GetMedium() )
 682     {
 683         SfxShell::SetName( GetTitle(SFX_TITLE_APINAME) );
 684         Broadcast( SfxHint(SfxHintId::TitleChanged) );
 685     }
 686 }
 687
 688
 689
 690 OUString SfxObjectShell::GetTitle( sal_uInt16  nMaxLength ) const
 691
 692 /*  [Description]
 693
 694     Returns the title or logical file name of the document, depending on the
 695     'nMaxLength'.
 696
 697     If the file name with path is used, the Name shortened by replacing one or
 698     more directory names with "...", URLs are currently always returned
 699     in complete form.
 700 */
 701
 702 {
 703     SfxMedium *pMed = GetMedium();
 704     if ( IsLoading() )
 705         return OUString();
 706
 707     // Create Title?
 708     if ( SFX_TITLE_DETECT == nMaxLength && pImpl->aTitle.isEmpty() )
 709     {
 710         static bool bRecur = false;
 711         if ( bRecur )
 712             return "-not available-";
 713         bRecur = true;
 714
 715         OUString aTitle;
 716
 717         if ( pMed )
 718         {
 719             const SfxStringItem* pNameItem = SfxItemSet::GetItem<SfxStringItem>(pMed->GetItemSet(), SID_DOCINFO_TITLE, false);
 720             if ( pNameItem )
 721                 aTitle = pNameItem->GetValue();
 722         }
 723
 724         if ( aTitle.isEmpty() )
 725             aTitle = GetTitle( SFX_TITLE_FILENAME );
 726
 727         bRecur = false;
 728         return aTitle;
 729     }
 730
 731     if (SFX_TITLE_APINAME == nMaxLength )
 732         return GetAPIName();
 733
 734     // Picklist/Caption is mapped
 735     if ( pMed && ( nMaxLength == SFX_TITLE_CAPTION || nMaxLength == SFX_TITLE_PICKLIST ) )
 736     {
 737         // If a specific title was given at open:
 738         // important for URLs: use INetProtocol::File for which the set title is not
 739         // considered. (See below, analysis of aTitleMap_Impl)
 740         const SfxStringItem* pNameItem = SfxItemSet::GetItem<SfxStringItem>(pMed->GetItemSet(), SID_DOCINFO_TITLE, false);
 741         if ( pNameItem )
 742             return pNameItem->GetValue();
 743     }
 744
 745     // Still unnamed?
 746     DBG_ASSERT( !HasName() || pMed, "HasName() but no Medium?!?" );
 747     if ( !HasName() || !pMed )
 748     {
 749         // Title already set?
 750         if ( !pImpl->aTitle.isEmpty() )
 751             return pImpl->aTitle;
 752
 753         // must it be numbered?
 754         const OUString aNoName(SfxResId(STR_NONAME));
 755         if (pImpl->bIsNamedVisible)
 756         {
 757             // Append number
 758             return aNoName + " " + OUString::number(pImpl->nVisualDocumentNumber);
 759         }
 760
 761         // Document called "Untitled" for the time being
 762         return aNoName;
 763     }
 764     assert(pMed);
 765
 766     const INetURLObject aURL( IsDocShared() ? GetSharedFileURL() : GetMedium()->GetName() );
 767     if ( nMaxLength > SFX_TITLE_CAPTION && nMaxLength <= SFX_TITLE_HISTORY )
 768     {
 769         sal_uInt16 nRemote;
 770         if (aURL.GetProtocol() == INetProtocol::File)
 771             nRemote = 0;
 772         else
 773             nRemote = 1;
 774         nMaxLength = aTitleMap_Impl[nMaxLength-SFX_TITLE_CAPTION][nRemote];
 775     }
 776
 777     // Local file?
 778     if ( aURL.GetProtocol() == INetProtocol::File )
 779     {
 780         if ( nMaxLength == SFX_TITLE_FULLNAME )
 781             return aURL.HasMark() ? INetURLObject( aURL.GetURLNoMark() ).PathToFileName() : aURL.PathToFileName();
 782         if ( nMaxLength == SFX_TITLE_FILENAME )
 783             return aURL.getName(INetURLObject::LAST_SEGMENT, true, INetURLObject::DecodeMechanism::WithCharset);
 784         if ( pImpl->aTitle.isEmpty() )
 785             pImpl->aTitle = aURL.getBase( INetURLObject::LAST_SEGMENT,
 786                                          true, INetURLObject::DecodeMechanism::WithCharset );
 787     }
 788     else
 789     {
 790         if ( nMaxLength >= SFX_TITLE_MAXLEN )
 791         {
 792             const OUString aComplete( aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ) );
 793             if( aComplete.getLength() > nMaxLength )
 794                 return "..." + aComplete.copy( aComplete.getLength() - nMaxLength + 3, nMaxLength - 3 );
 795             return aComplete;
 796         }
 797         if ( nMaxLength == SFX_TITLE_FILENAME )
 798         {
 799             const OUString aName = INetURLObject::decode( aURL.GetBase(), INetURLObject::DecodeMechanism::WithCharset );
 800             return aName.isEmpty() ? aURL.GetURLNoPass() : aName;
 801         }
 802         if ( nMaxLength == SFX_TITLE_FULLNAME )
 803             return aURL.GetMainURL( INetURLObject::DecodeMechanism::ToIUri );
 804
 805         // Generate Title from file name if possible
 806         if ( pImpl->aTitle.isEmpty() )
 807             pImpl->aTitle = aURL.GetBase();
 808
 809         // workaround for the case when the name can not be retrieved from URL by INetURLObject
 810         if ( pImpl->aTitle.isEmpty() )
 811             pImpl->aTitle = aURL.GetMainURL( INetURLObject::DecodeMechanism::WithCharset );
 812     }
 813
 814     // Complete Title
 815     return pImpl->aTitle;
 816 }
 817
 818
 819 void SfxObjectShell::InvalidateName()
 820
 821 /*  [Description]
 822
 823     Returns the title of the new document, DocInfo-Title or
 824     File name. Is required for loading from template or SaveAs.
 825 */
 826
 827 {
 828     pImpl->aTitle.clear();
 829     SetName( GetTitle( SFX_TITLE_APINAME ) );
 830
 831     Broadcast( SfxHint(SfxHintId::TitleChanged) );
 832 }
 833
 834
 835 void SfxObjectShell::SetNamedVisibility_Impl()
 836 {
 837     if ( !pImpl->bIsNamedVisible )
 838     {
 839         pImpl->bIsNamedVisible = true;
 840         if ( !HasName() && USHRT_MAX == pImpl->nVisualDocumentNumber && pImpl->aTitle.isEmpty() )
 841         {
 842             pImpl->nVisualDocumentNumber = SfxGetpApp()->GetFreeIndex();
 843             Broadcast( SfxHint(SfxHintId::TitleChanged) );
 844         }
 845     }
 846
 847     SetName( GetTitle(SFX_TITLE_APINAME) );
 848 }
 849
 850 void SfxObjectShell::SetNoName()
 851 {
 852     bHasName = false;
 853     GetModel()->attachResource( OUString(), GetModel()->getArgs() );
 854 }
 855
 856
 857 SfxProgress* SfxObjectShell::GetProgress() const
 858 {
 859     return pImpl->pProgress;
 860 }
 861
 862
 863 void SfxObjectShell::SetProgress_Impl
 864 (
 865     SfxProgress *pProgress      /* to started <SfxProgress> or 0,
 866                                    if the progress is to be reset */
 867 )
 868
 869 /*  [Description]
 870
 871     Internal method to set or reset the Progress modes for
 872     SfxObjectShell.
 873 */
 874
 875 {
 876     DBG_ASSERT( ( !pImpl->pProgress && pProgress ) ||
 877                 ( pImpl->pProgress && !pProgress ),
 878                 "Progress activation/deactivation mismatch" );
 879     pImpl->pProgress = pProgress;
 880 }
 881
 882
 883 void SfxObjectShell::PostActivateEvent_Impl( SfxViewFrame const * pFrame )
 884 {
 885     SfxApplication* pSfxApp = SfxGetpApp();
 886     if ( pSfxApp->IsDowning() || IsLoading() || !pFrame || pFrame->GetFrame().IsClosing_Impl() )
 887         return;
 888
 889     const SfxBoolItem* pHiddenItem = SfxItemSet::GetItem<SfxBoolItem>(pMedium->GetItemSet(), SID_HIDDEN, false);
 890     if ( !pHiddenItem || !pHiddenItem->GetValue() )
 891     {
 892         SfxEventHintId nId = pImpl->nEventId;
 893         pImpl->nEventId = SfxEventHintId::NONE;
 894         if ( nId == SfxEventHintId::OpenDoc )
 895             pSfxApp->NotifyEvent(SfxViewEventHint( nId, GlobalEventConfig::GetEventName(GlobalEventId::OPENDOC), this, pFrame->GetFrame().GetController() ), false);
 896         else if (nId == SfxEventHintId::CreateDoc )
 897             pSfxApp->NotifyEvent(SfxViewEventHint( nId, GlobalEventConfig::GetEventName(GlobalEventId::CREATEDOC), this, pFrame->GetFrame().GetController() ), false);
 898     }
 899 }
 900
 901
 902 void SfxObjectShell::SetActivateEvent_Impl(SfxEventHintId nId )
 903 {
 904     pImpl->nEventId = nId;
 905 }
 906
 907 bool SfxObjectShell::IsAutoLoadLocked() const
 908
 909 /* Returns whether an Autoload is allowed to be executed. Before the
 910    surrounding FrameSet of the AutoLoad is also taken into account as well.
 911 */
 912
 913 {
 914     return !IsReadOnly();
 915 }
 916
 917
 918 void SfxObjectShell::BreakMacroSign_Impl( bool bBreakMacroSign )
 919 {
 920     pImpl->m_bMacroSignBroken = bBreakMacroSign;
 921 }
 922
 923
 924 void SfxObjectShell::CheckSecurityOnLoading_Impl()
 925 {
 926     uno::Reference< task::XInteractionHandler > xInteraction;
 927     if ( GetMedium() )
 928         xInteraction = GetMedium()->GetInteractionHandler();
 929
 930     // check if there is a broken signature...
 931     CheckForBrokenDocSignatures_Impl();
 932
 933     CheckEncryption_Impl( xInteraction );
 934
 935     // check macro security
 936     pImpl->aMacroMode.checkMacrosOnLoading( xInteraction );
 937 }
 938
 939
 940 void SfxObjectShell::CheckEncryption_Impl( const uno::Reference< task::XInteractionHandler >& xHandler )
 941 {
 942     OUString aVersion;
 943     bool bIsEncrypted = false;
 944     bool bHasNonEncrypted = false;
 945
 946     try
 947     {
 948         uno::Reference < beans::XPropertySet > xPropSet( GetStorage(), uno::UNO_QUERY_THROW );
 949         xPropSet->getPropertyValue("Version") >>= aVersion;
 950         xPropSet->getPropertyValue("HasEncryptedEntries") >>= bIsEncrypted;
 951         xPropSet->getPropertyValue("HasNonEncryptedEntries") >>= bHasNonEncrypted;
 952     }
 953     catch( uno::Exception& )
 954     {
 955     }
 956
 957     if ( aVersion.compareTo( ODFVER_012_TEXT ) < 0 )
 958         return;
 959
 960     // this is ODF1.2 or later
 961     if ( !(bIsEncrypted && bHasNonEncrypted) )
 962         return;
 963
 964     if ( !pImpl->m_bIncomplEncrWarnShown )
 965     {
 966         // this is an encrypted document with nonencrypted streams inside, show the warning
 967         css::task::ErrorCodeRequest aErrorCode;
 968         aErrorCode.ErrCode = sal_uInt32(ERRCODE_SFX_INCOMPLETE_ENCRYPTION);
 969
 970         SfxMedium::CallApproveHandler( xHandler, uno::makeAny( aErrorCode ), false );
 971         pImpl->m_bIncomplEncrWarnShown = true;
 972     }
 973
 974     // broken signatures imply no macro execution at all
 975     pImpl->aMacroMode.disallowMacroExecution();
 976 }
 977
 978
 979 void SfxObjectShell::CheckForBrokenDocSignatures_Impl()
 980 {
 981     SignatureState nSignatureState = GetDocumentSignatureState();
 982     bool bSignatureBroken = ( nSignatureState == SignatureState::BROKEN );
 983     if ( !bSignatureBroken )
 984         return;
 985
 986     // broken signatures imply no macro execution at all
 987     pImpl->aMacroMode.disallowMacroExecution();
 988 }
 989
 990
 991 void SfxObjectShell::SetAutoLoad(
 992     const INetURLObject& rUrl, sal_uInt32 nTime, bool bReload )
 993 {
 994     pImpl->pReloadTimer.reset();
 995     if ( bReload )
 996     {
 997         pImpl->pReloadTimer.reset(new AutoReloadTimer_Impl(
 998                                 rUrl.GetMainURL( INetURLObject::DecodeMechanism::ToIUri ),
 999                                 nTime, this ));
1000         pImpl->pReloadTimer->Start();
1001     }
1002 }
1003
1004 void SfxObjectShell::SetLoading(SfxLoadedFlags nFlags)
1005 {
1006     pImpl->nLoadedFlags = nFlags;
1007 }
1008
1009 bool SfxObjectShell::IsLoadingFinished() const
1010 {
1011     return ( pImpl->nLoadedFlags == SfxLoadedFlags::ALL );
1012 }
1013
1014 void SfxObjectShell::InitOwnModel_Impl()
1015 {
1016     if ( pImpl->bModelInitialized )
1017         return;
1018
1019     const SfxStringItem* pSalvageItem = SfxItemSet::GetItem<SfxStringItem>(pMedium->GetItemSet(), SID_DOC_SALVAGE, false);
1020     if ( pSalvageItem )
1021     {
1022         pImpl->aTempName = pMedium->GetPhysicalName();
1023         pMedium->GetItemSet()->ClearItem( SID_DOC_SALVAGE );
1024         pMedium->GetItemSet()->ClearItem( SID_FILE_NAME );
1025         pMedium->GetItemSet()->Put( SfxStringItem( SID_FILE_NAME, pMedium->GetOrigURL() ) );
1026     }
1027     else
1028     {
1029         pMedium->GetItemSet()->ClearItem( SID_PROGRESS_STATUSBAR_CONTROL );
1030         pMedium->GetItemSet()->ClearItem( SID_DOCUMENT );
1031     }
1032
1033     pMedium->GetItemSet()->ClearItem( SID_REFERER );
1034     uno::Reference< frame::XModel >  xModel = GetModel();
1035     if ( xModel.is() )
1036     {
1037         SfxItemSet *pSet = GetMedium()->GetItemSet();
1038         if ( !GetMedium()->IsReadOnly() )
1039             pSet->ClearItem( SID_INPUTSTREAM );
1040         uno::Sequence< beans::PropertyValue > aArgs;
1041         TransformItems( SID_OPENDOC, *pSet, aArgs );
1042         xModel->attachResource( GetMedium()->GetOrigURL(), aArgs );
1043         impl_addToModelCollection(xModel);
1044     }
1045
1046     pImpl->bModelInitialized = true;
1047 }
1048
1049 void SfxObjectShell::FinishedLoading( SfxLoadedFlags nFlags )
1050 {
1051     std::shared_ptr<const SfxFilter> pFlt = pMedium->GetFilter();
1052     if( pFlt )
1053     {
1054         SetFormatSpecificCompatibilityOptions( pFlt->GetTypeName() );
1055     }
1056
1057     bool bSetModifiedTRUE = false;
1058     const SfxStringItem* pSalvageItem = SfxItemSet::GetItem<SfxStringItem>(pMedium->GetItemSet(), SID_DOC_SALVAGE, false);
1059     if( ( nFlags & SfxLoadedFlags::MAINDOCUMENT ) && !(pImpl->nLoadedFlags & SfxLoadedFlags::MAINDOCUMENT )
1060         && !(pImpl->nFlagsInProgress & SfxLoadedFlags::MAINDOCUMENT ))
1061     {
1062         pImpl->nFlagsInProgress |= SfxLoadedFlags::MAINDOCUMENT;
1063         static_cast<SfxHeaderAttributes_Impl*>(GetHeaderAttributes())->SetAttributes();
1064
1065         if ( ( GetModifyPasswordHash() || GetModifyPasswordInfo().hasElements() ) && !IsModifyPasswordEntered() )
1066             SetReadOnly();
1067
1068         // Salvage
1069         if ( pSalvageItem )
1070             bSetModifiedTRUE = true;
1071
1072         if ( !IsEnableSetModified() )
1073             EnableSetModified();
1074
1075         if( !bSetModifiedTRUE && IsEnableSetModified() )
1076             SetModified( false );
1077
1078         CheckSecurityOnLoading_Impl();
1079
1080         bHasName = true; // the document is loaded, so the name should already available
1081         GetTitle( SFX_TITLE_DETECT );
1082         InitOwnModel_Impl();
1083         pImpl->nFlagsInProgress &= ~SfxLoadedFlags::MAINDOCUMENT;
1084     }
1085
1086     if( ( nFlags & SfxLoadedFlags::IMAGES ) && !(pImpl->nLoadedFlags & SfxLoadedFlags::IMAGES )
1087         && !(pImpl->nFlagsInProgress & SfxLoadedFlags::IMAGES ))
1088     {
1089         pImpl->nFlagsInProgress |= SfxLoadedFlags::IMAGES;
1090         uno::Reference<document::XDocumentProperties> xDocProps(
1091             getDocProperties());
1092         const OUString url(xDocProps->getAutoloadURL());
1093         sal_Int32 delay(xDocProps->getAutoloadSecs());
1094         SetAutoLoad( INetURLObject(url), delay * 1000,
1095                      (delay > 0) || !url.isEmpty() );
1096         if( !bSetModifiedTRUE && IsEnableSetModified() )
1097             SetModified( false );
1098         Invalidate( SID_SAVEASDOC );
1099         pImpl->nFlagsInProgress &= ~SfxLoadedFlags::IMAGES;
1100     }
1101
1102     pImpl->nLoadedFlags |= nFlags;
1103
1104     if ( pImpl->nFlagsInProgress != SfxLoadedFlags::NONE )
1105         return;
1106
1107     // in case of reentrance calls the first called FinishedLoading() call on the stack
1108     // should do the notification, in result the notification is done when all the FinishedLoading() calls are finished
1109
1110     if ( bSetModifiedTRUE )
1111         SetModified();
1112     else
1113         SetModified( false );
1114
1115     if ( (pImpl->nLoadedFlags & SfxLoadedFlags::MAINDOCUMENT ) && (pImpl->nLoadedFlags & SfxLoadedFlags::IMAGES ) )
1116     {
1117         const SfxBoolItem* pTemplateItem = SfxItemSet::GetItem<SfxBoolItem>(pMedium->GetItemSet(), SID_TEMPLATE, false);
1118         bool bTemplate = pTemplateItem && pTemplateItem->GetValue();
1119
1120         // closing the streams on loading should be under control of SFX!
1121         DBG_ASSERT( pMedium->IsOpen(), "Don't close the medium when loading documents!" );
1122
1123         if ( bTemplate )
1124         {
1125             TemplateDisconnectionAfterLoad();
1126         }
1127         else
1128         {
1129             // if a readonly medium has storage then it's stream is already based on temporary file
1130             if( !(pMedium->GetOpenMode() & StreamMode::WRITE) && !pMedium->HasStorage_Impl() )
1131                 // don't lock file opened read only
1132                 pMedium->CloseInStream();
1133         }
1134     }
1135
1136     SetInitialized_Impl( false );
1137
1138     // Title is not available until loading has finished
1139     Broadcast( SfxHint( SfxHintId::TitleChanged ) );
1140     if ( pImpl->nEventId != SfxEventHintId::NONE )
1141         PostActivateEvent_Impl(SfxViewFrame::GetFirst(this));
1142 }
1143
1144 void SfxObjectShell::TemplateDisconnectionAfterLoad()
1145 {
1146     // document is created from a template
1147     //TODO/LATER: should the templates always be XML docs!
1148
1149     SfxMedium* pTmpMedium = pMedium;
1150     if ( !pTmpMedium )
1151         return;
1152
1153     const OUString aName( pTmpMedium->GetName() );
1154     const SfxStringItem* pTemplNamItem = SfxItemSet::GetItem<SfxStringItem>(pTmpMedium->GetItemSet(), SID_TEMPLATE_NAME, false);
1155     OUString aTemplateName;
1156     if ( pTemplNamItem )
1157         aTemplateName = pTemplNamItem->GetValue();
1158     else
1159     {
1160         // !TODO/LATER: what's this?!
1161         // Interactive ( DClick, Contextmenu ) no long name is included
1162         aTemplateName = getDocProperties()->getTitle();
1163         if ( aTemplateName.isEmpty() )
1164         {
1165             INetURLObject aURL( aName );
1166             aURL.CutExtension();
1167             aTemplateName = aURL.getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DecodeMechanism::WithCharset );
1168         }
1169     }
1170
1171     // set medium to noname
1172     pTmpMedium->SetName( OUString(), true );
1173     pTmpMedium->Init_Impl();
1174
1175     // drop resource
1176     SetNoName();
1177     InvalidateName();
1178
1179     if( IsPackageStorageFormat_Impl( *pTmpMedium ) )
1180     {
1181         // untitled document must be based on temporary storage
1182         // the medium should not dispose the storage in this case
1183         uno::Reference < embed::XStorage > xTmpStor = ::comphelper::OStorageHelper::GetTemporaryStorage();
1184         GetStorage()->copyToStorage( xTmpStor );
1185
1186         // the medium should disconnect from the original location
1187         // the storage should not be disposed since the document is still
1188         // based on it, but in DoSaveCompleted it will be disposed
1189         pTmpMedium->CanDisposeStorage_Impl( false );
1190         pTmpMedium->Close();
1191
1192         // setting the new storage the medium will be based on
1193         pTmpMedium->SetStorage_Impl( xTmpStor );
1194
1195         pMedium = nullptr;
1196         bool ok = DoSaveCompleted( pTmpMedium );
1197         assert(pMedium != nullptr);
1198         if( ok )
1199         {
1200             const SfxStringItem* pSalvageItem = SfxItemSet::GetItem<SfxStringItem>(pMedium->GetItemSet(), SID_DOC_SALVAGE, false);
1201             bool bSalvage = pSalvageItem != nullptr;
1202
1203             if ( !bSalvage )
1204             {
1205                 // some further initializations for templates
1206                 SetTemplate_Impl( aName, aTemplateName, this );
1207             }
1208
1209             // the medium should not dispose the storage, DoSaveCompleted() has let it to do so
1210             pTmpMedium->CanDisposeStorage_Impl( false );
1211         }
1212         else
1213         {
1214             SetError(ERRCODE_IO_GENERAL);
1215         }
1216     }
1217     else
1218     {
1219         // some further initializations for templates
1220         SetTemplate_Impl( aName, aTemplateName, this );
1221         pTmpMedium->CreateTempFile();
1222     }
1223
1224     // templates are never readonly
1225     pTmpMedium->GetItemSet()->ClearItem( SID_DOC_READONLY );
1226     pTmpMedium->SetOpenMode( SFX_STREAM_READWRITE, true );
1227
1228     // notifications about possible changes in readonly state and document info
1229     Broadcast( SfxHint(SfxHintId::ModeChanged) );
1230
1231     // created untitled document can't be modified
1232     SetModified( false );
1233 }
1234
1235
1236 bool SfxObjectShell::IsLoading() const
1237 /*  [Description]
1238
1239     Has FinishedLoading been called?
1240 */
1241 {
1242     return !( pImpl->nLoadedFlags & SfxLoadedFlags::MAINDOCUMENT );
1243 }
1244
1245
1246 void SfxObjectShell::CancelTransfers()
1247 /*  [Description]
1248
1249     Here can Transfers get canceled, which were not registered
1250     by RegisterTransfer.
1251 */
1252 {
1253     if( ( pImpl->nLoadedFlags & SfxLoadedFlags::ALL ) != SfxLoadedFlags::ALL )
1254     {
1255         pImpl->bIsAbortingImport = true;
1256         if( IsLoading() )
1257             FinishedLoading();
1258     }
1259 }
1260
1261
1262 AutoReloadTimer_Impl::AutoReloadTimer_Impl(
1263     const OUString& rURL, sal_uInt32 nTime, SfxObjectShell* pSh )
1264     : aUrl( rURL ), pObjSh( pSh )
1265 {
1266     SetTimeout( nTime );
1267 }
1268
1269
1270 void AutoReloadTimer_Impl::Invoke()
1271 {
1272     SfxViewFrame *pFrame = SfxViewFrame::GetFirst( pObjSh );
1273
1274     if ( pFrame )
1275     {
1276         // Not possible/meaningful at the moment?
1277         if ( !pObjSh->CanReload_Impl() || pObjSh->IsAutoLoadLocked() || Application::IsUICaptured() )
1278         {
1279             // Allow a retry
1280             Start();
1281             return;
1282         }
1283
1284         SfxAllItemSet aSet( SfxGetpApp()->GetPool() );
1285         aSet.Put( SfxBoolItem( SID_AUTOLOAD, true ) );
1286         if ( !aUrl.isEmpty() )
1287             aSet.Put(  SfxStringItem( SID_FILE_NAME, aUrl ) );
1288         if (pObjSh->HasName()) {
1289             aSet.Put(
1290                 SfxStringItem(SID_REFERER, pObjSh->GetMedium()->GetName()));
1291         }
1292         SfxRequest aReq( SID_RELOAD, SfxCallMode::SLOT, aSet );
1293         // this will delete this
1294         pObjSh->Get_Impl()->pReloadTimer.reset();
1295         pFrame->ExecReload_Impl( aReq );
1296         return;
1297     }
1298
1299     // this will delete this
1300     pObjSh->Get_Impl()->pReloadTimer.reset();
1301 }
1302
1303 SfxModule* SfxObjectShell::GetModule() const
1304 {
1305     return GetFactory().GetModule();
1306 }
1307
1308 ErrCode SfxObjectShell::CallBasic( const OUString& rMacro,
1309     const OUString& rBasic, SbxArray* pArgs,
1310     SbxValue* pRet )
1311 {
1312     SfxApplication* pApp = SfxGetpApp();
1313     if( pApp->GetName() != rBasic )
1314     {
1315         if ( !AdjustMacroMode() )
1316             return ERRCODE_IO_ACCESSDENIED;
1317     }
1318
1319     BasicManager *pMgr = GetBasicManager();
1320     if( pApp->GetName() == rBasic )
1321         pMgr = SfxApplication::GetBasicManager();
1322     ErrCode nRet = SfxApplication::CallBasic( rMacro, pMgr, pArgs, pRet );
1323     return nRet;
1324 }
1325
1326 namespace
1327 {
1328     bool lcl_isScriptAccessAllowed_nothrow( const Reference< XInterface >& _rxScriptContext )
1329     {
1330         try
1331         {
1332             Reference< XEmbeddedScripts > xScripts( _rxScriptContext, UNO_QUERY );
1333             if ( !xScripts.is() )
1334             {
1335                 Reference< XScriptInvocationContext > xContext( _rxScriptContext, UNO_QUERY_THROW );
1336                 xScripts.set( xContext->getScriptContainer(), UNO_SET_THROW );
1337             }
1338
1339             return xScripts->getAllowMacroExecution();
1340         }
1341         catch( const Exception& )
1342         {
1343             DBG_UNHANDLED_EXCEPTION("sfx.doc");
1344         }
1345         return false;
1346     }
1347 }
1348
1349 // don't allow LibreLogo to be used with our mouseover/etc dom-alike events
1350 bool SfxObjectShell::UnTrustedScript(const OUString& rScriptURL)
1351 {
1352     if (!rScriptURL.startsWith("vnd.sun.star.script:"))
1353         return false;
1354
1355     // ensure URL Escape Codes are decoded
1356     css::uno::Reference<css::uri::XUriReference> uri(
1357         css::uri::UriReferenceFactory::create(comphelper::getProcessComponentContext())->parse(rScriptURL));
1358     css::uno::Reference<css::uri::XVndSunStarScriptUrl> sfUri(uri, css::uno::UNO_QUERY);
1359
1360     if (!sfUri.is())
1361         return false;
1362
1363     // pyuno encodes path separator as |
1364     OUString sScript = sfUri->getName().replace('|', '/');
1365
1366     // check if any path portion matches LibreLogo and ban it if it does
1367     sal_Int32 nIndex = 0;
1368     do
1369     {
1370         OUString aToken = sScript.getToken(0, '/', nIndex);
1371         if (aToken.startsWithIgnoreAsciiCase("LibreLogo"))
1372         {
1373             return true;
1374         }
1375     }
1376     while (nIndex >= 0);
1377
1378     return false;
1379 }
1380
1381 ErrCode SfxObjectShell::CallXScript( const Reference< XInterface >& _rxScriptContext, const OUString& _rScriptURL,
1382     const Sequence< Any >& aParams, Any& aRet, Sequence< sal_Int16 >& aOutParamIndex, Sequence< Any >& aOutParam, bool bRaiseError, const css::uno::Any* pCaller )
1383 {
1384     SAL_INFO("sfx", "in CallXScript" );
1385     ErrCode nErr = ERRCODE_NONE;
1386
1387     bool bCaughtException = false;
1388     Any aException;
1389     try
1390     {
1391         if ( !lcl_isScriptAccessAllowed_nothrow( _rxScriptContext ) )
1392             return ERRCODE_IO_ACCESSDENIED;
1393
1394         if ( UnTrustedScript(_rScriptURL) )
1395             return ERRCODE_IO_ACCESSDENIED;
1396
1397         // obtain/create a script provider
1398         Reference< provider::XScriptProvider > xScriptProvider;
1399         Reference< provider::XScriptProviderSupplier > xSPS( _rxScriptContext, UNO_QUERY );
1400         if ( xSPS.is() )
1401             xScriptProvider.set( xSPS->getScriptProvider() );
1402
1403         if ( !xScriptProvider.is() )
1404         {
1405             Reference< provider::XScriptProviderFactory > xScriptProviderFactory =
1406                 provider::theMasterScriptProviderFactory::get( ::comphelper::getProcessComponentContext() );
1407             xScriptProvider.set( xScriptProviderFactory->createScriptProvider( makeAny( _rxScriptContext ) ), UNO_SET_THROW );
1408         }
1409
1410         // ry to protect the invocation context's undo manager (if present), just in case the script tampers with it
1411         ::framework::DocumentUndoGuard aUndoGuard( _rxScriptContext.get() );
1412
1413         // obtain the script, and execute it
1414         Reference< provider::XScript > xScript( xScriptProvider->getScript( _rScriptURL ), UNO_SET_THROW );
1415         if ( pCaller && pCaller->hasValue() )
1416         {
1417             Reference< beans::XPropertySet > xProps( xScript, uno::UNO_QUERY );
1418             if ( xProps.is() )
1419             {
1420                 Sequence< uno::Any > aArgs( 1 );
1421                 aArgs[ 0 ] = *pCaller;
1422                 xProps->setPropertyValue("Caller", uno::makeAny( aArgs ) );
1423             }
1424         }
1425         aRet = xScript->invoke( aParams, aOutParamIndex, aOutParam );
1426     }
1427     catch ( const uno::Exception& )
1428     {
1429         aException = ::cppu::getCaughtException();
1430         bCaughtException = true;
1431         nErr = ERRCODE_BASIC_INTERNAL_ERROR;
1432     }
1433
1434     if ( bCaughtException && bRaiseError )
1435     {
1436         SfxAbstractDialogFactory* pFact = SfxAbstractDialogFactory::Create();
1437         ScopedVclPtr<VclAbstractDialog> pScriptErrDlg( pFact->CreateScriptErrorDialog( aException ) );
1438         if ( pScriptErrDlg.get() )
1439             pScriptErrDlg->Execute();
1440     }
1441
1442     SAL_INFO("sfx", "leaving CallXScript" );
1443     return nErr;
1444 }
1445
1446 // perhaps rename to CallScript once we get rid of the existing CallScript
1447 // and Call, CallBasic, CallStarBasic methods
1448 ErrCode SfxObjectShell::CallXScript( const OUString& rScriptURL,
1449         const css::uno::Sequence< css::uno::Any >& aParams,
1450         css::uno::Any& aRet,
1451         css::uno::Sequence< sal_Int16 >& aOutParamIndex,
1452         css::uno::Sequence< css::uno::Any >& aOutParam,
1453         bool bRaiseError,
1454         const css::uno::Any* pCaller )
1455 {
1456     return CallXScript( GetModel(), rScriptURL, aParams, aRet, aOutParamIndex, aOutParam, bRaiseError, pCaller );
1457 }
1458
1459 void SfxHeaderAttributes_Impl::SetAttributes()
1460 {
1461     bAlert = true;
1462     SvKeyValue aPair;
1463     for( bool bCont = xIter->GetFirst( aPair ); bCont;
1464          bCont = xIter->GetNext( aPair ) )
1465         SetAttribute( aPair );
1466 }
1467
1468 void SfxHeaderAttributes_Impl::SetAttribute( const SvKeyValue& rKV )
1469 {
1470     const OUString& aValue = rKV.GetValue();
1471     if( rKV.GetKey().equalsIgnoreAsciiCase("refresh") && !rKV.GetValue().isEmpty() )
1472     {
1473         sal_Int32 nIdx{ 0 };
1474         const sal_Int32 nTime{ aValue.getToken( 0, ';', nIdx ).toInt32() };
1475         const OUString aURL{ comphelper::string::strip(aValue.getToken( 0, ';', nIdx ), ' ') };
1476         uno::Reference<document::XDocumentProperties> xDocProps(
1477             pDoc->getDocProperties());
1478         if( aURL.startsWithIgnoreAsciiCase( "url=" ) )
1479         {
1480             INetURLObject aObj;
1481             INetURLObject( pDoc->GetMedium()->GetName() ).GetNewAbsURL( aURL.copy( 4 ), &aObj );
1482             xDocProps->setAutoloadURL(
1483                 aObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ) );
1484         }
1485         try
1486         {
1487             xDocProps->setAutoloadSecs( nTime );
1488         }
1489         catch (lang::IllegalArgumentException &)
1490         {
1491             // ignore
1492         }
1493     }
1494     else if( rKV.GetKey().equalsIgnoreAsciiCase( "expires" ) )
1495     {
1496         DateTime aDateTime( DateTime::EMPTY );
1497         if( INetMIMEMessage::ParseDateField( rKV.GetValue(), aDateTime ) )
1498         {
1499             aDateTime.ConvertToLocalTime();
1500             pDoc->GetMedium()->SetExpired_Impl( aDateTime );
1501         }
1502         else
1503         {
1504             pDoc->GetMedium()->SetExpired_Impl( Date( 1, 1, 1970 ) );
1505         }
1506     }
1507 }
1508
1509 void SfxHeaderAttributes_Impl::Append( const SvKeyValue& rKV )
1510 {
1511     xIter->Append( rKV );
1512     if( bAlert ) SetAttribute( rKV );
1513 }
1514
1515 SvKeyValueIterator* SfxObjectShell::GetHeaderAttributes()
1516 {
1517     if( !pImpl->xHeaderAttributes.is() )
1518     {
1519         DBG_ASSERT( pMedium, "No Medium" );
1520         pImpl->xHeaderAttributes = new SfxHeaderAttributes_Impl( this );
1521     }
1522     return static_cast<SvKeyValueIterator*>( pImpl->xHeaderAttributes.get() );
1523 }
1524
1525 void SfxObjectShell::ClearHeaderAttributesForSourceViewHack()
1526 {
1527     static_cast<SfxHeaderAttributes_Impl*>(GetHeaderAttributes())
1528         ->ClearForSourceView();
1529 }
1530
1531
1532 void SfxObjectShell::SetHeaderAttributesForSourceViewHack()
1533 {
1534     static_cast<SfxHeaderAttributes_Impl*>(GetHeaderAttributes())
1535         ->SetAttributes();
1536 }
1537
1538 bool SfxObjectShell::IsPreview() const
1539 {
1540     if ( !pMedium )
1541         return false;
1542
1543     bool bPreview = false;
1544     const SfxStringItem* pFlags = SfxItemSet::GetItem<SfxStringItem>(pMedium->GetItemSet(), SID_OPTIONS, false);
1545     if ( pFlags )
1546     {
1547         // Distributed values among individual items
1548         const OUString aFileFlags = pFlags->GetValue().toAsciiUpperCase();
1549         if ( -1 != aFileFlags.indexOf( 'B' ) )
1550             bPreview = true;
1551     }
1552
1553     if ( !bPreview )
1554     {
1555         const SfxBoolItem* pItem = SfxItemSet::GetItem<SfxBoolItem>(pMedium->GetItemSet(), SID_PREVIEW, false);
1556         if ( pItem )
1557             bPreview = pItem->GetValue();
1558     }
1559
1560     return bPreview;
1561 }
1562
1563 void SfxObjectShell::SetWaitCursor( bool bSet ) const
1564 {
1565     for( SfxViewFrame* pFrame = SfxViewFrame::GetFirst( this ); pFrame; pFrame = SfxViewFrame::GetNext( *pFrame, this ) )
1566     {
1567         if ( bSet )
1568             pFrame->GetFrame().GetWindow().EnterWait();
1569         else
1570             pFrame->GetFrame().GetWindow().LeaveWait();
1571     }
1572 }
1573
1574 OUString SfxObjectShell::GetAPIName() const
1575 {
1576     INetURLObject aURL( IsDocShared() ? GetSharedFileURL() : GetMedium()->GetName() );
1577     OUString aName( aURL.GetBase() );
1578     if( aName.isEmpty() )
1579         aName = aURL.GetURLNoPass();
1580     if ( aName.isEmpty() )
1581         aName = GetTitle( SFX_TITLE_DETECT );
1582     return aName;
1583 }
1584
1585 void SfxObjectShell::Invalidate( sal_uInt16 nId )
1586 {
1587     for( SfxViewFrame* pFrame = SfxViewFrame::GetFirst( this ); pFrame; pFrame = SfxViewFrame::GetNext( *pFrame, this ) )
1588         Invalidate_Impl( pFrame->GetBindings(), nId );
1589 }
1590
1591 bool SfxObjectShell::AdjustMacroMode()
1592 {
1593     uno::Reference< task::XInteractionHandler > xInteraction;
1594     if ( pMedium )
1595         xInteraction = pMedium->GetInteractionHandler();
1596
1597     CheckForBrokenDocSignatures_Impl();
1598
1599     CheckEncryption_Impl( xInteraction );
1600
1601     return pImpl->aMacroMode.adjustMacroMode( xInteraction );
1602 }
1603
1604 vcl::Window* SfxObjectShell::GetDialogParent( SfxMedium const * pLoadingMedium )
1605 {
1606     VclPtr<vcl::Window> pWindow;
1607     SfxItemSet* pSet = pLoadingMedium ? pLoadingMedium->GetItemSet() : GetMedium()->GetItemSet();
1608     const SfxUnoFrameItem* pUnoItem = SfxItemSet::GetItem<SfxUnoFrameItem>(pSet, SID_FILLFRAME, false);
1609     if ( pUnoItem )
1610     {
1611         const uno::Reference < frame::XFrame >& xFrame( pUnoItem->GetFrame() );
1612         pWindow = VCLUnoHelper::GetWindow( xFrame->getContainerWindow() );
1613     }
1614
1615     if ( !pWindow )
1616     {
1617         SfxFrame* pFrame = nullptr;
1618         const SfxFrameItem* pFrameItem = SfxItemSet::GetItem<SfxFrameItem>(pSet, SID_DOCFRAME, false);
1619         if( pFrameItem && pFrameItem->GetFrame() )
1620             // get target frame from ItemSet
1621             pFrame = pFrameItem->GetFrame();
1622         else
1623         {
1624             // try the current frame
1625             SfxViewFrame* pView = SfxViewFrame::Current();
1626             if ( !pView || pView->GetObjectShell() != this )
1627                 // get any visible frame
1628                 pView = SfxViewFrame::GetFirst(this);
1629             if ( pView )
1630                 pFrame = &pView->GetFrame();
1631         }
1632
1633         if ( pFrame )
1634             // get topmost window
1635             pWindow = VCLUnoHelper::GetWindow( pFrame->GetFrameInterface()->getContainerWindow() );
1636     }
1637
1638     if ( pWindow )
1639     {
1640         // this frame may be invisible, show it if it is allowed
1641         const SfxBoolItem* pHiddenItem = SfxItemSet::GetItem<SfxBoolItem>(pSet, SID_HIDDEN, false);
1642         if ( !pHiddenItem || !pHiddenItem->GetValue() )
1643         {
1644             pWindow->Show();
1645             pWindow->ToTop();
1646         }
1647     }
1648
1649     return pWindow;
1650 }
1651
1652 void SfxObjectShell::SetCreateMode_Impl( SfxObjectCreateMode nMode )
1653 {
1654     eCreateMode = nMode;
1655 }
1656
1657 bool SfxObjectShell::IsInPlaceActive()
1658 {
1659     if ( eCreateMode != SfxObjectCreateMode::EMBEDDED )
1660         return false;
1661
1662     SfxViewFrame* pFrame = SfxViewFrame::GetFirst( this );
1663     return pFrame && pFrame->GetFrame().IsInPlace();
1664 }
1665
1666 bool SfxObjectShell::IsUIActive()
1667 {
1668     if ( eCreateMode != SfxObjectCreateMode::EMBEDDED )
1669         return false;
1670
1671     SfxViewFrame* pFrame = SfxViewFrame::GetFirst( this );
1672     return pFrame && pFrame->GetFrame().IsInPlace() && pFrame->GetFrame().GetWorkWindow_Impl()->IsVisible_Impl();
1673 }
1674
1675 bool SfxObjectShell::UseInteractionToHandleError(
1676                     const uno::Reference< task::XInteractionHandler >& xHandler,
1677                     ErrCode nError )
1678 {
1679     bool bResult = false;
1680
1681     if ( xHandler.is() )
1682     {
1683         try
1684         {
1685             uno::Any aInteraction;
1686             uno::Sequence< uno::Reference< task::XInteractionContinuation > > lContinuations(2);
1687             ::comphelper::OInteractionAbort* pAbort = new ::comphelper::OInteractionAbort();
1688             ::comphelper::OInteractionApprove* pApprove = new ::comphelper::OInteractionApprove();
1689             lContinuations[0].set( static_cast< task::XInteractionContinuation* >( pAbort ), uno::UNO_QUERY );
1690             lContinuations[1].set( static_cast< task::XInteractionContinuation* >( pApprove ), uno::UNO_QUERY );
1691
1692             task::ErrorCodeRequest aErrorCode;
1693             aErrorCode.ErrCode = sal_uInt32(nError);
1694             aInteraction <<= aErrorCode;
1695             xHandler->handle(::framework::InteractionRequest::CreateRequest (aInteraction,lContinuations));
1696             bResult = pAbort->wasSelected();
1697         }
1698         catch( uno::Exception& )
1699         {}
1700     }
1701
1702     return bResult;
1703 }
1704
1705 sal_Int16 SfxObjectShell_Impl::getCurrentMacroExecMode() const
1706 {
1707     sal_Int16 nImposedExecMode( MacroExecMode::NEVER_EXECUTE );
1708
1709     const SfxMedium* pMedium( rDocShell.GetMedium() );
1710     OSL_PRECOND( pMedium, "SfxObjectShell_Impl::getCurrentMacroExecMode: no medium!" );
1711     if ( pMedium )
1712     {
1713         const SfxUInt16Item* pMacroModeItem = SfxItemSet::GetItem<SfxUInt16Item>(pMedium->GetItemSet(), SID_MACROEXECMODE, false);
1714         if ( pMacroModeItem )
1715             nImposedExecMode = pMacroModeItem->GetValue();
1716     }
1717     return nImposedExecMode;
1718 }
1719
1720 void SfxObjectShell_Impl::setCurrentMacroExecMode( sal_uInt16 nMacroMode )
1721 {
1722     const SfxMedium* pMedium( rDocShell.GetMedium() );
1723     OSL_PRECOND( pMedium, "SfxObjectShell_Impl::getCurrentMacroExecMode: no medium!" );
1724     if ( pMedium )
1725     {
1726         pMedium->GetItemSet()->Put( SfxUInt16Item( SID_MACROEXECMODE, nMacroMode ) );
1727     }
1728 }
1729
1730 OUString SfxObjectShell_Impl::getDocumentLocation() const
1731 {
1732     OUString sLocation;
1733
1734     const SfxMedium* pMedium( rDocShell.GetMedium() );
1735     OSL_PRECOND( pMedium, "SfxObjectShell_Impl::getDocumentLocation: no medium!" );
1736     if ( pMedium )
1737     {
1738         sLocation = pMedium->GetName();
1739         if ( sLocation.isEmpty() )
1740         {
1741             // for documents made from a template: get the name of the template
1742             sLocation = rDocShell.getDocProperties()->getTemplateURL();
1743         }
1744     }
1745     return sLocation;
1746 }
1747
1748 bool SfxObjectShell_Impl::documentStorageHasMacros() const
1749 {
1750     return ::sfx2::DocumentMacroMode::storageHasMacros( m_xDocStorage );
1751 }
1752
1753 bool SfxObjectShell_Impl::macroCallsSeenWhileLoading() const
1754 {
1755     return rDocShell.GetMacroCallsSeenWhileLoading();
1756 }
1757
1758 Reference< XEmbeddedScripts > SfxObjectShell_Impl::getEmbeddedDocumentScripts() const
1759 {
1760     return Reference< XEmbeddedScripts >( rDocShell.GetModel(), UNO_QUERY );
1761 }
1762
1763 SignatureState SfxObjectShell_Impl::getScriptingSignatureState()
1764 {
1765     SignatureState nSignatureState( rDocShell.GetScriptingSignatureState() );
1766
1767     if ( nSignatureState != SignatureState::NOSIGNATURES && m_bMacroSignBroken )
1768     {
1769         // if there is a macro signature it must be handled as broken
1770         nSignatureState = SignatureState::BROKEN;
1771     }
1772
1773     return nSignatureState;
1774 }
1775
1776 bool SfxObjectShell_Impl::hasTrustedScriptingSignature( bool bAllowUIToAddAuthor )
1777 {
1778     bool bResult = false;
1779
1780     try
1781     {
1782         OUString aVersion;
1783         try
1784         {
1785             uno::Reference < beans::XPropertySet > xPropSet( rDocShell.GetStorage(), uno::UNO_QUERY_THROW );
1786             xPropSet->getPropertyValue("Version") >>= aVersion;
1787         }
1788         catch( uno::Exception& )
1789         {
1790         }
1791
1792         uno::Reference< security::XDocumentDigitalSignatures > xSigner( security::DocumentDigitalSignatures::createWithVersion(comphelper::getProcessComponentContext(), aVersion) );
1793
1794         if ( nScriptingSignatureState == SignatureState::UNKNOWN
1795           || nScriptingSignatureState == SignatureState::OK
1796           || nScriptingSignatureState == SignatureState::NOTVALIDATED )
1797         {
1798             uno::Sequence< security::DocumentSignatureInformation > aInfo = rDocShell.GetDocumentSignatureInformation( true, xSigner );
1799
1800             if ( aInfo.hasElements() )
1801             {
1802                 if ( nScriptingSignatureState == SignatureState::UNKNOWN )
1803                     nScriptingSignatureState = SfxObjectShell::ImplCheckSignaturesInformation( aInfo );
1804
1805                 if ( nScriptingSignatureState == SignatureState::OK
1806                   || nScriptingSignatureState == SignatureState::NOTVALIDATED )
1807                 {
1808                     bResult = std::any_of(aInfo.begin(), aInfo.end(),
1809                         [&xSigner](const security::DocumentSignatureInformation& rInfo) {
1810                             return xSigner->isAuthorTrusted( rInfo.Signer ); });
1811
1812                     if ( !bResult && bAllowUIToAddAuthor )
1813                     {
1814                         uno::Reference< task::XInteractionHandler > xInteraction;
1815                         if ( rDocShell.GetMedium() )
1816                             xInteraction = rDocShell.GetMedium()->GetInteractionHandler();
1817
1818                         if ( xInteraction.is() )
1819                         {
1820                             task::DocumentMacroConfirmationRequest aRequest;
1821                             aRequest.DocumentURL = getDocumentLocation();
1822                             aRequest.DocumentStorage = rDocShell.GetMedium()->GetZipStorageToSign_Impl();
1823                             aRequest.DocumentSignatureInformation = aInfo;
1824                             aRequest.DocumentVersion = aVersion;
1825                             aRequest.Classification = task::InteractionClassification_QUERY;
1826                             bResult = SfxMedium::CallApproveHandler( xInteraction, uno::makeAny( aRequest ), true );
1827                         }
1828                     }
1829                 }
1830             }
1831         }
1832     }
1833     catch( uno::Exception& )
1834     {}
1835
1836     return bResult;
1837 }
1838
1839 bool SfxObjectShell::IsContinueImportOnFilterExceptions(const OUString& aErrMessage)
1840 {
1841     if (mbContinueImportOnFilterExceptions == undefined)
1842     {
1843         if (Application::GetDialogCancelMode() == DialogCancelMode::Off)
1844         {
1845             // Ask the user to try to continue or abort loading
1846             OUString aMessage = SfxResId(STR_QMSG_ERROR_OPENING_FILE);
1847             if (!aErrMessage.isEmpty())
1848                 aMessage += SfxResId(STR_QMSG_ERROR_OPENING_FILE_DETAILS) + aErrMessage;
1849             aMessage += SfxResId(STR_QMSG_ERROR_OPENING_FILE_CONTINUE);
1850             std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(nullptr,
1851                                                       VclMessageType::Question, VclButtonsType::YesNo, aMessage));
1852             mbContinueImportOnFilterExceptions = (xBox->run() == RET_YES) ? yes : no;
1853         }
1854         else
1855             mbContinueImportOnFilterExceptions = no;
1856     }
1857     return mbContinueImportOnFilterExceptions == yes;
1858 }
1859
1860 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */