    /* -*- 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 <com/sun/star/ui/dialogs/XExecutableDialog.hpp>
    #include <com/sun/star/ui/dialogs/XFilePicker.hpp>
    #include <com/sun/star/ui/dialogs/XFilePickerControlAccess.hpp>
    #include <com/sun/star/ui/dialogs/CommonFilePickerElementIds.hpp>
    #include <com/sun/star/ui/dialogs/ExtendedFilePickerElementIds.hpp>
    #include <com/sun/star/ui/dialogs/TemplateDescription.hpp>
    #include <com/sun/star/view/XSelectionSupplier.hpp>
    #include <com/sun/star/beans/PropertyExistException.hpp>
    #include <com/sun/star/beans/XPropertyAccess.hpp>
    #include <com/sun/star/beans/XPropertySet.hpp>
    #include <com/sun/star/beans/XPropertyContainer.hpp>
    #include <com/sun/star/beans/PropertyAttribute.hpp>
    #include <com/sun/star/document/XExporter.hpp>
    #include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
    #include <com/sun/star/document/XDocumentProperties.hpp>
    #include <com/sun/star/task/ErrorCodeIOException.hpp>
    #include <com/sun/star/task/InteractionHandler.hpp>
    #include <com/sun/star/util/DateTime.hpp>
    #include <com/sun/star/util/URLTransformer.hpp>
    #include <com/sun/star/util/XURLTransformer.hpp>
    #include <com/sun/star/frame/ModuleManager.hpp>
    #include <com/sun/star/frame/XStorable.hpp>
    #include <com/sun/star/frame/XStorable2.hpp>
    #include <com/sun/star/frame/XDispatchProvider.hpp>
    #include <com/sun/star/frame/XDispatch.hpp>
    #include <com/sun/star/frame/XTitle.hpp>
    #include <com/sun/star/util/XModifyListener.hpp>
    #include <com/sun/star/util/XModifiable.hpp>
    #include <com/sun/star/util/XModifyBroadcaster.hpp>

    #include <com/sun/star/util/XCloneable.hpp>
    #include <com/sun/star/io/IOException.hpp>

    #include <guisaveas.hxx>

    #include <sal/log.hxx>
    #include <unotools/pathoptions.hxx>
    #include <svl/itemset.hxx>
    #include <svl/eitem.hxx>
    #include <svl/stritem.hxx>
    #include <svl/intitem.hxx>
    #include <unotools/useroptions.hxx>
    #include <unotools/saveopt.hxx>
    #include <svtools/miscopt.hxx>
    #include <tools/debug.hxx>
    #include <tools/urlobj.hxx>
    #include <comphelper/processfactory.hxx>
    #include <comphelper/propertysequence.hxx>
    #include <comphelper/sequenceashashmap.hxx>
    #include <comphelper/mimeconfighelper.hxx>
    #include <vcl/weld.hxx>
    #include <vcl/window.hxx>
    #include <toolkit/awt/vclxwindow.hxx>
    #include <o3tl/char16_t2wchar_t.hxx>

    #include <sfx2/sfxsids.hrc>
    #include <sfx2/strings.hrc>
    #include <sfx2/sfxresid.hxx>
    #include <sfx2/docfilt.hxx>
    #include <sfx2/filedlghelper.hxx>
    #include <sfx2/asyncfunc.hxx>
    #include <sfx2/app.hxx>
    #include <sfx2/objsh.hxx>
    #include <sfx2/request.hxx>
    #include <sfxtypes.hxx>
    #include <alienwarn.hxx>

    #include <sfx2/docmacromode.hxx>
    #include <com/sun/star/task/ErrorCodeRequest.hpp>
    #include <rtl/ref.hxx>
    #include <framework/interaction.hxx>
    #include <svtools/sfxecode.hxx>

    #include <memory>

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

    #include <officecfg/Office/Common.hxx>

    #include <vcl/FilterConfigItem.hxx>
    #include <com/sun/star/system/SystemShellExecute.hpp>
    #include <com/sun/star/system/SystemShellExecuteFlags.hpp>

    #include <osl/file.hxx>

    #ifdef _WIN32
    #include <Shlobj.h>
    #ifdef GetTempPath
    #undef GetTempPath
    #endif
    #endif

    // flags that specify requested operation
    #define EXPORT_REQUESTED            1
    #define PDFEXPORT_REQUESTED         2
    #define PDFDIRECTEXPORT_REQUESTED   4
    #define WIDEEXPORT_REQUESTED        8
    #define SAVE_REQUESTED              16
    #define SAVEAS_REQUESTED            32
    #define SAVEACOPY_REQUESTED         64
    #define EPUBEXPORT_REQUESTED       128
    #define EPUBDIRECTEXPORT_REQUESTED 256
    #define SAVEASREMOTE_REQUESTED      -1

    // possible statuses of save operation
    #define STATUS_NO_ACTION            0
    #define STATUS_SAVE                 1
    #define STATUS_SAVEAS               2
    #define STATUS_SAVEAS_STANDARDNAME  3

    const char aFilterNameString[] = "FilterName";
    const char aFilterOptionsString[] = "FilterOptions";
    const char aFilterDataString[] = "FilterData";

    using namespace ::com::sun::star;
    using namespace css::system;

    namespace {

    sal_uInt16 getSlotIDFromMode( sal_Int16 nStoreMode )
    {
        // This is a temporary hardcoded solution must be removed when
        // dialogs do not need parameters in SidSet representation any more

        sal_uInt16 nResult = 0;
        if ( nStoreMode == EXPORT_REQUESTED || nStoreMode == ( EXPORT_REQUESTED | SAVEACOPY_REQUESTED | WIDEEXPORT_REQUESTED ) )
            nResult = SID_EXPORTDOC;
        else if ( nStoreMode == ( EXPORT_REQUESTED | PDFEXPORT_REQUESTED ) )
            nResult = SID_EXPORTDOCASPDF;
        else if ( nStoreMode == ( EXPORT_REQUESTED | EPUBEXPORT_REQUESTED ) )
            nResult = SID_EXPORTDOCASEPUB;
        else if ( nStoreMode == ( EXPORT_REQUESTED | PDFEXPORT_REQUESTED | PDFDIRECTEXPORT_REQUESTED ) )
            nResult = SID_DIRECTEXPORTDOCASPDF;
        else if ( nStoreMode == ( EXPORT_REQUESTED | EPUBEXPORT_REQUESTED | EPUBDIRECTEXPORT_REQUESTED ) )
            nResult = SID_DIRECTEXPORTDOCASEPUB;
        else if ( nStoreMode == SAVEAS_REQUESTED || nStoreMode == ( EXPORT_REQUESTED | WIDEEXPORT_REQUESTED ) )
            nResult = SID_SAVEASDOC;
        else if ( nStoreMode == SAVEASREMOTE_REQUESTED )
            nResult = SID_SAVEASREMOTE;
        else {
            SAL_WARN( "sfx.doc", "Unacceptable slot name is provided!" );
        }

        return nResult;
    }

    sal_Int16 getStoreModeFromSlotName( const OUString& aSlotName )
    {
        sal_Int16 nResult = 0;
        if ( aSlotName == "ExportTo" )
            nResult = EXPORT_REQUESTED;
        else if ( aSlotName == "ExportToPDF" )
            nResult = EXPORT_REQUESTED | PDFEXPORT_REQUESTED;
        else if ( aSlotName == "ExportDirectToPDF" )
            nResult = EXPORT_REQUESTED | PDFEXPORT_REQUESTED | PDFDIRECTEXPORT_REQUESTED;
        else if ( aSlotName == "ExportToEPUB" )
            nResult = EXPORT_REQUESTED | EPUBEXPORT_REQUESTED;
        else if ( aSlotName == "ExportDirectToEPUB" )
            nResult = EXPORT_REQUESTED | EPUBEXPORT_REQUESTED | EPUBDIRECTEXPORT_REQUESTED;
        else if ( aSlotName == "Save" )
            nResult = SAVE_REQUESTED;
        else if ( aSlotName == "SaveAs" )
            nResult = SAVEAS_REQUESTED;
        else if ( aSlotName == "SaveAsRemote" )
            nResult = SAVEASREMOTE_REQUESTED;
        else
            throw task::ErrorCodeIOException(
                ("getStoreModeFromSlotName(\"" + aSlotName
                 + "): ERRCODE_IO_INVALIDPARAMETER"),
                uno::Reference< uno::XInterface >(), sal_uInt32(ERRCODE_IO_INVALIDPARAMETER) );

        return nResult;
    }

    SfxFilterFlags getMustFlags( sal_Int16 nStoreMode )
    {
        return ( SfxFilterFlags::EXPORT
                | ( ( ( nStoreMode & EXPORT_REQUESTED ) && !( nStoreMode & WIDEEXPORT_REQUESTED ) ) ? SfxFilterFlags::NONE : SfxFilterFlags::IMPORT ) );
    }

    SfxFilterFlags getDontFlags( sal_Int16 nStoreMode )
    {
        return ( SfxFilterFlags::INTERNAL
                | SfxFilterFlags::NOTINFILEDLG
                | ( ( ( nStoreMode & EXPORT_REQUESTED ) && !( nStoreMode & WIDEEXPORT_REQUESTED ) ) ? SfxFilterFlags::IMPORT : SfxFilterFlags::NONE ) );
    }

    // class DocumentSettingsGuard

    class DocumentSettingsGuard
    {
        uno::Reference< beans::XPropertySet > m_xDocumentSettings;
        bool m_bPreserveReadOnly;
        bool m_bReadOnlySupported;

        bool m_bRestoreSettings;
    public:
        DocumentSettingsGuard( const uno::Reference< frame::XModel >& xModel, bool bReadOnly, bool bRestore )
        : m_bPreserveReadOnly( false )
        , m_bReadOnlySupported( false )
        , m_bRestoreSettings( bRestore )
        {
            try
            {
                uno::Reference< lang::XMultiServiceFactory > xDocSettingsSupplier( xModel, uno::UNO_QUERY_THROW );
                m_xDocumentSettings.set(
                    xDocSettingsSupplier->createInstance( "com.sun.star.document.Settings" ),
                    uno::UNO_QUERY_THROW );

                OUString aLoadReadonlyString( "LoadReadonly" );

                try
                {
                    m_xDocumentSettings->getPropertyValue( aLoadReadonlyString ) >>= m_bPreserveReadOnly;
                    m_xDocumentSettings->setPropertyValue( aLoadReadonlyString, uno::makeAny( bReadOnly ) );
                    m_bReadOnlySupported = true;
                }
                catch( const uno::Exception& )
                {}
            }
            catch( const uno::Exception& )
            {}

            if ( bReadOnly && !m_bReadOnlySupported )
                throw uno::RuntimeException(); // the user could provide the data, so it must be stored
        }

        ~DocumentSettingsGuard()
        {
            if ( m_bRestoreSettings )
            {
                try
                {
                    if ( m_bReadOnlySupported )
                        m_xDocumentSettings->setPropertyValue( "LoadReadonly", uno::makeAny( m_bPreserveReadOnly ) );
                }
                catch( const uno::Exception& )
                {
                    OSL_FAIL( "Unexpected exception!" );
                }
            }
        }
    };
    } // anonymous namespace

    // class ModelData_Impl

    class ModelData_Impl
    {
        SfxStoringHelper* m_pOwner;
        uno::Reference< frame::XModel > m_xModel;
        uno::Reference< frame::XStorable > m_xStorable;
        uno::Reference< frame::XStorable2 > m_xStorable2;

        OUString m_aModuleName;
        std::unique_ptr<::comphelper::SequenceAsHashMap> m_pDocumentPropsHM;
        std::unique_ptr<::comphelper::SequenceAsHashMap> m_pModulePropsHM;

        ::comphelper::SequenceAsHashMap m_aMediaDescrHM;

        bool m_bRecommendReadOnly;

    public:
        ModelData_Impl( SfxStoringHelper& aOwner,
                        const uno::Reference< frame::XModel >& xModel,
                        const uno::Sequence< beans::PropertyValue >& aMediaDescr );

        ~ModelData_Impl();

        void FreeDocumentProps();

        uno::Reference< frame::XModel > const & GetModel();
        uno::Reference< frame::XStorable > const & GetStorable();
        uno::Reference< frame::XStorable2 > const & GetStorable2();

        ::comphelper::SequenceAsHashMap& GetMediaDescr() { return m_aMediaDescrHM; }

        bool IsRecommendReadOnly() const { return m_bRecommendReadOnly; }

        const ::comphelper::SequenceAsHashMap& GetDocProps();

        OUString const & GetModuleName();
        const ::comphelper::SequenceAsHashMap& GetModuleProps();

        void CheckInteractionHandler();

        OUString GetDocServiceName();
        uno::Sequence< beans::PropertyValue > GetDocServiceDefaultFilterCheckFlags( SfxFilterFlags nMust, SfxFilterFlags nDont );
        uno::Sequence< beans::PropertyValue > GetDocServiceAnyFilter( SfxFilterFlags nMust, SfxFilterFlags nDont );
        uno::Sequence< beans::PropertyValue > GetPreselectedFilter_Impl( sal_Int16 nStoreMode );
        uno::Sequence< beans::PropertyValue > GetDocServiceDefaultFilter();

        bool ExecuteFilterDialog_Impl( const OUString& aFilterName );

        sal_Int8 CheckSaveAcceptable( sal_Int8 nCurStatus );
        sal_Int8 CheckStateForSave();

        sal_Int8 CheckFilter( const OUString& );

        bool CheckFilterOptionsDialogExistence();

        bool OutputFileDialog( sal_Int16 nStoreMode,
                                    const ::comphelper::SequenceAsHashMap& aPreselectedFilterPropsHM,
                                    bool bSetStandardName,
                                    OUString& aSuggestedName,
                                    bool bPreselectPassword,
                                    OUString& aSuggestedDir,
                                    sal_Int16 nDialog,
                                    const OUString& rStandardDir,
                                    const css::uno::Sequence< OUString >& rBlackList
                                    );

        bool ShowDocumentInfoDialog(const std::function< void () >&);

        static OUString GetRecommendedExtension( const OUString& aTypeName );
        OUString GetRecommendedDir( const OUString& aSuggestedDir );
        OUString GetRecommendedName( const OUString& aSuggestedName,
                                            const OUString& aTypeName );

    };

    ModelData_Impl::ModelData_Impl( SfxStoringHelper& aOwner,
                                    const uno::Reference< frame::XModel >& xModel,
                                    const uno::Sequence< beans::PropertyValue >& aMediaDescr )
    : m_pOwner( &aOwner )
    , m_xModel( xModel )
    , m_aMediaDescrHM( aMediaDescr )
    , m_bRecommendReadOnly( false )
    {
        CheckInteractionHandler();
        try
        {
            uno::Reference< lang::XComponent > xCurrentComponent = frame::Desktop::create( comphelper::getProcessComponentContext() )->getCurrentComponent();
            if (aOwner.GetModuleManager()->identify(xCurrentComponent) == "com.sun.star.chart2.ChartDocument")
            {
                // let us switch the model and set the xStorable and
                // XStorable2 to the old model.
                // This is an ugly hack because we have no SfxObjectShell for chart2 yet.
                // We need SfxObjectShell for the heavy work around ODF document creation
                // because chart2 only writes the basic stream out.
                // In future in might make sense to implement a full scale object shell in
                // chart2 and make chart2 an own program.
                m_xModel.set(xCurrentComponent, uno::UNO_QUERY_THROW );
                m_xStorable.set(xModel, uno::UNO_QUERY_THROW );
                m_xStorable2.set(xModel, uno::UNO_QUERY_THROW );
            }
        }
        catch(...)
        {
            // we don't want to pass on any errors;
        }
    }

    ModelData_Impl::~ModelData_Impl()
    {
        FreeDocumentProps();
        m_pDocumentPropsHM.reset();
        m_pModulePropsHM.reset();
    }

    void ModelData_Impl::FreeDocumentProps()
    {
        m_pDocumentPropsHM.reset();
    }

    uno::Reference< frame::XModel > const & ModelData_Impl::GetModel()
    {
        if ( !m_xModel.is() )
            throw uno::RuntimeException();

        return m_xModel;
    }

    uno::Reference< frame::XStorable > const & ModelData_Impl::GetStorable()
    {
        if ( !m_xStorable.is() )
        {
            m_xStorable.set( m_xModel, uno::UNO_QUERY_THROW );
        }

        return m_xStorable;
    }

    uno::Reference< frame::XStorable2 > const & ModelData_Impl::GetStorable2()
    {
        if ( !m_xStorable2.is() )
        {
            m_xStorable2.set( m_xModel, uno::UNO_QUERY_THROW );
        }

        return m_xStorable2;
    }

    const ::comphelper::SequenceAsHashMap& ModelData_Impl::GetDocProps()
    {
        if ( !m_pDocumentPropsHM )
            m_pDocumentPropsHM.reset( new ::comphelper::SequenceAsHashMap( GetModel()->getArgs() ) );

        return *m_pDocumentPropsHM;
    }

    OUString const & ModelData_Impl::GetModuleName()
    {
        if ( m_aModuleName.isEmpty() )
        {
            m_aModuleName = m_pOwner->GetModuleManager()->identify(
                                                    uno::Reference< uno::XInterface >( m_xModel, uno::UNO_QUERY ) );
            if ( m_aModuleName.isEmpty() )
                throw uno::RuntimeException(); // TODO:
        }
        return m_aModuleName;
    }

    const ::comphelper::SequenceAsHashMap& ModelData_Impl::GetModuleProps()
    {
        if ( !m_pModulePropsHM )
        {
            uno::Sequence< beans::PropertyValue > aModuleProps;
            m_pOwner->GetModuleManager()->getByName( GetModuleName() ) >>= aModuleProps;
            if ( !aModuleProps.getLength() )
                throw uno::RuntimeException(); // TODO;
            m_pModulePropsHM.reset( new ::comphelper::SequenceAsHashMap( aModuleProps ) );
        }

        return *m_pModulePropsHM;
    }

    OUString ModelData_Impl::GetDocServiceName()
    {
        return GetModuleProps().getUnpackedValueOrDefault("ooSetupFactoryDocumentService", OUString());
    }

    void ModelData_Impl::CheckInteractionHandler()
    {
        const OUString sInteractionHandler {"InteractionHandler"};
        ::comphelper::SequenceAsHashMap::const_iterator aInteractIter =
                m_aMediaDescrHM.find( sInteractionHandler );

        if ( aInteractIter == m_aMediaDescrHM.end() )
        {
            try {
                m_aMediaDescrHM[ sInteractionHandler ]
                    <<= task::InteractionHandler::createWithParent( comphelper::getProcessComponentContext(), nullptr);
            }
            catch( const uno::Exception& )
            {
            }
        }
        else
        {
            uno::Reference< task::XInteractionHandler > xInteract;
            DBG_ASSERT( ( aInteractIter->second >>= xInteract ) && xInteract.is(), "Broken interaction handler is provided!\n" );
        }
    }

    uno::Sequence< beans::PropertyValue > ModelData_Impl::GetDocServiceDefaultFilter()
    {
        uno::Sequence< beans::PropertyValue > aProps;

        const OUString aFilterName = GetModuleProps().getUnpackedValueOrDefault( "ooSetupFactoryDefaultFilter", OUString() );

        m_pOwner->GetFilterConfiguration()->getByName( aFilterName ) >>= aProps;

        return aProps;
    }

    uno::Sequence< beans::PropertyValue > ModelData_Impl::GetDocServiceDefaultFilterCheckFlags( SfxFilterFlags nMust,
                                                                                                SfxFilterFlags nDont )
    {
        uno::Sequence< beans::PropertyValue > aFilterProps;
        uno::Sequence< beans::PropertyValue > aProps = GetDocServiceDefaultFilter();
        if ( aProps.getLength() )
        {
            ::comphelper::SequenceAsHashMap aFiltHM( aProps );
            SfxFilterFlags nFlags = static_cast<SfxFilterFlags>(aFiltHM.getUnpackedValueOrDefault("Flags",
                                                            sal_Int32(0) ));
            if ( ( ( nFlags & nMust ) == nMust ) && !( nFlags & nDont ) )
                aFilterProps = aProps;
        }

        return aFilterProps;
    }

    uno::Sequence< beans::PropertyValue > ModelData_Impl::GetDocServiceAnyFilter( SfxFilterFlags nMust, SfxFilterFlags nDont )
    {
        uno::Sequence< beans::NamedValue > aSearchRequest { { "DocumentService", css::uno::makeAny(GetDocServiceName()) } };

        return ::comphelper::MimeConfigurationHelper::SearchForFilter( m_pOwner->GetFilterQuery(), aSearchRequest, nMust, nDont );
    }

    uno::Sequence< beans::PropertyValue > ModelData_Impl::GetPreselectedFilter_Impl( sal_Int16 nStoreMode )
    {
        if ( nStoreMode == SAVEASREMOTE_REQUESTED )
            nStoreMode = SAVEAS_REQUESTED;

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

        SfxFilterFlags nMust = getMustFlags( nStoreMode );
        SfxFilterFlags nDont = getDontFlags( nStoreMode );

        if ( ( nStoreMode != SAVEASREMOTE_REQUESTED ) && ( nStoreMode & PDFEXPORT_REQUESTED ) )
        {
            // Preselect PDF-Filter for EXPORT
            uno::Sequence< beans::NamedValue > aSearchRequest
            {
                { "Type", css::uno::makeAny(OUString("pdf_Portable_Document_Format")) },
                { "DocumentService", css::uno::makeAny(GetDocServiceName()) }
            };

            aFilterProps = ::comphelper::MimeConfigurationHelper::SearchForFilter( m_pOwner->GetFilterQuery(), aSearchRequest, nMust, nDont );
        }
        else if ( ( nStoreMode != SAVEASREMOTE_REQUESTED ) && ( nStoreMode & EPUBEXPORT_REQUESTED ) )
        {
            // Preselect EPUB filter for export.
            uno::Sequence<beans::NamedValue> aSearchRequest
            {
                { "Type", css::uno::makeAny(OUString("writer_EPUB_Document")) },
                { "DocumentService", css::uno::makeAny(GetDocServiceName()) }
            };

            aFilterProps = ::comphelper::MimeConfigurationHelper::SearchForFilter( m_pOwner->GetFilterQuery(), aSearchRequest, nMust, nDont );
        }
        else
        {
            aFilterProps = GetDocServiceDefaultFilterCheckFlags( nMust, nDont );

            if ( !aFilterProps.getLength() )
            {
                // the default filter was not found, use just the first acceptable one
                aFilterProps = GetDocServiceAnyFilter( nMust, nDont );
            }
        }

        return aFilterProps;
    }

    bool ModelData_Impl::ExecuteFilterDialog_Impl( const OUString& aFilterName )
    {
        bool bDialogUsed = false;

        try {
            uno::Sequence < beans::PropertyValue > aProps;
            uno::Any aAny = m_pOwner->GetFilterConfiguration()->getByName( aFilterName );
            if ( aAny >>= aProps )
            {
                const sal_Int32 nPropertyCount = aProps.getLength();
                for( sal_Int32 nProperty=0; nProperty < nPropertyCount; ++nProperty )
                {
                    if( aProps[nProperty].Name == "UIComponent" )
                    {
                        OUString aServiceName;
                        aProps[nProperty].Value >>= aServiceName;
                        if( !aServiceName.isEmpty() )
                        {
                            uno::Sequence<uno::Any> aDialogArgs(comphelper::InitAnyPropertySequence(
                            {
                                {"ParentWindow", uno::Any(SfxStoringHelper::GetModelXWindow(m_xModel))},
                            }));

                            uno::Reference< ui::dialogs::XExecutableDialog > xFilterDialog(
                                                        comphelper::getProcessServiceFactory()->createInstanceWithArguments(aServiceName, aDialogArgs), uno::UNO_QUERY );
                            uno::Reference< beans::XPropertyAccess > xFilterProperties( xFilterDialog, uno::UNO_QUERY );

                            if( xFilterDialog.is() && xFilterProperties.is() )
                            {
                                bDialogUsed = true;

                                uno::Reference< document::XExporter > xExporter( xFilterDialog, uno::UNO_QUERY );
                                if( xExporter.is() )
                                    xExporter->setSourceDocument(
                                        uno::Reference< lang::XComponent >( GetModel(), uno::UNO_QUERY ) );

                                uno::Sequence< beans::PropertyValue > aPropsForDialog;
                                GetMediaDescr() >> aPropsForDialog;
                                xFilterProperties->setPropertyValues( aPropsForDialog );

                                if( !xFilterDialog->execute() )
                                {
                                    throw task::ErrorCodeIOException(
                                        ("ModelData_Impl::ExecuteFilterDialog_Impl:"
                                         " ERRCODE_IO_ABORT"),
                                        uno::Reference< uno::XInterface >(),
                                        sal_uInt32(ERRCODE_IO_ABORT));
                                }

                                uno::Sequence< beans::PropertyValue > aPropsFromDialog =
                                                                            xFilterProperties->getPropertyValues();
                                const sal_Int32 nPropsLen {aPropsFromDialog.getLength()};
                                for ( sal_Int32 nInd = 0; nInd < nPropsLen; ++nInd )
                                    GetMediaDescr()[aPropsFromDialog[nInd].Name] = aPropsFromDialog[nInd].Value;
                            }
                        }

                        break;
                    }
                }
            }
        }
        catch( const container::NoSuchElementException& e )
        {
            // the filter name is unknown
            throw task::ErrorCodeIOException(
                ("ModelData_Impl::ExecuteFilterDialog_Impl: NoSuchElementException"
                 " \"" + e.Message + "\": ERRCODE_IO_ABORT"),
                uno::Reference< uno::XInterface >(), sal_uInt32(ERRCODE_IO_INVALIDPARAMETER));
        }
        catch( const task::ErrorCodeIOException& )
        {
            throw;
        }
        catch( const uno::Exception& e )
        {
            SAL_WARN("sfx.doc", "ignoring " << e);
        }

        return bDialogUsed;
    }

    sal_Int8 ModelData_Impl::CheckSaveAcceptable( sal_Int8 nCurStatus )
    {
        sal_Int8 nResult = nCurStatus;

        if ( nResult != STATUS_NO_ACTION && GetStorable()->hasLocation() )
        {
            // the saving is acceptable
            // in case the configuration entry is not set or set to false
            // or in case of version creation
            if ( officecfg::Office::Common::Save::Document::AlwaysSaveAs::get()
              && GetMediaDescr().find( OUString("VersionComment") ) == GetMediaDescr().end() )
            {
                // notify the user that SaveAs is going to be done
                vcl::Window* pWin = SfxStoringHelper::GetModelWindow(m_xModel);
                std::unique_ptr<weld::MessageDialog> xMessageBox(Application::CreateMessageDialog(pWin ? pWin->GetFrameWeld() : nullptr,
                                                                 VclMessageType::Question, VclButtonsType::OkCancel, SfxResId(STR_NEW_FILENAME_SAVE)));
                if (xMessageBox->run() == RET_OK)
                    nResult = STATUS_SAVEAS;
                else
                    nResult = STATUS_NO_ACTION;
            }
        }

        return nResult;
    }

    sal_Int8 ModelData_Impl::CheckStateForSave()
    {
        // if the document is readonly or a new one a SaveAs operation must be used
        if ( !GetStorable()->hasLocation() || GetStorable()->isReadonly() )
            return STATUS_SAVEAS;

        // check acceptable entries for media descriptor
        ::comphelper::SequenceAsHashMap aAcceptedArgs;

        const OUString aVersionCommentString("VersionComment");
        const OUString aAuthorString("Author");
        const OUString aDontTerminateEdit("DontTerminateEdit");
        const OUString aInteractionHandlerString("InteractionHandler");
        const OUString aStatusIndicatorString("StatusIndicator");
        const OUString aFailOnWarningString("FailOnWarning");
        const OUString aNoFileSync("NoFileSync");

        if ( GetMediaDescr().find( aVersionCommentString ) != GetMediaDescr().end() )
            aAcceptedArgs[ aVersionCommentString ] = GetMediaDescr()[ aVersionCommentString ];
        if ( GetMediaDescr().find( aAuthorString ) != GetMediaDescr().end() )
            aAcceptedArgs[ aAuthorString ] = GetMediaDescr()[ aAuthorString ];
        if ( GetMediaDescr().find( aDontTerminateEdit ) != GetMediaDescr().end() )
            aAcceptedArgs[ aDontTerminateEdit ] = GetMediaDescr()[ aDontTerminateEdit ];
        if ( GetMediaDescr().find( aInteractionHandlerString ) != GetMediaDescr().end() )
            aAcceptedArgs[ aInteractionHandlerString ] = GetMediaDescr()[ aInteractionHandlerString ];
        if ( GetMediaDescr().find( aStatusIndicatorString ) != GetMediaDescr().end() )
            aAcceptedArgs[ aStatusIndicatorString ] = GetMediaDescr()[ aStatusIndicatorString ];
        if ( GetMediaDescr().find( aFailOnWarningString ) != GetMediaDescr().end() )
            aAcceptedArgs[ aFailOnWarningString ] = GetMediaDescr()[ aFailOnWarningString ];
        if (GetMediaDescr().find(aNoFileSync) != GetMediaDescr().end())
            aAcceptedArgs[aNoFileSync] = GetMediaDescr()[aNoFileSync];

        // remove unacceptable entry if there is any
        DBG_ASSERT( GetMediaDescr().size() == aAcceptedArgs.size(),
                    "Unacceptable parameters are provided in Save request!\n" );
        if ( GetMediaDescr().size() != aAcceptedArgs.size() )
            GetMediaDescr() = aAcceptedArgs;

        // check that the old filter is acceptable
        return CheckFilter( GetDocProps().getUnpackedValueOrDefault(aFilterNameString, OUString()) );
    }

    sal_Int8 ModelData_Impl::CheckFilter( const OUString& aFilterName )
    {
        ::comphelper::SequenceAsHashMap aFiltPropsHM;
        SfxFilterFlags nFiltFlags = SfxFilterFlags::NONE;
        if ( !aFilterName.isEmpty() )
        {
            // get properties of filter
            uno::Sequence< beans::PropertyValue > aFilterProps;
            m_pOwner->GetFilterConfiguration()->getByName( aFilterName ) >>= aFilterProps;

            aFiltPropsHM = ::comphelper::SequenceAsHashMap( aFilterProps );
            nFiltFlags = static_cast<SfxFilterFlags>(aFiltPropsHM.getUnpackedValueOrDefault("Flags", sal_Int32(0) ));
        }

        // only a temporary solution until default filter retrieving feature is implemented
        // then GetDocServiceDefaultFilter() must be used
        ::comphelper::SequenceAsHashMap aDefFiltPropsHM = GetDocServiceDefaultFilterCheckFlags( SfxFilterFlags::IMPORT | SfxFilterFlags::EXPORT, SfxFilterFlags::NONE );
        SfxFilterFlags nDefFiltFlags = static_cast<SfxFilterFlags>(aDefFiltPropsHM.getUnpackedValueOrDefault("Flags", sal_Int32(0) ));

        // if the old filter is not acceptable
        // and there is no default filter or it is not acceptable for requested parameters then proceed with saveAs
        if ( ( aFiltPropsHM.empty() || !( nFiltFlags & SfxFilterFlags::EXPORT ) )
          && ( aDefFiltPropsHM.empty() || !( nDefFiltFlags & SfxFilterFlags::EXPORT ) || nDefFiltFlags & SfxFilterFlags::INTERNAL ) )
            return STATUS_SAVEAS;

        // so at this point there is either an acceptable old filter or default one
        if ( aFiltPropsHM.empty() || !( nFiltFlags & SfxFilterFlags::EXPORT ) )
        {
            // so the default filter must be acceptable
            return STATUS_SAVEAS_STANDARDNAME;
        }
        else if ( ( !( nFiltFlags & SfxFilterFlags::OWN ) || ( nFiltFlags & SfxFilterFlags::ALIEN ) )
               && !aDefFiltPropsHM.empty()
               && ( nDefFiltFlags & SfxFilterFlags::EXPORT ) && !( nDefFiltFlags & SfxFilterFlags::INTERNAL ))
        {
            // the default filter is acceptable and the old filter is alien one
            // so ask to make a saveAs operation
            const OUString aUIName = aFiltPropsHM.getUnpackedValueOrDefault("UIName", OUString() );
            const OUString aDefUIName = aDefFiltPropsHM.getUnpackedValueOrDefault("UIName", OUString() );
            const OUString aPreusedFilterName = GetDocProps().getUnpackedValueOrDefault("PreusedFilterName", OUString() );
            const OUString aDefType = aDefFiltPropsHM.getUnpackedValueOrDefault( "Type", OUString() );
            const OUString aDefExtension = GetRecommendedExtension( aDefType );

            if ( aPreusedFilterName != aFilterName && aUIName != aDefUIName )
            {
                if ( !SfxStoringHelper::WarnUnacceptableFormat( GetModel(), aUIName, aDefExtension,
                                                                static_cast<bool>( nDefFiltFlags & SfxFilterFlags::ALIEN ) ) )
                    return STATUS_SAVEAS_STANDARDNAME;
            }
        }

        return STATUS_SAVE;
    }

    bool ModelData_Impl::CheckFilterOptionsDialogExistence()
    {
        uno::Sequence< beans::NamedValue > aSearchRequest { { "DocumentService", css::uno::makeAny(GetDocServiceName()) } };

        uno::Reference< container::XEnumeration > xFilterEnum =
                                        m_pOwner->GetFilterQuery()->createSubSetEnumerationByProperties( aSearchRequest );

        while ( xFilterEnum->hasMoreElements() )
        {
            uno::Sequence< beans::PropertyValue > aProps;
            if ( xFilterEnum->nextElement() >>= aProps )
            {
                ::comphelper::SequenceAsHashMap aPropsHM( aProps );
                if ( !aPropsHM.getUnpackedValueOrDefault("UIComponent", OUString()).isEmpty() )
                    return true;
            }
        }

        return false;
    }

    bool ModelData_Impl::OutputFileDialog( sal_Int16 nStoreMode,
                                                const ::comphelper::SequenceAsHashMap& aPreselectedFilterPropsHM,
                                                bool bSetStandardName,
                                                OUString& aSuggestedName,
                                                bool bPreselectPassword,
                                                OUString& aSuggestedDir,
                                                sal_Int16 nDialog,
                                                const OUString& rStandardDir,
                                                const css::uno::Sequence< OUString >& rBlackList)
    {
        if ( nStoreMode == SAVEASREMOTE_REQUESTED )
            nStoreMode = SAVEAS_REQUESTED;

        bool bUseFilterOptions = false;

        ::comphelper::SequenceAsHashMap::const_iterator aOverwriteIter =
                    GetMediaDescr().find( OUString("Overwrite") );

        // the file name must be specified if overwrite option is set
        if ( aOverwriteIter != GetMediaDescr().end() )
               throw task::ErrorCodeIOException(
                   "ModelData_Impl::OutputFileDialog: ERRCODE_IO_INVALIDPARAMETER",
                   uno::Reference< uno::XInterface >(),
                   sal_uInt32(ERRCODE_IO_INVALIDPARAMETER));

        // no target file name is specified
        // we need to show the file dialog

        // check if we have a filter which allows for filter options, so we need a corresponding checkbox in the dialog
        bool bAllowOptions = false;

        // in case of Export, filter options dialog is used if available
        if( !( nStoreMode & EXPORT_REQUESTED ) || ( nStoreMode & WIDEEXPORT_REQUESTED ) )
            bAllowOptions = CheckFilterOptionsDialogExistence();

        // get the filename by dialog ...
        // create the file dialog
        sal_Int16  aDialogMode = bAllowOptions
            ? css::ui::dialogs::TemplateDescription::FILESAVE_AUTOEXTENSION_PASSWORD_FILTEROPTIONS
            : css::ui::dialogs::TemplateDescription::FILESAVE_AUTOEXTENSION_PASSWORD;
        FileDialogFlags aDialogFlags = FileDialogFlags::NONE;

        if( ( nStoreMode & EXPORT_REQUESTED ) && !( nStoreMode & WIDEEXPORT_REQUESTED ) )
        {
            if ( (nStoreMode & PDFEXPORT_REQUESTED) || (nStoreMode & EPUBEXPORT_REQUESTED) )
                aDialogMode = css::ui::dialogs::TemplateDescription::
                    FILESAVE_AUTOEXTENSION;
            else
                aDialogMode = css::ui::dialogs::TemplateDescription::
                    FILESAVE_AUTOEXTENSION_SELECTION;
            aDialogFlags = FileDialogFlags::Export;
        }

        if( ( nStoreMode & EXPORT_REQUESTED ) && ( nStoreMode & SAVEACOPY_REQUESTED ) && ( nStoreMode & WIDEEXPORT_REQUESTED ) )
        {
            aDialogFlags = FileDialogFlags::SaveACopy;
        }

        std::unique_ptr<sfx2::FileDialogHelper> pFileDlg;

        const OUString aDocServiceName {GetDocServiceName()};
        DBG_ASSERT( !aDocServiceName.isEmpty(), "No document service for this module set!" );

        SfxFilterFlags nMust = getMustFlags( nStoreMode );
        SfxFilterFlags nDont = getDontFlags( nStoreMode );
        sfx2::FileDialogHelper::Context eCtxt = sfx2::FileDialogHelper::UNKNOWN_CONTEXT;
        vcl::Window* pWin = SfxStoringHelper::GetModelWindow( m_xModel );
        weld::Window* pFrameWin = pWin ? pWin->GetFrameWeld() : nullptr;
        if ( ( nStoreMode & EXPORT_REQUESTED ) && !( nStoreMode & WIDEEXPORT_REQUESTED ) )
        {
            if ( ( nStoreMode & PDFEXPORT_REQUESTED ) && !aPreselectedFilterPropsHM.empty() )
            {
                // this is a PDF export
                // the filter options has been shown already
                const OUString aFilterUIName = aPreselectedFilterPropsHM.getUnpackedValueOrDefault( "UIName", OUString() );
                pFileDlg.reset(new sfx2::FileDialogHelper( aDialogMode, aDialogFlags, aFilterUIName, "pdf", rStandardDir, rBlackList, pFrameWin ));
                pFileDlg->SetCurrentFilter( aFilterUIName );
            }
            else if ((nStoreMode & EPUBEXPORT_REQUESTED) && !aPreselectedFilterPropsHM.empty())
            {
                // This is an EPUB export, the filter options has been shown already.
                const OUString aFilterUIName = aPreselectedFilterPropsHM.getUnpackedValueOrDefault( "UIName", OUString() );
                pFileDlg.reset(new sfx2::FileDialogHelper(aDialogMode, aDialogFlags, aFilterUIName, "epub", rStandardDir, rBlackList, pFrameWin));
                pFileDlg->SetCurrentFilter(aFilterUIName);
            }
            else
            {
                // This is the normal dialog
                pFileDlg.reset(new sfx2::FileDialogHelper( aDialogMode, aDialogFlags, aDocServiceName, nDialog, nMust, nDont, rStandardDir, rBlackList, pFrameWin ));
            }

            if ( aDocServiceName == "com.sun.star.drawing.DrawingDocument" )
                eCtxt = sfx2::FileDialogHelper::SD_EXPORT;
            else if ( aDocServiceName == "com.sun.star.presentation.PresentationDocument" )
                eCtxt = sfx2::FileDialogHelper::SI_EXPORT;
            else if ( aDocServiceName == "com.sun.star.text.TextDocument" )
                eCtxt = sfx2::FileDialogHelper::SW_EXPORT;

            if ( eCtxt != sfx2::FileDialogHelper::UNKNOWN_CONTEXT )
                   pFileDlg->SetContext( eCtxt );

            pFileDlg->CreateMatcher( aDocServiceName );

            uno::Reference< ui::dialogs::XFilePicker3 > xFilePicker = pFileDlg->GetFilePicker();
            uno::Reference< ui::dialogs::XFilePickerControlAccess > xControlAccess =
            uno::Reference< ui::dialogs::XFilePickerControlAccess >( xFilePicker, uno::UNO_QUERY );

            if ( xControlAccess.is() )
            {
                xControlAccess->setLabel( ui::dialogs::CommonFilePickerElementIds::PUSHBUTTON_OK, SfxResId(STR_EXPORTBUTTON) );
                xControlAccess->setLabel( ui::dialogs::CommonFilePickerElementIds::LISTBOX_FILTER_LABEL, SfxResId(STR_LABEL_FILEFORMAT) );
            }
        }
        else
        {
            // This is the normal dialog
            pFileDlg.reset(new sfx2::FileDialogHelper( aDialogMode, aDialogFlags, aDocServiceName, nDialog,
                nMust, nDont, rStandardDir, rBlackList, pFrameWin ));
            pFileDlg->CreateMatcher( aDocServiceName );
        }

        OUString aAdjustToType;

        const OUString sFilterNameString(aFilterNameString);

        if ( ( nStoreMode & EXPORT_REQUESTED ) && !( nStoreMode & WIDEEXPORT_REQUESTED ) )
        {
            // it is export, set the preselected filter
            pFileDlg->SetCurrentFilter( aPreselectedFilterPropsHM.getUnpackedValueOrDefault( "UIName", OUString() ) );
            aAdjustToType = aPreselectedFilterPropsHM.getUnpackedValueOrDefault( "Type", OUString() );
        }
        // it is no export, bSetStandardName == true means that user agreed to store document in the default (default default ;-)) format
        else if ( bSetStandardName || GetStorable()->hasLocation() )
        {
            uno::Sequence< beans::PropertyValue > aOldFilterProps;
            const OUString aOldFilterName = GetDocProps().getUnpackedValueOrDefault( sFilterNameString, OUString() );

            if ( !aOldFilterName.isEmpty() )
                m_pOwner->GetFilterConfiguration()->getByName( aOldFilterName ) >>= aOldFilterProps;

            ::comphelper::SequenceAsHashMap aOldFiltPropsHM( aOldFilterProps );
            SfxFilterFlags nOldFiltFlags = static_cast<SfxFilterFlags>(aOldFiltPropsHM.getUnpackedValueOrDefault("Flags", sal_Int32(0) ));

            if ( bSetStandardName || ( nOldFiltFlags & nMust ) != nMust || bool(nOldFiltFlags & nDont) )
            {
                // the suggested type will be changed, the extension should be adjusted
                aAdjustToType = aPreselectedFilterPropsHM.getUnpackedValueOrDefault( "Type", OUString() );
                pFileDlg->SetCurrentFilter( aPreselectedFilterPropsHM.getUnpackedValueOrDefault( "UIName", OUString() ) );
            }
            else
            {
                pFileDlg->SetCurrentFilter( aOldFiltPropsHM.getUnpackedValueOrDefault(
                                                            "UIName",
                                                            OUString() ) );
            }
        }

        const OUString aRecommendedDir {GetRecommendedDir( aSuggestedDir )};
        if ( !aRecommendedDir.isEmpty() )
            pFileDlg->SetDisplayFolder( aRecommendedDir );
        const OUString aRecommendedName {GetRecommendedName( aSuggestedName, aAdjustToType )};
        if ( !aRecommendedName.isEmpty() )
            pFileDlg->SetFileName( aRecommendedName );

        uno::Reference < view::XSelectionSupplier > xSel( GetModel()->getCurrentController(), uno::UNO_QUERY );
        if ( xSel.is() && xSel->getSelection().hasValue() )
            GetMediaDescr()[OUString("SelectionOnly")] <<= true;

        // This is a temporary hardcoded solution must be removed when
        // dialogs do not need parameters in SidSet representation any more
        sal_uInt16 nSlotID = getSlotIDFromMode( nStoreMode );
        if ( !nSlotID )
            throw lang::IllegalArgumentException(); // TODO:

        // generate SidSet from MediaDescriptor and provide it into FileDialog
        // than merge changed SidSet back
        SfxAllItemSet aDialogParams( SfxGetpApp()->GetPool() );
        SfxItemSet* pDialogParams = &aDialogParams;
        TransformParameters( nSlotID,
                             GetMediaDescr().getAsConstPropertyValueList(),
                             aDialogParams );

        const SfxPoolItem* pItem = nullptr;
        if ( bPreselectPassword && aDialogParams.GetItemState( SID_ENCRYPTIONDATA, true, &pItem ) != SfxItemState::SET )
        {
            // the file dialog preselects the password checkbox if the provided mediadescriptor has encryption data entry
            // after dialog execution the password interaction flag will be either removed or not
            aDialogParams.Put( SfxBoolItem( SID_PASSWORDINTERACTION, true ) );
        }

        // aFilterName is a pure output parameter, pDialogParams is an in/out parameter
        OUString aFilterName;
        if ( pFileDlg->Execute( pDialogParams, aFilterName ) != ERRCODE_NONE )
        {
            throw task::ErrorCodeIOException(
                "ModelData_Impl::OutputFileDialog: ERRCODE_IO_ABORT",
                uno::Reference< uno::XInterface >(), sal_uInt32(ERRCODE_IO_ABORT));
        }

        // the following two arguments can not be converted in MediaDescriptor,
        // so they should be removed from the ItemSet after retrieving
        const SfxBoolItem* pRecommendReadOnly = SfxItemSet::GetItem<SfxBoolItem>(pDialogParams, SID_RECOMMENDREADONLY, false);
        m_bRecommendReadOnly = ( pRecommendReadOnly && pRecommendReadOnly->GetValue() );
        pDialogParams->ClearItem( SID_RECOMMENDREADONLY );

        uno::Sequence< beans::PropertyValue > aPropsFromDialog;
        TransformItems( nSlotID, *pDialogParams, aPropsFromDialog );
        GetMediaDescr() << aPropsFromDialog;

        // get the path from the dialog
        INetURLObject aURL( pFileDlg->GetPath() );
        // the path should be provided outside since it might be used for further calls to the dialog
        aSuggestedName = aURL.GetName( INetURLObject::DecodeMechanism::WithCharset );
           aSuggestedDir = pFileDlg->GetDisplayDirectory();

        // old filter options should be cleared in case different filter is used

        const OUString aFilterFromMediaDescr = GetMediaDescr().getUnpackedValueOrDefault( sFilterNameString, OUString() );
        const OUString aOldFilterName = GetDocProps().getUnpackedValueOrDefault( sFilterNameString, OUString() );

        const OUString sFilterOptionsString(aFilterOptionsString);
        const OUString sFilterDataString(aFilterDataString);

        if ( aFilterName == aFilterFromMediaDescr )
        {
            // preserve current settings if any
            // if there no current settings and the name is the same
            // as old filter name use old filter settings

            if ( aFilterFromMediaDescr == aOldFilterName )
            {
                ::comphelper::SequenceAsHashMap::const_iterator aIter =
                                            GetDocProps().find( sFilterOptionsString );
                if ( aIter != GetDocProps().end()
                  && GetMediaDescr().find( sFilterOptionsString ) == GetMediaDescr().end() )
                    GetMediaDescr()[aIter->first] = aIter->second;

                aIter = GetDocProps().find( sFilterDataString );
                if ( aIter != GetDocProps().end()
                  && GetMediaDescr().find( sFilterDataString ) == GetMediaDescr().end() )
                    GetMediaDescr()[aIter->first] = aIter->second;
            }
        }
        else
        {
            GetMediaDescr().erase( sFilterDataString );
            GetMediaDescr().erase( sFilterOptionsString );

            if ( aFilterName == aOldFilterName )
            {
                // merge filter option of the document filter

                ::comphelper::SequenceAsHashMap::const_iterator aIter =
                                    GetDocProps().find( sFilterOptionsString );
                if ( aIter != GetDocProps().end() )
                    GetMediaDescr()[aIter->first] = aIter->second;

                aIter = GetDocProps().find( sFilterDataString );
                if ( aIter != GetDocProps().end() )
                    GetMediaDescr()[aIter->first] = aIter->second;
            }
        }

        uno::Reference< ui::dialogs::XFilePickerControlAccess > xExtFileDlg( pFileDlg->GetFilePicker(), uno::UNO_QUERY );
        if ( xExtFileDlg.is() )
        {
            if ( SfxStoringHelper::CheckFilterOptionsAppearance( m_pOwner->GetFilterConfiguration(), aFilterName ) )
                bUseFilterOptions = true;

            if ( ( !( nStoreMode & EXPORT_REQUESTED ) || ( nStoreMode & WIDEEXPORT_REQUESTED ) ) && bUseFilterOptions )
            {
                try
                {
                    // for exporters: always show dialog if format uses options
                    // for save: show dialog if format uses options and no options given or if forced by user
                    uno::Any aVal =
                            xExtFileDlg->getValue( ui::dialogs::ExtendedFilePickerElementIds::CHECKBOX_FILTEROPTIONS, 0 );

                    aVal >>= bUseFilterOptions;
                    if ( !bUseFilterOptions )
                        bUseFilterOptions =
                          ( GetMediaDescr().find( sFilterDataString ) == GetMediaDescr().end()
                          && GetMediaDescr().find( sFilterOptionsString ) == GetMediaDescr().end() );
                }
                catch( const lang::IllegalArgumentException& )
                {}
            }
        }

        // merge in results of the dialog execution
        GetMediaDescr()[OUString("URL")] <<= aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE );
        GetMediaDescr()[sFilterNameString] <<= aFilterName;

        return bUseFilterOptions;
    }

    bool ModelData_Impl::ShowDocumentInfoDialog(const std::function< void () >& aFunc)
    {
        bool bDialogUsed = false;

        try {
            uno::Reference< frame::XController > xController = GetModel()->getCurrentController();
            if ( xController.is() )
            {
                uno::Reference< frame::XDispatchProvider > xFrameDispatch( xController->getFrame(), uno::UNO_QUERY );
                if ( xFrameDispatch.is() )
                {
                    util::URL aURL;
                    aURL.Complete = ".uno:SetDocumentProperties";

                    uno::Reference < util::XURLTransformer > xTransformer( util::URLTransformer::create( comphelper::getProcessComponentContext() ) );
                    if ( xTransformer->parseStrict( aURL ) )
                    {
                        uno::Reference< frame::XDispatch > xDispatch = xFrameDispatch->queryDispatch(
                                                                                    aURL,
                                                                                    "_self",
                                                                                    0 );
                        if ( xDispatch.is() )
                        {
                            uno::Sequence< beans::PropertyValue > aProperties(1);
                            uno::Reference< lang::XUnoTunnel > aAsyncFunc(new AsyncFunc(aFunc));
                            aProperties[0].Name = "AsyncFunc";
                            aProperties[0].Value <<= aAsyncFunc;
                            xDispatch->dispatch( aURL, aProperties );
                            bDialogUsed = true;
                        }
                    }
                }
            }
        }
        catch ( const uno::Exception& )
        {
        }

        return bDialogUsed;
    }

    OUString ModelData_Impl::GetRecommendedExtension( const OUString& aTypeName )
    {
       if ( aTypeName.isEmpty() )
           return OUString();

       uno::Reference< container::XNameAccess > xTypeDetection(
           comphelper::getProcessServiceFactory()->createInstance("com.sun.star.document.TypeDetection"),
           uno::UNO_QUERY );
       if ( xTypeDetection.is() )
       {
           uno::Sequence< beans::PropertyValue > aTypeNameProps;
           if ( ( xTypeDetection->getByName( aTypeName ) >>= aTypeNameProps ) && aTypeNameProps.getLength() )
           {
               ::comphelper::SequenceAsHashMap aTypeNamePropsHM( aTypeNameProps );
               uno::Sequence< OUString > aExtensions = aTypeNamePropsHM.getUnpackedValueOrDefault(
                                               "Extensions",
                                               ::uno::Sequence< OUString >() );
               if ( aExtensions.getLength() )
                   return aExtensions[0];
           }
        }

        return OUString();
    }

    OUString ModelData_Impl::GetRecommendedDir( const OUString& aSuggestedDir )
    {
        if ( ( !aSuggestedDir.isEmpty() || GetStorable()->hasLocation() )
          && !GetMediaDescr().getUnpackedValueOrDefault("RepairPackage", false ) )
        {
            INetURLObject aLocation;
            if ( !aSuggestedDir.isEmpty() )
                aLocation = INetURLObject( aSuggestedDir );
            else
            {
                const OUString aOldURL = GetStorable()->getLocation();
                if ( !aOldURL.isEmpty() )
                {
                    INetURLObject aTmp( aOldURL );
                    if ( aTmp.removeSegment() )
                        aLocation = aTmp;
                }

                if ( aLocation.HasError() )
                    aLocation = INetURLObject( SvtPathOptions().GetWorkPath() );
            }

            OUString sLocationURL( aLocation.GetMainURL( INetURLObject::DecodeMechanism::NONE ) );
            bool bIsInTempPath( false );
            OUString sSysTempPath;
            if( osl::FileBase::getTempDirURL( sSysTempPath ) == osl::FileBase::E_None )
                bIsInTempPath = !sSysTempPath.isEmpty() && sLocationURL.startsWith( sSysTempPath );
    #ifdef _WIN32
            if( !bIsInTempPath )
            {
                wchar_t sPath[MAX_PATH+1];
                HRESULT hRes = SHGetFolderPathW( nullptr, CSIDL_INTERNET_CACHE, nullptr, SHGFP_TYPE_CURRENT, sPath );
                if( SUCCEEDED(hRes) )
                {
                    OUString sTempINetFiles;
                    if( osl::FileBase::getFileURLFromSystemPath(o3tl::toU(sPath), sTempINetFiles) == osl::FileBase::E_None )
                        bIsInTempPath = !sTempINetFiles.isEmpty() && sLocationURL.startsWith( sTempINetFiles );
                }
            }
    #endif
            // Suggest somewhere other than the system's temp directory
            if( bIsInTempPath )
                aLocation = INetURLObject( SvtPathOptions().GetWorkPath() );

            aLocation.setFinalSlash();
            if ( !aLocation.HasError() )
                return aLocation.GetMainURL( INetURLObject::DecodeMechanism::NONE );

            return OUString();
        }

        return INetURLObject( SvtPathOptions().GetWorkPath() ).GetMainURL( INetURLObject::DecodeMechanism::NONE );
    }

    OUString ModelData_Impl::GetRecommendedName( const OUString& aSuggestedName, const OUString& aTypeName )
    {
        // the last used name might be provided by aSuggestedName from the old selection, or from the MediaDescriptor
        if ( !aSuggestedName.isEmpty() )
            return aSuggestedName;

        OUString aRecommendedName {INetURLObject( GetStorable()->getLocation() ).GetName( INetURLObject::DecodeMechanism::WithCharset )};
        if ( aRecommendedName.isEmpty() )
        {
            try {
                uno::Reference< frame::XTitle > xTitle( GetModel(), uno::UNO_QUERY_THROW );
                aRecommendedName = xTitle->getTitle();
            } catch( const uno::Exception& ) {}
        }

        if ( !aRecommendedName.isEmpty() && !aTypeName.isEmpty() )
        {
            // adjust the extension to the type
            uno::Reference< container::XNameAccess > xTypeDetection(
                comphelper::getProcessServiceFactory()->createInstance("com.sun.star.document.TypeDetection"),
                uno::UNO_QUERY );
            if ( xTypeDetection.is() )
            {
                INetURLObject aObj( "c:/" + aRecommendedName, INetProtocol::File,
                        INetURLObject::EncodeMechanism::All, RTL_TEXTENCODING_UTF8, FSysStyle::Dos );

                const OUString aExtension = GetRecommendedExtension( aTypeName );
                if ( !aExtension.isEmpty() )
                    aObj.SetExtension( aExtension );

                aRecommendedName = aObj.GetName( INetURLObject::DecodeMechanism::WithCharset );
            }
        }

        return aRecommendedName;
    }

    // class SfxStoringHelper

    SfxStoringHelper::SfxStoringHelper()
    {
    }

    uno::Reference< container::XNameAccess > const & SfxStoringHelper::GetFilterConfiguration()
    {
        if ( !m_xFilterCFG.is() )
        {
            m_xFilterCFG.set( comphelper::getProcessServiceFactory()->createInstance("com.sun.star.document.FilterFactory"),
                              uno::UNO_QUERY_THROW );
        }

        return m_xFilterCFG;
    }

    uno::Reference< container::XContainerQuery > const & SfxStoringHelper::GetFilterQuery()
    {
        if ( !m_xFilterQuery.is() )
        {
            m_xFilterQuery.set( GetFilterConfiguration(), uno::UNO_QUERY_THROW );
        }

        return m_xFilterQuery;
    }

    uno::Reference< css::frame::XModuleManager2 > const & SfxStoringHelper::GetModuleManager()
    {
        if ( !m_xModuleManager.is() )
        {
            m_xModuleManager = frame::ModuleManager::create(
                comphelper::getProcessComponentContext() );
        }

        return m_xModuleManager;
    }

    bool SfxStoringHelper::GUIStoreModel( const uno::Reference< frame::XModel >& xModel,
                                                const OUString& aSlotName,
                                                uno::Sequence< beans::PropertyValue >& aArgsSequence,
                                                bool bPreselectPassword,
                                                SignatureState nDocumentSignatureState )
    {
        ModelData_Impl aModelData( *this, xModel, aArgsSequence );

        bool bDialogUsed = false;

        INetURLObject aURL;

        bool bSetStandardName = false; // can be set only for SaveAs

        // parse the slot name
        bool bRemote = false;
        sal_Int16 nStoreMode = getStoreModeFromSlotName( aSlotName );

        if ( nStoreMode == SAVEASREMOTE_REQUESTED )
        {
            nStoreMode = SAVEAS_REQUESTED;
            bRemote = true;
        }

        sal_Int8 nStatusSave = STATUS_NO_ACTION;

        ::comphelper::SequenceAsHashMap::const_iterator aSaveACopyIter =
                            aModelData.GetMediaDescr().find( OUString("SaveACopy") );
        if ( aSaveACopyIter != aModelData.GetMediaDescr().end() )
        {
            bool bSaveACopy = false;
            aSaveACopyIter->second >>= bSaveACopy;
            if ( bSaveACopy )
                nStoreMode = EXPORT_REQUESTED | SAVEACOPY_REQUESTED | WIDEEXPORT_REQUESTED;
        }
        // handle the special cases
        if ( nStoreMode & SAVEAS_REQUESTED )
        {
            ::comphelper::SequenceAsHashMap::const_iterator aSaveToIter =
                            aModelData.GetMediaDescr().find( OUString("SaveTo") );
            if ( aSaveToIter != aModelData.GetMediaDescr().end() )
            {
                bool bWideExport = false;
                aSaveToIter->second >>= bWideExport;
                if ( bWideExport )
                    nStoreMode = EXPORT_REQUESTED | WIDEEXPORT_REQUESTED;
            }

            // if saving is not acceptable the warning must be shown even in case of SaveAs operation
            if ( ( nStoreMode & SAVEAS_REQUESTED ) && aModelData.CheckSaveAcceptable( STATUS_SAVEAS ) == STATUS_NO_ACTION )
                throw task::ErrorCodeIOException(
                    "SfxStoringHelper::GUIStoreModel: ERRCODE_IO_ABORT",
                    uno::Reference< uno::XInterface >(), sal_uInt32(ERRCODE_IO_ABORT));
        }
        else if ( nStoreMode & SAVE_REQUESTED )
        {
            // if saving is not acceptable by the configuration the warning must be shown
            nStatusSave = aModelData.CheckSaveAcceptable( STATUS_SAVE );

            if ( nStatusSave == STATUS_NO_ACTION )
                throw task::ErrorCodeIOException(
                    "SfxStoringHelper::GUIStoreModel: ERRCODE_IO_ABORT",
                    uno::Reference< uno::XInterface >(), sal_uInt32(ERRCODE_IO_ABORT));
            else if ( nStatusSave == STATUS_SAVE )
            {
                // check whether it is possible to use save operation
                nStatusSave = aModelData.CheckStateForSave();
            }

            if ( nStatusSave == STATUS_NO_ACTION )
            {
                throw task::ErrorCodeIOException(
                    "SfxStoringHelper::GUIStoreModel: ERRCODE_IO_ABORT",
                    uno::Reference< uno::XInterface >(), sal_uInt32(ERRCODE_IO_ABORT));
            }
            else if ( nStatusSave != STATUS_SAVE )
            {
                // this should be a usual SaveAs operation
                nStoreMode = SAVEAS_REQUESTED;
                if ( nStatusSave == STATUS_SAVEAS_STANDARDNAME )
                    bSetStandardName = true;
            }
        }

        if ( !( nStoreMode & EXPORT_REQUESTED ) )
        {
            // if it is no export, warn user that the signature will be removed
            if (  SignatureState::OK == nDocumentSignatureState
               || SignatureState::INVALID == nDocumentSignatureState
               || SignatureState::NOTVALIDATED == nDocumentSignatureState
               || SignatureState::PARTIAL_OK == nDocumentSignatureState)
            {
                std::unique_ptr<weld::MessageDialog> xMessageBox(Application::CreateMessageDialog(nullptr,
                                                                 VclMessageType::Question, VclButtonsType::YesNo, SfxResId(RID_SVXSTR_XMLSEC_QUERY_LOSINGSIGNATURE)));
                if (xMessageBox->run() != RET_YES)
                {
                    // the user has decided not to store the document
                    throw task::ErrorCodeIOException(
                        "SfxStoringHelper::GUIStoreModel: ERRCODE_IO_ABORT",
                        uno::Reference< uno::XInterface >(), sal_uInt32(ERRCODE_IO_ABORT));
                }
            }
        }

        if ( nStoreMode & SAVE_REQUESTED && nStatusSave == STATUS_SAVE )
        {
            // Document properties can contain streams that should be freed before storing
            aModelData.FreeDocumentProps();

            if ( aModelData.GetStorable2().is() )
            {
                try
                {
                    aModelData.GetStorable2()->storeSelf( aModelData.GetMediaDescr().getAsConstPropertyValueList() );
                }
                catch (const lang::IllegalArgumentException& e)
                {
                    SAL_WARN("sfx.doc", "Ignoring parameters! "
                        "ModelData considers this illegal:  " << e);
                    aModelData.GetStorable()->store();
                }
            }
            else
            {
                OSL_FAIL( "XStorable2 is not supported by the model!" );
                aModelData.GetStorable()->store();
            }

            return false;
        }

        // preselect a filter for the storing process
        uno::Sequence< beans::PropertyValue > aFilterProps = aModelData.GetPreselectedFilter_Impl( nStoreMode );

        DBG_ASSERT( aFilterProps.getLength(), "No filter for storing!\n" );
        if ( !aFilterProps.getLength() )
            throw task::ErrorCodeIOException(
                "SfxStoringHelper::GUIStoreModel: ERRCODE_IO_INVALIDPARAMETER",
                uno::Reference< uno::XInterface >(), sal_uInt32(ERRCODE_IO_INVALIDPARAMETER));

        ::comphelper::SequenceAsHashMap aFilterPropsHM( aFilterProps );
        OUString aFilterName = aFilterPropsHM.getUnpackedValueOrDefault( "Name", OUString() );

        const OUString sFilterNameString(aFilterNameString);

        const OUString aFilterFromMediaDescr = aModelData.GetMediaDescr().getUnpackedValueOrDefault( sFilterNameString, OUString() );
        const OUString aOldFilterName = aModelData.GetDocProps().getUnpackedValueOrDefault( sFilterNameString, OUString() );

        bool bUseFilterOptions = false;
        ::comphelper::SequenceAsHashMap::const_iterator aFileNameIter = aModelData.GetMediaDescr().find( OUString("URL") );

        const OUString sFilterOptionsString(aFilterOptionsString);
        const OUString sFilterDataString(aFilterDataString);
        const OUString sFilterFlagsString("FilterFlags");

        bool bPDFOptions = (nStoreMode & PDFEXPORT_REQUESTED) && !(nStoreMode & PDFDIRECTEXPORT_REQUESTED);
        bool bEPUBOptions = (nStoreMode & EPUBEXPORT_REQUESTED) && !(nStoreMode & EPUBDIRECTEXPORT_REQUESTED);
        if ( ( nStoreMode & EXPORT_REQUESTED ) && (bPDFOptions || bEPUBOptions) )
        {
            // this is PDF or EPUB export, the filter options dialog should be shown before the export
            aModelData.GetMediaDescr()[sFilterNameString] <<= aFilterName;
            if ( aModelData.GetMediaDescr().find( sFilterFlagsString ) == aModelData.GetMediaDescr().end()
              && aModelData.GetMediaDescr().find( sFilterOptionsString ) == aModelData.GetMediaDescr().end()
              && aModelData.GetMediaDescr().find( sFilterDataString ) == aModelData.GetMediaDescr().end() )
            {
                // execute filter options dialog since no options are set in the media descriptor
                if ( aModelData.ExecuteFilterDialog_Impl( aFilterName ) )
                    bDialogUsed = true;
            }
        }

        if ( aFileNameIter == aModelData.GetMediaDescr().end() )
        {
            sal_Int16 nDialog = SFX2_IMPL_DIALOG_CONFIG;

            if( bRemote )
            {
                nDialog = SFX2_IMPL_DIALOG_REMOTE;
            }
            else
            {
                ::comphelper::SequenceAsHashMap::const_iterator aDlgIter =
                    aModelData.GetMediaDescr().find( OUString("UseSystemDialog") );
                if ( aDlgIter != aModelData.GetMediaDescr().end() )
                {
                    bool bUseSystemDialog = true;
                    if ( aDlgIter->second >>= bUseSystemDialog )
                    {
                        if ( bUseSystemDialog )
                            nDialog = SFX2_IMPL_DIALOG_SYSTEM;
                        else
                            nDialog = SFX2_IMPL_DIALOG_OOO;
                    }
                }
            }

            // The Dispatch supports parameter FolderName that overwrites SuggestedSaveAsDir
            OUString aSuggestedDir = aModelData.GetMediaDescr().getUnpackedValueOrDefault("FolderName", OUString() );
            if ( aSuggestedDir.isEmpty() )
            {
                aSuggestedDir = aModelData.GetMediaDescr().getUnpackedValueOrDefault("SuggestedSaveAsDir", OUString() );
                if ( aSuggestedDir.isEmpty() )
                    aSuggestedDir = aModelData.GetDocProps().getUnpackedValueOrDefault("SuggestedSaveAsDir", OUString() );
            }

            OUString aSuggestedName = aModelData.GetMediaDescr().getUnpackedValueOrDefault("SuggestedSaveAsName", OUString() );
            if ( aSuggestedName.isEmpty() )
                aSuggestedName = aModelData.GetDocProps().getUnpackedValueOrDefault("SuggestedSaveAsName", OUString() );

            OUString sStandardDir;
            ::comphelper::SequenceAsHashMap::const_iterator aStdDirIter =
                aModelData.GetMediaDescr().find( OUString("StandardDir") );
            if ( aStdDirIter != aModelData.GetMediaDescr().end() )
                aStdDirIter->second >>= sStandardDir;

            css::uno::Sequence< OUString >  aBlackList;

            ::comphelper::SequenceAsHashMap::const_iterator aBlackListIter =
                aModelData.GetMediaDescr().find( OUString("BlackList") );
            if ( aBlackListIter != aModelData.GetMediaDescr().end() )
                aBlackListIter->second >>= aBlackList;

            for (;;)
            {
                // in case the dialog is opened a second time the folder should be the same as previously navigated to by the user, not what was handed over by initial parameters
                bUseFilterOptions = aModelData.OutputFileDialog( nStoreMode, aFilterProps, bSetStandardName, aSuggestedName, bPreselectPassword, aSuggestedDir, nDialog, sStandardDir, aBlackList );
                if ( nStoreMode == SAVEAS_REQUESTED )
                {
                    // in case of saving check filter for possible alien warning
                    const OUString aSelFilterName = aModelData.GetMediaDescr().getUnpackedValueOrDefault( sFilterNameString, OUString() );
                    sal_Int8 nStatusFilterSave = aModelData.CheckFilter( aSelFilterName );
                    if ( nStatusFilterSave == STATUS_SAVEAS_STANDARDNAME )
                    {
                        // switch to best filter
                        bSetStandardName = true;
                    }
                    else if ( nStatusFilterSave == STATUS_SAVE )
                    {
                        // user confirmed alien filter or "good" filter is used
                        break;
                    }
                }
                else
                    break;
            }

            bDialogUsed = true;
            aFileNameIter = aModelData.GetMediaDescr().find( OUString("URL") );
        }
        else
        {
            // the target file name is provided so check if new filter options
            // are provided or old options can be used
            if ( aFilterFromMediaDescr == aOldFilterName )
            {
                ::comphelper::SequenceAsHashMap::const_iterator aIter =
                                                aModelData.GetDocProps().find( sFilterOptionsString );
                if ( aIter != aModelData.GetDocProps().end()
                  && aModelData.GetMediaDescr().find( sFilterOptionsString ) == aModelData.GetMediaDescr().end() )
                    aModelData.GetMediaDescr()[aIter->first] = aIter->second;

                aIter = aModelData.GetDocProps().find( sFilterDataString );
                if ( aIter != aModelData.GetDocProps().end()
                  && aModelData.GetMediaDescr().find( sFilterDataString ) == aModelData.GetMediaDescr().end() )
                    aModelData.GetMediaDescr()[aIter->first] = aIter->second;
            }
        }

        if ( aFileNameIter != aModelData.GetMediaDescr().end() )
        {
            OUString aFileName;
            aFileNameIter->second >>= aFileName;
            aURL.SetURL( aFileName );
            DBG_ASSERT( aURL.GetProtocol() != INetProtocol::NotValid, "Illegal URL!" );

            ::comphelper::SequenceAsHashMap::const_iterator aIter =
                                    aModelData.GetMediaDescr().find( sFilterNameString );

            if ( aIter != aModelData.GetMediaDescr().end() )
                aIter->second >>= aFilterName;
            else
                aModelData.GetMediaDescr()[sFilterNameString] <<= aFilterName;

            DBG_ASSERT( !aFilterName.isEmpty(), "Illegal filter!" );
        }
        else
        {
            SAL_WARN( "sfx.doc", "This code must be unreachable!" );
            throw task::ErrorCodeIOException(
                "SfxStoringHelper::GUIStoreModel: ERRCODE_IO_INVALIDPARAMETER",
                uno::Reference< uno::XInterface >(), sal_uInt32(ERRCODE_IO_INVALIDPARAMETER));
        }

        ::comphelper::SequenceAsHashMap::const_iterator aIter =
                                aModelData.GetMediaDescr().find( OUString("FilterFlags") );
        bool bFilterFlagsSet = ( aIter != aModelData.GetMediaDescr().end() );

        if( !( nStoreMode & PDFEXPORT_REQUESTED ) && !( nStoreMode & EPUBEXPORT_REQUESTED ) && !bFilterFlagsSet
            && ( ( nStoreMode & EXPORT_REQUESTED ) || bUseFilterOptions ) )
        {
            // execute filter options dialog
            if ( aModelData.ExecuteFilterDialog_Impl( aFilterName ) )
                bDialogUsed = true;
        }

        // so the arguments will not change any more and can be stored to the main location
        aArgsSequence = aModelData.GetMediaDescr().getAsConstPropertyValueList();

        // store the document and handle it's docinfo
        SvtSaveOptions aOptions;

        DocumentSettingsGuard aSettingsGuard( aModelData.GetModel(), aModelData.IsRecommendReadOnly(), nStoreMode & EXPORT_REQUESTED );

        OSL_ENSURE( aModelData.GetMediaDescr().find( OUString( "Password" ) ) == aModelData.GetMediaDescr().end(), "The Password property of MediaDescriptor should not be used here!" );
        if ( aOptions.IsDocInfoSave()
          && ( !aModelData.GetStorable()->hasLocation()
              || INetURLObject( aModelData.GetStorable()->getLocation() ) != aURL ) )
        {
            // this is definitely not a Save operation
            // so the document info can be updated

            // on export document info must be preserved
            uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
                aModelData.GetModel(), uno::UNO_QUERY_THROW);
            uno::Reference<util::XCloneable> xCloneable(
                xDPS->getDocumentProperties(), uno::UNO_QUERY_THROW);
            uno::Reference<document::XDocumentProperties> xOldDocProps(
                xCloneable->createClone(), uno::UNO_QUERY_THROW);

            std::function< void () > aFunc = [xModel, xOldDocProps, nStoreMode, aURL, aArgsSequence]() {
                SfxStoringHelper aStoringHelper;
                ModelData_Impl aModel(aStoringHelper, xModel, aArgsSequence );

                try
                {
                    if ( nStoreMode & EXPORT_REQUESTED )
                        aModel.GetStorable()->storeToURL( aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), aArgsSequence );
                    else
                        aModel.GetStorable()->storeAsURL( aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), aArgsSequence );
                }
                catch( const uno::Exception& )
                {
                }

                if ( nStoreMode & EXPORT_REQUESTED )
                {
                    SfxStoringHelper::SetDocInfoState(aModel.GetModel(), xOldDocProps);
                }
            };

            // use dispatch API to show document info dialog
            if ( aModelData.ShowDocumentInfoDialog(aFunc) )
                bDialogUsed = true;
            else
            {
                OSL_FAIL( "Can't execute document info dialog!" );
            }
        }
        else
        {
            // Document properties can contain streams that should be freed before storing
            aModelData.FreeDocumentProps();

            // this is actually a save operation with different parameters
            // so storeTo or storeAs without DocInfo operations are used
            if ( nStoreMode & EXPORT_REQUESTED )
                aModelData.GetStorable()->storeToURL( aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), aArgsSequence );
            else
                aModelData.GetStorable()->storeAsURL( aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), aArgsSequence );
        }

        // Launch PDF viewer
        if ( nStoreMode & PDFEXPORT_REQUESTED )
        {
            FilterConfigItem aItem( "Office.Common/Filter/PDF/Export/" );
            bool aViewPDF = aItem.ReadBool( "ViewPDFAfterExport", false );

            if ( aViewPDF )
            {
                uno::Reference<XSystemShellExecute> xSystemShellExecute(SystemShellExecute::create( ::comphelper::getProcessComponentContext() ) );
                xSystemShellExecute->execute( aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), "", SystemShellExecuteFlags::URIS_ONLY );
            }
        }

        return bDialogUsed;
    }

    // static
    bool SfxStoringHelper::CheckFilterOptionsAppearance(
                                                        const uno::Reference< container::XNameAccess >& xFilterCFG,
                                                        const OUString& aFilterName )
    {
        bool bUseFilterOptions = false;

        DBG_ASSERT( xFilterCFG.is(), "No filter configuration!\n" );
        if( xFilterCFG.is() )
        {
            try {
                uno::Sequence < beans::PropertyValue > aProps;
                uno::Any aAny = xFilterCFG->getByName( aFilterName );
                if ( aAny >>= aProps )
                {
                    ::comphelper::SequenceAsHashMap aPropsHM( aProps );
                    if( !aPropsHM.getUnpackedValueOrDefault( "UIComponent", OUString() ).isEmpty() )
                        bUseFilterOptions = true;
                }
            }
            catch( const uno::Exception& )
            {
            }
        }

        return bUseFilterOptions;
    }

    // static
    void SfxStoringHelper::SetDocInfoState(
            const uno::Reference< frame::XModel >& xModel,
            const uno::Reference< document::XDocumentProperties>& i_xOldDocProps )
    {
        uno::Reference<document::XDocumentPropertiesSupplier> const
            xModelDocPropsSupplier(xModel, uno::UNO_QUERY_THROW);
        uno::Reference<document::XDocumentProperties> const xDocPropsToFill =
            xModelDocPropsSupplier->getDocumentProperties();
        uno::Reference< beans::XPropertySet > const xPropSet(
                i_xOldDocProps->getUserDefinedProperties(), uno::UNO_QUERY_THROW);

        uno::Reference< util::XModifiable > xModifiable( xModel, uno::UNO_QUERY );
        if ( !xModifiable.is() )
            throw uno::RuntimeException();

        bool bIsModified = xModifiable->isModified();

        try
        {
            uno::Reference< beans::XPropertySet > const xSet(
                    xDocPropsToFill->getUserDefinedProperties(), uno::UNO_QUERY);
            uno::Reference< beans::XPropertyContainer > xContainer( xSet, uno::UNO_QUERY );
            uno::Reference< beans::XPropertySetInfo > xSetInfo = xSet->getPropertySetInfo();
            uno::Sequence< beans::Property > lProps = xSetInfo->getProperties();
            const beans::Property* pProps = lProps.getConstArray();
            const sal_Int32 nPropLen = lProps.getLength();
            for (sal_Int32 i=0; i<nPropLen; ++i)
            {
                uno::Any aValue = xPropSet->getPropertyValue( pProps[i].Name );
                if ( pProps[i].Attributes & css::beans::PropertyAttribute::REMOVABLE )
                {
                    try
                    {
                        // QUESTION: DefaultValue?!
                        xContainer->addProperty( pProps[i].Name, pProps[i].Attributes, aValue );
                    }
                    catch (beans::PropertyExistException const&) {}
                    try
                    {
                        // it is possible that the propertysets from XML and binary files differ; we shouldn't break then
                        xSet->setPropertyValue( pProps[i].Name, aValue );
                    }
                    catch ( const uno::Exception& ) {}
                }
            }

            // sigh... have to set these manually I'm afraid... wonder why
            // SfxObjectShell doesn't handle this internally, should be easier
            xDocPropsToFill->setAuthor(i_xOldDocProps->getAuthor());
            xDocPropsToFill->setGenerator(i_xOldDocProps->getGenerator());
            xDocPropsToFill->setCreationDate(i_xOldDocProps->getCreationDate());
            xDocPropsToFill->setTitle(i_xOldDocProps->getTitle());
            xDocPropsToFill->setSubject(i_xOldDocProps->getSubject());
            xDocPropsToFill->setDescription(i_xOldDocProps->getDescription());
            xDocPropsToFill->setKeywords(i_xOldDocProps->getKeywords());
            xDocPropsToFill->setModifiedBy(i_xOldDocProps->getModifiedBy());
            xDocPropsToFill->setModificationDate(i_xOldDocProps->getModificationDate());
            xDocPropsToFill->setPrintedBy(i_xOldDocProps->getPrintedBy());
            xDocPropsToFill->setPrintDate(i_xOldDocProps->getPrintDate());
            xDocPropsToFill->setAutoloadURL(i_xOldDocProps->getAutoloadURL());
            xDocPropsToFill->setAutoloadSecs(i_xOldDocProps->getAutoloadSecs());
            xDocPropsToFill->setDefaultTarget(i_xOldDocProps->getDefaultTarget());
            xDocPropsToFill->setEditingCycles(i_xOldDocProps->getEditingCycles());
            xDocPropsToFill->setEditingDuration(i_xOldDocProps->getEditingDuration());
            // other attributes e.g. DocumentStatistics are not editable from dialog
        }
        catch (const uno::Exception& e)
        {
            SAL_INFO("sfx.doc", "SetDocInfoState: caught " << e);
        }

        // set the modified flag back if required
        if ( bIsModified != bool(xModifiable->isModified()) )
            xModifiable->setModified( bIsModified );
    }

    // static
    bool SfxStoringHelper::WarnUnacceptableFormat( const uno::Reference< frame::XModel >& xModel,
                                                        const OUString& aOldUIName,
                                                        const OUString& aDefExtension,
                                                        bool bDefIsAlien )
    {
        if ( !SvtSaveOptions().IsWarnAlienFormat() )
            return true;

        vcl::Window* pWin = SfxStoringHelper::GetModelWindow( xModel );
        SfxAlienWarningDialog aDlg(pWin ? pWin->GetFrameWeld() : nullptr, aOldUIName, aDefExtension, bDefIsAlien);

        return aDlg.run() == RET_OK;
    }

    uno::Reference<awt::XWindow> SfxStoringHelper::GetModelXWindow(const uno::Reference<frame::XModel>& xModel)
    {
        try {
            if ( xModel.is() )
            {
                uno::Reference< frame::XController > xController = xModel->getCurrentController();
                if ( xController.is() )
                {
                    uno::Reference< frame::XFrame > xFrame = xController->getFrame();
                    if ( xFrame.is() )
                    {
                        return xFrame->getContainerWindow();
                    }
                }
            }
        }
        catch ( const uno::Exception& )
        {
        }

        return uno::Reference<awt::XWindow>();
    }

    vcl::Window* SfxStoringHelper::GetModelWindow( const uno::Reference< frame::XModel >& xModel )
    {
        VclPtr<vcl::Window> pWin;

        try {
            uno::Reference<awt::XWindow> xWindow = GetModelXWindow(xModel);
            if ( xWindow.is() )
            {
                VCLXWindow* pVCLWindow = VCLXWindow::GetImplementation( xWindow );
                if ( pVCLWindow )
                    pWin = pVCLWindow->GetWindow();
            }
        }
        catch ( const uno::Exception& )
        {
        }

        return pWin;
    }

    /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

↑ V560 A part of conditional expression is always true: (nStoreMode != - 1).

↑ V547 Expression 'bWideExport' is always false.

↑ V547 Expression 'bSaveACopy' is always false.

↑ V560 A part of conditional expression is always true: (nStoreMode != - 1).

↑ V547 Expression 'bUseSystemDialog' is always true.