xref: /trunk/main/reportdesign/source/filter/xml/xmlExport.cxx (revision b63233d8)

/**************************************************************
 *
 * 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.
 *
 *************************************************************/


#include "precompiled_rptxml.hxx"

#include "xmlExport.hxx"
#include "xmlAutoStyle.hxx"
#include <xmloff/ProgressBarHelper.hxx>
#include <comphelper/sequence.hxx>
#include <xmloff/xmltoken.hxx>
#include <xmloff/txtimp.hxx>
#include <xmloff/xmlnmspe.hxx>
#include <xmloff/xmluconv.hxx>
#include <xmloff/nmspmap.hxx>
#include <comphelper/types.hxx>
#include "xmlEnums.hxx"
#include <xmloff/nmspmap.hxx>
#include <xmloff/xmluconv.hxx>
#include <xmloff/txtprmap.hxx>
#include <xmloff/numehelp.hxx>
#include "xmlHelper.hxx"
#include "xmlstrings.hrc"
#include "xmlPropertyHandler.hxx"
#include <com/sun/star/awt/ImagePosition.hpp>
#include <com/sun/star/util/NumberFormat.hpp>
#include <com/sun/star/style/ParagraphAdjust.hpp>
#include <com/sun/star/awt/TextAlign.hpp>
#include <com/sun/star/report/GroupOn.hpp>
#include <com/sun/star/report/XFixedText.hpp>
#include <com/sun/star/report/XImageControl.hpp>
#include <com/sun/star/report/XShape.hpp>
#include <com/sun/star/drawing/XShape.hpp>
#include <com/sun/star/drawing/XShapes.hpp>
#include <com/sun/star/report/XFunction.hpp>
#include <com/sun/star/awt/FontDescriptor.hpp>
#include <com/sun/star/text/TextContentAnchorType.hpp>
#include <com/sun/star/table/BorderLine.hpp>
#include <com/sun/star/report/XFixedLine.hpp>
#include <com/sun/star/frame/XController.hpp>
#include "RptDef.hxx"
// for locking SolarMutex: svapp + mutex
#include <vcl/svapp.hxx>
#include <vos/mutex.hxx>

#include <boost/bind.hpp>

//--------------------------------------------------------------------------
namespace rptxml
{
	using namespace xmloff;
	using namespace comphelper;
	using namespace ::com::sun::star;
	using namespace ::com::sun::star::report;
	using namespace ::com::sun::star::uno;
	using namespace ::com::sun::star::util;
	using namespace ::com::sun::star::xml;

	//---------------------------------------------------------------------
	Reference< XInterface > ORptExportHelper::create(Reference< XComponentContext > const & xContext)
	{
		return static_cast< XServiceInfo* >(new ORptExport(Reference< XMultiServiceFactory >(xContext->getServiceManager(),UNO_QUERY),EXPORT_SETTINGS ));
	}
	//---------------------------------------------------------------------
	::rtl::OUString ORptExportHelper::getImplementationName_Static(  ) throw (RuntimeException)
	{
		return ::rtl::OUString::createFromAscii("com.sun.star.comp.report.XMLSettingsExporter");
	}
	//---------------------------------------------------------------------
	Sequence< ::rtl::OUString > ORptExportHelper::getSupportedServiceNames_Static(  ) throw(RuntimeException)
	{
		Sequence< ::rtl::OUString > aSupported(1);
		aSupported[0] = ::rtl::OUString::createFromAscii("com.sun.star.document.ExportFilter");
		return aSupported;
	}
	//---------------------------------------------------------------------
	Reference< XInterface > ORptContentExportHelper::create(Reference< XComponentContext > const & xContext)
	{
		return static_cast< XServiceInfo* >(new ORptExport(Reference< XMultiServiceFactory >(xContext->getServiceManager(),UNO_QUERY),EXPORT_CONTENT ));
	}
	//---------------------------------------------------------------------
	::rtl::OUString ORptContentExportHelper::getImplementationName_Static(  ) throw (RuntimeException)
	{
		return ::rtl::OUString::createFromAscii("com.sun.star.comp.report.XMLContentExporter");
	}
	//---------------------------------------------------------------------
	Sequence< ::rtl::OUString > ORptContentExportHelper::getSupportedServiceNames_Static(  ) throw(RuntimeException)
	{
		Sequence< ::rtl::OUString > aSupported(1);
		aSupported[0] = ::rtl::OUString::createFromAscii("com.sun.star.document.ExportFilter");
		return aSupported;
	}

    //---------------------------------------------------------------------
	Reference< XInterface > ORptStylesExportHelper::create(Reference< XComponentContext > const & xContext)
	{
		return static_cast< XServiceInfo* >(new ORptExport(Reference< XMultiServiceFactory >(xContext->getServiceManager(),UNO_QUERY),EXPORT_STYLES | EXPORT_MASTERSTYLES | EXPORT_AUTOSTYLES |
    		EXPORT_FONTDECLS|EXPORT_OASIS ));
	}
	//---------------------------------------------------------------------
	::rtl::OUString ORptStylesExportHelper::getImplementationName_Static(  ) throw (RuntimeException)
	{
		return ::rtl::OUString::createFromAscii("com.sun.star.comp.report.XMLStylesExporter");
	}
	//---------------------------------------------------------------------
    Sequence< ::rtl::OUString > ORptStylesExportHelper::getSupportedServiceNames_Static(  ) throw(RuntimeException)
	{
		Sequence< ::rtl::OUString > aSupported(1);
		aSupported[0] = ::rtl::OUString::createFromAscii("com.sun.star.document.ExportFilter");
		return aSupported;
	}

    //---------------------------------------------------------------------
	Reference< XInterface > ORptMetaExportHelper::create(Reference< XComponentContext > const & xContext)
	{
		return static_cast< XServiceInfo* >(new ORptExport(Reference< XMultiServiceFactory >(xContext->getServiceManager(),UNO_QUERY),EXPORT_META ));
	}
	//---------------------------------------------------------------------
	::rtl::OUString ORptMetaExportHelper::getImplementationName_Static(  ) throw (RuntimeException)
	{
		return ::rtl::OUString::createFromAscii("com.sun.star.comp.report.XMLMetaExporter");
	}
	//---------------------------------------------------------------------
	Sequence< ::rtl::OUString > ORptMetaExportHelper::getSupportedServiceNames_Static(  ) throw(RuntimeException)
	{
		Sequence< ::rtl::OUString > aSupported(1);
		aSupported[0] = ::rtl::OUString::createFromAscii("com.sun.star.document.ExportFilter");
		return aSupported;
	}

	//---------------------------------------------------------------------
	Reference< XInterface > ODBFullExportHelper::create(Reference< XComponentContext > const & xContext)
	{
		return static_cast< XServiceInfo* >(new ORptExport(Reference< XMultiServiceFactory >(xContext->getServiceManager(),UNO_QUERY),EXPORT_ALL));
	}
	//---------------------------------------------------------------------
	::rtl::OUString ODBFullExportHelper::getImplementationName_Static(  ) throw (RuntimeException)
	{
		return ::rtl::OUString::createFromAscii("com.sun.star.comp.report.XMLFullExporter");
	}
	//---------------------------------------------------------------------
	Sequence< ::rtl::OUString > ODBFullExportHelper::getSupportedServiceNames_Static(  ) throw(RuntimeException)
	{
		Sequence< ::rtl::OUString > aSupported(1);
		aSupported[0] = ::rtl::OUString::createFromAscii("com.sun.star.document.ExportFilter");
		return aSupported;
	}

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

	class OSpecialHanldeXMLExportPropertyMapper : public SvXMLExportPropertyMapper
	{
	public:
		OSpecialHanldeXMLExportPropertyMapper(const UniReference< XMLPropertySetMapper >& rMapper) : SvXMLExportPropertyMapper(rMapper )
		{
		}
		/** this method is called for every item that has the
	    MID_FLAG_SPECIAL_ITEM_EXPORT flag set */
		virtual void handleSpecialItem(
				SvXMLAttributeList& /*rAttrList*/,
				const XMLPropertyState& /*rProperty*/,
				const SvXMLUnitConverter& /*rUnitConverter*/,
				const SvXMLNamespaceMap& /*rNamespaceMap*/,
				const ::std::vector< XMLPropertyState >* /*pProperties*/ = 0,
				sal_uInt32 /*nIdx*/ = 0 ) const
		{
			// nothing to do here
		}
	};
// -----------------------------------------------------------------------------
void lcl_adjustColumnSpanOverRows(ORptExport::TSectionsGrid& _rGrid)
{
    ORptExport::TSectionsGrid::iterator aSectionIter = _rGrid.begin();
    ORptExport::TSectionsGrid::iterator aSectionEnd = _rGrid.end();
    for (;aSectionIter != aSectionEnd ; ++aSectionIter)
    {
        ORptExport::TGrid::iterator aRowIter = aSectionIter->second.begin();
        ORptExport::TGrid::iterator aRowEnd = aSectionIter->second.end();
        for (; aRowIter != aRowEnd; ++aRowIter)
        {
            if ( aRowIter->first )
            {
                ::std::vector< ORptExport::TCell >::iterator aColIter = aRowIter->second.begin();
                ::std::vector< ORptExport::TCell >::iterator aColEnd = aRowIter->second.end();
                for (; aColIter != aColEnd; ++aColIter)
	            {
                    if ( aColIter->nRowSpan > 1 )
                    {
                        sal_Int32 nColSpan = aColIter->nColSpan;
                        sal_Int32 nColIndex = aColIter - aRowIter->second.begin();
                        for (sal_Int32 i = 1; i < aColIter->nRowSpan; ++i)
                        {
                            (aRowIter+i)->second[nColIndex].nColSpan = nColSpan;
                        }
                    }
                }
            }
        }
    }
}
// -----------------------------------------------------------------------------
ORptExport::ORptExport(const Reference< XMultiServiceFactory >& _rxMSF,sal_uInt16 nExportFlag)
: SvXMLExport( _rxMSF,MAP_100TH_MM,XML_REPORT, EXPORT_OASIS)
,m_bAllreadyFilled(sal_False)
{
	setExportFlags( EXPORT_OASIS | nExportFlag);
	GetMM100UnitConverter().setCoreMeasureUnit(MAP_100TH_MM);
	GetMM100UnitConverter().setXMLMeasureUnit(MAP_CM);

    // (getExportFlags() & EXPORT_CONTENT) != 0 ? : XML_N_OOO
	_GetNamespaceMap().Add( GetXMLToken(XML_NP_OFFICE), GetXMLToken(XML_N_OFFICE ), XML_NAMESPACE_OFFICE );
	_GetNamespaceMap().Add( GetXMLToken(XML_NP_OOO), GetXMLToken(XML_N_OOO), XML_NAMESPACE_OOO );

	_GetNamespaceMap().Add( GetXMLToken(XML_NP_RPT), GetXMLToken(XML_N_RPT), XML_NAMESPACE_REPORT );
    _GetNamespaceMap().Add( GetXMLToken(XML_NP_SVG), GetXMLToken(XML_N_SVG_COMPAT),  XML_NAMESPACE_SVG );
	_GetNamespaceMap().Add( GetXMLToken(XML_NP_FORM), GetXMLToken(XML_N_FORM), XML_NAMESPACE_FORM );
	_GetNamespaceMap().Add( GetXMLToken(XML_NP_DRAW), GetXMLToken(XML_N_DRAW), XML_NAMESPACE_DRAW );
    _GetNamespaceMap().Add( GetXMLToken(XML_NP_TEXT), GetXMLToken(XML_N_TEXT), XML_NAMESPACE_TEXT );


	if( (getExportFlags() & (EXPORT_STYLES|EXPORT_MASTERSTYLES|EXPORT_AUTOSTYLES|EXPORT_FONTDECLS) ) != 0 )
        _GetNamespaceMap().Add( GetXMLToken(XML_NP_FO), GetXMLToken(XML_N_FO_COMPAT), XML_NAMESPACE_FO );

	if( (getExportFlags() & (EXPORT_META|EXPORT_STYLES|EXPORT_MASTERSTYLES|EXPORT_AUTOSTYLES|EXPORT_CONTENT|EXPORT_SCRIPTS|EXPORT_SETTINGS) ) != 0 )
	{
		_GetNamespaceMap().Add( GetXMLToken(XML_NP_XLINK), GetXMLToken(XML_N_XLINK), XML_NAMESPACE_XLINK );
	}
	if( (getExportFlags() & EXPORT_SETTINGS) != 0 )
	{
		_GetNamespaceMap().Add( GetXMLToken(XML_NP_CONFIG), GetXMLToken(XML_N_CONFIG), XML_NAMESPACE_CONFIG );
	}

	if( (getExportFlags() & (EXPORT_STYLES|EXPORT_MASTERSTYLES|EXPORT_AUTOSTYLES|EXPORT_CONTENT|EXPORT_FONTDECLS) ) != 0 )
	{
		_GetNamespaceMap().Add( GetXMLToken(XML_NP_STYLE), GetXMLToken(XML_N_STYLE), XML_NAMESPACE_STYLE );
	}
	// RDFa: needed for content and header/footer styles
    if( (getExportFlags() & (EXPORT_STYLES|EXPORT_AUTOSTYLES|EXPORT_MASTERSTYLES|EXPORT_CONTENT) ) != 0 )
    {
        _GetNamespaceMap().Add( GetXMLToken(XML_NP_XHTML),GetXMLToken(XML_N_XHTML), XML_NAMESPACE_XHTML );
    }
	// GRDDL: to convert RDFa and meta.xml to RDF
    if( (getExportFlags() & (EXPORT_META|EXPORT_STYLES|EXPORT_AUTOSTYLES|EXPORT_MASTERSTYLES|EXPORT_CONTENT) ) != 0 )
    {
        _GetNamespaceMap().Add( GetXMLToken(XML_NP_GRDDL),GetXMLToken(XML_N_GRDDL), XML_NAMESPACE_GRDDL );
    }

	_GetNamespaceMap().Add( GetXMLToken(XML_NP_TABLE), GetXMLToken(XML_N_TABLE), XML_NAMESPACE_TABLE );
	_GetNamespaceMap().Add( GetXMLToken(XML_NP_NUMBER), GetXMLToken(XML_N_NUMBER), XML_NAMESPACE_NUMBER );

    m_sTableStyle = GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_TABLE, GetXMLToken(XML_STYLE_NAME) );
    m_sColumnStyle = GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_TABLE, GetXMLToken(XML_COLUMN) );
    m_sCellStyle = GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_REPORT, GetXMLToken(XML_STYLE_NAME) );


    m_xPropHdlFactory = new OXMLRptPropHdlFactory();
    UniReference < XMLPropertyHandlerFactory> xFac = new ::xmloff::OControlPropertyHandlerFactory();
    UniReference < XMLPropertySetMapper > xTableStylesPropertySetMapper1 = new XMLPropertySetMapper(OXMLHelper::GetTableStyleProps(),xFac);
    UniReference < XMLPropertySetMapper > xTableStylesPropertySetMapper2 = new XMLTextPropertySetMapper(TEXT_PROP_MAP_TABLE_DEFAULTS );
    xTableStylesPropertySetMapper1->AddMapperEntry(xTableStylesPropertySetMapper2);

    m_xTableStylesExportPropertySetMapper = new SvXMLExportPropertyMapper(xTableStylesPropertySetMapper1);
    //m_xTableStylesExportPropertySetMapper->ChainExportMapper(xTableStylesPropertySetMapper2);

    m_xCellStylesPropertySetMapper = OXMLHelper::GetCellStylePropertyMap();
    m_xCellStylesExportPropertySetMapper = new OSpecialHanldeXMLExportPropertyMapper(m_xCellStylesPropertySetMapper);
    m_xCellStylesExportPropertySetMapper->ChainExportMapper(XMLTextParagraphExport::CreateParaExtPropMapper(*this));

    UniReference < XMLPropertySetMapper > xColumnStylesPropertySetMapper = new XMLPropertySetMapper(OXMLHelper::GetColumnStyleProps(), m_xPropHdlFactory);
    m_xColumnStylesExportPropertySetMapper = new OSpecialHanldeXMLExportPropertyMapper(xColumnStylesPropertySetMapper);

    UniReference < XMLPropertySetMapper > xRowStylesPropertySetMapper = new XMLPropertySetMapper(OXMLHelper::GetRowStyleProps(), m_xPropHdlFactory);
    m_xRowStylesExportPropertySetMapper = new OSpecialHanldeXMLExportPropertyMapper(xRowStylesPropertySetMapper);

    UniReference < XMLPropertySetMapper > xPropMapper(new XMLTextPropertySetMapper( TEXT_PROP_MAP_PARA ));
	m_xParaPropMapper = new OSpecialHanldeXMLExportPropertyMapper( xPropMapper);
    // m_xParaPropMapper->ChainExportMapper(XMLTextParagraphExport::CreateParaExtPropMapper(*this));

    ::rtl::OUString sFamily( GetXMLToken(XML_PARAGRAPH) );
	::rtl::OUString aPrefix( String( 'P' ) );
	GetAutoStylePool()->AddFamily( XML_STYLE_FAMILY_TEXT_PARAGRAPH, sFamily,
							  m_xParaPropMapper, aPrefix );

    GetAutoStylePool()->AddFamily(XML_STYLE_FAMILY_TABLE_CELL, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_CELL_STYLES_NAME)),
		m_xCellStylesExportPropertySetMapper, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_CELL_STYLES_PREFIX)));
    GetAutoStylePool()->AddFamily(XML_STYLE_FAMILY_TABLE_COLUMN, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_COLUMN_STYLES_NAME)),
		m_xColumnStylesExportPropertySetMapper, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_COLUMN_STYLES_PREFIX)));
    GetAutoStylePool()->AddFamily(XML_STYLE_FAMILY_TABLE_ROW, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_ROW_STYLES_NAME)),
		m_xRowStylesExportPropertySetMapper, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_ROW_STYLES_PREFIX)));
    GetAutoStylePool()->AddFamily(XML_STYLE_FAMILY_TABLE_TABLE, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_TABLE_STYLES_NAME)),
		m_xTableStylesExportPropertySetMapper, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_TABLE_STYLES_PREFIX)));
}
// -----------------------------------------------------------------------------
Reference< XInterface > ORptExport::create(Reference< XComponentContext > const & xContext)
{
	return *(new ORptExport(Reference< XMultiServiceFactory >(xContext->getServiceManager(),UNO_QUERY)));
}

// -----------------------------------------------------------------------------
::rtl::OUString ORptExport::getImplementationName_Static(  ) throw(uno::RuntimeException)
{
	return ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.comp.report.ExportFilter"));
}

//--------------------------------------------------------------------------
::rtl::OUString SAL_CALL ORptExport::getImplementationName(  ) throw(uno::RuntimeException)
{
	return getImplementationName_Static();
}
//--------------------------------------------------------------------------
uno::Sequence< ::rtl::OUString > ORptExport::getSupportedServiceNames_Static(  ) throw(uno::RuntimeException)
{
	uno::Sequence< ::rtl::OUString > aServices(1);
	aServices.getArray()[0] = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.document.ExportFilter"));

	return aServices;
}
//--------------------------------------------------------------------------
uno::Sequence< ::rtl::OUString > SAL_CALL ORptExport::getSupportedServiceNames(  ) throw(uno::RuntimeException)
{
	return getSupportedServiceNames_Static();
}
//------------------------------------------------------------------------------
sal_Bool SAL_CALL ORptExport::supportsService(const ::rtl::OUString& ServiceName) throw( uno::RuntimeException )
{
    return ::comphelper::existsValue(ServiceName,getSupportedServiceNames_Static());
}
// -----------------------------------------------------------------------------
void ORptExport::exportFunctions(const Reference<XIndexAccess>& _xFunctions)
{
    const sal_Int32 nCount = _xFunctions->getCount();
    for (sal_Int32 i = 0; i< nCount; ++i)
    {
        uno::Reference< report::XFunction> xFunction(_xFunctions->getByIndex(i),uno::UNO_QUERY_THROW);
        OSL_ENSURE(xFunction.is(),"Function object is NULL!");
        exportFunction(xFunction);
    }
}
// -----------------------------------------------------------------------------
void ORptExport::exportFunction(const uno::Reference< XFunction>& _xFunction)
{
    exportFormula(XML_FORMULA,_xFunction->getFormula());
    beans::Optional< ::rtl::OUString> aInitial = _xFunction->getInitialFormula();
    if ( aInitial.IsPresent && aInitial.Value.getLength() )
        exportFormula(XML_INITIAL_FORMULA ,aInitial.Value );
    AddAttribute( XML_NAMESPACE_REPORT, XML_NAME , _xFunction->getName() );
    if ( _xFunction->getPreEvaluated() )
        AddAttribute( XML_NAMESPACE_REPORT, XML_PRE_EVALUATED , XML_TRUE );
    if ( _xFunction->getDeepTraversing() )
        AddAttribute( XML_NAMESPACE_REPORT, XML_DEEP_TRAVERSING , XML_TRUE );

    SvXMLElementExport aFunction(*this,XML_NAMESPACE_REPORT, XML_FUNCTION, sal_True, sal_True);
}
// -----------------------------------------------------------------------------
void ORptExport::exportMasterDetailFields(const Reference<XReportComponent>& _xReportComponet)
{
    const uno::Sequence< ::rtl::OUString> aMasterFields = _xReportComponet->getMasterFields();
    if ( aMasterFields.getLength() )
    {
        SvXMLElementExport aElement(*this,XML_NAMESPACE_REPORT, XML_MASTER_DETAIL_FIELDS, sal_True, sal_True);
        const uno::Sequence< ::rtl::OUString> aDetailFields = _xReportComponet->getDetailFields();

        OSL_ENSURE(aDetailFields.getLength() == aMasterFields.getLength(),"not equal length for master and detail fields!");

        const ::rtl::OUString* pDetailFieldsIter = aDetailFields.getConstArray();
        const ::rtl::OUString* pIter = aMasterFields.getConstArray();
        const ::rtl::OUString* pEnd	  = pIter + aMasterFields.getLength();
        for(;pIter != pEnd;++pIter,++pDetailFieldsIter)
        {
            AddAttribute( XML_NAMESPACE_REPORT, XML_MASTER , *pIter );
            if ( pDetailFieldsIter->getLength() )
                AddAttribute( XML_NAMESPACE_REPORT, XML_DETAIL , *pDetailFieldsIter );
            SvXMLElementExport aPair(*this,XML_NAMESPACE_REPORT, XML_MASTER_DETAIL_FIELD, sal_True, sal_True);
        }
    }
}
// -----------------------------------------------------------------------------
void ORptExport::exportReport(const Reference<XReportDefinition>& _xReportDefinition)
{
	if ( _xReportDefinition.is() )
	{
        exportFunctions(_xReportDefinition->getFunctions().get());
        exportGroupsExpressionAsFunction(_xReportDefinition->getGroups());
        //exportMasterDetailFields(_xReportDefinition.get());

		if ( _xReportDefinition->getReportHeaderOn() )
		{
			SvXMLElementExport aGroupSection(*this,XML_NAMESPACE_REPORT, XML_REPORT_HEADER, sal_True, sal_True);
			exportSection(_xReportDefinition->getReportHeader());
		} // if ( _xReportDefinition->getReportHeaderOn() )
		if ( _xReportDefinition->getPageHeaderOn() )
		{
            ::rtl::OUStringBuffer sValue;
		    sal_uInt16 nRet = _xReportDefinition->getPageHeaderOption();
		    const SvXMLEnumMapEntry* aXML_EnumMap = OXMLHelper::GetReportPrintOptions();
		    if ( SvXMLUnitConverter::convertEnum( sValue, nRet,aXML_EnumMap ) )
			    AddAttribute(XML_NAMESPACE_REPORT, XML_PAGE_PRINT_OPTION,sValue.makeStringAndClear());

			SvXMLElementExport aGroupSection(*this,XML_NAMESPACE_REPORT, XML_PAGE_HEADER, sal_True, sal_True);
			exportSection(_xReportDefinition->getPageHeader(),true);
		} // if ( _xReportDefinition->getPageHeaderOn() )

        exportGroup(_xReportDefinition,0);

		if ( _xReportDefinition->getPageFooterOn() )
		{
            ::rtl::OUStringBuffer sValue;
            sal_uInt16 nRet = _xReportDefinition->getPageFooterOption();
            const SvXMLEnumMapEntry* aXML_EnumMap = OXMLHelper::GetReportPrintOptions();
		    if ( SvXMLUnitConverter::convertEnum( sValue, nRet,aXML_EnumMap ) )
			    AddAttribute(XML_NAMESPACE_REPORT, XML_PAGE_PRINT_OPTION,sValue.makeStringAndClear());
			SvXMLElementExport aGroupSection(*this,XML_NAMESPACE_REPORT, XML_PAGE_FOOTER, sal_True, sal_True);
			exportSection(_xReportDefinition->getPageFooter(),true);
		} // if ( _xReportDefinition->getPageFooterOn() )
		if ( _xReportDefinition->getReportFooterOn() )
		{
			SvXMLElementExport aGroupSection(*this,XML_NAMESPACE_REPORT, XML_REPORT_FOOTER, sal_True, sal_True);
			exportSection(_xReportDefinition->getReportFooter());
		} // if ( _xReportDefinition->getReportFooterOn() )
	}
}
// -----------------------------------------------------------------------------
void ORptExport::exportComponent(const Reference<XReportComponent>& _xReportComponent)
{
	OSL_ENSURE(_xReportComponent.is(),"No component interface!");
	if ( !_xReportComponent.is() )
		return;

	AddAttribute(XML_NAMESPACE_DRAW, XML_NAME,_xReportComponent->getName());

	SvXMLElementExport aElem(*this,XML_NAMESPACE_REPORT, XML_REPORT_COMPONENT, sal_False, sal_False);
}
// -----------------------------------------------------------------------------
void ORptExport::exportFormatConditions(const Reference<XReportControlModel>& _xReportElement)
{
	OSL_ENSURE(_xReportElement.is(),"_xReportElement is NULL -> GPF");
    ::rtl::OUString sDataField = convertFormula(_xReportElement->getDataField());
	const sal_Int32 nCount = _xReportElement->getCount();
	try
	{
		for (sal_Int32 i = 0; i < nCount ; ++i)
		{
			uno::Reference< report::XFormatCondition > xCond(_xReportElement->getByIndex(i),uno::UNO_QUERY);
			if ( !xCond->getEnabled() )
				AddAttribute(XML_NAMESPACE_REPORT, XML_ENABLED,XML_FALSE);

            AddAttribute(XML_NAMESPACE_REPORT, XML_FORMULA,xCond->getFormula());

			exportStyleName(xCond.get(),GetAttrList(),m_sCellStyle);
			SvXMLElementExport aElem(*this,XML_NAMESPACE_REPORT, XML_FORMAT_CONDITION, sal_True, sal_True);
		} // for (sal_Int32 i = 0; i < nCount ; ++i)
	}
	catch(uno::Exception&)
	{
		OSL_ENSURE(0,"Can not access format condition!");
	}
}
// -----------------------------------------------------------------------------
void ORptExport::exportReportElement(const Reference<XReportControlModel>& _xReportElement)
{
	OSL_ENSURE(_xReportElement.is(),"_xReportElement is NULL -> GPF");
	if ( _xReportElement->getPrintWhenGroupChange() )
		AddAttribute(XML_NAMESPACE_REPORT, XML_PRINT_ONLY_WHEN_GROUP_CHANGE, XML_TRUE );

	if ( !_xReportElement->getPrintRepeatedValues() )
		AddAttribute(XML_NAMESPACE_REPORT, XML_PRINT_REPEATED_VALUES,XML_FALSE);

	SvXMLElementExport aElem(*this,XML_NAMESPACE_REPORT, XML_REPORT_ELEMENT, sal_True, sal_True);
    if ( _xReportElement->getCount() )
    {
        exportFormatConditions(_xReportElement);
    }

	::rtl::OUString sExpr = _xReportElement->getConditionalPrintExpression();
	if ( sExpr.getLength() )
	{
        exportFormula(XML_FORMULA,sExpr);
        SvXMLElementExport aPrintExpr(*this,XML_NAMESPACE_REPORT, XML_CONDITIONAL_PRINT_EXPRESSION, sal_True, sal_True);
	} // if ( sExpr.getLength() )

    // only export when parent exists
	uno::Reference< report::XSection> xParent(_xReportElement->getParent(),uno::UNO_QUERY);
	if ( xParent.is() )
		exportComponent(_xReportElement.get());
}
// -----------------------------------------------------------------------------
void lcl_calculate(const ::std::vector<sal_Int32>& _aPosX,const ::std::vector<sal_Int32>& _aPosY,ORptExport::TGrid& _rColumns)
{
    sal_Int32 nCountX = _aPosX.size() - 1;
    sal_Int32 nCountY = _aPosY.size() - 1;
    for (sal_Int32 j = 0; j < nCountY; ++j)
    {
        sal_Int32 nHeight = _aPosY[j+1] - _aPosY[j];
        if ( nHeight )
            for (sal_Int32 i = 0; i < nCountX ; ++i)
            {
                _rColumns[j].second[i] = ORptExport::TCell(_aPosX[i+1] - _aPosX[i],nHeight,1,1);
                _rColumns[j].second[i].bSet = sal_True;
            }
    }
}
// -----------------------------------------------------------------------------
void ORptExport::collectStyleNames(sal_Int32 _nFamily,const ::std::vector< sal_Int32>& _aSize, ORptExport::TStringVec& _rStyleNames)
{
    ::std::vector< XMLPropertyState > aPropertyStates;
    aPropertyStates.push_back(XMLPropertyState(0));
    ::std::vector<sal_Int32>::const_iterator aIter = _aSize.begin();
    ::std::vector<sal_Int32>::const_iterator aIter2 = aIter + 1;
    ::std::vector<sal_Int32>::const_iterator aEnd = _aSize.end();
    for (;aIter2 != aEnd ; ++aIter,++aIter2)
    {
        sal_Int32 nValue = static_cast<sal_Int32>(*aIter2 - *aIter);
        aPropertyStates[0].maValue <<= nValue;
        _rStyleNames.push_back(GetAutoStylePool()->Add(_nFamily, aPropertyStates ));
    }
}
// -----------------------------------------------------------------------------
void ORptExport::exportSectionAutoStyle(const Reference<XSection>& _xProp)
{
	OSL_ENSURE(_xProp != NULL,"Section is NULL -> GPF");
	exportAutoStyle(_xProp);

    Reference<XReportDefinition> xReport = _xProp->getReportDefinition();
    const awt::Size aSize   = rptui::getStyleProperty<awt::Size>(xReport,PROPERTY_PAPERSIZE);
    const sal_Int32 nOffset = rptui::getStyleProperty<sal_Int32>(xReport,PROPERTY_LEFTMARGIN);
    const sal_Int32 nCount  = _xProp->getCount();

    ::std::vector<sal_Int32> aColumnPos;
    aColumnPos.reserve(2*(nCount + 1));
    aColumnPos.push_back(nOffset);
    aColumnPos.push_back(aSize.Width - rptui::getStyleProperty<sal_Int32>(xReport,PROPERTY_RIGHTMARGIN));

    ::std::vector<sal_Int32> aRowPos;
    aRowPos.reserve(2*(nCount + 1));
    aRowPos.push_back(0);
    aRowPos.push_back(_xProp->getHeight());

    sal_Int32 i;
	for (i = 0 ; i< nCount ; ++i)
	{
		Reference<XReportComponent> xReportElement(_xProp->getByIndex(i),uno::UNO_QUERY);
        uno::Reference< XShape> xShape(xReportElement,uno::UNO_QUERY);
        if ( xShape.is() )
            continue;
        OSL_ENSURE( xReportElement.is(),"NULL Element in Section!" );
        if ( !xReportElement.is() )
            continue;
        sal_Int32 nX = xReportElement->getPositionX();
        aColumnPos.push_back(nX);
        Reference<XFixedLine> xFixedLine(xReportElement,uno::UNO_QUERY);
        if ( xFixedLine.is() && xFixedLine->getOrientation() == 1 ) // vertical
        {
            sal_Int32 nWidth = static_cast<sal_Int32>(xReportElement->getWidth()*0.5);
            nX += nWidth;
            aColumnPos.push_back(nX);
            nX += xReportElement->getWidth() - nWidth;
        }
        else
            nX += xReportElement->getWidth();
        aColumnPos.push_back(nX); // --nX why?

        sal_Int32 nY = xReportElement->getPositionY();
        aRowPos.push_back(nY);
        nY += xReportElement->getHeight();
        aRowPos.push_back(nY); // --nY why?
    }

    ::std::sort(aColumnPos.begin(),aColumnPos.end(),::std::less<sal_Int32>());
    aColumnPos.erase(::std::unique(aColumnPos.begin(),aColumnPos.end()),aColumnPos.end());

    ::std::sort(aRowPos.begin(),aRowPos.end(),::std::less<sal_Int32>());
    aRowPos.erase(::std::unique(aRowPos.begin(),aRowPos.end()),aRowPos.end());

    TSectionsGrid::iterator aInsert = m_aSectionsGrid.insert(
        TSectionsGrid::value_type(
                                    _xProp.get(),
                                    TGrid(aRowPos.size() - 1,TGrid::value_type(sal_False,TRow(aColumnPos.size() - 1)))
                                  )
        ).first;
    lcl_calculate(aColumnPos,aRowPos,aInsert->second);

    TGridStyleMap::iterator aPos = m_aColumnStyleNames.insert(TGridStyleMap::value_type(_xProp.get(),TStringVec())).first;
    collectStyleNames(XML_STYLE_FAMILY_TABLE_COLUMN,aColumnPos,aPos->second);
    aPos = m_aRowStyleNames.insert(TGridStyleMap::value_type(_xProp.get(),TStringVec())).first;
    collectStyleNames(XML_STYLE_FAMILY_TABLE_ROW,aRowPos,aPos->second);

    sal_Int32 x1 = 0;
	sal_Int32 y1 = 0;
	sal_Int32 x2 = 0;
	sal_Int32 y2 = 0;
	sal_Int32 xi = 0;
	sal_Int32 yi = 0;
	bool isOverlap = false;

	for (i = 0 ; i< nCount ; ++i)
	{
		Reference<XReportComponent> xReportElement(_xProp->getByIndex(i),uno::UNO_QUERY);
        uno::Reference< XShape> xShape(xReportElement,uno::UNO_QUERY);
        if ( xShape.is() )
            continue;
        sal_Int32 nPos = xReportElement->getPositionX();
        x1 = (::std::find(aColumnPos.begin(),aColumnPos.end(),nPos) - aColumnPos.begin());
        Reference<XFixedLine> xFixedLine(xReportElement,uno::UNO_QUERY);
        if ( xFixedLine.is() && xFixedLine->getOrientation() == 1 ) // vertical
            nPos += static_cast<sal_Int32>(xReportElement->getWidth()*0.5);
        else
            nPos += xReportElement->getWidth(); // -1 why
        x2 = (::std::find(aColumnPos.begin(),aColumnPos.end(),nPos) - aColumnPos.begin());

        nPos = xReportElement->getPositionY();
        y1 = (::std::find(aRowPos.begin(),aRowPos.end(),nPos) - aRowPos.begin());
        nPos += xReportElement->getHeight(); // -1 why?
        y2 = (::std::find(aRowPos.begin(),aRowPos.end(),nPos) - aRowPos.begin());

		isOverlap = false;
		yi = y1;
		while(yi < y2 && !isOverlap) // find overlapping controls
		{
			xi = x1;
			while(xi < x2 && !isOverlap)
			{
				if ( aInsert->second[yi].second[xi].xElement.is() )
				{
					isOverlap = true;
				}
				++xi;
			}
			++yi;
		}

		if (!isOverlap)
		{
			yi = y1;
			while(yi < y2)
			{
				xi = x1;
				while(xi < x2)
				{
					aInsert->second[yi].second[xi] = TCell();
					++xi;
				}
                aInsert->second[yi].first = sal_True;
				++yi;
			}

			if (x2 - x1 != 0 && y2 - y1 != 0)
			{
                awt::Size aElementSize = xReportElement->getSize();
                if ( xFixedLine.is() && xFixedLine->getOrientation() == 1 ) // vertical
                    aElementSize.Width = static_cast<sal_Int32>(xFixedLine->getWidth()*0.5);

                sal_Int32 nColSpan = x2 - x1;
                sal_Int32 nRowSpan = y2 - y1;
				aInsert->second[y1].second[x1] =
					TCell(
						aElementSize.Width , // -1 why?
						aElementSize.Height, // -1 why?
						nColSpan,
						nRowSpan,
                        xReportElement
						);
			}
		}
	}

    lcl_adjustColumnSpanOverRows(m_aSectionsGrid);
    exportReportComponentAutoStyles(_xProp);
}
// -----------------------------------------------------------------------------
void ORptExport::exportReportComponentAutoStyles(const Reference<XSection>& _xProp)
{
    const sal_Int32 nCount = _xProp->getCount();
    for (sal_Int32 i = 0 ; i< nCount ; ++i)
	{
        const Reference<XReportComponent> xReportElement(_xProp->getByIndex(i),uno::UNO_QUERY);
        const Reference< report::XShape > xShape(xReportElement,uno::UNO_QUERY);
        if ( xShape.is() )
        {
            UniReference< XMLShapeExport > xShapeExport = GetShapeExport();
            xShapeExport->seekShapes(_xProp.get());
            vos::OGuard aGuard(Application::GetSolarMutex());
            xShapeExport->collectShapeAutoStyles(xShape.get());
        }
        else
        {
		    exportAutoStyle(xReportElement.get());

		    Reference<XFormattedField> xFormattedField(xReportElement,uno::UNO_QUERY);
		    if ( xFormattedField.is() )
		    {
			    try
			    {
				    const sal_Int32 nFormatCount = xFormattedField->getCount();
				    for (sal_Int32 j = 0; j < nFormatCount ; ++j)
				    {
					    uno::Reference< report::XFormatCondition > xCond(xFormattedField->getByIndex(j),uno::UNO_QUERY);
					    exportAutoStyle(xCond.get(),xFormattedField);
				    } // for (sal_Int32 j = 0; j < nCount ; ++j)
			    }
			    catch(uno::Exception&)
			    {
				    OSL_ENSURE(0,"Can not access format condition!");
			    }
		    }
        }
	}
}
// -----------------------------------------------------------------------------
void ORptExport::exportSection(const Reference<XSection>& _xSection,bool bHeader)
{
	OSL_ENSURE(_xSection.is(),"Section is NULL -> GPF");
	::rtl::OUStringBuffer sValue;
	AddAttribute(XML_NAMESPACE_TABLE, XML_NAME,_xSection->getName());

	if ( !_xSection->getVisible() )
		AddAttribute(XML_NAMESPACE_REPORT, XML_VISIBLE,XML_FALSE);

    if ( !bHeader )
    {
	    sal_uInt16 nRet = _xSection->getForceNewPage();
	    const SvXMLEnumMapEntry* aXML_EnumMap = OXMLHelper::GetForceNewPageOptions();
	    if ( SvXMLUnitConverter::convertEnum( sValue, nRet,aXML_EnumMap ) )
		    AddAttribute(XML_NAMESPACE_REPORT, XML_FORCE_NEW_PAGE,sValue.makeStringAndClear());

	    nRet = _xSection->getNewRowOrCol();
	    if ( SvXMLUnitConverter::convertEnum( sValue, nRet,aXML_EnumMap ) )
		    AddAttribute(XML_NAMESPACE_REPORT, XML_FORCE_NEW_COLUMN,sValue.makeStringAndClear());
        if ( _xSection->getKeepTogether() )
		    AddAttribute(XML_NAMESPACE_REPORT, XML_KEEP_TOGETHER, XML_TRUE );
    }

	exportStyleName(_xSection.get(),GetAttrList(),m_sTableStyle);

    /// TODO export as table layout
	SvXMLElementExport aComponents(*this,XML_NAMESPACE_TABLE, XML_TABLE, sal_True, sal_True);

	::rtl::OUString sExpr = _xSection->getConditionalPrintExpression();
	if ( sExpr.getLength() )
	{
        exportFormula(XML_FORMULA,sExpr);
        SvXMLElementExport aPrintExpr(*this,XML_NAMESPACE_REPORT, XML_CONDITIONAL_PRINT_EXPRESSION, sal_True, sal_False);
	}

    exportContainer(_xSection);
}
// -----------------------------------------------------------------------------
void ORptExport::exportTableColumns(const Reference< XSection>& _xSection)
{
    SvXMLElementExport aColumns(*this,XML_NAMESPACE_TABLE, XML_TABLE_COLUMNS, sal_True, sal_True);
    TGridStyleMap::iterator aColFind = m_aColumnStyleNames.find(_xSection.get());
    OSL_ENSURE(aColFind != m_aColumnStyleNames.end(),"ORptExport::exportTableColumns: Section not found in m_aColumnStyleNames!");
    if ( aColFind == m_aColumnStyleNames.end() )
        return;

    TStringVec::iterator aColIter = aColFind->second.begin();
    TStringVec::iterator aColEnd = aColFind->second.end();
    for (; aColIter != aColEnd; ++aColIter)
	{
        AddAttribute( m_sTableStyle,*aColIter );
        SvXMLElementExport aColumn(*this,XML_NAMESPACE_TABLE, XML_TABLE_COLUMN, sal_True, sal_True);
    }
}
// -----------------------------------------------------------------------------
void ORptExport::exportContainer(const Reference< XSection>& _xSection)
{
    OSL_ENSURE(_xSection.is(),"Section is NULL -> GPF");

    exportTableColumns(_xSection);

    TSectionsGrid::iterator aFind = m_aSectionsGrid.find(_xSection.get());
    OSL_ENSURE(aFind != m_aSectionsGrid.end(),"ORptExport::exportContainer: Section not found in grid!");
    if ( aFind == m_aSectionsGrid.end() )
        return;
    TGrid::iterator aRowIter = aFind->second.begin();
    TGrid::iterator aRowEnd = aFind->second.end();

    sal_Int32 nEmptyCellColSpan = 0;
    TGridStyleMap::iterator aRowFind = m_aRowStyleNames.find(_xSection.get());
    TStringVec::iterator aHeightIter = aRowFind->second.begin();
    OSL_ENSURE(aRowFind->second.size() == aFind->second.size(),"Different count for rows");

    bool bShapeHandled = false;
    ::std::map<sal_Int32,sal_Int32> aRowSpan;
    for (sal_Int32 j = 0; aRowIter != aRowEnd; ++aRowIter,++j,++aHeightIter)
    {
        AddAttribute( m_sTableStyle,*aHeightIter );
        SvXMLElementExport aRow(*this,XML_NAMESPACE_TABLE, XML_TABLE_ROW, sal_True, sal_True);
        if ( aRowIter->first )
        {
            ::std::vector< TCell >::iterator aColIter = aRowIter->second.begin();
            ::std::vector< TCell >::iterator aColEnd = aRowIter->second.end();
            nEmptyCellColSpan = 0;
            for (; aColIter != aColEnd; ++aColIter)
	        {
                sal_Bool bCoveredCell = sal_False;
                sal_Int32 nColSpan = 0;
                sal_Int32 nColIndex = aColIter - aRowIter->second.begin();
                ::std::map<sal_Int32,sal_Int32>::iterator aRowSpanFind = aRowSpan.find(nColIndex);
                if ( aRowSpanFind != aRowSpan.end() )
                {
#if OSL_DEBUG_LEVEL > 0
                    sal_Int32 nRowSpan = aRowSpanFind->second;
                    nRowSpan = nRowSpan;
                    sal_Int32 nColSpanTemp = aColIter->nColSpan;
                    (void) nColSpanTemp;
#endif
                    nColSpan = 1;
                    if ( !--(aRowSpanFind->second) )
                        aRowSpan.erase(aRowSpanFind);

                    if ( aColIter->nColSpan > 1 )
                        nColSpan += aColIter->nColSpan - 1;

                    bCoveredCell = sal_True;
                    aColIter = aColIter + (aColIter->nColSpan - 1);
                }
                else if ( aColIter->bSet )
                {
                    if ( nEmptyCellColSpan > 0 )
                    {
                        AddAttribute( XML_NAMESPACE_TABLE,XML_NUMBER_COLUMNS_SPANNED,implConvertNumber(nEmptyCellColSpan) );
                        bCoveredCell = sal_True;
                        nColSpan = nEmptyCellColSpan - 1;
						nEmptyCellColSpan = 0;
					}
                    sal_Int32 nSpan = aColIter->nColSpan;
                    if ( nSpan > 1 )
                    {
                        AddAttribute( XML_NAMESPACE_TABLE,XML_NUMBER_COLUMNS_SPANNED,implConvertNumber(nSpan) );
                        nColSpan = nSpan - 1;
                        bCoveredCell = sal_True;
                    }
                    nSpan = aColIter->nRowSpan;
                    if ( nSpan > 1 )
                    {
                        AddAttribute( XML_NAMESPACE_TABLE,XML_NUMBER_ROWS_SPANNED,implConvertNumber(nSpan) );
                        aRowSpan[nColIndex] = nSpan - 1;
                    }
                    if ( aColIter->xElement.is() )
                        exportStyleName(aColIter->xElement.get(),GetAttrList(),m_sTableStyle);

                    // start <table:table-cell>
                    Reference<XFormattedField> xFormattedField(aColIter->xElement,uno::UNO_QUERY);
                    if ( xFormattedField.is() )
                    {
                        sal_Int32 nFormatKey = xFormattedField->getFormatKey();
                        if ( 0 != nFormatKey )
                        {
                            XMLNumberFormatAttributesExportHelper aHelper(GetNumberFormatsSupplier(),*this);
                            sal_Bool bIsStandard = sal_False;
                            ::rtl::OUString sEmpty;
                            if ( util::NumberFormat::TEXT == aHelper.GetCellType(nFormatKey,bIsStandard) )
                                aHelper.SetNumberFormatAttributes(sEmpty, sEmpty);
                            else
                                aHelper.SetNumberFormatAttributes(nFormatKey, 0.0,sal_False);
                        }
                    }
                    SvXMLElementExport aCell(*this,XML_NAMESPACE_TABLE, XML_TABLE_CELL, sal_True, sal_False);

                    if ( aColIter->xElement.is() )
                    {
                        // start <text:p>
                        SvXMLElementExport aParagraphContent(*this,XML_NAMESPACE_TEXT, XML_P, sal_True,sal_False);
                        Reference<XServiceInfo> xElement(aColIter->xElement,uno::UNO_QUERY);
                        Reference<XReportComponent> xReportComponent = aColIter->xElement;

                        if ( !bShapeHandled )
                        {
                            bShapeHandled = true;
                            exportShapes(_xSection,false);
                        }
                        uno::Reference< XShape > xShape(xElement,uno::UNO_QUERY);
                        uno::Reference< XFixedLine > xFixedLine(xElement,uno::UNO_QUERY);
                        if ( !xShape.is() && !xFixedLine.is() )
                        {
		                    Reference<XReportControlModel> xReportElement(xElement,uno::UNO_QUERY);
                            Reference<XReportDefinition> xReportDefinition(xElement,uno::UNO_QUERY);
                            Reference< XImageControl > xImage(xElement,uno::UNO_QUERY);
                            Reference<XSection> xSection(xElement,uno::UNO_QUERY);

		                    XMLTokenEnum eToken = XML_SECTION;
                            sal_Bool bExportData = sal_False;
		                    if ( xElement->supportsService(SERVICE_FIXEDTEXT) )
		                    {
			                    eToken = XML_FIXED_CONTENT;
		                    }
		                    else if ( xElement->supportsService(SERVICE_FORMATTEDFIELD) )
		                    {
			                    eToken = XML_FORMATTED_TEXT;
                                bExportData = sal_True;
		                    }
		                    else if ( xElement->supportsService(SERVICE_IMAGECONTROL) )
		                    {
			                    eToken = XML_IMAGE;
			                    ::rtl::OUString sTargetLocation = xImage->getImageURL();
			                    if ( sTargetLocation.getLength() )
                                {
				                    sTargetLocation = GetRelativeReference(sTargetLocation);
			                        AddAttribute(XML_NAMESPACE_FORM, XML_IMAGE_DATA,sTargetLocation);
                                }
                                bExportData = sal_True;
                                ::rtl::OUStringBuffer sValue;
                                const SvXMLEnumMapEntry* aXML_ImageScaleEnumMap = OXMLHelper::GetImageScaleOptions();
                                if ( SvXMLUnitConverter::convertEnum( sValue, xImage->getScaleMode(),aXML_ImageScaleEnumMap ) )
                                    AddAttribute(XML_NAMESPACE_REPORT, XML_SCALE, sValue.makeStringAndClear() );
		                    }
                            else if ( xReportDefinition.is() )
                            {
                                eToken = XML_SUB_DOCUMENT;
                            }
                            else if ( xSection.is() )
                            {
                            }

                            bool bPageSet = false;
                            if ( bExportData )
                            {
                                bPageSet = exportFormula(XML_FORMULA,xReportElement->getDataField());
                                if ( bPageSet )
                                    eToken = XML_FIXED_CONTENT;
                                else if ( eToken == XML_IMAGE )
                                    AddAttribute(XML_NAMESPACE_REPORT, XML_PRESERVE_IRI, xImage->getPreserveIRI() ? XML_TRUE : XML_FALSE );
                            }

                            //if ( !bPageSet )
                            {
                                // start <report:eToken>
		                        SvXMLElementExport aComponents(*this,XML_NAMESPACE_REPORT, eToken, sal_False, sal_False);
                                if ( eToken == XML_FIXED_CONTENT )
                                    exportParagraph(xReportElement);
                                if ( xReportElement.is() )
			                        exportReportElement(xReportElement);

                                if ( eToken == XML_GROUP && xSection.is() )
                                    exportContainer(xSection);
                                else if ( eToken == XML_SUB_DOCUMENT && xReportDefinition.is() )
                                {
                                    SvXMLElementExport aOfficeElement( *this, XML_NAMESPACE_OFFICE, XML_BODY,sal_True, sal_True );
			                        SvXMLElementExport aElem( *this, sal_True,
									                        XML_NAMESPACE_OFFICE, XML_REPORT,
								  	                        sal_True, sal_True );

                                    exportReportAttributes(xReportDefinition);
                                    exportReport(xReportDefinition);
                                }
                                else if ( xSection.is() )
                                    exportSection(xSection);
                            }
                        }
                    } // if ( aColIter->xElement.is() )
                    else if ( !bShapeHandled )
                    {
                        bShapeHandled = true;
                        exportShapes(_xSection);
                    }
                    aColIter = aColIter + (aColIter->nColSpan - 1);
				}
                else
					++nEmptyCellColSpan;
                if ( bCoveredCell )
                {
                    for (sal_Int32 k = 0; k < nColSpan; ++k)
                    {
                        SvXMLElementExport aCell(*this,XML_NAMESPACE_TABLE, XML_COVERED_TABLE_CELL, sal_True, sal_True);
                    }

                }
	        } // for (sal_Int32 i = 0 ; i< nCount ; ++i)
            if ( nEmptyCellColSpan )
            {
                {
                    AddAttribute( XML_NAMESPACE_TABLE,XML_NUMBER_COLUMNS_SPANNED,implConvertNumber(nEmptyCellColSpan) );
                    SvXMLElementExport aCell(*this,XML_NAMESPACE_TABLE, XML_TABLE_CELL, sal_True, sal_True);
                    if ( !bShapeHandled )
                    {
                        bShapeHandled = true;
                        exportShapes(_xSection);
                    }
                }
                for (sal_Int32 k = 0; k < nEmptyCellColSpan; ++k)
                {
                    SvXMLElementExport aCoveredCell(*this,XML_NAMESPACE_TABLE, XML_COVERED_TABLE_CELL, sal_True, sal_True);
                }
				nEmptyCellColSpan = 0;
			}
        }
        else
        { // empty rows
            nEmptyCellColSpan = aRowIter->second.size();
            if ( nEmptyCellColSpan )
            {
                {
                    AddAttribute( XML_NAMESPACE_TABLE,XML_NUMBER_COLUMNS_SPANNED,implConvertNumber(nEmptyCellColSpan) );
                    SvXMLElementExport aCell(*this,XML_NAMESPACE_TABLE, XML_TABLE_CELL, sal_True, sal_True);
                    if ( !bShapeHandled )
                    {
                        bShapeHandled = true;
                        exportShapes(_xSection);
                    }
                }
                for (sal_Int32 k = 1; k < nEmptyCellColSpan; ++k)
                {
                    SvXMLElementExport aCoveredCell(*this,XML_NAMESPACE_TABLE, XML_COVERED_TABLE_CELL, sal_True, sal_True);
                }
                nEmptyCellColSpan = 0;
            }
        }
    }
}
// -----------------------------------------------------------------------------
::rtl::OUString ORptExport::convertFormula(const ::rtl::OUString& _sFormula)
{
    ::rtl::OUString sFormula = _sFormula;
    if ( _sFormula.equalsAsciiL("rpt:",4) )
        sFormula = ::rtl::OUString();
    //sal_Int32 nLength = _sFormula.getLength();
    //if ( nLength )
    //{
    //    sal_Int32 nPos = 0;
    //    if ( _sFormula.matchAsciiL("=",1) != 0 )
    //    {
    //        nPos = 1;
    //        --nLength;
    //    }
    //    bool bFormula = _sFormula.indexOf('[') != -1 || _sFormula.indexOf('(') != -1;
    //    if ( bFormula )
    //        sFormula = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("rpt:")) + _sFormula.copy(nPos,nLength);
    //    else
    //        sFormula = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("field:[")) + _sFormula.copy(nPos,nLength) + ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("]"));;
    //}
    return sFormula;
}
// -----------------------------------------------------------------------------
bool ORptExport::exportFormula(enum ::xmloff::token::XMLTokenEnum eName,const ::rtl::OUString& _sFormula)
{
    const ::rtl::OUString sFieldData = convertFormula(_sFormula);
    static const ::rtl::OUString s_sPageNumber(RTL_CONSTASCII_USTRINGPARAM("PageNumber()"));
    static const ::rtl::OUString s_sPageCount(RTL_CONSTASCII_USTRINGPARAM("PageCount()"));
    sal_Int32 nPageNumberIndex = sFieldData.indexOf(s_sPageNumber);
    sal_Int32 nPageCountIndex = sFieldData.indexOf(s_sPageCount);
    bool bRet = nPageNumberIndex != -1 || nPageCountIndex != -1;
    if ( !bRet )
        AddAttribute(XML_NAMESPACE_REPORT, eName,sFieldData);

    return bRet;
}
// -----------------------------------------------------------------------------
void ORptExport::exportStyleName(XPropertySet* _xProp,SvXMLAttributeList& _rAtt,const ::rtl::OUString& _sName)
{
	Reference<XPropertySet> xFind(_xProp);
	TPropertyStyleMap::iterator aFind = m_aAutoStyleNames.find(xFind);
	if ( aFind != m_aAutoStyleNames.end() )
	{
		_rAtt.AddAttribute( _sName,
							aFind->second );
        m_aAutoStyleNames.erase(aFind);
	}
}
// -----------------------------------------------------------------------------
sal_Bool ORptExport::exportGroup(const Reference<XReportDefinition>& _xReportDefinition,sal_Int32 _nPos,sal_Bool _bExportAutoStyle)
{
    sal_Bool bGroupExported = sal_False;
	if ( _xReportDefinition.is() )
	{
		Reference< XGroups > xGroups = _xReportDefinition->getGroups();
		if ( xGroups.is() )
		{
			sal_Int32 nCount = xGroups->getCount();
			if ( _nPos >= 0 && _nPos < nCount )
			{
                bGroupExported = sal_True;
				Reference<XGroup> xGroup(xGroups->getByIndex(_nPos),uno::UNO_QUERY);
				OSL_ENSURE(xGroup.is(),"No Group prepare for GPF");
				if ( _bExportAutoStyle )
				{
					if ( xGroup->getHeaderOn() )
						exportSectionAutoStyle(xGroup->getHeader());
                    exportGroup(_xReportDefinition,_nPos+1,_bExportAutoStyle);
					if ( xGroup->getFooterOn() )
						exportSectionAutoStyle(xGroup->getFooter());
				}
				else
				{
					if ( xGroup->getSortAscending() )
						AddAttribute(XML_NAMESPACE_REPORT, XML_SORT_ASCENDING, XML_TRUE );

					if ( xGroup->getStartNewColumn() )
						AddAttribute(XML_NAMESPACE_REPORT, XML_START_NEW_COLUMN, XML_TRUE);
					if ( xGroup->getResetPageNumber() )
						AddAttribute(XML_NAMESPACE_REPORT, XML_RESET_PAGE_NUMBER, XML_TRUE );

                    ::rtl::OUString sExpression = xGroup->getExpression();
                    if ( sExpression.getLength() )
                    {
                        static ::rtl::OUString s_sQuote(RTL_CONSTASCII_USTRINGPARAM("\"\""));
                        sal_Int32 nIndex = sExpression.indexOf('"');
                        while ( nIndex > -1 )
                        {
                            sExpression = sExpression.replaceAt(nIndex,1,s_sQuote);
                            nIndex = sExpression.indexOf('"',nIndex+2);
                        }
                        ::rtl::OUString sFormula(RTL_CONSTASCII_USTRINGPARAM("rpt:HASCHANGED(\""));

                        TGroupFunctionMap::iterator aGroupFind = m_aGroupFunctionMap.find(xGroup);
                        if ( aGroupFind != m_aGroupFunctionMap.end() )
                            sExpression = aGroupFind->second->getName();
                        sFormula += sExpression;
                        sFormula += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("\")"));
                        sExpression = sFormula;
                    }
					AddAttribute(XML_NAMESPACE_REPORT, XML_GROUP_EXPRESSION,sExpression);
					sal_Int16 nRet = xGroup->getKeepTogether();
                    ::rtl::OUStringBuffer sValue;
					const SvXMLEnumMapEntry* aXML_KeepTogetherEnumMap = OXMLHelper::GetKeepTogetherOptions();
					if ( SvXMLUnitConverter::convertEnum( sValue, nRet,aXML_KeepTogetherEnumMap ) )
						AddAttribute(XML_NAMESPACE_REPORT, XML_KEEP_TOGETHER,sValue.makeStringAndClear());

					SvXMLElementExport aGroup(*this,XML_NAMESPACE_REPORT, XML_GROUP, sal_True, sal_True);
                    exportFunctions(xGroup->getFunctions().get());
					if ( xGroup->getHeaderOn() )
					{
                        Reference<XSection> xSection = xGroup->getHeader();
                        if ( xSection->getRepeatSection() )
		                    AddAttribute(XML_NAMESPACE_REPORT, XML_REPEAT_SECTION,XML_TRUE );
						SvXMLElementExport aGroupSection(*this,XML_NAMESPACE_REPORT, XML_GROUP_HEADER, sal_True, sal_True);
						exportSection(xSection);
					}
                    exportGroup(_xReportDefinition,_nPos+1,_bExportAutoStyle);
					if ( xGroup->getFooterOn() )
					{
                        Reference<XSection> xSection = xGroup->getFooter();
                        if ( xSection->getRepeatSection() )
		                    AddAttribute(XML_NAMESPACE_REPORT, XML_REPEAT_SECTION,XML_TRUE );
						SvXMLElementExport aGroupSection(*this,XML_NAMESPACE_REPORT, XML_GROUP_FOOTER, sal_True, sal_True);
						exportSection(xSection);
					} // if ( xGroup->getFooterOn() )
				}
			}
            else if ( _bExportAutoStyle )
            {
                exportSectionAutoStyle(_xReportDefinition->getDetail());
            }
            else
            {
			    SvXMLElementExport aGroupSection(*this,XML_NAMESPACE_REPORT, XML_DETAIL, sal_True, sal_True);
			    exportSection(_xReportDefinition->getDetail());
		    }
		}
	}
    return bGroupExported;
}
// -----------------------------------------------------------------------------
void ORptExport::exportAutoStyle(XPropertySet* _xProp,const Reference<XFormattedField>& _xParentFormattedField)
{
    const uno::Reference<report::XReportControlFormat> xFormat(_xProp,uno::UNO_QUERY);
	if ( xFormat.is() )
    {
        try
        {
			const awt::FontDescriptor aFont = xFormat->getFontDescriptor();
            OSL_ENSURE(aFont.Name.getLength(),"No Font Name !");
			GetFontAutoStylePool()->Add(aFont.Name,aFont.StyleName,aFont.Family,aFont.Pitch,aFont.CharSet );
        }
        catch(beans::UnknownPropertyException&)
        {
            // not interested in
        }
	}
    const uno::Reference< report::XShape> xShape(_xProp,uno::UNO_QUERY);
    if ( xShape.is() )
    {
        ::std::vector< XMLPropertyState > aPropertyStates( m_xParaPropMapper->Filter(_xProp) );
        if ( !aPropertyStates.empty() )
		    m_aAutoStyleNames.insert( TPropertyStyleMap::value_type(_xProp,GetAutoStylePool()->Add( XML_STYLE_FAMILY_TEXT_PARAGRAPH, aPropertyStates )));
    }
    ::std::vector< XMLPropertyState > aPropertyStates( m_xCellStylesExportPropertySetMapper->Filter(_xProp) );
    Reference<XFixedLine> xFixedLine(_xProp,uno::UNO_QUERY);
    if ( xFixedLine.is() )
    {
        uno::Reference<beans::XPropertySet> xBorderProp = OXMLHelper::createBorderPropertySet();
        table::BorderLine aValue;
        aValue.Color = COL_BLACK;
        aValue.InnerLineWidth = aValue.LineDistance = 0;
        aValue.OuterLineWidth = 2;

        awt::Point aPos = xFixedLine->getPosition();
        awt::Size aSize = xFixedLine->getSize();
        sal_Int32 nSectionHeight = xFixedLine->getSection()->getHeight();

        ::rtl::OUString sBorderProp;
        ::std::vector< ::rtl::OUString> aProps;
        if ( xFixedLine->getOrientation() == 1 ) // vertical
        {
            // check if border should be left
            if ( !aPos.X )
            {
                sBorderProp = PROPERTY_BORDERLEFT;
                aProps.push_back(PROPERTY_BORDERRIGHT);
            }
            else
            {
                sBorderProp = PROPERTY_BORDERRIGHT;
                aProps.push_back(PROPERTY_BORDERLEFT);
            }
            aProps.push_back(PROPERTY_BORDERTOP);
            aProps.push_back(PROPERTY_BORDERBOTTOM);
        }
        else // horizontal
        {
            // check if border should be bottom
            if ( (aPos.Y + aSize.Height) == nSectionHeight )
            {
                sBorderProp = PROPERTY_BORDERBOTTOM;
                aProps.push_back(PROPERTY_BORDERTOP);
            }
            else
            {
                sBorderProp = PROPERTY_BORDERTOP;
                aProps.push_back(PROPERTY_BORDERBOTTOM);
            }
            aProps.push_back(PROPERTY_BORDERRIGHT);
            aProps.push_back(PROPERTY_BORDERLEFT);
        }

        xBorderProp->setPropertyValue(sBorderProp,uno::makeAny(aValue));

        aValue.Color = aValue.OuterLineWidth = 0;
        uno::Any aEmpty;
        aEmpty <<= aValue;
        ::std::for_each(aProps.begin(),aProps.end(),
            ::boost::bind(&beans::XPropertySet::setPropertyValue,xBorderProp,_1,aEmpty));

        ::std::vector< XMLPropertyState > aBorderStates(m_xCellStylesExportPropertySetMapper->Filter(xBorderProp));
        ::std::copy(aBorderStates.begin(),aBorderStates.end(),::std::back_inserter(aPropertyStates));
    }
    else
    {
        //sal_Int32 nTextAlignIndex = m_xCellStylesExportPropertySetMapper->getPropertySetMapper()->FindEntryIndex( CTF_SD_SHAPE_PARA_ADJUST );
        //if ( nTextAlignIndex != -1 )
        //{
        //    ::std::vector< XMLPropertyState >::iterator aIter = aPropertyStates.begin();
        //    ::std::vector< XMLPropertyState >::iterator aEnd = aPropertyStates.end();
        //    for (; aIter != aEnd; ++aIter)
        //    {
        //        if ( aIter->mnIndex == nTextAlignIndex )
        //        {
        //            sal_Int16 nTextAlign = 0;
        //            aIter->maValue >>= nTextAlign;
        //            switch(nTextAlign)
        //            {
        //                case awt::TextAlign::LEFT:
        //                    nTextAlign = style::ParagraphAdjust_LEFT;
        //                    break;
        //                case awt::TextAlign::CENTER:
        //                    nTextAlign = style::ParagraphAdjust_CENTER;
        //                    break;
        //                case awt::TextAlign::RIGHT:
        //                    nTextAlign = style::ParagraphAdjust_RIGHT;
        //                    break;
        //                default:
        //                    OSL_ENSURE(0,"Illegal text alignment value!");
        //                    break;
        //            }
        //            aIter->maValue <<= nTextAlign;
        //            break;
        //        }
        //    }
        //}
        const Reference<XFormattedField> xFormattedField(_xProp,uno::UNO_QUERY);
        if ( (_xParentFormattedField.is() || xFormattedField.is()) && !aPropertyStates.empty() )
        {
            sal_Int32 nNumberFormat = 0;
            if ( _xParentFormattedField.is() )
                nNumberFormat = _xParentFormattedField->getFormatKey();
            else
                nNumberFormat = xFormattedField->getFormatKey();
            {
                sal_Int32 nStyleMapIndex = m_xCellStylesExportPropertySetMapper->getPropertySetMapper()->FindEntryIndex( CTF_RPT_NUMBERFORMAT );
                addDataStyle(nNumberFormat);
                XMLPropertyState aNumberStyleState( nStyleMapIndex, uno::makeAny( getDataStyleName(nNumberFormat) ) );
                aPropertyStates.push_back( aNumberStyleState );
            }
        }
    }


	if ( !aPropertyStates.empty() )
		m_aAutoStyleNames.insert( TPropertyStyleMap::value_type(_xProp,GetAutoStylePool()->Add( XML_STYLE_FAMILY_TABLE_CELL, aPropertyStates )));
}
// -----------------------------------------------------------------------------
void ORptExport::exportAutoStyle(const Reference<XSection>& _xProp)
{
	::std::vector< XMLPropertyState > aPropertyStates( m_xTableStylesExportPropertySetMapper->Filter(_xProp.get()) );
	if ( !aPropertyStates.empty() )
		m_aAutoStyleNames.insert( TPropertyStyleMap::value_type(_xProp.get(),GetAutoStylePool()->Add( XML_STYLE_FAMILY_TABLE_TABLE, aPropertyStates )));
}
// -----------------------------------------------------------------------------
void ORptExport::SetBodyAttributes()
{
    Reference<XReportDefinition> xProp(getReportDefinition());
    exportReportAttributes(xProp);
}
// -----------------------------------------------------------------------------
void ORptExport::exportReportAttributes(const Reference<XReportDefinition>& _xReport)
{
	if ( _xReport.is() )
	{
        ::rtl::OUStringBuffer sValue;
		const SvXMLEnumMapEntry* aXML_CommnadTypeEnumMap = OXMLHelper::GetCommandTypeOptions();
		if ( SvXMLUnitConverter::convertEnum( sValue, static_cast<sal_uInt16>(_xReport->getCommandType()),aXML_CommnadTypeEnumMap ) )
			AddAttribute(XML_NAMESPACE_REPORT, XML_COMMAND_TYPE,sValue.makeStringAndClear());

        ::rtl::OUString sComamnd = _xReport->getCommand();
        if ( sComamnd.getLength() )
		    AddAttribute(XML_NAMESPACE_REPORT, XML_COMMAND, sComamnd);

        ::rtl::OUString sFilter( _xReport->getFilter() );
        if ( sFilter.getLength() )
		    AddAttribute( XML_NAMESPACE_REPORT, XML_FILTER, sFilter );

        AddAttribute(XML_NAMESPACE_OFFICE, XML_MIMETYPE,_xReport->getMimeType());

        sal_Bool bEscapeProcessing( _xReport->getEscapeProcessing() );
        if ( !bEscapeProcessing )
			AddAttribute( XML_NAMESPACE_REPORT, XML_ESCAPE_PROCESSING, ::xmloff::token::GetXMLToken( XML_FALSE ) );

        ::rtl::OUString sName = _xReport->getCaption();
        if ( sName.getLength() )
            AddAttribute(XML_NAMESPACE_OFFICE, XML_CAPTION,sName);
        sName = _xReport->getName();
        if ( sName.getLength() )
            AddAttribute(XML_NAMESPACE_DRAW, XML_NAME,sName);
	}
}
// -----------------------------------------------------------------------------
void ORptExport::_ExportContent()
{
	exportReport(getReportDefinition());
}
// -----------------------------------------------------------------------------
void ORptExport::_ExportMasterStyles()
{
	GetPageExport()->exportMasterStyles( sal_True );
}
// -----------------------------------------------------------------------------
void ORptExport::collectComponentStyles()
{
	if ( m_bAllreadyFilled )
		return;

	m_bAllreadyFilled = sal_True;
	Reference<XReportDefinition> xProp(getReportDefinition());
	if ( xProp.is() )
	{
		uno::Reference< report::XSection> xParent(xProp->getParent(),uno::UNO_QUERY);
		if ( xParent.is() )
			exportAutoStyle(xProp.get());

		if ( xProp->getReportHeaderOn() )
			exportSectionAutoStyle(xProp->getReportHeader());
		if ( xProp->getPageHeaderOn() )
			exportSectionAutoStyle(xProp->getPageHeader());

        exportGroup(xProp,0,sal_True);

		if ( xProp->getPageFooterOn() )
			exportSectionAutoStyle(xProp->getPageFooter());
		if ( xProp->getReportFooterOn() )
			exportSectionAutoStyle(xProp->getReportFooter());
	}
}
// -----------------------------------------------------------------------------
void ORptExport::_ExportAutoStyles()
{
	// there are no styles that require their own autostyles
	if ( getExportFlags() & EXPORT_CONTENT )
	{
		collectComponentStyles();
        GetAutoStylePool()->exportXML(XML_STYLE_FAMILY_TABLE_TABLE
										,GetDocHandler()
										,GetMM100UnitConverter()
										,GetNamespaceMap()
        );
        GetAutoStylePool()->exportXML(XML_STYLE_FAMILY_TABLE_COLUMN
										,GetDocHandler()
										,GetMM100UnitConverter()
										,GetNamespaceMap()
        );
        GetAutoStylePool()->exportXML(XML_STYLE_FAMILY_TABLE_ROW
										,GetDocHandler()
										,GetMM100UnitConverter()
										,GetNamespaceMap()
        );

        GetAutoStylePool()->exportXML(XML_STYLE_FAMILY_TABLE_CELL
										,GetDocHandler()
										,GetMM100UnitConverter()
										,GetNamespaceMap()
        );


		/*GetAutoStylePool()->exportXML(XML_STYLE_FAMILY_REPORT_ID
										,GetDocHandler()
										,GetMM100UnitConverter()
										,GetNamespaceMap()
        );*/
		exportDataStyles();
        GetShapeExport()->exportAutoStyles();
	}
    // exported in _ExportMasterStyles
	if( (getExportFlags() & EXPORT_MASTERSTYLES) != 0 )
		GetPageExport()->collectAutoStyles( sal_False );
    if( (getExportFlags() & EXPORT_MASTERSTYLES) != 0 )
		GetPageExport()->exportAutoStyles();
}
// -----------------------------------------------------------------------------
void ORptExport::_ExportStyles(sal_Bool bUsed)
{
	SvXMLExport::_ExportStyles(bUsed);

    // write draw:style-name for object graphic-styles
	GetShapeExport()->ExportGraphicDefaults();
}
// -----------------------------------------------------------------------------
sal_uInt32 ORptExport::exportDoc(enum ::xmloff::token::XMLTokenEnum eClass)
{
	return SvXMLExport::exportDoc( eClass );
}
// -----------------------------------------------------------------------------
::rtl::OUString ORptExport::implConvertNumber(sal_Int32 _nValue)
{
	::rtl::OUStringBuffer aBuffer;
	GetMM100UnitConverter().convertNumber(aBuffer, _nValue);
	return aBuffer.makeStringAndClear();
}
// -----------------------------------------------------------------------------
UniReference < XMLPropertySetMapper > ORptExport::GetCellStylePropertyMapper() const
{
	return m_xCellStylesPropertySetMapper;
}
// -----------------------------------------------------------------------------
SvXMLAutoStylePoolP* ORptExport::CreateAutoStylePool()
{
	return new OXMLAutoStylePoolP(*this);
}
// -----------------------------------------------------------------------------
void SAL_CALL ORptExport::setSourceDocument( const Reference< XComponent >& xDoc ) throw(IllegalArgumentException, RuntimeException)
{
	m_xReportDefinition.set(xDoc,UNO_QUERY_THROW);
	OSL_ENSURE(m_xReportDefinition.is(),"DataSource is NULL!");

    SvXMLExport::setSourceDocument(xDoc);
}
// -----------------------------------------------------------------------------
void ORptExport::_ExportFontDecls()
{
	GetFontAutoStylePool();	// make sure the pool is created
	collectComponentStyles();
	SvXMLExport::_ExportFontDecls();
}
// -----------------------------------------------------------------------------
void ORptExport::exportParagraph(const Reference< XReportControlModel >& _xReportElement)
{
    OSL_PRECOND(_xReportElement.is(),"Element is null!");
    // start <text:p>
    SvXMLElementExport aParagraphContent(*this,XML_NAMESPACE_TEXT, XML_P, sal_False, sal_False);
    if ( Reference<XFormattedField>(_xReportElement,uno::UNO_QUERY).is() )
    {
        ::rtl::OUString sFieldData = _xReportElement->getDataField();
        static const ::rtl::OUString s_sPageNumber(RTL_CONSTASCII_USTRINGPARAM("PageNumber()"));
        static const ::rtl::OUString s_sPageCount(RTL_CONSTASCII_USTRINGPARAM("PageCount()"));
        static const ::rtl::OUString s_sReportPrefix(RTL_CONSTASCII_USTRINGPARAM("rpt:"));
        static const ::rtl::OUString s_sConcatOperator(RTL_CONSTASCII_USTRINGPARAM("&"));
        sFieldData = sFieldData.copy(s_sReportPrefix.getLength(),sFieldData.getLength() - s_sReportPrefix.getLength());
        sal_Int32 nPageNumberIndex = sFieldData.indexOf(s_sPageNumber);
        if ( nPageNumberIndex != -1 )
        {
            sal_Int32 nIndex = 0;
            do
            {
                ::rtl::OUString sToken = sFieldData.getToken( 0, '&', nIndex );
                sToken = sToken.trim();
                if ( sToken.getLength() )
                {
                    if ( sToken == s_sPageNumber )
                    {
                        static const ::rtl::OUString s_sCurrent(RTL_CONSTASCII_USTRINGPARAM("current"));
                        AddAttribute(XML_NAMESPACE_TEXT, XML_SELECT_PAGE, s_sCurrent );
                        SvXMLElementExport aPageNumber(*this,XML_NAMESPACE_TEXT, XML_PAGE_NUMBER, sal_False, sal_False);
                        Characters(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("1")));
                    }
                    else if ( sToken == s_sPageCount )
                    {
                        SvXMLElementExport aPageNumber(*this,XML_NAMESPACE_TEXT, XML_PAGE_COUNT, sal_False, sal_False);
                        Characters(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("1")));
                    }
                    else
                    {

                        if ( sToken.indexOf('"') == 0 && sToken.lastIndexOf('"') == sToken.getLength()-1 )
                            sToken = sToken.copy(1,sToken.getLength()-2);

                        sal_Bool bPrevCharIsSpace = sal_False;
                        GetTextParagraphExport()->exportText(sToken,bPrevCharIsSpace);
                    }
                }
            }
            while ( nIndex >= 0 );
        }
    }
    Reference< XFixedText > xFT(_xReportElement,UNO_QUERY);
    if ( xFT.is() )
    {
        ::rtl::OUString sExpr = xFT->getLabel();
        sal_Bool bPrevCharIsSpace = sal_False;
        GetTextParagraphExport()->exportText(sExpr,bPrevCharIsSpace);
    }
}
// -----------------------------------------------------------------------------
XMLShapeExport* ORptExport::CreateShapeExport()
{
	XMLShapeExport* pShapeExport = new XMLShapeExport( *this, XMLTextParagraphExport::CreateShapeExtPropMapper( *this ) );
	return pShapeExport;
}
// -----------------------------------------------------------------------------
void ORptExport::exportShapes(const Reference< XSection>& _xSection,bool _bAddParagraph)
{
    UniReference< XMLShapeExport > xShapeExport = GetShapeExport();
    xShapeExport->seekShapes(_xSection.get());
    const sal_Int32 nCount = _xSection->getCount();
    ::std::auto_ptr<SvXMLElementExport> pParagraphContent;
    if ( _bAddParagraph )
        pParagraphContent.reset(new SvXMLElementExport(*this,XML_NAMESPACE_TEXT, XML_P, sal_True, sal_False));

    awt::Point aRefPoint;
    aRefPoint.X = rptui::getStyleProperty<sal_Int32>(_xSection->getReportDefinition(),PROPERTY_LEFTMARGIN);
    for (sal_Int32 i = 0; i < nCount; ++i)
    {
        uno::Reference< XShape > xShape(_xSection->getByIndex(i),uno::UNO_QUERY);
        if ( xShape.is() )
        {
            ::std::auto_ptr<SvXMLElementExport> pSubDocument;
            uno::Reference< frame::XModel> xModel(xShape->getPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Model"))),uno::UNO_QUERY);
            if ( xModel.is() ) // special handling for chart object
            {
                pSubDocument.reset(new SvXMLElementExport(*this,XML_NAMESPACE_REPORT, XML_SUB_DOCUMENT, sal_False, sal_False));
                exportMasterDetailFields(xShape.get());
                exportReportElement(xShape.get());
            }

            AddAttribute( XML_NAMESPACE_TEXT, XML_ANCHOR_TYPE, XML_PARAGRAPH );
            xShapeExport->exportShape(xShape.get(),SEF_DEFAULT|SEF_EXPORT_NO_WS,&aRefPoint);
        }
    }
}
// -----------------------------------------------------------------------------
void ORptExport::exportGroupsExpressionAsFunction(const Reference< XGroups>& _xGroups)
{
    if ( _xGroups.is() )
	{
        uno::Reference< XFunctions> xFunctions = _xGroups->getReportDefinition()->getFunctions();
		const sal_Int32 nCount = _xGroups->getCount();
        for (sal_Int32 i = 0; i < nCount; ++i)
        {
            uno::Reference< XGroup> xGroup(_xGroups->getByIndex(i),uno::UNO_QUERY_THROW);
            const ::sal_Int16 nGroupOn = xGroup->getGroupOn();
            if ( nGroupOn != report::GroupOn::DEFAULT )
            {
                uno::Reference< XFunction> xFunction = xFunctions->createFunction();
                ::rtl::OUString sFunction,sPrefix,sPostfix;
                ::rtl::OUString sExpression = xGroup->getExpression();
                ::rtl::OUString sFunctionName;
                switch(nGroupOn)
	            {
		            case report::GroupOn::PREFIX_CHARACTERS:
			            sFunction = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("LEFT"));
                        sPrefix = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(";")) + ::rtl::OUString::valueOf(xGroup->getGroupInterval());
			            break;
		            case report::GroupOn::YEAR:
                        sFunction = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("YEAR"));
			            break;
		            case report::GroupOn::QUARTAL:
			            sFunction   = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("INT((MONTH"));
                        sPostfix    = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("-1)/3)+1"));
                        sFunctionName = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("QUARTAL_")) + sExpression;
			            break;
		            case report::GroupOn::MONTH:
			            sFunction = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("MONTH"));
			            break;
		            case report::GroupOn::WEEK:
			            sFunction = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("WEEK"));
			            break;
		            case report::GroupOn::DAY:
			            sFunction = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DAY"));
			            break;
		            case report::GroupOn::HOUR:
			            sFunction = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("HOUR"));
			            break;
		            case report::GroupOn::MINUTE:
			            sFunction = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("MINUTE"));
			            break;
		            case report::GroupOn::INTERVAL:
                        {
                            sFunction = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("INT"));
                            uno::Reference< XFunction> xCountFunction = xFunctions->createFunction();
                            xCountFunction->setInitialFormula(beans::Optional< ::rtl::OUString>(sal_True,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("rpt:1"))));
                            ::rtl::OUString sCountName = sFunction + ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("_count_")) + sExpression;
                            xCountFunction->setName(sCountName);
                            xCountFunction->setFormula(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("rpt:[")) + sCountName + ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("] + 1")));
                            exportFunction(xCountFunction);
                            sExpression = sCountName;
                            sPrefix = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" / ")) + ::rtl::OUString::valueOf(xGroup->getGroupInterval());
                            sFunctionName = sFunction + ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("_")) + sExpression;
                        }
			            break;
		            default:
                        ;
	            }
                if ( !sFunctionName.getLength() )
                    sFunctionName = sFunction + ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("_")) + sExpression;
                if ( sFunction.getLength() )
                {
                    sal_Unicode pReplaceChars[] = { '(',')',';',',','+','-','[',']','/','*'};
                    for(sal_uInt32 j= 0; j < sizeof(pReplaceChars)/sizeof(pReplaceChars[0]);++j)
                        sFunctionName = sFunctionName.replace(pReplaceChars[j],'_');

                    xFunction->setName(sFunctionName);
                    sFunction = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("rpt:")) + sFunction;
                    sFunction += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("(["));
                    sFunction += sExpression;
                    sFunction += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("]"));

                    if ( sPrefix.getLength() )
                        sFunction += sPrefix;
                    sFunction += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(")"));
                    if ( sPostfix.getLength() )
                        sFunction += sPostfix;
                    xFunction->setFormula(sFunction);
                    exportFunction(xFunction);
                    m_aGroupFunctionMap.insert(TGroupFunctionMap::value_type(xGroup,xFunction));
                }
            }
        }
    }
}

// -----------------------------------------------------------------------------
}// rptxml
// -----------------------------------------------------------------------------