LCOV - code coverage report
Current view: top level - xmloff/source/style - numehelp.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 134 232 57.8 %
Date: 2015-06-13 12:38:46 Functions: 12 14 85.7 %
Legend: Lines: hit not hit

          Line data    Source code
       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         112 : XMLNumberFormatAttributesExportHelper::XMLNumberFormatAttributesExportHelper(
      45             :             ::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormatsSupplier >& xTempNumberFormatsSupplier)
      46         224 :     : 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         224 :     aNumberFormats()
      53             : {
      54         112 : }
      55             : 
      56          19 : XMLNumberFormatAttributesExportHelper::XMLNumberFormatAttributesExportHelper(
      57             :             ::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormatsSupplier >& xTempNumberFormatsSupplier,
      58             :             SvXMLExport& rTempExport )
      59          38 : :   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          19 :     sAttrValue(rTempExport.GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_VALUE))),
      64          19 :     sAttrDateValue(rTempExport.GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_DATE_VALUE))),
      65          19 :     sAttrTimeValue(rTempExport.GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_TIME_VALUE))),
      66          19 :     sAttrBooleanValue(rTempExport.GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_BOOLEAN_VALUE))),
      67          19 :     sAttrStringValue(rTempExport.GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_STRING_VALUE))),
      68          19 :     sAttrCurrency(rTempExport.GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_CURRENCY))),
      69             :     msCurrencySymbol(XML_CURRENCYSYMBOL),
      70             :     msCurrencyAbbreviation(XML_CURRENCYABBREVIATION),
      71         152 :     aNumberFormats()
      72             : {
      73          19 : }
      74             : 
      75         131 : XMLNumberFormatAttributesExportHelper::~XMLNumberFormatAttributesExportHelper()
      76             : {
      77         131 : }
      78             : 
      79        1208 : sal_Int16 XMLNumberFormatAttributesExportHelper::GetCellType(const sal_Int32 nNumberFormat, OUString& sCurrency, bool& bIsStandard)
      80             : {
      81        1208 :     XMLNumberFormat aFormat(sEmpty, nNumberFormat, 0);
      82        1208 :     XMLNumberFormatSet::iterator aItr(aNumberFormats.find(aFormat));
      83        1208 :     XMLNumberFormatSet::iterator aEndItr(aNumberFormats.end());
      84        1208 :     if (aItr != aEndItr)
      85             :     {
      86         855 :         bIsStandard = aItr->bIsStandard;
      87         855 :         sCurrency = aItr->sCurrency;
      88         855 :         return aItr->nType;
      89             :     }
      90             :     else
      91             :     {
      92         353 :         aFormat.nType = GetCellType(nNumberFormat, bIsStandard);
      93         353 :         aFormat.bIsStandard = bIsStandard;
      94         353 :         if ((aFormat.nType & ~util::NumberFormat::DEFINED) == util::NumberFormat::CURRENCY)
      95          26 :             if (GetCurrencySymbol(nNumberFormat, aFormat.sCurrency))
      96          26 :                 sCurrency = aFormat.sCurrency;
      97         353 :         aNumberFormats.insert(aFormat);
      98         353 :         return aFormat.nType;
      99        1208 :     }
     100             : }
     101             : 
     102           2 : void XMLNumberFormatAttributesExportHelper::WriteAttributes(SvXMLExport& rXMLExport,
     103             :                                 const sal_Int16 nTypeKey,
     104             :                                 const double& rValue,
     105             :                                 const OUString& rCurrency,
     106             :                                 bool bExportValue)
     107             : {
     108           2 :     bool bWasSetTypeAttribute = false;
     109           2 :     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           2 :             if (!bWasSetTypeAttribute)
     117             :             {
     118           2 :                 rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_FLOAT);
     119           2 :                 bWasSetTypeAttribute = true;
     120             :             }
     121             :         }       // No Break
     122             :     case util::NumberFormat::PERCENT:
     123             :         {
     124           2 :             if (!bWasSetTypeAttribute)
     125             :             {
     126           0 :                 rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_PERCENTAGE);
     127           0 :                 bWasSetTypeAttribute = true;
     128             :             }
     129             :         }       // No Break
     130             :     case util::NumberFormat::CURRENCY:
     131             :         {
     132           2 :             if (!bWasSetTypeAttribute)
     133             :             {
     134           0 :                 rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_CURRENCY);
     135           0 :                 if (!rCurrency.isEmpty())
     136           0 :                     rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_CURRENCY, rCurrency);
     137           0 :                 bWasSetTypeAttribute = true;
     138             :             }
     139             : 
     140           2 :             if (bExportValue)
     141             :             {
     142             :                 OUString sValue( ::rtl::math::doubleToUString( rValue,
     143             :                             rtl_math_StringFormat_Automatic,
     144           1 :                             rtl_math_DecimalPlaces_Max, '.', true));
     145           1 :                 rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE, sValue);
     146             :             }
     147             :         }
     148           2 :         break;
     149             :     case util::NumberFormat::DATE:
     150             :     case util::NumberFormat::DATETIME:
     151             :         {
     152           0 :             if (!bWasSetTypeAttribute)
     153             :             {
     154           0 :                 rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_DATE);
     155           0 :                 bWasSetTypeAttribute = true;
     156             :             }
     157           0 :             if (bExportValue)
     158             :             {
     159           0 :                 if ( rXMLExport.SetNullDateOnUnitConverter() )
     160             :                 {
     161           0 :                     OUStringBuffer sBuffer;
     162           0 :                     rXMLExport.GetMM100UnitConverter().convertDateTime(sBuffer, rValue);
     163           0 :                     rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_DATE_VALUE, sBuffer.makeStringAndClear());
     164             :                 }
     165             :             }
     166             :         }
     167           0 :         break;
     168             :     case util::NumberFormat::TIME:
     169             :         {
     170           0 :             if (!bWasSetTypeAttribute)
     171             :             {
     172           0 :                 rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_TIME);
     173           0 :                 bWasSetTypeAttribute = true;
     174             :             }
     175           0 :             if (bExportValue)
     176             :             {
     177           0 :                 OUStringBuffer sBuffer;
     178           0 :                 ::sax::Converter::convertDuration(sBuffer, rValue);
     179           0 :                 rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_TIME_VALUE, sBuffer.makeStringAndClear());
     180             :             }
     181             :         }
     182           0 :         break;
     183             :     case util::NumberFormat::LOGICAL:
     184             :         {
     185           0 :             if (!bWasSetTypeAttribute)
     186             :             {
     187           0 :                 rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_BOOLEAN);
     188           0 :                 bWasSetTypeAttribute = true;
     189             :             }
     190           0 :             if (bExportValue)
     191             :             {
     192           0 :                 double fTempValue = rValue;
     193           0 :                 if (::rtl::math::approxEqual( fTempValue, 1.0 ))
     194             :                 {
     195           0 :                     rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_BOOLEAN_VALUE, XML_TRUE);
     196             :                 }
     197             :                 else
     198             :                 {
     199           0 :                     if (::rtl::math::approxEqual( rValue, 0.0 ))
     200             :                     {
     201           0 :                         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           0 :                                     true));
     210           0 :                         rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_BOOLEAN_VALUE, sValue);
     211             :                     }
     212             :                 }
     213             :             }
     214             :         }
     215           0 :         break;
     216             :     case util::NumberFormat::TEXT:
     217             :         {
     218           0 :             if (!bWasSetTypeAttribute)
     219             :             {
     220           0 :                 rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_FLOAT);
     221           0 :                 bWasSetTypeAttribute = true;
     222           0 :                 if (bExportValue)
     223             :                 {
     224             :                     OUString sValue( ::rtl::math::doubleToUString( rValue,
     225             :                                 rtl_math_StringFormat_Automatic,
     226           0 :                                 rtl_math_DecimalPlaces_Max, '.', true));
     227           0 :                     rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE, sValue);
     228             :                 }
     229             :             }
     230             :         }
     231           0 :         break;
     232             :     }
     233           2 : }
     234             : 
     235           0 : bool XMLNumberFormatAttributesExportHelper::GetCurrencySymbol(const sal_Int32 nNumberFormat, OUString& sCurrencySymbol,
     236             :     uno::Reference <util::XNumberFormatsSupplier>& xNumberFormatsSupplier)
     237             : {
     238           0 :     if (xNumberFormatsSupplier.is())
     239             :     {
     240           0 :         uno::Reference <util::XNumberFormats> xNumberFormats(xNumberFormatsSupplier->getNumberFormats());
     241           0 :         if (xNumberFormats.is())
     242             :         {
     243             :             try
     244             :             {
     245           0 :                 uno::Reference <beans::XPropertySet> xNumberPropertySet(xNumberFormats->getByKey(nNumberFormat));
     246           0 :                 if ( xNumberPropertySet->getPropertyValue(OUString(XML_CURRENCYSYMBOL)) >>= sCurrencySymbol)
     247             :                 {
     248           0 :                     OUString sCurrencyAbbreviation;
     249           0 :                     if ( xNumberPropertySet->getPropertyValue(OUString(XML_CURRENCYABBREVIATION)) >>= sCurrencyAbbreviation)
     250             :                     {
     251           0 :                         if ( !sCurrencyAbbreviation.isEmpty())
     252           0 :                             sCurrencySymbol = sCurrencyAbbreviation;
     253             :                         else
     254             :                         {
     255           0 :                             if ( sCurrencySymbol.getLength() == 1 && sCurrencySymbol.toChar() == NfCurrencyEntry::GetEuroSymbol() )
     256           0 :                                 sCurrencySymbol = "EUR";
     257             :                         }
     258             :                     }
     259           0 :                     return true;
     260           0 :                 }
     261             :             }
     262           0 :             catch ( uno::Exception& )
     263             :             {
     264             :                 OSL_FAIL("Numberformat not found");
     265             :             }
     266           0 :         }
     267             :     }
     268           0 :     return false;
     269             : }
     270             : 
     271             : 
     272           2 : sal_Int16 XMLNumberFormatAttributesExportHelper::GetCellType(const sal_Int32 nNumberFormat, bool& bIsStandard,
     273             :     uno::Reference <util::XNumberFormatsSupplier>& xNumberFormatsSupplier)
     274             : {
     275           2 :     if (xNumberFormatsSupplier.is())
     276             :     {
     277           2 :         uno::Reference <util::XNumberFormats> xNumberFormats(xNumberFormatsSupplier->getNumberFormats());
     278           2 :         if (xNumberFormats.is())
     279             :         {
     280             :             try
     281             :             {
     282           2 :                 uno::Reference <beans::XPropertySet> xNumberPropertySet(xNumberFormats->getByKey(nNumberFormat));
     283           2 :                 xNumberPropertySet->getPropertyValue(OUString(XML_STANDARDFORMAT)) >>= bIsStandard;
     284           2 :                 sal_Int16 nNumberType = sal_Int16();
     285           2 :                 if ( xNumberPropertySet->getPropertyValue(OUString(XML_TYPE)) >>= nNumberType )
     286             :                 {
     287           2 :                     return nNumberType;
     288           0 :                 }
     289             :             }
     290           0 :             catch ( uno::Exception& )
     291             :             {
     292             :                 OSL_FAIL("Numberformat not found");
     293             :             }
     294           0 :         }
     295             :     }
     296           0 :     return 0;
     297             : }
     298             : 
     299           2 : void XMLNumberFormatAttributesExportHelper::SetNumberFormatAttributes(SvXMLExport& rXMLExport,
     300             :     const sal_Int32 nNumberFormat, const double& rValue, bool bExportValue)
     301             : {
     302             :     bool bIsStandard;
     303           2 :     sal_Int16 nTypeKey = GetCellType(nNumberFormat, bIsStandard, rXMLExport.GetNumberFormatsSupplier());
     304           2 :     OUString sCurrency;
     305           2 :     if ((nTypeKey & ~util::NumberFormat::DEFINED) == util::NumberFormat::CURRENCY)
     306           0 :         GetCurrencySymbol(nNumberFormat, sCurrency, rXMLExport.GetNumberFormatsSupplier());
     307           2 :     WriteAttributes(rXMLExport, nTypeKey, rValue, sCurrency, bExportValue);
     308           2 : }
     309             : 
     310           0 : void XMLNumberFormatAttributesExportHelper::SetNumberFormatAttributes(SvXMLExport& rXMLExport,
     311             :     const OUString& rValue, const OUString& rCharacters,
     312             :     bool bExportValue, bool bExportTypeAttribute)
     313             : {
     314           0 :     if (bExportTypeAttribute)
     315           0 :         rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_STRING);
     316           0 :     if (bExportValue && !rValue.isEmpty() && (rValue != rCharacters))
     317           0 :         rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_STRING_VALUE, rValue);
     318           0 : }
     319             : 
     320          26 : bool XMLNumberFormatAttributesExportHelper::GetCurrencySymbol(const sal_Int32 nNumberFormat, OUString& rCurrencySymbol)
     321             : {
     322          26 :     if (!xNumberFormats.is() && pExport && pExport->GetNumberFormatsSupplier().is())
     323           0 :         xNumberFormats.set(pExport->GetNumberFormatsSupplier()->getNumberFormats());
     324             : 
     325          26 :     if (xNumberFormats.is())
     326             :     {
     327             :         try
     328             :         {
     329          26 :             uno::Reference <beans::XPropertySet> xNumberPropertySet(xNumberFormats->getByKey(nNumberFormat));
     330          26 :             if ( xNumberPropertySet->getPropertyValue(msCurrencySymbol) >>= rCurrencySymbol)
     331             :             {
     332          26 :                 OUString sCurrencyAbbreviation;
     333          26 :                 if ( xNumberPropertySet->getPropertyValue(msCurrencyAbbreviation) >>= sCurrencyAbbreviation)
     334             :                 {
     335          26 :                     if ( !sCurrencyAbbreviation.isEmpty())
     336          26 :                         rCurrencySymbol = sCurrencyAbbreviation;
     337             :                     else
     338             :                     {
     339           0 :                         if ( rCurrencySymbol.getLength() == 1 && rCurrencySymbol.toChar() == NfCurrencyEntry::GetEuroSymbol() )
     340           0 :                             rCurrencySymbol = "EUR";
     341             :                     }
     342             :                 }
     343          26 :                 return true;
     344           0 :             }
     345             :         }
     346           0 :         catch ( uno::Exception& )
     347             :         {
     348             :             OSL_FAIL("Numberformat not found");
     349             :         }
     350             :     }
     351           0 :     return false;
     352             : }
     353             : 
     354         353 : sal_Int16 XMLNumberFormatAttributesExportHelper::GetCellType(const sal_Int32 nNumberFormat, bool& bIsStandard)
     355             : {
     356         353 :     if (!xNumberFormats.is() && pExport && pExport->GetNumberFormatsSupplier().is())
     357           0 :         xNumberFormats.set(pExport->GetNumberFormatsSupplier()->getNumberFormats());
     358             : 
     359         353 :     if (xNumberFormats.is())
     360             :     {
     361             :         try
     362             :         {
     363         353 :             uno::Reference <beans::XPropertySet> xNumberPropertySet(xNumberFormats->getByKey(nNumberFormat));
     364         353 :             if (xNumberPropertySet.is())
     365             :             {
     366         353 :                 xNumberPropertySet->getPropertyValue(sStandardFormat) >>= bIsStandard;
     367         353 :                 sal_Int16 nNumberType = sal_Int16();
     368         353 :                 if ( xNumberPropertySet->getPropertyValue(sType) >>= nNumberType )
     369             :                 {
     370         353 :                     return nNumberType;
     371             :                 }
     372           0 :             }
     373             :         }
     374           0 :         catch ( uno::Exception& )
     375             :         {
     376             :             OSL_FAIL("Numberformat not found");
     377             :         }
     378             :     }
     379           0 :     return 0;
     380             : }
     381             : 
     382         582 : void XMLNumberFormatAttributesExportHelper::WriteAttributes(
     383             :                                 const sal_Int16 nTypeKey,
     384             :                                 const double& rValue,
     385             :                                 const OUString& rCurrency,
     386             :                                 bool bExportValue, sal_uInt16 nNamespace)
     387             : {
     388         582 :     if (!pExport)
     389         582 :         return;
     390             : 
     391         582 :     bool bWasSetTypeAttribute = false;
     392         582 :     OUString sAttrValType = pExport->GetNamespaceMap().GetQNameByKey( nNamespace, GetXMLToken(XML_VALUE_TYPE));
     393         582 :     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         556 :             if (!bWasSetTypeAttribute)
     401             :             {
     402         556 :                 pExport->AddAttribute(sAttrValType, XML_FLOAT);
     403         556 :                 bWasSetTypeAttribute = true;
     404             :             }
     405             :         }       // No Break
     406             :     case util::NumberFormat::PERCENT:
     407             :         {
     408         566 :             if (!bWasSetTypeAttribute)
     409             :             {
     410          10 :                 pExport->AddAttribute(sAttrValType, XML_PERCENTAGE);
     411          10 :                 bWasSetTypeAttribute = true;
     412             :             }
     413             :         }       // No Break
     414             :     case util::NumberFormat::CURRENCY:
     415             :         {
     416         576 :             if (!bWasSetTypeAttribute)
     417             :             {
     418          10 :                 pExport->AddAttribute(sAttrValType, XML_CURRENCY);
     419          10 :                 if (!rCurrency.isEmpty())
     420           5 :                     pExport->AddAttribute(sAttrCurrency, rCurrency);
     421          10 :                 bWasSetTypeAttribute = true;
     422             :             }
     423             : 
     424         576 :             if (bExportValue)
     425             :             {
     426             :                 OUString sValue( ::rtl::math::doubleToUString( rValue,
     427             :                             rtl_math_StringFormat_Automatic,
     428         288 :                             rtl_math_DecimalPlaces_Max, '.', true));
     429         288 :                 pExport->AddAttribute(sAttrValue, sValue);
     430             :             }
     431             :         }
     432         576 :         break;
     433             :     case util::NumberFormat::DATE:
     434             :     case util::NumberFormat::DATETIME:
     435             :         {
     436           0 :             if (!bWasSetTypeAttribute)
     437             :             {
     438           0 :                 pExport->AddAttribute(sAttrValType, XML_DATE);
     439           0 :                 bWasSetTypeAttribute = true;
     440             :             }
     441           0 :             if (bExportValue)
     442             :             {
     443           0 :                 if ( pExport->SetNullDateOnUnitConverter() )
     444             :                 {
     445           0 :                     OUStringBuffer sBuffer;
     446           0 :                     pExport->GetMM100UnitConverter().convertDateTime(sBuffer, rValue);
     447           0 :                     pExport->AddAttribute(sAttrDateValue, sBuffer.makeStringAndClear());
     448             :                 }
     449             :             }
     450             :         }
     451           0 :         break;
     452             :     case util::NumberFormat::TIME:
     453             :         {
     454           2 :             if (!bWasSetTypeAttribute)
     455             :             {
     456           2 :                 pExport->AddAttribute(sAttrValType, XML_TIME);
     457           2 :                 bWasSetTypeAttribute = true;
     458             :             }
     459           2 :             if (bExportValue)
     460             :             {
     461           1 :                 OUStringBuffer sBuffer;
     462           1 :                 ::sax::Converter::convertDuration(sBuffer, rValue);
     463           1 :                 pExport->AddAttribute(sAttrTimeValue, sBuffer.makeStringAndClear());
     464             :             }
     465             :         }
     466           2 :         break;
     467             :     case util::NumberFormat::LOGICAL:
     468             :         {
     469           4 :             if (!bWasSetTypeAttribute)
     470             :             {
     471           4 :                 pExport->AddAttribute(sAttrValType, XML_BOOLEAN);
     472           4 :                 bWasSetTypeAttribute = true;
     473             :             }
     474           4 :             if (bExportValue)
     475             :             {
     476           2 :                 double fTempValue = rValue;
     477           2 :                 if (::rtl::math::approxEqual( fTempValue, 1.0 ))
     478             :                 {
     479           1 :                     pExport->AddAttribute(sAttrBooleanValue, XML_TRUE);
     480             :                 }
     481             :                 else
     482             :                 {
     483           1 :                     if (::rtl::math::approxEqual( rValue, 0.0 ))
     484             :                     {
     485           1 :                         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           0 :                                     true));
     494           0 :                         pExport->AddAttribute(sAttrBooleanValue, sValue);
     495             :                     }
     496             :                 }
     497             :             }
     498             :         }
     499           4 :         break;
     500             :     case util::NumberFormat::TEXT:
     501             :         {
     502           0 :             if (!bWasSetTypeAttribute)
     503             :             {
     504           0 :                 pExport->AddAttribute(sAttrValType, XML_FLOAT);
     505           0 :                 bWasSetTypeAttribute = true;
     506           0 :                 if (bExportValue)
     507             :                 {
     508             :                     OUString sValue( ::rtl::math::doubleToUString( rValue,
     509             :                                 rtl_math_StringFormat_Automatic,
     510           0 :                                 rtl_math_DecimalPlaces_Max, '.', true));
     511           0 :                     pExport->AddAttribute(sAttrValue, sValue);
     512             :                 }
     513             :             }
     514             :         }
     515           0 :         break;
     516         582 :     }
     517             : }
     518             : 
     519         582 : void XMLNumberFormatAttributesExportHelper::SetNumberFormatAttributes(
     520             :     const sal_Int32 nNumberFormat, const double& rValue, bool bExportValue,
     521             :     sal_uInt16 nNamespace, bool bExportCurrencySymbol)
     522             : {
     523         582 :     if (pExport)
     524             :     {
     525             :         bool bIsStandard;
     526         582 :         OUString sCurrency;
     527         582 :         sal_Int16 nTypeKey = GetCellType(nNumberFormat, sCurrency, bIsStandard);
     528         582 :         if(!bExportCurrencySymbol)
     529         291 :             sCurrency.clear();
     530             : 
     531         582 :         WriteAttributes(nTypeKey, rValue, sCurrency, bExportValue, nNamespace);
     532             :     }
     533             :     else {
     534             :         OSL_FAIL("no SvXMLExport given");
     535             :     }
     536         582 : }
     537             : 
     538         114 : void XMLNumberFormatAttributesExportHelper::SetNumberFormatAttributes(
     539             :     const OUString& rValue, const OUString& rCharacters,
     540             :     bool bExportValue, bool bExportTypeAttribute,
     541             :     sal_uInt16 nNamespace)
     542             : {
     543         114 :     if (pExport)
     544             :     {
     545         114 :         if (bExportTypeAttribute)
     546         114 :             pExport->AddAttribute(nNamespace, XML_VALUE_TYPE, XML_STRING);
     547         114 :         if (bExportValue && !rValue.isEmpty() && (rValue != rCharacters))
     548           1 :             pExport->AddAttribute(sAttrStringValue, rValue);
     549             :     }
     550             :     else {
     551             :         OSL_FAIL("no SvXMLExport given");
     552             :     }
     553         114 : }
     554             : 
     555             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11