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