svl/source/numbers/numfmuno.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 #include <tools/color.hxx>
  21 #include <o3tl/any.hxx>
  22 #include <osl/mutex.hxx>
  23 #include <osl/diagnose.h>
  24 #include <rtl/ustring.hxx>
  25
  26 #include <com/sun/star/util/Date.hpp>
  27 #include <com/sun/star/util/MalformedNumberFormatException.hpp>
  28 #include <com/sun/star/util/NotNumericException.hpp>
  29 #include <com/sun/star/beans/PropertyAttribute.hpp>
  30 #include <comphelper/propertysequence.hxx>
  31 #include <cppuhelper/supportsservice.hxx>
  32
  33 #include "numfmuno.hxx"
  34 #include <svl/numformat.hxx>
  35 #include <svl/numuno.hxx>
  36 #include <svl/zforlist.hxx>
  37 #include <svl/zformat.hxx>
  38 #include <svl/itemprop.hxx>
  39
  40 using namespace com::sun::star;
  41
  42 constexpr OUStringLiteral PROPERTYNAME_FMTSTR = u"FormatString";
  43 constexpr OUStringLiteral PROPERTYNAME_LOCALE = u"Locale";
  44 constexpr OUStringLiteral PROPERTYNAME_TYPE = u"Type";
  45 constexpr OUStringLiteral PROPERTYNAME_COMMENT = u"Comment";
  46 constexpr OUStringLiteral PROPERTYNAME_CURREXT = u"CurrencyExtension";
  47 constexpr OUStringLiteral PROPERTYNAME_CURRSYM = u"CurrencySymbol";
  48 constexpr OUStringLiteral PROPERTYNAME_CURRABB = u"CurrencyAbbreviation";
  49 constexpr OUStringLiteral PROPERTYNAME_DECIMALS = u"Decimals";
  50 constexpr OUStringLiteral PROPERTYNAME_LEADING = u"LeadingZeros";
  51 constexpr OUStringLiteral PROPERTYNAME_NEGRED = u"NegativeRed";
  52 constexpr OUStringLiteral PROPERTYNAME_STDFORM = u"StandardFormat";
  53 constexpr OUStringLiteral PROPERTYNAME_THOUS = u"ThousandsSeparator";
  54 constexpr OUStringLiteral PROPERTYNAME_USERDEF = u"UserDefined";
  55
  56 constexpr OUStringLiteral PROPERTYNAME_NOZERO = u"NoZero";
  57 constexpr OUStringLiteral PROPERTYNAME_NULLDATE = u"NullDate";
  58 constexpr OUStringLiteral PROPERTYNAME_STDDEC = u"StandardDecimals";
  59 constexpr OUStringLiteral PROPERTYNAME_TWODIGIT = u"TwoDigitDateStart";
  60
  61 // All without a Which-ID, Map only for PropertySetInfo
  62
  63 static const SfxItemPropertyMapEntry* lcl_GetNumberFormatPropertyMap()
  64 {
  65     static const SfxItemPropertyMapEntry aNumberFormatPropertyMap_Impl[] =
  66     {
  67         {PROPERTYNAME_FMTSTR,   0, cppu::UnoType<OUString>::get(),    beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY, 0},
  68         {PROPERTYNAME_LOCALE,   0, cppu::UnoType<lang::Locale>::get(),beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY, 0},
  69         {PROPERTYNAME_TYPE,     0, cppu::UnoType<sal_Int16>::get(),   beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY, 0},
  70         {PROPERTYNAME_COMMENT,  0, cppu::UnoType<OUString>::get(),    beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY, 0},
  71         {PROPERTYNAME_CURREXT,  0, cppu::UnoType<OUString>::get(),    beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY, 0},
  72         {PROPERTYNAME_CURRSYM,  0, cppu::UnoType<OUString>::get(),    beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY, 0},
  73         {PROPERTYNAME_DECIMALS, 0, cppu::UnoType<sal_Int16>::get(),   beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY, 0},
  74         {PROPERTYNAME_LEADING,  0, cppu::UnoType<sal_Int16>::get(),   beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY, 0},
  75         {PROPERTYNAME_NEGRED,   0, cppu::UnoType<bool>::get(),         beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY, 0},
  76         {PROPERTYNAME_STDFORM,  0, cppu::UnoType<bool>::get(),         beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY, 0},
  77         {PROPERTYNAME_THOUS,    0, cppu::UnoType<bool>::get(),         beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY, 0},
  78         {PROPERTYNAME_USERDEF,  0, cppu::UnoType<bool>::get(),         beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY, 0},
  79         {PROPERTYNAME_CURRABB,  0, cppu::UnoType<OUString>::get(),    beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY, 0},
  80         { u"", 0, css::uno::Type(), 0, 0 }
  81     };
  82     return aNumberFormatPropertyMap_Impl;
  83 }
  84
  85 static const SfxItemPropertyMapEntry* lcl_GetNumberSettingsPropertyMap()
  86 {
  87     static const SfxItemPropertyMapEntry aNumberSettingsPropertyMap_Impl[] =
  88     {
  89         {PROPERTYNAME_NOZERO,   0, cppu::UnoType<bool>::get(),         beans::PropertyAttribute::BOUND, 0},
  90         {PROPERTYNAME_NULLDATE, 0, cppu::UnoType<util::Date>::get(),  beans::PropertyAttribute::BOUND, 0},
  91         {PROPERTYNAME_STDDEC,   0, cppu::UnoType<sal_Int16>::get(),   beans::PropertyAttribute::BOUND, 0},
  92         {PROPERTYNAME_TWODIGIT, 0, cppu::UnoType<sal_Int16>::get(),   beans::PropertyAttribute::BOUND, 0},
  93         { u"", 0, css::uno::Type(), 0, 0 }
  94     };
  95     return aNumberSettingsPropertyMap_Impl;
  96 }
  97
  98 static LanguageType lcl_GetLanguage( const lang::Locale& rLocale )
  99 {
 100     LanguageType eRet = LanguageTag::convertToLanguageTypeWithFallback( rLocale, false);
 101     if ( eRet == LANGUAGE_NONE )
 102         eRet = LANGUAGE_SYSTEM; //! or throw an exception?
 103
 104     return eRet;
 105 }
 106
 107 SvNumberFormatterServiceObj::SvNumberFormatterServiceObj()
 108 {
 109 }
 110
 111 SvNumberFormatterServiceObj::~SvNumberFormatterServiceObj()
 112 {
 113 }
 114
 115 // XNumberFormatter
 116
 117 void SAL_CALL SvNumberFormatterServiceObj::attachNumberFormatsSupplier( const uno::Reference<util::XNumberFormatsSupplier>& _xSupplier )
 118 {
 119     ::rtl::Reference< SvNumberFormatsSupplierObj > xAutoReleaseOld;
 120
 121     // SYNCHRONIZED ->
 122     {
 123         ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
 124
 125         SvNumberFormatsSupplierObj* pNew = comphelper::getFromUnoTunnel<SvNumberFormatsSupplierObj>( _xSupplier );
 126         if (!pNew)
 127             throw uno::RuntimeException(); // wrong object
 128
 129         xAutoReleaseOld = xSupplier;
 130
 131         xSupplier = pNew;
 132         m_aMutex = xSupplier->getSharedMutex();
 133     }
 134     // <- SYNCHRONIZED
 135 }
 136
 137 uno::Reference<util::XNumberFormatsSupplier> SAL_CALL SvNumberFormatterServiceObj::getNumberFormatsSupplier()
 138 {
 139     ::osl::MutexGuard aGuard( m_aMutex );
 140     return xSupplier;
 141 }
 142
 143 sal_Int32 SAL_CALL SvNumberFormatterServiceObj::detectNumberFormat( sal_Int32 nKey, const OUString& aString )
 144 {
 145     ::osl::MutexGuard aGuard( m_aMutex );
 146
 147     SvNumberFormatter* pFormatter = xSupplier.is() ? xSupplier->GetNumberFormatter() : nullptr;
 148     if (!pFormatter)
 149         throw uno::RuntimeException();
 150
 151     sal_uInt32 nUKey = nKey;
 152     double fValue = 0.0;
 153     if ( !pFormatter->IsNumberFormat(aString, nUKey, fValue) )
 154         throw util::NotNumericException();
 155
 156     return nUKey;
 157 }
 158
 159 double SAL_CALL SvNumberFormatterServiceObj::convertStringToNumber( sal_Int32 nKey, const OUString& aString )
 160 {
 161     ::osl::MutexGuard aGuard( m_aMutex );
 162
 163     SvNumberFormatter* pFormatter = xSupplier.is() ? xSupplier->GetNumberFormatter() : nullptr;
 164     if (!pFormatter)
 165         throw uno::RuntimeException();
 166
 167     sal_uInt32 nUKey = nKey;
 168     double fValue = 0.0;
 169     if ( !pFormatter->IsNumberFormat(aString, nUKey, fValue) )
 170         throw util::NotNumericException();
 171
 172     return fValue;
 173 }
 174
 175 OUString SAL_CALL SvNumberFormatterServiceObj::convertNumberToString( sal_Int32 nKey, double fValue )
 176 {
 177     ::osl::MutexGuard aGuard( m_aMutex );
 178
 179     OUString aRet;
 180     SvNumberFormatter* pFormatter = xSupplier.is() ? xSupplier->GetNumberFormatter() : nullptr;
 181     if (!pFormatter)
 182         throw uno::RuntimeException();
 183
 184     const Color* pColor = nullptr;
 185     pFormatter->GetOutputString(fValue, nKey, aRet, &pColor);
 186
 187     return aRet;
 188 }
 189
 190 sal_Int32 SAL_CALL SvNumberFormatterServiceObj::queryColorForNumber( sal_Int32 nKey,
 191                                                                        double fValue,
 192                                                                        sal_Int32 aDefaultColor )
 193 {
 194     ::osl::MutexGuard aGuard( m_aMutex );
 195
 196     util::Color nRet = aDefaultColor; // color = sal_Int32
 197     SvNumberFormatter* pFormatter = xSupplier.is() ? xSupplier->GetNumberFormatter() : nullptr;
 198     if (!pFormatter)
 199         throw uno::RuntimeException();
 200
 201     OUString aStr;
 202     const Color* pColor = nullptr;
 203     pFormatter->GetOutputString(fValue, nKey, aStr, &pColor);
 204     if (pColor)
 205         nRet = sal_uInt32(*pColor);
 206     // Else keep Default
 207
 208     return nRet;
 209 }
 210
 211 OUString SAL_CALL SvNumberFormatterServiceObj::formatString( sal_Int32 nKey,
 212                                                              const OUString& aString )
 213 {
 214     ::osl::MutexGuard aGuard( m_aMutex );
 215
 216     OUString aRet;
 217     SvNumberFormatter* pFormatter = xSupplier.is() ? xSupplier->GetNumberFormatter() : nullptr;
 218     if (!pFormatter)
 219     {
 220         throw uno::RuntimeException();
 221     }
 222
 223     const Color* pColor = nullptr;
 224     pFormatter->GetOutputString(aString, nKey, aRet, &pColor);
 225
 226     return aRet;
 227 }
 228
 229 sal_Int32 SAL_CALL SvNumberFormatterServiceObj::queryColorForString( sal_Int32 nKey,
 230                                                                        const OUString& aString,
 231                                                                        sal_Int32 aDefaultColor )
 232 {
 233     ::osl::MutexGuard aGuard( m_aMutex );
 234
 235     util::Color nRet = aDefaultColor; // color = sal_Int32
 236     SvNumberFormatter* pFormatter = xSupplier.is() ? xSupplier->GetNumberFormatter() : nullptr;
 237     if (!pFormatter)
 238     {
 239         throw uno::RuntimeException();
 240     }
 241
 242     OUString aStr;
 243     const Color* pColor = nullptr;
 244     pFormatter->GetOutputString(aString, nKey, aStr, &pColor);
 245     if (pColor)
 246     {
 247         nRet = sal_uInt32(*pColor);
 248     }
 249     // Else keep Default
 250
 251     return nRet;
 252 }
 253
 254 OUString SAL_CALL SvNumberFormatterServiceObj::getInputString( sal_Int32 nKey, double fValue )
 255 {
 256     ::osl::MutexGuard aGuard( m_aMutex );
 257
 258     OUString aRet;
 259     SvNumberFormatter* pFormatter = xSupplier.is() ? xSupplier->GetNumberFormatter() : nullptr;
 260     if (!pFormatter)
 261         throw uno::RuntimeException();
 262
 263     pFormatter->GetInputLineString(fValue, nKey, aRet);
 264
 265     return aRet;
 266 }
 267
 268 // XNumberFormatPreviewer
 269
 270 OUString SAL_CALL SvNumberFormatterServiceObj::convertNumberToPreviewString( const OUString& aFormat,
 271                                                                              double fValue,
 272                                                                              const lang::Locale& nLocale,
 273                                                                              sal_Bool bAllowEnglish )
 274 {
 275     ::osl::MutexGuard aGuard( m_aMutex );
 276
 277     OUString aRet;
 278     SvNumberFormatter* pFormatter = xSupplier.is() ? xSupplier->GetNumberFormatter() : nullptr;
 279     if (!pFormatter)
 280         throw uno::RuntimeException();
 281
 282     LanguageType eLang = lcl_GetLanguage( nLocale );
 283     const Color* pColor = nullptr;
 284
 285     bool bOk;
 286     if ( bAllowEnglish )
 287         bOk = pFormatter->GetPreviewStringGuess( aFormat, fValue, aRet, &pColor, eLang );
 288     else
 289         bOk = pFormatter->GetPreviewString( aFormat, fValue, aRet, &pColor, eLang );
 290
 291     if (!bOk)
 292         throw util::MalformedNumberFormatException();
 293
 294     return aRet;
 295 }
 296
 297 sal_Int32 SAL_CALL SvNumberFormatterServiceObj::queryPreviewColorForNumber( const OUString& aFormat,
 298                                                                               double fValue,
 299                                                                               const lang::Locale& nLocale,
 300                                                                               sal_Bool bAllowEnglish,
 301                                                                               sal_Int32 aDefaultColor )
 302 {
 303     ::osl::MutexGuard aGuard( m_aMutex );
 304
 305     util::Color nRet = aDefaultColor; // color = sal_Int32
 306     SvNumberFormatter* pFormatter = xSupplier.is() ? xSupplier->GetNumberFormatter() : nullptr;
 307     if (!pFormatter)
 308         throw uno::RuntimeException();
 309
 310     OUString aOutString;
 311     LanguageType eLang = lcl_GetLanguage( nLocale );
 312     const Color* pColor = nullptr;
 313
 314     bool bOk;
 315     if ( bAllowEnglish )
 316         bOk = pFormatter->GetPreviewStringGuess( aFormat, fValue, aOutString, &pColor, eLang );
 317     else
 318         bOk = pFormatter->GetPreviewString( aFormat, fValue, aOutString, &pColor, eLang );
 319
 320     if (!bOk)
 321         throw util::MalformedNumberFormatException();
 322
 323     if (pColor)
 324         nRet = sal_uInt32(*pColor);
 325     // Else keep Default
 326
 327     return nRet;
 328 }
 329
 330 // XServiceInfo
 331
 332 OUString SAL_CALL SvNumberFormatterServiceObj::getImplementationName()
 333 {
 334     return "com.sun.star.uno.util.numbers.SvNumberFormatterServiceObject";
 335 }
 336
 337 sal_Bool SAL_CALL SvNumberFormatterServiceObj::supportsService( const OUString& ServiceName )
 338 {
 339     return cppu::supportsService( this, ServiceName );
 340 }
 341
 342 uno::Sequence<OUString> SAL_CALL SvNumberFormatterServiceObj::getSupportedServiceNames()
 343 {
 344     return { "com.sun.star.util.NumberFormatter" };
 345 }
 346
 347 SvNumberFormatsObj::SvNumberFormatsObj( SvNumberFormatsSupplierObj& _rParent, ::comphelper::SharedMutex const & _rMutex )
 348     :m_xSupplier( &_rParent )
 349     ,m_aMutex( _rMutex )
 350 {
 351 }
 352
 353 SvNumberFormatsObj::~SvNumberFormatsObj()
 354 {
 355 }
 356
 357 // XNumberFormats
 358
 359 uno::Reference<beans::XPropertySet> SAL_CALL SvNumberFormatsObj::getByKey( sal_Int32 nKey )
 360 {
 361     ::osl::MutexGuard aGuard( m_aMutex );
 362
 363     SvNumberFormatter* pFormatter = m_xSupplier->GetNumberFormatter();
 364     const SvNumberformat* pFormat = pFormatter ? pFormatter->GetEntry(nKey) : nullptr;
 365     if (!pFormat)
 366         throw uno::RuntimeException();
 367
 368     return new SvNumberFormatObj( *m_xSupplier, nKey, m_aMutex );
 369 }
 370
 371 uno::Sequence<sal_Int32> SAL_CALL SvNumberFormatsObj::queryKeys( sal_Int16 nType,
 372                                                                  const lang::Locale& nLocale,
 373                                                                  sal_Bool bCreate )
 374 {
 375     ::osl::MutexGuard aGuard( m_aMutex );
 376
 377     SvNumberFormatter* pFormatter = m_xSupplier->GetNumberFormatter();
 378     if ( !pFormatter )
 379         throw uno::RuntimeException();
 380
 381     sal_uInt32 nIndex = 0;
 382     LanguageType eLang = lcl_GetLanguage( nLocale );
 383     SvNumberFormatTable& rTable = bCreate ?
 384                                     pFormatter->ChangeCL( static_cast<SvNumFormatType>(nType), nIndex, eLang ) :
 385                                     pFormatter->GetEntryTable( static_cast<SvNumFormatType>(nType), nIndex, eLang );
 386     sal_uInt32 nCount = rTable.size();
 387     uno::Sequence<sal_Int32> aSeq(nCount);
 388     sal_Int32* pAry = aSeq.getArray();
 389     sal_uInt32 i=0;
 390     for (const auto& rEntry : rTable)
 391     {
 392         pAry[i] = rEntry.first;
 393         ++i;
 394     }
 395     return aSeq;
 396 }
 397
 398 sal_Int32 SAL_CALL SvNumberFormatsObj::queryKey( const OUString& aFormat,
 399                                                  const lang::Locale& nLocale,
 400                                                  sal_Bool bScan )
 401 {
 402     ::osl::MutexGuard aGuard( m_aMutex );
 403
 404     SvNumberFormatter* pFormatter = m_xSupplier->GetNumberFormatter();
 405     if (!pFormatter)
 406         throw uno::RuntimeException();
 407
 408     LanguageType eLang = lcl_GetLanguage( nLocale );
 409     if (bScan)
 410     {
 411         //! FIXME: Something still needs to happen here ...
 412     }
 413     sal_Int32 nRet = pFormatter->GetEntryKey( aFormat, eLang );
 414     return nRet;
 415 }
 416
 417 sal_Int32 SAL_CALL SvNumberFormatsObj::addNew( const OUString& aFormat,
 418                                                const lang::Locale& nLocale )
 419 {
 420     ::osl::MutexGuard aGuard( m_aMutex );
 421
 422     sal_Int32 nRet = 0;
 423     SvNumberFormatter* pFormatter = m_xSupplier->GetNumberFormatter();
 424     if (!pFormatter)
 425         throw uno::RuntimeException();
 426
 427     OUString aFormStr = aFormat;
 428     LanguageType eLang = lcl_GetLanguage( nLocale );
 429     sal_uInt32 nKey = 0;
 430     sal_Int32 nCheckPos = 0;
 431     SvNumFormatType nType = SvNumFormatType::ALL;
 432     bool bOk = pFormatter->PutEntry( aFormStr, nCheckPos, nType, nKey, eLang );
 433     if (bOk)
 434         nRet = nKey;
 435     else if (nCheckPos)
 436     {
 437         throw util::MalformedNumberFormatException(); // Invalid Format
 438     }
 439     else
 440         throw uno::RuntimeException(); // Other error (e.g. already added)
 441
 442     return nRet;
 443 }
 444
 445 sal_Int32 SAL_CALL SvNumberFormatsObj::addNewConverted( const OUString& aFormat,
 446                                                         const lang::Locale& nLocale,
 447                                                         const lang::Locale& nNewLocale )
 448 {
 449     ::osl::MutexGuard aGuard( m_aMutex );
 450
 451     sal_Int32 nRet = 0;
 452     SvNumberFormatter* pFormatter = m_xSupplier->GetNumberFormatter();
 453     if (!pFormatter)
 454         throw uno::RuntimeException();
 455
 456     OUString aFormStr = aFormat;
 457     LanguageType eLang = lcl_GetLanguage( nLocale );
 458     LanguageType eNewLang = lcl_GetLanguage( nNewLocale );
 459     sal_uInt32 nKey = 0;
 460     sal_Int32 nCheckPos = 0;
 461     SvNumFormatType nType = SvNumFormatType::ALL;
 462     // This is used also when reading OOXML documents, there's no indicator
 463     // whether to convert date particle order as well, so don't. See tdf#119013
 464     bool bOk = pFormatter->PutandConvertEntry( aFormStr, nCheckPos, nType, nKey, eLang, eNewLang, false);
 465     if (bOk || nKey > 0)
 466         nRet = nKey;
 467     else if (nCheckPos)
 468     {
 469         throw util::MalformedNumberFormatException();       // Invalid format
 470     }
 471     else
 472         throw uno::RuntimeException(); // Other error (e.g. already added)
 473
 474     return nRet;
 475 }
 476
 477 void SAL_CALL SvNumberFormatsObj::removeByKey( sal_Int32 nKey )
 478 {
 479     ::osl::MutexGuard aGuard( m_aMutex );
 480     SvNumberFormatter* pFormatter = m_xSupplier->GetNumberFormatter();
 481
 482     if (pFormatter)
 483     {
 484         pFormatter->DeleteEntry(nKey);
 485     }
 486 }
 487
 488 OUString SAL_CALL SvNumberFormatsObj::generateFormat( sal_Int32 nBaseKey,
 489                                                       const lang::Locale& nLocale,
 490                                                       sal_Bool bThousands,
 491                                                       sal_Bool bRed, sal_Int16 nDecimals,
 492                                                       sal_Int16 nLeading )
 493 {
 494     ::osl::MutexGuard aGuard( m_aMutex );
 495
 496     SvNumberFormatter* pFormatter = m_xSupplier->GetNumberFormatter();
 497     if (!pFormatter)
 498         throw uno::RuntimeException();
 499
 500     LanguageType eLang = lcl_GetLanguage( nLocale );
 501     OUString aRet = pFormatter->GenerateFormat(nBaseKey, eLang, bThousands, bRed, nDecimals, nLeading);
 502     return aRet;
 503 }
 504
 505 // XNumberFormatTypes
 506
 507 sal_Int32 SAL_CALL SvNumberFormatsObj::getStandardIndex( const lang::Locale& nLocale )
 508 {
 509     ::osl::MutexGuard aGuard( m_aMutex );
 510
 511     SvNumberFormatter* pFormatter = m_xSupplier->GetNumberFormatter();
 512     if (!pFormatter)
 513         throw uno::RuntimeException();
 514
 515     LanguageType eLang = lcl_GetLanguage( nLocale );
 516     sal_Int32 nRet = pFormatter->GetStandardIndex(eLang);
 517     return nRet;
 518 }
 519
 520 sal_Int32 SAL_CALL SvNumberFormatsObj::getStandardFormat( sal_Int16 nType, const lang::Locale& nLocale )
 521 {
 522     ::osl::MutexGuard aGuard( m_aMutex );
 523
 524     SvNumberFormatter* pFormatter = m_xSupplier->GetNumberFormatter();
 525     if (!pFormatter)
 526         throw uno::RuntimeException();
 527
 528     LanguageType eLang = lcl_GetLanguage( nLocale );
 529     // Mask out "defined" bit, so type from an existing number format
 530     // can directly be used for getStandardFormat
 531     SvNumFormatType nType2 = static_cast<SvNumFormatType>(nType);
 532     nType2 &= ~SvNumFormatType::DEFINED;
 533     sal_Int32 nRet = pFormatter->GetStandardFormat(nType2, eLang);
 534     return nRet;
 535 }
 536
 537 sal_Int32 SAL_CALL SvNumberFormatsObj::getFormatIndex( sal_Int16 nIndex, const lang::Locale& nLocale )
 538 {
 539     ::osl::MutexGuard aGuard( m_aMutex );
 540
 541     SvNumberFormatter* pFormatter = m_xSupplier->GetNumberFormatter();
 542     if (!pFormatter)
 543         throw uno::RuntimeException();
 544
 545     LanguageType eLang = lcl_GetLanguage( nLocale );
 546     sal_Int32 nRet = pFormatter->GetFormatIndex( static_cast<NfIndexTableOffset>(nIndex), eLang );
 547     return nRet;
 548 }
 549
 550 sal_Bool SAL_CALL SvNumberFormatsObj::isTypeCompatible( sal_Int16 nOldType, sal_Int16 nNewType )
 551 {
 552     ::osl::MutexGuard aGuard( m_aMutex );
 553
 554     return SvNumberFormatter::IsCompatible( static_cast<SvNumFormatType>(nOldType), static_cast<SvNumFormatType>(nNewType) );
 555 }
 556
 557 sal_Int32 SAL_CALL SvNumberFormatsObj::getFormatForLocale( sal_Int32 nKey, const lang::Locale& nLocale )
 558 {
 559     ::osl::MutexGuard aGuard( m_aMutex );
 560
 561     SvNumberFormatter* pFormatter = m_xSupplier->GetNumberFormatter();
 562     if (!pFormatter)
 563         throw uno::RuntimeException();
 564
 565     LanguageType eLang = lcl_GetLanguage( nLocale );
 566     sal_Int32 nRet = pFormatter->GetFormatForLanguageIfBuiltIn(nKey, eLang);
 567     return nRet;
 568 }
 569
 570 // XServiceInfo
 571
 572 OUString SAL_CALL SvNumberFormatsObj::getImplementationName()
 573 {
 574     return "SvNumberFormatsObj";
 575 }
 576
 577 sal_Bool SAL_CALL SvNumberFormatsObj::supportsService( const OUString& ServiceName )
 578 {
 579     return cppu::supportsService( this, ServiceName );
 580 }
 581
 582 uno::Sequence<OUString> SAL_CALL SvNumberFormatsObj::getSupportedServiceNames()
 583 {
 584     return { "com.sun.star.util.NumberFormats" };
 585 }
 586
 587 SvNumberFormatObj::SvNumberFormatObj( SvNumberFormatsSupplierObj& rParent, sal_uLong nK, const ::comphelper::SharedMutex& _rMutex )
 588     :m_xSupplier( &rParent )
 589     ,nKey( nK )
 590     ,m_aMutex( _rMutex )
 591 {
 592 }
 593
 594 SvNumberFormatObj::~SvNumberFormatObj()
 595 {
 596 }
 597
 598 // XPropertySet
 599
 600 uno::Reference<beans::XPropertySetInfo> SAL_CALL SvNumberFormatObj::getPropertySetInfo()
 601 {
 602     static uno::Reference<beans::XPropertySetInfo> aRef =
 603         new SfxItemPropertySetInfo( lcl_GetNumberFormatPropertyMap() );
 604     return aRef;
 605 }
 606
 607 void SAL_CALL SvNumberFormatObj::setPropertyValue( const OUString&,
 608                                                    const uno::Any& )
 609 {
 610     throw beans::UnknownPropertyException(); // Everything is read-only
 611 }
 612
 613 uno::Any SAL_CALL SvNumberFormatObj::getPropertyValue( const OUString& aPropertyName )
 614 {
 615     ::osl::MutexGuard aGuard( m_aMutex );
 616
 617     uno::Any aRet;
 618     SvNumberFormatter* pFormatter = m_xSupplier->GetNumberFormatter();
 619     const SvNumberformat* pFormat = pFormatter ? pFormatter->GetEntry(nKey) : nullptr;
 620     if (!pFormat)
 621         throw uno::RuntimeException();
 622
 623     bool bThousand, bRed;
 624     sal_uInt16 nDecimals, nLeading;
 625
 626     if (aPropertyName == PROPERTYNAME_FMTSTR)
 627     {
 628         aRet <<= pFormat->GetFormatstring();
 629     }
 630     else if (aPropertyName == PROPERTYNAME_LOCALE)
 631     {
 632         lang::Locale aLocale( LanguageTag::convertToLocale( pFormat->GetLanguage(), false));
 633         aRet <<= aLocale;
 634     }
 635     else if (aPropertyName == PROPERTYNAME_TYPE)
 636     {
 637         aRet <<= static_cast<sal_Int16>( pFormat->GetType() );
 638     }
 639     else if (aPropertyName == PROPERTYNAME_COMMENT)
 640     {
 641         aRet <<= pFormat->GetComment();
 642     }
 643     else if (aPropertyName == PROPERTYNAME_STDFORM)
 644     {
 645         //! Pass through SvNumberformat Member bStandard?
 646         aRet <<= ( ( nKey % SV_COUNTRY_LANGUAGE_OFFSET ) == 0 );
 647     }
 648     else if (aPropertyName == PROPERTYNAME_USERDEF)
 649     {
 650         aRet <<= bool( pFormat->GetType() & SvNumFormatType::DEFINED );
 651     }
 652     else if (aPropertyName == PROPERTYNAME_DECIMALS)
 653     {
 654         pFormat->GetFormatSpecialInfo( bThousand, bRed, nDecimals, nLeading );
 655         aRet <<= static_cast<sal_Int16>(nDecimals);
 656     }
 657     else if (aPropertyName == PROPERTYNAME_LEADING)
 658     {
 659         pFormat->GetFormatSpecialInfo( bThousand, bRed, nDecimals, nLeading );
 660         aRet <<= static_cast<sal_Int16>(nLeading);
 661     }
 662     else if (aPropertyName == PROPERTYNAME_NEGRED)
 663     {
 664         pFormat->GetFormatSpecialInfo( bThousand, bRed, nDecimals, nLeading );
 665         aRet <<= bRed;
 666     }
 667     else if (aPropertyName == PROPERTYNAME_THOUS)
 668     {
 669         pFormat->GetFormatSpecialInfo( bThousand, bRed, nDecimals, nLeading );
 670         aRet <<= bThousand;
 671     }
 672     else if (aPropertyName == PROPERTYNAME_CURRSYM)
 673     {
 674         OUString aSymbol, aExt;
 675         pFormat->GetNewCurrencySymbol( aSymbol, aExt );
 676         aRet <<= aSymbol;
 677     }
 678     else if (aPropertyName == PROPERTYNAME_CURREXT)
 679     {
 680         OUString aSymbol, aExt;
 681         pFormat->GetNewCurrencySymbol( aSymbol, aExt );
 682         aRet <<= aExt;
 683     }
 684     else if (aPropertyName == PROPERTYNAME_CURRABB)
 685     {
 686         OUString aSymbol, aExt;
 687         bool bBank = false;
 688         pFormat->GetNewCurrencySymbol( aSymbol, aExt );
 689         const NfCurrencyEntry* pCurr = SvNumberFormatter::GetCurrencyEntry( bBank,
 690             aSymbol, aExt, pFormat->GetLanguage() );
 691         if ( pCurr )
 692             aRet <<= pCurr->GetBankSymbol();
 693         else
 694             aRet <<= OUString();
 695     }
 696     else
 697         throw beans::UnknownPropertyException(aPropertyName);
 698
 699     return aRet;
 700 }
 701
 702 void SAL_CALL SvNumberFormatObj::addPropertyChangeListener( const OUString&,
 703                                                             const uno::Reference<beans::XPropertyChangeListener>&)
 704 {
 705     OSL_FAIL("not implemented");
 706 }
 707
 708 void SAL_CALL SvNumberFormatObj::removePropertyChangeListener( const OUString&,
 709                                                                const uno::Reference<beans::XPropertyChangeListener>&)
 710 {
 711     OSL_FAIL("not implemented");
 712 }
 713
 714 void SAL_CALL SvNumberFormatObj::addVetoableChangeListener( const OUString&,
 715                                                             const uno::Reference<beans::XVetoableChangeListener>&)
 716 {
 717     OSL_FAIL("not implemented");
 718 }
 719
 720 void SAL_CALL SvNumberFormatObj::removeVetoableChangeListener( const OUString&,
 721                                                                const uno::Reference<beans::XVetoableChangeListener>&)
 722 {
 723     OSL_FAIL("not implemented");
 724 }
 725
 726 // XPropertyAccess
 727
 728 uno::Sequence<beans::PropertyValue> SAL_CALL SvNumberFormatObj::getPropertyValues()
 729 {
 730     ::osl::MutexGuard aGuard( m_aMutex );
 731
 732     SvNumberFormatter* pFormatter = m_xSupplier->GetNumberFormatter();
 733     const SvNumberformat* pFormat = pFormatter ? pFormatter->GetEntry(nKey) : nullptr;
 734     if (!pFormat)
 735         throw uno::RuntimeException();
 736
 737     OUString aSymbol, aExt;
 738     OUString aAbb;
 739     bool bBank = false;
 740     pFormat->GetNewCurrencySymbol( aSymbol, aExt );
 741     const NfCurrencyEntry* pCurr = SvNumberFormatter::GetCurrencyEntry( bBank,
 742         aSymbol, aExt, pFormat->GetLanguage() );
 743     if ( pCurr )
 744         aAbb = pCurr->GetBankSymbol();
 745
 746     OUString aFmtStr = pFormat->GetFormatstring();
 747     OUString aComment = pFormat->GetComment();
 748     bool bStandard = ( ( nKey % SV_COUNTRY_LANGUAGE_OFFSET ) == 0 );
 749     //! Pass through SvNumberformat Member bStandard?
 750     bool bUserDef( pFormat->GetType() & SvNumFormatType::DEFINED );
 751     bool bThousand, bRed;
 752     sal_uInt16 nDecimals, nLeading;
 753     pFormat->GetFormatSpecialInfo( bThousand, bRed, nDecimals, nLeading );
 754     lang::Locale aLocale( LanguageTag( pFormat->GetLanguage()).getLocale());
 755
 756     uno::Sequence<beans::PropertyValue> aSeq( comphelper::InitPropertySequence({
 757             { PROPERTYNAME_FMTSTR, uno::Any(aFmtStr) },
 758             { PROPERTYNAME_LOCALE, uno::Any(aLocale) },
 759             { PROPERTYNAME_TYPE, uno::Any(sal_Int16( pFormat->GetType() )) },
 760             { PROPERTYNAME_COMMENT, uno::Any(aComment) },
 761             { PROPERTYNAME_STDFORM, uno::Any(bStandard) },
 762             { PROPERTYNAME_USERDEF, uno::Any(bUserDef) },
 763             { PROPERTYNAME_DECIMALS, uno::Any(sal_Int16( nDecimals )) },
 764             { PROPERTYNAME_LEADING, uno::Any(sal_Int16( nLeading )) },
 765             { PROPERTYNAME_NEGRED, uno::Any(bRed) },
 766             { PROPERTYNAME_THOUS, uno::Any(bThousand) },
 767             { PROPERTYNAME_CURRSYM, uno::Any(aSymbol) },
 768             { PROPERTYNAME_CURREXT, uno::Any(aExt) },
 769             { PROPERTYNAME_CURRABB, uno::Any(aAbb) }
 770         }));
 771
 772     return aSeq;
 773 }
 774
 775 void SAL_CALL SvNumberFormatObj::setPropertyValues( const uno::Sequence<beans::PropertyValue>& )
 776 {
 777     throw beans::UnknownPropertyException(); // Everything is read-only
 778 }
 779
 780 // XServiceInfo
 781
 782 OUString SAL_CALL SvNumberFormatObj::getImplementationName()
 783 {
 784     return "SvNumberFormatObj";
 785 }
 786
 787 sal_Bool SAL_CALL SvNumberFormatObj::supportsService( const OUString& ServiceName )
 788 {
 789     return cppu::supportsService( this, ServiceName );
 790 }
 791
 792 uno::Sequence<OUString> SAL_CALL SvNumberFormatObj::getSupportedServiceNames()
 793 {
 794     return { "com.sun.star.util.NumberFormatProperties" };
 795 }
 796
 797 SvNumberFormatSettingsObj::SvNumberFormatSettingsObj( SvNumberFormatsSupplierObj& rParent, const ::comphelper::SharedMutex& _rMutex )
 798     :m_xSupplier( &rParent )
 799     ,m_aMutex( _rMutex )
 800 {
 801 }
 802
 803 SvNumberFormatSettingsObj::~SvNumberFormatSettingsObj()
 804 {
 805 }
 806
 807 // XPropertySet
 808
 809 uno::Reference<beans::XPropertySetInfo> SAL_CALL SvNumberFormatSettingsObj::getPropertySetInfo()
 810 {
 811     static uno::Reference<beans::XPropertySetInfo> aRef =
 812         new SfxItemPropertySetInfo( lcl_GetNumberSettingsPropertyMap() );
 813     return aRef;
 814 }
 815
 816 void SAL_CALL SvNumberFormatSettingsObj::setPropertyValue( const OUString& aPropertyName,
 817                                                            const uno::Any& aValue )
 818 {
 819     ::osl::MutexGuard aGuard( m_aMutex );
 820
 821     SvNumberFormatter* pFormatter = m_xSupplier->GetNumberFormatter();
 822     if (!pFormatter)
 823         throw uno::RuntimeException();
 824
 825     if (aPropertyName == PROPERTYNAME_NOZERO)
 826     {
 827         //  operator >>= shouldn't be used for bool (?)
 828         if ( auto b = o3tl::tryAccess<bool>(aValue) )
 829             pFormatter->SetNoZero( *b );
 830     }
 831     else if (aPropertyName == PROPERTYNAME_NULLDATE)
 832     {
 833         util::Date aDate;
 834         if ( aValue >>= aDate )
 835             pFormatter->ChangeNullDate( aDate.Day, aDate.Month, aDate.Year );
 836     }
 837     else if (aPropertyName == PROPERTYNAME_STDDEC)
 838     {
 839         sal_Int16 nInt16 = sal_Int16();
 840         if ( aValue >>= nInt16 )
 841             pFormatter->ChangeStandardPrec( nInt16 );
 842     }
 843     else if (aPropertyName == PROPERTYNAME_TWODIGIT)
 844     {
 845         sal_Int16 nInt16 = sal_Int16();
 846         if ( aValue >>= nInt16 )
 847             pFormatter->SetYear2000( nInt16 );
 848     }
 849     else
 850         throw beans::UnknownPropertyException(aPropertyName);
 851
 852 }
 853
 854 uno::Any SAL_CALL SvNumberFormatSettingsObj::getPropertyValue( const OUString& aPropertyName )
 855 {
 856     ::osl::MutexGuard aGuard( m_aMutex );
 857
 858     uno::Any aRet;
 859     SvNumberFormatter* pFormatter = m_xSupplier->GetNumberFormatter();
 860     if (!pFormatter)
 861         throw uno::RuntimeException();
 862
 863     if (aPropertyName == PROPERTYNAME_NOZERO)
 864     {
 865         aRet <<= pFormatter->GetNoZero();
 866     }
 867     else if (aPropertyName == PROPERTYNAME_NULLDATE)
 868     {
 869         const Date& rDate = pFormatter->GetNullDate();
 870         aRet <<= rDate.GetUNODate();
 871     }
 872     else if (aPropertyName == PROPERTYNAME_STDDEC)
 873         aRet <<= static_cast<sal_Int16>( pFormatter->GetStandardPrec() );
 874     else if (aPropertyName == PROPERTYNAME_TWODIGIT)
 875         aRet <<= static_cast<sal_Int16>( pFormatter->GetYear2000() );
 876     else
 877         throw beans::UnknownPropertyException(aPropertyName);
 878
 879     return aRet;
 880 }
 881
 882 void SAL_CALL SvNumberFormatSettingsObj::addPropertyChangeListener( const OUString&,
 883                                                                     const uno::Reference<beans::XPropertyChangeListener>&)
 884 {
 885     OSL_FAIL("not implemented");
 886 }
 887
 888 void SAL_CALL SvNumberFormatSettingsObj::removePropertyChangeListener( const OUString&,
 889                                                                        const uno::Reference<beans::XPropertyChangeListener>&)
 890 {
 891     OSL_FAIL("not implemented");
 892 }
 893
 894 void SAL_CALL SvNumberFormatSettingsObj::addVetoableChangeListener( const OUString&,
 895                                                                     const uno::Reference<beans::XVetoableChangeListener>&)
 896 {
 897     OSL_FAIL("not implemented");
 898 }
 899
 900 void SAL_CALL SvNumberFormatSettingsObj::removeVetoableChangeListener( const OUString&,
 901                                                                        const uno::Reference<beans::XVetoableChangeListener>&)
 902 {
 903     OSL_FAIL("not implemented");
 904 }
 905
 906 // XServiceInfo
 907
 908 OUString SAL_CALL SvNumberFormatSettingsObj::getImplementationName()
 909 {
 910     return "SvNumberFormatSettingsObj";
 911 }
 912
 913 sal_Bool SAL_CALL SvNumberFormatSettingsObj::supportsService( const OUString& ServiceName )
 914 {
 915     return cppu::supportsService( this, ServiceName );
 916 }
 917
 918 uno::Sequence<OUString> SAL_CALL SvNumberFormatSettingsObj::getSupportedServiceNames()
 919 {
 920     return { "com.sun.star.util.NumberFormatSettings" };
 921 }
 922
 923
 924 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
 925 com_sun_star_uno_util_numbers_SvNumberFormatterServiceObject_get_implementation(css::uno::XComponentContext*,
 926                                                                                 css::uno::Sequence<css::uno::Any> const &)
 927 {
 928     return cppu::acquire(new SvNumberFormatterServiceObj());
 929 }
 930
 931
 932 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */