/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/*

 * This file is part of the LibreOffice project.

 *

 * This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/.

 *

 * This file incorporates work covered by the following license notice:

 *

 *   Licensed to the Apache Software Foundation (ASF) under one or more

 *   contributor license agreements. See the NOTICE file distributed

 *   with this work for additional information regarding copyright

 *   ownership. The ASF licenses this file to you under the Apache

 *   License, Version 2.0 (the "License"); you may not use this file

 *   except in compliance with the License. You may obtain a copy of

 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .

 */

#include <config_features.h>

#include <officecfg/Office/Calc.hxx>

#include <officecfg/Office/Common.hxx>

#include <officecfg/Office/Impress.hxx>

#include <officecfg/Office/Writer.hxx>

#include <vcl/weld/MessageDialog.hxx>

#include <vcl/svapp.hxx>

#include <vcl/syswin.hxx>

#include <vcl/jobset.hxx>

#include <svl/numformat.hxx>

#include <svl/whiter.hxx>

#include <svl/eitem.hxx>

#include <svl/stritem.hxx>

#include <svl/PasswordHelper.hxx>

#include <tools/urlobj.hxx>

#include <unotools/moduleoptions.hxx>

#include <sfx2/bindings.hxx>

#include <sfx2/docfile.hxx>

#include <sfx2/docfilt.hxx>

#include <sfx2/notebookbar/SfxNotebookBar.hxx>

#include <sfx2/printer.hxx>

#include <sfx2/linkmgr.hxx>

#include <editeng/flstitem.hxx>

#include <comphelper/lok.hxx>

#include <comphelper/classids.hxx>

#include <comphelper/sequenceashashmap.hxx>

#include <basic/sbmod.hxx>

#include <osl/diagnose.h>

#include <node.hxx>

#include <swwait.hxx>

#include <printdata.hxx>

#include <view.hxx>

#include <edtwin.hxx>

#include <PostItMgr.hxx>

#include <wrtsh.hxx>

#include <docsh.hxx>

#include <viewopt.hxx>

#include <wdocsh.hxx>

#include <swmodule.hxx>

#include <globdoc.hxx>

#include <usrpref.hxx>

#include <shellio.hxx>

#include <docstyle.hxx>

#include <doc.hxx>

#include <docfunc.hxx>

#include <IDocumentUndoRedo.hxx>

#include <IDocumentSettingAccess.hxx>

#include <IDocumentLinksAdministration.hxx>

#include <IDocumentDeviceAccess.hxx>

#include <IDocumentDrawModelAccess.hxx>

#include <IDocumentRedlineAccess.hxx>

#include <IDocumentStatistics.hxx>

#include <IDocumentState.hxx>

#include <pview.hxx>

#include <srcview.hxx>

#include <ndindex.hxx>

#include <ndole.hxx>

#include <txtftn.hxx>

#include <ftnidx.hxx>

#include <fldbas.hxx>

#include <docary.hxx>

#include <swerror.h>

#include <cmdid.h>

#include <strings.hrc>

#include <sfx2/viewfrm.hxx>

#include <sfx2/objface.hxx>

#define ShellClass_SwDocShell

#include <sfx2/msg.hxx>

#include <swslots.hxx>

#include <com/sun/star/document/UpdateDocMode.hpp>

#include <com/sun/star/script/XLibraryContainer.hpp>

#include <com/sun/star/document/XDocumentProperties.hpp>

#include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>

#include <com/sun/star/sdb/DatabaseContext.hpp>

#include <com/sun/star/sdb/XDocumentDataSource.hpp>

#include <com/sun/star/uri/UriReferenceFactory.hpp>

#include <com/sun/star/uri/VndSunStarPkgUrlReferenceFactory.hpp>

#include <com/sun/star/frame/XStorable.hpp>

#include <ooo/vba/XSinkCaller.hpp>

#include <unotextrange.hxx>

#include <dbmgr.hxx>

#include <iodetect.hxx>

#include <comphelper/processfactory.hxx>

#include <svx/fillbitmaplink.hxx>

#include <unotxdoc.hxx>

using namespace ::com::sun::star;

using namespace ::com::sun::star::uno;

using namespace ::com::sun::star::script;

using namespace ::com::sun::star::container;

SFX_IMPL_SUPERCLASS_INTERFACE(SwDocShell, SfxObjectShell)

void SwDocShell::InitInterface_Impl()

{

}

SFX_IMPL_OBJECTFACTORY(SwDocShell, SvGlobalName(SO3_SW_CLASSID), u"swriter"_ustr  )

bool SwDocShell::InsertGeneratedStream(SfxMedium & rMedium,

        uno::Reference<text::XTextRange> const& xInsertPosition)

{

    SwUnoInternalPaM aPam(*GetDoc()); // must have doc since called from SwView

    if (!::sw::XTextRangeToSwPaM(aPam, xInsertPosition))

        return false;

    // similar to SwView::InsertMedium

    SwReaderPtr pReader;

    Reader *const pRead = StartConvertFrom(rMedium, pReader, nullptr, &aPam);

    if (!pRead)

        return false;

    ErrCodeMsg const nError = pReader->Read(*pRead);

    return ERRCODE_NONE == nError;

}

// Prepare loading

Reader* SwDocShell::StartConvertFrom(SfxMedium& rMedium, SwReaderPtr& rpRdr,

                                    SwCursorShell const *pCursorShell,

                                    SwPaM* pPaM )

{

    bool bAPICall = false;

    if( const SfxBoolItem* pApiItem = rMedium.GetItemSet().GetItemIfSet( FN_API_CALL ) )

        bAPICall = pApiItem->GetValue();

    std::shared_ptr<const SfxFilter> pFlt = rMedium.GetFilter();

    if( !pFlt )

    {

        if(!bAPICall)

        {

            std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(nullptr,

                                                          VclMessageType::Info, VclButtonsType::Ok,

                                                          SwResId(STR_CANTOPEN)));

            xInfoBox->run();

        }

        return nullptr;

    }

    OUString aFileName( rMedium.GetName() );

    Reader* pRead = SwReaderWriter::GetReader( pFlt->GetUserData() );

    if( !pRead )

        return nullptr;

    if( rMedium.IsStorage()

        ? SwReaderType::Storage & pRead->GetReaderType()

        : SwReaderType::Stream & pRead->GetReaderType() )

    {

        if (pPaM)

            rpRdr.reset(new SwReader( rMedium, aFileName, *pPaM ));

        else if (pCursorShell)

            rpRdr.reset(new SwReader( rMedium, aFileName, *pCursorShell->GetCursor() ));

        else

            rpRdr.reset(new SwReader( rMedium, aFileName, m_xDoc.get() ));

    }

    else

        return nullptr;

    // #i30171# set the UpdateDocMode at the SwDocShell

    const SfxUInt16Item* pUpdateDocItem = rMedium.GetItemSet().GetItem(SID_UPDATEDOCMODE, false);

    m_nUpdateDocMode = pUpdateDocItem ? pUpdateDocItem->GetValue() : document::UpdateDocMode::NO_UPDATE;

    if (!pFlt->GetDefaultTemplate().isEmpty())

        pRead->SetTemplateName( pFlt->GetDefaultTemplate() );

    if( pRead == ReadAscii && nullptr != rMedium.GetInStream() &&

        pFlt->GetUserData() == FILTER_TEXT_DLG )

    {

        SwAsciiOptions aOpt;

        if( const SfxStringItem* pItem = rMedium.GetItemSet().GetItemIfSet( SID_FILE_FILTEROPTIONS ) )

            aOpt.ReadUserData( pItem->GetValue() );

        pRead->GetReaderOpt().SetASCIIOpts( aOpt );

    }

    return pRead;

}

// Loading

bool SwDocShell::ConvertFrom( SfxMedium& rMedium )

{

    SwReaderPtr pRdr;

    Reader* pRead = StartConvertFrom(rMedium, pRdr);

    if (!pRead)

      return false; // #129881# return if no reader is found

    rtl::Reference<SotStorage> pStg=pRead->getSotStorageRef(); // #i45333# save sot storage ref in case of recursive calls

    // Reading a foreign format starts from the same state as reading our own one, so link updates

    // are off until the load settles them.

    getEmbeddedObjectContainer().setUserAllowsLinkUpdate(false);

    m_xDoc->setDocAccTitle(OUString());

    if (const auto pFrame1 = SfxViewFrame::GetFirst(this))

    {

        if (auto pSysWin = pFrame1->GetWindow().GetSystemWindow())

        {

            pSysWin->SetAccessibleName(OUString());

        }

    }

    SwWait aWait( *this, true );

    SwModule* mod = SwModule::get();

        // Suppress SfxProgress, when we are Embedded

    mod->SetEmbeddedLoadSave(SfxObjectCreateMode::EMBEDDED == GetCreateMode());

    pRdr->GetDoc().getIDocumentSettingAccess().set(DocumentSettingId::HTML_MODE, dynamic_cast< const SwWebDocShell *>( this ) !=  nullptr);

    // Restore the pool default if reading a saved document.

    m_xDoc->RemoveAllFormatLanguageDependencies();

    ErrCodeMsg nErr = pRdr->Read( *pRead );

    // Maybe put away one old Doc

    if (m_xDoc.get() != &pRdr->GetDoc())

    {

        RemoveLink();

        m_xDoc = &pRdr->GetDoc();

        AddLink();

        if (!m_xBasePool.is())

            m_xBasePool = new SwDocStyleSheetPool( *m_xDoc, SfxObjectCreateMode::ORGANIZER == GetCreateMode() );

    }

    UpdateFontList();

    InitDrawModelAndDocShell(this, m_xDoc ? m_xDoc->getIDocumentDrawModelAccess().GetDrawModel() : nullptr);

    pRdr.reset();

    mod->SetEmbeddedLoadSave(false);

    SetError(nErr);

    bool bOk = !nErr.IsError();

    if (bOk && !m_xDoc->IsInLoadAsynchron())

    {

        LoadingFinished();

    }

    pRead->setSotStorageRef(pStg); // #i45333# save sot storage ref in case of recursive calls

    return bOk;

}

// Saving the Default-Format, Stg present

bool SwDocShell::Save()

{

    //#i3370# remove quick help to prevent saving of autocorrection suggestions

    if (m_pView)

        m_pView->GetEditWin().StopQuickHelp();

    SwWait aWait( *this, true );

    CalcLayoutForOLEObjects();  // format for OLE objects

    // #i62875#

    // reset compatibility flag <DoNotCaptureDrawObjsOnPage>, if possible

    if (m_pWrtShell && m_xDoc &&

        m_xDoc->getIDocumentSettingAccess().get(DocumentSettingId::DO_NOT_CAPTURE_DRAW_OBJS_ON_PAGE) &&

        docfunc::AllDrawObjsOnPage(*m_xDoc))

    {

        m_xDoc->getIDocumentSettingAccess().set(DocumentSettingId::DO_NOT_CAPTURE_DRAW_OBJS_ON_PAGE, false);

    }

    ErrCodeMsg nErr = ERR_SWG_WRITE_ERROR;

    ErrCode nVBWarning = ERRCODE_NONE;

    if( SfxObjectShell::Save() )

    {

        SwModule* mod = SwModule::get();

        switch( GetCreateMode() )

        {

        case SfxObjectCreateMode::INTERNAL:

            nErr = ERRCODE_NONE;

            break;

        case SfxObjectCreateMode::ORGANIZER:

            {

                WriterRef xWrt;

                ::GetXMLWriter(std::u16string_view(), GetMedium()->GetBaseURL(true), xWrt);

                xWrt->SetOrganizerMode( true );

                SwWriter aWrt( *GetMedium(), *m_xDoc );

                nErr = aWrt.Write( xWrt );

                xWrt->SetOrganizerMode( false );

            }

            break;

        case SfxObjectCreateMode::EMBEDDED:

            // Suppress SfxProgress, if we are Embedded

            mod->SetEmbeddedLoadSave(true);

            [[fallthrough]];

        case SfxObjectCreateMode::STANDARD:

        default:

            {

                if (m_xDoc->ContainsMSVBasic())

                {

                    if (officecfg::Office::Writer::Filter::Import::VBA::Save::get())

                        nVBWarning = GetSaveWarningOfMSVBAStorage( static_cast<SfxObjectShell&>(*this) );

                    m_xDoc->SetContainsMSVBasic( false );

                }

                // End TableBox Edit!

                if (m_pWrtShell)

                    m_pWrtShell->EndAllTableBoxEdit();

                WriterRef xWrt;

                ::GetXMLWriter(std::u16string_view(), GetMedium()->GetBaseURL(true), xWrt);

                bool bLockedView(false);

                if (m_pWrtShell)

                {

                    bLockedView = m_pWrtShell->IsViewLocked();

                    m_pWrtShell->LockView( true );    //lock visible section

                }

                SwWriter aWrt( *GetMedium(), *m_xDoc );

                nErr = aWrt.Write( xWrt );

                if (m_pWrtShell)

                    m_pWrtShell->LockView( bLockedView );

            }

            break;

        }

        mod->SetEmbeddedLoadSave(false);

    }

    SetError(nErr ? nErr : nVBWarning);

    SfxViewFrame *const pFrame =

        m_pWrtShell ? &m_pWrtShell->GetView().GetViewFrame() : nullptr;

    if( pFrame )

    {

        pFrame->GetBindings().SetState(SfxBoolItem(SID_DOC_MODIFIED, false));

    }

    return !nErr.IsError();

}

SwDocShell::LockAllViewsGuard_Impl::LockAllViewsGuard_Impl(SwViewShell* pViewShell)

{

    if (!pViewShell)

        return;

    for (SwViewShell& rShell : pViewShell->GetRingContainer())

    {

        if (!rShell.IsViewLocked())

        {

            m_aViewWasUnLocked.push_back(&rShell);

            rShell.LockView(true);

        }

    }

}

SwDocShell::LockAllViewsGuard_Impl::~LockAllViewsGuard_Impl()

{

    for (SwViewShell* pShell : m_aViewWasUnLocked)

        pShell->LockView(false);

}

std::unique_ptr<SfxObjectShell::LockAllViewsGuard> SwDocShell::LockAllViews()

{

    return std::make_unique<LockAllViewsGuard_Impl>(GetEditShell());

}

// Save using the Defaultformat

bool SwDocShell::SaveAs( SfxMedium& rMedium )

{

    SwWait aWait( *this, true );

    //#i3370# remove quick help to prevent saving of autocorrection suggestions

    if (m_pView)

        m_pView->GetEditWin().StopQuickHelp();

    //#i91811# mod if we have an active margin window, write back the text

    if (m_pView &&

        m_pView->GetPostItMgr() &&

        m_pView->GetPostItMgr()->HasActiveSidebarWin())

    {

        m_pView->GetPostItMgr()->UpdateDataOnActiveSidebarWin();

    }

    if (m_xDoc->getIDocumentSettingAccess().get(DocumentSettingId::GLOBAL_DOCUMENT) &&

        !m_xDoc->getIDocumentSettingAccess().get(DocumentSettingId::GLOBAL_DOCUMENT_SAVE_LINKS))

        RemoveOLEObjects();

    if (GetMedium())

    {

        // Task 75666 - is the Document imported by our Microsoft-Filters?

        std::shared_ptr<const SfxFilter> pOldFilter = GetMedium()->GetFilter();

        if( pOldFilter &&

            ( pOldFilter->GetUserData() == FILTER_WW8 ||

              pOldFilter->GetUserData() == "CWW6" ||

              pOldFilter->GetUserData() == "WW6" ) )

        {

            // when saving it in our own fileformat, then remove the template

            // name from the docinfo.

            uno::Reference<document::XDocumentPropertiesSupplier> xDPS(

                GetModel(), uno::UNO_QUERY_THROW);

            uno::Reference<document::XDocumentProperties> xDocProps

                = xDPS->getDocumentProperties();

            xDocProps->setTemplateName(OUString());

            xDocProps->setTemplateURL(OUString());

            xDocProps->setTemplateDate(::util::DateTime());

        }

    }

    CalcLayoutForOLEObjects();  // format for OLE objects

    const bool bURLChanged = GetMedium() && GetMedium()->GetURLObject() != rMedium.GetURLObject();

    const SwDBManager* const pMgr = m_xDoc->GetDBManager();

    const bool bHasEmbedded = pMgr && !pMgr->getEmbeddedName().isEmpty();

    bool bSaveDS = bHasEmbedded && bURLChanged;

    if (bSaveDS)

    {

        // Don't save data source in case a temporary is being saved for preview in MM wizard

        if (const SfxBoolItem* pNoEmbDS

            = rMedium.GetItemSet().GetItem(SID_NO_EMBEDDED_DS, false))

            bSaveDS = !pNoEmbDS->GetValue();

    }

    if (bSaveDS)

    {

        // We have an embedded data source definition, need to re-store it,

        // otherwise relative references will break when the new file is in a

        // different directory.

        OUString aURL(GetMedium()->GetURLObject().GetMainURL(INetURLObject::DecodeMechanism::NONE));

        if (aURL.isEmpty())

        {

            // No old URL - is this a new document created from a template with embedded DS?

            // Try to get the template URL to reconstruct the embedded data source URL

            aURL = GetMedium()->GetArgs().getUnpackedValueOrDefault(u"URL"_ustr, aURL);

        }

        if (!aURL.isEmpty())

        {

            const auto& xContext(comphelper::getProcessComponentContext());

            auto xUri = css::uri::UriReferenceFactory::create(xContext)->parse(aURL);

            assert(xUri.is());

            xUri = css::uri::VndSunStarPkgUrlReferenceFactory::create(xContext)

                       ->createVndSunStarPkgUrlReference(xUri);

            assert(xUri.is());

            aURL = xUri->getUriReference() + "/"

                   + INetURLObject::encode(pMgr->getEmbeddedName(), INetURLObject::PART_FPATH,

                                           INetURLObject::EncodeMechanism::All);

            bool bCopyTo = GetCreateMode() == SfxObjectCreateMode::EMBEDDED;

            if (!bCopyTo)

            {

                if (const SfxBoolItem* pSaveToItem

                    = rMedium.GetItemSet().GetItem(SID_SAVETO, false))

                    bCopyTo = pSaveToItem->GetValue();

            }

            auto xDatabaseContext = sdb::DatabaseContext::create(xContext);

            uno::Reference<sdb::XDocumentDataSource> xDataSource(xDatabaseContext->getByName(aURL),

                                                                 uno::UNO_QUERY);

            if (xDataSource)

            {

                uno::Reference<frame::XStorable> xStorable(xDataSource->getDatabaseDocument(),

                                                           uno::UNO_QUERY);

                SwDBManager::StoreEmbeddedDataSource(xStorable, rMedium.GetOutputStorage(),

                                                     pMgr->getEmbeddedName(), rMedium.GetName(),

                                                     bCopyTo);

            }

        }

    }

    // #i62875#

    // reset compatibility flag <DoNotCaptureDrawObjsOnPage>, if possible

    if (m_pWrtShell &&

        m_xDoc->getIDocumentSettingAccess().get(DocumentSettingId::DO_NOT_CAPTURE_DRAW_OBJS_ON_PAGE) &&

        docfunc::AllDrawObjsOnPage(*m_xDoc))

    {

        m_xDoc->getIDocumentSettingAccess().set(DocumentSettingId::DO_NOT_CAPTURE_DRAW_OBJS_ON_PAGE, false);

    }

    ErrCodeMsg nErr = ERR_SWG_WRITE_ERROR;

    ErrCode nVBWarning = ERRCODE_NONE;

    uno::Reference < embed::XStorage > xStor = rMedium.GetOutputStorage();

    if( SfxObjectShell::SaveAs( rMedium ) )

    {

        if( GetDoc()->getIDocumentSettingAccess().get(DocumentSettingId::GLOBAL_DOCUMENT) && dynamic_cast< const SwGlobalDocShell *>( this ) ==  nullptr )

        {

            // The document is closed explicitly, but using SfxObjectShellLock is still more correct here

            SfxObjectShellLock xDocSh =

                new SwGlobalDocShell( SfxObjectCreateMode::INTERNAL );

            // the global document can not be a template

            xDocSh->SetupStorage( xStor, SotStorage::GetVersion( xStor ), false );

            xDocSh->DoClose();

        }

        if (m_xDoc->ContainsMSVBasic())

        {

            if (officecfg::Office::Writer::Filter::Import::VBA::Save::get())

                nVBWarning = GetSaveWarningOfMSVBAStorage( static_cast<SfxObjectShell&>(*this) );

            m_xDoc->SetContainsMSVBasic( false );

        }

        if (m_pWrtShell)

        {

            // End TableBox Edit!

            m_pWrtShell->EndAllTableBoxEdit();

            // Remove invalid signatures.

            m_pWrtShell->ValidateAllParagraphSignatures(false);

            m_pWrtShell->ClassifyDocPerHighestParagraphClass();

        }

        // Remember and preserve Modified-Flag without calling the Link

        // (for OLE; after Statement from MM)

        const bool bIsModified = m_xDoc->getIDocumentState().IsModified();

        m_xDoc->GetIDocumentUndoRedo().LockUndoNoModifiedPosition();

        Link<bool,void> aOldOLELnk( m_xDoc->GetOle2Link() );

        m_xDoc->SetOle2Link( Link<bool,void>() );

        SwModule* mod = SwModule::get();

            // Suppress SfxProgress when we are Embedded

        mod->SetEmbeddedLoadSave(SfxObjectCreateMode::EMBEDDED == GetCreateMode());

        WriterRef xWrt;

        ::GetXMLWriter(std::u16string_view(), rMedium.GetBaseURL(true), xWrt);

        bool bLockedView(false);

        if (m_pWrtShell)

        {

            bLockedView = m_pWrtShell->IsViewLocked();

            m_pWrtShell->LockView( true );    //lock visible section

        }

        SwWriter aWrt( rMedium, *m_xDoc );

        nErr = aWrt.Write( xWrt );

        if (m_pWrtShell)

            m_pWrtShell->LockView( bLockedView );

        if( bIsModified )

        {

            m_xDoc->getIDocumentState().SetModified();

            m_xDoc->GetIDocumentUndoRedo().UnLockUndoNoModifiedPosition();

        }

        m_xDoc->SetOle2Link( aOldOLELnk );

        mod->SetEmbeddedLoadSave(false);

        // Increase RSID

        m_xDoc->setRsid( m_xDoc->getRsid() );

        m_xDoc->cleanupUnoCursorTable();

    }

    SetError(nErr ? nErr : nVBWarning);

    return !nErr.IsError();

}

