numformat.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
#pragma once
 
#include <svl/svldllapi.h>
#include <com/sun/star/i18n/XNumberFormatCode.hpp>
#include <com/sun/star/uno/XComponentContext.hpp>
#include <i18nlangtag/lang.h>
#include <tools/link.hxx>
#include <svl/nfkeytab.hxx>
#include <svl/ondemand.hxx>
#include <svl/zforlist.hxx>
#include <unotools/charclass.hxx>
 
#include <map>
 
class Color;
class ImpSvNumberformatScan;
class ImpSvNumberInputScan;
class SvNumberFormatterRegistry_Impl;
class NfCurrencyTable;
 
class SVL_DLLPUBLIC SvNumberFormatter
{
    friend class SvNumberFormatterRegistry_Impl;
 
public:
    static const sal_uInt16 UNLIMITED_PRECISION;
 
    static const sal_uInt16 INPUTSTRING_PRECISION;
 
    SvNumberFormatter(const css::uno::Reference<css::uno::XComponentContext>& rxContext,
                      LanguageType eLang);
 
    ~SvNumberFormatter();
 
    void SetColorLink(const Link<sal_uInt16, Color*>& rColorTableCallBack);
    Color* GetUserDefColor(sal_uInt16 nIndex);
 
    void ChangeIntl(LanguageType eLnge);
    void ChangeNullDate(sal_uInt16 nDay, sal_uInt16 nMonth, sal_Int16 nYear);
    void ChangeStandardPrec(short nPrec);
    void SetNoZero(bool bNZ);
 
    LanguageType GetLanguage() const;
 
    // Determine whether two format types are input compatible or not
    static bool IsCompatible(SvNumFormatType eOldType, SvNumFormatType eNewType);
 
    SvNumberFormatTable& GetEntryTable(SvNumFormatType eType, sal_uInt32& FIndex,
                                       LanguageType eLnge);
 
    SvNumberFormatTable& ChangeCL(SvNumFormatType eType, sal_uInt32& FIndex, LanguageType eLnge);
 
    SvNumberFormatTable& GetFirstEntryTable(SvNumFormatType& eType, sal_uInt32& FIndex,
                                            LanguageType& rLnge);
 
    void DeleteEntry(sal_uInt32 nKey);
 
    bool PutEntry(OUString& rString, sal_Int32& nCheckPos, SvNumFormatType& nType, sal_uInt32& nKey,
                  LanguageType eLnge = LANGUAGE_DONTKNOW, bool bReplaceBooleanEquivalent = true);
 
    bool PutandConvertEntry(OUString& rString, sal_Int32& nCheckPos, SvNumFormatType& nType,
                            sal_uInt32& nKey, LanguageType eLnge, LanguageType eNewLnge,
                            bool bConvertDateOrder, bool bReplaceBooleanEquivalent = true);
 
    bool PutandConvertEntrySystem(OUString& rString, sal_Int32& nCheckPos, SvNumFormatType& nType,
                                  sal_uInt32& nKey, LanguageType eLnge, LanguageType eNewLnge);
 
    sal_uInt32 GetIndexPuttingAndConverting(OUString& rString, LanguageType eLnge,
                                            LanguageType eSysLnge, SvNumFormatType& rType,
                                            bool& rNewInserted, sal_Int32& rCheckPos);
 
    OUString GenerateFormat(sal_uInt32 nIndex, LanguageType eLnge = LANGUAGE_DONTKNOW,
                            bool bThousand = false, bool IsRed = false, sal_uInt16 nPrecision = 0,
                            sal_uInt16 nLeadingCnt = 1);
 
    bool IsNumberFormat(const OUString& sString, sal_uInt32& F_Index, double& fOutNumber,
                        SvNumInputOptions eInputOptions = SvNumInputOptions::NONE);
 
    void GetOutputString(const double& fOutNumber, sal_uInt32 nFIndex, OUString& sOutString,
                         const Color** ppColor, bool bUseStarFormat = false);
 
    void GetOutputString(const OUString& sString, sal_uInt32 nFIndex, OUString& sOutString,
                         const Color** ppColor, bool bUseStarFormat = false);
 
    void GetInputLineString(const double& fOutNumber, sal_uInt32 nFIndex, OUString& rOutString,
                            bool bFiltering = false, bool bForceSystemLocale = false);
 
