xmloff/source/style/numehelp.cxx

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