// Save all Formats

static SwSrcView* lcl_GetSourceView( SwDocShell const * pSh )

{

    // are we in SourceView?

    SfxViewFrame* pVFrame = SfxViewFrame::GetFirst( pSh );

    SfxViewShell* pViewShell = pVFrame ? pVFrame->GetViewShell() : nullptr;

    return dynamic_cast<SwSrcView*>( pViewShell );

}

bool SwDocShell::ConvertTo( SfxMedium& rMedium )

{

    std::shared_ptr<const SfxFilter> pFlt = rMedium.GetFilter();

    if( !pFlt )

        return false;

    WriterRef xWriter;

    SwReaderWriter::GetWriter( pFlt->GetUserData(), rMedium.GetBaseURL( true ), xWriter );

    if( !xWriter.is() )

    {   // Filter not available

        std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(nullptr,

                                                      VclMessageType::Info, VclButtonsType::Ok,

                                                      SwResId(STR_DLLNOTFOUND)));

        xInfoBox->run();

        return false;

    }

    //#i3370# remove quick help to prevent saving of autocorrection suggestions

    if (m_pView)

        m_pView->GetEditWin().StopQuickHelp();

    //#i91811# mod if we have an active margin window, write back the text

    if (m_pView &&

        m_pView->GetPostItMgr() &&

        m_pView->GetPostItMgr()->HasActiveSidebarWin())

    {

        m_pView->GetPostItMgr()->UpdateDataOnActiveSidebarWin();

    }

    ErrCode nVBWarning = ERRCODE_NONE;

    if (m_xDoc->ContainsMSVBasic())

    {

        bool bSave = pFlt->GetUserData() == "CWW8"

                     && officecfg::Office::Writer::Filter::Import::VBA::Save::get();

        if ( bSave )

        {

            rtl::Reference<SotStorage> xStg = new SotStorage(rMedium.GetOutStream(), false);

            OSL_ENSURE( !xStg->GetError(), "No storage available for storing VBA macros!" );

            if ( !xStg->GetError() )

            {

                nVBWarning = SaveOrDelMSVBAStorage( static_cast<SfxObjectShell&>(*this), *xStg, bSave, u"Macros"_ustr );

                xStg->Commit();

                m_xDoc->SetContainsMSVBasic( true );

            }

        }

    }

    // End TableBox Edit!

    if (m_pWrtShell)

        m_pWrtShell->EndAllTableBoxEdit();

    if( pFlt->GetUserData() == "HTML" )

    {

#if HAVE_FEATURE_SCRIPTING

        if( !officecfg::Office::Common::Filter::HTML::Export::Basic::get()

            && officecfg::Office::Common::Filter::HTML::Export::Warning::get()

            && HasBasic() )

        {

            uno::Reference< XLibraryContainer > xLibCont = GetBasicContainer();

            uno::Reference< XNameAccess > xLib;

            const Sequence<OUString> aNames = xLibCont->getElementNames();

            for(const OUString& rName : aNames)

            {

                Any aLib = xLibCont->getByName(rName);

                aLib >>= xLib;

                if(xLib.is())

                {

                    Sequence<OUString> aModNames = xLib->getElementNames();

                    if(aModNames.hasElements())

                    {

                        SetError(WARN_SWG_HTML_NO_MACROS);

                        break;

                    }

                }

            }

        }

#endif

    }

    // #i76360# Update document statistics

    if ( !rMedium.IsSkipImages() )

        m_xDoc->getIDocumentStatistics().UpdateDocStat( false, true );

    CalcLayoutForOLEObjects();  // format for OLE objects

    // #i62875#

    // reset compatibility flag <DoNotCaptureDrawObjsOnPage>, if possible

    if (m_pWrtShell &&

        m_xDoc->getIDocumentSettingAccess().get(DocumentSettingId::DO_NOT_CAPTURE_DRAW_OBJS_ON_PAGE) &&

        docfunc::AllDrawObjsOnPage(*m_xDoc))

    {

        m_xDoc->getIDocumentSettingAccess().set(DocumentSettingId::DO_NOT_CAPTURE_DRAW_OBJS_ON_PAGE, false);

    }

    if( xWriter->IsStgWriter() &&

        ( pFlt->GetUserData() == FILTER_XML ||

          pFlt->GetUserData() == FILTER_XMLV ||

          pFlt->GetUserData() == FILTER_XMLVW ) )

    {

        // determine the own Type

        sal_uInt8 nMyType = 0;

        if( dynamic_cast< const SwWebDocShell *>( this ) !=  nullptr )

            nMyType = 1;

        else if( dynamic_cast< const SwGlobalDocShell *>( this ) !=  nullptr )

            nMyType = 2;

        // determine the desired Type

        sal_uInt8 nSaveType = 0;

        SotClipboardFormatId nSaveClipId = pFlt->GetFormat();

        if( SotClipboardFormatId::STARWRITERWEB_8 == nSaveClipId ||

            SotClipboardFormatId::STARWRITERWEB_60 == nSaveClipId ||

            SotClipboardFormatId::STARWRITERWEB_50 == nSaveClipId ||

            SotClipboardFormatId::STARWRITERWEB_40 == nSaveClipId )

            nSaveType = 1;

        else if( SotClipboardFormatId::STARWRITERGLOB_8 == nSaveClipId ||

                 SotClipboardFormatId::STARWRITERGLOB_8_TEMPLATE == nSaveClipId ||

                 SotClipboardFormatId::STARWRITERGLOB_60 == nSaveClipId ||

                 SotClipboardFormatId::STARWRITERGLOB_50 == nSaveClipId ||

                 SotClipboardFormatId::STARWRITERGLOB_40 == nSaveClipId )

            nSaveType = 2;

        // Change Flags of the Document accordingly

        bool bIsHTMLModeSave = GetDoc()->getIDocumentSettingAccess().get(DocumentSettingId::HTML_MODE);

        bool bIsGlobalDocSave = GetDoc()->getIDocumentSettingAccess().get(DocumentSettingId::GLOBAL_DOCUMENT);

        bool bIsGlblDocSaveLinksSave = GetDoc()->getIDocumentSettingAccess().get(DocumentSettingId::GLOBAL_DOCUMENT_SAVE_LINKS);

        if( nMyType != nSaveType )

        {

            GetDoc()->getIDocumentSettingAccess().set(DocumentSettingId::HTML_MODE, 1 == nSaveType);

            GetDoc()->getIDocumentSettingAccess().set(DocumentSettingId::GLOBAL_DOCUMENT, 2 == nSaveType);

            if( 2 != nSaveType )

                GetDoc()->getIDocumentSettingAccess().set(DocumentSettingId::GLOBAL_DOCUMENT_SAVE_LINKS, false);

        }

        // if the target format is storage based, then the output storage must be already created

        if ( rMedium.IsStorage() )

        {

            // set MediaType on target storage

            // (MediaType will be queried during SaveAs)

            try

            {

                // TODO/MBA: testing

                uno::Reference < beans::XPropertySet > xSet( rMedium.GetStorage(), uno::UNO_QUERY );

                if ( xSet.is() )

                    xSet->setPropertyValue(u"MediaType"_ustr, uno::Any( SotExchange::GetFormatMimeType( nSaveClipId ) ) );

            }

            catch (const uno::Exception&)

            {

            }

        }

        // Now normally save the Document

        bool bRet = SaveAs( rMedium );

        if( nMyType != nSaveType )

        {

            GetDoc()->getIDocumentSettingAccess().set(DocumentSettingId::HTML_MODE, bIsHTMLModeSave );

            GetDoc()->getIDocumentSettingAccess().set(DocumentSettingId::GLOBAL_DOCUMENT, bIsGlobalDocSave);

            GetDoc()->getIDocumentSettingAccess().set(DocumentSettingId::GLOBAL_DOCUMENT_SAVE_LINKS, bIsGlblDocSaveLinksSave);

        }

        return bRet;

    }

    if( pFlt->GetUserData() == FILTER_TEXT_DLG &&

        (m_pWrtShell || !::lcl_GetSourceView(this)))

    {

        SwAsciiOptions aOpt;

        OUString sItemOpt;

        if( const SfxStringItem* pItem = rMedium.GetItemSet().GetItemIfSet( SID_FILE_FILTEROPTIONS ) )

            sItemOpt = pItem->GetValue();

        if(!sItemOpt.isEmpty())

            aOpt.ReadUserData( sItemOpt );

        xWriter->SetAsciiOptions( aOpt );

    }

    SwModule* mod = SwModule::get();

        // Suppress SfxProgress when we are Embedded

    mod->SetEmbeddedLoadSave(SfxObjectCreateMode::EMBEDDED == GetCreateMode());

    // Span Context in order to suppress the Selection's View

    ErrCodeMsg nErrno;

    const OUString aFileName( rMedium.GetName() );

    bool bSelection = false;

    if (m_pWrtShell)

    {

        const SfxBoolItem* pSelectionItem = rMedium.GetItemSet().GetItemIfSet(SID_SELECTION);

        bSelection = pSelectionItem && pSelectionItem->GetValue();

    }

    // No View, so the whole Document! (unless SID_SELECTION explicitly set)

    if (m_pWrtShell && (!Application::IsHeadlessModeEnabled() || bSelection))

    {

        SwWait aWait( *this, true );

        // #i106906#

        const bool bFormerLockView = m_pWrtShell->IsViewLocked();

        m_pWrtShell->LockView( true );

        m_pWrtShell->StartAllAction();

        m_pWrtShell->Push();

        SwWriter aWrt( rMedium, *m_pWrtShell, !bSelection );

        nErrno = aWrt.Write( xWriter, &aFileName );

        //JP 16.05.97: In case the SFX revokes the View while saving

        if (m_pWrtShell)

        {

            m_pWrtShell->Pop(SwCursorShell::PopMode::DeleteCurrent);

            m_pWrtShell->EndAllAction();

            // #i106906#

            m_pWrtShell->LockView( bFormerLockView );

        }

    }

    else

    {

        // are we in SourceView?

        SwSrcView* pSrcView = ::lcl_GetSourceView( this );

        if( pSrcView )

        {

            pSrcView->SaveContentTo(rMedium);

            nErrno = ERRCODE_NONE;

        }

        else

        {

            SwWriter aWrt( rMedium, *m_xDoc );

            nErrno = aWrt.Write( xWriter, &aFileName );

        }

    }

    mod->SetEmbeddedLoadSave(false);

    SetError(nErrno ? nErrno : nVBWarning);

    if( !rMedium.IsStorage() )

        rMedium.CloseOutStream();

    return ! nErrno.IsError();

}

// Hands off

// do not yet activate, must deliver TRUE

bool SwDocShell::SaveCompleted( const uno::Reference < embed::XStorage >& xStor  )

{

    bool bRet = SfxObjectShell::SaveCompleted( xStor );

    if( bRet )

    {

        // Do not decide until here, whether Saving was successful or not

        if( IsModified() )

            m_xDoc->getIDocumentState().SetModified();

        else

            m_xDoc->getIDocumentState().ResetModified();

    }

    if (m_pOLEChildList)

    {

        bool bResetModified = IsEnableSetModified();

        if( bResetModified )

            EnableSetModified( false );

        uno::Sequence < OUString > aNames = m_pOLEChildList->GetObjectNames();

        for( sal_Int32 n = aNames.getLength(); n; n-- )

        {

            if (!m_pOLEChildList->MoveEmbeddedObject(aNames[n-1], GetEmbeddedObjectContainer()))

            {

                OSL_FAIL("Copying of objects didn't work!" );

            }

        }

        m_pOLEChildList.reset();

        if( bResetModified )

            EnableSetModified();

    }

    return bRet;

}

// Draw()-Override for OLE2 (Sfx)

void SwDocShell::Draw( OutputDevice* pDev, const JobSetup& rSetup,

                               sal_uInt16 nAspect, bool bOutputForScreen )

{

    //fix #25341# Draw should not affect the Modified

    bool bResetModified = IsEnableSetModified();

    if ( bResetModified )

        EnableSetModified( false );

    // When there is a JobSetup connected to the Document, we copy it to

    // reconnect it after PrtOle2. We don't use an empty JobSetup because

    // that would only lead to questionable results after expensive

    // reformatting (Preview!)

    std::unique_ptr<JobSetup> pOrig;

    if ( !rSetup.GetPrinterName().isEmpty() && ASPECT_THUMBNAIL != nAspect )

    {

        const JobSetup* pCurrentJobSetup = m_xDoc->getIDocumentDeviceAccess().getJobsetup();

        if( pCurrentJobSetup )         // then we copy that

            pOrig.reset(new JobSetup( *pCurrentJobSetup ));

        m_xDoc->getIDocumentDeviceAccess().setJobsetup( rSetup );

    }

    tools::Rectangle aRect( nAspect == ASPECT_THUMBNAIL ?

            GetVisArea( nAspect ) : GetVisArea( ASPECT_CONTENT ) );

    pDev->Push();

    pDev->SetFillColor();

    pDev->SetLineColor();

    pDev->SetBackground();

    const bool bWeb = dynamic_cast< const SwWebDocShell *>( this ) !=  nullptr;

    SwPrintData aOpts;

    SwViewShell::PrtOle2(m_xDoc.get(), SwModule::get()->GetUsrPref(bWeb), aOpts, *pDev, aRect, bOutputForScreen);

    pDev->Pop();

    if( pOrig )

    {

        m_xDoc->getIDocumentDeviceAccess().setJobsetup( *pOrig );

    }

    if ( bResetModified )

        EnableSetModified();

}

rtl::Reference<SwXTextDocument> SwDocShell::GetBaseModel() const