/* -*- 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 "elementexport.hxx"

#include "strings.hxx"

#include <utility>

#include <xmloff/xmlnamespace.hxx>

#include "eventexport.hxx"

#include "formenums.hxx"

#include "formcellbinding.hxx"

#include <xmloff/xformsexport.hxx>

#include "property_meta_data.hxx"

#include <com/sun/star/text/XText.hpp>

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

#include <com/sun/star/io/XPersistObject.hpp>

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

#include <com/sun/star/form/FormComponentType.hpp>

#include <com/sun/star/form/FormSubmitEncoding.hpp>

#include <com/sun/star/form/FormSubmitMethod.hpp>

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

#include <com/sun/star/form/NavigationBarMode.hpp>

#include <com/sun/star/form/TabulatorCycle.hpp>

#include <com/sun/star/form/FormButtonType.hpp>

#include <com/sun/star/awt/ScrollBarOrientation.hpp>

#include <com/sun/star/awt/VisualEffect.hpp>

#include <com/sun/star/form/ListSourceType.hpp>

#include <com/sun/star/awt/ImagePosition.hpp>

#include <sax/tools/converter.hxx>

#include <tools/gen.hxx>

#include <xmloff/txtprmap.hxx>

#include <com/sun/star/form/binding/XBindableValue.hpp>

#include <com/sun/star/form/binding/XListEntrySink.hpp>

#include <tools/urlobj.hxx>

#include <xmloff/xmlexp.hxx>

#include <xmloff/namespacemap.hxx>

#include <xmloff/XMLEventExport.hxx>

#include <xmloff/xmluconv.hxx>

#include <xmloff/xmltoken.hxx>

#include <xmloff/maptype.hxx>

#include <tools/time.hxx>

#include <comphelper/diagnose_ex.hxx>

#include <comphelper/extract.hxx>

#include <sal/log.hxx>

#include <algorithm>

namespace xmloff

{

    #if OSL_DEBUG_LEVEL > 0

        #define RESET_BIT( bitfield, bit ) \

            bitfield = bitfield & ~bit

    #else

        #define RESET_BIT( bitfield, bit )

    #endif

    using namespace ::xmloff::token;

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

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

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

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

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

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

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

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

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

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

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

    using namespace ::com::sun::star::form::binding;

    //= OElementExport

    OElementExport::OElementExport(IFormsExportContext& _rContext, const Reference< XPropertySet >& _rxProps,

        const Sequence< ScriptEventDescriptor >& _rEvents)

        :OPropertyExport(_rContext, _rxProps)

        ,m_aEvents(_rEvents)

    {

    }

    OElementExport::~OElementExport()

    {

    }

    void OElementExport::doExport()

    {

        // collect some general information about the element

        examine();

        // first add the attributes necessary for the element

        m_rContext.getGlobalContext().ClearAttrList();

        // add the attributes

        exportAttributes();

        // start the XML element

        implStartElement(getXMLElementName());

        // the sub elements (mostly control type dependent)

        exportSubTags();

        implEndElement();

    }

    void OElementExport::examine()

    {

        // nothing to do here

    }

    void OElementExport::exportAttributes()

    {

        // nothing to do here

    }

    void OElementExport::exportSubTags()

    {

        // the properties which where not exported 'til now

        exportRemainingProperties();

        // the script:events sub tags

        exportEvents();

    }

    void OElementExport::implStartElement(const OUString& _pName)

    {

        m_pXMLElement = std::make_unique<SvXMLElementExport>(m_rContext.getGlobalContext(), XML_NAMESPACE_FORM, _pName, true, true);

    }

    void OElementExport::implEndElement()

    {

        m_pXMLElement.reset();

    }

    void OElementExport::exportServiceNameAttribute()

    {

        Reference< XPersistObject > xPersistence(m_xProps, UNO_QUERY);

        if (!xPersistence.is())

        {

            OSL_FAIL("OElementExport::exportServiceNameAttribute: no XPersistObject!");

            return;

        }

        OUString sServiceName = xPersistence->getServiceName();

        // we don't want to write the old service name directly: it's a name used for compatibility reasons, but

        // as we start some kind of new file format here (with this xml export), we don't care about

        // compatibility ...

        // So we translate the old persistence service name into new ones, if possible

        OUString sToWriteServiceName = sServiceName;

#define CHECK_N_TRANSLATE( persistentComponent, serviceName )   \

        else if (sServiceName == persistentComponent) \

            sToWriteServiceName = serviceName

        if (sServiceName == SERVICE_PERSISTENT_COMPONENT_EDIT)

        {

            // special handling for the edit field: we have two controls using this as persistence service name

            sToWriteServiceName = SERVICE_EDIT;

            Reference< XServiceInfo > xSI(m_xProps, UNO_QUERY);

            if (xSI.is() && xSI->supportsService(SERVICE_FORMATTEDFIELD))

                sToWriteServiceName = SERVICE_FORMATTEDFIELD;

        }

        CHECK_N_TRANSLATE( SERVICE_PERSISTENT_COMPONENT_FORM,           SERVICE_FORM );

        CHECK_N_TRANSLATE( SERVICE_PERSISTENT_COMPONENT_LISTBOX,        SERVICE_LISTBOX );

        CHECK_N_TRANSLATE( SERVICE_PERSISTENT_COMPONENT_COMBOBOX,       SERVICE_COMBOBOX );

        CHECK_N_TRANSLATE( SERVICE_PERSISTENT_COMPONENT_RADIOBUTTON,    SERVICE_RADIOBUTTON );

        CHECK_N_TRANSLATE( SERVICE_PERSISTENT_COMPONENT_GROUPBOX,       SERVICE_GROUPBOX );

        CHECK_N_TRANSLATE( SERVICE_PERSISTENT_COMPONENT_FIXEDTEXT,      SERVICE_FIXEDTEXT );

        CHECK_N_TRANSLATE( SERVICE_PERSISTENT_COMPONENT_COMMANDBUTTON,  SERVICE_COMMANDBUTTON );

        CHECK_N_TRANSLATE( SERVICE_PERSISTENT_COMPONENT_CHECKBOX,       SERVICE_CHECKBOX );

        CHECK_N_TRANSLATE( SERVICE_PERSISTENT_COMPONENT_GRID,           SERVICE_GRID );

        CHECK_N_TRANSLATE( SERVICE_PERSISTENT_COMPONENT_IMAGEBUTTON,    SERVICE_IMAGEBUTTON );

        CHECK_N_TRANSLATE( SERVICE_PERSISTENT_COMPONENT_FILECONTROL,    SERVICE_FILECONTROL );

        CHECK_N_TRANSLATE( SERVICE_PERSISTENT_COMPONENT_TIMEFIELD,      SERVICE_TIMEFIELD );

        CHECK_N_TRANSLATE( SERVICE_PERSISTENT_COMPONENT_DATEFIELD,      SERVICE_DATEFIELD );

        CHECK_N_TRANSLATE( SERVICE_PERSISTENT_COMPONENT_NUMERICFIELD,   SERVICE_NUMERICFIELD );

        CHECK_N_TRANSLATE( SERVICE_PERSISTENT_COMPONENT_CURRENCYFIELD,  SERVICE_CURRENCYFIELD );

        CHECK_N_TRANSLATE( SERVICE_PERSISTENT_COMPONENT_PATTERNFIELD,   SERVICE_PATTERNFIELD );

        CHECK_N_TRANSLATE( SERVICE_PERSISTENT_COMPONENT_HIDDENCONTROL,  SERVICE_HIDDENCONTROL );

        CHECK_N_TRANSLATE( SERVICE_PERSISTENT_COMPONENT_IMAGECONTROL,   SERVICE_IMAGECONTROL );

        CHECK_N_TRANSLATE( SERVICE_PERSISTENT_COMPONENT_FORMATTEDFIELD, SERVICE_FORMATTEDFIELD );

#if OSL_DEBUG_LEVEL > 0

        Reference< XServiceInfo > xSI(m_xProps, UNO_QUERY);

        OSL_ENSURE(xSI.is() && xSI->supportsService(sToWriteServiceName),

            "OElementExport::exportServiceNameAttribute: wrong service name translation!");

#endif

        sToWriteServiceName =

            m_rContext.getGlobalContext().GetNamespaceMap().GetQNameByKey(

                XML_NAMESPACE_OOO, sToWriteServiceName );

        // now write this

        AddAttribute(

            OAttributeMetaData::getCommonControlAttributeNamespace(CCAFlags::ServiceName),

            OAttributeMetaData::getCommonControlAttributeName(CCAFlags::ServiceName),

            sToWriteServiceName);

    }

    void OElementExport::exportEvents()

    {

        if (!m_aEvents.hasElements())

            // nothing to do

            return;

        Reference< XNameReplace > xWrapper = new OEventDescriptorMapper(m_aEvents);

        m_rContext.getGlobalContext().GetEventExport().Export(xWrapper);

    }

    //= OControlExport

    OControlExport::OControlExport(IFormsExportContext& _rContext,  const Reference< XPropertySet >& _rxControl,

        OUString _sControlId, OUString _sReferringControls,

        const Sequence< ScriptEventDescriptor >& _rEvents)

        :OElementExport(_rContext, _rxControl, _rEvents)

        ,m_sControlId(std::move(_sControlId))

        ,m_sReferringControls(std::move(_sReferringControls))

        ,m_nClassId(FormComponentType::CONTROL)

        ,m_eType( UNKNOWN )

        ,m_nIncludeCommon(CCAFlags::NONE)

        ,m_nIncludeDatabase(DAFlags::NONE)

        ,m_nIncludeSpecial(SCAFlags::NONE)

        ,m_nIncludeEvents(EAFlags::NONE)

        ,m_nIncludeBindings(BAFlags::NONE)

    {

        OSL_ENSURE(m_xProps.is(), "OControlExport::OControlExport: invalid arguments!");

    }

    void OControlExport::exportOuterAttributes()

    {

        // the control id

        if (CCAFlags::Name & m_nIncludeCommon)

        {

            exportStringPropertyAttribute(

                OAttributeMetaData::getCommonControlAttributeNamespace(CCAFlags::Name),

                OAttributeMetaData::getCommonControlAttributeName(CCAFlags::Name),

                PROPERTY_NAME

                );

        #if OSL_DEBUG_LEVEL > 0

            //  reset the bit for later checking

            m_nIncludeCommon = m_nIncludeCommon & ~CCAFlags::Name;

        #endif

        }

        // the service name

        if (m_nIncludeCommon & CCAFlags::ServiceName)

        {

            exportServiceNameAttribute();

        #if OSL_DEBUG_LEVEL > 0

            //  reset the bit for later checking

            m_nIncludeCommon = m_nIncludeCommon & ~CCAFlags::ServiceName;

        #endif

        }

    }

    void OControlExport::exportInnerAttributes()

    {

        // the control id

        if (CCAFlags::ControlId & m_nIncludeCommon)

        {

            OSL_ENSURE(!m_sControlId.isEmpty(), "OControlExport::exportInnerAttributes: have no control id for the control!");

            m_rContext.getGlobalContext().AddAttributeIdLegacy(

                XML_NAMESPACE_FORM, m_sControlId);

        #if OSL_DEBUG_LEVEL > 0

            //  reset the bit for later checking

            m_nIncludeCommon = m_nIncludeCommon & ~CCAFlags::ControlId;

        #endif

        }

        // "new-style" properties ...

        exportGenericHandlerAttributes();

        // common control attributes

        exportCommonControlAttributes();

        // common database attributes

        exportDatabaseAttributes();

        // attributes related to external bindings

        exportBindingAttributes();

        // attributes special to the respective control type

        exportSpecialAttributes();

        // add the style references to the attributes

        flagStyleProperties();

    }

    void OControlExport::exportAttributes()

    {

        exportOuterAttributes();

    }

    void OControlExport::exportSubTags()

    {

        // for the upcoming exportRemainingProperties:

        // if a control has the LabelControl property, this is not stored with the control itself, but instead with

        // the control which is referenced by this property. As the base class' exportRemainingProperties doesn't

        // know anything about this, we need to prevent that it tries to export this property

        exportedProperty(PROPERTY_CONTROLLABEL);

        // if it's a control supporting XText, then we need to declare all text-related properties

        // as "already exported". This prevents them from being exported as generic "form:property"-tags.

        // *If* we would export them this way, they would be completely superfluous, and sometimes even

        // disastrous, since they may, at import time, override paragraph properties which already have

        // been set before

        Reference< XText > xControlText( m_xProps, UNO_QUERY );

        if ( xControlText.is() )

        {

            const XMLPropertyMapEntry* pCharAttributeProperties = XMLTextPropertySetMapper::getPropertyMapForType( TextPropMap::TEXT );

            while ( !pCharAttributeProperties->IsEnd() )

            {

                exportedProperty( pCharAttributeProperties->getApiName() );

                ++pCharAttributeProperties;

            }

            const XMLPropertyMapEntry* pParaAttributeProperties = XMLTextPropertySetMapper::getPropertyMapForType( TextPropMap::SHAPE_PARA );

            while ( !pParaAttributeProperties->IsEnd() )

            {

                exportedProperty( pParaAttributeProperties->getApiName() );

                ++pParaAttributeProperties;

            }

            // the RichText property is not exported. The presence of the text:p element

            // will be used - upon reading - as indicator for the value of the RichText property

            exportedProperty( PROPERTY_RICH_TEXT );

            // strange thing: paragraphs support both a CharStrikeout and a CharCrossedOut property

            // The former is a short/enum value, the latter a boolean. The former has a real meaning

            // (the strikeout type), the latter hasn't. But, when the CharCrossedOut is exported and

            // later on imported, it overwrites anything which has previously been imported for

            // CharStrikeout.

            // #i27729#

            exportedProperty( u"CharCrossedOut"_ustr );

        }

        if ( m_eType == LISTBOX )

        {

            // will be exported in exportListSourceAsElements:

            if ( controlHasUserSuppliedListEntries() )

                exportedProperty( PROPERTY_DEFAULT_SELECT_SEQ );

            // will not be exported in a generic way. Either exportListSourceAsElements cares

            // for them, or we don't need them

            exportedProperty( PROPERTY_STRING_ITEM_LIST );

            exportedProperty( PROPERTY_VALUE_SEQ );

            exportedProperty( PROPERTY_SELECT_SEQ );

            exportedProperty( PROPERTY_LISTSOURCE );

        }

        if ( m_eType == COMBOBOX )

            exportedProperty( PROPERTY_STRING_ITEM_LIST );

        // let the base class export the remaining properties and the events

        OElementExport::exportSubTags();

        // special sub tags for some controls

        switch (m_eType)

        {

            case LISTBOX:

                // don't export the list entries if the are not provided by the user, but obtained implicitly

                // from other sources

                // #i26944#

                if ( controlHasUserSuppliedListEntries() )

                    exportListSourceAsElements();

                break;

            case GRID:

            {   // a grid control requires us to store all columns as sub elements

                Reference< XIndexAccess > xColumnContainer(m_xProps, UNO_QUERY);

                OSL_ENSURE(xColumnContainer.is(), "OControlExport::exportSubTags: a grid control which is no IndexAccess?!!");

                if (xColumnContainer.is())

                    m_rContext.exportCollectionElements(xColumnContainer);

            }

            break;

            case COMBOBOX:

            {   // a combox box description has sub elements: the items

                DBG_CHECK_PROPERTY( PROPERTY_STRING_ITEM_LIST, Sequence< OUString > );

                // don't export the list entries if the are not provided by the user, but obtained implicitly

                // from other sources

                // #i26944#

                if ( controlHasUserSuppliedListEntries() )

                {

                    // get the item list

                    Sequence< OUString > aListItems;

                    m_xProps->getPropertyValue(PROPERTY_STRING_ITEM_LIST) >>= aListItems;

                    // loop through it and write the sub elements

                    for (const auto& rListItem : aListItems)

                    {

                        m_rContext.getGlobalContext().ClearAttrList();

                        AddAttribute(

                            OAttributeMetaData::getCommonControlAttributeNamespace(CCAFlags::Label),

                            OAttributeMetaData::getCommonControlAttributeName(CCAFlags::Label),

                            rListItem);

                        SvXMLElementExport aFormElement(m_rContext.getGlobalContext(), XML_NAMESPACE_FORM, u"item"_ustr, true, true);

                    }

                }

            }

            break;

            case TEXT_AREA:

            {

                // if we act as rich text control, we need to export some text:p elements

                if ( xControlText.is() )

                {

                    bool bActingAsRichText = false;

                    if ( m_xPropertyInfo->hasPropertyByName( PROPERTY_RICH_TEXT ) )

                    {

                        OSL_VERIFY(m_xProps->getPropertyValue( PROPERTY_RICH_TEXT ) >>= bActingAsRichText );

                    }

                    if ( bActingAsRichText )

                        m_rContext.getGlobalContext().GetTextParagraphExport()->exportText( xControlText );

                }

            }

            break;

            default:

                // nothing do to

                break;

        }

    }

    void OControlExport::exportGenericHandlerAttributes()

    {

        const Sequence< Property > aProperties = m_xPropertyInfo->getProperties();

        for ( auto const & prop : aProperties )

        {

            try

            {

                // see if this property can already be handled with an IPropertyHandler (which, on the long

                // term, should be the case for most, if not all, properties)

                const PropertyDescription* propDescription = metadata::getPropertyDescription( prop.Name );

                if ( propDescription == nullptr )

                    continue;

                // let the factory provide the concrete handler. Note that caching, if desired, is the task

                // of the factory

                PPropertyHandler handler = (*propDescription->factory)( propDescription->propertyId );

                if ( !handler )

                {

                    SAL_WARN( "xmloff.forms", "OControlExport::exportGenericHandlerAttributes: invalid property handler provided by the factory!" );

                    continue;

                }

                // that's a property which has a direct mapping to an attribute

                if ( !shouldExportProperty( prop.Name ) )

                    // TODO: in the future, we surely need a more sophisticated approach to this, involving the property

                    // handler, or the property description

                {

                    exportedProperty( prop.Name );

                    continue;

                }

                const Any propValue = m_xProps->getPropertyValue( prop.Name );

                OUString attributeValue = handler->getAttributeValue( propValue );

                AddAttribute(

                    propDescription->attribute.namespacePrefix,

                    token::GetXMLToken( propDescription->attribute.attributeToken ),

                    attributeValue

                );

                exportedProperty( prop.Name );

            }

            catch( const Exception& )

            {

                DBG_UNHANDLED_EXCEPTION("xmloff.forms");

            }

        }

    }

    void OControlExport::exportCommonControlAttributes()

    {

        size_t i=0;

        // I decided to handle all the properties here with some static arrays describing the property-attribute

        // relations. This leads to somewhat ugly code :), but the only alternative I can think of right now

        // would require maps and O(log n) searches, which seems somewhat expensive as this code is used

        // very frequently.

        // the extra indents for the respective blocks are to ensure that there is no copy'n'paste error, using

        // map identifiers from the wrong block

        // some string properties

        {

            // the attribute ids of all properties which are expected to be of type string

            static const CCAFlags nStringPropertyAttributeIds[] =

            {

                CCAFlags::Label, CCAFlags::Title

            };

            // the names of all properties which are expected to be of type string

            static constexpr OUString aStringPropertyNames[] =

            {

                PROPERTY_LABEL, PROPERTY_TITLE

            };

            OSL_ENSURE( std::size(aStringPropertyNames) ==

                        std::size(nStringPropertyAttributeIds),

                        "OControlExport::exportCommonControlAttributes: somebody tampered with the maps (1)!");

            for (i=0; i<std::size(nStringPropertyAttributeIds); ++i)

                if (nStringPropertyAttributeIds[i] & m_nIncludeCommon)

                {

                    exportStringPropertyAttribute(

                        OAttributeMetaData::getCommonControlAttributeNamespace(nStringPropertyAttributeIds[i]),

                        OAttributeMetaData::getCommonControlAttributeName(nStringPropertyAttributeIds[i]),

                        aStringPropertyNames[i]

                        );

                #if OSL_DEBUG_LEVEL > 0

                    //  reset the bit for later checking

                    m_nIncludeCommon = m_nIncludeCommon & ~nStringPropertyAttributeIds[i];

                #endif

                }

        }

        // some boolean properties

        {

            static const CCAFlags nBooleanPropertyAttributeIds[] =

            {   // attribute flags

                CCAFlags::CurrentSelected, CCAFlags::Disabled, CCAFlags::Dropdown, CCAFlags::Printable, CCAFlags::ReadOnly, CCAFlags::Selected, CCAFlags::TabStop, CCAFlags::EnableVisible

            };

            static constexpr OUString pBooleanPropertyNames[] =

            {   // property names

                PROPERTY_STATE, PROPERTY_ENABLED,

                PROPERTY_DROPDOWN, PROPERTY_PRINTABLE,

                PROPERTY_READONLY, PROPERTY_DEFAULT_STATE,

                PROPERTY_TABSTOP, PROPERTY_ENABLEVISIBLE

            };

            static const BoolAttrFlags nBooleanPropertyAttrFlags[] =

            {   // attribute defaults

                BoolAttrFlags::DefaultFalse, BoolAttrFlags::DefaultFalse | BoolAttrFlags::InverseSemantics, BoolAttrFlags::DefaultFalse, BoolAttrFlags::DefaultTrue, BoolAttrFlags::DefaultFalse, BoolAttrFlags::DefaultFalse, BoolAttrFlags::DefaultVoid, BoolAttrFlags::DefaultFalse

            };

        #if OSL_DEBUG_LEVEL > 0

            static const sal_Int32 nIdCount = std::size(nBooleanPropertyAttributeIds);

            static const sal_Int32 nNameCount = std::size(pBooleanPropertyNames);

            static const sal_Int32 nFlagsCount = std::size(nBooleanPropertyAttrFlags);

            OSL_ENSURE((nIdCount == nNameCount) && (nNameCount == nFlagsCount),

                "OControlExport::exportCommonControlAttributes: somebody tampered with the maps (2)!");

        #endif

            for (i=0; i<std::size(nBooleanPropertyAttributeIds); ++i)

                if (nBooleanPropertyAttributeIds[i] & m_nIncludeCommon)

                {

                    exportBooleanPropertyAttribute(

                        OAttributeMetaData::getCommonControlAttributeNamespace(nBooleanPropertyAttributeIds[i]),

                        OAttributeMetaData::getCommonControlAttributeName(nBooleanPropertyAttributeIds[i]),

                        pBooleanPropertyNames[i],

                        nBooleanPropertyAttrFlags[i]);

        #if OSL_DEBUG_LEVEL > 0

                    //  reset the bit for later checking

                    m_nIncludeCommon = m_nIncludeCommon & ~nBooleanPropertyAttributeIds[i];

        #endif

                }

        }

        // some integer properties

        {

            // now the common handling

            static const CCAFlags nIntegerPropertyAttributeIds[] =

            {   // attribute flags

                CCAFlags::Size, CCAFlags::TabIndex

            };

            static constexpr OUString pIntegerPropertyNames[] =

            {   // property names

                PROPERTY_LINECOUNT, PROPERTY_TABINDEX

            };

            static const sal_Int16 nIntegerPropertyAttrDefaults[] =

            {   // attribute defaults

                5, 0

            };

            if ( m_nIncludeCommon & CCAFlags::MaxLength )

                exportedProperty(PROPERTY_MAXTEXTLENGTH);

        #if OSL_DEBUG_LEVEL > 0

            static const sal_Int32 nIdCount = std::size(nIntegerPropertyAttributeIds);

            static const sal_Int32 nNameCount = std::size(pIntegerPropertyNames);

            static const sal_Int32 nDefaultCount = std::size(nIntegerPropertyAttrDefaults);

            OSL_ENSURE((nIdCount == nNameCount) && (nNameCount == nDefaultCount),

                "OControlExport::exportCommonControlAttributes: somebody tampered with the maps (3)!");

        #endif

            for (i=0; i<std::size(nIntegerPropertyAttributeIds); ++i)

                if (nIntegerPropertyAttributeIds[i] & m_nIncludeCommon)

                {

                    exportInt16PropertyAttribute(

                        OAttributeMetaData::getCommonControlAttributeNamespace(nIntegerPropertyAttributeIds[i]),

                        OAttributeMetaData::getCommonControlAttributeName(nIntegerPropertyAttributeIds[i]),

                        pIntegerPropertyNames[i],

                        nIntegerPropertyAttrDefaults[i]);

        #if OSL_DEBUG_LEVEL > 0

                    //  reset the bit for later checking

                    m_nIncludeCommon = m_nIncludeCommon & ~nIntegerPropertyAttributeIds[i];

        #endif

                }

        }

        // some enum properties

        {

            if (m_nIncludeCommon & CCAFlags::ButtonType)

            {

                exportEnumPropertyAttribute(

                    OAttributeMetaData::getCommonControlAttributeNamespace(CCAFlags::ButtonType),

                    OAttributeMetaData::getCommonControlAttributeName(CCAFlags::ButtonType),

                    PROPERTY_BUTTONTYPE,

                    aFormButtonTypeMap,

                    FormButtonType_PUSH);

        #if OSL_DEBUG_LEVEL > 0

                //  reset the bit for later checking

                m_nIncludeCommon = m_nIncludeCommon & ~CCAFlags::ButtonType;

        #endif

            }

            if ( m_nIncludeCommon & CCAFlags::Orientation )

            {

                exportEnumPropertyAttribute(

                    OAttributeMetaData::getCommonControlAttributeNamespace( CCAFlags::Orientation ),

                    OAttributeMetaData::getCommonControlAttributeName( CCAFlags::Orientation ),

                    PROPERTY_ORIENTATION,

                    aOrientationMap,

                    ScrollBarOrientation::HORIZONTAL

                );

        #if OSL_DEBUG_LEVEL > 0

                //  reset the bit for later checking

                m_nIncludeCommon = m_nIncludeCommon & ~CCAFlags::Orientation;

        #endif

            }

            if ( m_nIncludeCommon & CCAFlags::VisualEffect )

            {

                exportEnumPropertyAttribute(

                    OAttributeMetaData::getCommonControlAttributeNamespace( CCAFlags::VisualEffect ),

                    OAttributeMetaData::getCommonControlAttributeName( CCAFlags::VisualEffect ),

                    PROPERTY_VISUAL_EFFECT,

                    aVisualEffectMap,

                    VisualEffect::LOOK3D

                );

            #if OSL_DEBUG_LEVEL > 0

                //  reset the bit for later checking

                m_nIncludeCommon = m_nIncludeCommon & ~CCAFlags::VisualEffect;

            #endif

            }

        }

        // some properties which require a special handling

        // the target frame

        if (m_nIncludeCommon & CCAFlags::TargetFrame)

        {

            exportTargetFrameAttribute();

        #if OSL_DEBUG_LEVEL > 0

            //  reset the bit for later checking

            m_nIncludeCommon = m_nIncludeCommon & ~CCAFlags::TargetFrame;

        #endif

        }

        // max text length

        if ( m_nIncludeCommon & CCAFlags::MaxLength )

        {

            // normally, the respective property would be "MaxTextLen"

            // However, if the model has a property "PersistenceMaxTextLength", then we prefer this

            // determine the name of the property to export

            OUString sTextLenPropertyName( PROPERTY_MAXTEXTLENGTH );

            if ( m_xPropertyInfo->hasPropertyByName( PROPERTY_PERSISTENCE_MAXTEXTLENGTH ) )

                sTextLenPropertyName = PROPERTY_PERSISTENCE_MAXTEXTLENGTH;

            // export it

            exportInt16PropertyAttribute(

                OAttributeMetaData::getCommonControlAttributeNamespace( CCAFlags::MaxLength ),

                OAttributeMetaData::getCommonControlAttributeName( CCAFlags::MaxLength ),

                sTextLenPropertyName,

                0

            );

            // in either way, both properties count as "exported"

            exportedProperty( PROPERTY_MAXTEXTLENGTH );

            exportedProperty( PROPERTY_PERSISTENCE_MAXTEXTLENGTH );

        #if OSL_DEBUG_LEVEL > 0

            //  reset the bit for later checking

            m_nIncludeCommon = m_nIncludeCommon & ~CCAFlags::MaxLength;

        #endif

        }

        if (m_nIncludeCommon & CCAFlags::TargetLocation)

        {

            exportTargetLocationAttribute(false);

        #if OSL_DEBUG_LEVEL > 0

            //  reset the bit for later checking

            m_nIncludeCommon = m_nIncludeCommon & ~CCAFlags::TargetLocation;

        #endif

        }

        // OJ #99721#

        if (m_nIncludeCommon & CCAFlags::ImageData)

        {

            exportImageDataAttribute();

        #if OSL_DEBUG_LEVEL > 0

            //  reset the bit for later checking

            m_nIncludeCommon = m_nIncludeCommon & ~CCAFlags::ImageData;

        #endif

        }

        // the for attribute

        // the target frame

        if (m_nIncludeCommon & CCAFlags::For)

        {

            if (!m_sReferringControls.isEmpty())

            {   // there is at least one control referring to the one we're handling currently

                AddAttribute(

                    OAttributeMetaData::getCommonControlAttributeNamespace(CCAFlags::For),

                    OAttributeMetaData::getCommonControlAttributeName(CCAFlags::For),

                    m_sReferringControls);

            }

        #if OSL_DEBUG_LEVEL > 0

            //  reset the bit for later checking

            m_nIncludeCommon = m_nIncludeCommon & ~CCAFlags::For;

        #endif

        }

        if ((CCAFlags::CurrentValue | CCAFlags::Value) & m_nIncludeCommon)

        {

            OUString pCurrentValuePropertyName;

            OUString pValuePropertyName;

            // get the property names

            getValuePropertyNames(m_eType, m_nClassId, pCurrentValuePropertyName, pValuePropertyName);

            // add the attributes if necessary and possible

            if (!pCurrentValuePropertyName.isEmpty() && (CCAFlags::CurrentValue & m_nIncludeCommon))

            {

                static const OUString pCurrentValueAttributeName = OAttributeMetaData::getCommonControlAttributeName(CCAFlags::CurrentValue);

                // don't export the current-value if this value originates from a data binding

                // #i26944#

                if ( controlHasActiveDataBinding() )

                    exportedProperty( pCurrentValuePropertyName );

                else

                {

                    static const sal_uInt16 nCurrentValueAttributeNamespaceKey = OAttributeMetaData::getCommonControlAttributeNamespace(CCAFlags::CurrentValue);

                    exportGenericPropertyAttribute(

                        nCurrentValueAttributeNamespaceKey,

                        pCurrentValueAttributeName,

                        pCurrentValuePropertyName

                    );

                }

            }

            if (!pValuePropertyName.isEmpty() && (CCAFlags::Value & m_nIncludeCommon))

            {

                static const OUString pValueAttributeName = OAttributeMetaData::getCommonControlAttributeName(CCAFlags::Value);

                static const sal_uInt16 nValueAttributeNamespaceKey = OAttributeMetaData::getCommonControlAttributeNamespace(CCAFlags::Value);

                exportGenericPropertyAttribute(

                    nValueAttributeNamespaceKey,

                    pValueAttributeName,

                    pValuePropertyName);

            }

            OSL_ENSURE((pValuePropertyName.isEmpty()) == (CCAFlags::NONE == (CCAFlags::Value & m_nIncludeCommon)),

                "OControlExport::exportCommonControlAttributes: no property found for the value attribute!");

            OSL_ENSURE((pCurrentValuePropertyName.isEmpty()) == (CCAFlags::NONE == (CCAFlags::CurrentValue & m_nIncludeCommon)),

                "OControlExport::exportCommonControlAttributes: no property found for the current-value attribute!");

        #if OSL_DEBUG_LEVEL > 0

            //  reset the bit for later checking

            m_nIncludeCommon = m_nIncludeCommon & ~CCAFlags(CCAFlags::CurrentValue | CCAFlags::Value);

        #endif

        }

        OSL_ENSURE(CCAFlags::NONE == m_nIncludeCommon,

            "OControlExport::exportCommonControlAttributes: forgot some flags!");

            // in the dbg_util version, we should have removed every bit we handled from the mask, so it should

            // be 0 now ...

    }

    void OControlExport::exportDatabaseAttributes()

    {

#if OSL_DEBUG_LEVEL > 0

        DAFlags nIncludeDatabase = m_nIncludeDatabase;

#endif

        // the only string property: DataField

        if (DAFlags::DataField & m_nIncludeDatabase)

        {

            exportStringPropertyAttribute(

                OAttributeMetaData::getDatabaseAttributeNamespace(),

                OAttributeMetaData::getDatabaseAttributeName(DAFlags::DataField),

                PROPERTY_DATAFIELD);

            RESET_BIT( nIncludeDatabase, DAFlags::DataField );

        }

        // InputRequired

        if ( DAFlags::InputRequired & m_nIncludeDatabase )

        {

            exportBooleanPropertyAttribute(

                OAttributeMetaData::getDatabaseAttributeNamespace(),

                OAttributeMetaData::getDatabaseAttributeName( DAFlags::InputRequired ),

                PROPERTY_INPUT_REQUIRED,

                BoolAttrFlags::DefaultFalse | BoolAttrFlags::DefaultVoid

            );

            RESET_BIT( nIncludeDatabase, DAFlags::InputRequired );

        }

        // the only int16 property: BoundColumn

        if (DAFlags::BoundColumn & m_nIncludeDatabase)

        {

            exportInt16PropertyAttribute(

                OAttributeMetaData::getDatabaseAttributeNamespace(),

                OAttributeMetaData::getDatabaseAttributeName(DAFlags::BoundColumn),

                PROPERTY_BOUNDCOLUMN,

                0,

                true);

            RESET_BIT( nIncludeDatabase, DAFlags::BoundColumn );

        }

        // ConvertEmptyToNull

        if (DAFlags::ConvertEmpty & m_nIncludeDatabase)

        {

            exportBooleanPropertyAttribute(

                OAttributeMetaData::getDatabaseAttributeNamespace(),

                OAttributeMetaData::getDatabaseAttributeName(DAFlags::ConvertEmpty),

                PROPERTY_EMPTY_IS_NULL,

                BoolAttrFlags::DefaultFalse

                );

            RESET_BIT( nIncludeDatabase, DAFlags::ConvertEmpty );

        }

        // the only enum property: ListSourceType

        if (DAFlags::ListSource_TYPE & m_nIncludeDatabase)

        {

            exportEnumPropertyAttribute(

                OAttributeMetaData::getDatabaseAttributeNamespace(),

                OAttributeMetaData::getDatabaseAttributeName(DAFlags::ListSource_TYPE),

                PROPERTY_LISTSOURCETYPE,

                aListSourceTypeMap,

                ListSourceType_VALUELIST

                );

            RESET_BIT( nIncludeDatabase, DAFlags::ListSource_TYPE );

        }

        if (m_nIncludeDatabase & DAFlags::ListSource)

        {

            exportListSourceAsAttribute();

            RESET_BIT( nIncludeDatabase, DAFlags::ListSource );

        }

#if OSL_DEBUG_LEVEL > 0

        OSL_ENSURE(DAFlags::NONE == nIncludeDatabase,

            "OControlExport::exportDatabaseAttributes: forgot some flags!");

            // in the dbg_util version, we should have removed every bit we handled from the mask, so it should

            // be 0 now ...

#endif

    }

    void OControlExport::exportBindingAttributes()

    {

#if OSL_DEBUG_LEVEL > 0

        BAFlags nIncludeBinding = m_nIncludeBindings;

#endif

        if ( m_nIncludeBindings & BAFlags::LinkedCell )

        {

            exportCellBindingAttributes( bool(m_nIncludeBindings & BAFlags::ListLinkingType) );

        #if OSL_DEBUG_LEVEL > 0

            //  reset the bit for later checking

            nIncludeBinding = nIncludeBinding & ~BAFlags( BAFlags::LinkedCell | BAFlags::ListLinkingType );

        #endif

        }

        if ( m_nIncludeBindings & BAFlags::ListCellRange )

        {

            exportCellListSourceRange();

        #if OSL_DEBUG_LEVEL > 0

            //  reset the bit for later checking

            nIncludeBinding = nIncludeBinding & ~BAFlags::ListCellRange;

        #endif

        }

        if ( m_nIncludeBindings & BAFlags::XFormsBind )

        {

            exportXFormsBindAttributes();

        #if OSL_DEBUG_LEVEL > 0

            //  reset the bit for later checking

            nIncludeBinding = nIncludeBinding & ~BAFlags::XFormsBind;

        #endif

        }

        if ( m_nIncludeBindings & BAFlags::XFormsListBind )

        {

            exportXFormsListAttributes();

        #if OSL_DEBUG_LEVEL > 0

            //  reset the bit for later checking

            nIncludeBinding = nIncludeBinding & ~BAFlags::XFormsListBind;

        #endif

        }

        if ( m_nIncludeBindings & BAFlags::XFormsSubmission )

        {

            exportXFormsSubmissionAttributes();

        #if OSL_DEBUG_LEVEL > 0

            //  reset the bit for later checking

            nIncludeBinding = nIncludeBinding & ~BAFlags::XFormsSubmission;

        #endif

        }

        #if OSL_DEBUG_LEVEL > 0

        OSL_ENSURE( BAFlags::NONE == nIncludeBinding,

            "OControlExport::exportBindingAttributes: forgot some flags!");

            // in the debug version, we should have removed every bit we handled from the mask, so it should

            // be 0 now ...

        #endif

    }

    void OControlExport::exportSpecialAttributes()

    {

        sal_Int32 i=0;

        // the boolean properties

        {

            static const SCAFlags nBooleanPropertyAttributeIds[] =

            {   // attribute flags

                SCAFlags::Validation, SCAFlags::MultiLine, SCAFlags::AutoCompletion, SCAFlags::Multiple, SCAFlags::DefaultButton, SCAFlags::IsTristate,

                SCAFlags::Toggle, SCAFlags::FocusOnClick

            };

            static constexpr OUString pBooleanPropertyNames[] =

            {   // property names

                PROPERTY_STRICTFORMAT, PROPERTY_MULTILINE,