diff options
Diffstat (limited to '')
| -rw-r--r-- | i18npool/source/defaultnumberingprovider/defaultnumberingprovider.cxx | 1266 |
1 files changed, 1266 insertions, 0 deletions
diff --git a/i18npool/source/defaultnumberingprovider/defaultnumberingprovider.cxx b/i18npool/source/defaultnumberingprovider/defaultnumberingprovider.cxx new file mode 100644 index 000000000..64325b43c --- /dev/null +++ b/i18npool/source/defaultnumberingprovider/defaultnumberingprovider.cxx @@ -0,0 +1,1266 @@ +/* -*- 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 . + */ + +#include <defaultnumberingprovider.hxx> +#include <transliterationImpl.hxx> +#include <com/sun/star/i18n/NativeNumberMode.hpp> +#include <com/sun/star/lang/IllegalArgumentException.hpp> +#include <com/sun/star/style/NumberingType.hpp> +#include <com/sun/star/beans/PropertyValue.hpp> +#include <com/sun/star/configuration/theDefaultProvider.hpp> +#include <com/sun/star/container/XHierarchicalNameAccess.hpp> +#include <osl/diagnose.h> +#include <rtl/ref.hxx> +#include <localedata.hxx> +#include <nativenumbersupplier.hxx> +#include <string.h> +#include <comphelper/propertysequence.hxx> +#include <cppuhelper/supportsservice.hxx> + +// Cyrillic upper case +#define C_CYR_A "\xD0\x90" +#define C_CYR_B "\xD0\x91" +// Cyrillic lower case +#define S_CYR_A "\xD0\xB0" +#define S_CYR_B "\xD0\xB1" + +//Greek upper case +#define C_GR_A "\xCE\x91" +#define C_GR_B "\xCE\x92" +//Greek lower case +#define S_GR_A "\xCE\xB1" +#define S_GR_B "\xCE\xB2" + +//Hebrew +#define S_HE_ALEPH "\xD7\x90" +#define S_HE_YOD "\xD7\x99" +#define S_HE_QOF "\xD7\xA7" + +//Arabic-Indic +#define S_AR_ONE "\xd9\xa1" +#define S_AR_TWO "\xd9\xa2" +#define S_AR_THREE "\xd9\xa3" + +// East Arabic-Indic +#define S_FA_ONE "\xDB\xB1" +#define S_FA_TWO "\xDB\xB2" +#define S_FA_THREE "\xDB\xB3" + +// Indic Devanagari +#define S_HI_ONE "\xE0\xA5\xA7" +#define S_HI_TWO "\xE0\xA5\xA8" +#define S_HI_THREE "\xE0\xA5\xA9" + +// Chicago footnote symbols +#define S_DAGGER "\xE2\x80\xA0" +#define S_DBL_DAGGER "\xE2\x80\xA1" +#define S_SECTION "\xC2\xA7" + +#include <sal/macros.h> +#include <rtl/ustring.hxx> +#include <rtl/ustrbuf.hxx> + +#include <bullet.h> + +using namespace com::sun::star; +using namespace com::sun::star::uno; +using namespace ::com::sun::star::i18n; +using namespace com::sun::star::lang; + +namespace i18npool { + +const sal_Unicode table_Alphabet_ar[] = { + 0x0623, 0x0628, 0x062A, 0x062B, 0x062C, 0x062D, 0x062E, + 0x062F, 0x0630, 0x0631, 0x0632, 0x0633, 0x0634, 0x0635, + 0x0636, 0x0637, 0x0638, 0x0639, 0x063A, 0x0641, 0x0642, + 0x0643, 0x0644, 0x0645, 0x0646, 0x0647, 0x0648, 0x0649 +}; + +const sal_Unicode table_Alphabet_ar_abjad[] = { + 0x0627, 0x0628, 0x062c, 0x062f, 0x0647, 0x0648, 0x0632, 0x062d, + 0x0637, 0x064a, 0x0643, 0x0644, 0x0645, 0x0646, 0x0633, 0x0639, + 0x0641, 0x0635, 0x0642, 0x0631, 0x0634, 0x062a, 0x062b, 0x062e, + 0x0630, 0x0636, 0x0638, 0x063a +}; + +const sal_Unicode table_Alphabet_th[] = { + 0x0E01, 0x0E02, 0x0E04, 0x0E07, + 0x0E08, 0x0E09, 0x0E0A, 0x0E0B, 0x0E0C, 0x0E0D, 0x0E0E, 0x0E0F, + 0x0E10, 0x0E11, 0x0E12, 0x0E13, 0x0E14, 0x0E15, 0x0E16, 0x0E17, + 0x0E18, 0x0E19, 0x0E1A, 0x0E1B, 0x0E1C, 0x0E1D, 0x0E1E, 0x0E1F, + 0x0E20, 0x0E21, 0x0E22, 0x0E23, 0x0E24, 0x0E25, 0x0E26, 0x0E27, + 0x0E28, 0x0E29, 0x0E2A, 0x0E2B, 0x0E2C, 0x0E2D, 0x0E2E +}; + +const sal_Unicode table_Alphabet_he[] = { + 0x05D0, 0x05D1, 0x05D2, 0x05D3, 0x05D4, 0x05D5, 0x05D6, 0x05D7, + 0x05D8, 0x05D9, 0x05DB, 0x05DC, 0x05DE, 0x05E0, 0x05E1, 0x05E2, + 0x05E4, 0x05E6, 0x05E7, 0x05E8, 0x05E9, 0x05EA +}; + +const sal_Unicode table_Alphabet_ne[] = { + 0x0915, 0x0916, 0x0917, 0x0918, 0x0919, 0x091A, 0x091B, 0x091C, + 0x091D, 0x091E, 0x091F, 0x0920, 0x0921, 0x0922, 0x0923, 0x0924, + 0x0925, 0x0926, 0x0927, 0x0928, 0x092A, 0x092B, 0x092C, 0x092D, + 0x092E, 0x092F, 0x0930, 0x0932, 0x0935, 0x0936, 0x0937, 0x0938, + 0x0939 +}; + +const sal_Unicode table_Alphabet_km[] = { + 0x1780, 0x1781, 0x1782, 0x1783, 0x1784, 0x1785, 0x1786, 0x1787, + 0x1788, 0x1789, 0x178A, 0x178B, 0x178C, 0x178D, 0x178E, 0x178F, + 0x1790, 0x1791, 0x1792, 0x1793, 0x1794, 0x1795, 0x1796, 0x1797, + 0x1798, 0x1799, 0x179A, 0x179B, 0x179C, 0x179F, + 0x17A0, 0x17A1, 0x17A2 +}; + +const sal_Unicode table_Alphabet_lo[] = { + 0x0E81, 0x0E82, 0x0E84, 0x0E87, 0x0E88, 0x0E8A, 0x0E8D, 0x0E94, + 0x0E95, 0x0E96, 0x0E97, 0x0E99, 0x0E9A, 0x0E9B, 0x0E9C, + 0x0E9D, 0x0E9E, 0x0E9F, 0x0EA1, 0x0EA2, 0x0EA3, 0x0EA5, 0x0EA7, + 0x0EAA, 0x0EAB, 0x0EAD, 0x0EAE, 0x0EAF, 0x0EAE, 0x0EDC, 0x0EDD +}; + +const sal_Unicode table_Alphabet_dz[] = { + 0x0F40, 0x0F41, 0x0F42, 0x0F44, 0x0F45, 0x0F46, 0x0F47, 0x0F49, + 0x0F4F, 0x0F50, 0x0F51, 0x0F53, 0x0F54, 0x0F55, 0x0F56, 0x0F58, + 0x0F59, 0x0F5A, 0x0F5B, 0x0F5D, 0x0F5E, 0x0F5F, 0x0F60, 0x0F61, + 0x0F62, 0x0F63, 0x0F64, 0x0F66, 0x0F67, 0x0F68 +}; + +const sal_Unicode table_Alphabet_my[] = { + 0x1000, 0x1001, 0x1002, 0x1003, 0x1004, 0x1005, 0x1006, 0x1007, + 0x1008,/*0x1009,*/0x100A, 0x100B, 0x100C, 0x100D, 0x100E, 0x100F, + 0x1010, 0x1011, 0x1012, 0x1013, 0x1014, 0x1015, 0x1016, 0x1017, + 0x1018, 0x1019, 0x101A, 0x101B, 0x101C, 0x101D, 0x101E, 0x101F, + 0x1020, 0x1021 +}; + +// Bulgarian Cyrillic upper case letters +const sal_Unicode table_CyrillicUpperLetter_bg[] = { + 0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417, 0x0418, + 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F, 0x0420, 0x0421, 0x0422, + 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042A, 0x042E, + 0x042F +}; + +// Bulgarian cyrillic lower case letters +const sal_Unicode table_CyrillicLowerLetter_bg[] = { + 0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437, 0x0438, + 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F, 0x0440, 0x0441, 0x0442, + 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 0x0448, 0x0449, 0x044A, 0x044E, + 0x044F +}; + +// Russian Cyrillic upper letters +const sal_Unicode table_CyrillicUpperLetter_ru[] = { + 0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417, + 0x0418, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F, 0x0420, + 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 0x0428, + 0x0429, 0x042B, 0x042D, 0x042E, 0x042F +}; + +// Russian cyrillic lower letters +const sal_Unicode table_CyrillicLowerLetter_ru[] = { + 0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437, + 0x0438, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F, 0x0440, + 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 0x0448, + 0x0449, 0x044B, 0x044D, 0x044E, 0x044F +}; + +// Serbian Cyrillic upper letters +const sal_Unicode table_CyrillicUpperLetter_sr[] = { + 0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0402, 0x0415, 0x0416, + 0x0417, 0x0418, 0x0408, 0x041A, 0x041B, 0x0409, 0x041C, 0x041D, + 0x040A, 0x041E, 0x041F, 0x0420, 0x0421, 0x0422, 0x040B, 0x0423, + 0x0424, 0x0425, 0x0426, 0x0427, 0x040F, 0x0428 +}; + +// Serbian cyrillic lower letters +const sal_Unicode table_CyrillicLowerLetter_sr[] = { + 0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0452, 0x0435, 0x0436, + 0x0437, 0x0438, 0x0458, 0x043A, 0x043B, 0x0459, 0x043C, 0x043D, + 0x045A, 0x043E, 0x043F, 0x0440, 0x0441, 0x0442, 0x045B, 0x0443, + 0x0444, 0x0445, 0x0446, 0x0447, 0x045F, 0x0448 +}; + +const sal_Unicode table_GreekUpperLetter[] = { + 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x03DB, 0x0396, 0x0397, 0x0398, + 0x0399, 0x039A, 0x039B, 0x039C, 0x039D, 0x039E, 0x039F, 0x03A0, 0x03DF, + 0x03A1, 0x03A3, 0x03A4, 0x03A5, 0x03A6, 0x03A7, 0x03A8, 0x03A9, 0x03E0 +}; + +const sal_Unicode table_GreekLowerLetter[] = { + 0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03DB, 0x03B6, 0x03B7, 0x03B8, + 0x03B9, 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF, 0x03C0, 0x03DF, + 0x03C1, 0x03C3, 0x03C4, 0x03C5, 0x03C6, 0x03C7, 0x03C8, 0x03C9, 0x03E1 +}; + +const sal_Unicode table_Alphabet_fa[] = { + 0x0622, 0x0628, 0x067E, 0x062A, 0x062B, 0x062C, 0x0686, 0x062D, + 0x062E, 0x062F, 0x0630, 0x0631, 0x0632, 0x0698, 0x0633, 0x0634, + 0x0635, 0x0636, 0x0637, 0x0638, 0x0639, 0x0640, 0x0641, 0x0642, + 0x06A9, 0x06AF, 0x0644, 0x0645, 0x0646, 0x0648, 0x0647, 0x06CC +}; + +const sal_Unicode upperLetter[] = { + 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, + 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, + 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A +}; + +const sal_Unicode lowerLetter[] = { + 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, + 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, + 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A +}; + +const sal_Unicode table_Chicago[] = { + 0x002a, 0x2020, 0x2021, 0x00a7 +}; + +// Tables used for numbering in persian words +const sal_Unicode table_PersianWord_decade1[][7]={ + {0}, // 0 + {0x06cc, 0x06a9, 0}, // 1 + {0x062f, 0x0648, 0}, // 2 + {0x0633, 0x0647, 0}, // 3 + {0x0686, 0x0647, 0x0627, 0x0631, 0}, // 4 + {0x067e, 0x0646, 0x062c, 0}, // 5 + {0x0634, 0x0634, 0}, // 6 + {0x0647, 0x0641, 0x062a, 0}, // 7 + {0x0647, 0x0634, 0x062a, 0}, // 8 + {0x0646, 0x0647, 0}, // 9 + {0x062f, 0x0647, 0}, // 10 + {0x06cc, 0x0627, 0x0632, 0x062f, 0x0647, 0}, // 11 + {0x062f, 0x0648, 0x0627, 0x0632, 0x062f, 0x0647, 0}, // 12 + {0x0633, 0x06cc, 0x0632, 0x062f, 0x0647, 0}, // 13 + {0x0686, 0x0647, 0x0627, 0x0631, 0x062f, 0x0647, 0}, // 14 + {0x067e, 0x0627, 0x0646, 0x0632, 0x062f, 0x0647, 0}, // 15 + {0x0634, 0x0627, 0x0646, 0x0632, 0x062f, 0x0647, 0}, // 16 + {0x0647, 0x0641, 0x062f, 0x0647, 0}, // 17 + {0x0647, 0x062c, 0x062f, 0x0647, 0}, // 18 + {0x0646, 0x0648, 0x0632, 0x062f, 0x0647, 0} // 19 +}; + +const sal_Unicode table_PersianWord_decade2[][6]={ + {0x0628, 0x06cc, 0x0633, 0x062a, 0}, // 20 + {0x0633, 0x06cc, 0}, // 30 + {0x0686, 0x0647, 0x0644, 0}, // 40 + {0x067e, 0x0646, 0x062c, 0x0627, 0x0647, 0}, // 50 + {0x0634, 0x0635, 0x062a, 0}, // 60 + {0x0647, 0x0641, 0x062a, 0x0627, 0x062f, 0}, // 70 + {0x0647, 0x0634, 0x062a, 0x0627, 0x062f, 0}, // 80 + {0x0646, 0x0648, 0x062f, 0} // 90 +}; + +const sal_Unicode table_PersianWord_decade3[][7]={ + {0x0635, 0x062f, 0}, // 100 + {0x062f, 0x0648, 0x06cc, 0x0633, 0x062a, 0}, // 200 + {0x0633, 0x06cc, 0x0635, 0x062f, 0}, // 300 + {0x0686, 0x0647, 0x0627, 0x0631, 0x0635, 0x062f, 0}, // 400 + {0x067e, 0x0627, 0x0646, 0x0635, 0x062f, 0}, // 500 + {0x0634, 0x0635, 0x062f, 0}, // 600 + {0x0647, 0x0641, 0x062a, 0x0635, 0x062f, 0}, // 700 + {0x0647, 0x0634, 0x062a, 0x0635, 0x062f, 0}, // 800 + {0x0646, 0x0647, 0x0635, 0x062f, 0} // 900 +}; + +const sal_Unicode table_PersianWord_decadeX[][8]={ + {0x0647, 0x0632, 0x0627, 0x0631, 0}, // 1000 + {0x0645, 0x06cc, 0x0644, 0x06cc, 0x0648, 0x0646, 0}, // 1000000 + {0x0645, 0x06cc, 0x0644, 0x06cc, 0x0627, 0x0631, 0x062f, 0} // 1000000000 +}; + +const sal_Unicode table_KoreanLegalWord_decade1[][3] = { + {0xd558, 0xb098, 0}, // 1 + {0xb458, 0}, // 2 + {0xc14b, 0}, // 3 + {0xb137, 0}, // 4 + {0xb2e4, 0xc12f, 0}, // 5 + {0xc5ec, 0xc12f, 0}, // 6 + {0xc77c, 0xacf1, 0}, // 7 + {0xc5ec, 0xb35f, 0}, // 8 + {0xc544, 0xd649, 0} // 9 +}; + +const sal_Unicode table_KoreanLegalWord_decade2[][3] = { + {0xc5f4, 0}, // 10 + {0xc2a4, 0xbb3c, 0}, // 20 + {0xc11c, 0xb978, 0}, // 30 + {0xb9c8, 0xd754, 0}, // 40 + {0xc270, 0}, // 50 + {0xc608, 0xc21c, 0}, // 60 + {0xc77c, 0xd754, 0}, // 70 + {0xc5ec, 0xb4e0, 0}, // 80 + {0xc544, 0xd754, 0} // 90 +}; + +DefaultNumberingProvider::DefaultNumberingProvider( const Reference < XComponentContext >& rxContext ) : m_xContext(rxContext) +{ + +} + +DefaultNumberingProvider::~DefaultNumberingProvider() +{ +} + +Sequence< Reference<container::XIndexAccess> > +DefaultNumberingProvider::getDefaultOutlineNumberings(const Locale& rLocale ) +{ + return LocaleDataImpl::get()->getOutlineNumberingLevels( rLocale ); +} + +Sequence< Sequence<beans::PropertyValue> > +DefaultNumberingProvider::getDefaultContinuousNumberingLevels( const Locale& rLocale ) +{ + return LocaleDataImpl::get()->getContinuousNumberingLevels( rLocale ); +} + +static OUString toRoman( sal_Int32 n ) +{ + +// i, ii, iii, iv, v, vi, vii, vii, viii, ix +// (Dummy),1000,500,100,50,10,5,1 + static const char coRomanArr[] = "MDCLXVI--"; // +2 Dummy entries !! + const char* cRomanStr = coRomanArr; + sal_uInt16 nMask = 1000; + sal_uInt32 nOver1000 = n / nMask; + n -= ( nOver1000 * nMask ); + + OUStringBuffer sTmp; + while(nOver1000--) + sTmp.append(*coRomanArr); + + while( nMask ) + { + sal_uInt8 nNumber = sal_uInt8( n / nMask ); + sal_uInt8 nDiff = 1; + n %= nMask; + + if( 5 < nNumber ) + { + if( nNumber < 9 ) + sTmp.append(*(cRomanStr-1)); + ++nDiff; + nNumber -= 5; + } + switch( nNumber ) + { + case 3: sTmp.append(*cRomanStr); [[fallthrough]]; + case 2: sTmp.append(*cRomanStr); [[fallthrough]]; + case 1: sTmp.append(*cRomanStr); break; + case 4: sTmp.append(*cRomanStr).append(*(cRomanStr-nDiff)); break; + case 5: sTmp.append(*(cRomanStr-nDiff)); break; + } + + nMask /= 10; // to the next decade + cRomanStr += 2; + } + return sTmp.makeStringAndClear(); +} + +// not used: + +static +void lcl_formatChars( const sal_Unicode table[], int tableSize, int n, OUString& s ) +{ + // string representation of n is appended to s. + // if A=='A' then 0=>A, 1=>B, ..., 25=>Z, 26=>AA, 27=>AB, ... + // if A=='a' then 0=>a, 1=>b, ..., 25=>z, 26=>aa, 27=>ab, ... + + if( n>=tableSize ) lcl_formatChars( table, tableSize, (n-tableSize)/tableSize, s ); + + s += OUStringChar( table[ n % tableSize ] ); +} + +static +void lcl_formatChars1( const sal_Unicode table[], int tableSize, int n, OUString& s ) +{ + // string representation of n is appended to s. + // if A=='A' then 0=>A, 1=>B, ..., 25=>Z, 26=>AA, 27=>BB, ... + // if A=='a' then 0=>a, 1=>b, ..., 25=>z, 26=>aa, 27=>bb, ... + + int repeat_count = n / tableSize + 1; + + for( int i=0; i<repeat_count; i++ ) + s += OUStringChar( table[ n%tableSize ] ); +} + +static +void lcl_formatChars2( const sal_Unicode table_capital[], const sal_Unicode table_small[], int tableSize, int n, OUString& s ) +{ + // string representation of n is appended to s. + // if A=='A' then 0=>A, 1=>B, ..., 25=>Z, 26=>Aa, 27=>Ab, ... + + if( n>=tableSize ) + { + lcl_formatChars2( table_capital, table_small, tableSize, (n-tableSize)/tableSize, s ); + s += OUStringChar( table_small[ n % tableSize ] ); + } else + s += OUStringChar( table_capital[ n % tableSize ] ); +} + +static +void lcl_formatChars3( const sal_Unicode table_capital[], const sal_Unicode table_small[], int tableSize, int n, OUString& s ) +{ + // string representation of n is appended to s. + // if A=='A' then 0=>A, 1=>B, ..., 25=>Z, 26=>Aa, 27=>Bb, ... + + int repeat_count = n / tableSize + 1; + s += OUStringChar( table_capital[ n%tableSize ] ); + + for( int i=1; i<repeat_count; i++ ) + s += OUStringChar( table_small[ n%tableSize ] ); +} + + +/** Returns number's representation in persian words up to 999999999999 + respectively limited by sal_Int32 >=0. + The caller assures that nNumber is not negative. + + @throws IllegalArgumentException + @throws RuntimeException + */ +static +void lcl_formatPersianWord( sal_Int32 nNumber, OUString& rsResult ) +{ + OUStringBuffer aTemp(64); + static constexpr OUStringLiteral asPersianWord_conjunction_data = u" \u0648 "; + OUString asPersianWord_conjunction( asPersianWord_conjunction_data ); + unsigned char nSection = 0; + + while (int nPart = nNumber % 1000) + { + if (nSection) + { + if (nSection > SAL_N_ELEMENTS( table_PersianWord_decadeX)) + throw IllegalArgumentException(); // does not happen with sal_Int32 + aTemp.insert( 0, asPersianWord_conjunction).insert( 0, table_PersianWord_decadeX[nSection-1]); + } + + unsigned int nDigit; + if ((nDigit = nPart % 100) < 20) + { + if (!aTemp.isEmpty()) + aTemp.insert( 0, u' '); + aTemp.insert( 0, table_PersianWord_decade1[nDigit]); + } + else + { + if ((nDigit = nPart % 10) != 0) + { + if (!aTemp.isEmpty()) + aTemp.insert( 0, asPersianWord_conjunction); + aTemp.insert( 0, table_PersianWord_decade1[nDigit]); + } + if ((nDigit = (nPart / 10) % 10) != 0) + { + if (!aTemp.isEmpty()) + aTemp.insert( 0, asPersianWord_conjunction); + aTemp.insert( 0, table_PersianWord_decade2[nDigit-2]); + } + } + + if ((nDigit = nPart / 100) != 0) + { + if (!aTemp.isEmpty()) + aTemp.insert( 0, asPersianWord_conjunction); + aTemp.insert( 0, table_PersianWord_decade3[nDigit-1]); + } + + nNumber /= 1000; + nSection++; + } + rsResult += aTemp; +} + +static void lcl_formatKoreanLegalWord(sal_Int32 nNumber, OUString& rsResult) { + OUStringBuffer aTemp(64); + int digit1 = nNumber % 10; + int digit2 = nNumber / 10; + if (digit1 > 0) + aTemp.insert(0, (table_KoreanLegalWord_decade1[digit1 - 1])); + if (digit2 > 0) + aTemp.insert(0, (table_KoreanLegalWord_decade2[digit2 - 1])); + rsResult += aTemp.makeStringAndClear(); +} + +// Greek Letter Numbering + +// KERAIA separates numerals from other text +#define STIGMA u'\x03DB' +#define LEFT_KERAIA u'\x0375' +#define MYRIAD_SYM u'\x039C' +#define DOT_SYM u'.' +#define SIGMA_OFFSET 19 +#define TAU_OFFSET 20 +#define MYRIAD 10000 + +/* +* Return the 1-999999 number's representation in the Greek numbering system. +* Adding a "left keraia" to represent numbers in the range 10000 ... 999999 is +* not orthodox, so it's better to use the myriad notation and call this method +* only for numbers up to 9999. +*/ +static +OUString gr_smallNum(const sal_Unicode table[], int n) +{ + if (n > 9999) + throw IllegalArgumentException(); + + int i = 0; + OUStringBuffer sb; + for (int v = n; v > 0; v /= 10, i++) { + int digit = v % 10; + if (digit == 0) + continue; + + sal_Unicode sign = table[(digit - 1) + 9 * (i % 3)]; + if (sign == STIGMA) { + sb.insert(0, table[TAU_OFFSET]); + sb.insert(0, table[SIGMA_OFFSET]); + } else { + sb.insert(0, sign); + } + + if (i > 2) + sb.insert(0, LEFT_KERAIA); + } + + return sb.makeStringAndClear(); +} + +static +void lcl_formatCharsGR(const sal_Unicode table[], int n, OUString& s ) +{ + OUStringBuffer sb; + int myriadPower = 2; + + for (int divisor = MYRIAD * MYRIAD; divisor > 1; divisor /= MYRIAD, myriadPower--) { + if (n > divisor - 1) { + /* + * Follow the Diophantus representation of: + * A myriad sign, M(10000) as many times as the power + * followed by the multiplier for the myriad + * followed by a dot + * followed by the rest + * This is enough for 32-bit integers + */ + for (int i = 0; i < myriadPower; i++) + sb.append(MYRIAD_SYM); + + sb.append(gr_smallNum(table, n/divisor)); + n %= divisor; + + if (n > 0) + sb.append(DOT_SYM); + } + } + sb.append(gr_smallNum(table,n)); + + s += sb; +} + +static +bool should_ignore( std::u16string_view s ) +{ + // return true if blank or null + return s == u" " || (!s.empty() && s[0]==0); +} + +/** + * Turn nNumber into a string and pad the result to nLimit by inserting zero characters at the + * start. + */ +static OUString lcl_formatArabicZero(sal_Int32 nNumber, sal_Int32 nLimit) +{ + OUString aRet = OUString::number(nNumber); + sal_Int32 nDiff = nLimit - aRet.getLength(); + + if (nDiff <= 0) + { + return aRet; + } + + OUStringBuffer aBuffer; + aBuffer.setLength(nDiff); + for (sal_Int32 i = 0; i < nDiff; ++i) + { + aBuffer[i] = '0'; + } + aBuffer.append(aRet); + return aBuffer.makeStringAndClear(); +} + +static +Any getPropertyByName( const Sequence<beans::PropertyValue>& aProperties, + const char* name ) +{ + auto pProp = std::find_if(aProperties.begin(), aProperties.end(), + [&name](const beans::PropertyValue& rProp) { return rProp.Name.equalsAscii(name); }); + if (pProp != aProperties.end()) + return pProp->Value; + throw IllegalArgumentException(); +} + +//XNumberingFormatter +OUString +DefaultNumberingProvider::makeNumberingString( const Sequence<beans::PropertyValue>& aProperties, + const Locale& aLocale ) +{ + // the Sequence of PropertyValues is expected to have at least 4 elements: + // elt Name Type purpose + + + // 0. "Prefix" OUString + // 1. "NumberingType" sal_Int16 type of formatting from style::NumberingType (roman, arabic, etc) + // 2. "Suffix" OUString + // ... ... ... + // n. "Value" sal_Int32 the number to be formatted + // example: + // given the Sequence { '(', NumberingType::ROMAN_UPPER, ')', ..., 7 } + // makeNumberingString() returns the string "(VII)". + + // Q: why is the type of numType sal_Int16 instead of style::NumberingType? + // A: an Any can't hold a style::NumberingType for some reason. + // add.: style::NumberingType holds constants of type sal_Int16, it's not an enum type + + sal_Int16 natNum = 0; + sal_Int16 tableSize = 0; + const sal_Unicode *table = nullptr; // initialize to avoid compiler warning + bool bRecycleSymbol = false; + OUString sNatNumParams; + Locale locale; + + OUString prefix; + sal_Int16 numType = -1; // type of formatting from style::NumberingType (roman, arabic, etc) + OUString suffix; + sal_Int32 number = -1; // the number that needs to be formatted. + +// int nProperties = aProperties.getLength(); +// int last = nProperties-1; + + for (auto const & prop : aProperties) + { + if (prop.Name == "Prefix") + prop.Value >>= prefix; + else if (prop.Name == "Suffix") + prop.Value >>= suffix; + else if (prop.Name == "NumberingType") + prop.Value >>= numType; + else if (prop.Name == "Value") + prop.Value >>= number; + } + + if( number <= 0 ) + throw IllegalArgumentException(); + + // start empty + OUString result; + + // append prefix + if( !should_ignore(prefix) ) result += prefix; + + // append formatted number + using namespace style::NumberingType; + switch( numType ) + { + case CHARS_UPPER_LETTER: + lcl_formatChars( upperLetter, 26, number-1, result ); // 1=>A, 2=>B, ..., 26=>Z, 27=>AA, 28=>AB, ... + break; + case CHARS_LOWER_LETTER: + lcl_formatChars( lowerLetter, 26, number-1, result ); + break; + case TEXT_NUMBER: // ordinal indicators (1st, 2nd, 3rd, ...) + natNum = NativeNumberMode::NATNUM12; + sNatNumParams = "capitalize ordinal-number"; + locale = aLocale; + break; + case TEXT_CARDINAL: // cardinal number names (One, Two, Three, ...) + natNum = NativeNumberMode::NATNUM12; + sNatNumParams = "capitalize"; + locale = aLocale; + break; + case TEXT_ORDINAL: // ordinal number names (First, Second, Third, ...) + natNum = NativeNumberMode::NATNUM12; + sNatNumParams = "capitalize ordinal"; + locale = aLocale; + break; + case ROMAN_UPPER: + result += toRoman( number ); + break; + case ROMAN_LOWER: + result += toRoman( number ).toAsciiLowerCase(); + break; + case ARABIC: + result += OUString::number( number ); + break; + case NUMBER_NONE: + return OUString(); // ignore prefix and suffix + case CHAR_SPECIAL: + // apparently, we're supposed to return an empty string in this case... + return OUString(); // ignore prefix and suffix + case PAGE_DESCRIPTOR: + case BITMAP: + OSL_ASSERT(false); + throw IllegalArgumentException(); + case CHARS_UPPER_LETTER_N: + lcl_formatChars1( upperLetter, 26, number-1, result ); // 1=>A, 2=>B, ..., 26=>Z, 27=>AA, 28=>BB, ... + break; + case CHARS_LOWER_LETTER_N: + lcl_formatChars1( lowerLetter, 26, number-1, result ); // 1=>A, 2=>B, ..., 26=>Z, 27=>AA, 28=>BB, ... + break; + case TRANSLITERATION: + try { + const OUString &tmp = OUString::number( number ); + OUString transliteration; + getPropertyByName(aProperties, "Transliteration") >>= transliteration; + if ( !translit ) + translit = new TransliterationImpl(m_xContext); + translit->loadModuleByImplName(transliteration, aLocale); + result += translit->transliterateString2String(tmp, 0, tmp.getLength()); + } catch (Exception& ) { + // When transliteration property is missing, return default number (bug #101141#) + result += OUString::number( number ); + // OSL_ASSERT(0); + // throw IllegalArgumentException(); + } + break; + case NATIVE_NUMBERING: + natNum = NativeNumberMode::NATNUM1; + locale = aLocale; + break; + case FULLWIDTH_ARABIC: + natNum = NativeNumberMode::NATNUM3; + locale = aLocale; + break; + case NUMBER_LOWER_ZH: + natNum = NativeNumberMode::NATNUM12; + locale.Language = "zh"; + break; + case NUMBER_UPPER_ZH: + natNum = NativeNumberMode::NATNUM5; + locale.Language = "zh"; + break; + case NUMBER_UPPER_ZH_TW: + natNum = NativeNumberMode::NATNUM5; + locale.Language = "zh"; + locale.Country = "TW"; + break; + case NUMBER_TRADITIONAL_JA: + natNum = NativeNumberMode::NATNUM8; + locale.Language = "ja"; + break; + case NUMBER_UPPER_KO: + natNum = NativeNumberMode::NATNUM8; + locale.Language = "ko"; + break; + case NUMBER_HANGUL_KO: + natNum = NativeNumberMode::NATNUM11; + locale.Language = "ko"; + break; + case NUMBER_DIGITAL_KO: + natNum = NativeNumberMode::NATNUM9; + locale.Language = "ko"; + break; + case NUMBER_DIGITAL2_KO: + natNum = NativeNumberMode::NATNUM1; + locale.Language = "ko"; + break; + case NUMBER_LEGAL_KO: + if (number < 1 || number >= 100) + { + natNum = NativeNumberMode::NATNUM11; + locale.Language = "ko"; + } + else + { + lcl_formatKoreanLegalWord(number, result); + } + break; + + case CIRCLE_NUMBER: + table = table_CircledNumber; + tableSize = SAL_N_ELEMENTS(table_CircledNumber); + break; + case TIAN_GAN_ZH: + table = table_TianGan_zh; + tableSize = SAL_N_ELEMENTS(table_TianGan_zh); + break; + case DI_ZI_ZH: + table = table_DiZi_zh; + tableSize = SAL_N_ELEMENTS(table_DiZi_zh); + break; + case AIU_FULLWIDTH_JA: + table = table_AIUFullWidth_ja_JP; + tableSize = SAL_N_ELEMENTS(table_AIUFullWidth_ja_JP); + bRecycleSymbol = true; + break; + case AIU_HALFWIDTH_JA: + table = table_AIUHalfWidth_ja_JP; + tableSize = SAL_N_ELEMENTS(table_AIUHalfWidth_ja_JP); + bRecycleSymbol = true; + break; + case IROHA_FULLWIDTH_JA: + table = table_IROHAFullWidth_ja_JP; + tableSize = SAL_N_ELEMENTS(table_IROHAFullWidth_ja_JP); + bRecycleSymbol = true; + break; + case IROHA_HALFWIDTH_JA: + table = table_IROHAHalfWidth_ja_JP; + tableSize = SAL_N_ELEMENTS(table_IROHAHalfWidth_ja_JP); + bRecycleSymbol = true; + break; + case HANGUL_JAMO_KO: + table = table_HangulJamo_ko; + tableSize = SAL_N_ELEMENTS(table_HangulJamo_ko); + bRecycleSymbol = true; + break; + case HANGUL_SYLLABLE_KO: + table = table_HangulSyllable_ko; + tableSize = SAL_N_ELEMENTS(table_HangulSyllable_ko); + bRecycleSymbol = true; + break; + case HANGUL_CIRCLED_JAMO_KO: + table = table_HangulCircledJamo_ko; + tableSize = SAL_N_ELEMENTS(table_HangulCircledJamo_ko); + bRecycleSymbol = true; + break; + case HANGUL_CIRCLED_SYLLABLE_KO: + table = table_HangulCircledSyllable_ko; + tableSize = SAL_N_ELEMENTS(table_HangulCircledSyllable_ko); + bRecycleSymbol = true; + break; + case CHARS_ARABIC: + lcl_formatChars(table_Alphabet_ar, SAL_N_ELEMENTS(table_Alphabet_ar), number - 1, result); + break; + case CHARS_ARABIC_ABJAD: + lcl_formatChars(table_Alphabet_ar_abjad, SAL_N_ELEMENTS(table_Alphabet_ar_abjad), number - 1, result); + break; + case NUMBER_ARABIC_INDIC: + natNum = NativeNumberMode::NATNUM1; + locale.Language = "ar"; + break; + case NUMBER_EAST_ARABIC_INDIC: + natNum = NativeNumberMode::NATNUM1; + locale.Language = "fa"; + break; + case NUMBER_INDIC_DEVANAGARI: + natNum = NativeNumberMode::NATNUM1; + locale.Language = "hi"; + break; + case CHARS_THAI: + lcl_formatChars(table_Alphabet_th, SAL_N_ELEMENTS(table_Alphabet_th), number - 1, result); + break; + case CHARS_HEBREW: + lcl_formatChars(table_Alphabet_he, SAL_N_ELEMENTS(table_Alphabet_he), number - 1, result); + break; + case NUMBER_HEBREW: + natNum = NativeNumberMode::NATNUM1; + locale.Language = "he"; + break; + case CHARS_NEPALI: + lcl_formatChars(table_Alphabet_ne, SAL_N_ELEMENTS(table_Alphabet_ne), number - 1, result); + break; + case CHARS_KHMER: + lcl_formatChars(table_Alphabet_km, SAL_N_ELEMENTS(table_Alphabet_km), number - 1, result); + break; + case CHARS_LAO: + lcl_formatChars(table_Alphabet_lo, SAL_N_ELEMENTS(table_Alphabet_lo), number - 1, result); + break; + case CHARS_MYANMAR: + lcl_formatChars(table_Alphabet_my, SAL_N_ELEMENTS(table_Alphabet_my), number - 1, result); + break; + case CHARS_TIBETAN: + lcl_formatChars(table_Alphabet_dz, SAL_N_ELEMENTS(table_Alphabet_dz), number - 1, result); + break; + case CHARS_CYRILLIC_UPPER_LETTER_BG: + lcl_formatChars2( table_CyrillicUpperLetter_bg, + table_CyrillicLowerLetter_bg, + SAL_N_ELEMENTS(table_CyrillicLowerLetter_bg), number-1, + result); // 1=>a, 2=>b, ..., 28=>z, 29=>Aa, 30=>Ab, ... + break; + case CHARS_CYRILLIC_LOWER_LETTER_BG: + lcl_formatChars( table_CyrillicLowerLetter_bg, + SAL_N_ELEMENTS(table_CyrillicLowerLetter_bg), number-1, + result); // 1=>a, 2=>b, ..., 28=>z, 29=>aa, 30=>ab, ... + break; + case CHARS_CYRILLIC_UPPER_LETTER_N_BG: + lcl_formatChars3( table_CyrillicUpperLetter_bg, + table_CyrillicLowerLetter_bg, + SAL_N_ELEMENTS(table_CyrillicLowerLetter_bg), number-1, + result); // 1=>a, 2=>b, ..., 28=>z, 29=>Aa, 30=>Bb, ... + break; + case CHARS_CYRILLIC_LOWER_LETTER_N_BG: + lcl_formatChars1( table_CyrillicLowerLetter_bg, + SAL_N_ELEMENTS(table_CyrillicLowerLetter_bg), number-1, + result); // 1=>a, 2=>b, ..., 28=>z, 29=>aa, 30=>bb, ... + break; + case CHARS_CYRILLIC_UPPER_LETTER_RU: + lcl_formatChars2( table_CyrillicUpperLetter_ru, + table_CyrillicLowerLetter_ru, + SAL_N_ELEMENTS(table_CyrillicLowerLetter_ru), number-1, + result); // 1=>a, 2=>b, ..., 27=>z, 28=>Aa, 29=>Ab, ... + break; + case CHARS_CYRILLIC_LOWER_LETTER_RU: + lcl_formatChars( table_CyrillicLowerLetter_ru, + SAL_N_ELEMENTS(table_CyrillicLowerLetter_ru), number-1, + result); // 1=>a, 2=>b, ..., 27=>z, 28=>aa, 29=>ab, ... + break; + case CHARS_CYRILLIC_UPPER_LETTER_N_RU: + lcl_formatChars3( table_CyrillicUpperLetter_ru, + table_CyrillicLowerLetter_ru, + SAL_N_ELEMENTS(table_CyrillicLowerLetter_ru), number-1, + result); // 1=>a, 2=>b, ..., 27=>z, 28=>Aa, 29=>Bb, ... + break; + case CHARS_CYRILLIC_LOWER_LETTER_N_RU: + lcl_formatChars1( table_CyrillicLowerLetter_ru, + SAL_N_ELEMENTS(table_CyrillicLowerLetter_ru), number-1, + result); // 1=>a, 2=>b, ..., 27=>z, 28=>aa, 29=>bb, ... + break; + case CHARS_CYRILLIC_UPPER_LETTER_SR: + lcl_formatChars2( table_CyrillicUpperLetter_sr, + table_CyrillicLowerLetter_sr, + SAL_N_ELEMENTS(table_CyrillicLowerLetter_sr), number-1, + result); // 1=>a, 2=>b, ..., 27=>z, 28=>Aa, 29=>Ab, ... + break; + case CHARS_CYRILLIC_LOWER_LETTER_SR: + lcl_formatChars( table_CyrillicLowerLetter_sr, + SAL_N_ELEMENTS(table_CyrillicLowerLetter_sr), number-1, + result); // 1=>a, 2=>b, ..., 27=>z, 28=>aa, 29=>ab, ... + break; + case CHARS_CYRILLIC_UPPER_LETTER_N_SR: + lcl_formatChars3( table_CyrillicUpperLetter_sr, + table_CyrillicLowerLetter_sr, + SAL_N_ELEMENTS(table_CyrillicLowerLetter_sr), number-1, + result); // 1=>a, 2=>b, ..., 27=>z, 28=>Aa, 29=>Bb, ... + break; + case CHARS_CYRILLIC_LOWER_LETTER_N_SR: + lcl_formatChars1( table_CyrillicLowerLetter_sr, + SAL_N_ELEMENTS(table_CyrillicLowerLetter_sr), number-1, + result); // 1=>a, 2=>b, ..., 27=>z, 28=>aa, 29=>bb, ... + break; + + case CHARS_GREEK_LOWER_LETTER: + lcl_formatCharsGR( table_GreekLowerLetter, number, result); + break; + + case CHARS_GREEK_UPPER_LETTER: + lcl_formatCharsGR( table_GreekUpperLetter, number, result); + break; + + case CHARS_PERSIAN: + lcl_formatChars(table_Alphabet_fa, SAL_N_ELEMENTS(table_Alphabet_fa), number - 1, result); + break; + + case CHARS_PERSIAN_WORD: + lcl_formatPersianWord(number, result); + break; + + case SYMBOL_CHICAGO: + lcl_formatChars1( table_Chicago, 4, number-1, result ); // *, +, |, S, **, ++, ... + break; + + case ARABIC_ZERO: + result += lcl_formatArabicZero(number, 2); + break; + + case ARABIC_ZERO3: + result += lcl_formatArabicZero(number, 3); + break; + + case ARABIC_ZERO4: + result += lcl_formatArabicZero(number, 4); + break; + + case ARABIC_ZERO5: + result += lcl_formatArabicZero(number, 5); + break; + + case SZEKELY_ROVAS: // Old Hungarian + natNum = NativeNumberMode::NATNUM12; + locale.Language = "hu-Hung"; + break; + + default: + OSL_ASSERT(false); + throw IllegalArgumentException(); + } + + if (natNum) { + if (!mxNatNum) + mxNatNum.set(new NativeNumberSupplierService); + result += mxNatNum->getNativeNumberStringParams(OUString::number(number), locale, + natNum, sNatNumParams); + } else if (tableSize) { + if ( number > tableSize && !bRecycleSymbol) + result += OUString::number( number); + else + result += OUStringChar(table[--number % tableSize]); + } + + // append suffix + if( !should_ignore(suffix) ) result += suffix; + + return result; +} + +#define LANG_ALL (1 << 0) +#define LANG_CJK (1 << 1) +#define LANG_CTL (1 << 2) + +struct Supported_NumberingType +{ + const char* cSymbol; + sal_Int16 nType; + sal_Int16 langOption; + Supported_NumberingType(sal_Int16 nType_, const char* pSymbol, sal_Int16 opt) + : cSymbol(pSymbol), nType(nType_), langOption(opt) {} +}; +const Supported_NumberingType aSupportedTypes[] = +{ + {style::NumberingType::CHARS_UPPER_LETTER, "A", LANG_ALL}, + {style::NumberingType::CHARS_LOWER_LETTER, "a", LANG_ALL}, + {style::NumberingType::ROMAN_UPPER, "I", LANG_ALL}, + {style::NumberingType::ROMAN_LOWER, "i", LANG_ALL}, + {style::NumberingType::ARABIC, "1", LANG_ALL}, + {style::NumberingType::NUMBER_NONE, "''", LANG_ALL}, + {style::NumberingType::CHAR_SPECIAL, "Bullet", LANG_ALL}, + {style::NumberingType::PAGE_DESCRIPTOR, "Page", LANG_ALL}, + {style::NumberingType::BITMAP, "Bitmap", LANG_ALL}, + {style::NumberingType::SYMBOL_CHICAGO, "*, " S_DAGGER ", " S_DBL_DAGGER ", " S_SECTION ", **, " S_DAGGER S_DAGGER ", ...", LANG_ALL}, + {style::NumberingType::TEXT_NUMBER, "1st", LANG_ALL}, + {style::NumberingType::TEXT_CARDINAL, "One", LANG_ALL}, + {style::NumberingType::TEXT_ORDINAL, "First", LANG_ALL}, + {style::NumberingType::CHARS_UPPER_LETTER_N, "AAA", LANG_ALL}, + {style::NumberingType::CHARS_LOWER_LETTER_N, "aaa", LANG_ALL}, + {style::NumberingType::NATIVE_NUMBERING, "Native Numbering", LANG_CJK|LANG_CTL}, + {style::NumberingType::FULLWIDTH_ARABIC, nullptr, LANG_CJK}, + {style::NumberingType::CIRCLE_NUMBER, nullptr, LANG_CJK}, + // The cSymbol is defined here for compatibility with files created by old releases. + // Otherwise if nullptr, these 3 digits may change as NATNUM12 depends on 3rd-party lib. + {style::NumberingType::NUMBER_LOWER_ZH, "一, 二, 三, ...", LANG_CJK}, + {style::NumberingType::NUMBER_UPPER_ZH, nullptr, LANG_CJK}, + {style::NumberingType::NUMBER_UPPER_ZH_TW, nullptr, LANG_CJK}, + {style::NumberingType::TIAN_GAN_ZH, nullptr, LANG_CJK}, + {style::NumberingType::DI_ZI_ZH, nullptr, LANG_CJK}, + {style::NumberingType::NUMBER_TRADITIONAL_JA, nullptr, LANG_CJK}, + {style::NumberingType::AIU_FULLWIDTH_JA, nullptr, LANG_CJK}, + {style::NumberingType::AIU_HALFWIDTH_JA, nullptr, LANG_CJK}, + {style::NumberingType::IROHA_FULLWIDTH_JA, nullptr, LANG_CJK}, + {style::NumberingType::IROHA_HALFWIDTH_JA, nullptr, LANG_CJK}, + {style::NumberingType::NUMBER_UPPER_KO, nullptr, LANG_CJK}, + {style::NumberingType::NUMBER_HANGUL_KO, nullptr, LANG_CJK}, + {style::NumberingType::HANGUL_JAMO_KO, nullptr, LANG_CJK}, + {style::NumberingType::HANGUL_SYLLABLE_KO, nullptr, LANG_CJK}, + {style::NumberingType::HANGUL_CIRCLED_JAMO_KO, nullptr, LANG_CJK}, + {style::NumberingType::HANGUL_CIRCLED_SYLLABLE_KO, nullptr, LANG_CJK}, + {style::NumberingType::NUMBER_LEGAL_KO, nullptr, LANG_CJK}, + {style::NumberingType::NUMBER_DIGITAL_KO, nullptr, LANG_CJK}, + {style::NumberingType::NUMBER_DIGITAL2_KO, nullptr, LANG_CJK}, + {style::NumberingType::CHARS_ARABIC, nullptr, LANG_CTL}, + {style::NumberingType::CHARS_ARABIC_ABJAD, nullptr, LANG_CTL}, + {style::NumberingType::NUMBER_ARABIC_INDIC, S_AR_ONE ", " S_AR_TWO ", " S_AR_THREE ", ...", LANG_CTL}, + {style::NumberingType::NUMBER_EAST_ARABIC_INDIC, S_FA_ONE ", " S_FA_TWO ", " S_FA_THREE ", ...", LANG_CTL}, + {style::NumberingType::NUMBER_INDIC_DEVANAGARI, S_HI_ONE ", " S_HI_TWO ", " S_HI_THREE ", ...", LANG_CTL}, + {style::NumberingType::CHARS_THAI, nullptr, LANG_CTL}, + {style::NumberingType::CHARS_HEBREW, nullptr, LANG_CTL}, + {style::NumberingType::NUMBER_HEBREW, S_HE_ALEPH ", " S_HE_YOD ", " S_HE_QOF ", ...", LANG_CTL}, + {style::NumberingType::CHARS_NEPALI, nullptr, LANG_CTL}, + {style::NumberingType::CHARS_KHMER, nullptr, LANG_CTL}, + {style::NumberingType::CHARS_LAO, nullptr, LANG_CTL}, + {style::NumberingType::CHARS_MYANMAR, nullptr, LANG_CTL}, + {style::NumberingType::CHARS_TIBETAN, nullptr, LANG_CTL}, + {style::NumberingType::CHARS_CYRILLIC_UPPER_LETTER_BG, C_CYR_A ", " C_CYR_B ", .., " C_CYR_A S_CYR_A ", " C_CYR_A S_CYR_B ", ... (bg)", LANG_ALL}, + {style::NumberingType::CHARS_CYRILLIC_LOWER_LETTER_BG, S_CYR_A ", " S_CYR_B ", .., " S_CYR_A S_CYR_A ", " S_CYR_A S_CYR_B ", ... (bg)", LANG_ALL}, + {style::NumberingType::CHARS_CYRILLIC_UPPER_LETTER_N_BG, C_CYR_A ", " C_CYR_B ", .., " C_CYR_A S_CYR_A ", " C_CYR_B S_CYR_B ", ... (bg)", LANG_ALL}, + {style::NumberingType::CHARS_CYRILLIC_LOWER_LETTER_N_BG, S_CYR_A ", " S_CYR_B ", .., " S_CYR_A S_CYR_A ", " S_CYR_B S_CYR_B ", ... (bg)", LANG_ALL}, + {style::NumberingType::CHARS_CYRILLIC_UPPER_LETTER_RU, C_CYR_A ", " C_CYR_B ", .., " C_CYR_A S_CYR_A ", " C_CYR_A S_CYR_B ", ... (ru)", LANG_ALL}, + {style::NumberingType::CHARS_CYRILLIC_LOWER_LETTER_RU, S_CYR_A ", " S_CYR_B ", .., " S_CYR_A S_CYR_A ", " S_CYR_A S_CYR_B ", ... (ru)", LANG_ALL}, + {style::NumberingType::CHARS_CYRILLIC_UPPER_LETTER_N_RU, C_CYR_A ", " C_CYR_B ", .., " C_CYR_A S_CYR_A ", " C_CYR_B S_CYR_B ", ... (ru)", LANG_ALL}, + {style::NumberingType::CHARS_CYRILLIC_LOWER_LETTER_N_RU, S_CYR_A ", " S_CYR_B ", .., " S_CYR_A S_CYR_A ", " S_CYR_B S_CYR_B ", ... (ru)", LANG_ALL}, + {style::NumberingType::CHARS_CYRILLIC_UPPER_LETTER_SR, C_CYR_A ", " C_CYR_B ", .., " C_CYR_A S_CYR_A ", " C_CYR_A S_CYR_B ", ... (sr)", LANG_ALL}, + {style::NumberingType::CHARS_CYRILLIC_LOWER_LETTER_SR, S_CYR_A ", " S_CYR_B ", .., " S_CYR_A S_CYR_A ", " S_CYR_A S_CYR_B ", ... (sr)", LANG_ALL}, + {style::NumberingType::CHARS_CYRILLIC_UPPER_LETTER_N_SR, C_CYR_A ", " C_CYR_B ", .., " C_CYR_A S_CYR_A ", " C_CYR_B S_CYR_B ", ... (sr)", LANG_ALL}, + {style::NumberingType::CHARS_CYRILLIC_LOWER_LETTER_N_SR, S_CYR_A ", " S_CYR_B ", .., " S_CYR_A S_CYR_A ", " S_CYR_B S_CYR_B ", ... (sr)", LANG_ALL}, + {style::NumberingType::CHARS_PERSIAN, nullptr, LANG_CTL}, + {style::NumberingType::CHARS_PERSIAN_WORD, nullptr, LANG_CTL}, + {style::NumberingType::SZEKELY_ROVAS, nullptr, LANG_CTL}, + {style::NumberingType::CHARS_GREEK_UPPER_LETTER, C_GR_A ", " C_GR_B ", ... (gr)", LANG_ALL}, + {style::NumberingType::CHARS_GREEK_LOWER_LETTER, S_GR_A ", " S_GR_B ", ... (gr)", LANG_ALL}, + {style::NumberingType::ARABIC_ZERO, "01, 02, 03, ...", LANG_ALL}, + {style::NumberingType::ARABIC_ZERO3, "001, 002, 003, ...", LANG_ALL}, + {style::NumberingType::ARABIC_ZERO4, "0001, 0002, 0003, ...", LANG_ALL}, + {style::NumberingType::ARABIC_ZERO5, "00001, 00002, 00003, ...", LANG_ALL}, +}; +const sal_Int32 nSupported_NumberingTypes = SAL_N_ELEMENTS(aSupportedTypes); + +OUString DefaultNumberingProvider::makeNumberingIdentifier(sal_Int16 index) +{ + if (index < 0 || index >= nSupported_NumberingTypes) + throw RuntimeException(); + + if (aSupportedTypes[index].cSymbol) + return OUString(aSupportedTypes[index].cSymbol, strlen(aSupportedTypes[index].cSymbol), RTL_TEXTENCODING_UTF8); + else { + OUStringBuffer result; + Locale aLocale("en", OUString(), OUString()); + Sequence<beans::PropertyValue> aProperties(2); + auto aPropertiesRange = asNonConstRange(aProperties); + aPropertiesRange[0].Name = "NumberingType"; + aPropertiesRange[0].Value <<= aSupportedTypes[index].nType; + aPropertiesRange[1].Name = "Value"; + for (sal_Int32 j = 1; j <= 3; j++) { + aPropertiesRange[1].Value <<= j; + result.append( makeNumberingString( aProperties, aLocale ) ); + result.append(", "); + } + result.append("..."); + // Make known duplicate generated identifiers unique. + // Note this alone works only for newly added numberings, if duplicates + // are in the wild further handling is needed when loading documents + // and asking for numberings. + switch (aSupportedTypes[index].nType) + { + case css::style::NumberingType::NUMBER_DIGITAL_KO: + // Duplicate of NUMBER_HANGUL_KO. + result.append(" (ko-x-digital)"); + break; + case css::style::NumberingType::NUMBER_DIGITAL2_KO: + // Duplicate of NUMBER_LOWER_ZH. + result.append(" (ko)"); + break; + default: + ; // nothing + } + return result.makeStringAndClear(); + } +} + +bool +DefaultNumberingProvider::isScriptFlagEnabled(const OUString& aName) +{ + if (! xHierarchicalNameAccess.is()) { + Reference< XMultiServiceFactory > xConfigProvider = + configuration::theDefaultProvider::get(m_xContext); + + if (! xConfigProvider.is()) + throw RuntimeException(); + + uno::Sequence<uno::Any> aArgs(comphelper::InitAnyPropertySequence( + { + {"nodepath", uno::Any(OUString("/org.openoffice.Office.Common/I18N"))} + })); + + Reference<XInterface> xInterface = xConfigProvider->createInstanceWithArguments( + "com.sun.star.configuration.ConfigurationAccess", aArgs); + + xHierarchicalNameAccess.set(xInterface, UNO_QUERY_THROW); + } + + Any aEnabled = xHierarchicalNameAccess->getByHierarchicalName(aName); + + bool enabled = false; + + aEnabled >>= enabled; + + return enabled; +} + +Sequence< sal_Int16 > DefaultNumberingProvider::getSupportedNumberingTypes( ) +{ + Sequence< sal_Int16 > aRet(nSupported_NumberingTypes ); + sal_Int16* pArray = aRet.getArray(); + + bool cjkEnabled = isScriptFlagEnabled("CJK/CJKFont"); + bool ctlEnabled = isScriptFlagEnabled("CTL/CTLFont"); + + for(sal_Int16 i = 0; i < nSupported_NumberingTypes; i++) { + if ( (aSupportedTypes[i].langOption & LANG_ALL) || + ((aSupportedTypes[i].langOption & LANG_CJK) && cjkEnabled) || + ((aSupportedTypes[i].langOption & LANG_CTL) && ctlEnabled) ) + pArray[i] = aSupportedTypes[i].nType; + } + return aRet; +} + +sal_Int16 DefaultNumberingProvider::getNumberingType( const OUString& rNumberingIdentifier ) +{ + auto it = maSupportedTypesCache.find(rNumberingIdentifier); + if (it != maSupportedTypesCache.end()) + return it->second->nType; + for(sal_Int16 i = 0; i < nSupported_NumberingTypes; i++) + if(rNumberingIdentifier == makeNumberingIdentifier(i)) + { + maSupportedTypesCache.emplace(rNumberingIdentifier, &aSupportedTypes[i]); + return aSupportedTypes[i].nType; + } + throw RuntimeException(); +} + +sal_Bool DefaultNumberingProvider::hasNumberingType( const OUString& rNumberingIdentifier ) +{ + auto it = maSupportedTypesCache.find(rNumberingIdentifier); + if (it != maSupportedTypesCache.end()) + return true; + for(sal_Int16 i = 0; i < nSupported_NumberingTypes; i++) + if(rNumberingIdentifier == makeNumberingIdentifier(i)) + { + maSupportedTypesCache.emplace(rNumberingIdentifier, &aSupportedTypes[i]); + return true; + } + return false; +} + +OUString DefaultNumberingProvider::getNumberingIdentifier( sal_Int16 nNumberingType ) +{ + for(sal_Int16 i = 0; i < nSupported_NumberingTypes; i++) + if(nNumberingType == aSupportedTypes[i].nType) + return makeNumberingIdentifier(i); + return OUString(); +} + +OUString DefaultNumberingProvider::getImplementationName() +{ + return "com.sun.star.text.DefaultNumberingProvider"; +} + +sal_Bool DefaultNumberingProvider::supportsService(const OUString& rServiceName) +{ + return cppu::supportsService(this, rServiceName); +} + +Sequence< OUString > DefaultNumberingProvider::getSupportedServiceNames() +{ + Sequence< OUString > aRet { "com.sun.star.text.DefaultNumberingProvider" }; + return aRet; +} + +} + +extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface * +com_sun_star_text_DefaultNumberingProvider_get_implementation( + css::uno::XComponentContext *context, + css::uno::Sequence<css::uno::Any> const &) +{ + return cppu::acquire(new i18npool::DefaultNumberingProvider(context)); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |