main/xmloff/source/style/numehelp.cxx - openoffice - Git at Google

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

 #include <xmloff/nmspmap.hxx>
 #include "xmloff/xmlnmspe.hxx"
 #include <xmloff/xmluconv.hxx>
 #include <xmloff/xmltoken.hxx>
 #include <xmloff/xmlexp.hxx>
 #include <com/sun/star/uno/Reference.h>
 #include <rtl/ustring.hxx>
 #include <svl/zforlist.hxx>
 #include <com/sun/star/util/NumberFormat.hpp>
 #include <rtl/math.hxx>
 #include <tools/debug.hxx>
 #include <rtl/ustrbuf.hxx>

 using namespace com::sun::star;
 using namespace xmloff::token;

 #define XML_TYPE "Type"
 #define XML_CURRENCYSYMBOL "CurrencySymbol"
 #define XML_CURRENCYABBREVIATION "CurrencyAbbreviation"
 #define XML_STANDARDFORMAT "StandardFormat"

 XMLNumberFormatAttributesExportHelper::XMLNumberFormatAttributesExportHelper(
 			::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormatsSupplier >& xTempNumberFormatsSupplier)
 	: xNumberFormats(xTempNumberFormatsSupplier.is() ? xTempNumberFormatsSupplier->getNumberFormats() : ::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormats > ()),
 	pExport(NULL),
     sStandardFormat(RTL_CONSTASCII_USTRINGPARAM(XML_STANDARDFORMAT)),
     sType(RTL_CONSTASCII_USTRINGPARAM(XML_TYPE)),
     msCurrencySymbol(RTL_CONSTASCII_USTRINGPARAM(XML_CURRENCYSYMBOL)),
     msCurrencyAbbreviation(RTL_CONSTASCII_USTRINGPARAM(XML_CURRENCYABBREVIATION)),
 	aNumberFormats()
 {
 }

 XMLNumberFormatAttributesExportHelper::XMLNumberFormatAttributesExportHelper(
             ::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormatsSupplier >& xTempNumberFormatsSupplier,
             SvXMLExport& rTempExport )
 :	xNumberFormats(xTempNumberFormatsSupplier.is() ? xTempNumberFormatsSupplier->getNumberFormats() : ::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormats > ()),
 	pExport(&rTempExport),
     sStandardFormat(RTL_CONSTASCII_USTRINGPARAM(XML_STANDARDFORMAT)),
     sType(RTL_CONSTASCII_USTRINGPARAM(XML_TYPE)),
     sAttrValueType(rTempExport.GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_VALUE_TYPE))),
     sAttrValue(rTempExport.GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_VALUE))),
 	sAttrDateValue(rTempExport.GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_DATE_VALUE))),
     sAttrTimeValue(rTempExport.GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_TIME_VALUE))),
 	sAttrBooleanValue(rTempExport.GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_BOOLEAN_VALUE))),
     sAttrStringValue(rTempExport.GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_STRING_VALUE))),
 	sAttrCurrency(rTempExport.GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_CURRENCY))),
     msCurrencySymbol(RTL_CONSTASCII_USTRINGPARAM(XML_CURRENCYSYMBOL)),
     msCurrencyAbbreviation(RTL_CONSTASCII_USTRINGPARAM(XML_CURRENCYABBREVIATION)),
     aNumberFormats()
 {
 }

 XMLNumberFormatAttributesExportHelper::~XMLNumberFormatAttributesExportHelper()
 {
 }

 sal_Int16 XMLNumberFormatAttributesExportHelper::GetCellType(const sal_Int32 nNumberFormat, rtl::OUString& sCurrency, sal_Bool& bIsStandard)
 {
 	XMLNumberFormat aFormat(sEmpty, nNumberFormat, 0);
 	XMLNumberFormatSet::iterator aItr(aNumberFormats.find(aFormat));
     XMLNumberFormatSet::iterator aEndItr(aNumberFormats.end());
 	if (aItr != aEndItr)
 	{
 		bIsStandard = aItr->bIsStandard;
 		sCurrency = aItr->sCurrency;
 		return aItr->nType;
 	}
 	else
 	{
 		aFormat.nType = GetCellType(nNumberFormat, bIsStandard);
 		aFormat.bIsStandard = bIsStandard;
         if ((aFormat.nType & ~util::NumberFormat::DEFINED) == util::NumberFormat::CURRENCY)
 			if (GetCurrencySymbol(nNumberFormat, aFormat.sCurrency))
 				sCurrency = aFormat.sCurrency;
 		aNumberFormats.insert(aFormat);
 		return aFormat.nType;
 	}
 }

 void XMLNumberFormatAttributesExportHelper::WriteAttributes(SvXMLExport& rXMLExport,
 								const sal_Int16 nTypeKey,
 								const double& rValue,
 								const rtl::OUString& rCurrency,
 								sal_Bool bExportValue)
 {
 	sal_Bool bWasSetTypeAttribute = sal_False;
 	switch(nTypeKey & ~util::NumberFormat::DEFINED)
 	{
 	case 0:
 	case util::NumberFormat::NUMBER:
 	case util::NumberFormat::SCIENTIFIC:
 	case util::NumberFormat::FRACTION:
 		{
 			if (!bWasSetTypeAttribute)
 			{
 				rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_FLOAT);
 				bWasSetTypeAttribute = sal_True;
 			}
 		}		// No Break
 	case util::NumberFormat::PERCENT:
 		{
 			if (!bWasSetTypeAttribute)
 			{
 				rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_PERCENTAGE);
 				bWasSetTypeAttribute = sal_True;
 			}
 		}		// No Break
 	case util::NumberFormat::CURRENCY:
 		{
 			if (!bWasSetTypeAttribute)
 			{
 				rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_CURRENCY);
 				if (rCurrency.getLength() > 0)
 					rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_CURRENCY, rCurrency);
 				bWasSetTypeAttribute = sal_True;
 			}

 			if (bExportValue)
 			{
                 rtl::OUString sValue( ::rtl::math::doubleToUString( rValue,
                             rtl_math_StringFormat_Automatic,
                             rtl_math_DecimalPlaces_Max, '.', sal_True));
 				rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE, sValue);
 			}
 		}
 		break;
 	case util::NumberFormat::DATE:
 	case util::NumberFormat::DATETIME:
 		{
 			if (!bWasSetTypeAttribute)
 			{
 				rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_DATE);
 				bWasSetTypeAttribute = sal_True;
 			}
 			if (bExportValue)
 			{
                 if ( rXMLExport.SetNullDateOnUnitConverter() )
 				{
 					rtl::OUStringBuffer sBuffer;
 					rXMLExport.GetMM100UnitConverter().convertDateTime(sBuffer, rValue);
 					rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_DATE_VALUE, sBuffer.makeStringAndClear());
 				}
 			}
 		}
 		break;
 	case util::NumberFormat::TIME:
 		{
 			if (!bWasSetTypeAttribute)
 			{
 				rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_TIME);
 				bWasSetTypeAttribute = sal_True;
 			}
 			if (bExportValue)
 			{
 				rtl::OUStringBuffer sBuffer;
 				rXMLExport.GetMM100UnitConverter().convertTime(sBuffer, rValue);
 				rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_TIME_VALUE, sBuffer.makeStringAndClear());
 			}
 		}
 		break;
 	case util::NumberFormat::LOGICAL:
 		{
 			if (!bWasSetTypeAttribute)
 			{
 				rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_BOOLEAN);
 				bWasSetTypeAttribute = sal_True;
 			}
 			if (bExportValue)
 			{
 				double fTempValue = rValue;
 				if (::rtl::math::approxEqual( fTempValue, 1.0 ))
 				{
 					rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_BOOLEAN_VALUE, XML_TRUE);
 				}
 				else
 				{
 					if (::rtl::math::approxEqual( rValue, 0.0 ))
 					{
 						rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_BOOLEAN_VALUE, XML_FALSE);
 					}
 					else
 					{
                         rtl::OUString sValue( ::rtl::math::doubleToUString(
                                     fTempValue,
                                     rtl_math_StringFormat_Automatic,
                                     rtl_math_DecimalPlaces_Max, '.',
                                     sal_True));
 						rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_BOOLEAN_VALUE, sValue);
 					}
 				}
 			}
 		}
 		break;
 	case util::NumberFormat::TEXT:
 		{
 			if (!bWasSetTypeAttribute)
 			{
 				rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_FLOAT);
 				bWasSetTypeAttribute = sal_True;
 				if (bExportValue)
 				{
                     rtl::OUString sValue( ::rtl::math::doubleToUString( rValue,
                                 rtl_math_StringFormat_Automatic,
                                 rtl_math_DecimalPlaces_Max, '.', sal_True));
 					rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE, sValue);
 				}
 			}
 		}
 		break;
 	}
 }

 sal_Bool XMLNumberFormatAttributesExportHelper::GetCurrencySymbol(const sal_Int32 nNumberFormat, rtl::OUString& sCurrencySymbol,
 	uno::Reference <util::XNumberFormatsSupplier>& xNumberFormatsSupplier)
 {
 	if (xNumberFormatsSupplier.is())
 	{
 		uno::Reference <util::XNumberFormats> xNumberFormats(xNumberFormatsSupplier->getNumberFormats());
 		if (xNumberFormats.is())
 		{
 			try
 			{
 				uno::Reference <beans::XPropertySet> xNumberPropertySet(xNumberFormats->getByKey(nNumberFormat));
 				if ( xNumberPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_CURRENCYSYMBOL))) >>= sCurrencySymbol)
 				{
 					rtl::OUString sCurrencyAbbreviation;
 					if ( xNumberPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_CURRENCYABBREVIATION))) >>= sCurrencyAbbreviation)
 					{
 						if ( sCurrencyAbbreviation.getLength() != 0 )
 							sCurrencySymbol = sCurrencyAbbreviation;
 						else
 						{
 							if ( sCurrencySymbol.getLength() == 1 && sCurrencySymbol.toChar() == NfCurrencyEntry::GetEuroSymbol() )
 								sCurrencySymbol = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("EUR"));
 						}
 					}
 					return sal_True;
 				}
 			}
 			catch ( uno::Exception& )
 			{
 				DBG_ERROR("Numberformat not found");
 			}
 		}
 	}
 	return sal_False;
 }


 sal_Int16 XMLNumberFormatAttributesExportHelper::GetCellType(const sal_Int32 nNumberFormat, sal_Bool& bIsStandard,
 	uno::Reference <util::XNumberFormatsSupplier>& xNumberFormatsSupplier)
 {
 	if (xNumberFormatsSupplier.is())
 	{
 		uno::Reference <util::XNumberFormats> xNumberFormats(xNumberFormatsSupplier->getNumberFormats());
 		if (xNumberFormats.is())
 		{
 			try
 			{
 				uno::Reference <beans::XPropertySet> xNumberPropertySet(xNumberFormats->getByKey(nNumberFormat));
 				xNumberPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STANDARDFORMAT))) >>= bIsStandard;
 				sal_Int16 nNumberType = sal_Int16();
 				if ( xNumberPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_TYPE))) >>= nNumberType )
 				{
 					return nNumberType;
 				}
 			}
 			catch ( uno::Exception& )
 			{
 				DBG_ERROR("Numberformat not found");
 			}
 		}
 	}
 	return 0;
 }

 void XMLNumberFormatAttributesExportHelper::SetNumberFormatAttributes(SvXMLExport& rXMLExport,
 	const sal_Int32 nNumberFormat, const double& rValue, sal_Bool bExportValue)
 {
 	sal_Bool bIsStandard;
 	sal_Int16 nTypeKey = GetCellType(nNumberFormat, bIsStandard, rXMLExport.GetNumberFormatsSupplier());
 	rtl::OUString sCurrency;
     if ((nTypeKey & ~util::NumberFormat::DEFINED) == util::NumberFormat::CURRENCY)
 		GetCurrencySymbol(nNumberFormat, sCurrency, rXMLExport.GetNumberFormatsSupplier());
 	WriteAttributes(rXMLExport, nTypeKey, rValue, sCurrency, bExportValue);
 }

 void XMLNumberFormatAttributesExportHelper::SetNumberFormatAttributes(SvXMLExport& rXMLExport,
 	const rtl::OUString& rValue, const rtl::OUString& rCharacters,
 	sal_Bool bExportValue, sal_Bool bExportTypeAttribute)
 {
 	if (bExportTypeAttribute)
 		rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_STRING);
 	if (bExportValue && rValue.getLength() && (rValue != rCharacters))
 		rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_STRING_VALUE, rValue);
 }

 sal_Bool XMLNumberFormatAttributesExportHelper::GetCurrencySymbol(const sal_Int32 nNumberFormat, rtl::OUString& rCurrencySymbol)
 {
     if (!xNumberFormats.is() && pExport && pExport->GetNumberFormatsSupplier().is())
 		xNumberFormats.set(pExport->GetNumberFormatsSupplier()->getNumberFormats());

     if (xNumberFormats.is())
 	{
 		try
 		{
 			uno::Reference <beans::XPropertySet> xNumberPropertySet(xNumberFormats->getByKey(nNumberFormat));
 			if ( xNumberPropertySet->getPropertyValue(msCurrencySymbol) >>= rCurrencySymbol)
 			{
 				rtl::OUString sCurrencyAbbreviation;
 				if ( xNumberPropertySet->getPropertyValue(msCurrencyAbbreviation) >>= sCurrencyAbbreviation)
 				{
 					if ( sCurrencyAbbreviation.getLength() != 0 )
 						rCurrencySymbol = sCurrencyAbbreviation;
 					else
 					{
 						if ( rCurrencySymbol.getLength() == 1 && rCurrencySymbol.toChar() == NfCurrencyEntry::GetEuroSymbol() )
 							rCurrencySymbol = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("EUR"));
 					}
 				}
 				return sal_True;
 			}
 		}
 		catch ( uno::Exception& )
 		{
 			DBG_ERROR("Numberformat not found");
 		}
 	}
 	return sal_False;
 }

 sal_Int16 XMLNumberFormatAttributesExportHelper::GetCellType(const sal_Int32 nNumberFormat, sal_Bool& bIsStandard)
 {
     if (!xNumberFormats.is() && pExport && pExport->GetNumberFormatsSupplier().is())
 		xNumberFormats.set(pExport->GetNumberFormatsSupplier()->getNumberFormats());

     if (xNumberFormats.is())
 	{
 		try
 		{
 			uno::Reference <beans::XPropertySet> xNumberPropertySet(xNumberFormats->getByKey(nNumberFormat));
             if (xNumberPropertySet.is())
             {
 			    xNumberPropertySet->getPropertyValue(sStandardFormat) >>= bIsStandard;
 			    sal_Int16 nNumberType = sal_Int16();
 			    if ( xNumberPropertySet->getPropertyValue(sType) >>= nNumberType )
 			    {
 				    return nNumberType;
 			    }
             }
 		}
 		catch ( uno::Exception& )
 		{
 			DBG_ERROR("Numberformat not found");
 		}
 	}
 	return 0;
 }

 void XMLNumberFormatAttributesExportHelper::WriteAttributes(
 								const sal_Int16 nTypeKey,
 								const double& rValue,
 								const rtl::OUString& rCurrency,
 								sal_Bool bExportValue)
 {
     if (!pExport)
         return;

 	sal_Bool bWasSetTypeAttribute = sal_False;
 	switch(nTypeKey & ~util::NumberFormat::DEFINED)
 	{
 	case 0:
 	case util::NumberFormat::NUMBER:
 	case util::NumberFormat::SCIENTIFIC:
 	case util::NumberFormat::FRACTION:
 		{
 			if (!bWasSetTypeAttribute)
 			{
 				pExport->AddAttribute(sAttrValueType, XML_FLOAT);
 				bWasSetTypeAttribute = sal_True;
 			}
 		}		// No Break
 	case util::NumberFormat::PERCENT:
 		{
 			if (!bWasSetTypeAttribute)
 			{
 				pExport->AddAttribute(sAttrValueType, XML_PERCENTAGE);
 				bWasSetTypeAttribute = sal_True;
 			}
 		}		// No Break
 	case util::NumberFormat::CURRENCY:
 		{
 			if (!bWasSetTypeAttribute)
 			{
 				pExport->AddAttribute(sAttrValueType, XML_CURRENCY);
 				if (rCurrency.getLength() > 0)
 					pExport->AddAttribute(sAttrCurrency, rCurrency);
 				bWasSetTypeAttribute = sal_True;
 			}

 			if (bExportValue)
 			{
                 rtl::OUString sValue( ::rtl::math::doubleToUString( rValue,
                             rtl_math_StringFormat_Automatic,
                             rtl_math_DecimalPlaces_Max, '.', sal_True));
 				pExport->AddAttribute(sAttrValue, sValue);
 			}
 		}
 		break;
 	case util::NumberFormat::DATE:
 	case util::NumberFormat::DATETIME:
 		{
 			if (!bWasSetTypeAttribute)
 			{
 				pExport->AddAttribute(sAttrValueType, XML_DATE);
 				bWasSetTypeAttribute = sal_True;
 			}
 			if (bExportValue)
 			{
                 if ( pExport->SetNullDateOnUnitConverter() )
 				{
 					rtl::OUStringBuffer sBuffer;
 					pExport->GetMM100UnitConverter().convertDateTime(sBuffer, rValue);
 					pExport->AddAttribute(sAttrDateValue, sBuffer.makeStringAndClear());
 				}
 			}
 		}
 		break;
 	case util::NumberFormat::TIME:
 		{
 			if (!bWasSetTypeAttribute)
 			{
 				pExport->AddAttribute(sAttrValueType, XML_TIME);
 				bWasSetTypeAttribute = sal_True;
 			}
 			if (bExportValue)
 			{
 				rtl::OUStringBuffer sBuffer;
 				pExport->GetMM100UnitConverter().convertTime(sBuffer, rValue);
 				pExport->AddAttribute(sAttrTimeValue, sBuffer.makeStringAndClear());
 			}
 		}
 		break;
 	case util::NumberFormat::LOGICAL:
 		{
 			if (!bWasSetTypeAttribute)
 			{
 				pExport->AddAttribute(sAttrValueType, XML_BOOLEAN);
 				bWasSetTypeAttribute = sal_True;
 			}
 			if (bExportValue)
 			{
 				double fTempValue = rValue;
 				if (::rtl::math::approxEqual( fTempValue, 1.0 ))
 				{
 					pExport->AddAttribute(sAttrBooleanValue, XML_TRUE);
 				}
 				else
 				{
 					if (::rtl::math::approxEqual( rValue, 0.0 ))
 					{
 						pExport->AddAttribute(sAttrBooleanValue, XML_FALSE);
 					}
 					else
 					{
                         rtl::OUString sValue( ::rtl::math::doubleToUString(
                                     fTempValue,
                                     rtl_math_StringFormat_Automatic,
                                     rtl_math_DecimalPlaces_Max, '.',
                                     sal_True));
 						pExport->AddAttribute(sAttrBooleanValue, sValue);
 					}
 				}
 			}
 		}
 		break;
 	case util::NumberFormat::TEXT:
 		{
 			if (!bWasSetTypeAttribute)
 			{
 				pExport->AddAttribute(sAttrValueType, XML_FLOAT);
 				bWasSetTypeAttribute = sal_True;
 				if (bExportValue)
 				{
                     rtl::OUString sValue( ::rtl::math::doubleToUString( rValue,
                                 rtl_math_StringFormat_Automatic,
                                 rtl_math_DecimalPlaces_Max, '.', sal_True));
 					pExport->AddAttribute(sAttrValue, sValue);
 				}
 			}
 		}
 		break;
 	}
 }

 void XMLNumberFormatAttributesExportHelper::SetNumberFormatAttributes(
 	const sal_Int32 nNumberFormat, const double& rValue, sal_Bool bExportValue)
 {
 	if (pExport)
 	{
 		sal_Bool bIsStandard;
 		rtl::OUString sCurrency;
 		sal_Int16 nTypeKey = GetCellType(nNumberFormat, sCurrency, bIsStandard);
 	    WriteAttributes(nTypeKey, rValue, sCurrency, bExportValue);
 	}
 	else {
 		DBG_ERROR("no SvXMLExport given");
     }
 }

 void XMLNumberFormatAttributesExportHelper::SetNumberFormatAttributes(
 	const rtl::OUString& rValue, const rtl::OUString& rCharacters,
 	sal_Bool bExportValue, sal_Bool bExportTypeAttribute)
 {
     if (pExport)
     {
 	    if (bExportTypeAttribute)
 		    pExport->AddAttribute(sAttrValueType, XML_STRING);
 	    if (bExportValue && rValue.getLength() && (rValue != rCharacters))
 		    pExport->AddAttribute(sAttrStringValue, rValue);
     }
 	else {
 		DBG_ERROR("no SvXMLExport given");
     }
 }
	/**************************************************************
	*
	* 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 "xmloff/numehelp.hxx"

	#include <xmloff/nmspmap.hxx>
	#include "xmloff/xmlnmspe.hxx"
	#include <xmloff/xmluconv.hxx>
	#include <xmloff/xmltoken.hxx>
	#include <xmloff/xmlexp.hxx>
	#include <com/sun/star/uno/Reference.h>
	#include <rtl/ustring.hxx>
	#include <svl/zforlist.hxx>
	#include <com/sun/star/util/NumberFormat.hpp>
	#include <rtl/math.hxx>
	#include <tools/debug.hxx>
	#include <rtl/ustrbuf.hxx>

	using namespace com::sun::star;
	using namespace xmloff::token;

	#define XML_TYPE "Type"
	#define XML_CURRENCYSYMBOL "CurrencySymbol"
	#define XML_CURRENCYABBREVIATION "CurrencyAbbreviation"
	#define XML_STANDARDFORMAT "StandardFormat"

	XMLNumberFormatAttributesExportHelper::XMLNumberFormatAttributesExportHelper(
	::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormatsSupplier >& xTempNumberFormatsSupplier)
	: xNumberFormats(xTempNumberFormatsSupplier.is() ? xTempNumberFormatsSupplier->getNumberFormats() : ::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormats > ()),
	pExport(NULL),
	sStandardFormat(RTL_CONSTASCII_USTRINGPARAM(XML_STANDARDFORMAT)),
	sType(RTL_CONSTASCII_USTRINGPARAM(XML_TYPE)),
	msCurrencySymbol(RTL_CONSTASCII_USTRINGPARAM(XML_CURRENCYSYMBOL)),
	msCurrencyAbbreviation(RTL_CONSTASCII_USTRINGPARAM(XML_CURRENCYABBREVIATION)),
	aNumberFormats()
	{
	}

	XMLNumberFormatAttributesExportHelper::XMLNumberFormatAttributesExportHelper(
	::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormatsSupplier >& xTempNumberFormatsSupplier,
	SvXMLExport& rTempExport )
	: xNumberFormats(xTempNumberFormatsSupplier.is() ? xTempNumberFormatsSupplier->getNumberFormats() : ::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormats > ()),
	pExport(&rTempExport),
	sStandardFormat(RTL_CONSTASCII_USTRINGPARAM(XML_STANDARDFORMAT)),
	sType(RTL_CONSTASCII_USTRINGPARAM(XML_TYPE)),
	sAttrValueType(rTempExport.GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_VALUE_TYPE))),
	sAttrValue(rTempExport.GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_VALUE))),
	sAttrDateValue(rTempExport.GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_DATE_VALUE))),
	sAttrTimeValue(rTempExport.GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_TIME_VALUE))),
	sAttrBooleanValue(rTempExport.GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_BOOLEAN_VALUE))),
	sAttrStringValue(rTempExport.GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_STRING_VALUE))),
	sAttrCurrency(rTempExport.GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_CURRENCY))),
	msCurrencySymbol(RTL_CONSTASCII_USTRINGPARAM(XML_CURRENCYSYMBOL)),
	msCurrencyAbbreviation(RTL_CONSTASCII_USTRINGPARAM(XML_CURRENCYABBREVIATION)),
	aNumberFormats()
	{
	}

	XMLNumberFormatAttributesExportHelper::~XMLNumberFormatAttributesExportHelper()
	{
	}

	sal_Int16 XMLNumberFormatAttributesExportHelper::GetCellType(const sal_Int32 nNumberFormat, rtl::OUString& sCurrency, sal_Bool& bIsStandard)
	{
	XMLNumberFormat aFormat(sEmpty, nNumberFormat, 0);
	XMLNumberFormatSet::iterator aItr(aNumberFormats.find(aFormat));
	XMLNumberFormatSet::iterator aEndItr(aNumberFormats.end());
	if (aItr != aEndItr)
	{
	bIsStandard = aItr->bIsStandard;
	sCurrency = aItr->sCurrency;
	return aItr->nType;
	}
	else
	{
	aFormat.nType = GetCellType(nNumberFormat, bIsStandard);
	aFormat.bIsStandard = bIsStandard;
	if ((aFormat.nType & ~util::NumberFormat::DEFINED) == util::NumberFormat::CURRENCY)
	if (GetCurrencySymbol(nNumberFormat, aFormat.sCurrency))
	sCurrency = aFormat.sCurrency;
	aNumberFormats.insert(aFormat);
	return aFormat.nType;
	}
	}

	void XMLNumberFormatAttributesExportHelper::WriteAttributes(SvXMLExport& rXMLExport,
	const sal_Int16 nTypeKey,
	const double& rValue,
	const rtl::OUString& rCurrency,
	sal_Bool bExportValue)
	{
	sal_Bool bWasSetTypeAttribute = sal_False;
	switch(nTypeKey & ~util::NumberFormat::DEFINED)
	{
	case 0:
	case util::NumberFormat::NUMBER:
	case util::NumberFormat::SCIENTIFIC:
	case util::NumberFormat::FRACTION:
	{
	if (!bWasSetTypeAttribute)
	{
	rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_FLOAT);
	bWasSetTypeAttribute = sal_True;
	}
	} // No Break
	case util::NumberFormat::PERCENT:
	{
	if (!bWasSetTypeAttribute)
	{
	rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_PERCENTAGE);
	bWasSetTypeAttribute = sal_True;
	}
	} // No Break
	case util::NumberFormat::CURRENCY:
	{
	if (!bWasSetTypeAttribute)
	{
	rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_CURRENCY);
	if (rCurrency.getLength() > 0)
	rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_CURRENCY, rCurrency);
	bWasSetTypeAttribute = sal_True;
	}

	if (bExportValue)
	{
	rtl::OUString sValue( ::rtl::math::doubleToUString( rValue,
	rtl_math_StringFormat_Automatic,
	rtl_math_DecimalPlaces_Max, '.', sal_True));
	rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE, sValue);
	}
	}
	break;
	case util::NumberFormat::DATE:
	case util::NumberFormat::DATETIME:
	{
	if (!bWasSetTypeAttribute)
	{
	rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_DATE);
	bWasSetTypeAttribute = sal_True;
	}
	if (bExportValue)
	{
	if ( rXMLExport.SetNullDateOnUnitConverter() )
	{
	rtl::OUStringBuffer sBuffer;
	rXMLExport.GetMM100UnitConverter().convertDateTime(sBuffer, rValue);
	rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_DATE_VALUE, sBuffer.makeStringAndClear());
	}
	}
	}
	break;
	case util::NumberFormat::TIME:
	{
	if (!bWasSetTypeAttribute)
	{
	rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_TIME);
	bWasSetTypeAttribute = sal_True;
	}
	if (bExportValue)
	{
	rtl::OUStringBuffer sBuffer;
	rXMLExport.GetMM100UnitConverter().convertTime(sBuffer, rValue);
	rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_TIME_VALUE, sBuffer.makeStringAndClear());
	}
	}
	break;
	case util::NumberFormat::LOGICAL:
	{
	if (!bWasSetTypeAttribute)
	{
	rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_BOOLEAN);
	bWasSetTypeAttribute = sal_True;
	}
	if (bExportValue)
	{
	double fTempValue = rValue;
	if (::rtl::math::approxEqual( fTempValue, 1.0 ))
	{
	rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_BOOLEAN_VALUE, XML_TRUE);
	}
	else
	{
	if (::rtl::math::approxEqual( rValue, 0.0 ))
	{
	rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_BOOLEAN_VALUE, XML_FALSE);
	}
	else
	{
	rtl::OUString sValue( ::rtl::math::doubleToUString(
	fTempValue,
	rtl_math_StringFormat_Automatic,
	rtl_math_DecimalPlaces_Max, '.',
	sal_True));
	rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_BOOLEAN_VALUE, sValue);
	}
	}
	}
	}
	break;
	case util::NumberFormat::TEXT:
	{
	if (!bWasSetTypeAttribute)
	{
	rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_FLOAT);
	bWasSetTypeAttribute = sal_True;
	if (bExportValue)
	{
	rtl::OUString sValue( ::rtl::math::doubleToUString( rValue,
	rtl_math_StringFormat_Automatic,
	rtl_math_DecimalPlaces_Max, '.', sal_True));
	rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE, sValue);
	}
	}
	}
	break;
	}
	}

	sal_Bool XMLNumberFormatAttributesExportHelper::GetCurrencySymbol(const sal_Int32 nNumberFormat, rtl::OUString& sCurrencySymbol,
	uno::Reference <util::XNumberFormatsSupplier>& xNumberFormatsSupplier)
	{
	if (xNumberFormatsSupplier.is())
	{
	uno::Reference <util::XNumberFormats> xNumberFormats(xNumberFormatsSupplier->getNumberFormats());
	if (xNumberFormats.is())
	{
	try
	{
	uno::Reference <beans::XPropertySet> xNumberPropertySet(xNumberFormats->getByKey(nNumberFormat));
	if ( xNumberPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_CURRENCYSYMBOL))) >>= sCurrencySymbol)
	{
	rtl::OUString sCurrencyAbbreviation;
	if ( xNumberPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_CURRENCYABBREVIATION))) >>= sCurrencyAbbreviation)
	{
	if ( sCurrencyAbbreviation.getLength() != 0 )
	sCurrencySymbol = sCurrencyAbbreviation;
	else
	{
	if ( sCurrencySymbol.getLength() == 1 && sCurrencySymbol.toChar() == NfCurrencyEntry::GetEuroSymbol() )
	sCurrencySymbol = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("EUR"));
	}
	}
	return sal_True;
	}
	}
	catch ( uno::Exception& )
	{
	DBG_ERROR("Numberformat not found");
	}
	}
	}
	return sal_False;
	}


	sal_Int16 XMLNumberFormatAttributesExportHelper::GetCellType(const sal_Int32 nNumberFormat, sal_Bool& bIsStandard,
	uno::Reference <util::XNumberFormatsSupplier>& xNumberFormatsSupplier)
	{
	if (xNumberFormatsSupplier.is())
	{
	uno::Reference <util::XNumberFormats> xNumberFormats(xNumberFormatsSupplier->getNumberFormats());
	if (xNumberFormats.is())
	{
	try
	{
	uno::Reference <beans::XPropertySet> xNumberPropertySet(xNumberFormats->getByKey(nNumberFormat));
	xNumberPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STANDARDFORMAT))) >>= bIsStandard;
	sal_Int16 nNumberType = sal_Int16();
	if ( xNumberPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_TYPE))) >>= nNumberType )
	{
	return nNumberType;
	}
	}
	catch ( uno::Exception& )
	{
	DBG_ERROR("Numberformat not found");
	}
	}
	}
	return 0;
	}

	void XMLNumberFormatAttributesExportHelper::SetNumberFormatAttributes(SvXMLExport& rXMLExport,
	const sal_Int32 nNumberFormat, const double& rValue, sal_Bool bExportValue)
	{
	sal_Bool bIsStandard;
	sal_Int16 nTypeKey = GetCellType(nNumberFormat, bIsStandard, rXMLExport.GetNumberFormatsSupplier());
	rtl::OUString sCurrency;
	if ((nTypeKey & ~util::NumberFormat::DEFINED) == util::NumberFormat::CURRENCY)
	GetCurrencySymbol(nNumberFormat, sCurrency, rXMLExport.GetNumberFormatsSupplier());
	WriteAttributes(rXMLExport, nTypeKey, rValue, sCurrency, bExportValue);
	}

	void XMLNumberFormatAttributesExportHelper::SetNumberFormatAttributes(SvXMLExport& rXMLExport,
	const rtl::OUString& rValue, const rtl::OUString& rCharacters,
	sal_Bool bExportValue, sal_Bool bExportTypeAttribute)
	{
	if (bExportTypeAttribute)
	rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_STRING);
	if (bExportValue && rValue.getLength() && (rValue != rCharacters))
	rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_STRING_VALUE, rValue);
	}

	sal_Bool XMLNumberFormatAttributesExportHelper::GetCurrencySymbol(const sal_Int32 nNumberFormat, rtl::OUString& rCurrencySymbol)
	{
	if (!xNumberFormats.is() && pExport && pExport->GetNumberFormatsSupplier().is())
	xNumberFormats.set(pExport->GetNumberFormatsSupplier()->getNumberFormats());

	if (xNumberFormats.is())
	{
	try
	{
	uno::Reference <beans::XPropertySet> xNumberPropertySet(xNumberFormats->getByKey(nNumberFormat));
	if ( xNumberPropertySet->getPropertyValue(msCurrencySymbol) >>= rCurrencySymbol)
	{
	rtl::OUString sCurrencyAbbreviation;
	if ( xNumberPropertySet->getPropertyValue(msCurrencyAbbreviation) >>= sCurrencyAbbreviation)
	{
	if ( sCurrencyAbbreviation.getLength() != 0 )
	rCurrencySymbol = sCurrencyAbbreviation;
	else
	{
	if ( rCurrencySymbol.getLength() == 1 && rCurrencySymbol.toChar() == NfCurrencyEntry::GetEuroSymbol() )
	rCurrencySymbol = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("EUR"));
	}
	}
	return sal_True;
	}
	}
	catch ( uno::Exception& )
	{
	DBG_ERROR("Numberformat not found");
	}
	}
	return sal_False;
	}

	sal_Int16 XMLNumberFormatAttributesExportHelper::GetCellType(const sal_Int32 nNumberFormat, sal_Bool& bIsStandard)
	{
	if (!xNumberFormats.is() && pExport && pExport->GetNumberFormatsSupplier().is())
	xNumberFormats.set(pExport->GetNumberFormatsSupplier()->getNumberFormats());

	if (xNumberFormats.is())
	{
	try
	{
	uno::Reference <beans::XPropertySet> xNumberPropertySet(xNumberFormats->getByKey(nNumberFormat));
	if (xNumberPropertySet.is())
	{
	xNumberPropertySet->getPropertyValue(sStandardFormat) >>= bIsStandard;
	sal_Int16 nNumberType = sal_Int16();
	if ( xNumberPropertySet->getPropertyValue(sType) >>= nNumberType )
	{
	return nNumberType;
	}
	}
	}
	catch ( uno::Exception& )
	{
	DBG_ERROR("Numberformat not found");
	}
	}
	return 0;
	}

	void XMLNumberFormatAttributesExportHelper::WriteAttributes(
	const sal_Int16 nTypeKey,
	const double& rValue,
	const rtl::OUString& rCurrency,
	sal_Bool bExportValue)
	{
	if (!pExport)
	return;

	sal_Bool bWasSetTypeAttribute = sal_False;
	switch(nTypeKey & ~util::NumberFormat::DEFINED)
	{
	case 0:
	case util::NumberFormat::NUMBER:
	case util::NumberFormat::SCIENTIFIC:
	case util::NumberFormat::FRACTION:
	{
	if (!bWasSetTypeAttribute)
	{
	pExport->AddAttribute(sAttrValueType, XML_FLOAT);
	bWasSetTypeAttribute = sal_True;
	}
	} // No Break
	case util::NumberFormat::PERCENT:
	{
	if (!bWasSetTypeAttribute)
	{
	pExport->AddAttribute(sAttrValueType, XML_PERCENTAGE);
	bWasSetTypeAttribute = sal_True;
	}
	} // No Break
	case util::NumberFormat::CURRENCY:
	{
	if (!bWasSetTypeAttribute)
	{
	pExport->AddAttribute(sAttrValueType, XML_CURRENCY);
	if (rCurrency.getLength() > 0)
	pExport->AddAttribute(sAttrCurrency, rCurrency);
	bWasSetTypeAttribute = sal_True;
	}

	if (bExportValue)
	{
	rtl::OUString sValue( ::rtl::math::doubleToUString( rValue,
	rtl_math_StringFormat_Automatic,
	rtl_math_DecimalPlaces_Max, '.', sal_True));
	pExport->AddAttribute(sAttrValue, sValue);
	}
	}
	break;
	case util::NumberFormat::DATE:
	case util::NumberFormat::DATETIME:
	{
	if (!bWasSetTypeAttribute)
	{
	pExport->AddAttribute(sAttrValueType, XML_DATE);
	bWasSetTypeAttribute = sal_True;
	}
	if (bExportValue)
	{
	if ( pExport->SetNullDateOnUnitConverter() )
	{
	rtl::OUStringBuffer sBuffer;
	pExport->GetMM100UnitConverter().convertDateTime(sBuffer, rValue);
	pExport->AddAttribute(sAttrDateValue, sBuffer.makeStringAndClear());
	}
	}
	}
	break;
	case util::NumberFormat::TIME:
	{
	if (!bWasSetTypeAttribute)
	{
	pExport->AddAttribute(sAttrValueType, XML_TIME);
	bWasSetTypeAttribute = sal_True;
	}
	if (bExportValue)
	{
	rtl::OUStringBuffer sBuffer;
	pExport->GetMM100UnitConverter().convertTime(sBuffer, rValue);
	pExport->AddAttribute(sAttrTimeValue, sBuffer.makeStringAndClear());
	}
	}
	break;
	case util::NumberFormat::LOGICAL:
	{
	if (!bWasSetTypeAttribute)
	{
	pExport->AddAttribute(sAttrValueType, XML_BOOLEAN);
	bWasSetTypeAttribute = sal_True;
	}
	if (bExportValue)
	{
	double fTempValue = rValue;
	if (::rtl::math::approxEqual( fTempValue, 1.0 ))
	{
	pExport->AddAttribute(sAttrBooleanValue, XML_TRUE);
	}
	else
	{
	if (::rtl::math::approxEqual( rValue, 0.0 ))
	{
	pExport->AddAttribute(sAttrBooleanValue, XML_FALSE);
	}
	else
	{
	rtl::OUString sValue( ::rtl::math::doubleToUString(
	fTempValue,
	rtl_math_StringFormat_Automatic,
	rtl_math_DecimalPlaces_Max, '.',
	sal_True));
	pExport->AddAttribute(sAttrBooleanValue, sValue);
	}
	}
	}
	}
	break;
	case util::NumberFormat::TEXT:
	{
	if (!bWasSetTypeAttribute)
	{
	pExport->AddAttribute(sAttrValueType, XML_FLOAT);
	bWasSetTypeAttribute = sal_True;
	if (bExportValue)
	{
	rtl::OUString sValue( ::rtl::math::doubleToUString( rValue,
	rtl_math_StringFormat_Automatic,
	rtl_math_DecimalPlaces_Max, '.', sal_True));
	pExport->AddAttribute(sAttrValue, sValue);
	}
	}
	}
	break;
	}
	}

	void XMLNumberFormatAttributesExportHelper::SetNumberFormatAttributes(
	const sal_Int32 nNumberFormat, const double& rValue, sal_Bool bExportValue)
	{
	if (pExport)
	{
	sal_Bool bIsStandard;
	rtl::OUString sCurrency;
	sal_Int16 nTypeKey = GetCellType(nNumberFormat, sCurrency, bIsStandard);
	WriteAttributes(nTypeKey, rValue, sCurrency, bExportValue);
	}
	else {
	DBG_ERROR("no SvXMLExport given");
	}
	}

	void XMLNumberFormatAttributesExportHelper::SetNumberFormatAttributes(
	const rtl::OUString& rValue, const rtl::OUString& rCharacters,
	sal_Bool bExportValue, sal_Bool bExportTypeAttribute)
	{
	if (pExport)
	{
	if (bExportTypeAttribute)
	pExport->AddAttribute(sAttrValueType, XML_STRING);
	if (bExportValue && rValue.getLength() && (rValue != rCharacters))
	pExport->AddAttribute(sAttrStringValue, rValue);
	}
	else {
	DBG_ERROR("no SvXMLExport given");
	}
	}