/**************************************************************
*
* 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
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_i18npool.hxx"
#include <localedata.hxx>
#include <i18npool/mslangid.hxx>
#include <rtl/ustrbuf.hxx>
#include <string.h>
#include <stdio.h>
#include "rtl/instance.hxx"
using namespace com::sun::star::i18n;
using namespace com::sun::star::uno;
using namespace com::sun::star::lang;
using namespace com::sun::star;
using namespace rtl;
static const sal_Char clocaledata[] = "com.sun.star.i18n.LocaleData";
typedef sal_Unicode** (SAL_CALL * MyFunc_Type)( sal_Int16&);
typedef sal_Unicode*** (SAL_CALL * MyFunc_Type2)( sal_Int16&, sal_Int16& );
typedef sal_Unicode**** (SAL_CALL * MyFunc_Type3)( sal_Int16&, sal_Int16&, sal_Int16& );
typedef sal_Unicode const * const * (SAL_CALL * MyFunc_FormatCode)( sal_Int16&, sal_Unicode const *&, sal_Unicode const *& );
#ifdef OS2 // YD 8.3!!
static const char *lcl_DATA_EN = "ld_en";
static const char *lcl_DATA_ES = "ld_es";
static const char *lcl_DATA_EURO = "ld_eur";
static const char *lcl_DATA_OTHERS = "ld_oth";
#else
static const char *lcl_DATA_EN = "localedata_en";
static const char *lcl_DATA_ES = "localedata_es";
static const char *lcl_DATA_EURO = "localedata_euro";
static const char *lcl_DATA_OTHERS = "localedata_others";
#endif
static const struct {
const char* pLocale;
const char* pLib;
} aLibTable[] = {
{ "en_US", lcl_DATA_EN },
{ "en_AU", lcl_DATA_EN },
{ "en_BZ", lcl_DATA_EN },
{ "en_CA", lcl_DATA_EN },
{ "en_GB", lcl_DATA_EN },
{ "en_IE", lcl_DATA_EN },
{ "en_JM", lcl_DATA_EN },
{ "en_NZ", lcl_DATA_EN },
{ "en_PH", lcl_DATA_EN },
{ "en_TT", lcl_DATA_EN },
{ "en_ZA", lcl_DATA_EN },
{ "en_ZW", lcl_DATA_EN },
{ "en_NA", lcl_DATA_EN },
{ "en_GH", lcl_DATA_EN },
{ "es_ES", lcl_DATA_ES },
{ "es_AR", lcl_DATA_ES },
{ "es_BO", lcl_DATA_ES },
{ "es_CL", lcl_DATA_ES },
{ "es_CO", lcl_DATA_ES },
{ "es_CR", lcl_DATA_ES },
{ "es_DO", lcl_DATA_ES },
{ "es_EC", lcl_DATA_ES },
{ "es_GT", lcl_DATA_ES },
{ "es_HN", lcl_DATA_ES },
{ "es_MX", lcl_DATA_ES },
{ "es_NI", lcl_DATA_ES },
{ "es_PA", lcl_DATA_ES },
{ "es_PE", lcl_DATA_ES },
{ "es_PR", lcl_DATA_ES },
{ "es_PY", lcl_DATA_ES },
{ "es_SV", lcl_DATA_ES },
{ "es_UY", lcl_DATA_ES },
{ "es_VE", lcl_DATA_ES },
{ "gl_ES", lcl_DATA_ES },
{ "de_DE", lcl_DATA_EURO },
{ "de_AT", lcl_DATA_EURO },
{ "de_CH", lcl_DATA_EURO },
{ "de_LI", lcl_DATA_EURO },
{ "de_LU", lcl_DATA_EURO },
{ "fr_FR", lcl_DATA_EURO },
{ "fr_BE", lcl_DATA_EURO },
{ "fr_CA", lcl_DATA_EURO },
{ "fr_CH", lcl_DATA_EURO },
{ "fr_LU", lcl_DATA_EURO },
{ "fr_MC", lcl_DATA_EURO },
{ "it_IT", lcl_DATA_EURO },
{ "it_CH", lcl_DATA_EURO },
{ "sl_SI", lcl_DATA_EURO },
{ "sv_SE", lcl_DATA_EURO },
{ "sv_FI", lcl_DATA_EURO },
{ "ca_ES", lcl_DATA_EURO },
{ "cs_CZ", lcl_DATA_EURO },
{ "sk_SK", lcl_DATA_EURO },
{ "da_DK", lcl_DATA_EURO },
{ "el_GR", lcl_DATA_EURO },
{ "fi_FI", lcl_DATA_EURO },
{ "is_IS", lcl_DATA_EURO },
{ "nl_BE", lcl_DATA_EURO },
{ "nl_NL", lcl_DATA_EURO },
{ "no_NO", lcl_DATA_EURO },
{ "nn_NO", lcl_DATA_EURO },
{ "nb_NO", lcl_DATA_EURO },
{ "pl_PL", lcl_DATA_EURO },
{ "pt_BR", lcl_DATA_EURO },
{ "pt_PT", lcl_DATA_EURO },
{ "ru_RU", lcl_DATA_EURO },
{ "tr_TR", lcl_DATA_EURO },
{ "et_EE", lcl_DATA_EURO },
{ "lb_LU", lcl_DATA_EURO },
{ "lt_LT", lcl_DATA_EURO },
{ "lv_LV", lcl_DATA_EURO },
{ "uk_UA", lcl_DATA_EURO },
{ "ro_RO", lcl_DATA_EURO },
{ "cy_GB", lcl_DATA_EURO },
{ "bg_BG", lcl_DATA_EURO },
{ "sh_ME", lcl_DATA_EURO },
{ "sh_RS", lcl_DATA_EURO },
{ "sh_YU", lcl_DATA_EURO },
{ "sr_ME", lcl_DATA_EURO },
{ "sr_RS", lcl_DATA_EURO },
{ "sr_YU", lcl_DATA_EURO },
{ "hr_HR", lcl_DATA_EURO },
{ "bs_BA", lcl_DATA_EURO },
{ "eu", lcl_DATA_EURO },
{ "fo_FO", lcl_DATA_EURO },
{ "ga_IE", lcl_DATA_EURO },
{ "gd_GB", lcl_DATA_EURO },
{ "ka_GE", lcl_DATA_EURO },
{ "be_BY", lcl_DATA_EURO },
{ "kl_GL", lcl_DATA_EURO },
{ "mk_MK", lcl_DATA_EURO },
{ "br_FR", lcl_DATA_EURO },
{ "la_VA", lcl_DATA_EURO },
{ "cv_RU", lcl_DATA_EURO },
{ "wa_BE", lcl_DATA_EURO },
{ "fur_IT", lcl_DATA_EURO },
{ "gsc_FR", lcl_DATA_EURO },
{ "fy_NL", lcl_DATA_EURO },
{ "oc_FR", lcl_DATA_EURO },
{ "mt_MT", lcl_DATA_EURO },
{ "sc_IT", lcl_DATA_EURO },
{ "ast_ES", lcl_DATA_EURO },
{ "ltg_LV", lcl_DATA_EURO },
{ "hsb_DE", lcl_DATA_EURO },
{ "dsb_DE", lcl_DATA_EURO },
{ "rue_SK", lcl_DATA_EURO },
{ "ja_JP", lcl_DATA_OTHERS },
{ "ko_KR", lcl_DATA_OTHERS },
{ "zh_CN", lcl_DATA_OTHERS },
{ "zh_HK", lcl_DATA_OTHERS },
{ "zh_SG", lcl_DATA_OTHERS },
{ "zh_TW", lcl_DATA_OTHERS },
{ "zh_MO", lcl_DATA_OTHERS },
{ "ar_EG", lcl_DATA_OTHERS },
{ "ar_DZ", lcl_DATA_OTHERS },
{ "ar_LB", lcl_DATA_OTHERS },
{ "ar_SA", lcl_DATA_OTHERS },
{ "ar_TN", lcl_DATA_OTHERS },
{ "he_IL", lcl_DATA_OTHERS },
{ "hi_IN", lcl_DATA_OTHERS },
{ "kn_IN", lcl_DATA_OTHERS },
{ "ta_IN", lcl_DATA_OTHERS },
{ "te_IN", lcl_DATA_OTHERS },
{ "gu_IN", lcl_DATA_OTHERS },
{ "mr_IN", lcl_DATA_OTHERS },
{ "pa_IN", lcl_DATA_OTHERS },
{ "bn_IN", lcl_DATA_OTHERS },
{ "or_IN", lcl_DATA_OTHERS },
{ "en_IN", lcl_DATA_OTHERS },
{ "ml_IN", lcl_DATA_OTHERS },
{ "bn_BD", lcl_DATA_OTHERS },
{ "th_TH", lcl_DATA_OTHERS },
{ "af_ZA", lcl_DATA_OTHERS },
{ "hu_HU", lcl_DATA_OTHERS },
{ "id_ID", lcl_DATA_OTHERS },
{ "ms_MY", lcl_DATA_OTHERS },
{ "ia", lcl_DATA_OTHERS },
{ "mn_MN", lcl_DATA_OTHERS },
{ "az_AZ", lcl_DATA_OTHERS },
{ "sw_TZ", lcl_DATA_OTHERS },
{ "km_KH", lcl_DATA_OTHERS },
{ "lo_LA", lcl_DATA_OTHERS },
{ "rw_RW", lcl_DATA_OTHERS },
{ "eo", lcl_DATA_OTHERS },
{ "dz_BT", lcl_DATA_OTHERS },
{ "ne_NP", lcl_DATA_OTHERS },
{ "zu_ZA", lcl_DATA_OTHERS },
{ "nso_ZA", lcl_DATA_OTHERS },
{ "vi_VN", lcl_DATA_OTHERS },
{ "tn_ZA", lcl_DATA_OTHERS },
{ "xh_ZA", lcl_DATA_OTHERS },
{ "st_ZA", lcl_DATA_OTHERS },
{ "ss_ZA", lcl_DATA_OTHERS },
{ "ve_ZA", lcl_DATA_OTHERS },
{ "nr_ZA", lcl_DATA_OTHERS },
{ "ts_ZA", lcl_DATA_OTHERS },
{ "ku_TR", lcl_DATA_OTHERS },
{ "ak_GH", lcl_DATA_OTHERS },
{ "af_NA", lcl_DATA_OTHERS },
{ "am_ET", lcl_DATA_OTHERS },
{ "ti_ER", lcl_DATA_OTHERS },
{ "tg_TJ", lcl_DATA_OTHERS },
{ "ky_KG", lcl_DATA_OTHERS },
{ "kk_KZ", lcl_DATA_OTHERS },
{ "fa_IR", lcl_DATA_OTHERS },
{ "ha_GH", lcl_DATA_OTHERS },
{ "ee_GH", lcl_DATA_OTHERS },
{ "sg_CF", lcl_DATA_OTHERS },
{ "lg_UG", lcl_DATA_OTHERS },
{ "uz_UZ", lcl_DATA_OTHERS },
{ "ln_CD", lcl_DATA_OTHERS },
{ "hy_AM", lcl_DATA_OTHERS },
{ "hil_PH", lcl_DATA_OTHERS },
{ "so_SO", lcl_DATA_OTHERS },
{ "gug_PY", lcl_DATA_OTHERS },
{ "tk_TM", lcl_DATA_OTHERS },
{ "my_MM", lcl_DATA_OTHERS },
{ "shs_CA", lcl_DATA_OTHERS },
{ "tpi_PG", lcl_DATA_OTHERS },
{ "ar_OM", lcl_DATA_OTHERS },
{ "ug_CN", lcl_DATA_OTHERS },
{ "om_ET", lcl_DATA_OTHERS },
{ "plt_MG", lcl_DATA_OTHERS },
{ "mai_IN", lcl_DATA_OTHERS },
{ "yi_US", lcl_DATA_OTHERS },
{ "haw_US", lcl_DATA_OTHERS },
{ "lif_NP", lcl_DATA_OTHERS },
{ "ur_PK", lcl_DATA_OTHERS },
{ "ht_HT", lcl_DATA_OTHERS },
{ "jbo", lcl_DATA_OTHERS }
};
static const sal_Unicode under = sal_Unicode('_');
static const sal_Int16 nbOfLocales = sizeof(aLibTable) / sizeof(aLibTable[0]);
struct LocaleDataLookupTableItem
{
LocaleDataLookupTableItem(const sal_Char *name, osl::Module* m, const sal_Char* lname) : dllName(name), module(m), localeName(lname)
{
}
const sal_Char* dllName;
osl::Module *module;
const sal_Char* localeName;
com::sun::star::lang::Locale aLocale;
sal_Bool equals(const com::sun::star::lang::Locale& rLocale)
{
return (rLocale == aLocale);
}
};
LocaleData::LocaleData()
{
}
LocaleData::~LocaleData()
{
}
LocaleDataItem SAL_CALL
LocaleData::getLocaleItem( const Locale& rLocale ) throw(RuntimeException)
{
sal_Int16 dataItemCount = 0;
sal_Unicode **dataItem = NULL;
MyFunc_Type func = (MyFunc_Type) getFunctionSymbol( rLocale, "getLocaleItem" );
if ( func ) {
dataItem = func(dataItemCount);
LocaleDataItem item(
dataItem[0],
dataItem[1],
dataItem[2],
dataItem[3],
dataItem[4],
dataItem[5],
dataItem[6],
dataItem[7],
dataItem[8],
dataItem[9],
dataItem[10],
dataItem[11],
dataItem[12],
dataItem[13],
dataItem[14],
dataItem[15],
dataItem[16],
dataItem[17]
);
return item;
}
else {
LocaleDataItem item1;
return item1;
}
}
extern "C" { static void SAL_CALL thisModule() {} }
namespace
{
// implement the lookup table as a safe static object
class lcl_LookupTableHelper
{
public:
lcl_LookupTableHelper();
~lcl_LookupTableHelper();
oslGenericFunction SAL_CALL getFunctionSymbolByName(
const OUString& localeName, const sal_Char* pFunction,
LocaleDataLookupTableItem** pOutCachedItem );
private:
::osl::Mutex maMutex;
::std::vector< LocaleDataLookupTableItem* > maLookupTable;
};
// from instance.hxx: Helper base class for a late-initialized
// (default-constructed) static variable, implementing the double-checked
// locking pattern correctly.
// usage: lcl_LookupTableHelper & rLookupTable = lcl_LookupTableStatic::get();
// retrieves the singleton lookup table instance
struct lcl_LookupTableStatic : public ::rtl::Static< lcl_LookupTableHelper, lcl_LookupTableStatic >
{};
lcl_LookupTableHelper::lcl_LookupTableHelper()
{
}
lcl_LookupTableHelper::~lcl_LookupTableHelper()
{
LocaleDataLookupTableItem* pItem = 0;
std::vector<LocaleDataLookupTableItem*>::const_iterator aEnd(maLookupTable.end());
std::vector<LocaleDataLookupTableItem*>::iterator aIter(maLookupTable.begin());
for ( ; aIter != aEnd; ++aIter ) {
pItem = *aIter;
delete pItem->module;
delete pItem;
}
maLookupTable.clear();
}
oslGenericFunction SAL_CALL lcl_LookupTableHelper::getFunctionSymbolByName(
const OUString& localeName, const sal_Char* pFunction,
LocaleDataLookupTableItem** pOutCachedItem )
{
OUString aFallback;
bool bFallback = (localeName.indexOf( under) < 0);
if (bFallback)
{
Locale aLocale;
aLocale.Language = localeName;
Locale aFbLocale = MsLangId::getFallbackLocale( aLocale);
if (aFbLocale == aLocale)
bFallback = false; // may be a "language-only-locale" like Interlingua (ia)
else if (aFbLocale.Country.getLength()) {
OUStringBuffer aBuf(5);
aFallback = aBuf.append(aFbLocale.Language).append( under).append(aFbLocale.Country).makeStringAndClear();
}
else
aFallback = aFbLocale.Language;
}
for ( sal_Int16 i = 0; i < nbOfLocales; i++)
{
if (localeName.equalsAscii(aLibTable[i].pLocale) ||
(bFallback && localeName == aFallback))
{
LocaleDataLookupTableItem* pCurrent = 0;
OUStringBuffer aBuf(strlen(aLibTable[i].pLocale) + 1 + strlen(pFunction));
{
::osl::MutexGuard aGuard( maMutex );
for (size_t l = 0; l < maLookupTable.size(); l++)
{
pCurrent = maLookupTable[l];
if (pCurrent->dllName == aLibTable[i].pLib)
{
OSL_ASSERT( pOutCachedItem );
if( pOutCachedItem )
{
(*pOutCachedItem) = new LocaleDataLookupTableItem( *pCurrent );
(*pOutCachedItem)->localeName = aLibTable[i].pLocale;
return (*pOutCachedItem)->module->getFunctionSymbol(
aBuf.appendAscii( pFunction).append( under).
appendAscii( (*pOutCachedItem)->localeName).makeStringAndClear());
}
else
return NULL;
}
}
}
// Library not loaded, load it and add it to the list.
#ifdef SAL_DLLPREFIX
aBuf.ensureCapacity(strlen(aLibTable[i].pLib) + 6); // mostly "lib*.so"
aBuf.appendAscii( SAL_DLLPREFIX ).appendAscii(aLibTable[i].pLib).appendAscii( SAL_DLLEXTENSION );
#else
aBuf.ensureCapacity(strlen(aLibTable[i].pLib) + 4); // mostly "*.dll"
aBuf.appendAscii(aLibTable[i].pLib).appendAscii( SAL_DLLEXTENSION );
#endif
osl::Module *module = new osl::Module();
if ( module->loadRelative(&thisModule, aBuf.makeStringAndClear()) )
{
::osl::MutexGuard aGuard( maMutex );
LocaleDataLookupTableItem* pNewItem = 0;
maLookupTable.push_back(pNewItem = new LocaleDataLookupTableItem(aLibTable[i].pLib, module, aLibTable[i].pLocale ));
OSL_ASSERT( pOutCachedItem );
if( pOutCachedItem )
{
(*pOutCachedItem) = new LocaleDataLookupTableItem( *pNewItem );
return module->getFunctionSymbol(
aBuf.appendAscii(pFunction).append(under).
appendAscii((*pOutCachedItem)->localeName).makeStringAndClear());
}
else
return NULL;
}
else
delete module;
}
}
return NULL;
}
} // anonymous namespace
#define REF_DAYS 0
#define REF_MONTHS 1
#define REF_ERAS 2
Sequence< CalendarItem > &LocaleData::getCalendarItemByName(const OUString& name,
const Locale& rLocale, const Sequence< Calendar >& calendarsSeq, sal_Int16 len, sal_Int16 item)
throw(RuntimeException)
{
if (!ref_name.equals(name)) {
sal_Int32 index = 0;
OUString language = name.getToken(0, under, index);
OUString country = name.getToken(0, under, index);
Locale loc(language, country, OUString());
Sequence < Calendar > cals;
if (loc == rLocale) {
cals = calendarsSeq;
} else {
cals = getAllCalendars(loc);
len = sal::static_int_cast<sal_Int16>( cals.getLength() );
}
const OUString& id = name.getToken(0, under, index);
for (index = 0; index < cals.getLength(); index++) {
if (id.equals(cals[index].Name)) {
ref_cal = cals[index];
break;
}
}
// Refered locale does not found, return name for en_US locale.
if (index == cals.getLength()) {
cals = getAllCalendars(
Locale(OUString::createFromAscii("en"), OUString::createFromAscii("US"), OUString()));
if (cals.getLength() > 0)
ref_cal = cals[0];
else
throw RuntimeException();
}
ref_name = name;
}
return item == REF_DAYS ? ref_cal.Days : item == REF_MONTHS ? ref_cal.Months : ref_cal.Eras;
}
Sequence< Calendar > SAL_CALL
LocaleData::getAllCalendars( const Locale& rLocale ) throw(RuntimeException)
{
sal_Int16 calendarsCount = 0;
sal_Unicode **allCalendars = NULL;
MyFunc_Type func = (MyFunc_Type) getFunctionSymbol( rLocale, "getAllCalendars" );
if ( func ) {
allCalendars = func(calendarsCount);
Sequence< Calendar > calendarsSeq(calendarsCount);
sal_Int16 offset = 3;
sal_Int16 i, j;
for(i = 0; i < calendarsCount; i++) {
Sequence< CalendarItem > days(allCalendars[0][i]);
Sequence< CalendarItem > months(allCalendars[1][i]);
Sequence< CalendarItem > eras(allCalendars[2][i]);
OUString calendarID(allCalendars[offset]);
offset++;
sal_Bool defaultCalendar = sal::static_int_cast<sal_Bool>( allCalendars[offset][0] );
offset++;
if (OUString(allCalendars[offset]).equalsAscii("ref")) {
days = getCalendarItemByName(OUString(allCalendars[offset+1]), rLocale, calendarsSeq, i, REF_DAYS);
offset += 2;
} else {
for(j = 0; j < allCalendars[0][i]; j++) {
CalendarItem day(allCalendars[offset],
allCalendars[offset+1], allCalendars[offset+2]);
days[j] = day;
offset += 3;
}
}
if (OUString(allCalendars[offset]).equalsAscii("ref")) {
months = getCalendarItemByName(OUString(allCalendars[offset+1]), rLocale, calendarsSeq, i, REF_MONTHS);
offset += 2;
} else {
for(j = 0; j < allCalendars[1][i]; j++) {
CalendarItem month(allCalendars[offset],
allCalendars[offset+1], allCalendars[offset+2]);
months[j] = month;
offset += 3;
}
}
if (OUString(allCalendars[offset]).equalsAscii("ref")) {
eras = getCalendarItemByName(OUString(allCalendars[offset+1]), rLocale, calendarsSeq, i, REF_ERAS);
offset += 2;
} else {
for(j = 0; j < allCalendars[2][i]; j++) {
CalendarItem era(allCalendars[offset],
allCalendars[offset+1], allCalendars[offset+2]);
eras[j] = era;
offset += 3;
}
}
OUString startOfWeekDay(allCalendars[offset]);
offset++;
sal_Int16 minimalDaysInFirstWeek = allCalendars[offset][0];
offset++;
Calendar aCalendar(days, months, eras, startOfWeekDay,
minimalDaysInFirstWeek, defaultCalendar, calendarID);
calendarsSeq[i] = aCalendar;
}
return calendarsSeq;
}
else {
Sequence< Calendar > seq1(0);
return seq1;
}
}
Sequence< Currency2 > SAL_CALL
LocaleData::getAllCurrencies2( const Locale& rLocale ) throw(RuntimeException)
{
sal_Int16 currencyCount = 0;
sal_Unicode **allCurrencies = NULL;
MyFunc_Type func = (MyFunc_Type) getFunctionSymbol( rLocale, "getAllCurrencies" );
if ( func ) {
allCurrencies = func(currencyCount);
Sequence< Currency2 > seq(currencyCount);
for(int i = 0, nOff = 0; i < currencyCount; i++, nOff += 8 ) {
Currency2 cur(
allCurrencies[nOff], // string ID
allCurrencies[nOff+1], // string Symbol
allCurrencies[nOff+2], // string BankSymbol
allCurrencies[nOff+3], // string Name
allCurrencies[nOff+4][0] != 0, // boolean Default
allCurrencies[nOff+5][0] != 0, // boolean UsedInCompatibleFormatCodes
allCurrencies[nOff+6][0], // short DecimalPlaces
allCurrencies[nOff+7][0] != 0 // boolean LegacyOnly
);
seq[i] = cur;
}
return seq;
}
else {
Sequence< Currency2 > seq1(0);
return seq1;
}
}
Sequence< Currency > SAL_CALL
LocaleData::getAllCurrencies( const Locale& rLocale ) throw(RuntimeException)
{
Sequence< Currency2 > aCur2( getAllCurrencies2( rLocale));
sal_Int32 nLen = aCur2.getLength();
Sequence< Currency > aCur1( nLen);
const Currency2* p2 = aCur2.getArray();
Currency* p1 = aCur1.getArray();
for (sal_Int32 i=0; i < nLen; ++i, ++p1, ++p2)
{
*p1 = *p2;
}
return aCur1;
}
// return a static (!) string resulting from replacing all occurrences of
// 'oldStr' string in 'formatCode' string with 'newStr' string
static const sal_Unicode * replace( sal_Unicode const * const formatCode, sal_Unicode const * const oldStr, sal_Unicode const * const newStr)
{
// make reasonable assumption of maximum length of formatCode.
#define MAX_FORMATCODE_LENTH 512
static sal_Unicode str[MAX_FORMATCODE_LENTH];
if (oldStr[0] == 0) // no replacement requires
return formatCode;
sal_Int32 i = 0, k = 0;
while (formatCode[i] > 0 && k < MAX_FORMATCODE_LENTH) {
sal_Int32 j = 0, last = k;
// search oldStr in formatCode
while (formatCode[i] > 0 && oldStr[j] > 0 && k < MAX_FORMATCODE_LENTH) {
str[k++] = formatCode[i];
if (formatCode[i++] != oldStr[j++])
break;
}
if (oldStr[j] == 0) {
// matched string found, do replacement
k = last; j = 0;
while (newStr[j] > 0 && k < MAX_FORMATCODE_LENTH)
str[k++] = newStr[j++];
}
}
if (k >= MAX_FORMATCODE_LENTH) // could not complete replacement, return original formatCode
return formatCode;
str[k] = 0;
return str;
}
Sequence< FormatElement > SAL_CALL
LocaleData::getAllFormats( const Locale& rLocale ) throw(RuntimeException)
{
const int SECTIONS = 2;
struct FormatSection
{
MyFunc_FormatCode func;
sal_Unicode const *from;
sal_Unicode const *to;
sal_Unicode const *const *formatArray;
sal_Int16 formatCount;
FormatSection() : func(0), from(0), to(0), formatArray(0), formatCount(0) {}
sal_Int16 getFunc( LocaleData& rLocaleData, const Locale& rL, const char* pName )
{
func = reinterpret_cast<MyFunc_FormatCode>( rLocaleData.getFunctionSymbol( rL, pName));
if (func)
formatArray = func( formatCount, from, to);
return formatCount;
}
} section[SECTIONS];
#if 0
// #i79398# wntmsci10 MSVC doesn't get this right with optimization.
const sal_Int32 formatCount = section[0].getFunc( *this, rLocale, "getAllFormats0")
+ section[1].getFunc( *this, rLocale, "getAllFormats1");
#else
sal_Int32 formatCount = section[0].getFunc( *this, rLocale, "getAllFormats0");
formatCount += section[1].getFunc( *this, rLocale, "getAllFormats1");
#endif
Sequence< FormatElement > seq(formatCount);
sal_Int32 f = 0;
for (int s = 0; s < SECTIONS; ++s)
{
sal_Unicode const * const * const formatArray = section[s].formatArray;
if ( formatArray )
{
for (int i = 0, nOff = 0; i < section[s].formatCount; ++i, nOff += 7, ++f)
{
FormatElement elem(
replace( formatArray[nOff], section[s].from, section[s].to),
formatArray[nOff + 1],
formatArray[nOff + 2],
formatArray[nOff + 3],
formatArray[nOff + 4],
formatArray[nOff + 5][0],
sal::static_int_cast<sal_Bool>(formatArray[nOff + 6][0]));
seq[f] = elem;
}
}
}
return seq;
}
#define COLLATOR_OFFSET_ALGO 0
#define COLLATOR_OFFSET_DEFAULT 1
#define COLLATOR_OFFSET_RULE 2
#define COLLATOR_ELEMENTS 3
OUString SAL_CALL
LocaleData::getCollatorRuleByAlgorithm( const Locale& rLocale, const OUString& algorithm ) throw(RuntimeException)
{
MyFunc_Type func = (MyFunc_Type) getFunctionSymbol( rLocale, "getCollatorImplementation" );
if ( func ) {
sal_Int16 collatorCount = 0;
sal_Unicode **collatorArray = func(collatorCount);
for(sal_Int16 i = 0; i < collatorCount; i++)
if (algorithm.equals(collatorArray[i * COLLATOR_ELEMENTS + COLLATOR_OFFSET_ALGO]))
return OUString(collatorArray[i * COLLATOR_ELEMENTS + COLLATOR_OFFSET_RULE]);
}
return OUString();
}
Sequence< Implementation > SAL_CALL
LocaleData::getCollatorImplementations( const Locale& rLocale ) throw(RuntimeException)
{
sal_Int16 collatorCount = 0;
sal_Unicode **collatorArray = NULL;
MyFunc_Type func = (MyFunc_Type) getFunctionSymbol( rLocale, "getCollatorImplementation" );
if ( func ) {
collatorArray = func(collatorCount);
Sequence< Implementation > seq(collatorCount);
for(sal_Int16 i = 0; i < collatorCount; i++) {
Implementation impl(collatorArray[i * COLLATOR_ELEMENTS + COLLATOR_OFFSET_ALGO],
sal::static_int_cast<sal_Bool>(
collatorArray[i * COLLATOR_ELEMENTS + COLLATOR_OFFSET_DEFAULT][0]));
seq[i] = impl;
}
return seq;
}
else {
Sequence< Implementation > seq1(0);
return seq1;
}
}
Sequence< OUString > SAL_CALL
LocaleData::getCollationOptions( const Locale& rLocale ) throw(RuntimeException)
{
sal_Int16 optionsCount = 0;
sal_Unicode **optionsArray = NULL;
MyFunc_Type func = (MyFunc_Type) getFunctionSymbol( rLocale, "getCollationOptions" );
if ( func ) {
optionsArray = func(optionsCount);
Sequence< OUString > seq(optionsCount);
for(sal_Int16 i = 0; i < optionsCount; i++) {
seq[i] = OUString( optionsArray[i] );
}
return seq;
}
else {
Sequence< OUString > seq1(0);
return seq1;
}
}
Sequence< OUString > SAL_CALL
LocaleData::getSearchOptions( const Locale& rLocale ) throw(RuntimeException)
{
sal_Int16 optionsCount = 0;
sal_Unicode **optionsArray = NULL;
MyFunc_Type func = (MyFunc_Type) getFunctionSymbol( rLocale, "getSearchOptions" );
if ( func ) {
optionsArray = func(optionsCount);
Sequence< OUString > seq(optionsCount);
for(sal_Int16 i = 0; i < optionsCount; i++) {
seq[i] = OUString( optionsArray[i] );
}
return seq;
}
else {
Sequence< OUString > seq1(0);
return seq1;
}
}
sal_Unicode ** SAL_CALL
LocaleData::getIndexArray(const Locale& rLocale, sal_Int16& indexCount)
{
MyFunc_Type func = (MyFunc_Type) getFunctionSymbol( rLocale, "getIndexAlgorithm" );
if (func)
return func(indexCount);
return NULL;
}
Sequence< OUString > SAL_CALL
LocaleData::getIndexAlgorithm( const Locale& rLocale ) throw(RuntimeException)
{
sal_Int16 indexCount = 0;
sal_Unicode **indexArray = getIndexArray(rLocale, indexCount);
if ( indexArray ) {
Sequence< OUString > seq(indexCount);
for(sal_Int16 i = 0; i < indexCount; i++) {
seq[i] = indexArray[i*5];
}
return seq;
}
else {
Sequence< OUString > seq1(0);
return seq1;
}
}
OUString SAL_CALL
LocaleData::getDefaultIndexAlgorithm( const Locale& rLocale ) throw(RuntimeException)
{
sal_Int16 indexCount = 0;
sal_Unicode **indexArray = getIndexArray(rLocale, indexCount);
if ( indexArray ) {
for(sal_Int16 i = 0; i < indexCount; i++) {
if (indexArray[i*5 + 3][0])
return OUString(indexArray[i*5]);
}
}
return OUString();
}
sal_Bool SAL_CALL
LocaleData::hasPhonetic( const Locale& rLocale ) throw(RuntimeException)
{
sal_Int16 indexCount = 0;
sal_Unicode **indexArray = getIndexArray(rLocale, indexCount);
if ( indexArray ) {
for(sal_Int16 i = 0; i < indexCount; i++) {
if (indexArray[i*5 + 4][0])
return sal_True;
}
}
return sal_False;
}
sal_Unicode ** SAL_CALL
LocaleData::getIndexArrayForAlgorithm(const Locale& rLocale, const OUString& algorithm)
{
sal_Int16 indexCount = 0;
sal_Unicode **indexArray = getIndexArray(rLocale, indexCount);
if ( indexArray ) {
for(sal_Int16 i = 0; i < indexCount; i++) {
if (algorithm.equals(indexArray[i*5]))
return indexArray+i*5;
}
}
return NULL;
}
sal_Bool SAL_CALL
LocaleData::isPhonetic( const Locale& rLocale, const OUString& algorithm ) throw(RuntimeException)
{
sal_Unicode **indexArray = getIndexArrayForAlgorithm(rLocale, algorithm);
return (indexArray && indexArray[4][0]) ? sal_True : sal_False;
}
OUString SAL_CALL
LocaleData::getIndexKeysByAlgorithm( const Locale& rLocale, const OUString& algorithm ) throw(RuntimeException)
{
sal_Unicode **indexArray = getIndexArrayForAlgorithm(rLocale, algorithm);
return indexArray ? OUString::createFromAscii("0-9")+OUString(indexArray[2]) : OUString();
}
OUString SAL_CALL
LocaleData::getIndexModuleByAlgorithm( const Locale& rLocale, const OUString& algorithm ) throw(RuntimeException)
{
sal_Unicode **indexArray = getIndexArrayForAlgorithm(rLocale, algorithm);
return indexArray ? OUString(indexArray[1]) : OUString();
}
Sequence< UnicodeScript > SAL_CALL
LocaleData::getUnicodeScripts( const Locale& rLocale ) throw(RuntimeException)
{
sal_Int16 scriptCount = 0;
sal_Unicode **scriptArray = NULL;
MyFunc_Type func = (MyFunc_Type) getFunctionSymbol( rLocale, "getUnicodeScripts" );
if ( func ) {
scriptArray = func(scriptCount);
Sequence< UnicodeScript > seq(scriptCount);
for(sal_Int16 i = 0; i < scriptCount; i++) {
seq[i] = UnicodeScript( OUString(scriptArray[i]).toInt32() );
}
return seq;
}
else {
Sequence< UnicodeScript > seq1(0);
return seq1;
}
}
Sequence< OUString > SAL_CALL
LocaleData::getFollowPageWords( const Locale& rLocale ) throw(RuntimeException)
{
sal_Int16 wordCount = 0;
sal_Unicode **wordArray = NULL;
MyFunc_Type func = (MyFunc_Type) getFunctionSymbol( rLocale, "getFollowPageWords" );
if ( func ) {
wordArray = func(wordCount);
Sequence< OUString > seq(wordCount);
for(sal_Int16 i = 0; i < wordCount; i++) {
seq[i] = OUString(wordArray[i]);
}
return seq;
}
else {
Sequence< OUString > seq1(0);
return seq1;
}
}
Sequence< OUString > SAL_CALL
LocaleData::getTransliterations( const Locale& rLocale ) throw(RuntimeException)
{
sal_Int16 transliterationsCount = 0;
sal_Unicode **transliterationsArray = NULL;
MyFunc_Type func = (MyFunc_Type) getFunctionSymbol( rLocale, "getTransliterations" );
if ( func ) {
transliterationsArray = func(transliterationsCount);
Sequence< OUString > seq(transliterationsCount);
for(int i = 0; i < transliterationsCount; i++) {
OUString elem(transliterationsArray[i]);
seq[i] = elem;
}
return seq;
}
else {
Sequence< OUString > seq1(0);
return seq1;
}
}
LanguageCountryInfo SAL_CALL
LocaleData::getLanguageCountryInfo( const Locale& rLocale ) throw(RuntimeException)
{
sal_Int16 LCInfoCount = 0;
sal_Unicode **LCInfoArray = NULL;
MyFunc_Type func = (MyFunc_Type) getFunctionSymbol( rLocale, "getLCInfo" );
if ( func ) {
LCInfoArray = func(LCInfoCount);
LanguageCountryInfo info(LCInfoArray[0],
LCInfoArray[1],
LCInfoArray[2],
LCInfoArray[3],
LCInfoArray[4]);
return info;
}
else {
LanguageCountryInfo info1;
return info1;
}
}
ForbiddenCharacters SAL_CALL
LocaleData::getForbiddenCharacters( const Locale& rLocale ) throw(RuntimeException)
{
sal_Int16 LCForbiddenCharactersCount = 0;
sal_Unicode **LCForbiddenCharactersArray = NULL;
MyFunc_Type func = (MyFunc_Type) getFunctionSymbol( rLocale, "getForbiddenCharacters" );
if ( func ) {
LCForbiddenCharactersArray = func(LCForbiddenCharactersCount);
ForbiddenCharacters chars(LCForbiddenCharactersArray[0], LCForbiddenCharactersArray[1]);
return chars;
}
else {
ForbiddenCharacters chars1;
return chars1;
}
}
OUString SAL_CALL
LocaleData::getHangingCharacters( const Locale& rLocale ) throw(RuntimeException)
{
sal_Int16 LCForbiddenCharactersCount = 0;
sal_Unicode **LCForbiddenCharactersArray = NULL;
MyFunc_Type func = (MyFunc_Type) getFunctionSymbol( rLocale, "getForbiddenCharacters" );
if ( func ) {
LCForbiddenCharactersArray = func(LCForbiddenCharactersCount);
return OUString(LCForbiddenCharactersArray[2]);
}
return OUString();
}
Sequence< OUString > SAL_CALL
LocaleData::getBreakIteratorRules( const Locale& rLocale ) throw(RuntimeException)
{
sal_Int16 LCBreakIteratorRuleCount = 0;
sal_Unicode **LCBreakIteratorRulesArray = NULL;
MyFunc_Type func = (MyFunc_Type) getFunctionSymbol( rLocale, "getBreakIteratorRules" );
if ( func ) {
LCBreakIteratorRulesArray = func(LCBreakIteratorRuleCount);
Sequence< OUString > seq(LCBreakIteratorRuleCount);
for(int i = 0; i < (LCBreakIteratorRuleCount); i++) {
OUString elem(LCBreakIteratorRulesArray[i]);
seq[i] = elem;
}
return seq;
}
else {
Sequence< OUString > seq1(0);
return seq1;
}
}
Sequence< OUString > SAL_CALL
LocaleData::getReservedWord( const Locale& rLocale ) throw(RuntimeException)
{
sal_Int16 LCReservedWordsCount = 0;
sal_Unicode **LCReservedWordsArray = NULL;
MyFunc_Type func = (MyFunc_Type) getFunctionSymbol( rLocale, "getReservedWords" );
if ( func ) {
LCReservedWordsArray = func(LCReservedWordsCount);
Sequence< OUString > seq(LCReservedWordsCount);
for(int i = 0; i < (LCReservedWordsCount); i++) {
OUString elem(LCReservedWordsArray[i]);
seq[i] = elem;
}
return seq;
}
else {
Sequence< OUString > seq1(0);
return seq1;
}
}
inline
OUString C2U( const char* s )
{
return OUString::createFromAscii( s );
}
Sequence< Sequence<beans::PropertyValue> > SAL_CALL
LocaleData::getContinuousNumberingLevels( const lang::Locale& rLocale ) throw(RuntimeException)
{
int i;
// load symbol
MyFunc_Type2 func = (MyFunc_Type2) getFunctionSymbol( rLocale, "getContinuousNumberingLevels" );
if ( func )
{
// invoke function
sal_Int16 nStyles;
sal_Int16 nAttributes;
sal_Unicode*** p0 = func( nStyles, nAttributes );
// allocate memory for nAttributes attributes for each of the nStyles styles.
Sequence< Sequence<beans::PropertyValue> > pv( nStyles );
for( i=0; i<pv.getLength(); i++ ) {
pv[i] = Sequence<beans::PropertyValue>( nAttributes );
}
sal_Unicode*** pStyle = p0;
for( i=0; i<nStyles; i++ ) {
sal_Unicode** pAttribute = pStyle[i];
for( int j=0; j<nAttributes; j++ ) { // prefix, numberingtype, ...
sal_Unicode* pString = pAttribute[j];
beans::PropertyValue& rVal = pv[i][j];
OUString sVal;
if( pString ) {
if( 0 != j && 2 != j )
sVal = pString;
else if( *pString )
sVal = OUString( pString, 1 );
}
switch( j )
{
case 0:
rVal.Name = C2U("Prefix");
rVal.Value <<= sVal;
break;
case 1:
rVal.Name = C2U("NumberingType");
rVal.Value <<= (sal_Int16) sVal.toInt32();
break;
case 2:
rVal.Name = C2U("Suffix");
rVal.Value <<= sVal;
break;
case 3:
rVal.Name = C2U("Transliteration");
rVal.Value <<= sVal;
break;
case 4:
rVal.Name = C2U("NatNum");
rVal.Value <<= (sal_Int16) sVal.toInt32();
break;
default:
OSL_ASSERT(0);
}
}
}
return pv;
}
Sequence< Sequence<beans::PropertyValue> > seq1(0);
return seq1;
}
// ============================================================================
// \/ OutlineNumbering helper class \/
//
#include <com/sun/star/container/XIndexAccess.hpp>
#include <cppuhelper/implbase1.hxx>
namespace com{ namespace sun{ namespace star{ namespace lang {
struct Locale;
}}}}
//-----------------------------------------------------------------------------
struct OutlineNumberingLevel_Impl
{
OUString sPrefix;
sal_Int16 nNumType; //com::sun::star::style::NumberingType
OUString sSuffix;
sal_Unicode cBulletChar;
const sal_Char* sBulletFontName;
sal_Int16 nParentNumbering;
sal_Int32 nLeftMargin;
sal_Int32 nSymbolTextDistance;
sal_Int32 nFirstLineOffset;
OUString sTransliteration;
sal_Int32 nNatNum;
};
//-----------------------------------------------------------------------------
class OutlineNumbering : public cppu::WeakImplHelper1 < container::XIndexAccess >
{
const OutlineNumberingLevel_Impl* m_pOutlineLevels;
sal_Int16 m_nCount;
public:
// OutlineNumbering(const OutlineNumberingLevel_Impl* pOutlineLevels);
OutlineNumbering(const OutlineNumberingLevel_Impl* pOutlineLevels, int nLevels);
~OutlineNumbering();
//XIndexAccess
virtual sal_Int32 SAL_CALL getCount( ) throw(RuntimeException);
virtual Any SAL_CALL getByIndex( sal_Int32 Index )
throw(IndexOutOfBoundsException, WrappedTargetException, RuntimeException);
//XElementAccess
virtual Type SAL_CALL getElementType( ) throw(RuntimeException);
virtual sal_Bool SAL_CALL hasElements( ) throw(RuntimeException);
};
//
// OutlineNumbering helper class
// ============================================================================
static
sal_Char* U2C( OUString str )
{
sal_Char* s = new sal_Char[ str.getLength()+1 ];
int i;
for( i = 0; i < str.getLength(); i++)
s[i] = sal::static_int_cast<sal_Char>( str[i] );
s[i]='\0';
return s;
}
Sequence< Reference<container::XIndexAccess> > SAL_CALL
LocaleData::getOutlineNumberingLevels( const lang::Locale& rLocale ) throw(RuntimeException)
{
int i;
// load symbol
MyFunc_Type3 func = (MyFunc_Type3) getFunctionSymbol( rLocale, "getOutlineNumberingLevels" );
if ( func )
{
// invoke function
sal_Int16 nStyles;
sal_Int16 nLevels;
sal_Int16 nAttributes;
sal_Unicode**** p0 = func( nStyles, nLevels, nAttributes );
Sequence< Reference<container::XIndexAccess> > aRet( nStyles );
OUString aEmptyStr;
sal_Unicode**** pStyle = p0;
for( i=0; i<nStyles; i++ )
{
int j;
OutlineNumberingLevel_Impl* level = new OutlineNumberingLevel_Impl[ nLevels+1 ];
sal_Unicode*** pLevel = pStyle[i];
for( j = 0; j < nLevels; j++ )
{
sal_Unicode** pAttribute = pLevel[j];
for( int k=0; k<nAttributes; k++ )
{
OUString tmp( pAttribute[k] );
switch( k )
{
case 0: level[j].sPrefix = tmp; break;
case 1: level[j].nNumType = sal::static_int_cast<sal_Int16>(tmp.toInt32()); break;
case 2: level[j].sSuffix = tmp; break;
//case 3: level[j].cBulletChar = tmp.toChar(); break;
case 3: level[j].cBulletChar = sal::static_int_cast<sal_Unicode>(tmp.toInt32(16)); break; // base 16
case 4: level[j].sBulletFontName = U2C( tmp ); break;
case 5: level[j].nParentNumbering = sal::static_int_cast<sal_Int16>(tmp.toInt32()); break;
case 6: level[j].nLeftMargin = tmp.toInt32(); break;
case 7: level[j].nSymbolTextDistance = tmp.toInt32(); break;
case 8: level[j].nFirstLineOffset = tmp.toInt32(); break;
case 9: // Adjust
// these values seem to be hard-coded elsewhere:
// level[j].Value <<= (sal_Int16) text::HoriOrientation::LEFT;
// level[j].Value <<= (sal_Int16) style::HorizontalAlignment::LEFT;
break;
case 10: level[j].sTransliteration = tmp; break;
case 11: level[j].nNatNum = tmp.toInt32(); break;
default:
OSL_ASSERT(0);
}
}
}
level[j].sPrefix = aEmptyStr;
level[j].nNumType = 0;
level[j].sSuffix = aEmptyStr;
level[j].cBulletChar = 0;
level[j].sBulletFontName = 0;
level[j].nParentNumbering = 0;
level[j].nLeftMargin = 0;
level[j].nSymbolTextDistance = 0;
level[j].nFirstLineOffset = 0;
level[j].sTransliteration = aEmptyStr;
level[j].nNatNum = 0;
aRet[i] = new OutlineNumbering( level, nLevels );
}
return aRet;
}
else {
Sequence< Reference<container::XIndexAccess> > seq1(0);
return seq1;
}
}
/////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////helper functions///////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////
oslGenericFunction SAL_CALL LocaleData::getFunctionSymbol( const Locale& rLocale, const sal_Char* pFunction )
throw(RuntimeException)
{
lcl_LookupTableHelper & rLookupTable = lcl_LookupTableStatic::get();
OUStringBuffer aBuf(1);
if (cachedItem.get() && cachedItem->equals(rLocale)) {
aBuf.ensureCapacity(strlen(pFunction) + 1 + strlen(cachedItem->localeName));
return cachedItem->module->getFunctionSymbol(aBuf.appendAscii(pFunction).append(under).
appendAscii(cachedItem->localeName).makeStringAndClear());
}
oslGenericFunction pSymbol = 0;
static OUString tw(OUString::createFromAscii("TW"));
static OUString en_US(OUString::createFromAscii("en_US"));
sal_Int32 l = rLocale.Language.getLength();
sal_Int32 c = rLocale.Country.getLength();
sal_Int32 v = rLocale.Variant.getLength();
aBuf.ensureCapacity(l+c+v+3);
LocaleDataLookupTableItem *pCachedItem = 0;
if ((l > 0 && c > 0 && v > 0 &&
// load function with name <func>_<lang>_<country>_<varian>
(pSymbol = rLookupTable.getFunctionSymbolByName(aBuf.append(rLocale.Language).append(under).append(
rLocale.Country).append(under).append(rLocale.Variant).makeStringAndClear(), pFunction, &pCachedItem)) != 0) ||
(l > 0 && c > 0 &&
// load function with name <ase>_<lang>_<country>
(pSymbol = rLookupTable.getFunctionSymbolByName(aBuf.append(rLocale.Language).append(under).append(
rLocale.Country).makeStringAndClear(), pFunction, &pCachedItem)) != 0) ||
(l > 0 && c > 0 && rLocale.Language.equalsAscii("zh") &&
(rLocale.Country.equalsAscii("HK") ||
rLocale.Country.equalsAscii("MO")) &&
// if the country code is HK or MO, one more step to try TW.
(pSymbol = rLookupTable.getFunctionSymbolByName(aBuf.append(rLocale.Language).append(under).append(tw).makeStringAndClear(),
pFunction, &pCachedItem)) != 0) ||
(l > 0 &&
// load function with name <func>_<lang>
(pSymbol = rLookupTable.getFunctionSymbolByName(rLocale.Language, pFunction, &pCachedItem)) != 0) ||
// load default function with name <func>_en_US
(pSymbol = rLookupTable.getFunctionSymbolByName(en_US, pFunction, &pCachedItem)) != 0)
{
if( pCachedItem )
cachedItem.reset( pCachedItem );
if( cachedItem.get())
cachedItem->aLocale = rLocale;
return pSymbol;
}
throw RuntimeException();
}
Sequence< Locale > SAL_CALL
LocaleData::getAllInstalledLocaleNames() throw(RuntimeException)
{
Sequence< lang::Locale > seq( nbOfLocales );
OUString empStr;
sal_Int16 nInstalled = 0;
for( sal_Int16 i=0; i<nbOfLocales; i++ ) {
OUString name = OUString::createFromAscii( aLibTable[i].pLocale );
// Check if the locale is really available and not just in the table,
// don't allow fall backs.
LocaleDataLookupTableItem *pCachedItem = 0;
if (lcl_LookupTableStatic::get().getFunctionSymbolByName( name, "getLocaleItem", &pCachedItem )) {
if( pCachedItem )
cachedItem.reset( pCachedItem );
sal_Int32 index = 0;
lang::Locale tmpLocale(name.getToken(0, under, index), empStr, empStr);
if (index >= 0) {
tmpLocale.Country = name.getToken(0, under, index);
if (index >= 0)
tmpLocale.Variant = name.getToken(0, under, index);
}
seq[nInstalled++] = tmpLocale;
}
}
if ( nInstalled < nbOfLocales )
seq.realloc( nInstalled ); // reflect reality
return seq;
}
// ============================================================================
using namespace ::com::sun::star::container;
using namespace ::com::sun::star::beans;
using namespace ::com::sun::star::style;
using namespace ::com::sun::star::text;
// // bad: can't have empty prefix ...
// OutlineNumbering::OutlineNumbering(const OutlineNumberingLevel_Impl* pOutlnLevels) :
// m_pOutlineLevels(pOutlnLevels),
// m_nCount(0)
// {
// const OutlineNumberingLevel_Impl* pTemp = m_pOutlineLevels;
// while((pTemp++)->sPrefix)
// m_nCount++;
// }
OutlineNumbering::OutlineNumbering(const OutlineNumberingLevel_Impl* pOutlnLevels, int nLevels) :
m_pOutlineLevels(pOutlnLevels),
m_nCount(sal::static_int_cast<sal_Int16>(nLevels))
{
}
OutlineNumbering::~OutlineNumbering()
{
delete [] m_pOutlineLevels;
}
sal_Int32 OutlineNumbering::getCount( ) throw(RuntimeException)
{
return m_nCount;
}
Any OutlineNumbering::getByIndex( sal_Int32 nIndex )
throw(IndexOutOfBoundsException, WrappedTargetException, RuntimeException)
{
if(nIndex < 0 || nIndex >= m_nCount)
throw IndexOutOfBoundsException();
const OutlineNumberingLevel_Impl* pTemp = m_pOutlineLevels;
pTemp += nIndex;
Any aRet;
Sequence<PropertyValue> aOutlineNumbering(12);
PropertyValue* pValues = aOutlineNumbering.getArray();
pValues[0].Name = C2U( "Prefix");
pValues[0].Value <<= pTemp->sPrefix;
pValues[1].Name = C2U("NumberingType");
pValues[1].Value <<= pTemp->nNumType;
pValues[2].Name = C2U("Suffix");
pValues[2].Value <<= pTemp->sSuffix;
pValues[3].Name = C2U("BulletChar");
pValues[3].Value <<= OUString(&pTemp->cBulletChar, 1);
pValues[4].Name = C2U("BulletFontName");
pValues[4].Value <<= C2U(pTemp->sBulletFontName);
pValues[5].Name = C2U("ParentNumbering");
pValues[5].Value <<= pTemp->nParentNumbering;
pValues[6].Name = C2U("LeftMargin");
pValues[6].Value <<= pTemp->nLeftMargin;
pValues[7].Name = C2U("SymbolTextDistance");
pValues[7].Value <<= pTemp->nSymbolTextDistance;
pValues[8].Name = C2U("FirstLineOffset");
pValues[8].Value <<= pTemp->nFirstLineOffset;
pValues[9].Name = C2U("Adjust");
pValues[9].Value <<= (sal_Int16)HoriOrientation::LEFT;
pValues[10].Name = C2U("Transliteration");
pValues[10].Value <<= pTemp->sTransliteration;
pValues[11].Name = C2U("NatNum");
pValues[11].Value <<= pTemp->nNatNum;
aRet <<= aOutlineNumbering;
return aRet;
}
Type OutlineNumbering::getElementType( ) throw(RuntimeException)
{
return ::getCppuType((Sequence<PropertyValue>*)0);
}
sal_Bool OutlineNumbering::hasElements( ) throw(RuntimeException)
{
return m_nCount > 0;
}
OUString SAL_CALL
LocaleData::getImplementationName() throw( RuntimeException )
{
return OUString::createFromAscii(clocaledata);
}
sal_Bool SAL_CALL
LocaleData::supportsService(const OUString& rServiceName)
throw( RuntimeException )
{
return !rServiceName.compareToAscii(clocaledata);
}
Sequence< OUString > SAL_CALL
LocaleData::getSupportedServiceNames() throw( RuntimeException )
{
Sequence< OUString > aRet(1);
aRet[0] = OUString::createFromAscii(clocaledata);
return aRet;
}