/* -*- 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 <fltoptint.hxx>
#include <sfx2/brokenpackageint.hxx>
#include <sfx2/docfile.hxx>
#include <sfx2/frame.hxx>
#include <sfx2/msg.hxx>
#include <sfx2/msgpool.hxx>
#include <sfx2/sfxsids.hrc>
#include <sfx2/sfxuno.hxx>
#include <sfxslots.hxx>

#include <sal/config.h>
#include <sal/log.hxx>
#include <comphelper/interaction.hxx>
#include <osl/diagnose.h>
#include <svl/eitem.hxx>
#include <svl/intitem.hxx>
#include <svl/itempool.hxx>
#include <svl/slstitm.hxx>
#include <svl/stritem.hxx>
#include <tools/debug.hxx>
#include <cppuhelper/implbase.hxx>

#include <com/sun/star/document/BrokenPackageRequest.hpp>
#include <com/sun/star/document/FilterOptionsRequest.hpp>
#include <com/sun/star/frame/XFrame.hpp>
#include <com/sun/star/frame/XModel.hpp>
#include <com/sun/star/io/XInputStream.hpp>
#include <com/sun/star/io/XOutputStream.hpp>
#include <com/sun/star/task/XInteractionHandler.hpp>
#include <com/sun/star/task/XStatusIndicator.hpp>
#include <com/sun/star/ucb/XContent.hpp>

#include <memory>

using namespace ::com::sun::star;
using namespace ::com::sun::star::ucb;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::frame;
using namespace ::com::sun::star::beans;
using namespace ::com::sun::star::io;

// needs to be converted to a better data structure
SfxFormalArgument const aFormalArgs[] = {
    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "SuggestedSaveAsName", SID_DEFAULTFILENAME },
    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "SuggestedSaveAsDir", SID_DEFAULTFILEPATH },
    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "VersionAuthor", SID_DOCINFO_AUTHOR },
    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "VersionComment", SID_DOCINFO_COMMENTS },
    { reinterpret_cast<SfxType*>(&aSfxBoolItem_Impl), "DontTerminateEdit", FN_PARAM_1 },
    { reinterpret_cast<SfxType*>(&aSfxBoolItem_Impl), "VersionMajor", SID_DOCINFO_MAJOR },
    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "FilterOptions", SID_FILE_FILTEROPTIONS },
    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "FilterName", SID_FILTER_NAME },
    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "Margin1", SID_RULER_MARGIN1 },
    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "Margin2", SID_RULER_MARGIN2 },
//    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "FileName", SID_FILE_NAME },
    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "URL", SID_FILE_NAME },
    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "OpenFlags", SID_OPTIONS },
    { reinterpret_cast<SfxType*>(&aSfxBoolItem_Impl), "Overwrite", SID_OVERWRITE },
    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "Password", SID_PASSWORD },
    { reinterpret_cast<SfxType*>(&aSfxBoolItem_Impl), "PasswordInteraction", SID_PASSWORDINTERACTION },
    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "Referer", SID_REFERER },
    { reinterpret_cast<SfxType*>(&aSfxBoolItem_Impl), "SaveTo", SID_SAVETO },
    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "TemplateName", SID_TEMPLATE_NAME },
    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "TemplateRegion", SID_TEMPLATE_REGIONNAME },
//    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "Region", SID_TEMPLATE_REGIONNAME },
//    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "Name", SID_TEMPLATE_NAME },
    { reinterpret_cast<SfxType*>(&aSfxBoolItem_Impl), "Unpacked", SID_UNPACK },
    { reinterpret_cast<SfxType*>(&aSfxInt16Item_Impl), "Version", SID_VERSION },
    { reinterpret_cast<SfxType*>(&aSfxBoolItem_Impl), "SaveACopy", SID_SAVEACOPYITEM },
    { reinterpret_cast<SfxType*>(&aSfxBoolItem_Impl), "NoFileSync", SID_NO_FILE_SYNC },
    { reinterpret_cast<SfxType*>(&aSfxBoolItem_Impl), "NoThumbnail", SID_NO_THUMBNAIL },
    { reinterpret_cast<SfxType*>(&aSfxBoolItem_Impl), "NoEmbDataSet", SID_NO_EMBEDDED_DS },
    { reinterpret_cast<SfxType*>(&aSfxBoolItem_Impl), "IsRedactMode", SID_IS_REDACT_MODE },
    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "RedactionStyle", SID_REDACTION_STYLE },
};

static sal_uInt16 const nMediaArgsCount = SAL_N_ELEMENTS(aFormalArgs);

static char const sTemplateRegionName[] = "TemplateRegionName";
static char const sTemplateName[] = "TemplateName";
static char const sAsTemplate[] = "AsTemplate";
static char const sOpenNewView[] = "OpenNewView";
static char const sViewId[] = "ViewId";
static char const sPluginMode[] = "PluginMode";
static char const sReadOnly[] = "ReadOnly";
static char const sDdeReconnect[] = "DDEReconnect";
static char const sStartPresentation[] = "StartPresentation";
static char const sFrameName[] = "FrameName";
static char const sMediaType[] = "MediaType";
static char const sPostData[] = "PostData";
static char const sCharacterSet[] = "CharacterSet";
static char const sInputStream[] = "InputStream";
static char const sStream[] = "Stream";
static char const sOutputStream[] = "OutputStream";
static char const sHidden[] = "Hidden";
static char const sPreview[] = "Preview";
static char const sViewOnly[] = "ViewOnly";
static char const sDontEdit[] = "DontEdit";
static char const sSilent[] = "Silent";
static char const sJumpMark[] = "JumpMark";
static char const sSalvagedFile[] = "SalvagedFile";
static char const sStatusInd[] = "StatusIndicator";
static char const sModel[] = "Model";
static char const sFrame[] = "Frame";
static char const sViewData[] = "ViewData";
static char const sFilterData[] = "FilterData";
static char const sSelectionOnly[] = "SelectionOnly";
static char const sMacroExecMode[] = "MacroExecutionMode";
static char const sUpdateDocMode[] = "UpdateDocMode";
static char const sMinimized[] = "Minimized";
static char const sInteractionHdl[] = "InteractionHandler";
static char const sUCBContent[] = "UCBContent";
static char const sRepairPackage[] = "RepairPackage";
static char const sDocumentTitle[] = "DocumentTitle";
static char const sComponentData[] = "ComponentData";
static char const sComponentContext[] = "ComponentContext";
static char const sDocumentBaseURL[] = "DocumentBaseURL";
static char const sHierarchicalDocumentName[] = "HierarchicalDocumentName";
static char const sCopyStreamIfPossible[] = "CopyStreamIfPossible";
static char const sNoAutoSave[] = "NoAutoSave";
static char const sFolderName[] = "FolderName";
static char const sUseSystemDialog[] = "UseSystemDialog";
static char const sStandardDir[] = "StandardDir";
static char const sBlackList[] = "BlackList";
static char const sModifyPasswordInfo[] = "ModifyPasswordInfo";
static char const sSuggestedSaveAsDir[] = "SuggestedSaveAsDir";
static char const sSuggestedSaveAsName[] = "SuggestedSaveAsName";
static char const sEncryptionData[] = "EncryptionData";
static char const sFailOnWarning[] = "FailOnWarning";
static char const sDocumentService[] = "DocumentService";
static char const sFilterProvider[] = "FilterProvider";
static char const sImageFilter[] = "ImageFilter";
static char const sLockContentExtraction[] = "LockContentExtraction";
static char const sLockExport[] = "LockExport";
static char const sLockPrint[] = "LockPrint";
static char const sLockSave[] = "LockSave";
static char const sLockEditDoc[] = "LockEditDoc";
static char const sReplaceable[] = "Replaceable";

static bool isMediaDescriptor( sal_uInt16 nSlotId )
{
    return ( nSlotId == SID_OPENDOC || nSlotId == SID_EXPORTDOC ||
             nSlotId == SID_SAVEASDOC || nSlotId == SID_SAVEDOC ||
             nSlotId == SID_SAVETO || nSlotId == SID_SAVEACOPY ||
             nSlotId == SID_EXPORTDOCASPDF || nSlotId == SID_DIRECTEXPORTDOCASPDF ||
             nSlotId == SID_EXPORTDOCASEPUB || nSlotId == SID_DIRECTEXPORTDOCASEPUB ||
             nSlotId == SID_REDACTDOC || nSlotId == SID_AUTOREDACTDOC ||
             nSlotId == SID_SAVEACOPYITEM);
}

void TransformParameters( sal_uInt16 nSlotId, const uno::Sequence<beans::PropertyValue>& rArgs, SfxAllItemSet& rSet, const SfxSlot* pSlot )
{
    if ( !pSlot )
        pSlot = SFX_SLOTPOOL().GetSlot( nSlotId );

    if ( !pSlot )
        return;

    if ( nSlotId == SID_OPENURL )
        nSlotId = SID_OPENDOC;

    const sal_Int32 nCount = rArgs.getLength();
    if ( !nCount )
        return;

    const beans::PropertyValue* pPropsVal = rArgs.getConstArray();
    if ( !pSlot->IsMode(SfxSlotMode::METHOD) )
    {
        // slot is a property
        const SfxType* pType = pSlot->GetType();
        std::unique_ptr<SfxPoolItem> pItem(pType->CreateItem());

        if ( !pItem )
        {
            SAL_WARN( "sfx", "No creator method for item: " << nSlotId );
            return;
        }

        sal_uInt16 nWhich = rSet.GetPool()->GetWhich(nSlotId);
        bool bConvertTwips = ( rSet.GetPool()->GetMetric( nWhich ) == MapUnit::MapTwip );
        pItem->SetWhich( nWhich );
        sal_uInt16 nSubCount = pType->nAttribs;

        const beans::PropertyValue& rProp = pPropsVal[0];
        const OUString& rName = rProp.Name;
        if ( nCount == 1 && rName == OUString( pSlot->pUnoName, strlen( pSlot->pUnoName ), RTL_TEXTENCODING_UTF8 ) )
        {
            // there is only one parameter and its name matches the name of the property,
            // so it's either a simple property or a complex property in one single UNO struct
            if( pItem->PutValue( rProp.Value, bConvertTwips ? CONVERT_TWIPS : 0 ) )
                // only use successfully converted items
                rSet.Put( *pItem );
            else
            {
                SAL_WARN( "sfx", "Property not convertible: " << pSlot->pUnoName );
            }
        }
#ifdef DBG_UTIL
        else if ( nSubCount == 0 )
        {
            // for a simple property there can be only one parameter and its name *must* match
            SAL_WARN("sfx.appl", "Property name does not match: " << rName);
        }
#endif
        else
        {
            // there is more than one parameter and the property is a complex one
#ifdef DBG_UTIL
            // if the dispatch API is used for UI purposes or from the testtool,
            // it is possible to skip some or all arguments,
            // but it indicates an error for macro recording;
            // so this should be notified as a warning only
            if ( nCount != nSubCount )
            {
                SAL_INFO("sfx.appl", "MacroPlayer: wrong number of parameters for slot: " << nSlotId );
            }
#endif
            // complex property; collect sub items from the parameter set and reconstruct complex item
            sal_uInt16 nFound=0;
            for ( const beans::PropertyValue& rPropValue : rArgs )
            {
                sal_uInt16 nSub;
                for ( nSub=0; nSub<nSubCount; nSub++ )
                {
                    // search sub item by name
                    OString aStr = rtl::OStringView(pSlot->pUnoName) + "." + pType->aAttrib[nSub].pName;
                    if ( rPropValue.Name.equalsAsciiL(aStr.getStr(), aStr.getLength()) )
                    {
                        sal_uInt8 nSubId = static_cast<sal_uInt8>(static_cast<sal_Int8>(pType->aAttrib[nSub].nAID));
                        if ( bConvertTwips )
                            nSubId |= CONVERT_TWIPS;
                        if ( pItem->PutValue( rPropValue.Value, nSubId ) )
                            nFound++;
                        else
                        {
                            SAL_WARN( "sfx.appl", "Property not convertible: " << pSlot->pUnoName);
                        }
                        break;
                    }
                }

                // there was a parameter with a name that didn't match to any of the members
                SAL_WARN_IF( nSub >= nSubCount, "sfx.appl", "Property name does not match: " << rPropValue.Name );
            }

            // at least one part of the complex item must be present; other parts can have default values
            if ( nFound > 0 )
                rSet.Put( *pItem );
        }

        return;
    }

#ifdef DBG_UTIL
    // detect parameters that don't match to any formal argument or one of its members
    sal_Int32 nFoundArgs = 0;
#endif
    // slot is a method
    bool bIsMediaDescriptor = isMediaDescriptor( nSlotId );
    sal_uInt16 nMaxArgs = bIsMediaDescriptor ? nMediaArgsCount : pSlot->nArgDefCount;
    for ( sal_uInt16 nArgs=0; nArgs<nMaxArgs; nArgs++ )
    {
        const SfxFormalArgument &rArg = bIsMediaDescriptor ? aFormalArgs[nArgs] : pSlot->GetFormalArgument( nArgs );
        std::unique_ptr<SfxPoolItem> pItem(rArg.CreateItem());
        if ( !pItem )
        {
            SAL_WARN( "sfx", "No creator method for argument: " << rArg.pName );
            return;
        }

        sal_uInt16 nWhich = rSet.GetPool()->GetWhich(rArg.nSlotId);
        bool bConvertTwips = ( rSet.GetPool()->GetMetric( nWhich ) == MapUnit::MapTwip );
        pItem->SetWhich( nWhich );
        const SfxType* pType = rArg.pType;
        sal_uInt16 nSubCount = pType->nAttribs;
        if ( nSubCount == 0 )
        {
            // "simple" (base type) argument
            auto pProp = std::find_if(rArgs.begin(), rArgs.end(),
                [&rArg](const beans::PropertyValue& rProp) { return rProp.Name.equalsAscii(rArg.pName); });
            if (pProp != rArgs.end())
            {
#ifdef DBG_UTIL
                ++nFoundArgs;
#endif
                if( pItem->PutValue( pProp->Value, 0 ) )
                    // only use successfully converted items
                    rSet.Put( *pItem );
                else
                {
                    SAL_WARN( "sfx", "Property not convertible: " << rArg.pName );
                }
            }
        }
        else
        {
            // complex argument, could be passed in one struct
            bool bAsWholeItem = false;
            for ( const beans::PropertyValue& rProp : rArgs )
            {
                const OUString& rName = rProp.Name;
                if ( rName == OUString(rArg.pName, strlen(rArg.pName), RTL_TEXTENCODING_UTF8) )
                {
                    bAsWholeItem = true;
#ifdef DBG_UTIL
                    ++nFoundArgs;
#endif
                    if( pItem->PutValue( rProp.Value, 0 ) )
                        // only use successfully converted items
                        rSet.Put( *pItem );
                    else
                    {
                        SAL_WARN( "sfx", "Property not convertible: " << rArg.pName );
                    }
                }
            }

            if ( !bAsWholeItem )
            {
                // complex argument; collect sub items from argument array and reconstruct complex item
                // only put item if at least one member was found and had the correct type
                // (is this a good idea?! Should we ask for *all* members?)
                bool bRet = false;
                for ( const beans::PropertyValue& rProp : rArgs )
                {
                    for ( sal_uInt16 nSub=0; nSub<nSubCount; nSub++ )
                    {
                        // search sub item by name
                        OString aStr = rtl::OStringView(rArg.pName) + "." + pType->aAttrib[nSub].pName;
                        if ( rProp.Name.equalsAsciiL(aStr.getStr(), aStr.getLength()) )
                        {
                            // at least one member found ...
                            bRet = true;
#ifdef DBG_UTIL
                            ++nFoundArgs;
#endif
                            sal_uInt8 nSubId = static_cast<sal_uInt8>(static_cast<sal_Int8>(pType->aAttrib[nSub].nAID));
                            if ( bConvertTwips )
                                nSubId |= CONVERT_TWIPS;
                            if (!pItem->PutValue( rProp.Value, nSubId ) )
                            {
                                // ... but it was not convertible
                                bRet = false;
                                SAL_WARN( "sfx", "Property not convertible: " << rArg.pName );
                            }

                            break;
                        }
                    }
                }

                if ( bRet )
                    // only use successfully converted items
                    rSet.Put( *pItem );

            }
        }
    }

    // special additional parameters for some slots not seen in the slot definitions
    // Some of these slots are not considered to be used for macro recording, because they shouldn't be recorded as slots,
    // but as dispatching or factory or arbitrary URLs to the frame
    // Some also can use additional arguments that are not recordable (will be changed later,
    // f.e. "SaveAs" shouldn't support parameters not in the slot definition!)
    if ( nSlotId == SID_NEWWINDOW )
    {
        for ( const beans::PropertyValue& rProp : rArgs )
        {
            const OUString& rName = rProp.Name;
            if ( rName == sFrame )
            {
                Reference< XFrame > xFrame;
                OSL_VERIFY( rProp.Value >>= xFrame );
                rSet.Put( SfxUnoFrameItem( SID_FILLFRAME, xFrame ) );
            }
            else
            if ( rName == sHidden )
            {
                bool bVal = false;
                if (rProp.Value >>= bVal)
                    rSet.Put( SfxBoolItem( SID_HIDDEN, bVal ) );
            }
        }
    }
    else if ( bIsMediaDescriptor )
    {
        for ( const beans::PropertyValue& rProp : rArgs )
        {
#ifdef DBG_UTIL
            ++nFoundArgs;
#endif
            const OUString& aName = rProp.Name;
            if ( aName == sModel )
                rSet.Put( SfxUnoAnyItem( SID_DOCUMENT, rProp.Value ) );
            else if ( aName == sComponentData )
            {
                rSet.Put( SfxUnoAnyItem( SID_COMPONENTDATA, rProp.Value ) );
            }
            else if ( aName == sComponentContext )
            {
                rSet.Put( SfxUnoAnyItem( SID_COMPONENTCONTEXT, rProp.Value ) );
            }
            else if ( aName == sStatusInd )
            {
                Reference<task::XStatusIndicator> xVal;
                bool bOK = (rProp.Value >>= xVal);
                DBG_ASSERT( bOK, "invalid type for StatusIndicator" );
                if (bOK && xVal.is())
                    rSet.Put( SfxUnoAnyItem( SID_PROGRESS_STATUSBAR_CONTROL, rProp.Value ) );
            }
            else if ( aName == sInteractionHdl )
            {
                Reference<task::XInteractionHandler> xVal;
                bool bOK = (rProp.Value >>= xVal);
                DBG_ASSERT( bOK, "invalid type for InteractionHandler" );
                if (bOK && xVal.is())
                    rSet.Put( SfxUnoAnyItem( SID_INTERACTIONHANDLER, rProp.Value ) );
            }
            else if ( aName == sViewData )
                rSet.Put( SfxUnoAnyItem( SID_VIEW_DATA, rProp.Value ) );
            else if ( aName == sFilterData )
                rSet.Put( SfxUnoAnyItem( SID_FILTER_DATA, rProp.Value ) );
            else if ( aName == sInputStream )
            {
                Reference< XInputStream > xVal;
                bool bOK = ((rProp.Value >>= xVal) && xVal.is());
                DBG_ASSERT( bOK, "invalid type for InputStream" );
                if (bOK)
                    rSet.Put( SfxUnoAnyItem( SID_INPUTSTREAM, rProp.Value ) );
            }
            else if ( aName == sStream )
            {
                Reference< XInputStream > xVal;
                bool bOK = ((rProp.Value >>= xVal) && xVal.is());
                DBG_ASSERT( bOK, "invalid type for Stream" );
                if (bOK)
                    rSet.Put( SfxUnoAnyItem( SID_STREAM, rProp.Value ) );
            }
            else if ( aName == sUCBContent )
            {
                Reference< XContent > xVal;
                bool bOK = ((rProp.Value >>= xVal) && xVal.is());
                DBG_ASSERT( bOK, "invalid type for UCBContent" );
                if (bOK)
                    rSet.Put( SfxUnoAnyItem( SID_CONTENT, rProp.Value ) );
            }
            else if ( aName == sOutputStream )
            {
                Reference< XOutputStream > xVal;
                bool bOK = ((rProp.Value >>= xVal) && xVal.is());
                DBG_ASSERT( bOK, "invalid type for OutputStream" );
                if (bOK)
                    rSet.Put( SfxUnoAnyItem( SID_OUTPUTSTREAM, rProp.Value ) );
            }
            else if ( aName == sPostData )
            {
                Reference< XInputStream > xVal;
                bool bOK = (rProp.Value >>= xVal);
                DBG_ASSERT( bOK, "invalid type for PostData" );
                if (bOK)
                    rSet.Put( SfxUnoAnyItem( SID_POSTDATA, rProp.Value ) );
            }
            else if ( aName == sFrame )
            {
                Reference< XFrame > xFrame;
                bool bOK = (rProp.Value >>= xFrame);
                DBG_ASSERT( bOK, "invalid type for Frame" );
                if (bOK)
                    rSet.Put( SfxUnoFrameItem( SID_FILLFRAME, xFrame ) );
            }
            else if ( aName == sAsTemplate )
            {
                bool bVal = false;
                bool bOK = (rProp.Value >>= bVal);
                DBG_ASSERT( bOK, "invalid type for AsTemplate" );
                if (bOK)
                    rSet.Put( SfxBoolItem( SID_TEMPLATE, bVal ) );
            }
            else if ( aName == sOpenNewView )
            {
                bool bVal = false;
                bool bOK = (rProp.Value >>= bVal);
                DBG_ASSERT( bOK, "invalid type for OpenNewView" );
                if (bOK)
                    rSet.Put( SfxBoolItem( SID_OPEN_NEW_VIEW, bVal ) );
            }
            else if ( aName == sFailOnWarning )
            {
                bool bVal = false;
                bool bOK = (rProp.Value >>= bVal);
                DBG_ASSERT( bOK, "invalid type for FailOnWarning" );
                if (bOK)
                    rSet.Put( SfxBoolItem( SID_FAIL_ON_WARNING, bVal ) );
            }
            else if ( aName == sViewId )
            {
                sal_Int16 nVal = -1;
                bool bOK = ((rProp.Value >>= nVal) && (nVal != -1));
                DBG_ASSERT( bOK, "invalid type for ViewId" );
                if (bOK)
                    rSet.Put( SfxUInt16Item( SID_VIEW_ID, nVal ) );
            }
            else if ( aName == sPluginMode )
            {
                sal_Int16 nVal = -1;
                bool bOK = ((rProp.Value >>= nVal) && (nVal != -1));
                DBG_ASSERT( bOK, "invalid type for PluginMode" );
                if (bOK)
                    rSet.Put( SfxUInt16Item( SID_PLUGIN_MODE, nVal ) );
            }
            else if ( aName == sReadOnly )
            {
                bool bVal = false;
                bool bOK = (rProp.Value >>= bVal);
                DBG_ASSERT( bOK, "invalid type for ReadOnly" );
                if (bOK)
                    rSet.Put( SfxBoolItem( SID_DOC_READONLY, bVal ) );
            }
            else if ( aName == sDdeReconnect )
            {
                bool bVal = true;
                bool bOK = (rProp.Value >>= bVal);
                DBG_ASSERT( bOK, "invalid type for DDEReconnect" );
                if (bOK)
                    rSet.Put( SfxBoolItem( SID_DDE_RECONNECT_ONLOAD, bVal ) );
            }
            else if ( aName == sStartPresentation )
            {
                bool bVal = false;
                bool bOK = (rProp.Value >>= bVal);
                DBG_ASSERT( bOK, "invalid type for StartPresentation" );
                if (bOK)
                    rSet.Put( SfxBoolItem( SID_DOC_STARTPRESENTATION, bVal ) );
            }
            else if ( aName == sSelectionOnly )
            {
                bool bVal = false;
                bool bOK = (rProp.Value >>= bVal);
                DBG_ASSERT( bOK, "invalid type for SelectionOnly" );
                if (bOK)
                    rSet.Put( SfxBoolItem( SID_SELECTION, bVal ) );
            }
            else if ( aName == sHidden )
            {
                bool bVal = false;
                bool bOK = (rProp.Value >>= bVal);
                DBG_ASSERT( bOK, "invalid type for Hidden" );
                if (bOK)
                    rSet.Put( SfxBoolItem( SID_HIDDEN, bVal ) );
            }
            else if ( aName == sMinimized )
            {
                bool bVal = false;
                bool bOK = (rProp.Value >>= bVal);
                DBG_ASSERT( bOK, "invalid type for Minimized" );
                if (bOK)
                    rSet.Put( SfxBoolItem( SID_MINIMIZED, bVal ) );
            }
            else if ( aName == sSilent )
            {
                bool bVal = false;
                bool bOK = (rProp.Value >>= bVal);
                DBG_ASSERT( bOK, "invalid type for Silent" );
                if (bOK)
                    rSet.Put( SfxBoolItem( SID_SILENT, bVal ) );
            }
            else if ( aName == sPreview )
            {
                bool bVal = false;
                bool bOK = (rProp.Value >>= bVal);
                DBG_ASSERT( bOK, "invalid type for Preview" );
                if (bOK)
                    rSet.Put( SfxBoolItem( SID_PREVIEW, bVal ) );
            }
            else if ( aName == sViewOnly )
            {
                bool bVal = false;
                bool bOK = (rProp.Value >>= bVal);
                DBG_ASSERT( bOK, "invalid type for ViewOnly" );
                if (bOK)
                    rSet.Put( SfxBoolItem( SID_VIEWONLY, bVal ) );
            }
            else if ( aName == sDontEdit )
            {
                bool bVal = false;
                bool bOK = (rProp.Value >>= bVal);
                DBG_ASSERT( bOK, "invalid type for ViewOnly" );
                if (bOK)
                    rSet.Put( SfxBoolItem( SID_EDITDOC, !bVal ) );
            }
            else if ( aName == sUseSystemDialog )
            {
                bool bVal = false;
                bool bOK = (rProp.Value >>= bVal);
                DBG_ASSERT( bOK, "invalid type for ViewOnly" );
                if (bOK)
                    rSet.Put( SfxBoolItem( SID_FILE_DIALOG, bVal ) );
            }
            else if ( aName == sStandardDir )
            {
                OUString sVal;
                bool bOK = ((rProp.Value >>= sVal) && !sVal.isEmpty());
                DBG_ASSERT( bOK, "invalid type or value for StandardDir" );
                if (bOK)
                    rSet.Put( SfxStringItem( SID_STANDARD_DIR, sVal ) );
            }
            else if ( aName == sBlackList )
            {
                uno::Sequence<OUString> xVal;
                bool bOK = (rProp.Value >>= xVal);
                DBG_ASSERT( bOK, "invalid type or value for BlackList" );
                if (bOK)
                {
                    SfxStringListItem stringList(SID_BLACK_LIST);
                    stringList.SetStringList( xVal );
                    rSet.Put( stringList );
                }
            }
            else if ( aName == "FileName" )
            {
                OUString sVal;
                bool bOK = ((rProp.Value >>= sVal) && !sVal.isEmpty());
                DBG_ASSERT( bOK, "invalid type or value for FileName" );
                if (bOK)
                    rSet.Put( SfxStringItem( SID_FILE_NAME, sVal ) );
            }
            else if ( aName == sSalvagedFile )
            {
                OUString sVal;
                bool bOK = (rProp.Value >>= sVal);
                DBG_ASSERT( bOK, "invalid type or value for SalvagedFile" );
                if (bOK)
                    rSet.Put( SfxStringItem( SID_DOC_SALVAGE, sVal ) );
            }
            else if ( aName == sFolderName )
            {
                OUString sVal;
                bool bOK = (rProp.Value >>= sVal);
                DBG_ASSERT( bOK, "invalid type or value for FolderName" );
                if (bOK)
                    rSet.Put( SfxStringItem( SID_PATH, sVal ) );
            }
            else if ( aName == sFrameName )
            {
                OUString sVal;
                bool bOK = (rProp.Value >>= sVal);
                DBG_ASSERT( bOK, "invalid type for FrameName" );
                if (bOK && !sVal.isEmpty())
                    rSet.Put( SfxStringItem( SID_TARGETNAME, sVal ) );
            }
            else if ( aName == sMediaType )
            {
                OUString sVal;
                bool bOK = ((rProp.Value >>= sVal) && !sVal.isEmpty());
                DBG_ASSERT( bOK, "invalid type or value for MediaType" );
                if (bOK)
                    rSet.Put( SfxStringItem( SID_CONTENTTYPE, sVal ) );
            }
            else if ( aName == sTemplateName )
            {
                OUString sVal;
                bool bOK = ((rProp.Value >>= sVal) && !sVal.isEmpty());
                DBG_ASSERT( bOK, "invalid type or value for TemplateName" );
                if (bOK)
                    rSet.Put( SfxStringItem( SID_TEMPLATE_NAME, sVal ) );
            }
            else if ( aName == sTemplateRegionName )
            {
                OUString sVal;
                bool bOK = ((rProp.Value >>= sVal) && !sVal.isEmpty());
                DBG_ASSERT( bOK, "invalid type or value for TemplateRegionName" );
                if (bOK)
                    rSet.Put( SfxStringItem( SID_TEMPLATE_REGIONNAME, sVal ) );
            }
            else if ( aName == sJumpMark )
            {
                OUString sVal;
                bool bOK = ((rProp.Value >>= sVal) && !sVal.isEmpty());
                DBG_ASSERT( bOK, "invalid type or value for JumpMark" );
                if (bOK)
                    rSet.Put( SfxStringItem( SID_JUMPMARK, sVal ) );
            }
            else if ( aName == sCharacterSet )
            {
                OUString sVal;
                bool bOK = ((rProp.Value >>= sVal) && !sVal.isEmpty());
                DBG_ASSERT( bOK, "invalid type or value for CharacterSet" );
                if (bOK)
                    rSet.Put( SfxStringItem( SID_CHARSET, sVal ) );
            }
            else if ( aName == "FilterFlags" )
            {
                OUString sVal;
                bool bOK = ((rProp.Value >>= sVal) && !sVal.isEmpty());
                DBG_ASSERT( bOK, "invalid type or value for FilterFlags" );
                if (bOK)
                    rSet.Put( SfxStringItem( SID_FILE_FILTEROPTIONS, sVal ) );
            }
            else if ( aName == sImageFilter )
            {
                OUString sVal;
                bool bOK = ((rProp.Value >>= sVal) && !sVal.isEmpty());
                DBG_ASSERT( bOK, "invalid type or value for FilterFlags" );
                if (bOK)
                    rSet.Put( SfxStringItem( SID_CONVERT_IMAGES, sVal ) );
            }
            else if ( aName == sMacroExecMode )
            {
                sal_Int16 nVal =-1;
                bool bOK = ((rProp.Value >>= nVal) && (nVal != -1));
                DBG_ASSERT( bOK, "invalid type for MacroExecMode" );
                if (bOK)
                    rSet.Put( SfxUInt16Item( SID_MACROEXECMODE, nVal ) );
            }
            else if ( aName == sUpdateDocMode )
            {
                sal_Int16 nVal =-1;
                bool bOK = ((rProp.Value >>= nVal) && (nVal != -1));
                DBG_ASSERT( bOK, "invalid type for UpdateDocMode" );
                if (bOK)
                    rSet.Put( SfxUInt16Item( SID_UPDATEDOCMODE, nVal ) );
            }
            else if ( aName == sRepairPackage )
            {
                bool bVal = false;
                bool bOK = (rProp.Value >>= bVal);
                DBG_ASSERT( bOK, "invalid type for RepairPackage" );
                if (bOK)
                    rSet.Put( SfxBoolItem( SID_REPAIRPACKAGE, bVal ) );
            }
            else if ( aName == sDocumentTitle )
            {
                OUString sVal;
                bool bOK = ((rProp.Value >>= sVal) && !sVal.isEmpty());
                DBG_ASSERT( bOK, "invalid type or value for DocumentTitle" );
                if (bOK)
                    rSet.Put( SfxStringItem( SID_DOCINFO_TITLE, sVal ) );
            }
            else if ( aName == sDocumentBaseURL )
            {
                OUString sVal;
                // the base url can be set to empty ( for embedded objects for example )
                bool bOK = (rProp.Value >>= sVal);
                DBG_ASSERT( bOK, "invalid type or value for DocumentBaseURL" );
                if (bOK)
                    rSet.Put( SfxStringItem( SID_DOC_BASEURL, sVal ) );
            }
            else if ( aName == sHierarchicalDocumentName )
            {
                OUString sVal;
                bool bOK = ((rProp.Value >>= sVal) && !sVal.isEmpty());
                DBG_ASSERT( bOK, "invalid type or value for HierarchicalDocumentName" );
                if (bOK)
                    rSet.Put( SfxStringItem( SID_DOC_HIERARCHICALNAME, sVal ) );
            }
            else if ( aName == sCopyStreamIfPossible )
            {
                bool bVal = false;
                bool bOK = (rProp.Value >>= bVal);
                DBG_ASSERT( bOK, "invalid type for CopyStreamIfPossible" );
                if (bOK)
                    rSet.Put( SfxBoolItem( SID_COPY_STREAM_IF_POSSIBLE, bVal ) );
            }
            else if ( aName == sNoAutoSave )
            {
                bool bVal = false;
                bool bOK = (rProp.Value >>= bVal);
                DBG_ASSERT( bOK, "invalid type for NoAutoSave" );
                if (bOK)
                    rSet.Put( SfxBoolItem( SID_NOAUTOSAVE, bVal ) );
            }
            else if ( aName == sModifyPasswordInfo )
            {
                rSet.Put( SfxUnoAnyItem( SID_MODIFYPASSWORDINFO, rProp.Value ) );
            }
            else if ( aName == sEncryptionData )
            {
                rSet.Put( SfxUnoAnyItem( SID_ENCRYPTIONDATA, rProp.Value ) );
            }
            else if ( aName == sSuggestedSaveAsDir )
            {
                OUString sVal;
                bool bOK = ((rProp.Value >>= sVal) && !sVal.isEmpty());
                DBG_ASSERT( bOK, "invalid type or value for SuggestedSaveAsDir" );
                if (bOK)
                    rSet.Put( SfxStringItem( SID_SUGGESTEDSAVEASDIR, sVal ) );
            }
            else if ( aName == sSuggestedSaveAsName )
            {
                OUString sVal;
                bool bOK = ((rProp.Value >>= sVal) && !sVal.isEmpty());
                DBG_ASSERT( bOK, "invalid type or value for SuggestedSaveAsName" );
                if (bOK)
                    rSet.Put( SfxStringItem( SID_SUGGESTEDSAVEASNAME, sVal ) );
            }
            else if (aName == sDocumentService)
            {
                OUString aVal;
                bool bOK = ((rProp.Value >>= aVal) && !aVal.isEmpty());
                if (bOK)
                    rSet.Put(SfxStringItem(SID_DOC_SERVICE, aVal));
            }
            else if (aName == sFilterProvider)
            {
                OUString aVal;
                bool bOK = ((rProp.Value >>= aVal) && !aVal.isEmpty());
                if (bOK)
                    rSet.Put(SfxStringItem(SID_FILTER_PROVIDER, aVal));
            }
            else if (aName == sLockContentExtraction)
            {
                bool bVal = false;
                bool bOK = (rProp.Value >>= bVal);
                DBG_ASSERT( bOK, "invalid type for LockContentExtraction" );
                if (bOK)
                    rSet.Put( SfxBoolItem( SID_LOCK_CONTENT_EXTRACTION, bVal ) );
            }
            else if (aName == sLockExport)
            {
                bool bVal = false;
                bool bOK = (rProp.Value >>= bVal);
                DBG_ASSERT( bOK, "invalid type for LockExport" );
                if (bOK)
                    rSet.Put( SfxBoolItem( SID_LOCK_EXPORT, bVal ) );
            }
            else if (aName == sLockPrint)
            {
                bool bVal = false;
                bool bOK = (rProp.Value >>= bVal);
                DBG_ASSERT( bOK, "invalid type for LockPrint" );
                if (bOK)
                    rSet.Put( SfxBoolItem( SID_LOCK_PRINT, bVal ) );
            }
            else if (aName == sLockSave)
            {
                bool bVal = false;
                bool bOK = (rProp.Value >>= bVal);
                DBG_ASSERT( bOK, "invalid type for LockSave" );
                if (bOK)
                    rSet.Put( SfxBoolItem( SID_LOCK_SAVE, bVal ) );
            }
            else if (aName == sLockEditDoc)
            {
                bool bVal = false;
                bool bOK = (rProp.Value >>= bVal);
                DBG_ASSERT( bOK, "invalid type for LockEditDoc" );
                if (bOK)
                    rSet.Put( SfxBoolItem( SID_LOCK_EDITDOC, bVal ) );
            }
            else if (aName == sReplaceable)
            {
                bool bVal = false;
                bool bOK = (rProp.Value >>= bVal);
                DBG_ASSERT(bOK, "invalid type for Replaceable");
                if (bOK)
                    rSet.Put(SfxBoolItem(SID_REPLACEABLE, bVal));
            }
#ifdef DBG_UTIL
            else
                --nFoundArgs;
#endif
        }
    }
    // API to raise options dialog with a specified options ab page (#i83757#)
    else
    {
        // transform parameter "OptionsPageURL" of slot "OptionsTreeDialog"
        if ( "OptionsTreeDialog" == OUString( pSlot->pUnoName, strlen(pSlot->pUnoName), RTL_TEXTENCODING_UTF8 ) )
        {
            auto pProp = std::find_if(rArgs.begin(), rArgs.end(),
                [](const PropertyValue& rProp) { return rProp.Name == "OptionsPageURL"; });
            if (pProp != rArgs.end())
            {
                OUString sURL;
                if ( pProp->Value >>= sURL )
                    rSet.Put( SfxStringItem( SID_OPTIONS_PAGEURL, sURL ) );
            }
        }
    }
#ifdef DBG_UTIL
    if ( nFoundArgs == nCount )
    {
        // except for the "special" slots: assure that every argument was convertible
        SAL_INFO( "sfx.appl", "MacroPlayer: Some properties didn't match to any formal argument for slot: "<< pSlot->pUnoName );
    }
#endif
}

void TransformItems( sal_uInt16 nSlotId, const SfxItemSet& rSet, uno::Sequence<beans::PropertyValue>& rArgs, const SfxSlot* pSlot )
{
    if ( !pSlot )
        pSlot = SFX_SLOTPOOL().GetSlot( nSlotId );

    if ( !pSlot)
        return;

    if ( nSlotId == SID_OPENURL )
        nSlotId = SID_OPENDOC;
    if ( nSlotId == SID_SAVEASREMOTE )
        nSlotId = SID_SAVEASDOC;

    // find number of properties to avoid permanent reallocations in the sequence
    sal_Int32 nProps=0;

#ifdef DBG_UTIL
    // trace number of items and compare with number of properties for debugging purposes
    sal_Int32 nItems=0;
#endif

    const SfxType *pType = pSlot->GetType();
    if ( !pSlot->IsMode(SfxSlotMode::METHOD) )
    {
        // slot is a property
        sal_uInt16 nWhich = rSet.GetPool()->GetWhich(nSlotId);
        if ( rSet.GetItemState( nWhich ) == SfxItemState::SET ) //???
        {
            sal_uInt16 nSubCount = pType->nAttribs;
            if ( nSubCount )
                // it's a complex property, we want it split into simple types
                // so we expect to get as many items as we have (sub) members
                nProps = nSubCount;
            else
                // simple property: we expect to get exactly one item
                nProps++;
        }
        else
        {
            // we will not rely on the "toggle" ability of some property slots
            SAL_WARN( "sfx", "Processing property slot without argument: " << nSlotId );
        }

#ifdef DBG_UTIL
        nItems++;
#endif
    }
    else
    {
        // slot is a method
        bool bIsMediaDescriptor = isMediaDescriptor( nSlotId );
        sal_uInt16 nFormalArgs = bIsMediaDescriptor ? nMediaArgsCount : pSlot->GetFormalArgumentCount();
        for ( sal_uInt16 nArg=0; nArg<nFormalArgs; ++nArg )
        {
            // check every formal argument of the method
            const SfxFormalArgument &rArg = bIsMediaDescriptor ? aFormalArgs[nArg] : pSlot->GetFormalArgument( nArg );

            sal_uInt16 nWhich = rSet.GetPool()->GetWhich( rArg.nSlotId );
            if ( rSet.GetItemState( nWhich ) == SfxItemState::SET ) //???
            {
                sal_uInt16 nSubCount = rArg.pType->nAttribs;
                if ( nSubCount )
                    // argument has a complex type, we want it split into simple types
                    // so for this argument we expect to get as many items as we have (sub) members
                    nProps += nSubCount;
                else
                    // argument of simple type: we expect to get exactly one item for it
                    nProps++;
#ifdef DBG_UTIL
                nItems++;
#endif
            }
        }

        // special treatment for slots that are *not* meant to be recorded as slots (except SaveAs/To)
        if ( bIsMediaDescriptor )
        {
            sal_Int32 nAdditional=0;
            if ( rSet.GetItemState( SID_PROGRESS_STATUSBAR_CONTROL ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_INTERACTIONHANDLER ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_DOC_SALVAGE ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_PATH ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_FILE_DIALOG ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_STANDARD_DIR ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_BLACK_LIST ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_CONTENT ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_INPUTSTREAM ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_STREAM ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_OUTPUTSTREAM ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_TEMPLATE ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_OPEN_NEW_VIEW ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_FAIL_ON_WARNING ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_VIEW_ID ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_VIEW_DATA ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_FILTER_DATA ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_PLUGIN_MODE ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_DOC_READONLY ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_DDE_RECONNECT_ONLOAD ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_DOC_STARTPRESENTATION ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_SELECTION ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_CONTENTTYPE ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_POSTDATA ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_FILLFRAME ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_CHARSET ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_TARGETNAME ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_TEMPLATE_NAME ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_TEMPLATE_REGIONNAME ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_HIDDEN ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_MINIMIZED ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_PREVIEW ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_VIEWONLY ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_EDITDOC ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_SILENT ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_JUMPMARK ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_DOCUMENT ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_MACROEXECMODE ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_UPDATEDOCMODE ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_REPAIRPACKAGE ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_DOCINFO_TITLE ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_COMPONENTDATA ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_COMPONENTCONTEXT ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_DOC_BASEURL ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_DOC_HIERARCHICALNAME ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_COPY_STREAM_IF_POSSIBLE ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_NOAUTOSAVE ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_MODIFYPASSWORDINFO ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_SUGGESTEDSAVEASDIR ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_ENCRYPTIONDATA ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_SUGGESTEDSAVEASNAME ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_DOC_SERVICE ) == SfxItemState::SET )
                nAdditional++;
            if (rSet.HasItem(SID_FILTER_PROVIDER))
                ++nAdditional;
            if ( rSet.GetItemState( SID_CONVERT_IMAGES ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_LOCK_CONTENT_EXTRACTION ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_LOCK_EXPORT ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_LOCK_PRINT ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_LOCK_SAVE ) == SfxItemState::SET )
                nAdditional++;
            if ( rSet.GetItemState( SID_LOCK_EDITDOC ) == SfxItemState::SET )
                nAdditional++;
            if (rSet.GetItemState(SID_REPLACEABLE) == SfxItemState::SET)
                nAdditional++;

            // consider additional arguments
            nProps += nAdditional;
#ifdef DBG_UTIL
            nItems += nAdditional;
#endif
        }
    }

#ifdef DBG_UTIL
    // now check the itemset: is there any item that is not convertible using the list of formal arguments
    // or the table of additional items?!
    if ( rSet.Count() != nItems )
    {
        // detect unknown item and present error message
        const sal_uInt16 *pRanges = rSet.GetRanges();
        while ( *pRanges )
        {
            sal_uInt16 nStartWhich = *pRanges++;
            sal_uInt16 nEndWhich = *pRanges++;
            for(sal_uInt16 nId = nStartWhich; nId <= nEndWhich; ++nId)
            {
                if ( rSet.GetItemState(nId) < SfxItemState::SET ) //???
                    // not really set
                    continue;

                if ( !pSlot->IsMode(SfxSlotMode::METHOD) && nId == rSet.GetPool()->GetWhich( pSlot->GetSlotId() ) )
                    continue;

                bool bIsMediaDescriptor = isMediaDescriptor( nSlotId );
                sal_uInt16 nFormalArgs = bIsMediaDescriptor ? nMediaArgsCount : pSlot->nArgDefCount;
                sal_uInt16 nArg;
                for ( nArg=0; nArg<nFormalArgs; ++nArg )
                {
                    const SfxFormalArgument &rArg = bIsMediaDescriptor ? aFormalArgs[nArg] : pSlot->GetFormalArgument( nArg );
                    sal_uInt16 nWhich = rSet.GetPool()->GetWhich( rArg.nSlotId );
                    if ( nId == nWhich )
                        break;
                }

                if ( nArg<nFormalArgs )
                    continue;

                if ( bIsMediaDescriptor )
                {
                    if ( nId == SID_DOCFRAME )
                        continue;
                    if ( nId == SID_PROGRESS_STATUSBAR_CONTROL )
                        continue;
                    if ( nId == SID_INTERACTIONHANDLER )
                        continue;
                    if ( nId == SID_VIEW_DATA )
                        continue;
                    if ( nId == SID_FILTER_DATA )
                        continue;
                    if ( nId == SID_DOCUMENT )
                        continue;
                    if ( nId == SID_CONTENT )
                        continue;
                    if ( nId == SID_INPUTSTREAM )
                        continue;
                    if ( nId == SID_STREAM )
                        continue;
                    if ( nId == SID_OUTPUTSTREAM )
                        continue;
                    if ( nId == SID_POSTDATA )
                        continue;
                    if ( nId == SID_FILLFRAME )
                        continue;
                    if ( nId == SID_TEMPLATE )
                        continue;
                    if ( nId == SID_OPEN_NEW_VIEW )
                        continue;
                    if ( nId == SID_VIEW_ID )
                        continue;
                    if ( nId == SID_PLUGIN_MODE )
                        continue;
                    if ( nId == SID_DOC_READONLY )
                        continue;
                    if ( nId == SID_DOC_STARTPRESENTATION )
                        continue;
                    if ( nId == SID_SELECTION )
                        continue;
                    if ( nId == SID_HIDDEN )
                        continue;
                    if ( nId == SID_MINIMIZED )
                        continue;
                    if ( nId == SID_SILENT )
                        continue;
                    if ( nId == SID_PREVIEW )
                        continue;
                    if ( nId == SID_VIEWONLY )
                        continue;
                    if ( nId == SID_EDITDOC )
                        continue;
                    if ( nId == SID_TARGETNAME )
                        continue;
                    if ( nId == SID_DOC_SALVAGE )
                        continue;
                    if ( nId == SID_PATH )
                        continue;
                    if ( nId == SID_FILE_DIALOG )
                        continue;
                    if ( nId == SID_STANDARD_DIR )
                        continue;
                    if ( nId == SID_BLACK_LIST )
                        continue;
                    if ( nId == SID_CONTENTTYPE )
                        continue;
                    if ( nId == SID_TEMPLATE_NAME )
                        continue;
                    if ( nId == SID_TEMPLATE_REGIONNAME )
                        continue;
                    if ( nId == SID_JUMPMARK )
                        continue;
                    if ( nId == SID_CHARSET )
                        continue;
                    if ( nId == SID_MACROEXECMODE )
                        continue;
                    if ( nId == SID_UPDATEDOCMODE )
                        continue;
                    if ( nId == SID_REPAIRPACKAGE )
                        continue;
                    if ( nId == SID_DOCINFO_TITLE )
                        continue;
                    if ( nId == SID_COMPONENTDATA )
                        continue;
                    if ( nId == SID_COMPONENTCONTEXT )
                        continue;
                    if ( nId == SID_DOC_BASEURL )
                        continue;
                    if ( nId == SID_DOC_HIERARCHICALNAME )
                        continue;
                    if ( nId == SID_COPY_STREAM_IF_POSSIBLE )
                        continue;
                    if ( nId == SID_NOAUTOSAVE )
                        continue;
                    if ( nId == SID_ENCRYPTIONDATA )
                        continue;
                    if ( nId == SID_DOC_SERVICE )
                        continue;
                    if (nId == SID_FILTER_PROVIDER)
                        continue;
                    if ( nId == SID_CONVERT_IMAGES )
                        continue;

                    // used only internally
                    if ( nId == SID_SAVETO )
                        continue;
                    if ( nId == SID_SAVEACOPYITEM )
                        continue;
                    if ( nId == SID_MODIFYPASSWORDINFO )
                        continue;
                    if ( nId == SID_SUGGESTEDSAVEASDIR )
                        continue;
                    if ( nId == SID_SUGGESTEDSAVEASNAME )
                        continue;
                    if ( nId == SID_LOCK_CONTENT_EXTRACTION )
                        continue;
                    if ( nId == SID_LOCK_EXPORT )
                        continue;
                    if ( nId == SID_LOCK_PRINT )
                        continue;
                    if ( nId == SID_LOCK_SAVE )
                        continue;
                    if ( nId == SID_LOCK_EDITDOC )
                        continue;
                    if (nId == SID_REPLACEABLE)
                        continue;
               }

                OString aDbg = "Unknown item detected: " + OString::number(static_cast<sal_Int32>(nId));
                DBG_ASSERT(nArg<nFormalArgs, aDbg.getStr());
            }
        }
    }
#endif

    if ( !nProps )
        return;

    // convert every item into a property
    uno::Sequence<beans::PropertyValue> aSequ(nProps);
    beans::PropertyValue *pValue = aSequ.getArray();

    sal_Int32 nActProp=0;
    if ( !pSlot->IsMode(SfxSlotMode::METHOD) )
    {
        // slot is a property
        sal_uInt16 nWhich = rSet.GetPool()->GetWhich(nSlotId);
        bool bConvertTwips = ( rSet.GetPool()->GetMetric( nWhich ) == MapUnit::MapTwip );
        const SfxPoolItem* pItem = rSet.GetItem<SfxPoolItem>(nWhich, false);
        if ( pItem ) //???
        {
            sal_uInt16 nSubCount = pType->nAttribs;
            if ( !nSubCount )
            {
                pValue[nActProp].Name = OUString::createFromAscii(pSlot->pUnoName) ;
                if ( !pItem->QueryValue( pValue[nActProp].Value ) )
                {
                    SAL_WARN( "sfx", "Item not convertible: " << nSlotId );
                }
            }
            else
            {
                // complex type, add a property value for every member of the struct
                for ( sal_uInt16 n=1; n<=nSubCount; ++n )
                {
                    sal_uInt8 nSubId = static_cast<sal_uInt8>(static_cast<sal_Int8>(pType->aAttrib[n-1].nAID));
                    if ( bConvertTwips )
                        nSubId |= CONVERT_TWIPS;

                    DBG_ASSERT(( pType->aAttrib[n-1].nAID ) <= 127, "Member ID out of range" );
                    pValue[nActProp].Name = OUString::createFromAscii( pSlot->pUnoName ) +
                        "." +
                        OUString::createFromAscii( pType->aAttrib[n-1].pName );
                    if ( !pItem->QueryValue( pValue[nActProp++].Value, nSubId ) )
                    {
                        SAL_WARN( "sfx", "Sub item " << pType->aAttrib[n-1].nAID
                                    << " not convertible in slot: " << nSlotId );
                    }
                }
            }
        }

        rArgs = aSequ;
        return;
    }

    // slot is a method
    sal_uInt16 nFormalArgs = pSlot->GetFormalArgumentCount();
    for ( sal_uInt16 nArg=0; nArg<nFormalArgs; ++nArg )
    {
        const SfxFormalArgument &rArg = pSlot->GetFormalArgument( nArg );
        sal_uInt16 nWhich = rSet.GetPool()->GetWhich( rArg.nSlotId );
        bool bConvertTwips = ( rSet.GetPool()->GetMetric( nWhich ) == MapUnit::MapTwip );
        const SfxPoolItem* pItem = rSet.GetItem<SfxPoolItem>(nWhich, false);
        if ( pItem ) //???
        {
            sal_uInt16 nSubCount = rArg.pType->nAttribs;
            if ( !nSubCount )
            {
                pValue[nActProp].Name = OUString::createFromAscii( rArg.pName ) ;
                if ( !pItem->QueryValue( pValue[nActProp++].Value ) )
                {
                    SAL_WARN( "sfx", "Item not convertible: " << rArg.nSlotId );
                }
            }
            else
            {
                // complex type, add a property value for every member of the struct
                for ( sal_uInt16 n = 1; n <= nSubCount; ++n )
                {
                    sal_uInt8 nSubId = static_cast<sal_uInt8>(static_cast<sal_Int8>(rArg.pType->aAttrib[n-1].nAID));
                    if ( bConvertTwips )
                        nSubId |= CONVERT_TWIPS;

                    DBG_ASSERT((rArg.pType->aAttrib[n-1].nAID) <= 127, "Member ID out of range" );
                    pValue[nActProp].Name = OUString::createFromAscii( rArg.pName ) +
                        "." +
                        OUString::createFromAscii( rArg.pType->aAttrib[n-1].pName ) ;
                    if ( !pItem->QueryValue( pValue[nActProp++].Value, nSubId ) )
                    {
                        SAL_WARN( "sfx", "Sub item "
                                    << rArg.pType->aAttrib[n-1].nAID
                                    << " not convertible in slot: "
                                    << rArg.nSlotId );
                    }
                }
            }
        }
    }

    if ( nSlotId == SID_OPENDOC || nSlotId == SID_EXPORTDOC || nSlotId == SID_SAVEASDOC ||  nSlotId == SID_SAVEDOC ||
         nSlotId == SID_SAVETO || nSlotId == SID_EXPORTDOCASPDF || nSlotId == SID_DIRECTEXPORTDOCASPDF ||
         nSlotId == SID_EXPORTDOCASEPUB || nSlotId == SID_DIRECTEXPORTDOCASEPUB ||
         nSlotId == SID_REDACTDOC || nSlotId == SID_AUTOREDACTDOC || nSlotId == SID_SAVEACOPY )
    {
        const SfxPoolItem *pItem=nullptr;
        if ( rSet.GetItemState( SID_COMPONENTDATA, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sComponentData;
            pValue[nActProp++].Value = static_cast<const SfxUnoAnyItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_COMPONENTCONTEXT, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sComponentContext;
            pValue[nActProp++].Value = static_cast<const SfxUnoAnyItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_PROGRESS_STATUSBAR_CONTROL, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sStatusInd;
            pValue[nActProp++].Value = static_cast<const SfxUnoAnyItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_INTERACTIONHANDLER, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sInteractionHdl;
            pValue[nActProp++].Value = static_cast<const SfxUnoAnyItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_VIEW_DATA, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sViewData;
            pValue[nActProp++].Value = static_cast<const SfxUnoAnyItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_FILTER_DATA, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sFilterData;
            pValue[nActProp++].Value = static_cast<const SfxUnoAnyItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_DOCUMENT, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sModel;
            pValue[nActProp++].Value = static_cast<const SfxUnoAnyItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_CONTENT, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sUCBContent;
            pValue[nActProp++].Value = static_cast<const SfxUnoAnyItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_INPUTSTREAM, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sInputStream;
            pValue[nActProp++].Value = static_cast<const SfxUnoAnyItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_STREAM, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sStream;
            pValue[nActProp++].Value = static_cast<const SfxUnoAnyItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_OUTPUTSTREAM, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sOutputStream;
            pValue[nActProp++].Value = static_cast<const SfxUnoAnyItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_POSTDATA, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sPostData;
            pValue[nActProp++].Value = static_cast<const SfxUnoAnyItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_FILLFRAME, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sFrame;
            if ( auto pUsrAnyItem = dynamic_cast< const SfxUnoAnyItem *>( pItem ) )
            {
                OSL_FAIL( "TransformItems: transporting an XFrame via an SfxUnoAnyItem is not deprecated!" );
                pValue[nActProp++].Value = pUsrAnyItem->GetValue();
            }
            else if ( auto pUnoFrameItem = dynamic_cast< const SfxUnoFrameItem *>( pItem ) )
                pValue[nActProp++].Value <<= pUnoFrameItem->GetFrame();
            else
                OSL_FAIL( "TransformItems: invalid item type for SID_FILLFRAME!" );
        }
        if ( rSet.GetItemState( SID_TEMPLATE, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sAsTemplate;
            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_OPEN_NEW_VIEW, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sOpenNewView;
            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_FAIL_ON_WARNING, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sFailOnWarning;
            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_VIEW_ID, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sViewId;
            pValue[nActProp++].Value <<= static_cast<sal_Int16>(static_cast<const SfxUInt16Item*>(pItem)->GetValue());
        }
        if ( rSet.GetItemState( SID_PLUGIN_MODE, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sPluginMode;
            pValue[nActProp++].Value <<= static_cast<sal_Int16>(static_cast<const SfxUInt16Item*>(pItem)->GetValue());
        }
        if ( rSet.GetItemState( SID_DOC_READONLY, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sReadOnly;
            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_DDE_RECONNECT_ONLOAD, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sDdeReconnect;
            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_DOC_STARTPRESENTATION, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sStartPresentation;
            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_SELECTION, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sSelectionOnly;
            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_HIDDEN, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sHidden;
            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_MINIMIZED, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sMinimized;
            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_SILENT, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sSilent;
            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_PREVIEW, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sPreview;
            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_VIEWONLY, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sViewOnly;
            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_EDITDOC, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sDontEdit;
            pValue[nActProp++].Value <<= !static_cast<const SfxBoolItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_FILE_DIALOG, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sUseSystemDialog;
            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_STANDARD_DIR, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sStandardDir;
            pValue[nActProp++].Value <<= static_cast<const SfxStringItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_BLACK_LIST, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sBlackList;

            css::uno::Sequence< OUString > aList;
            static_cast<const SfxStringListItem*>(pItem)->GetStringList( aList );
            pValue[nActProp++].Value <<= aList ;
        }
        if ( rSet.GetItemState( SID_TARGETNAME, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sFrameName;
            pValue[nActProp++].Value <<= static_cast<const SfxStringItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_DOC_SALVAGE, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sSalvagedFile;
            pValue[nActProp++].Value <<= static_cast<const SfxStringItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_PATH, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sFolderName;
            pValue[nActProp++].Value <<= static_cast<const SfxStringItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_CONTENTTYPE, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sMediaType;
            pValue[nActProp++].Value <<= static_cast<const SfxStringItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_TEMPLATE_NAME, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sTemplateName;
            pValue[nActProp++].Value <<= static_cast<const SfxStringItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_TEMPLATE_REGIONNAME, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sTemplateRegionName;
            pValue[nActProp++].Value <<= static_cast<const SfxStringItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_JUMPMARK, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sJumpMark;
            pValue[nActProp++].Value <<= static_cast<const SfxStringItem*>(pItem)->GetValue();
        }

        if ( rSet.GetItemState( SID_CHARSET, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sCharacterSet;
            pValue[nActProp++].Value <<= static_cast<const SfxStringItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_MACROEXECMODE, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sMacroExecMode;
            pValue[nActProp++].Value <<= static_cast<sal_Int16>(static_cast<const SfxUInt16Item*>(pItem)->GetValue());
        }
        if ( rSet.GetItemState( SID_UPDATEDOCMODE, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sUpdateDocMode;
            pValue[nActProp++].Value <<= static_cast<sal_Int16>(static_cast<const SfxUInt16Item*>(pItem)->GetValue());
        }
        if ( rSet.GetItemState( SID_REPAIRPACKAGE, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sRepairPackage;
            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue() ;
        }
        if ( rSet.GetItemState( SID_DOCINFO_TITLE, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sDocumentTitle;
            pValue[nActProp++].Value <<= static_cast<const SfxStringItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_DOC_BASEURL, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sDocumentBaseURL;
            pValue[nActProp++].Value <<= static_cast<const SfxStringItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_DOC_HIERARCHICALNAME, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sHierarchicalDocumentName;
            pValue[nActProp++].Value <<= static_cast<const SfxStringItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_COPY_STREAM_IF_POSSIBLE, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sCopyStreamIfPossible;
            pValue[nActProp++].Value = static_cast<const SfxUnoAnyItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_NOAUTOSAVE, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sNoAutoSave;
            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue() ;
        }
        if ( rSet.GetItemState( SID_MODIFYPASSWORDINFO, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sModifyPasswordInfo;
            pValue[nActProp++].Value = static_cast<const SfxUnoAnyItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_ENCRYPTIONDATA, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sEncryptionData;
            pValue[nActProp++].Value = static_cast<const SfxUnoAnyItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_SUGGESTEDSAVEASDIR, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sSuggestedSaveAsDir;
            pValue[nActProp++].Value <<= static_cast<const SfxStringItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_SUGGESTEDSAVEASNAME, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sSuggestedSaveAsName;
            pValue[nActProp++].Value <<= static_cast<const SfxStringItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_DOC_SERVICE, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sDocumentService;
            pValue[nActProp++].Value <<= static_cast<const SfxStringItem*>(pItem)->GetValue();
        }
        if (rSet.HasItem(SID_FILTER_PROVIDER, &pItem))
        {
            pValue[nActProp].Name = sFilterProvider;
            pValue[nActProp++].Value <<= static_cast<const SfxStringItem*>(pItem)->GetValue();
        }
        if (rSet.HasItem(SID_CONVERT_IMAGES, &pItem))
        {
            pValue[nActProp].Name = sImageFilter;
            pValue[nActProp++].Value <<= static_cast<const SfxStringItem*>(pItem)->GetValue();
        }
        if ( rSet.GetItemState( SID_LOCK_CONTENT_EXTRACTION, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sLockContentExtraction;
            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue() ;
        }
        if ( rSet.GetItemState( SID_LOCK_EXPORT, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sLockExport;
            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue() ;
        }
        if ( rSet.GetItemState( SID_LOCK_PRINT, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sLockPrint;
            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue() ;
        }
        if ( rSet.GetItemState( SID_LOCK_SAVE, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sLockSave;
            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue() ;
        }
        if ( rSet.GetItemState( SID_LOCK_EDITDOC, false, &pItem ) == SfxItemState::SET )
        {
            pValue[nActProp].Name = sLockEditDoc;
            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue();
        }
        if (rSet.GetItemState(SID_REPLACEABLE, false, &pItem) == SfxItemState::SET)
        {
            pValue[nActProp].Name = sReplaceable;
            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue();
        }
    }

    rArgs = aSequ;
}

void SAL_CALL FilterOptionsContinuation::setFilterOptions(
                const uno::Sequence<beans::PropertyValue>& rProps )
{
    rProperties = rProps;
}

uno::Sequence< beans::PropertyValue > SAL_CALL
    FilterOptionsContinuation::getFilterOptions()
{
    return rProperties;
}


RequestFilterOptions::RequestFilterOptions( uno::Reference< frame::XModel > const & rModel,
                              const uno::Sequence< beans::PropertyValue >& rProperties )
{
    uno::Reference< uno::XInterface > temp2;
    document::FilterOptionsRequest aOptionsRequest( OUString(),
                                                    temp2,
                                                    rModel,
                                                    rProperties );

    m_aRequest <<= aOptionsRequest;

    m_xAbort  = new comphelper::OInteractionAbort;
    m_xOptions = new FilterOptionsContinuation;
}

uno::Any SAL_CALL RequestFilterOptions::getRequest()
{
    return m_aRequest;
}

uno::Sequence< uno::Reference< task::XInteractionContinuation > >
    SAL_CALL RequestFilterOptions::getContinuations()
{
    return { m_xAbort.get(), m_xOptions.get() };
}


class RequestPackageReparation_Impl : public ::cppu::WeakImplHelper< task::XInteractionRequest >
{
    uno::Any m_aRequest;
    rtl::Reference<comphelper::OInteractionApprove> m_xApprove;
    rtl::Reference<comphelper::OInteractionDisapprove>  m_xDisapprove;

public:
    explicit RequestPackageReparation_Impl( const OUString& aName );
    bool    isApproved() const;
    virtual uno::Any SAL_CALL getRequest() override;
    virtual uno::Sequence< uno::Reference< task::XInteractionContinuation > > SAL_CALL getContinuations() override;
};

RequestPackageReparation_Impl::RequestPackageReparation_Impl( const OUString& aName )
{
    uno::Reference< uno::XInterface > temp2;
    document::BrokenPackageRequest aBrokenPackageRequest( OUString(), temp2, aName );
    m_aRequest <<= aBrokenPackageRequest;
    m_xApprove = new comphelper::OInteractionApprove;
    m_xDisapprove = new comphelper::OInteractionDisapprove;
}

bool RequestPackageReparation_Impl::isApproved() const
{
    return m_xApprove->wasSelected();
}

uno::Any SAL_CALL RequestPackageReparation_Impl::getRequest()
{
    return m_aRequest;
}

uno::Sequence< uno::Reference< task::XInteractionContinuation > >
    SAL_CALL RequestPackageReparation_Impl::getContinuations()
{
    return { m_xApprove.get(), m_xDisapprove.get() };
}

RequestPackageReparation::RequestPackageReparation( const OUString& aName )
    : mxImpl(new RequestPackageReparation_Impl( aName ))
{
}

RequestPackageReparation::~RequestPackageReparation()
{
}

bool RequestPackageReparation::isApproved() const
{
    return mxImpl->isApproved();
}

css::uno::Reference < task::XInteractionRequest > RequestPackageReparation::GetRequest()
{
    return mxImpl.get();
}


class NotifyBrokenPackage_Impl : public ::cppu::WeakImplHelper< task::XInteractionRequest >
{
    uno::Any m_aRequest;
    rtl::Reference<comphelper::OInteractionAbort>  m_xAbort;

public:
    explicit NotifyBrokenPackage_Impl(const OUString& rName);
    virtual uno::Any SAL_CALL getRequest() override;
    virtual uno::Sequence< uno::Reference< task::XInteractionContinuation > > SAL_CALL getContinuations() override;
};

NotifyBrokenPackage_Impl::NotifyBrokenPackage_Impl( const OUString& aName )
{
    uno::Reference< uno::XInterface > temp2;
    document::BrokenPackageRequest aBrokenPackageRequest( OUString(), temp2, aName );
    m_aRequest <<= aBrokenPackageRequest;
    m_xAbort = new comphelper::OInteractionAbort;
}

uno::Any SAL_CALL NotifyBrokenPackage_Impl::getRequest()
{
    return m_aRequest;
}

uno::Sequence< uno::Reference< task::XInteractionContinuation > >
    SAL_CALL NotifyBrokenPackage_Impl::getContinuations()
{
    return { m_xAbort.get() };
}

NotifyBrokenPackage::NotifyBrokenPackage( const OUString& aName )
    : mxImpl(new NotifyBrokenPackage_Impl( aName ))
{
}

NotifyBrokenPackage::~NotifyBrokenPackage()
{
}

css::uno::Reference < task::XInteractionRequest > NotifyBrokenPackage::GetRequest()
{
    return mxImpl.get();
}

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