xmloff/source/style/numehelp.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: numehelp.cxx,v $
  10  * $Revision: 1.28 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_xmloff.hxx"
  33
  34 #include "numehelp.hxx"
  35
  36 #include <xmloff/nmspmap.hxx>
  37 #include "xmlnmspe.hxx"
  38 #include <xmloff/xmluconv.hxx>
  39 #include <xmloff/xmltoken.hxx>
  40 #include <xmloff/xmlexp.hxx>
  41 #include <com/sun/star/uno/Reference.h>
  42 #include <rtl/ustring.hxx>
  43 #include <svtools/zforlist.hxx>
  44 #include <com/sun/star/util/NumberFormat.hpp>
  45 #include <rtl/math.hxx>
  46 #include <tools/debug.hxx>
  47 #include <rtl/ustrbuf.hxx>
  48
  49 using namespace com::sun::star;
  50 using namespace xmloff::token;
  51
  52 #define XML_TYPE "Type"
  53 #define XML_CURRENCYSYMBOL "CurrencySymbol"
  54 #define XML_CURRENCYABBREVIATION "CurrencyAbbreviation"
  55 #define XML_STANDARDFORMAT "StandardFormat"
  56
  57 XMLNumberFormatAttributesExportHelper::XMLNumberFormatAttributesExportHelper(
  58             ::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormatsSupplier >& xTempNumberFormatsSupplier)
  59     : xNumberFormats(xTempNumberFormatsSupplier.is() ? xTempNumberFormatsSupplier->getNumberFormats() : ::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormats > ()),
  60     pExport(NULL),
  61     sStandardFormat(RTL_CONSTASCII_USTRINGPARAM(XML_STANDARDFORMAT)),
  62     sType(RTL_CONSTASCII_USTRINGPARAM(XML_TYPE)),
  63     msCurrencySymbol(RTL_CONSTASCII_USTRINGPARAM(XML_CURRENCYSYMBOL)),
  64     msCurrencyAbbreviation(RTL_CONSTASCII_USTRINGPARAM(XML_CURRENCYABBREVIATION)),
  65     aNumberFormats()
  66 {
  67 }
  68
  69 XMLNumberFormatAttributesExportHelper::XMLNumberFormatAttributesExportHelper(
  70             ::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormatsSupplier >& xTempNumberFormatsSupplier,
  71             SvXMLExport& rTempExport )
  72 :       xNumberFormats(xTempNumberFormatsSupplier.is() ? xTempNumberFormatsSupplier->getNumberFormats() : ::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormats > ()),
  73     pExport(&rTempExport),
  74     sStandardFormat(RTL_CONSTASCII_USTRINGPARAM(XML_STANDARDFORMAT)),
  75     sType(RTL_CONSTASCII_USTRINGPARAM(XML_TYPE)),
  76     sAttrValueType(rTempExport.GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_VALUE_TYPE))),
  77     sAttrValue(rTempExport.GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_VALUE))),
  78     sAttrDateValue(rTempExport.GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_DATE_VALUE))),
  79     sAttrTimeValue(rTempExport.GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_TIME_VALUE))),
  80     sAttrBooleanValue(rTempExport.GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_BOOLEAN_VALUE))),
  81     sAttrStringValue(rTempExport.GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_STRING_VALUE))),
  82     sAttrCurrency(rTempExport.GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_CURRENCY))),
  83     msCurrencySymbol(RTL_CONSTASCII_USTRINGPARAM(XML_CURRENCYSYMBOL)),
  84     msCurrencyAbbreviation(RTL_CONSTASCII_USTRINGPARAM(XML_CURRENCYABBREVIATION)),
  85     aNumberFormats()
  86 {
  87 }
  88
  89 XMLNumberFormatAttributesExportHelper::~XMLNumberFormatAttributesExportHelper()
  90 {
  91 }
  92
  93 sal_Int16 XMLNumberFormatAttributesExportHelper::GetCellType(const sal_Int32 nNumberFormat, rtl::OUString& sCurrency, sal_Bool& bIsStandard)
  94 {
  95     XMLNumberFormat aFormat(sEmpty, nNumberFormat, 0);
  96     XMLNumberFormatSet::iterator aItr(aNumberFormats.find(aFormat));
  97     XMLNumberFormatSet::iterator aEndItr(aNumberFormats.end());
  98     if (aItr != aEndItr)
  99     {
 100         bIsStandard = aItr->bIsStandard;
 101         sCurrency = aItr->sCurrency;
 102         return aItr->nType;
 103     }
 104     else
 105     {
 106         aFormat.nType = GetCellType(nNumberFormat, bIsStandard);
 107         aFormat.bIsStandard = bIsStandard;
 108         if ((aFormat.nType & ~util::NumberFormat::DEFINED) == util::NumberFormat::CURRENCY)
 109             if (GetCurrencySymbol(nNumberFormat, aFormat.sCurrency))
 110                 sCurrency = aFormat.sCurrency;
 111         aNumberFormats.insert(aFormat);
 112         return aFormat.nType;
 113     }
 114 }
 115
 116 void XMLNumberFormatAttributesExportHelper::WriteAttributes(SvXMLExport& rXMLExport,
 117                                 const sal_Int16 nTypeKey,
 118                                 const double& rValue,
 119                                 const rtl::OUString& rCurrency,
 120                                 sal_Bool bExportValue)
 121 {
 122     sal_Bool bWasSetTypeAttribute = sal_False;
 123     switch(nTypeKey & ~util::NumberFormat::DEFINED)
 124     {
 125     case 0:
 126     case util::NumberFormat::NUMBER:
 127     case util::NumberFormat::SCIENTIFIC:
 128     case util::NumberFormat::FRACTION:
 129         {
 130             if (!bWasSetTypeAttribute)
 131             {
 132                 rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_FLOAT);
 133                 bWasSetTypeAttribute = sal_True;
 134             }
 135         }               // No Break
 136     case util::NumberFormat::PERCENT:
 137         {
 138             if (!bWasSetTypeAttribute)
 139             {
 140                 rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_PERCENTAGE);
 141                 bWasSetTypeAttribute = sal_True;
 142             }
 143         }               // No Break
 144     case util::NumberFormat::CURRENCY:
 145         {
 146             if (!bWasSetTypeAttribute)
 147             {
 148                 rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_CURRENCY);
 149                 if (rCurrency.getLength() > 0)
 150                     rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_CURRENCY, rCurrency);
 151                 bWasSetTypeAttribute = sal_True;
 152             }
 153
 154             if (bExportValue)
 155             {
 156                 rtl::OUString sValue( ::rtl::math::doubleToUString( rValue,
 157                             rtl_math_StringFormat_Automatic,
 158                             rtl_math_DecimalPlaces_Max, '.', sal_True));
 159                 rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE, sValue);
 160             }
 161         }
 162         break;
 163     case util::NumberFormat::DATE:
 164     case util::NumberFormat::DATETIME:
 165         {
 166             if (!bWasSetTypeAttribute)
 167             {
 168                 rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_DATE);
 169                 bWasSetTypeAttribute = sal_True;
 170             }
 171             if (bExportValue)
 172             {
 173                 if ( rXMLExport.SetNullDateOnUnitConverter() )
 174                 {
 175                     rtl::OUStringBuffer sBuffer;
 176                     rXMLExport.GetMM100UnitConverter().convertDateTime(sBuffer, rValue);
 177                     rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_DATE_VALUE, sBuffer.makeStringAndClear());
 178                 }
 179             }
 180         }
 181         break;
 182     case util::NumberFormat::TIME:
 183         {
 184             if (!bWasSetTypeAttribute)
 185             {
 186                 rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_TIME);
 187                 bWasSetTypeAttribute = sal_True;
 188             }
 189             if (bExportValue)
 190             {
 191                 rtl::OUStringBuffer sBuffer;
 192                 rXMLExport.GetMM100UnitConverter().convertTime(sBuffer, rValue);
 193                 rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_TIME_VALUE, sBuffer.makeStringAndClear());
 194             }
 195         }
 196         break;
 197     case util::NumberFormat::LOGICAL:
 198         {
 199             if (!bWasSetTypeAttribute)
 200             {
 201                 rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_BOOLEAN);
 202                 bWasSetTypeAttribute = sal_True;
 203             }
 204             if (bExportValue)
 205             {
 206                 double fTempValue = rValue;
 207                 if (::rtl::math::approxEqual( fTempValue, 1.0 ))
 208                 {
 209                     rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_BOOLEAN_VALUE, XML_TRUE);
 210                 }
 211                 else
 212                 {
 213                     if (::rtl::math::approxEqual( rValue, 0.0 ))
 214                     {
 215                         rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_BOOLEAN_VALUE, XML_FALSE);
 216                     }
 217                     else
 218                     {
 219                         rtl::OUString sValue( ::rtl::math::doubleToUString(
 220                                     fTempValue,
 221                                     rtl_math_StringFormat_Automatic,
 222                                     rtl_math_DecimalPlaces_Max, '.',
 223                                     sal_True));
 224                         rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_BOOLEAN_VALUE, sValue);
 225                     }
 226                 }
 227             }
 228         }
 229         break;
 230     case util::NumberFormat::TEXT:
 231         {
 232             if (!bWasSetTypeAttribute)
 233             {
 234                 rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_FLOAT);
 235                 bWasSetTypeAttribute = sal_True;
 236                 if (bExportValue)
 237                 {
 238                     rtl::OUString sValue( ::rtl::math::doubleToUString( rValue,
 239                                 rtl_math_StringFormat_Automatic,
 240                                 rtl_math_DecimalPlaces_Max, '.', sal_True));
 241                     rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE, sValue);
 242                 }
 243             }
 244         }
 245         break;
 246     }
 247 }
 248
 249 sal_Bool XMLNumberFormatAttributesExportHelper::GetCurrencySymbol(const sal_Int32 nNumberFormat, rtl::OUString& sCurrencySymbol,
 250     uno::Reference <util::XNumberFormatsSupplier>& xNumberFormatsSupplier)
 251 {
 252     if (xNumberFormatsSupplier.is())
 253     {
 254         uno::Reference <util::XNumberFormats> xNumberFormats(xNumberFormatsSupplier->getNumberFormats());
 255         if (xNumberFormats.is())
 256         {
 257             try
 258             {
 259                 uno::Reference <beans::XPropertySet> xNumberPropertySet(xNumberFormats->getByKey(nNumberFormat));
 260                 if ( xNumberPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_CURRENCYSYMBOL))) >>= sCurrencySymbol)
 261                 {
 262                     rtl::OUString sCurrencyAbbreviation;
 263                     if ( xNumberPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_CURRENCYABBREVIATION))) >>= sCurrencyAbbreviation)
 264                     {
 265                         if ( sCurrencyAbbreviation.getLength() != 0 )
 266                             sCurrencySymbol = sCurrencyAbbreviation;
 267                         else
 268                         {
 269                             if ( sCurrencySymbol.getLength() == 1 && sCurrencySymbol.toChar() == NfCurrencyEntry::GetEuroSymbol() )
 270                                 sCurrencySymbol = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("EUR"));
 271                         }
 272                     }
 273                     return sal_True;
 274                 }
 275             }
 276             catch ( uno::Exception& )
 277             {
 278                 DBG_ERROR("Numberformat not found");
 279             }
 280         }
 281     }
 282     return sal_False;
 283 }
 284
 285
 286 sal_Int16 XMLNumberFormatAttributesExportHelper::GetCellType(const sal_Int32 nNumberFormat, sal_Bool& bIsStandard,
 287     uno::Reference <util::XNumberFormatsSupplier>& xNumberFormatsSupplier)
 288 {
 289     if (xNumberFormatsSupplier.is())
 290     {
 291         uno::Reference <util::XNumberFormats> xNumberFormats(xNumberFormatsSupplier->getNumberFormats());
 292         if (xNumberFormats.is())
 293         {
 294             try
 295             {
 296                 uno::Reference <beans::XPropertySet> xNumberPropertySet(xNumberFormats->getByKey(nNumberFormat));
 297                 xNumberPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STANDARDFORMAT))) >>= bIsStandard;
 298                 sal_Int16 nNumberType = sal_Int16();
 299                 if ( xNumberPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_TYPE))) >>= nNumberType )
 300                 {
 301                     return nNumberType;
 302                 }
 303             }
 304             catch ( uno::Exception& )
 305             {
 306                 DBG_ERROR("Numberformat not found");
 307             }
 308         }
 309     }
 310     return 0;
 311 }
 312
 313 void XMLNumberFormatAttributesExportHelper::SetNumberFormatAttributes(SvXMLExport& rXMLExport,
 314     const sal_Int32 nNumberFormat, const double& rValue, sal_Bool bExportValue)
 315 {
 316     sal_Bool bIsStandard;
 317     sal_Int16 nTypeKey = GetCellType(nNumberFormat, bIsStandard, rXMLExport.GetNumberFormatsSupplier());
 318     rtl::OUString sCurrency;
 319     if ((nTypeKey & ~util::NumberFormat::DEFINED) == util::NumberFormat::CURRENCY)
 320         GetCurrencySymbol(nNumberFormat, sCurrency, rXMLExport.GetNumberFormatsSupplier());
 321     WriteAttributes(rXMLExport, nTypeKey, rValue, sCurrency, bExportValue);
 322 }
 323
 324 void XMLNumberFormatAttributesExportHelper::SetNumberFormatAttributes(SvXMLExport& rXMLExport,
 325     const rtl::OUString& rValue, const rtl::OUString& rCharacters,
 326     sal_Bool bExportValue, sal_Bool bExportTypeAttribute)
 327 {
 328     if (bExportTypeAttribute)
 329         rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_STRING);
 330     if (bExportValue && rValue.getLength() && (rValue != rCharacters))
 331         rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_STRING_VALUE, rValue);
 332 }
 333
 334 sal_Bool XMLNumberFormatAttributesExportHelper::GetCurrencySymbol(const sal_Int32 nNumberFormat, rtl::OUString& rCurrencySymbol)
 335 {
 336     if (!xNumberFormats.is() && pExport && pExport->GetNumberFormatsSupplier().is())
 337         xNumberFormats.set(pExport->GetNumberFormatsSupplier()->getNumberFormats());
 338
 339     if (xNumberFormats.is())
 340     {
 341         try
 342         {
 343             uno::Reference <beans::XPropertySet> xNumberPropertySet(xNumberFormats->getByKey(nNumberFormat));
 344             if ( xNumberPropertySet->getPropertyValue(msCurrencySymbol) >>= rCurrencySymbol)
 345             {
 346                 rtl::OUString sCurrencyAbbreviation;
 347                 if ( xNumberPropertySet->getPropertyValue(msCurrencyAbbreviation) >>= sCurrencyAbbreviation)
 348                 {
 349                     if ( sCurrencyAbbreviation.getLength() != 0 )
 350                         rCurrencySymbol = sCurrencyAbbreviation;
 351                     else
 352                     {
 353                         if ( rCurrencySymbol.getLength() == 1 && rCurrencySymbol.toChar() == NfCurrencyEntry::GetEuroSymbol() )
 354                             rCurrencySymbol = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("EUR"));
 355                     }
 356                 }
 357                 return sal_True;
 358             }
 359         }
 360         catch ( uno::Exception& )
 361         {
 362             DBG_ERROR("Numberformat not found");
 363         }
 364     }
 365     return sal_False;
 366 }
 367
 368 sal_Int16 XMLNumberFormatAttributesExportHelper::GetCellType(const sal_Int32 nNumberFormat, sal_Bool& bIsStandard)
 369 {
 370     if (!xNumberFormats.is() && pExport && pExport->GetNumberFormatsSupplier().is())
 371         xNumberFormats.set(pExport->GetNumberFormatsSupplier()->getNumberFormats());
 372
 373     if (xNumberFormats.is())
 374     {
 375         try
 376         {
 377             uno::Reference <beans::XPropertySet> xNumberPropertySet(xNumberFormats->getByKey(nNumberFormat));
 378             if (xNumberPropertySet.is())
 379             {
 380                 xNumberPropertySet->getPropertyValue(sStandardFormat) >>= bIsStandard;
 381                 sal_Int16 nNumberType = sal_Int16();
 382                 if ( xNumberPropertySet->getPropertyValue(sType) >>= nNumberType )
 383                 {
 384                     return nNumberType;
 385                 }
 386             }
 387         }
 388         catch ( uno::Exception& )
 389         {
 390             DBG_ERROR("Numberformat not found");
 391         }
 392     }
 393     return 0;
 394 }
 395
 396 void XMLNumberFormatAttributesExportHelper::WriteAttributes(
 397                                 const sal_Int16 nTypeKey,
 398                                 const double& rValue,
 399                                 const rtl::OUString& rCurrency,
 400                                 sal_Bool bExportValue)
 401 {
 402     if (!pExport)
 403         return;
 404
 405     sal_Bool bWasSetTypeAttribute = sal_False;
 406     switch(nTypeKey & ~util::NumberFormat::DEFINED)
 407     {
 408     case 0:
 409     case util::NumberFormat::NUMBER:
 410     case util::NumberFormat::SCIENTIFIC:
 411     case util::NumberFormat::FRACTION:
 412         {
 413             if (!bWasSetTypeAttribute)
 414             {
 415                 pExport->AddAttribute(sAttrValueType, XML_FLOAT);
 416                 bWasSetTypeAttribute = sal_True;
 417             }
 418         }               // No Break
 419     case util::NumberFormat::PERCENT:
 420         {
 421             if (!bWasSetTypeAttribute)
 422             {
 423                 pExport->AddAttribute(sAttrValueType, XML_PERCENTAGE);
 424                 bWasSetTypeAttribute = sal_True;
 425             }
 426         }               // No Break
 427     case util::NumberFormat::CURRENCY:
 428         {
 429             if (!bWasSetTypeAttribute)
 430             {
 431                 pExport->AddAttribute(sAttrValueType, XML_CURRENCY);
 432                 if (rCurrency.getLength() > 0)
 433                     pExport->AddAttribute(sAttrCurrency, rCurrency);
 434                 bWasSetTypeAttribute = sal_True;
 435             }
 436
 437             if (bExportValue)
 438             {
 439                 rtl::OUString sValue( ::rtl::math::doubleToUString( rValue,
 440                             rtl_math_StringFormat_Automatic,
 441                             rtl_math_DecimalPlaces_Max, '.', sal_True));
 442                 pExport->AddAttribute(sAttrValue, sValue);
 443             }
 444         }
 445         break;
 446     case util::NumberFormat::DATE:
 447     case util::NumberFormat::DATETIME:
 448         {
 449             if (!bWasSetTypeAttribute)
 450             {
 451                 pExport->AddAttribute(sAttrValueType, XML_DATE);
 452                 bWasSetTypeAttribute = sal_True;
 453             }
 454             if (bExportValue)
 455             {
 456                 if ( pExport->SetNullDateOnUnitConverter() )
 457                 {
 458                     rtl::OUStringBuffer sBuffer;
 459                     pExport->GetMM100UnitConverter().convertDateTime(sBuffer, rValue);
 460                     pExport->AddAttribute(sAttrDateValue, sBuffer.makeStringAndClear());
 461                 }
 462             }
 463         }
 464         break;
 465     case util::NumberFormat::TIME:
 466         {
 467             if (!bWasSetTypeAttribute)
 468             {
 469                 pExport->AddAttribute(sAttrValueType, XML_TIME);
 470                 bWasSetTypeAttribute = sal_True;
 471             }
 472             if (bExportValue)
 473             {
 474                 rtl::OUStringBuffer sBuffer;
 475                 pExport->GetMM100UnitConverter().convertTime(sBuffer, rValue);
 476                 pExport->AddAttribute(sAttrTimeValue, sBuffer.makeStringAndClear());
 477             }
 478         }
 479         break;
 480     case util::NumberFormat::LOGICAL:
 481         {
 482             if (!bWasSetTypeAttribute)
 483             {
 484                 pExport->AddAttribute(sAttrValueType, XML_BOOLEAN);
 485                 bWasSetTypeAttribute = sal_True;
 486             }
 487             if (bExportValue)
 488             {
 489                 double fTempValue = rValue;
 490                 if (::rtl::math::approxEqual( fTempValue, 1.0 ))
 491                 {
 492                     pExport->AddAttribute(sAttrBooleanValue, XML_TRUE);
 493                 }
 494                 else
 495                 {
 496                     if (::rtl::math::approxEqual( rValue, 0.0 ))
 497                     {
 498                         pExport->AddAttribute(sAttrBooleanValue, XML_FALSE);
 499                     }
 500                     else
 501                     {
 502                         rtl::OUString sValue( ::rtl::math::doubleToUString(
 503                                     fTempValue,
 504                                     rtl_math_StringFormat_Automatic,
 505                                     rtl_math_DecimalPlaces_Max, '.',
 506                                     sal_True));
 507                         pExport->AddAttribute(sAttrBooleanValue, sValue);
 508                     }
 509                 }
 510             }
 511         }
 512         break;
 513     case util::NumberFormat::TEXT:
 514         {
 515             if (!bWasSetTypeAttribute)
 516             {
 517                 pExport->AddAttribute(sAttrValueType, XML_FLOAT);
 518                 bWasSetTypeAttribute = sal_True;
 519                 if (bExportValue)
 520                 {
 521                     rtl::OUString sValue( ::rtl::math::doubleToUString( rValue,
 522                                 rtl_math_StringFormat_Automatic,
 523                                 rtl_math_DecimalPlaces_Max, '.', sal_True));
 524                     pExport->AddAttribute(sAttrValue, sValue);
 525                 }
 526             }
 527         }
 528         break;
 529     }
 530 }
 531
 532 void XMLNumberFormatAttributesExportHelper::SetNumberFormatAttributes(
 533     const sal_Int32 nNumberFormat, const double& rValue, sal_Bool bExportValue)
 534 {
 535     if (pExport)
 536     {
 537         sal_Bool bIsStandard;
 538         rtl::OUString sCurrency;
 539         sal_Int16 nTypeKey = GetCellType(nNumberFormat, sCurrency, bIsStandard);
 540         WriteAttributes(nTypeKey, rValue, sCurrency, bExportValue);
 541     }
 542     else {
 543         DBG_ERROR("no SvXMLExport given");
 544     }
 545 }
 546
 547 void XMLNumberFormatAttributesExportHelper::SetNumberFormatAttributes(
 548     const rtl::OUString& rValue, const rtl::OUString& rCharacters,
 549     sal_Bool bExportValue, sal_Bool bExportTypeAttribute)
 550 {
 551     if (pExport)
 552     {
 553         if (bExportTypeAttribute)
 554             pExport->AddAttribute(sAttrValueType, XML_STRING);
 555         if (bExportValue && rValue.getLength() && (rValue != rCharacters))
 556             pExport->AddAttribute(sAttrStringValue, rValue);
 557     }
 558     else {
 559         DBG_ERROR("no SvXMLExport given");
 560     }
 561 }