xref: /aoo41x/main/xmloff/source/forms/elementexport.cxx (revision 63bba73c)

/**************************************************************
 *
 * 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
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_xmloff.hxx"

#include "elementexport.hxx"
#include "strings.hxx"
#include "xmloff/xmlnmspe.hxx"
#include "eventexport.hxx"
#include "formenums.hxx"
#include "formcellbinding.hxx"
#include "formcellbinding.hxx"
#include "xmloff/xformsexport.hxx"
#include "property_meta_data.hxx"

/** === begin UNO includes === **/
#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/form/FormComponentType.hpp>
#include <com/sun/star/beans/PropertyAttribute.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>
/** === end UNO includes === **/

#include <tools/wintypes.hxx>		// for check states
#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/nmspmap.hxx>
#include <xmloff/XMLEventExport.hxx>
#include <xmloff/xmluconv.hxx>
#include <xmloff/xmltoken.hxx>
#include <tools/time.hxx>
#include <tools/diagnose_ex.h>
#include <comphelper/extract.hxx>

#include <stdio.h>
#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::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::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::table;
	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)
		,m_pXMLElement(NULL)
	{
	}

	//---------------------------------------------------------------------
	OElementExport::~OElementExport()
	{
		implEndElement();
	}

	//---------------------------------------------------------------------
	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 sal_Char* _pName)
	{
		m_pXMLElement = new SvXMLElementExport(m_rContext.getGlobalContext(), XML_NAMESPACE_FORM, _pName, sal_True, sal_True);
	}

	//---------------------------------------------------------------------
	void OElementExport::implEndElement()
	{
		delete m_pXMLElement;
		m_pXMLElement = NULL;
	}

	//---------------------------------------------------------------------
	void OElementExport::exportServiceNameAttribute()
	{
		Reference< XPersistObject > xPersistence(m_xProps, UNO_QUERY);
		if (!xPersistence.is())
		{
			OSL_ENSURE(sal_False, "OElementExport::exportServiceNameAttribute: no XPersistObject!");
			return;
		}

		::rtl::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

		::rtl::OUString sToWriteServiceName = sServiceName;
#define CHECK_N_TRANSLATE( name )	\
		else if (0 == sServiceName.compareToAscii(SERVICE_PERSISTENT_COMPONENT_##name))	\
			sToWriteServiceName = SERVICE_##name

		if (sal_False)
			;
		CHECK_N_TRANSLATE( FORM );
		CHECK_N_TRANSLATE( FORM );
		CHECK_N_TRANSLATE( LISTBOX );
		CHECK_N_TRANSLATE( COMBOBOX );
		CHECK_N_TRANSLATE( RADIOBUTTON );
		CHECK_N_TRANSLATE( GROUPBOX );
		CHECK_N_TRANSLATE( FIXEDTEXT );
		CHECK_N_TRANSLATE( COMMANDBUTTON );
		CHECK_N_TRANSLATE( CHECKBOX );
		CHECK_N_TRANSLATE( GRID );
		CHECK_N_TRANSLATE( IMAGEBUTTON );
		CHECK_N_TRANSLATE( FILECONTROL );
		CHECK_N_TRANSLATE( TIMEFIELD );
		CHECK_N_TRANSLATE( DATEFIELD );
		CHECK_N_TRANSLATE( NUMERICFIELD );
		CHECK_N_TRANSLATE( CURRENCYFIELD );
		CHECK_N_TRANSLATE( PATTERNFIELD );
		CHECK_N_TRANSLATE( HIDDENCONTROL );
		CHECK_N_TRANSLATE( IMAGECONTROL );
		CHECK_N_TRANSLATE( FORMATTEDFIELD );
		else if (0 == sServiceName.compareToAscii(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;
		}
#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(CCA_SERVICE_NAME),
			OAttributeMetaData::getCommonControlAttributeName(CCA_SERVICE_NAME),
			sToWriteServiceName);
	}

	//---------------------------------------------------------------------
	void OElementExport::exportEvents()
	{
		if (!m_aEvents.getLength())
			// 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,
		const ::rtl::OUString& _rControlId, const ::rtl::OUString& _rReferringControls,
		const Sequence< ScriptEventDescriptor >& _rEvents)
		:OElementExport(_rContext, _rxControl, _rEvents)
		,m_sControlId(_rControlId)
		,m_sReferringControls(_rReferringControls)
        ,m_nClassId(FormComponentType::CONTROL)
        ,m_eType( UNKNOWN )
		,m_nIncludeCommon(0)
		,m_nIncludeDatabase(0)
		,m_nIncludeSpecial(0)
		,m_nIncludeEvents(0)
        ,m_nIncludeBindings(0)
		,m_pOuterElement(NULL)
	{
		OSL_ENSURE(m_xProps.is(), "OControlExport::OControlExport: invalid arguments!");
	}

	//---------------------------------------------------------------------
	OControlExport::~OControlExport()
	{
		implEndElement();
	}

	//---------------------------------------------------------------------
	void OControlExport::exportOuterAttributes()
	{
		// the control id
		if (CCA_NAME & m_nIncludeCommon)
		{
			exportStringPropertyAttribute(
				OAttributeMetaData::getCommonControlAttributeNamespace(CCA_NAME),
				OAttributeMetaData::getCommonControlAttributeName(CCA_NAME),
				PROPERTY_NAME
				);
        #if OSL_DEBUG_LEVEL > 0
			//  reset the bit for later checking
			m_nIncludeCommon = m_nIncludeCommon & ~CCA_NAME;
		#endif
		}

		// the service name
		if (m_nIncludeCommon & CCA_SERVICE_NAME)
		{
			exportServiceNameAttribute();
		#if OSL_DEBUG_LEVEL > 0
			//  reset the bit for later checking
			m_nIncludeCommon = m_nIncludeCommon & ~CCA_SERVICE_NAME;
		#endif
		}
	}

	//---------------------------------------------------------------------
	void OControlExport::exportInnerAttributes()
	{
		// the control id
		if (CCA_CONTROL_ID & m_nIncludeCommon)
		{
			OSL_ENSURE(m_sControlId.getLength(), "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 & ~CCA_CONTROL_ID;
		#endif
		}

        // "new-style" properties ...
        exportGenericHandlerAttributes();

        // common control attributes
		exportCommonControlAttributes();

		// common database attributes
		exportDatabaseAttributes();

        // attributes related to external bindings
        exportBindingAtributes();

		// attributes special to the respective control type
		exportSpecialAttributes();

		// add the style references to the attributes
		flagStyleProperties();
	}

	//---------------------------------------------------------------------
	void OControlExport::exportAttributes()
	{
		exportOuterAttributes();
	}

	//---------------------------------------------------------------------
	void OControlExport::exportSubTags() throw (Exception)
	{
		// 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( TEXT_PROP_MAP_TEXT );
            while ( pCharAttributeProperties->msApiName )
            {
                exportedProperty( ::rtl::OUString::createFromAscii( pCharAttributeProperties->msApiName ) );
                ++pCharAttributeProperties;
            }

            const XMLPropertyMapEntry* pParaAttributeProperties = XMLTextPropertySetMapper::getPropertyMapForType( TEXT_PROP_MAP_SHAPE_PARA );
            while ( pParaAttributeProperties->msApiName )
            {
                exportedProperty( ::rtl::OUString::createFromAscii( pParaAttributeProperties->msApiName ) );
                ++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.
            // 2004-04-14 - #i27729# - fs@openoffice.org
            exportedProperty( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "CharCrossedOut" ) ) );
        }

        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# - 2004-05-17 - fs@openoffice.org
                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< ::rtl::OUString > );

                // don't export the list entries if the are not provided by the user, but obtained implicitly
                // from other sources
                // #i26944# - 2004-05-17 - fs@openoffice.org
                if ( controlHasUserSuppliedListEntries() )
                {
				    // get the item list
				    Sequence< ::rtl::OUString > aListItems;
				    m_xProps->getPropertyValue(PROPERTY_STRING_ITEM_LIST) >>= aListItems;
				    // loop through it and write the sub elements
				    const ::rtl::OUString* pListItems = aListItems.getConstArray();
				    for (sal_Int32 i=0; i<aListItems.getLength(); ++i, ++pListItems)
				    {
					    m_rContext.getGlobalContext().ClearAttrList();
					    AddAttribute(
						    OAttributeMetaData::getCommonControlAttributeNamespace(CCA_LABEL),
						    OAttributeMetaData::getCommonControlAttributeName(CCA_LABEL),
						    *pListItems);
					    SvXMLElementExport aFormElement(m_rContext.getGlobalContext(), XML_NAMESPACE_FORM, "item", sal_True, sal_True);
				    }
                }
			}
			break;

            case TEXT_AREA:
            {
                // if we act as rich text control, we need to export some text:p elements
                if ( xControlText.is() )
                {
                    sal_Bool bActingAsRichText = sal_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 (   const Property* prop = aProperties.getConstArray();
                prop != aProperties.getConstArray() + aProperties.getLength();
                ++prop
            )
        {
            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 == NULL )
                    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 );
                ENSURE_OR_CONTINUE( handler.get() != NULL,
                    "OControlExport::exportGenericHandlerAttributes: invalid property handler provided by the factory!" );

                ::rtl::OUString attributeValue;
                if ( propDescription->propertyGroup == NO_GROUP )
                {
                    // 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 );
                    attributeValue = handler->getAttributeValue( propValue );
                }
                else
                {
                    // that's a property which is part of a group of properties, whose values, in their entity, comprise
                    // a single attribute value

                    // retrieve the descriptions of all other properties which add to the attribute value
                    PropertyDescriptionList descriptions;
                    metadata::getPropertyGroup( propDescription->propertyGroup, descriptions );

                    // retrieve the values for all those properties
                    PropertyValues aValues;
                    for (   PropertyDescriptionList::iterator desc = descriptions.begin();
                            desc != descriptions.end();
                            ++desc
                        )
                    {
                        // TODO: XMultiPropertySet?
                        const Any propValue = m_xProps->getPropertyValue( (*desc)->propertyName );
                        aValues[ (*desc)->propertyId ] = propValue;
                    }

                    // let the handler translate into an XML attribute value
                    attributeValue = handler->getAttributeValue( aValues );
                }

			    AddAttribute(
				    propDescription->attribute.namespacePrefix,
                    token::GetXMLToken( propDescription->attribute.attributeToken ),
				    attributeValue
                );

                exportedProperty( prop->Name );
            }
            catch( const Exception& )
            {
        	    DBG_UNHANDLED_EXCEPTION();
            }
        }
    }

    //---------------------------------------------------------------------
	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 sal_Int32 nStringPropertyAttributeIds[] =
			{
				CCA_LABEL, CCA_TITLE
			};
			// the names of all properties which are expected to be of type string
			static ::rtl::OUString aStringPropertyNames[] =
			{
				PROPERTY_LABEL, PROPERTY_TITLE
			};
			OSL_ENSURE(	sizeof(aStringPropertyNames)/sizeof(aStringPropertyNames[0]) ==
						sizeof(nStringPropertyAttributeIds)/sizeof(nStringPropertyAttributeIds[0]),
						"OControlExport::exportCommonControlAttributes: somebody tampered with the maps (1)!");

			for (i=0; i<sizeof(nStringPropertyAttributeIds)/sizeof(nStringPropertyAttributeIds[0]); ++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 sal_Int32 nBooleanPropertyAttributeIds[] =
			{	// attribute flags
				CCA_CURRENT_SELECTED, CCA_DISABLED, CCA_DROPDOWN, CCA_PRINTABLE, CCA_READONLY, CCA_SELECTED, CCA_TAB_STOP, CCA_ENABLEVISIBLE
			};
			static const ::rtl::OUString* pBooleanPropertyNames[] =
			{	// property names
				&PROPERTY_STATE, &PROPERTY_ENABLED, &PROPERTY_DROPDOWN, &PROPERTY_PRINTABLE, &PROPERTY_READONLY, &PROPERTY_DEFAULT_STATE, &PROPERTY_TABSTOP, &PROPERTY_ENABLEVISIBLE
			};
			static sal_Bool nBooleanPropertyAttrFlags[] =
			{	// attribute defaults
				BOOLATTR_DEFAULT_FALSE, BOOLATTR_DEFAULT_FALSE | BOOLATTR_INVERSE_SEMANTICS, BOOLATTR_DEFAULT_FALSE, BOOLATTR_DEFAULT_TRUE, BOOLATTR_DEFAULT_FALSE, BOOLATTR_DEFAULT_FALSE, BOOLATTR_DEFAULT_VOID, BOOLATTR_DEFAULT_FALSE
			};
		#if OSL_DEBUG_LEVEL > 0
			sal_Int32 nIdCount = sizeof(nBooleanPropertyAttributeIds) / sizeof(nBooleanPropertyAttributeIds[0]);
			sal_Int32 nNameCount = sizeof(pBooleanPropertyNames) / sizeof(pBooleanPropertyNames[0]);
			sal_Int32 nFlagsCount = sizeof(nBooleanPropertyAttrFlags) / sizeof(nBooleanPropertyAttrFlags[0]);
			OSL_ENSURE((nIdCount == nNameCount) && (nNameCount == nFlagsCount),
				"OControlExport::exportCommonControlAttributes: somebody tampered with the maps (2)!");
		#endif
			for (i=0; i<sizeof(nBooleanPropertyAttributeIds)/sizeof(nBooleanPropertyAttributeIds[0]); ++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 sal_Int32 nIntegerPropertyAttributeIds[] =
			{	// attribute flags
				CCA_SIZE, CCA_TAB_INDEX
			};
			static const ::rtl::OUString* pIntegerPropertyNames[] =
			{	// property names
				&PROPERTY_LINECOUNT, &PROPERTY_TABINDEX
			};
			static const sal_Int16 nIntegerPropertyAttrDefaults[] =
			{	// attribute defaults
				5, 0
			};

			if ( m_nIncludeCommon & CCA_MAX_LENGTH )
				exportedProperty(PROPERTY_MAXTEXTLENGTH);

		#if OSL_DEBUG_LEVEL > 0
			sal_Int32 nIdCount = sizeof(nIntegerPropertyAttributeIds) / sizeof(nIntegerPropertyAttributeIds[0]);
			sal_Int32 nNameCount = sizeof(pIntegerPropertyNames) / sizeof(pIntegerPropertyNames[0]);
			sal_Int32 nDefaultCount = sizeof(nIntegerPropertyAttrDefaults) / sizeof(nIntegerPropertyAttrDefaults[0]);
			OSL_ENSURE((nIdCount == nNameCount) && (nNameCount == nDefaultCount),
				"OControlExport::exportCommonControlAttributes: somebody tampered with the maps (3)!");
		#endif
			for (i=0; i<sizeof(nIntegerPropertyAttributeIds)/sizeof(nIntegerPropertyAttributeIds[0]); ++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 & CCA_BUTTON_TYPE)
			{
				exportEnumPropertyAttribute(
					OAttributeMetaData::getCommonControlAttributeNamespace(CCA_BUTTON_TYPE),
					OAttributeMetaData::getCommonControlAttributeName(CCA_BUTTON_TYPE),
					PROPERTY_BUTTONTYPE,
					OEnumMapper::getEnumMap(OEnumMapper::epButtonType),
					FormButtonType_PUSH);
		#if OSL_DEBUG_LEVEL > 0
				//  reset the bit for later checking
				m_nIncludeCommon = m_nIncludeCommon & ~CCA_BUTTON_TYPE;
		#endif
			}
			if ( m_nIncludeCommon & CCA_ORIENTATION )
			{
				exportEnumPropertyAttribute(
					OAttributeMetaData::getCommonControlAttributeNamespace( CCA_ORIENTATION ),
					OAttributeMetaData::getCommonControlAttributeName( CCA_ORIENTATION ),
					PROPERTY_ORIENTATION,
					OEnumMapper::getEnumMap( OEnumMapper::epOrientation ),
                    ScrollBarOrientation::HORIZONTAL
                );
		#if OSL_DEBUG_LEVEL > 0
				//  reset the bit for later checking
				m_nIncludeCommon = m_nIncludeCommon & ~CCA_ORIENTATION;
		#endif
			}

            if ( m_nIncludeCommon & CCA_VISUAL_EFFECT )
            {
				exportEnumPropertyAttribute(
					OAttributeMetaData::getCommonControlAttributeNamespace( CCA_VISUAL_EFFECT ),
					OAttributeMetaData::getCommonControlAttributeName( CCA_VISUAL_EFFECT ),
					PROPERTY_VISUAL_EFFECT,
					OEnumMapper::getEnumMap( OEnumMapper::epVisualEffect ),
                    VisualEffect::LOOK3D
                );
			#if OSL_DEBUG_LEVEL > 0
				//  reset the bit for later checking
				m_nIncludeCommon = m_nIncludeCommon & ~CCA_VISUAL_EFFECT;
			#endif
            }
		}

		// --------------------------------------------------------------------
		// some properties which require a special handling

		// the target frame
		if (m_nIncludeCommon & CCA_TARGET_FRAME)
		{
			exportTargetFrameAttribute();
		#if OSL_DEBUG_LEVEL > 0
			//  reset the bit for later checking
			m_nIncludeCommon = m_nIncludeCommon & ~CCA_TARGET_FRAME;
		#endif
		}

		// max text length
		if ( m_nIncludeCommon & CCA_MAX_LENGTH )
		{
			// 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
			::rtl::OUString sTextLenPropertyName( PROPERTY_MAXTEXTLENGTH );
			if ( m_xPropertyInfo->hasPropertyByName( PROPERTY_PERSISTENCE_MAXTEXTLENGTH ) )
				sTextLenPropertyName = PROPERTY_PERSISTENCE_MAXTEXTLENGTH;

			// export it
			exportInt16PropertyAttribute(
				OAttributeMetaData::getCommonControlAttributeNamespace( CCA_MAX_LENGTH ),
				OAttributeMetaData::getCommonControlAttributeName( CCA_MAX_LENGTH ),
				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 & ~CCA_MAX_LENGTH;
		#endif
		}

		if (m_nIncludeCommon & CCA_TARGET_LOCATION)
		{
			exportTargetLocationAttribute(false);
		#if OSL_DEBUG_LEVEL > 0
			//  reset the bit for later checking
			m_nIncludeCommon = m_nIncludeCommon & ~CCA_TARGET_LOCATION;
		#endif
		}

		// OJ #99721#
		if (m_nIncludeCommon & CCA_IMAGE_DATA)
		{
			exportImageDataAttribute();
		#if OSL_DEBUG_LEVEL > 0
			//  reset the bit for later checking
			m_nIncludeCommon = m_nIncludeCommon & ~CCA_IMAGE_DATA;
		#endif
		}

		// the for attribute
		// the target frame
		if (m_nIncludeCommon & CCA_FOR)
		{
			if (m_sReferringControls.getLength())
			{	// there is at least one control referring to the one we're handling currently
				AddAttribute(
					OAttributeMetaData::getCommonControlAttributeNamespace(CCA_FOR),
					OAttributeMetaData::getCommonControlAttributeName(CCA_FOR),
					m_sReferringControls);
			}
		#if OSL_DEBUG_LEVEL > 0
			//  reset the bit for later checking
			m_nIncludeCommon = m_nIncludeCommon & ~CCA_FOR;
		#endif
		}

		if ((CCA_CURRENT_VALUE | CCA_VALUE) & m_nIncludeCommon)
		{
			const sal_Char* pCurrentValuePropertyName = NULL;
			const sal_Char* pValuePropertyName = NULL;

			// get the property names
			getValuePropertyNames(m_eType, m_nClassId, pCurrentValuePropertyName, pValuePropertyName);

			static const sal_Char* pCurrentValueAttributeName = OAttributeMetaData::getCommonControlAttributeName(CCA_CURRENT_VALUE);
			static const sal_Char* pValueAttributeName = OAttributeMetaData::getCommonControlAttributeName(CCA_VALUE);
			static const sal_uInt16 nCurrentValueAttributeNamespaceKey = OAttributeMetaData::getCommonControlAttributeNamespace(CCA_CURRENT_VALUE);
			static const sal_uInt16 nValueAttributeNamespaceKey = OAttributeMetaData::getCommonControlAttributeNamespace(CCA_VALUE);

			// add the atrtributes if necessary and possible
			if (pCurrentValuePropertyName && (CCA_CURRENT_VALUE & m_nIncludeCommon))
            {
                // don't export the current-value if this value originates from a data binding
                // #i26944# - 2004-05-17 - fs@openoffice.org
                if ( controlHasActiveDataBinding() )
                    exportedProperty( ::rtl::OUString::createFromAscii( pCurrentValuePropertyName ) );
                else
				    exportGenericPropertyAttribute(
					    nCurrentValueAttributeNamespaceKey,
					    pCurrentValueAttributeName,
					    pCurrentValuePropertyName
                    );
            }

			if (pValuePropertyName && (CCA_VALUE & m_nIncludeCommon))
				exportGenericPropertyAttribute(
					nValueAttributeNamespaceKey,
					pValueAttributeName,
					pValuePropertyName);

			OSL_ENSURE((NULL == pValuePropertyName) == (0 == (CCA_VALUE & m_nIncludeCommon)),
				"OControlExport::exportCommonControlAttributes: no property found for the value attribute!");
			OSL_ENSURE((NULL == pCurrentValuePropertyName ) == (0 == (CCA_CURRENT_VALUE & 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 & ~(CCA_CURRENT_VALUE | CCA_VALUE);
		#endif
		}

		OSL_ENSURE(0 == 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
		sal_Int32 nIncludeDatabase = m_nIncludeDatabase;
#endif
		// the only string property: DataField
		if (DA_DATA_FIELD & m_nIncludeDatabase)
		{
			exportStringPropertyAttribute(
				OAttributeMetaData::getDatabaseAttributeNamespace(DA_DATA_FIELD),
				OAttributeMetaData::getDatabaseAttributeName(DA_DATA_FIELD),
				PROPERTY_DATAFIELD);
            RESET_BIT( nIncludeDatabase, DA_DATA_FIELD );
		}

        // InputRequired
        if ( DA_INPUT_REQUIRED & m_nIncludeDatabase )
        {
            exportBooleanPropertyAttribute(
                OAttributeMetaData::getDatabaseAttributeNamespace( DA_INPUT_REQUIRED ),
                OAttributeMetaData::getDatabaseAttributeName( DA_INPUT_REQUIRED ),
                PROPERTY_INPUT_REQUIRED,
                BOOLATTR_DEFAULT_TRUE
            );
            RESET_BIT( nIncludeDatabase, DA_INPUT_REQUIRED );
        }

		// the only int16 property: BoundColumn
		if (DA_BOUND_COLUMN & m_nIncludeDatabase)
		{
			exportInt16PropertyAttribute(
				OAttributeMetaData::getDatabaseAttributeNamespace(DA_BOUND_COLUMN),
				OAttributeMetaData::getDatabaseAttributeName(DA_BOUND_COLUMN),
				PROPERTY_BOUNDCOLUMN,
				0);
            RESET_BIT( nIncludeDatabase, DA_BOUND_COLUMN );
		}

		// ConvertEmptyToNull
		if (DA_CONVERT_EMPTY & m_nIncludeDatabase)
		{
			exportBooleanPropertyAttribute(
				OAttributeMetaData::getDatabaseAttributeNamespace(DA_CONVERT_EMPTY),
				OAttributeMetaData::getDatabaseAttributeName(DA_CONVERT_EMPTY),
				PROPERTY_EMPTY_IS_NULL,
				BOOLATTR_DEFAULT_FALSE
				);
            RESET_BIT( nIncludeDatabase, DA_CONVERT_EMPTY );
		}

		// the only enum property: ListSourceType
		if (DA_LIST_SOURCE_TYPE & m_nIncludeDatabase)
		{
			exportEnumPropertyAttribute(
				OAttributeMetaData::getDatabaseAttributeNamespace(DA_LIST_SOURCE_TYPE),
				OAttributeMetaData::getDatabaseAttributeName(DA_LIST_SOURCE_TYPE),
				PROPERTY_LISTSOURCETYPE,
				OEnumMapper::getEnumMap(OEnumMapper::epListSourceType),
				ListSourceType_VALUELIST
				);
            RESET_BIT( nIncludeDatabase, DA_LIST_SOURCE_TYPE );
		}

		if (m_nIncludeDatabase & DA_LIST_SOURCE)
		{
			exportListSourceAsAttribute();
            RESET_BIT( nIncludeDatabase, DA_LIST_SOURCE );
		}

#if OSL_DEBUG_LEVEL > 0
		OSL_ENSURE(0 == 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::exportBindingAtributes()
    {
#if OSL_DEBUG_LEVEL > 0
		sal_Int32 nIncludeBinding = m_nIncludeBindings;
#endif

        // ....................................................
        if ( m_nIncludeBindings & BA_LINKED_CELL )
        {
            exportCellBindingAttributes( ( m_nIncludeBindings & BA_LIST_LINKING_TYPE ) != 0 );
        #if OSL_DEBUG_LEVEL > 0
			//  reset the bit for later checking
			nIncludeBinding = nIncludeBinding & ~( BA_LINKED_CELL | BA_LIST_LINKING_TYPE );
		#endif
        }

        // ....................................................
        if ( m_nIncludeBindings & BA_LIST_CELL_RANGE )
        {
            exportCellListSourceRange();
        #if OSL_DEBUG_LEVEL > 0
			//  reset the bit for later checking
			nIncludeBinding = nIncludeBinding & ~BA_LIST_CELL_RANGE;
		#endif
        }

        if ( m_nIncludeBindings & BA_XFORMS_BIND )
        {
            exportXFormsBindAttributes();
        #if OSL_DEBUG_LEVEL > 0
			//  reset the bit for later checking
			nIncludeBinding = nIncludeBinding & ~BA_XFORMS_BIND;
		#endif
        }

        if ( m_nIncludeBindings & BA_XFORMS_LISTBIND )
        {
            exportXFormsListAttributes();
        #if OSL_DEBUG_LEVEL > 0
			//  reset the bit for later checking
			nIncludeBinding = nIncludeBinding & ~BA_XFORMS_LISTBIND;
		#endif
        }

        if ( m_nIncludeBindings & BA_XFORMS_SUBMISSION )
        {
            exportXFormsSubmissionAttributes();
        #if OSL_DEBUG_LEVEL > 0
			//  reset the bit for later checking
			nIncludeBinding = nIncludeBinding & ~BA_XFORMS_SUBMISSION;
		#endif
        }

        OSL_ENSURE( 0 == nIncludeBinding,
			"OControlExport::exportBindingAtributes: forgot some flags!");
			// in the debug version, we should have removed every bit we handled from the mask, so it should
			// be 0 now ...
    }

	//---------------------------------------------------------------------
	void OControlExport::exportSpecialAttributes()
	{
		sal_Int32 i=0;

		// ----------------------
		// the boolean properties
		{
			static const sal_Int32 nBooleanPropertyAttributeIds[] =
			{	// attribute flags
				SCA_VALIDATION, SCA_MULTI_LINE, SCA_AUTOMATIC_COMPLETION, SCA_MULTIPLE, SCA_DEFAULT_BUTTON, SCA_IS_TRISTATE,
                SCA_TOGGLE, SCA_FOCUS_ON_CLICK
			};
			static const ::rtl::OUString* pBooleanPropertyNames[] =
			{	// property names
				&PROPERTY_STRICTFORMAT, &PROPERTY_MULTILINE, &PROPERTY_AUTOCOMPLETE, &PROPERTY_MULTISELECTION, &PROPERTY_DEFAULTBUTTON, &PROPERTY_TRISTATE,
                &PROPERTY_TOGGLE, &PROPERTY_FOCUS_ON_CLICK
			};
			sal_Int32 nIdCount = sizeof(nBooleanPropertyAttributeIds) / sizeof(nBooleanPropertyAttributeIds[0]);
		#if OSL_DEBUG_LEVEL > 0
			sal_Int32 nNameCount = sizeof(pBooleanPropertyNames) / sizeof(pBooleanPropertyNames[0]);
			OSL_ENSURE((nIdCount == nNameCount),
				"OControlExport::exportSpecialAttributes: somebody tampered with the maps (1)!");
		#endif
            const sal_Int32* pAttributeId = nBooleanPropertyAttributeIds;
            const ::rtl::OUString** pPropertyName = pBooleanPropertyNames;
			for ( i = 0; i < nIdCount; ++i, ++pAttributeId, ++pPropertyName )
            {
				if ( *pAttributeId& m_nIncludeSpecial)
				{
					exportBooleanPropertyAttribute(
						OAttributeMetaData::getSpecialAttributeNamespace( *pAttributeId ),
						OAttributeMetaData::getSpecialAttributeName( *pAttributeId ),
						*(*pPropertyName),
                        ( *pAttributeId == SCA_FOCUS_ON_CLICK ) ? BOOLATTR_DEFAULT_TRUE : BOOLATTR_DEFAULT_FALSE
					);
			#if OSL_DEBUG_LEVEL > 0
				//  reset the bit for later checking
				m_nIncludeSpecial = m_nIncludeSpecial & ~*pAttributeId;
			#endif
				}
            }
		}

		// ----------------------
		// the integer properties
		{
			static sal_Int32 nIntegerPropertyAttributeIds[] =
			{	// attribute flags
				SCA_PAGE_STEP_SIZE
			};
			static const ::rtl::OUString* pIntegerPropertyNames[] =
			{	// property names
                &PROPERTY_BLOCK_INCREMENT
			};
			static const sal_Int32 nIntegerPropertyAttrDefaults[] =
			{	// attribute defaults (XML defaults, not runtime defaults!)
				10
			};

            sal_Int32 nIdCount = sizeof( nIntegerPropertyAttributeIds ) / sizeof( nIntegerPropertyAttributeIds[0] );
		#if OSL_DEBUG_LEVEL > 0
			sal_Int32 nNameCount = sizeof( pIntegerPropertyNames ) / sizeof( pIntegerPropertyNames[0] );
			OSL_ENSURE( ( nIdCount == nNameCount ),
				"OControlExport::exportSpecialAttributes: somebody tampered with the maps (2)!" );
            sal_Int32 nDefaultCount = sizeof( nIntegerPropertyAttrDefaults ) / sizeof( nIntegerPropertyAttrDefaults[0] );
			OSL_ENSURE( ( nIdCount == nDefaultCount ),
				"OControlExport::exportSpecialAttributes: somebody tampered with the maps (3)!" );
		#endif
			for ( i = 0; i < nIdCount; ++i )
				if ( nIntegerPropertyAttributeIds[i] & m_nIncludeSpecial )
				{
					exportInt32PropertyAttribute(
						OAttributeMetaData::getSpecialAttributeNamespace( nIntegerPropertyAttributeIds[i] ),
						OAttributeMetaData::getSpecialAttributeName( nIntegerPropertyAttributeIds[i] ),
						*( pIntegerPropertyNames[i] ),
						nIntegerPropertyAttrDefaults[i]
					);
			#if OSL_DEBUG_LEVEL > 0
				//  reset the bit for later checking
				m_nIncludeSpecial = m_nIncludeSpecial & ~nIntegerPropertyAttributeIds[i];
			#endif
				}

            if ( SCA_STEP_SIZE & m_nIncludeSpecial )
            {
                ::rtl::OUString sPropertyName;
                if ( m_xPropertyInfo->hasPropertyByName( PROPERTY_LINE_INCREMENT ) )
                    sPropertyName = PROPERTY_LINE_INCREMENT;
                else if ( m_xPropertyInfo->hasPropertyByName( PROPERTY_SPIN_INCREMENT ) )
                    sPropertyName = PROPERTY_SPIN_INCREMENT;
                else
                    OSL_ENSURE( sal_False, "OControlExport::exportSpecialAttributes: not property which can be mapped to step-size attribute!" );

                if ( sPropertyName.getLength() )
					exportInt32PropertyAttribute(
						OAttributeMetaData::getSpecialAttributeNamespace( SCA_STEP_SIZE ),
						OAttributeMetaData::getSpecialAttributeName( SCA_STEP_SIZE ),
						sPropertyName,
						1
					);

            #if OSL_DEBUG_LEVEL > 0
				//  reset the bit for later checking
				m_nIncludeSpecial = m_nIncludeSpecial & ~SCA_STEP_SIZE;
			#endif
            }

        }

		// -------------------
		// the enum properties
		{
			if (SCA_STATE & m_nIncludeSpecial)
			{
				exportEnumPropertyAttribute(
					OAttributeMetaData::getSpecialAttributeNamespace(SCA_STATE),
					OAttributeMetaData::getSpecialAttributeName(SCA_STATE),
					PROPERTY_DEFAULT_STATE,
					OEnumMapper::getEnumMap(OEnumMapper::epCheckState),
					STATE_NOCHECK);
			#if OSL_DEBUG_LEVEL > 0
				//  reset the bit for later checking
				m_nIncludeSpecial = m_nIncludeSpecial & ~SCA_STATE;
			#endif
			}

			if (SCA_CURRENT_STATE & m_nIncludeSpecial)
			{
				exportEnumPropertyAttribute(
					OAttributeMetaData::getSpecialAttributeNamespace(SCA_CURRENT_STATE),
					OAttributeMetaData::getSpecialAttributeName(SCA_CURRENT_STATE),
					PROPERTY_STATE,
					OEnumMapper::getEnumMap(OEnumMapper::epCheckState),
					STATE_NOCHECK);
			#if OSL_DEBUG_LEVEL > 0
				//  reset the bit for later checking
				m_nIncludeSpecial = m_nIncludeSpecial & ~SCA_CURRENT_STATE;
			#endif
			}
		}

		// --------------------------------------------------------------------
		// some properties which require a special handling
        // the repeat delay
        {
		    if ( m_nIncludeSpecial & SCA_REPEAT_DELAY )
		    {
		        DBG_CHECK_PROPERTY( PROPERTY_REPEAT_DELAY, sal_Int32 );

                sal_Int32 nRepeatDelay = 0;
                m_xProps->getPropertyValue( PROPERTY_REPEAT_DELAY ) >>= nRepeatDelay;
                Time aTime;
                aTime.MakeTimeFromMS( nRepeatDelay );

			    AddAttribute(OAttributeMetaData::getSpecialAttributeNamespace( SCA_REPEAT_DELAY )
						    ,OAttributeMetaData::getSpecialAttributeName( SCA_REPEAT_DELAY )
						    ,SvXMLUnitConverter::convertTimeDuration( aTime, nRepeatDelay % 1000 ) );

		        exportedProperty( PROPERTY_REPEAT_DELAY );

            #if OSL_DEBUG_LEVEL > 0
			    //  reset the bit for later checking
			    m_nIncludeSpecial = m_nIncludeSpecial & ~SCA_REPEAT_DELAY;
		    #endif
		    }
        }

		// ----------------------------------
		// the EchoChar property needs special handling, cause it's a Int16, but must be stored as one-character-string
		{
			if (SCA_ECHO_CHAR & m_nIncludeSpecial)
			{
				DBG_CHECK_PROPERTY( PROPERTY_ECHO_CHAR, sal_Int16 );
				sal_Int16 nValue(0);
				m_xProps->getPropertyValue(PROPERTY_ECHO_CHAR) >>= nValue;
				if (nValue)
				{
					::rtl::OUString sCharacter(reinterpret_cast<const sal_Unicode*>(&nValue), 1);
					AddAttribute(
						OAttributeMetaData::getSpecialAttributeNamespace(SCA_ECHO_CHAR),
						OAttributeMetaData::getSpecialAttributeName(SCA_ECHO_CHAR),
						sCharacter);
				}
				exportedProperty(PROPERTY_ECHO_CHAR);
			#if OSL_DEBUG_LEVEL > 0
				//  reset the bit for later checking
				m_nIncludeSpecial = m_nIncludeSpecial & ~SCA_ECHO_CHAR;
			#endif
			}
		}

		// ----------------------------------
		if ((SCA_MIN_VALUE | SCA_MAX_VALUE) & m_nIncludeSpecial)
		{
			// need to export the min value and the max value as attributes
			// It depends on the real type (FormComponentType) of the control, which properties hold these
			// values
			const sal_Char* pMinValuePropertyName = NULL;
			const sal_Char* pMaxValuePropertyName = NULL;
			getValueLimitPropertyNames(m_nClassId, pMinValuePropertyName, pMaxValuePropertyName);

			OSL_ENSURE((NULL == pMinValuePropertyName) == (0 == (SCA_MIN_VALUE & m_nIncludeSpecial)),
				"OControlExport::exportCommonControlAttributes: no property found for the min value attribute!");
			OSL_ENSURE((NULL == pMaxValuePropertyName) == (0 == (SCA_MAX_VALUE & m_nIncludeSpecial)),
				"OControlExport::exportCommonControlAttributes: no property found for the max value attribute!");

			// add the two attributes
			static const sal_Char* pMinValueAttributeName = OAttributeMetaData::getSpecialAttributeName(SCA_MIN_VALUE);
			static const sal_Char* pMaxValueAttributeName = OAttributeMetaData::getSpecialAttributeName(SCA_MAX_VALUE);
			static const sal_uInt16 nMinValueNamespaceKey = OAttributeMetaData::getSpecialAttributeNamespace(SCA_MIN_VALUE);
			static const sal_uInt16 nMaxValueNamespaceKey = OAttributeMetaData::getSpecialAttributeNamespace(SCA_MAX_VALUE);

			if (pMinValuePropertyName && (SCA_MIN_VALUE & m_nIncludeSpecial))
				exportGenericPropertyAttribute(
					nMinValueNamespaceKey,
					pMinValueAttributeName,
					pMinValuePropertyName);

			if (pMaxValuePropertyName && (SCA_MAX_VALUE & m_nIncludeSpecial))
				exportGenericPropertyAttribute(
					nMaxValueNamespaceKey,
					pMaxValueAttributeName,
					pMaxValuePropertyName);
		#if OSL_DEBUG_LEVEL > 0
			//  reset the bit for later checking
			m_nIncludeSpecial = m_nIncludeSpecial & ~(SCA_MIN_VALUE | SCA_MAX_VALUE);
		#endif
		}

		// ----------------------------------
        if ( SCA_IMAGE_POSITION & m_nIncludeSpecial )
        {
            exportImagePositionAttributes();
            RESET_BIT( m_nIncludeSpecial, SCA_IMAGE_POSITION );
        }

		OSL_ENSURE(0 == m_nIncludeSpecial,
			"OControlExport::exportSpecialAttributes: 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 ...
	}

	//---------------------------------------------------------------------
    ::rtl::OUString OControlExport::getScalarListSourceValue() const
    {
		::rtl::OUString sListSource;
		Any aListSource = m_xProps->getPropertyValue( PROPERTY_LISTSOURCE );
		if ( !( aListSource >>= sListSource ) )
		{
			Sequence< ::rtl::OUString > aListSourceSequence;
			aListSource >>= aListSourceSequence;
			if ( aListSourceSequence.getLength() )
				sListSource = aListSourceSequence[ 0 ];
		}
        return sListSource;
    }

	//---------------------------------------------------------------------
	void OControlExport::exportListSourceAsAttribute()
	{
		// DA_LIST_SOURCE needs some special handling
		DBG_CHECK_PROPERTY_NO_TYPE( PROPERTY_LISTSOURCE );

        ::rtl::OUString sListSource = getScalarListSourceValue();
		if ( sListSource.getLength() )
		{	// the ListSource property needs to be exported as attribute, and it is not empty
			AddAttribute(
				OAttributeMetaData::getDatabaseAttributeNamespace(DA_LIST_SOURCE),
				OAttributeMetaData::getDatabaseAttributeName(DA_LIST_SOURCE),
				sListSource);
		}

        exportedProperty( PROPERTY_LISTSOURCE );
	}

	//---------------------------------------------------------------------
	void OControlExport::getSequenceInt16PropertyAsSet(const ::rtl::OUString& _rPropertyName, Int16Set& _rOut)
	{
		Sequence< sal_Int16 > aValueSequence;
		DBG_CHECK_PROPERTY(_rPropertyName, Sequence< sal_Int16 >);
		m_xProps->getPropertyValue(_rPropertyName) >>= aValueSequence;

		const sal_Int16* pValues = aValueSequence.getConstArray();
		for (sal_Int32 i=0; i<aValueSequence.getLength(); ++i, ++pValues)
			_rOut.insert(*pValues);
	}

	//---------------------------------------------------------------------
	void OControlExport::exportListSourceAsElements()
	{
		// the string lists
		Sequence< ::rtl::OUString > aItems, aValues;
		DBG_CHECK_PROPERTY( PROPERTY_STRING_ITEM_LIST, Sequence< ::rtl::OUString > );
		m_xProps->getPropertyValue(PROPERTY_STRING_ITEM_LIST) >>= aItems;

		DBG_CHECK_PROPERTY( PROPERTY_LISTSOURCE, Sequence< ::rtl::OUString > );
		if ( 0 == ( m_nIncludeDatabase & DA_LIST_SOURCE ) )
			m_xProps->getPropertyValue(PROPERTY_LISTSOURCE) >>= aValues;
		// if we exported the list source as attribute, we do not repeat it as sub elements

		// the selection lists
		Int16Set aSelection, aDefaultSelection;
		getSequenceInt16PropertyAsSet(PROPERTY_SELECT_SEQ, aSelection);
		getSequenceInt16PropertyAsSet(PROPERTY_DEFAULT_SELECT_SEQ, aDefaultSelection);

		// the string for "true"
		::rtl::OUString sTrue;
		::rtl::OUStringBuffer sBuffer;
		m_rContext.getGlobalContext().GetMM100UnitConverter().convertBool(sBuffer, sal_True);
		sTrue = sBuffer.makeStringAndClear();

		// loop through both lists ('til the maximum of both lengths)
		const ::rtl::OUString* pItems = aItems.getConstArray();
		const ::rtl::OUString* pValues = aValues.getConstArray();

		sal_Int32 nItems = aItems.getLength();
		sal_Int32 nValues = aValues.getLength();

		sal_Int16 nMaxLen = (sal_Int16)std::max(nItems, nValues);

		for	(sal_Int16 i=0; i<nMaxLen; ++i )
		{
			m_rContext.getGlobalContext().ClearAttrList();
			if (i < nItems)
			{
				// there is an item at this position
				AddAttribute(
					OAttributeMetaData::getCommonControlAttributeNamespace(CCA_LABEL),
					OAttributeMetaData::getCommonControlAttributeName(CCA_LABEL),
					*pItems);
				++pItems;
			}
			if (i < nValues)
			{
				// there is an value at this position
				AddAttribute(
					OAttributeMetaData::getCommonControlAttributeNamespace(CCA_VALUE),
					OAttributeMetaData::getCommonControlAttributeName(CCA_VALUE),
					*pValues);
				++pValues;
			}

			Int16SetIterator aSelectedPos = aSelection.find(i);
			if (aSelection.end() != aSelectedPos)
			{	// the item at this position is selected
				AddAttribute(
					OAttributeMetaData::getCommonControlAttributeNamespace(CCA_CURRENT_SELECTED),
					OAttributeMetaData::getCommonControlAttributeName(CCA_CURRENT_SELECTED),
					sTrue
					);
				aSelection.erase(aSelectedPos);
			}

			Int16SetIterator aDefaultSelectedPos = aDefaultSelection.find(i);
			if (aDefaultSelection.end() != aDefaultSelectedPos)
			{	// the item at this position is selected as default
				AddAttribute(
					OAttributeMetaData::getCommonControlAttributeNamespace(CCA_SELECTED),
					OAttributeMetaData::getCommonControlAttributeName(CCA_SELECTED),
					sTrue
					);
				aDefaultSelection.erase(aDefaultSelectedPos);
			}
			SvXMLElementExport aFormElement(m_rContext.getGlobalContext(), XML_NAMESPACE_FORM, "option", sal_True, sal_True);
		}

		// There may be more "selected" or "default-selected" items than there are in the lists in real,
		// so we need to store some additional "form:option" items which have no name and no label, but
		// one or both of the selected flags.
		// 21.05.2001 - 85388 - frank.schoenheit@germany.sun.com

		if ( !aSelection.empty() || !aDefaultSelection.empty() )
		{
			sal_Int16 nLastSelected = -1;
			if ( !aSelection.empty() )
				nLastSelected = *(--aSelection.end());

			sal_Int16 nLastDefaultSelected = -1;
			if ( !aDefaultSelection.empty() )
				nLastDefaultSelected = *(--aDefaultSelection.end());

			// the maximum element in both sets
			sal_Int16 nLastReferredEntry = std::max(nLastSelected, nLastDefaultSelected);
			OSL_ENSURE(nLastReferredEntry >= nMaxLen, "OControlExport::exportListSourceAsElements: inconsistence!");
				// if the maximum (selected or default selected) entry number is less than the maximum item count
				// in both lists, the entry number should have been removed from the set

			for (sal_Int16 i=nMaxLen; i<=nLastReferredEntry; ++i)
			{
				if (aSelection.end() != aSelection.find(i))
				{	// the (not existent) item at this position is selected
					AddAttribute(
						OAttributeMetaData::getCommonControlAttributeNamespace(CCA_CURRENT_SELECTED),
						OAttributeMetaData::getCommonControlAttributeName(CCA_CURRENT_SELECTED),
						sTrue
						);
				}

				if (aDefaultSelection.end() != aDefaultSelection.find(i))
				{	// the (not existent) item at this position is selected as default
					AddAttribute(
						OAttributeMetaData::getCommonControlAttributeNamespace(CCA_SELECTED),
						OAttributeMetaData::getCommonControlAttributeName(CCA_SELECTED),
						sTrue
						);
				}
				SvXMLElementExport aFormElement(m_rContext.getGlobalContext(), XML_NAMESPACE_FORM, "option", sal_True, sal_True);
			}
		}
	}

	//---------------------------------------------------------------------
	void OControlExport::implStartElement(const sal_Char* _pName)
	{
		// before we let the base class start it's outer element, we add a wrapper element
		const sal_Char *pOuterElementName = getOuterXMLElementName();
		m_pOuterElement = pOuterElementName
		   					? new SvXMLElementExport(
										m_rContext.getGlobalContext(),
										XML_NAMESPACE_FORM,
										pOuterElementName, sal_True,
										sal_True)
							: 0;

		// add the attributes for the inner element
		exportInnerAttributes();

		// and start the inner element
		OElementExport::implStartElement(_pName);
	}

	//---------------------------------------------------------------------
	void OControlExport::implEndElement()
	{
		// end the inner element
		OElementExport::implEndElement();

		// end the outer element if it exists
		delete m_pOuterElement;
		m_pOuterElement = NULL;
	}

	//---------------------------------------------------------------------
	const sal_Char* OControlExport::getOuterXMLElementName() const
	{
		return 0;
	}

	//---------------------------------------------------------------------
	const sal_Char* OControlExport::getXMLElementName() const
	{
		return getElementName(m_eType);
	}

	//---------------------------------------------------------------------
	void OControlExport::examine()
	{
        OSL_ENSURE( ( m_nIncludeCommon == 0 ) && ( m_nIncludeSpecial == 0 ) && ( m_nIncludeDatabase == 0 )
                 && ( m_nIncludeEvents == 0 ) && ( m_nIncludeBindings == 0),
                 "OControlExport::examine: called me twice? Not initialized?" );

        // get the class id to decide which kind of element we need in the XML stream
		m_nClassId = FormComponentType::CONTROL;
		DBG_CHECK_PROPERTY( PROPERTY_CLASSID, sal_Int16 );
		m_xProps->getPropertyValue(PROPERTY_CLASSID) >>= m_nClassId;
        bool knownType = false;
		switch (m_nClassId)
		{
			case FormComponentType::DATEFIELD:
                m_eType = DATE;
                knownType = true;
                // NO BREAK
			case FormComponentType::TIMEFIELD:
                if ( !knownType )
                {
                    m_eType = TIME;
                    knownType = true;
                }
				m_nIncludeSpecial |= SCA_VALIDATION;
                // NO BREAK
			case FormComponentType::NUMERICFIELD:
			case FormComponentType::CURRENCYFIELD:
			case FormComponentType::PATTERNFIELD:
                if ( !knownType )
                {
				    m_eType = FORMATTED_TEXT;
                    knownType = true;
                }
				// NO BREAK
			case FormComponentType::TEXTFIELD:
			{	// it's some kind of edit. To know which type we need further investigation

				if ( !knownType )
				{
					// check if it's a formatted field
					if (m_xPropertyInfo->hasPropertyByName(PROPERTY_FORMATKEY))
					{
						m_eType = FORMATTED_TEXT;
					}
					else
					{
						// all other controls are represented by an ordinary edit control, but which XML control type
						// it is depends on the current values of some properties

						// if the EchoChar string is not empty, it is a password field
						sal_Int16 nEchoChar = 0;
						if (m_xPropertyInfo->hasPropertyByName(PROPERTY_ECHOCHAR))
							// grid columns do not have this property ....
							m_xProps->getPropertyValue(PROPERTY_ECHOCHAR) >>= nEchoChar;
						if (nEchoChar)
						{
							m_eType = PASSWORD;
							m_nIncludeSpecial |= SCA_ECHO_CHAR;
						}
						else
						{
							// if the MultiLine property is sal_True, it is a TextArea
							sal_Bool bMultiLine = sal_False;
							if (m_xPropertyInfo->hasPropertyByName(PROPERTY_MULTILINE))
								// grid columns do not have this property ....
								bMultiLine = ::cppu::any2bool(m_xProps->getPropertyValue(PROPERTY_MULTILINE));

                            if ( bMultiLine )
								m_eType = TEXT_AREA;
							else
								// the only case left is represented by a Text element
								m_eType = TEXT;
						}
					}
                    knownType = true;
				}

				// attributes which are common to all the types:
				// common attributes
				m_nIncludeCommon =
					CCA_NAME | CCA_SERVICE_NAME | CCA_DISABLED |
					CCA_PRINTABLE | CCA_TAB_INDEX | CCA_TAB_STOP | CCA_TITLE;

                if  (   ( m_nClassId != FormComponentType::DATEFIELD )
                    &&  ( m_nClassId != FormComponentType::TIMEFIELD )
                    )
                    // date and time field values are handled differently nowadays
                    m_nIncludeCommon |= CCA_VALUE;

                // database attributes
				m_nIncludeDatabase = DA_DATA_FIELD | DA_INPUT_REQUIRED;

				// event attributes
				m_nIncludeEvents = EA_CONTROL_EVENTS | EA_ON_CHANGE | EA_ON_SELECT;

				// only text and pattern fields have a ConvertEmptyToNull property
				if  (   ( m_nClassId == FormComponentType::TEXTFIELD )
                    ||  ( m_nClassId == FormComponentType::PATTERNFIELD )
                    )
					m_nIncludeDatabase |= DA_CONVERT_EMPTY;

				// all controls but the file control fields have a readonly property
				if ( m_nClassId != FormComponentType::FILECONTROL )
					m_nIncludeCommon |= CCA_READONLY;

				// a text field has a max text len
                if ( m_nClassId == FormComponentType::TEXTFIELD )
					m_nIncludeCommon |= CCA_MAX_LENGTH;

				// max and min values and validation:
				if (FORMATTED_TEXT == m_eType)
				{	// in general all controls represented as formatted-text have these props
					if  ( FormComponentType::PATTERNFIELD != m_nClassId )   // except the PatternField
						m_nIncludeSpecial |= SCA_MAX_VALUE | SCA_MIN_VALUE;

					if (FormComponentType::TEXTFIELD != m_nClassId)
						// and the FormattedField does not have a validation flag
						m_nIncludeSpecial |= SCA_VALIDATION;
				}

				// if it's not a password field or rich text control, the CurrentValue needs to be stored, too
				if  (   ( PASSWORD != m_eType )
                    &&  ( DATE != m_eType )
                    &&  ( TIME != m_eType )
                    )
                {
				    m_nIncludeCommon |= CCA_CURRENT_VALUE;
                }
			}
			break;

			case FormComponentType::FILECONTROL:
				m_eType = FILE;
				m_nIncludeCommon =
					CCA_NAME | CCA_SERVICE_NAME | CCA_CURRENT_VALUE | CCA_DISABLED |
					CCA_PRINTABLE | CCA_TAB_INDEX | CCA_TAB_STOP | CCA_TITLE |
					CCA_VALUE;
				m_nIncludeEvents = EA_CONTROL_EVENTS | EA_ON_CHANGE | EA_ON_SELECT;
				break;

			case FormComponentType::FIXEDTEXT:
				m_eType = FIXED_TEXT;
				m_nIncludeCommon =
					CCA_NAME | CCA_SERVICE_NAME | CCA_DISABLED | CCA_LABEL |
					CCA_PRINTABLE | CCA_TITLE | CCA_FOR;
				m_nIncludeSpecial = SCA_MULTI_LINE;
				m_nIncludeEvents = EA_CONTROL_EVENTS;
				break;

			case FormComponentType::COMBOBOX:
				m_eType = COMBOBOX;
				m_nIncludeCommon =
					CCA_NAME | CCA_SERVICE_NAME | CCA_CURRENT_VALUE |
					CCA_DISABLED | CCA_DROPDOWN | CCA_MAX_LENGTH | CCA_PRINTABLE | CCA_READONLY | CCA_SIZE |
					CCA_TAB_INDEX | CCA_TAB_STOP | CCA_TITLE | CCA_VALUE;
				m_nIncludeSpecial = SCA_AUTOMATIC_COMPLETION;
				m_nIncludeDatabase = DA_CONVERT_EMPTY | DA_DATA_FIELD | DA_INPUT_REQUIRED | DA_LIST_SOURCE | DA_LIST_SOURCE_TYPE;
				m_nIncludeEvents = EA_CONTROL_EVENTS | EA_ON_CHANGE | EA_ON_SELECT;
				break;

			case FormComponentType::LISTBOX:
				m_eType = LISTBOX;
				m_nIncludeCommon =
					CCA_NAME | CCA_SERVICE_NAME | CCA_DISABLED | CCA_DROPDOWN |
					CCA_PRINTABLE | CCA_SIZE | CCA_TAB_INDEX | CCA_TAB_STOP | CCA_TITLE;
				m_nIncludeSpecial = SCA_MULTIPLE;
				m_nIncludeDatabase = DA_BOUND_COLUMN | DA_DATA_FIELD | DA_INPUT_REQUIRED | DA_LIST_SOURCE_TYPE;
				m_nIncludeEvents = EA_CONTROL_EVENTS | EA_ON_CHANGE | EA_ON_CLICK | EA_ON_DBLCLICK;
				// check if we need to export the ListSource as attribute
				{
					// for a list box, if the ListSourceType is VALUE_LIST, no ListSource is stored, but instead
					// a sequence of pairs which is build from the StringItemList and the ValueList
					ListSourceType eListSourceType = ListSourceType_VALUELIST;
                #if OSL_DEBUG_LEVEL > 0
					sal_Bool bSuccess =
				#endif
					m_xProps->getPropertyValue(PROPERTY_LISTSOURCETYPE) >>= eListSourceType;
					OSL_ENSURE(bSuccess, "OControlExport::examineControl: could not retrieve the ListSourceType!");
					if (ListSourceType_VALUELIST != eListSourceType)
					{
						m_nIncludeDatabase |= DA_LIST_SOURCE;
					}
				}

				break;

			case FormComponentType::COMMANDBUTTON:
				m_eType = BUTTON;
				m_nIncludeCommon |= CCA_TAB_STOP | CCA_LABEL;
				m_nIncludeSpecial = SCA_DEFAULT_BUTTON | SCA_TOGGLE | SCA_FOCUS_ON_CLICK | SCA_IMAGE_POSITION | SCA_REPEAT_DELAY;
				// NO BREAK !
			case FormComponentType::IMAGEBUTTON:
				if (BUTTON != m_eType)
                {
					// not coming from the previous case
					m_eType = IMAGE;
                }
				m_nIncludeCommon |=
					CCA_NAME | CCA_SERVICE_NAME | CCA_BUTTON_TYPE | CCA_DISABLED |
					CCA_IMAGE_DATA | CCA_PRINTABLE | CCA_TAB_INDEX | CCA_TARGET_FRAME |
					CCA_TARGET_LOCATION | CCA_TITLE;
				m_nIncludeEvents = EA_CONTROL_EVENTS | EA_ON_CLICK	| EA_ON_DBLCLICK;
				break;

			case FormComponentType::CHECKBOX:
				m_eType = CHECKBOX;
				m_nIncludeSpecial = SCA_CURRENT_STATE | SCA_IS_TRISTATE | SCA_STATE;
				// NO BREAK !
			case FormComponentType::RADIOBUTTON:
				m_nIncludeCommon =
					CCA_NAME | CCA_SERVICE_NAME | CCA_DISABLED | CCA_LABEL | CCA_PRINTABLE |
                    CCA_TAB_INDEX | CCA_TAB_STOP | CCA_TITLE | CCA_VALUE | CCA_VISUAL_EFFECT;
				if (CHECKBOX != m_eType)
				{	// not coming from the previous case
					m_eType = RADIO;
					m_nIncludeCommon |= CCA_CURRENT_SELECTED | CCA_SELECTED;
				}
                if ( m_xPropertyInfo->hasPropertyByName( PROPERTY_IMAGE_POSITION ) )
                    m_nIncludeSpecial |= SCA_IMAGE_POSITION;
				m_nIncludeDatabase = DA_DATA_FIELD | DA_INPUT_REQUIRED;
				m_nIncludeEvents = EA_CONTROL_EVENTS | EA_ON_CHANGE;
				break;

			case FormComponentType::GROUPBOX:
				m_eType = FRAME;
				m_nIncludeCommon =
					CCA_NAME | CCA_SERVICE_NAME | CCA_DISABLED | CCA_LABEL |
					CCA_PRINTABLE | CCA_TITLE | CCA_FOR;
				m_nIncludeEvents = EA_CONTROL_EVENTS;
				break;

			case FormComponentType::IMAGECONTROL:
				m_eType = IMAGE_FRAME;
				m_nIncludeCommon =
					CCA_NAME | CCA_SERVICE_NAME | CCA_DISABLED | CCA_IMAGE_DATA |
					CCA_PRINTABLE | CCA_READONLY | CCA_TITLE;
				m_nIncludeDatabase = DA_DATA_FIELD | DA_INPUT_REQUIRED;
				m_nIncludeEvents = EA_CONTROL_EVENTS;
				break;

			case FormComponentType::HIDDENCONTROL:
				m_eType = HIDDEN;
				m_nIncludeCommon =
					CCA_NAME | CCA_SERVICE_NAME | CCA_VALUE;
				break;

			case FormComponentType::GRIDCONTROL:
				m_eType = GRID;
				m_nIncludeCommon =
					CCA_NAME | CCA_SERVICE_NAME | CCA_DISABLED | CCA_PRINTABLE |
					CCA_TAB_INDEX | CCA_TAB_STOP | CCA_TITLE;
				m_nIncludeEvents = EA_CONTROL_EVENTS;
				break;

			case FormComponentType::SCROLLBAR:
			case FormComponentType::SPINBUTTON:
				m_eType = VALUERANGE;
				m_nIncludeCommon =
					CCA_NAME | CCA_SERVICE_NAME | CCA_DISABLED | CCA_PRINTABLE |
                    CCA_TITLE | CCA_CURRENT_VALUE | CCA_VALUE | CCA_ORIENTATION;
                m_nIncludeSpecial = SCA_MAX_VALUE | SCA_STEP_SIZE | SCA_MIN_VALUE | SCA_REPEAT_DELAY;

                if ( m_nClassId == FormComponentType::SCROLLBAR )
                    m_nIncludeSpecial |= SCA_PAGE_STEP_SIZE ;

				m_nIncludeEvents = EA_CONTROL_EVENTS;
                break;

            default:
				OSL_ENSURE(sal_False, "OControlExport::examineControl: unknown control type (class id)!");
                // NO break!

            case FormComponentType::NAVIGATIONBAR:
                // TODO: should we have an own file format for this?
                // NO break

            case FormComponentType::CONTROL:
				m_eType = GENERIC_CONTROL;
				// unknown control type
				m_nIncludeCommon = CCA_NAME | CCA_SERVICE_NAME;
					// at least a name should be there, 'cause without a name the control could never have been
					// inserted into it's parent container
					// In addition, the service name is absolutely necessary to create the control upon reading.
				m_nIncludeEvents = EA_CONTROL_EVENTS;
					// we always should be able to export events - this is not control type dependent
				break;
		}

		// in general, all control types need to export the control id
		m_nIncludeCommon |= CCA_CONTROL_ID;

        // is is a control bound to a calc cell?
        if ( FormCellBindingHelper::livesInSpreadsheetDocument( m_xProps ) )
        {
            FormCellBindingHelper aHelper( m_xProps, NULL );
            {
                if ( aHelper.isCellBinding( aHelper.getCurrentBinding( ) ) )
                {
                    m_nIncludeBindings |= BA_LINKED_CELL;
                    if ( m_nClassId == FormComponentType::LISTBOX )
                        m_nIncludeBindings |= BA_LIST_LINKING_TYPE;
                }
            }

            // is it a list-like control which uses a calc cell range as list source?
            {
                if ( aHelper.isCellRangeListSource( aHelper.getCurrentListSource( ) ) )
                    m_nIncludeBindings |= BA_LIST_CELL_RANGE;
            }
        }

        // is control bound to XForms?
        if( getXFormsBindName( m_xProps ).getLength() > 0 )
        {
            m_nIncludeBindings |= BA_XFORMS_BIND;
        }

        // is (list-)control bound to XForms list?
        if( getXFormsListBindName( m_xProps ).getLength() > 0 )
        {
            m_nIncludeBindings |= BA_XFORMS_LISTBIND;
        }

        // does the control have an XForms submission?
        if( getXFormsSubmissionName( m_xProps ).getLength() > 0 )
        {
            m_nIncludeBindings |= BA_XFORMS_SUBMISSION;
        }
	}

	//---------------------------------------------------------------------
    void OControlExport::exportCellBindingAttributes( bool _bIncludeListLinkageType )
    {
        try
        {
            FormCellBindingHelper aHelper( m_xProps, NULL );
            Reference< XValueBinding > xBinding( aHelper.getCurrentBinding() );
            OSL_ENSURE( xBinding.is(), "OControlExport::exportCellBindingAttributes: invalid bindable or invalid binding!" );
            if ( xBinding.is() )
            {
                // ....................................................
    			AddAttribute(
                    OAttributeMetaData::getBindingAttributeNamespace( BA_LINKED_CELL ),
                    OAttributeMetaData::getBindingAttributeName( BA_LINKED_CELL ),
                    aHelper.getStringAddressFromCellBinding( xBinding )
                );

                // ....................................................
                if ( _bIncludeListLinkageType )
                {
                    sal_Int16 nLinkageType = aHelper.isCellIntegerBinding( xBinding ) ? 1 : 0;

                    ::rtl::OUStringBuffer sBuffer;
			        m_rContext.getGlobalContext().GetMM100UnitConverter().convertEnum(
                        sBuffer,
                        (sal_uInt16)nLinkageType,
                        OEnumMapper::getEnumMap( OEnumMapper::epListLinkageType )
                    );

                    AddAttribute(
                        OAttributeMetaData::getBindingAttributeNamespace( BA_LIST_LINKING_TYPE ),
                        OAttributeMetaData::getBindingAttributeName( BA_LIST_LINKING_TYPE ),
                        sBuffer.makeStringAndClear()
                    );
                }

            }
        }
        catch( const Exception& )
        {
            OSL_ENSURE( sal_False, "OControlExport::exportCellBindingAttributes: caught an exception!" );
        }
    }

	//---------------------------------------------------------------------
    void OControlExport::exportXFormsBindAttributes()
    {
        rtl::OUString sBindName = getXFormsBindName( m_xProps );
        AddAttribute( XML_NAMESPACE_XFORMS, XML_BIND, sBindName );
    }
	//---------------------------------------------------------------------
    void OControlExport::exportXFormsListAttributes()
    {
        rtl::OUString sBindName = getXFormsListBindName( m_xProps );
        AddAttribute( XML_NAMESPACE_FORM, XML_XFORMS_LIST_SOURCE, sBindName );
    }
	//---------------------------------------------------------------------
    void OControlExport::exportXFormsSubmissionAttributes()
    {
        rtl::OUString sSubmission = getXFormsSubmissionName( m_xProps );
        AddAttribute( XML_NAMESPACE_FORM, XML_XFORMS_SUBMISSION, sSubmission );
    }
	//---------------------------------------------------------------------
    void OControlExport::exportCellListSourceRange( )
    {
        try
        {
            Reference< XListEntrySink > xSink( m_xProps, UNO_QUERY );
            Reference< XListEntrySource > xSource;
            if ( xSink.is() )
                xSource = xSource.query( xSink->getListEntrySource() );
            OSL_ENSURE( xSource.is(), "OControlExport::exportCellListSourceRange: list source or sink!" );
            if ( xSource.is() )
            {
                FormCellBindingHelper aHelper( m_xProps, NULL );

    			AddAttribute(
                    OAttributeMetaData::getBindingAttributeNamespace( BA_LIST_CELL_RANGE ),
                    OAttributeMetaData::getBindingAttributeName( BA_LIST_CELL_RANGE ),
                    aHelper.getStringAddressFromCellListSource( xSource )
                );
            }
        }
        catch( const Exception& )
        {
            OSL_ENSURE( sal_False, "OControlExport::exportCellListSourceRange: caught an exception!" );
        }
    }

	//---------------------------------------------------------------------
    void OControlExport::exportImagePositionAttributes()
    {
        try
        {
            sal_Int16 nImagePosition = ImagePosition::Centered;
            OSL_VERIFY( m_xProps->getPropertyValue( PROPERTY_IMAGE_POSITION ) >>= nImagePosition );
            OSL_ENSURE( ( nImagePosition >= ImagePosition::LeftTop ) && ( nImagePosition <= ImagePosition::Centered ),
                "OControlExport::exportImagePositionAttributes: don't know this image position!" );

            if ( ( nImagePosition < ImagePosition::LeftTop ) || ( nImagePosition > ImagePosition::Centered ) )
                // this is important to prevent potential buffer overflows below, so don't optimize
                nImagePosition = ImagePosition::Centered;

            if ( nImagePosition == ImagePosition::Centered )
            {
    		    AddAttribute( XML_NAMESPACE_FORM, GetXMLToken( XML_IMAGE_POSITION ), GetXMLToken( XML_CENTER ) );
            }
            else
            {
                XMLTokenEnum eXmlImagePositions[] =
                {
                    XML_START, XML_END, XML_TOP, XML_BOTTOM
                };
                XMLTokenEnum eXmlImageAligns[] =
                {
                    XML_START, XML_CENTER, XML_END
                };

                XMLTokenEnum eXmlImagePosition = eXmlImagePositions[ nImagePosition / 3 ];
                XMLTokenEnum eXmlImageAlign    = eXmlImageAligns   [ nImagePosition % 3 ];

    		    AddAttribute( XML_NAMESPACE_FORM, GetXMLToken( XML_IMAGE_POSITION ), GetXMLToken( eXmlImagePosition ) );
    		    AddAttribute( XML_NAMESPACE_FORM, GetXMLToken( XML_IMAGE_ALIGN    ), GetXMLToken( eXmlImageAlign    ) );
            }

            exportedProperty( PROPERTY_IMAGE_POSITION );
            // some of the controls which have an ImagePosition also have an ImageAlign for compatibility
            // reasons. Since the ImageAlign values simply represent a sub set of the ImagePosition values,
            // we don't need to export ImageAlign anymore
            exportedProperty( PROPERTY_IMAGE_ALIGN );
        }
        catch( const Exception& )
        {
            DBG_UNHANDLED_EXCEPTION();
        }
    }

	//---------------------------------------------------------------------
	bool OControlExport::controlHasActiveDataBinding() const
    {
        try
        {
            // currently exchanging the data with a database column?
            ::rtl::OUString sBoundFieldPropertyName( RTL_CONSTASCII_USTRINGPARAM( "BoundField" ) );
            if ( m_xPropertyInfo.is() && m_xPropertyInfo->hasPropertyByName( sBoundFieldPropertyName ) )
            {
                Reference< XPropertySet > xBoundField;
                m_xProps->getPropertyValue( sBoundFieldPropertyName ) >>= xBoundField;
                if ( xBoundField.is() )
                    return true;
            }

            // currently exchanging data with an external binding?
            Reference< XBindableValue > xBindable( m_xProps, UNO_QUERY );
            if ( xBindable.is() && xBindable->getValueBinding().is() )
                return true;
        }
        catch( const Exception& )
        {
        	OSL_ENSURE( sal_False, "OColumnExport::controlHasActiveDataBinding: caught an exception!" );
        }

        return false;
    }

	//---------------------------------------------------------------------
	bool OControlExport::controlHasUserSuppliedListEntries() const
    {
        try
        {
            // an external list source?
            Reference< XListEntrySink > xEntrySink( m_xProps, UNO_QUERY );
            if ( xEntrySink.is() && xEntrySink->getListEntrySource().is() )
                return false;

            if ( m_xPropertyInfo.is() && m_xPropertyInfo->hasPropertyByName( PROPERTY_LISTSOURCETYPE ) )
            {
                ListSourceType eListSourceType = ListSourceType_VALUELIST;
                OSL_VERIFY( m_xProps->getPropertyValue( PROPERTY_LISTSOURCETYPE ) >>= eListSourceType );
                if ( eListSourceType == ListSourceType_VALUELIST )
                    // for value lists, the list entries as entered by the user are used
                    return true;

                // for every other type, the list entries are filled with some data obtained
                // from a database - if and only if the ListSource property is not empty
                return ( 0 == getScalarListSourceValue().getLength() );
            }
        }
        catch( const Exception& )
        {
        	OSL_ENSURE( sal_False, "OControlExport::controlHasUserSuppliedListEntries: caught an exception!" );
        }

        OSL_ENSURE( sal_False, "OControlExport::controlHasUserSuppliedListEntries: unreachable code!" );
            // this method should be called for list and combo boxes only
        return true;
    }

	//=====================================================================
	//= OColumnExport
	//=====================================================================
	//---------------------------------------------------------------------
	OColumnExport::OColumnExport(IFormsExportContext& _rContext, const Reference< XPropertySet >& _rxControl, const ::rtl::OUString& _rControlId,
		const Sequence< ScriptEventDescriptor >& _rEvents)
		:OControlExport(_rContext, _rxControl, _rControlId, ::rtl::OUString(), _rEvents)
	{
	}

	//---------------------------------------------------------------------
	OColumnExport::~OColumnExport()
	{
		implEndElement();
	}

	//---------------------------------------------------------------------
	void OColumnExport::exportServiceNameAttribute()
	{
		// the attribute "service name" (which has a slightly different meaning for columns
		DBG_CHECK_PROPERTY( PROPERTY_COLUMNSERVICENAME, ::rtl::OUString );
		::rtl::OUString sColumnServiceName;
		m_xProps->getPropertyValue(PROPERTY_COLUMNSERVICENAME) >>= sColumnServiceName;
		// the service name is a full qualified one (i.e. com.sun.star.form.TextField), but the
		// real service name for the column (for use with the XGridColumnFactory) is only the last
		// token of this complete name.
		sal_Int32 nLastSep = sColumnServiceName.lastIndexOf('.');
		OSL_ENSURE(-1 != nLastSep, "OColumnExport::startExportElement: invalid service name!");
		sColumnServiceName = sColumnServiceName.copy(nLastSep + 1);
		sColumnServiceName =
			m_rContext.getGlobalContext().GetNamespaceMap().GetQNameByKey(
				XML_NAMESPACE_OOO, sColumnServiceName );
		// add the attribute
		AddAttribute( OAttributeMetaData::getCommonControlAttributeNamespace(CCA_SERVICE_NAME)
					, OAttributeMetaData::getCommonControlAttributeName(CCA_SERVICE_NAME)
					, sColumnServiceName);
		// flag the property as "handled"
		exportedProperty(PROPERTY_COLUMNSERVICENAME);

	}

	//---------------------------------------------------------------------
	const sal_Char* OColumnExport::getOuterXMLElementName() const
	{
		return "column";
	}

	//---------------------------------------------------------------------
	void OColumnExport::exportAttributes()
	{
		OControlExport::exportAttributes();

		// the attribute "label"
		exportStringPropertyAttribute(
			OAttributeMetaData::getCommonControlAttributeNamespace(CCA_LABEL),
			OAttributeMetaData::getCommonControlAttributeName(CCA_LABEL),
			PROPERTY_LABEL);

		// the style attribute
		::rtl::OUString sStyleName = m_rContext.getObjectStyleName( m_xProps );
		if ( sStyleName.getLength() )
		{
			AddAttribute(
				OAttributeMetaData::getSpecialAttributeNamespace( SCA_COLUMN_STYLE_NAME ),
				OAttributeMetaData::getSpecialAttributeName( SCA_COLUMN_STYLE_NAME ),
				sStyleName
			);
		}
	}

	//---------------------------------------------------------------------
	void OColumnExport::examine()
	{
		OControlExport::examine();

		// grid columns miss some properties of the controls they're representing
		m_nIncludeCommon &= ~(CCA_FOR | CCA_PRINTABLE | CCA_TAB_INDEX | CCA_TAB_STOP | CCA_LABEL);
		m_nIncludeSpecial &= ~(SCA_ECHO_CHAR | SCA_AUTOMATIC_COMPLETION | SCA_MULTIPLE | SCA_MULTI_LINE);

		if (FormComponentType::DATEFIELD != m_nClassId)
			// except date fields, no column has the DropDown property
			m_nIncludeCommon &= ~CCA_DROPDOWN;
	}

	//=====================================================================
	//= OFormExport
	//=====================================================================
	//---------------------------------------------------------------------
	OFormExport::OFormExport(IFormsExportContext& _rContext, const Reference< XPropertySet >& _rxForm,
		const Sequence< ScriptEventDescriptor >& _rEvents)
		:OElementExport(_rContext, _rxForm, _rEvents)
		,m_bCreateConnectionResourceElement(sal_False)
	{
		OSL_ENSURE(m_xProps.is(), "OFormExport::OFormExport: invalid arguments!");
	}

	//---------------------------------------------------------------------
	const sal_Char* OFormExport::getXMLElementName() const
	{
		return "form";
	}

	//---------------------------------------------------------------------
	void OFormExport::exportSubTags()
	{
		if ( m_bCreateConnectionResourceElement && m_xProps.is() )
		{
			m_rContext.getGlobalContext().ClearAttrList();
			::rtl::OUString sPropValue;
			m_xProps->getPropertyValue( PROPERTY_DATASOURCENAME ) >>= sPropValue; // if set it is a file url
			if ( !sPropValue.getLength() )
				m_xProps->getPropertyValue( PROPERTY_URL ) >>= sPropValue;
			if ( sPropValue.getLength() )
				AddAttribute(
					OAttributeMetaData::getCommonControlAttributeNamespace(CCA_TARGET_LOCATION),
					OAttributeMetaData::getCommonControlAttributeName(CCA_TARGET_LOCATION),
					sPropValue);
			if ( m_rContext.getGlobalContext().GetAttrList().getLength() )
			{
				SvXMLElementExport aFormElement(m_rContext.getGlobalContext(), XML_NAMESPACE_FORM, xmloff::token::XML_CONNECTION_RESOURCE, sal_True, sal_True);
			}
		}

		// let the base class export the remaining properties and the events
		OElementExport::exportSubTags();
		// loop through all children
		Reference< XIndexAccess > xCollection(m_xProps, UNO_QUERY);
		OSL_ENSURE(xCollection.is(), "OFormLayerXMLExport::implExportForm: a form which is not an index access? Suspic�ous!");

		if (xCollection.is())
			m_rContext.exportCollectionElements(xCollection);
	}

	//---------------------------------------------------------------------
	void OFormExport::exportAttributes()
	{
		sal_Int32 i=0;

		// ---------------------
		// the string properties
		{
			static FormAttributes eStringPropertyIds[] =
			{
				faName, /*faAction,*/ faCommand, faFilter, faOrder
			};
			static ::rtl::OUString aStringPropertyNames[] =
			{
				PROPERTY_NAME, /*PROPERTY_TARGETURL,*/ PROPERTY_COMMAND, PROPERTY_FILTER, PROPERTY_ORDER
			};
			sal_Int32 nIdCount = sizeof(eStringPropertyIds) / sizeof(eStringPropertyIds[0]);
		#if OSL_DEBUG_LEVEL > 0
			sal_Int32 nNameCount = sizeof(aStringPropertyNames) / sizeof(aStringPropertyNames[0]);
			OSL_ENSURE((nIdCount == nNameCount),
				"OFormExport::exportAttributes: somebody tampered with the maps (1)!");
		#endif
			for (i=0; i<nIdCount; ++i)
				exportStringPropertyAttribute(
					OAttributeMetaData::getFormAttributeNamespace(eStringPropertyIds[i]),
					OAttributeMetaData::getFormAttributeName(eStringPropertyIds[i]),
					aStringPropertyNames[i]);

            // #i112082# xlink:type is added as part of exportTargetLocationAttribute

            // now export the data source name or databaselocation or connection resource
			::rtl::OUString sPropValue;
			m_xProps->getPropertyValue( PROPERTY_DATASOURCENAME ) >>= sPropValue;
            m_bCreateConnectionResourceElement = !sPropValue.getLength();
			if ( !m_bCreateConnectionResourceElement )
			{
				INetURLObject aURL(sPropValue);
                m_bCreateConnectionResourceElement = ( aURL.GetProtocol() == INET_PROT_FILE );
				if ( !m_bCreateConnectionResourceElement )
					exportStringPropertyAttribute(
						OAttributeMetaData::getFormAttributeNamespace(faDatasource),
						OAttributeMetaData::getFormAttributeName(faDatasource),
						PROPERTY_DATASOURCENAME);
			}
			else
				exportedProperty(PROPERTY_URL);
			if ( m_bCreateConnectionResourceElement )
				exportedProperty(PROPERTY_DATASOURCENAME);
		}

		// ----------------------
		// the boolean properties
		{
			static FormAttributes eBooleanPropertyIds[] =
			{
				faAllowDeletes, faAllowInserts, faAllowUpdates, faApplyFilter, faEscapeProcessing, faIgnoreResult
			};
			static const ::rtl::OUString* pBooleanPropertyNames[] =
			{
				&PROPERTY_ALLOWDELETES, &PROPERTY_ALLOWINSERTS, &PROPERTY_ALLOWUPDATES, &PROPERTY_APPLYFILTER, &PROPERTY_ESCAPEPROCESSING, &PROPERTY_IGNORERESULT
			};
			static sal_Int8 nBooleanPropertyAttrFlags[] =
			{
				BOOLATTR_DEFAULT_TRUE, BOOLATTR_DEFAULT_TRUE, BOOLATTR_DEFAULT_TRUE, BOOLATTR_DEFAULT_FALSE, BOOLATTR_DEFAULT_TRUE, BOOLATTR_DEFAULT_FALSE
			};
			sal_Int32 nIdCount = sizeof(eBooleanPropertyIds) / sizeof(eBooleanPropertyIds[0]);
		#if OSL_DEBUG_LEVEL > 0
			sal_Int32 nNameCount = sizeof(pBooleanPropertyNames) / sizeof(pBooleanPropertyNames[0]);
			sal_Int32 nFlagsCount = sizeof(nBooleanPropertyAttrFlags) / sizeof(nBooleanPropertyAttrFlags[0]);
			OSL_ENSURE((nIdCount == nNameCount) && (nNameCount == nFlagsCount),
				"OFormExport::exportAttributes: somebody tampered with the maps (2)!");
		#endif
			for (i=0; i<nIdCount; ++i)
				exportBooleanPropertyAttribute(
					OAttributeMetaData::getFormAttributeNamespace(eBooleanPropertyIds[i]),
					OAttributeMetaData::getFormAttributeName(eBooleanPropertyIds[i]),
					*(pBooleanPropertyNames[i]),
					nBooleanPropertyAttrFlags[i]
				);
		}

		// -------------------
		// the enum properties
		{
			static FormAttributes eEnumPropertyIds[] =
			{
				faEnctype, faMethod, faCommandType, faNavigationMode, faTabbingCycle
			};
			static const sal_Char* pEnumPropertyNames[] =
			{
				PROPERTY_SUBMIT_ENCODING, PROPERTY_SUBMIT_METHOD, PROPERTY_COMMAND_TYPE, PROPERTY_NAVIGATION, PROPERTY_CYCLE
			};
			static OEnumMapper::EnumProperties eEnumPropertyMaps[] =
			{
				OEnumMapper::epSubmitEncoding, OEnumMapper::epSubmitMethod, OEnumMapper::epCommandType, OEnumMapper::epNavigationType, OEnumMapper::epTabCyle
			};
			static sal_Int32 nEnumPropertyAttrDefaults[] =
			{
				FormSubmitEncoding_URL, FormSubmitMethod_GET, CommandType::COMMAND, NavigationBarMode_CURRENT, TabulatorCycle_RECORDS
			};
			static sal_Bool nEnumPropertyAttrDefaultFlags[] =
			{
				sal_False, sal_False, sal_False, sal_False, sal_True
			};
			sal_Int32 nIdCount = sizeof(eEnumPropertyIds) / sizeof(eEnumPropertyIds[0]);
		#if OSL_DEBUG_LEVEL > 0
			sal_Int32 nNameCount = sizeof(pEnumPropertyNames) / sizeof(pEnumPropertyNames[0]);
			sal_Int32 nDefaultCount = sizeof(nEnumPropertyAttrDefaults) / sizeof(nEnumPropertyAttrDefaults[0]);
			sal_Int32 nDefaultFlagCount = sizeof(nEnumPropertyAttrDefaultFlags) / sizeof(nEnumPropertyAttrDefaultFlags[0]);
			sal_Int32 nMapCount = sizeof(eEnumPropertyMaps) / sizeof(eEnumPropertyMaps[0]);
			OSL_ENSURE((nIdCount == nNameCount) && (nNameCount == nDefaultCount) && (nDefaultCount == nDefaultFlagCount) && (nDefaultFlagCount == nMapCount),
				"OFormExport::exportAttributes: somebody tampered with the maps (3)!");
		#endif
			for (i=0; i<nIdCount; ++i)
				exportEnumPropertyAttribute(
					OAttributeMetaData::getFormAttributeNamespace(eEnumPropertyIds[i]),
					OAttributeMetaData::getFormAttributeName(eEnumPropertyIds[i]),
					pEnumPropertyNames[i],
					OEnumMapper::getEnumMap(eEnumPropertyMaps[i]),
					nEnumPropertyAttrDefaults[i],
					nEnumPropertyAttrDefaultFlags[i]
                );
		}

		// the service name
		exportServiceNameAttribute();
		// the target frame
		exportTargetFrameAttribute();
		// the target URL
		exportTargetLocationAttribute(true);    // #i110911# add type attribute (for form, but not for control)

		// master fields
		exportStringSequenceAttribute(
			OAttributeMetaData::getFormAttributeNamespace(faMasterFields),
			OAttributeMetaData::getFormAttributeName(faMasterFields),
			PROPERTY_MASTERFIELDS);
		// detail fields
		exportStringSequenceAttribute(
			OAttributeMetaData::getFormAttributeNamespace(faDetailFiels),
			OAttributeMetaData::getFormAttributeName(faDetailFiels),
			PROPERTY_DETAILFIELDS);
	}
//.........................................................................
}	// namespace xmloff
//.........................................................................