    bool GetPreviewString(const OUString& sFormatString, double fPreviewNumber,
                          OUString& sOutString, const Color** ppColor, LanguageType eLnge,
                          bool bUseStarFormat = false);
 
    bool GetPreviewStringGuess(const OUString& sFormatString, double fPreviewNumber,
                               OUString& sOutString, const Color** ppColor,
                               LanguageType eLnge = LANGUAGE_DONTKNOW);
 
    bool GetPreviewString(const OUString& sFormatString, const OUString& sPreviewString,
                          OUString& sOutString, const Color** ppColor,
                          LanguageType eLnge = LANGUAGE_DONTKNOW);
 
    sal_uInt32 TestNewString(const OUString& sFormatString, LanguageType eLnge = LANGUAGE_DONTKNOW);
 
    bool IsTextFormat(sal_uInt32 nFIndex) const;
 
    bool IsNatNum12(sal_uInt32 nFIndex) const;
 
    void GetFormatSpecialInfo(sal_uInt32 nFormat, bool& bThousand, bool& IsRed,
                              sal_uInt16& nPrecision, sal_uInt16& nLeadingCnt);
 
    sal_uInt16 GetFormatPrecision(sal_uInt32 nFormat) const;
 
    sal_uInt16 GetFormatIntegerDigits(sal_uInt32 nFormat) const;
 
    sal_uInt32 GetFormatSpecialInfo(const OUString&, bool& bThousand, bool& IsRed,
                                    sal_uInt16& nPrecision, sal_uInt16& nLeadingCnt,
                                    LanguageType eLnge = LANGUAGE_DONTKNOW);
 
    OUString GetCalcCellReturn(sal_uInt32 nFormat) const;
 
    bool IsUserDefined(sal_uInt32 F_Index) const;
 
    bool IsUserDefined(std::u16string_view sStr, LanguageType eLnge = LANGUAGE_DONTKNOW);
 
    sal_uInt32 GetEntryKey(std::u16string_view sStr, LanguageType eLnge = LANGUAGE_DONTKNOW);
 
    const SvNumberformat* GetEntry(sal_uInt32 nKey) const;
 
    const SvNumberformat* GetSubstitutedEntry(sal_uInt32 nKey, sal_uInt32& o_rNewKey) const;
 
    sal_uInt32 GetStandardIndex(LanguageType eLnge = LANGUAGE_DONTKNOW);
 
    sal_uInt32 GetStandardFormat(SvNumFormatType eType, LanguageType eLnge = LANGUAGE_DONTKNOW);
 
    sal_uInt32 GetStandardFormat(sal_uInt32 nFIndex, SvNumFormatType eType, LanguageType eLnge);
 
    sal_uInt32 GetStandardFormat(double fNumber, sal_uInt32 nFIndex, SvNumFormatType eType,
                                 LanguageType eLnge);
 
    bool IsSpecialStandardFormat(sal_uInt32 nFIndex, LanguageType eLnge);
 
    sal_uInt32 GetTimeFormat(double fNumber, LanguageType eLnge, bool bForceDuration);
 
    sal_uInt32 GuessDateTimeFormat(SvNumFormatType& rType, double fNumber, LanguageType eLnge);
 
    sal_uInt32 GetEditFormat(double fNumber, sal_uInt32 nFIndex, SvNumFormatType eType,
                             SvNumberformat const* pFormat,
                             LanguageType eForLocale = LANGUAGE_DONTKNOW);
 
    const Date& GetNullDate() const;
    sal_uInt16 GetStandardPrec() const;
    bool GetNoZero() const;
    SvNumFormatType GetType(sal_uInt32 nFIndex) const;
 
    void ClearMergeTable();
    SvNumberFormatterIndexTable* MergeFormatter(SvNumberFormatter& rNewTable);
 
    bool HasMergeFormatTable() const;
    sal_uInt32 GetMergeFormatIndex(sal_uInt32 nOldFmt) const;
 
    SvNumberFormatterMergeMap ConvertMergeTableToMap();
 
    sal_uInt32 GetFormatForLanguageIfBuiltIn(sal_uInt32 nFormat,
                                             LanguageType eLnge = LANGUAGE_DONTKNOW);
 
    sal_uInt32 GetFormatIndex(NfIndexTableOffset, LanguageType eLnge = LANGUAGE_DONTKNOW);
 
    NfIndexTableOffset GetIndexTableOffset(sal_uInt32 nFormat) const;
 
    void SetEvalDateFormat(NfEvalDateFormat eEDF);
    NfEvalDateFormat GetEvalDateFormat() const;
 
    void SetYear2000(sal_uInt16 nVal);
    sal_uInt16 GetYear2000() const;
    static sal_uInt16 GetYear2000Default();
 
    sal_uInt16 ExpandTwoDigitYear(sal_uInt16 nYear) const;
    static sal_uInt16 ExpandTwoDigitYear(sal_uInt16 nYear, sal_uInt16 nTwoDigitYearStart);
 
    OUString GetFormatDecimalSep(sal_uInt32 nFormat) const;
 
    OUString GetLangDecimalSep(LanguageType nLang) const;
 
    static void resetTheCurrencyTable();
 
    static const NfCurrencyTable& GetTheCurrencyTable();
 
    static const NfCurrencyEntry* MatchSystemCurrency();
 
    static const NfCurrencyEntry& GetCurrencyEntry(LanguageType);
 
    static const NfCurrencyEntry* GetCurrencyEntry(std::u16string_view rAbbrev, LanguageType eLang);
 
    static const NfCurrencyEntry* GetLegacyOnlyCurrencyEntry(std::u16string_view rSymbol,
                                                             std::u16string_view rAbbrev);
 
    static void SetDefaultSystemCurrency(std::u16string_view rAbbrev, LanguageType eLang);
 
    sal_uInt16 GetCurrencyFormatStrings(NfWSStringsDtor&, const NfCurrencyEntry&, bool bBank) const;
 
    bool GetNewCurrencySymbolString(sal_uInt32 nFormat, OUString& rSymbol,
                                    const NfCurrencyEntry** ppEntry, bool* pBank = nullptr) const;
 
    static const NfCurrencyEntry* GetCurrencyEntry(bool& bFoundBank, std::u16string_view rSymbol,
                                                   std::u16string_view rExtension,
                                                   LanguageType eFormatLanguage,
                                                   bool bOnlyStringLanguage = false);
 
    void GetCompatibilityCurrency(OUString& rSymbol, OUString& rAbbrev) const;
 
    void GetUsedLanguages(std::vector<LanguageType>& rList);
 
    void FillKeywordTable(NfKeywordTable& rKeywords, LanguageType eLang);
 
    void FillKeywordTableForExcel(NfKeywordTable& rKeywords);
 
    OUString GetFormatStringForExcel(sal_uInt32 nKey, const NfKeywordTable& rKeywords,
                                     SvNumberFormatter& rTempFormatter) const;
 
    OUString GetKeyword(LanguageType eLnge, sal_uInt16 nIndex);
 
    OUString GetStandardName(LanguageType eLnge);
 
    static bool IsLocaleInstalled(LanguageType eLang);
 
    const NfKeywordTable& GetKeywords(sal_uInt32 nKey);
 
    const NfKeywordTable& GetEnglishKeywords() const;
 
    const std::vector<Color>& GetStandardColors() const;
 
    size_t GetMaxDefaultColors() const;
 
    struct InputScannerPrivateAccess
    {
        friend class ImpSvNumberInputScan;
 
    private:
        InputScannerPrivateAccess() {}
    };
    OnDemandLocaleDataWrapper& GetOnDemandLocaleDataWrapper(const InputScannerPrivateAccess&)
    {
        return xLocaleData;
    }
 
private:
    mutable ::osl::Mutex m_aMutex;
    css::uno::Reference<css::uno::XComponentContext> m_xContext;
    LanguageTag maLanguageTag;
    std::map<sal_uInt32, std::unique_ptr<SvNumberformat>>
        aFTable; // Table of format keys to format entries
    typedef std::map<sal_uInt32, sal_uInt32> DefaultFormatKeysMap;
    DefaultFormatKeysMap aDefaultFormatKeys; // Table of default standard to format keys
    std::unique_ptr<SvNumberFormatTable> pFormatTable; // For the UI dialog
    std::unique_ptr<SvNumberFormatterIndexTable>
        pMergeTable; // List of indices for merging two formatters
    OnDemandCharClass xCharClass; // CharacterClassification
    OnDemandLocaleDataWrapper xLocaleData; // LocaleData switched between SYSTEM, ENGLISH and other
    OnDemandTransliterationWrapper xTransliteration; // Transliteration loaded on demand
    OnDemandCalendarWrapper xCalendar; // Calendar loaded on demand
    OnDemandNativeNumberWrapper xNatNum; // Native number service loaded on demand
    std::unique_ptr<ImpSvNumberInputScan> pStringScanner; // Input string scanner
    std::unique_ptr<ImpSvNumberformatScan> pFormatScanner; // Format code string scanner
    Link<sal_uInt16, Color*> aColorLink; // User defined color table CallBack
    sal_uInt32 MaxCLOffset; // Max language/country offset used
    sal_uInt32 nDefaultSystemCurrencyFormat; // NewCurrency matching SYSTEM locale
    LanguageType IniLnge; // Initialized setting language/country
    LanguageType ActLnge; // Current setting language/country
    NfEvalDateFormat eEvalDateFormat; // DateFormat evaluation
    bool bNoZero; // Zero value suppression
 
    // cached locale data items needed almost any time
    OUString aDecimalSep;
    OUString aDecimalSepAlt;
    OUString aThousandSep;
    OUString aDateSep;
 
    SVL_DLLPRIVATE static volatile bool bCurrencyTableInitialized;
    SVL_DLLPRIVATE static sal_uInt16 nSystemCurrencyPosition;
    SVL_DLLPRIVATE static SvNumberFormatterRegistry_Impl* pFormatterRegistry;
 
    // get the registry, create one if none exists
    SVL_DLLPRIVATE static SvNumberFormatterRegistry_Impl& GetFormatterRegistry();
 
    // called by ctors
    SVL_DLLPRIVATE void ImpConstruct(LanguageType eLang);
 
    // Generate builtin formats provided by i18n behind CLOffset,
    // if bNoAdditionalFormats==false also generate additional i18n formats.
    SVL_DLLPRIVATE void ImpGenerateFormats(sal_uInt32 CLOffset, bool bNoAdditionalFormats);
 
    // Generate additional formats provided by i18n
    SVL_DLLPRIVATE void ImpGenerateAdditionalFormats(
        sal_uInt32 CLOffset,
        css::uno::Reference<css::i18n::XNumberFormatCode> const& rNumberFormatCode,
        bool bAfterChangingSystemCL);
 
    SVL_DLLPRIVATE SvNumberformat* ImpInsertFormat(const css::i18n::NumberFormatCode& rCode,
                                                   sal_uInt32 nPos,
                                                   bool bAfterChangingSystemCL = false,
                                                   sal_Int16 nOrgIndex = 0);
 
    // Return CLOffset or (MaxCLOffset + SV_COUNTRY_LANGUAGE_OFFSET) if new language/country
    SVL_DLLPRIVATE sal_uInt32 ImpGetCLOffset(LanguageType eLnge) const;
 
    // Test whether format code already exists, then return index key,
    // otherwise NUMBERFORMAT_ENTRY_NOT_FOUND
    SVL_DLLPRIVATE sal_uInt32 ImpIsEntry(std::u16string_view rString, sal_uInt32 CLOffset,
                                         LanguageType eLnge);
 
    // Create builtin formats for language/country if necessary, return CLOffset
    SVL_DLLPRIVATE sal_uInt32 ImpGenerateCL(LanguageType eLnge);
 
    // Create theCurrencyTable with all <type>NfCurrencyEntry</type>
    SVL_DLLPRIVATE static void ImpInitCurrencyTable();
 
    // Return the format index of the currency format of the system locale.
    // Format is created if not already present.
    SVL_DLLPRIVATE sal_uInt32 ImpGetDefaultSystemCurrencyFormat();
 
    // Return the format index of the currency format of the current locale.
    // Format is created if not already present.
    SVL_DLLPRIVATE sal_uInt32 ImpGetDefaultCurrencyFormat();
 
    // Return the default format for a given type and current locale.
    // May ONLY be called from within GetStandardFormat().
    SVL_DLLPRIVATE sal_uInt32 ImpGetDefaultFormat(SvNumFormatType nType);
 
