/* -*- 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 <com/sun/star/style/XStyleFamiliesSupplier.hpp>

#include <com/sun/star/ui/dialogs/ExtendedFilePickerElementIds.hpp>

#include <com/sun/star/util/CloseVetoException.hpp>

#include <com/sun/star/beans/XPropertySet.hpp>

#include <com/sun/star/beans/PropertyValue.hpp>

#include <com/sun/star/beans/PropertyAttribute.hpp>

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

#include <com/sun/star/drawing/LineStyle.hpp>

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

#include <com/sun/star/lang/XServiceInfo.hpp>

#include <com/sun/star/security/XCertificate.hpp>

#include <com/sun/star/task/ErrorCodeIOException.hpp>

#include <com/sun/star/task/InteractionHandler.hpp>

#include <com/sun/star/task/XStatusIndicator.hpp>

#include <com/sun/star/task/XStatusIndicatorFactory.hpp>

#include <comphelper/processfactory.hxx>

#include <comphelper/servicehelper.hxx>

#include <com/sun/star/drawing/XDrawView.hpp>

#include <com/sun/star/security/DocumentSignatureInformation.hpp>

#include <com/sun/star/security/DocumentDigitalSignatures.hpp>

#include <comphelper/diagnose_ex.hxx>

#include <tools/debug.hxx>

#include <tools/stream.hxx>

#include <tools/urlobj.hxx>

#include <svl/whiter.hxx>

#include <svl/intitem.hxx>

#include <svl/eitem.hxx>

#include <svl/visitem.hxx>

#include <svtools/sfxecode.hxx>

#include <svtools/ehdl.hxx>

#include <sal/log.hxx>

#include <sfx2/app.hxx>

#include <comphelper/string.hxx>

#include <basic/sbxcore.hxx>

#include <basic/sberrors.hxx>

#include <unotools/moduleoptions.hxx>

#include <unotools/saveopt.hxx>

#include <unotools/securityoptions.hxx>

#include <svtools/DocumentToGraphicRenderer.hxx>

#include <vcl/gdimtf.hxx>

#include <vcl/svapp.hxx>

#include <vcl/weld/MessageDialog.hxx>

#include <comphelper/documentconstants.hxx>

#include <comphelper/storagehelper.hxx>

#include <comphelper/lok.hxx>

#include <LibreOfficeKit/LibreOfficeKitEnums.h>

#include <tools/link.hxx>

#include <svl/cryptosign.hxx>

#include <officecfg/Office/Common.hxx>

#include <vcl/stdtext.hxx>

#include <vcl/help.hxx>

#include <sfx2/signaturestate.hxx>

#include <sfx2/sfxresid.hxx>

#include <sfx2/request.hxx>

#include <sfx2/printer.hxx>

#include <sfx2/viewsh.hxx>

#include <sfx2/dinfdlg.hxx>

#include <sfx2/docfilt.hxx>

#include <sfx2/docfile.hxx>

#include <sfx2/dispatch.hxx>

#include <sfx2/objitem.hxx>

#include <sfx2/objsh.hxx>

#include <objshimp.hxx>

#include <sfx2/module.hxx>

#include <sfx2/viewfrm.hxx>

#include <versdlg.hxx>

#include <sfx2/strings.hrc>

#include <sfx2/docfac.hxx>

#include <sfx2/fcontnr.hxx>

#include <sfx2/msgpool.hxx>

#include <sfx2/objface.hxx>

#include <checkin.hxx>

#include <sfx2/infobar.hxx>

#include <sfx2/sfxuno.hxx>

#include <sfx2/sfxsids.hrc>

#include <sfx2/lokhelper.hxx>

#include <comphelper/dispatchcommand.hxx>

#include <SfxRedactionHelper.hxx>

#include <com/sun/star/util/XCloseable.hpp>

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

#include <com/sun/star/drawing/XDrawPagesSupplier.hpp>

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

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

#include <guisaveas.hxx>

#include <saveastemplatedlg.hxx>

#include <memory>

#include <cppuhelper/implbase.hxx>

#include <unotools/ucbstreamhelper.hxx>

#include <unotools/streamwrap.hxx>

#include <comphelper/sequenceashashmap.hxx>

#include <editeng/unoprnms.hxx>

#include <comphelper/base64.hxx>

#include <autoredactdialog.hxx>

#include <boost/property_tree/json_parser.hpp>

#define ShellClass_SfxObjectShell

#include <sfxslots.hxx>

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

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

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

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

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

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

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

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

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

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

SFX_IMPL_SUPERCLASS_INTERFACE(SfxObjectShell, SfxShell)

void SfxObjectShell::InitInterface_Impl()

{

}

namespace {

class SfxClosePreventer_Impl : public ::cppu::WeakImplHelper< css::util::XCloseListener >

{

    bool m_bGotOwnership;

    bool m_bPreventClose;

public:

    SfxClosePreventer_Impl();

    bool HasOwnership() const { return m_bGotOwnership; }

    void SetPreventClose( bool bPrevent ) { m_bPreventClose = bPrevent; }

    virtual void SAL_CALL queryClosing( const lang::EventObject& aEvent, sal_Bool bDeliverOwnership ) override;

    virtual void SAL_CALL notifyClosing( const lang::EventObject& aEvent ) override ;

    virtual void SAL_CALL disposing( const lang::EventObject& aEvent ) override ;

} ;

}

SfxClosePreventer_Impl::SfxClosePreventer_Impl()

: m_bGotOwnership( false )

, m_bPreventClose( true )

{

}

void SAL_CALL SfxClosePreventer_Impl::queryClosing( const lang::EventObject&, sal_Bool bDeliverOwnership )

{

    if ( m_bPreventClose )

    {

        if ( !m_bGotOwnership )

            m_bGotOwnership = bDeliverOwnership;

        throw util::CloseVetoException();

    }

}

void SAL_CALL SfxClosePreventer_Impl::notifyClosing( const lang::EventObject& )

{}

void SAL_CALL SfxClosePreventer_Impl::disposing( const lang::EventObject& )

{}

namespace {

class SfxInstanceCloseGuard_Impl

{

    rtl::Reference<SfxClosePreventer_Impl> m_xPreventer;

    uno::Reference< util::XCloseable > m_xCloseable;

public:

    SfxInstanceCloseGuard_Impl() {}

    ~SfxInstanceCloseGuard_Impl();

    bool Init_Impl( const uno::Reference< util::XCloseable >& xCloseable );

};

}

bool SfxInstanceCloseGuard_Impl::Init_Impl( const uno::Reference< util::XCloseable >& xCloseable )

{

    bool bResult = false;

    // do not allow reinit after the successful init

    if ( xCloseable.is() && !m_xCloseable.is() )

    {

        try

        {

            m_xPreventer = new SfxClosePreventer_Impl();

            xCloseable->addCloseListener( m_xPreventer );

            m_xCloseable = xCloseable;

            bResult = true;

        }

        catch( uno::Exception& )

        {

            OSL_FAIL( "Could not register close listener!" );

        }

    }

    return bResult;

}

SfxInstanceCloseGuard_Impl::~SfxInstanceCloseGuard_Impl()

{

    if ( !m_xCloseable.is() || !m_xPreventer.is() )

        return;

    try

    {

        m_xCloseable->removeCloseListener( m_xPreventer );

    }

    catch( uno::Exception& )

    {

    }

    try

    {

        if ( m_xPreventer.is() )

        {

            m_xPreventer->SetPreventClose( false );

            if ( m_xPreventer->HasOwnership() )

                m_xCloseable->close( true ); // TODO: do it asynchronously

        }

    }

    catch( uno::Exception& )

    {

    }

}

void SfxObjectShell::PrintExec_Impl(SfxRequest &rReq)

{

    SfxViewFrame *pFrame = SfxViewFrame::GetFirst(this);

    if ( pFrame )

    {

        rReq.SetSlot( SID_PRINTDOC );

        pFrame->GetViewShell()->ExecuteSlot(rReq);

    }

}

void SfxObjectShell::PrintState_Impl(SfxItemSet &rSet)

{

    bool bPrinting = false;

    SfxViewFrame* pFrame = SfxViewFrame::GetFirst( this );

    if ( pFrame )

    {

        SfxPrinter *pPrinter = pFrame->GetViewShell()->GetPrinter();

        bPrinting = pPrinter && pPrinter->IsPrinting();

    }

    rSet.Put( SfxBoolItem( SID_PRINTOUT, bPrinting ) );

}

bool SfxObjectShell::APISaveAs_Impl(std::u16string_view aFileName, SfxItemSet& rItemSet,

                                    const css::uno::Sequence<css::beans::PropertyValue>& rArgs)

{

    bool bOk = false;

    if ( GetMedium() )

    {

        OUString aFilterName;

        const SfxStringItem* pFilterNameItem = rItemSet.GetItem<SfxStringItem>(SID_FILTER_NAME, false);

        if( pFilterNameItem )

        {

            aFilterName = pFilterNameItem->GetValue();

        }

        else

        {

            const SfxStringItem* pContentTypeItem = rItemSet.GetItem<SfxStringItem>(SID_CONTENTTYPE, false);

            if ( pContentTypeItem )

            {

                std::shared_ptr<const SfxFilter> pFilter = SfxFilterMatcher( GetFactory().GetFactoryName() ).GetFilter4Mime( pContentTypeItem->GetValue(), SfxFilterFlags::EXPORT );

                if ( pFilter )

                    aFilterName = pFilter->GetName();

            }

        }

        // in case no filter defined use default one

        if( aFilterName.isEmpty() )

        {

            std::shared_ptr<const SfxFilter> pFilt = SfxFilter::GetDefaultFilterFromFactory(GetFactory().GetFactoryName());

            DBG_ASSERT( pFilt, "No default filter!\n" );

            if( pFilt )

                aFilterName = pFilt->GetFilterName();

            rItemSet.Put(SfxStringItem(SID_FILTER_NAME, aFilterName));

        }

        {

            SfxObjectShellRef xLock( this ); // ???

            // use the title that is provided in the media descriptor

            const SfxStringItem* pDocTitleItem = rItemSet.GetItem<SfxStringItem>(SID_DOCINFO_TITLE, false);

            if ( pDocTitleItem )

                getDocProperties()->setTitle( pDocTitleItem->GetValue() );

            bOk = CommonSaveAs_Impl(INetURLObject(aFileName), aFilterName, rItemSet, rArgs);

        }

    }

    return bOk;

}

void SfxObjectShell::CheckOut( )

{

    try

    {

        uno::Reference< document::XCmisDocument > xCmisDoc( GetModel(), uno::UNO_QUERY_THROW );

        xCmisDoc->checkOut( );

        // Remove the info bar

        if (SfxViewFrame* pViewFrame = GetFrame())

            pViewFrame->RemoveInfoBar( u"checkout" );

    }

    catch ( const uno::RuntimeException& e )

    {

        if (SfxViewFrame* pFrame = GetFrame())

        {

            std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(pFrame->GetFrameWeld(),

                                                      VclMessageType::Warning, VclButtonsType::Ok, e.Message));

            xBox->run();

        }

    }

}

void SfxObjectShell::CancelCheckOut( )

{

    try

    {

        uno::Reference< document::XCmisDocument > xCmisDoc( GetModel(), uno::UNO_QUERY_THROW );

        xCmisDoc->cancelCheckOut( );

        uno::Reference< util::XModifiable > xModifiable( GetModel( ), uno::UNO_QUERY );

        if ( xModifiable.is( ) )

            xModifiable->setModified( false );

    }

    catch ( const uno::RuntimeException& e )

    {

        if (SfxViewFrame* pFrame = GetFrame())

        {

            std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(pFrame->GetFrameWeld(),

                                                      VclMessageType::Warning, VclButtonsType::Ok, e.Message));

            xBox->run();

        }

    }

}

void SfxObjectShell::CheckIn( )

{

    try

    {

        uno::Reference< document::XCmisDocument > xCmisDoc( GetModel(), uno::UNO_QUERY_THROW );

        // Pop up dialog to ask for comment and major

        if (SfxViewFrame* pFrame = GetFrame())

        {

            SfxCheckinDialog checkinDlg(pFrame->GetFrameWeld());

            if (checkinDlg.run() == RET_OK)

            {

                xCmisDoc->checkIn(checkinDlg.IsMajor(), checkinDlg.GetComment());

                uno::Reference< util::XModifiable > xModifiable( GetModel( ), uno::UNO_QUERY );

                if ( xModifiable.is( ) )

                    xModifiable->setModified( false );

            }

        }

    }

    catch ( const uno::RuntimeException& e )

    {

        if (SfxViewFrame* pFrame = GetFrame())

        {

            std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(pFrame->GetFrameWeld(),

                                                      VclMessageType::Warning, VclButtonsType::Ok, e.Message));

            xBox->run();

        }

    }

}

uno::Sequence< document::CmisVersion > SfxObjectShell::GetCmisVersions( ) const

{

    try

    {

        uno::Reference< document::XCmisDocument > xCmisDoc( GetModel(), uno::UNO_QUERY_THROW );

        return xCmisDoc->getAllVersions( );

    }

    catch ( const uno::RuntimeException& e )

    {

        if (SfxViewFrame* pFrame = GetFrame())

        {

            std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(pFrame->GetFrameWeld(),

                                                      VclMessageType::Warning, VclButtonsType::Ok, e.Message));

            xBox->run();

        }

    }

    return uno::Sequence< document::CmisVersion > ( );

}

bool SfxObjectShell::IsSignPDF() const

{

    if (pMedium && !pMedium->IsOriginallyReadOnly())

    {

        const std::shared_ptr<const SfxFilter>& pFilter = pMedium->GetFilter();

        if (pFilter && pFilter->GetName() == "draw_pdf_import")

            return true;

    }

    return false;

}

static void sendErrorToLOK(const ErrCodeMsg& error)

{

    if (error.GetCode().GetClass() == ErrCodeClass::NONE)

        return;

    SfxViewShell* pNotifier = SfxViewShell::Current();

    if (!pNotifier)

        return;

    boost::property_tree::ptree aTree;

    aTree.put("code", error);

    aTree.put("kind", "");

    aTree.put("cmd", "");

    OUString aErr;

    if (ErrorStringFactory::CreateString(error, aErr))

        aTree.put("message", aErr.toUtf8());

    std::stringstream aStream;

    boost::property_tree::write_json(aStream, aTree);

    pNotifier->libreOfficeKitViewCallback(LOK_CALLBACK_ERROR, OString(aStream.str()));

}

namespace

{

void SetDocProperties(const uno::Reference<document::XDocumentProperties>& xDP,

                      const uno::Sequence<beans::PropertyValue>& rUpdatedProperties)

{

    comphelper::SequenceAsHashMap aMap(rUpdatedProperties);

    OUString aNamePrefix;

    auto it = aMap.find(u"NamePrefix"_ustr);

    if (it != aMap.end())

    {

        it->second >>= aNamePrefix;

    }

    uno::Sequence<beans::PropertyValue> aUserDefinedProperties;

    it = aMap.find(u"UserDefinedProperties"_ustr);

    if (it != aMap.end())

    {

        it->second >>= aUserDefinedProperties;

    }

    uno::Reference<beans::XPropertyContainer> xUDP = xDP->getUserDefinedProperties();

    if (!aNamePrefix.isEmpty())

    {

        uno::Reference<beans::XPropertySet> xSet(xUDP, UNO_QUERY);

        uno::Reference<beans::XPropertySetInfo> xSetInfo = xSet->getPropertySetInfo();

        const uno::Sequence<beans::Property> aProperties = xSetInfo->getProperties();

        for (const auto& rProperty : aProperties)

        {

            if (!rProperty.Name.startsWith(aNamePrefix))

            {

                continue;

            }

            if (!(rProperty.Attributes & beans::PropertyAttribute::REMOVABLE))

            {

                continue;

            }

            xUDP->removeProperty(rProperty.Name);

        }

    }

    for (const auto& rUserDefinedProperty : aUserDefinedProperties)

    {

        xUDP->addProperty(rUserDefinedProperty.Name, beans::PropertyAttribute::REMOVABLE,

                          rUserDefinedProperty.Value);

    }

}

}

void SfxObjectShell::AfterSignContent(bool bHaveWeSigned, weld::Window* pDialogParent)

{

    if (comphelper::LibreOfficeKit::isActive())

    {

        // LOK signing certificates are per-view, don't store them in the model.

        return;

    }

    if ( bHaveWeSigned && HasValidSignatures() )

    {

        std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog( pDialogParent,

                    VclMessageType::Question, VclButtonsType::YesNo, SfxResId(STR_QUERY_REMEMBERSIGNATURE)));

        SetRememberCurrentSignature(xBox->run() == RET_YES);

    }

}

namespace

{

/// Updates the UI so it doesn't try to modify an already finalized signature line shape.

void ResetSignatureSelection(SfxObjectShell& rObjectShell, SfxViewShell& rViewShell)

{

    rViewShell.SetSignPDFCertificate({});

    comphelper::dispatchCommand(".uno:DeSelect", {});

    rObjectShell.RecheckSignature(false);

}

}

static weld::Window* GetReqDialogParent(const SfxRequest &rReq, const SfxObjectShell& rShell)

{

    weld::Window* pDialogParent = rReq.GetFrameWeld();

    if (!pDialogParent)

    {

        SfxViewFrame* pFrame = rShell.GetFrame();

        if (!pFrame)

            pFrame = SfxViewFrame::GetFirst(&rShell);

        if (pFrame)

            pDialogParent = pFrame->GetFrameWeld();

    }

    return pDialogParent;

}

void SfxObjectShell::ExecFile_Impl(SfxRequest &rReq)

{

    sal_uInt16 nId = rReq.GetSlot();

    bool bHaveWeSigned = false;

    if( SID_SIGNATURE == nId || SID_MACRO_SIGNATURE == nId )

    {

        weld::Window* pDialogParent = GetReqDialogParent(rReq, *this);

        QueryHiddenInformation(HiddenWarningFact::WhenSigning);

        if (SID_SIGNATURE == nId)

        {

            SfxViewFrame* pFrame = GetFrame();

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

            uno::Reference<security::XCertificate> xCertificate = pViewShell ? pViewShell->GetSignPDFCertificate().m_xCertificate : nullptr;

            if (xCertificate.is())

            {

                svl::crypto::SigningContext aSigningContext;

                aSigningContext.m_xCertificate = std::move(xCertificate);

                bHaveWeSigned |= SignDocumentContentUsingCertificate(aSigningContext);

                // Reset the picked certificate for PDF signing, then recheck signatures to show how

                // the PDF actually looks like after signing.  Also change the "finish signing" on

                // the infobar back to "sign document".

                if (pViewShell)

                {

                    ResetSignatureSelection(*this, *pViewShell);

                    pFrame->RemoveInfoBar(u"readonly");

                    pFrame->AppendReadOnlyInfobar();

                }

            }

            else

            {

                // See if a signing cert is passed as a parameter: if so, parse that.

                std::string aSignatureCert;

                std::string aSignatureKey;

                const SfxStringItem* pSignatureCert = rReq.GetArg<SfxStringItem>(FN_PARAM_1);

                if (pSignatureCert)

                {

                    aSignatureCert = pSignatureCert->GetValue().toUtf8();

                }

                const SfxStringItem* pSignatureKey = rReq.GetArg<SfxStringItem>(FN_PARAM_2);

                if (pSignatureKey)

                {

                    aSignatureKey = pSignatureKey->GetValue().toUtf8();

                }

                // See if an external signature time/value is provided: if so, sign with those

                // instead of interactive signing via the dialog.

                svl::crypto::SigningContext aSigningContext;

                const SfxStringItem* pSignatureTime = rReq.GetArg<SfxStringItem>(FN_PARAM_3);

                if (pSignatureTime)

                {

                    sal_Int64 nSignatureTime = pSignatureTime->GetValue().toInt64();

                    aSigningContext.m_nSignatureTime = nSignatureTime;

                }

                const SfxStringItem* pSignatureValue = rReq.GetArg<SfxStringItem>(FN_PARAM_4);

                if (pSignatureValue)

                {

                    OUString aSignatureValue = pSignatureValue->GetValue();

                    uno::Sequence<sal_Int8> aBytes;

                    comphelper::Base64::decode(aBytes, aSignatureValue);

                    aSigningContext.m_aSignatureValue.assign(

                        aBytes.getArray(), aBytes.getArray() + aBytes.getLength());

                }

                if (!aSigningContext.m_aSignatureValue.empty())

                {

                    SignDocumentContentUsingCertificate(aSigningContext);

                    if (pViewShell)

                    {

                        ResetSignatureSelection(*this, *pViewShell);

                    }

                    rReq.Done();

                    return;

                }

                if (pViewShell)

                {

                    svl::crypto::CertificateOrName aCertificateOrName;

                    if (!aSignatureCert.empty() && !aSignatureKey.empty())

                    {

                        aCertificateOrName.m_xCertificate = SfxLokHelper::getSigningCertificate(aSignatureCert, aSignatureKey);

                    }

                    // Always set the signing certificate, to clear data from a previous dispatch.

                    pViewShell->SetSigningCertificate(aCertificateOrName);

                }

                // Async, all code before return has to go into the callback.

                SignDocumentContent(pDialogParent, [this, pDialogParent] (bool bSigned) {

                    AfterSignContent(bSigned, pDialogParent);

                });

                return;

            }

        }

        else

        {

            // Async, all code before return has to go into the callback.

            SignScriptingContent(pDialogParent, [this, pDialogParent] (bool bSigned) {

                AfterSignContent(bSigned, pDialogParent);

            });

            return;

        }

        AfterSignContent(bHaveWeSigned, pDialogParent);

        return;

    }

    if ( !GetMedium() && nId != SID_CLOSEDOC )

    {

        rReq.Ignore();

        return;

    }

    // this guard is created here to have it destruction at the end of the method

    SfxInstanceCloseGuard_Impl aModelGuard;

    bool bIsPDFExport = false;

    bool bIsAutoRedact = false;

    bool bIsAsync = false;

    std::vector<std::pair<RedactionTarget, OUString>> aRedactionTargets;

    switch(nId)

    {

        case SID_VERSION:

        {

            SfxViewFrame* pFrame = GetFrame();

            if ( !pFrame )

                pFrame = SfxViewFrame::GetFirst( this );

            if ( !pFrame )

                return;

            if ( !IsOwnStorageFormat( *GetMedium() ) )

                return;

            weld::Window* pDialogParent = GetReqDialogParent(rReq, *this);

            SfxVersionDialog aDlg(pDialogParent, pFrame, IsSaveVersionOnClose());

            aDlg.run();

            SetSaveVersionOnClose(aDlg.IsSaveVersionOnClose());

            rReq.Done();

            return;

        }

        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

        case SID_DOCINFO:

        {

            const SfxDocumentInfoItem* pDocInfItem = rReq.GetArg(SID_DOCINFO);

            if ( pDocInfItem )

            {

                // parameter, e.g. from replayed macro

                pDocInfItem->UpdateDocumentInfo(getDocProperties(), true);

                SetUseUserData( pDocInfItem->IsUseUserData() );

                SetUseThumbnailSave( pDocInfItem->IsUseThumbnailSave() );

            }

            else if (const SfxUnoAnyItem* pItem = rReq.GetArg<SfxUnoAnyItem>(FN_PARAM_1))

            {

                uno::Sequence<beans::PropertyValue> aUpdatedProperties;

                pItem->GetValue() >>= aUpdatedProperties;

                SetDocProperties(getDocProperties(), aUpdatedProperties);

            }

            else

            {

                // no argument containing DocInfo; check optional arguments

                bool bReadOnly = IsReadOnly();

                const SfxBoolItem* pROItem = rReq.GetArg(SID_DOC_READONLY);

                if ( pROItem )

                    // override readonly attribute of document

                    // e.g. if a readonly document is saved elsewhere and user asks for editing DocInfo before

                    bReadOnly = pROItem->GetValue();

                // URL for dialog

                const SfxStringItem* pFileSize = rReq.GetArg<SfxStringItem>(FN_PARAM_2);

                sal_Int64 nFileSize = pFileSize ? pFileSize->GetValue().toInt64() : -1;

                const OUString aURL( HasName() ? GetMedium()->GetName() : GetFactory().GetFactoryURL() );

                Reference< XCmisDocument > xCmisDoc( GetModel(), uno::UNO_QUERY );

                uno::Sequence< document::CmisProperty> aCmisProperties = xCmisDoc->getCmisProperties();

                SfxDocumentInfoItem aDocInfoItem( aURL, getDocProperties(), aCmisProperties,

                    IsUseUserData(), IsUseThumbnailSave(), nFileSize );

                const SfxPoolItemHolder aSlotState(GetSlotState(SID_DOCTEMPLATE));

                if (!aSlotState)

                    // templates not supported

                    aDocInfoItem.SetTemplate(false);

                SfxItemSet aSet(SfxItemSet::makeFixedSfxItemSet<SID_DOCINFO, SID_DOCINFO, SID_DOC_READONLY, SID_DOC_READONLY,

                                SID_EXPLORER_PROPS_START, SID_EXPLORER_PROPS_START, SID_BASEURL, SID_BASEURL>

                    (GetPool()));

                aSet.Put( aDocInfoItem );

                aSet.Put( SfxBoolItem( SID_DOC_READONLY, bReadOnly ) );

                aSet.Put( SfxStringItem( SID_EXPLORER_PROPS_START, GetTitle() ) );

                aSet.Put( SfxStringItem( SID_BASEURL, GetMedium()->GetBaseURL() ) );

                // creating dialog is done via virtual method; application will

                // add its own statistics page

                std::shared_ptr<SfxDocumentInfoDialog> xDlg(CreateDocumentInfoDialog(rReq.GetFrameWeld(), aSet));

                auto aFunc = [this, xDlg, xCmisDoc, nFileSize](sal_Int32 nResult, SfxRequest& rRequest)

                {

                    if (RET_OK == nResult)

                    {

                        const SfxDocumentInfoItem* pDocInfoItem = SfxItemSet::GetItem(xDlg->GetOutputItemSet(), SID_DOCINFO, false);

                        if ( pDocInfoItem )

                        {

                            // user has done some changes to DocumentInfo

                            pDocInfoItem->UpdateDocumentInfo(getDocProperties());

                            const uno::Sequence< document::CmisProperty >& aNewCmisProperties =

                                pDocInfoItem->GetCmisProperties( );

                            if ( aNewCmisProperties.hasElements( ) )

                                xCmisDoc->updateCmisProperties( aNewCmisProperties );

                            SetUseUserData( pDocInfoItem->IsUseUserData() );

                            SetUseThumbnailSave( pDocInfoItem-> IsUseThumbnailSave() );

                            // add data from dialog for possible recording purpose

                            rRequest.AppendItem( SfxDocumentInfoItem( GetTitle(),

                                getDocProperties(), aNewCmisProperties, IsUseUserData(), IsUseThumbnailSave(), nFileSize ) );

                        }

                        rRequest.Done();

                    }

                    else

                    {

                        // nothing done; no recording

                        rRequest.Ignore();

                    }

                };

                if (!rReq.IsSynchronCall())

                {

                    std::shared_ptr<SfxRequest> xReq = std::make_shared<SfxRequest>(rReq);

                    SfxTabDialogController::runAsync(xDlg, [xReq=std::move(xReq), aFunc=std::move(aFunc)](sal_Int32 nResult)

                    {

                        aFunc(nResult, *xReq);

                    });

                    rReq.Ignore();

                }

                else

                {

                    aFunc(xDlg->run(), rReq);

                }

            }

            return;

        }

        case SID_AUTOREDACTDOC:

        {

            weld::Window* pDialogParent = GetReqDialogParent(rReq, *this);

            // Actual redaction takes place on a newly generated Draw document

            if (!SvtModuleOptions().IsDrawInstalled())

            {

                std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(

                    pDialogParent, VclMessageType::Warning, VclButtonsType::Ok,

                    SfxResId(STR_REDACTION_NO_DRAW_WARNING)));

                xBox->run();

                return;

            }

            SfxAutoRedactDialog aDlg(pDialogParent);

            sal_Int16 nResult = aDlg.run();

            const SfxBoolItem* redactImage = rReq.GetArg<SfxBoolItem>(SID_REDACT_IMAGE);

            if (redactImage && redactImage->GetValue())

            {

                RedactionTarget redactiontarget({ "Images", RedactionTargetType::REDACTION_TARGET_IMAGE,

                                            "All Images", false, false, 0 });

                aRedactionTargets.push_back({redactiontarget, redactiontarget.sName});

            }

            else if (nResult != RET_OK || !aDlg.hasTargets() || !aDlg.isValidState())

            {

                //Do nothing

                return;

            }

            // else continue with normal redaction

            bIsAutoRedact = true;

            aDlg.getTargets(aRedactionTargets);

            [[fallthrough]];

        }

        case SID_REDACTDOC:

        {

            css::uno::Reference<css::frame::XModel> xModel = GetModel();

            if(!xModel.is())

                return;

            uno::Reference< lang::XComponent > xSourceDoc( xModel );

            // Actual redaction takes place on a newly generated Draw document

            if (!SvtModuleOptions().IsDrawInstalled())

            {

                weld::Window* pDialogParent = GetReqDialogParent(rReq, *this);

                std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(

                    pDialogParent, VclMessageType::Warning, VclButtonsType::Ok,

                    SfxResId(STR_REDACTION_NO_DRAW_WARNING)));

                xBox->run();

                return;

            }

            DocumentToGraphicRenderer aRenderer(xSourceDoc, false);

            // Get the page margins of the original doc

            PageMargins aPageMargins = {-1, -1, -1, -1};

            if (aRenderer.isWriter())

                aPageMargins = SfxRedactionHelper::getPageMarginsForWriter(xModel);

            else if (aRenderer.isCalc())

                aPageMargins = SfxRedactionHelper::getPageMarginsForCalc(xModel);

            sal_Int32 nPages = aRenderer.getPageCount();

            std::vector< GDIMetaFile > aMetaFiles;

            std::vector< ::Size > aPageSizes;

            // Convert the pages of the document to gdimetafiles

            SfxRedactionHelper::getPageMetaFilesFromDoc(aMetaFiles, aPageSizes, nPages, aRenderer);

            // Create an empty Draw component.

            uno::Reference<frame::XDesktop2> xDesktop = css::frame::Desktop::create(comphelper::getProcessComponentContext());

            uno::Reference<lang::XComponent> xComponent = xDesktop->loadComponentFromURL(u"private:factory/sdraw"_ustr, u"_default"_ustr, 0, {});

            if (!xComponent.is())

            {

                SAL_WARN("sfx.doc", "SID_REDACTDOC: Failed to load new draw component. loadComponentFromURL returned an empty reference.");

                return;

            }

            // Add the doc pages to the new draw document

            SfxRedactionHelper::addPagesToDraw(xComponent, nPages, aMetaFiles, aPageSizes, aPageMargins, aRedactionTargets, bIsAutoRedact);

            // Show the Redaction toolbar

            SfxViewFrame* pViewFrame = SfxViewFrame::Current();

            if (!pViewFrame)

                return;

            SfxRedactionHelper::showRedactionToolbar(pViewFrame);

            return;

        }

        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

        case SID_DIRECTEXPORTDOCASPDF:

        {

            uno::Reference< lang::XComponent > xComponent( GetCurrentComponent(), uno::UNO_QUERY );

            if (!xComponent.is())

                return;

            uno::Reference< lang::XServiceInfo > xServiceInfo( xComponent, uno::UNO_QUERY);

            // Redaction finalization takes place in Draw

            if ( xServiceInfo.is() && xServiceInfo->supportsService(u"com.sun.star.drawing.DrawingDocument"_ustr)