    // Return the index in a sequence of format codes matching an enum of
    // NfIndexTableOffset. If not found 0 is returned. If the sequence doesn't
    // contain any format code elements a default element is created and inserted.
    SVL_DLLPRIVATE sal_Int32 ImpGetFormatCodeIndex(
        css::uno::Sequence<css::i18n::NumberFormatCode>& rSeq, const NfIndexTableOffset nTabOff);
 
    // Adjust a sequence of format codes to contain only one (THE) default
    // instead of multiple defaults for short/medium/long types.
    // If there is no medium but a short and a long default the long is taken.
    // Non-PRODUCT version may check locale data for matching defaults in one
    // FormatElement group.
    SVL_DLLPRIVATE void ImpAdjustFormatCodeDefault(css::i18n::NumberFormatCode* pFormatArr,
                                                   sal_Int32 nCount);
 
    // Obtain the format entry for a given key index.
    SVL_DLLPRIVATE SvNumberformat* GetFormatEntry(sal_uInt32 nKey);
    SVL_DLLPRIVATE const SvNumberformat* GetFormatEntry(sal_uInt32 nKey) const;
 
    // used as a loop body inside of GetNewCurrencySymbolString() and GetCurrencyEntry()
    static bool ImpLookupCurrencyEntryLoopBody(const NfCurrencyEntry*& pFoundEntry,
                                               bool& bFoundBank, const NfCurrencyEntry* pData,
                                               sal_uInt16 nPos, std::u16string_view rSymbol);
 
    // link to be set at <method>SvtSysLocaleOptions::SetCurrencyChangeLink()</method>
    DECL_DLLPRIVATE_STATIC_LINK(SvNumberFormatter, CurrencyChangeLink, LinkParamNone*, void);
 
    // return position of a special character
    sal_Int32 ImpPosToken(const OUStringBuffer& sFormat, sal_Unicode token,
                          sal_Int32 nStartPos = 0) const;
 
    // Substitute a format during GetFormatEntry(), i.e. system formats.
    SvNumberformat* ImpSubstituteEntry(SvNumberformat* pFormat, sal_uInt32* o_pRealKey = nullptr);
 
    // own mutex, may also be used by internal class SvNumberFormatterRegistry_Impl
    static ::osl::Mutex& GetGlobalMutex();
    ::osl::Mutex& GetInstanceMutex() const { return m_aMutex; }
 
public:
    // called by SvNumberFormatterRegistry_Impl::Notify if the default system currency changes
    void ResetDefaultSystemCurrency();
 
    // Called by SvNumberFormatterRegistry_Impl::Notify if the system locale's
    // date acceptance patterns change.
    void InvalidateDateAcceptancePatterns();
 
    // Replace the SYSTEM language/country format codes. Called upon change of
    // the user configurable locale.
    // Old compatibility codes are replaced, user defined are converted, and
    // new format codes are appended.
    void ReplaceSystemCL(LanguageType eOldLanguage);
 
    const css::uno::Reference<css::uno::XComponentContext>& GetComponentContext() const;
 
    // return the current FormatScanner
    const ImpSvNumberformatScan* GetFormatScanner() const;
 
 
    // return current (!) Locale
    const LanguageTag& GetLanguageTag() const;
 
    // return corresponding Transliteration wrapper
    const ::utl::TransliterationWrapper* GetTransliteration() const;
 
    // return the corresponding CharacterClassification wrapper
    const CharClass* GetCharClass() const;
 
    // return the corresponding LocaleData wrapper
    const LocaleDataWrapper* GetLocaleData() const;
 
    // return the corresponding Calendar wrapper
    CalendarWrapper* GetCalendar() const;
 
    // return the corresponding NativeNumberSupplier wrapper
    const NativeNumberWrapper* GetNatNum() const;
 
    // cached locale data items
 
    // return the corresponding decimal separator
    const OUString& GetNumDecimalSep() const;
 
    // return the corresponding decimal separator alternative
    const OUString& GetNumDecimalSepAlt() const;
 
    // return the corresponding group (AKA thousand) separator
    const OUString& GetNumThousandSep() const;
 
    // return the corresponding date separator
    const OUString& GetDateSep() const;
 
    // checks for decimal separator and optional alternative
    bool IsDecimalSep(std::u16string_view rStr) const;
};
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */