Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <cppuhelper/supportsservice.hxx>
21 : #include <localedata.hxx>
22 : #include <i18nlangtag/mslangid.hxx>
23 : #include <i18nlangtag/languagetag.hxx>
24 : #include <rtl/ustrbuf.hxx>
25 : #include <sal/log.hxx>
26 : #include <osl/diagnose.h>
27 : #include <string.h>
28 : #include <stdio.h>
29 : #include "rtl/instance.hxx"
30 : #include <sal/macros.h>
31 :
32 : using namespace com::sun::star::i18n;
33 : using namespace com::sun::star::uno;
34 : using namespace com::sun::star::lang;
35 : using namespace com::sun::star;
36 :
37 : typedef sal_Unicode** (SAL_CALL * MyFunc_Type)( sal_Int16&);
38 : typedef sal_Unicode*** (SAL_CALL * MyFunc_Type2)( sal_Int16&, sal_Int16& );
39 : typedef sal_Unicode**** (SAL_CALL * MyFunc_Type3)( sal_Int16&, sal_Int16&, sal_Int16& );
40 : typedef sal_Unicode const * const * (SAL_CALL * MyFunc_FormatCode)( sal_Int16&, sal_Unicode const *&, sal_Unicode const *& );
41 :
42 : #ifndef DISABLE_DYNLOADING
43 :
44 : static const char *lcl_DATA_EN = "localedata_en";
45 : static const char *lcl_DATA_ES = "localedata_es";
46 : static const char *lcl_DATA_EURO = "localedata_euro";
47 : static const char *lcl_DATA_OTHERS = "localedata_others";
48 :
49 : #endif
50 :
51 : #ifndef DISABLE_DYNLOADING
52 :
53 : static const struct {
54 : const char* pLocale;
55 : const char* pLib;
56 : } aLibTable[] = {
57 : { "en_US", lcl_DATA_EN },
58 : { "en_AU", lcl_DATA_EN },
59 : { "en_BZ", lcl_DATA_EN },
60 : { "en_CA", lcl_DATA_EN },
61 : { "en_GB", lcl_DATA_EN },
62 : { "en_IE", lcl_DATA_EN },
63 : { "en_JM", lcl_DATA_EN },
64 : { "en_NZ", lcl_DATA_EN },
65 : { "en_PH", lcl_DATA_EN },
66 : { "en_TT", lcl_DATA_EN },
67 : { "en_ZA", lcl_DATA_EN },
68 : { "en_ZW", lcl_DATA_EN },
69 : { "en_NA", lcl_DATA_EN },
70 : { "en_GH", lcl_DATA_EN },
71 : { "en_MW", lcl_DATA_EN },
72 :
73 : { "es_ES", lcl_DATA_ES },
74 : { "es_AR", lcl_DATA_ES },
75 : { "es_BO", lcl_DATA_ES },
76 : { "es_CL", lcl_DATA_ES },
77 : { "es_CO", lcl_DATA_ES },
78 : { "es_CR", lcl_DATA_ES },
79 : { "es_DO", lcl_DATA_ES },
80 : { "es_EC", lcl_DATA_ES },
81 : { "es_GT", lcl_DATA_ES },
82 : { "es_HN", lcl_DATA_ES },
83 : { "es_MX", lcl_DATA_ES },
84 : { "es_NI", lcl_DATA_ES },
85 : { "es_PA", lcl_DATA_ES },
86 : { "es_PE", lcl_DATA_ES },
87 : { "es_PR", lcl_DATA_ES },
88 : { "es_PY", lcl_DATA_ES },
89 : { "es_SV", lcl_DATA_ES },
90 : { "es_UY", lcl_DATA_ES },
91 : { "es_VE", lcl_DATA_ES },
92 : { "gl_ES", lcl_DATA_ES },
93 :
94 : { "de_DE", lcl_DATA_EURO },
95 : { "de_AT", lcl_DATA_EURO },
96 : { "de_CH", lcl_DATA_EURO },
97 : { "de_LI", lcl_DATA_EURO },
98 : { "de_LU", lcl_DATA_EURO },
99 : { "fr_FR", lcl_DATA_EURO },
100 : { "fr_BE", lcl_DATA_EURO },
101 : { "fr_CA", lcl_DATA_EURO },
102 : { "fr_CH", lcl_DATA_EURO },
103 : { "fr_LU", lcl_DATA_EURO },
104 : { "fr_MC", lcl_DATA_EURO },
105 : { "fr_BF", lcl_DATA_EURO },
106 : { "fr_CI", lcl_DATA_EURO },
107 : { "fr_ML", lcl_DATA_EURO },
108 : { "fr_SN", lcl_DATA_EURO },
109 : { "fr_BJ", lcl_DATA_EURO },
110 : { "fr_NE", lcl_DATA_EURO },
111 : { "fr_TG", lcl_DATA_EURO },
112 : { "it_IT", lcl_DATA_EURO },
113 : { "it_CH", lcl_DATA_EURO },
114 : { "sl_SI", lcl_DATA_EURO },
115 : { "sv_SE", lcl_DATA_EURO },
116 : { "sv_FI", lcl_DATA_EURO },
117 : { "ca_ES", lcl_DATA_EURO },
118 : { "ca_ES_valencia", lcl_DATA_EURO },
119 : { "cs_CZ", lcl_DATA_EURO },
120 : { "sk_SK", lcl_DATA_EURO },
121 : { "da_DK", lcl_DATA_EURO },
122 : { "el_GR", lcl_DATA_EURO },
123 : { "fi_FI", lcl_DATA_EURO },
124 : { "is_IS", lcl_DATA_EURO },
125 : { "nl_BE", lcl_DATA_EURO },
126 : { "nl_NL", lcl_DATA_EURO },
127 : { "no_NO", lcl_DATA_EURO },
128 : { "nn_NO", lcl_DATA_EURO },
129 : { "nb_NO", lcl_DATA_EURO },
130 : { "nds_DE", lcl_DATA_EURO },
131 : { "pl_PL", lcl_DATA_EURO },
132 : { "pt_BR", lcl_DATA_EURO },
133 : { "pt_PT", lcl_DATA_EURO },
134 : { "ru_RU", lcl_DATA_EURO },
135 : { "tr_TR", lcl_DATA_EURO },
136 : { "tt_RU", lcl_DATA_EURO },
137 : { "et_EE", lcl_DATA_EURO },
138 : { "lb_LU", lcl_DATA_EURO },
139 : { "lt_LT", lcl_DATA_EURO },
140 : { "lv_LV", lcl_DATA_EURO },
141 : { "uk_UA", lcl_DATA_EURO },
142 : { "ro_RO", lcl_DATA_EURO },
143 : { "cy_GB", lcl_DATA_EURO },
144 : { "bg_BG", lcl_DATA_EURO },
145 : { "sr_Latn_ME", lcl_DATA_EURO },
146 : { "sr_Latn_RS", lcl_DATA_EURO },
147 : { "sr_Latn_CS", lcl_DATA_EURO },
148 : { "sr_ME", lcl_DATA_EURO },
149 : { "sr_RS", lcl_DATA_EURO },
150 : { "sr_CS", lcl_DATA_EURO },
151 : { "hr_HR", lcl_DATA_EURO },
152 : { "bs_BA", lcl_DATA_EURO },
153 : { "eu", lcl_DATA_EURO },
154 : { "fo_FO", lcl_DATA_EURO },
155 : { "ga_IE", lcl_DATA_EURO },
156 : { "gd_GB", lcl_DATA_EURO },
157 : { "ka_GE", lcl_DATA_EURO },
158 : { "be_BY", lcl_DATA_EURO },
159 : { "kl_GL", lcl_DATA_EURO },
160 : { "mk_MK", lcl_DATA_EURO },
161 : { "br_FR", lcl_DATA_EURO },
162 : { "la_VA", lcl_DATA_EURO },
163 : { "cv_RU", lcl_DATA_EURO },
164 : { "wa_BE", lcl_DATA_EURO },
165 : { "fur_IT", lcl_DATA_EURO },
166 : { "gsc_FR", lcl_DATA_EURO },
167 : { "fy_NL", lcl_DATA_EURO },
168 : { "oc_FR", lcl_DATA_EURO },
169 : { "mt_MT", lcl_DATA_EURO },
170 : { "sc_IT", lcl_DATA_EURO },
171 : { "ast_ES", lcl_DATA_EURO },
172 : { "ltg_LV", lcl_DATA_EURO },
173 : { "hsb_DE", lcl_DATA_EURO },
174 : { "dsb_DE", lcl_DATA_EURO },
175 : { "rue_SK", lcl_DATA_EURO },
176 : { "an_ES", lcl_DATA_EURO },
177 : { "myv_RU", lcl_DATA_EURO },
178 : { "lld_IT", lcl_DATA_EURO },
179 : { "cu_RU", lcl_DATA_EURO },
180 : { "vec_IT", lcl_DATA_EURO },
181 :
182 : { "ja_JP", lcl_DATA_OTHERS },
183 : { "ko_KR", lcl_DATA_OTHERS },
184 : { "zh_CN", lcl_DATA_OTHERS },
185 : { "zh_HK", lcl_DATA_OTHERS },
186 : { "zh_SG", lcl_DATA_OTHERS },
187 : { "zh_TW", lcl_DATA_OTHERS },
188 : { "zh_MO", lcl_DATA_OTHERS },
189 :
190 : { "ar_EG", lcl_DATA_OTHERS },
191 : { "ar_DZ", lcl_DATA_OTHERS },
192 : { "ar_LB", lcl_DATA_OTHERS },
193 : { "ar_SA", lcl_DATA_OTHERS },
194 : { "ar_TN", lcl_DATA_OTHERS },
195 : { "he_IL", lcl_DATA_OTHERS },
196 : { "hi_IN", lcl_DATA_OTHERS },
197 : { "kn_IN", lcl_DATA_OTHERS },
198 : { "ta_IN", lcl_DATA_OTHERS },
199 : { "te_IN", lcl_DATA_OTHERS },
200 : { "gu_IN", lcl_DATA_OTHERS },
201 : { "mr_IN", lcl_DATA_OTHERS },
202 : { "pa_IN", lcl_DATA_OTHERS },
203 : { "bn_IN", lcl_DATA_OTHERS },
204 : { "or_IN", lcl_DATA_OTHERS },
205 : { "en_IN", lcl_DATA_OTHERS },
206 : { "ml_IN", lcl_DATA_OTHERS },
207 : { "bn_BD", lcl_DATA_OTHERS },
208 : { "th_TH", lcl_DATA_OTHERS },
209 :
210 : { "af_ZA", lcl_DATA_OTHERS },
211 : { "hu_HU", lcl_DATA_OTHERS },
212 : { "id_ID", lcl_DATA_OTHERS },
213 : { "ms_MY", lcl_DATA_OTHERS },
214 : { "ia", lcl_DATA_OTHERS },
215 : { "mn_Cyrl_MN", lcl_DATA_OTHERS },
216 : { "az_AZ", lcl_DATA_OTHERS },
217 : { "sw_TZ", lcl_DATA_OTHERS },
218 : { "km_KH", lcl_DATA_OTHERS },
219 : { "lo_LA", lcl_DATA_OTHERS },
220 : { "rw_RW", lcl_DATA_OTHERS },
221 : { "eo", lcl_DATA_OTHERS },
222 : { "dz_BT", lcl_DATA_OTHERS },
223 : { "ne_NP", lcl_DATA_OTHERS },
224 : { "zu_ZA", lcl_DATA_OTHERS },
225 : { "nso_ZA", lcl_DATA_OTHERS },
226 : { "vi_VN", lcl_DATA_OTHERS },
227 : { "tn_ZA", lcl_DATA_OTHERS },
228 : { "xh_ZA", lcl_DATA_OTHERS },
229 : { "st_ZA", lcl_DATA_OTHERS },
230 : { "ss_ZA", lcl_DATA_OTHERS },
231 : { "ve_ZA", lcl_DATA_OTHERS },
232 : { "nr_ZA", lcl_DATA_OTHERS },
233 : { "ts_ZA", lcl_DATA_OTHERS },
234 : { "kmr_Latn_TR", lcl_DATA_OTHERS },
235 : { "ak_GH", lcl_DATA_OTHERS },
236 : { "af_NA", lcl_DATA_OTHERS },
237 : { "am_ET", lcl_DATA_OTHERS },
238 : { "ti_ER", lcl_DATA_OTHERS },
239 : { "tg_TJ", lcl_DATA_OTHERS },
240 : { "ky_KG", lcl_DATA_OTHERS },
241 : { "kk_KZ", lcl_DATA_OTHERS },
242 : { "fa_IR", lcl_DATA_OTHERS },
243 : { "ha_Latn_GH", lcl_DATA_OTHERS },
244 : { "ee_GH", lcl_DATA_OTHERS },
245 : { "sg_CF", lcl_DATA_OTHERS },
246 : { "lg_UG", lcl_DATA_OTHERS },
247 : { "uz_UZ", lcl_DATA_OTHERS },
248 : { "ln_CD", lcl_DATA_OTHERS },
249 : { "hy_AM", lcl_DATA_OTHERS },
250 : { "hil_PH", lcl_DATA_OTHERS },
251 : { "so_SO", lcl_DATA_OTHERS },
252 : { "gug_PY", lcl_DATA_OTHERS },
253 : { "tk_TM", lcl_DATA_OTHERS },
254 : { "my_MM", lcl_DATA_OTHERS },
255 : { "shs_CA", lcl_DATA_OTHERS },
256 : { "tpi_PG", lcl_DATA_OTHERS },
257 : { "ar_OM", lcl_DATA_OTHERS },
258 : { "ug_CN", lcl_DATA_OTHERS },
259 : { "om_ET", lcl_DATA_OTHERS },
260 : { "plt_MG", lcl_DATA_OTHERS },
261 : { "mai_IN", lcl_DATA_OTHERS },
262 : { "yi_US", lcl_DATA_OTHERS },
263 : { "haw_US", lcl_DATA_OTHERS },
264 : { "lif_NP", lcl_DATA_OTHERS },
265 : { "ur_PK", lcl_DATA_OTHERS },
266 : { "ht_HT", lcl_DATA_OTHERS },
267 : { "jbo", lcl_DATA_OTHERS },
268 : { "kab_DZ", lcl_DATA_OTHERS },
269 : { "pt_AO", lcl_DATA_OTHERS },
270 : { "pjt_AU", lcl_DATA_OTHERS },
271 : { "pap_BQ", lcl_DATA_OTHERS },
272 : { "pap_CW", lcl_DATA_OTHERS },
273 : { "ebo_CG", lcl_DATA_OTHERS },
274 : { "tyx_CG", lcl_DATA_OTHERS },
275 : { "axk_CG", lcl_DATA_OTHERS },
276 : { "beq_CG", lcl_DATA_OTHERS },
277 : { "bkw_CG", lcl_DATA_OTHERS },
278 : { "bvx_CG", lcl_DATA_OTHERS },
279 : { "dde_CG", lcl_DATA_OTHERS },
280 : { "iyx_CG", lcl_DATA_OTHERS },
281 : { "kkw_CG", lcl_DATA_OTHERS },
282 : { "kng_CG", lcl_DATA_OTHERS },
283 : { "ldi_CG", lcl_DATA_OTHERS },
284 : { "mdw_CG", lcl_DATA_OTHERS },
285 : { "mkw_CG", lcl_DATA_OTHERS },
286 : { "njx_CG", lcl_DATA_OTHERS },
287 : { "ngz_CG", lcl_DATA_OTHERS },
288 : { "njy_CG", lcl_DATA_OTHERS },
289 : { "puu_CG", lcl_DATA_OTHERS },
290 : { "sdj_CG", lcl_DATA_OTHERS },
291 : { "tek_CG", lcl_DATA_OTHERS },
292 : { "tsa_CG", lcl_DATA_OTHERS },
293 : { "vif_CG", lcl_DATA_OTHERS },
294 : { "xku_CG", lcl_DATA_OTHERS },
295 : { "yom_CG", lcl_DATA_OTHERS },
296 : { "sid_ET", lcl_DATA_OTHERS },
297 : { "bo_CN", lcl_DATA_OTHERS },
298 : { "bo_IN", lcl_DATA_OTHERS },
299 : { "ar_AE", lcl_DATA_OTHERS },
300 : { "ar_KW", lcl_DATA_OTHERS },
301 : { "bm_ML", lcl_DATA_OTHERS },
302 : { "pui_CO", lcl_DATA_OTHERS },
303 : { "lgr_SB", lcl_DATA_OTHERS },
304 : { "mos_BF", lcl_DATA_OTHERS },
305 : { "ny_MW", lcl_DATA_OTHERS },
306 : { "ti_ET", lcl_DATA_OTHERS }
307 235 : };
308 :
309 : #else
310 :
311 : #include "localedata_static.hxx"
312 :
313 : #endif
314 :
315 : static const sal_Unicode cUnder = '_';
316 : static const sal_Unicode cHyphen = '-';
317 :
318 : static const sal_Int16 nbOfLocales = SAL_N_ELEMENTS(aLibTable);
319 :
320 172859 : struct LocaleDataLookupTableItem
321 : {
322 397 : LocaleDataLookupTableItem(const sal_Char *name, osl::Module* m, const sal_Char* lname) : dllName(name), module(m), localeName(lname)
323 : {
324 397 : }
325 : const sal_Char* dllName;
326 : osl::Module *module;
327 : const sal_Char* localeName;
328 :
329 : com::sun::star::lang::Locale aLocale;
330 85491511 : bool equals(const com::sun::star::lang::Locale& rLocale)
331 : {
332 85491511 : return (rLocale == aLocale);
333 : }
334 : };
335 :
336 :
337 : // static
338 0 : Sequence< CalendarItem > LocaleDataImpl::downcastCalendarItems( const Sequence< CalendarItem2 > & rCi )
339 : {
340 0 : sal_Int32 nSize = rCi.getLength();
341 0 : Sequence< CalendarItem > aCi( nSize);
342 0 : CalendarItem* p1 = aCi.getArray();
343 0 : const CalendarItem2* p2 = rCi.getConstArray();
344 0 : for (sal_Int32 i=0; i < nSize; ++i, ++p1, ++p2)
345 0 : *p1 = *p2;
346 0 : return aCi;
347 : }
348 :
349 :
350 : // static
351 0 : Calendar LocaleDataImpl::downcastCalendar( const Calendar2 & rC )
352 : {
353 : Calendar aCal(
354 : downcastCalendarItems( rC.Days),
355 : downcastCalendarItems( rC.Months),
356 : downcastCalendarItems( rC.Eras),
357 : rC.StartOfWeek,
358 : rC.MinimumNumberOfDaysForFirstWeek,
359 : rC.Default,
360 : rC.Name
361 0 : );
362 0 : return aCal;
363 : }
364 :
365 :
366 68998 : LocaleDataImpl::LocaleDataImpl()
367 : {
368 68998 : }
369 121280 : LocaleDataImpl::~LocaleDataImpl()
370 : {
371 121280 : }
372 :
373 :
374 : LocaleDataItem SAL_CALL
375 42686 : LocaleDataImpl::getLocaleItem( const Locale& rLocale ) throw(RuntimeException, std::exception)
376 : {
377 42686 : MyFunc_Type func = reinterpret_cast<MyFunc_Type>(getFunctionSymbol( rLocale, "getLocaleItem" ));
378 :
379 42686 : if ( func ) {
380 42686 : sal_Int16 dataItemCount = 0;
381 42686 : sal_Unicode **dataItem = func(dataItemCount);
382 :
383 : LocaleDataItem item(
384 : dataItem[0],
385 42686 : dataItem[1],
386 42686 : dataItem[2],
387 42686 : dataItem[3],
388 42686 : dataItem[4],
389 42686 : dataItem[5],
390 42686 : dataItem[6],
391 42686 : dataItem[7],
392 42686 : dataItem[8],
393 42686 : dataItem[9],
394 42686 : dataItem[10],
395 42686 : dataItem[11],
396 42686 : dataItem[12],
397 42686 : dataItem[13],
398 42686 : dataItem[14],
399 42686 : dataItem[15],
400 42686 : dataItem[16],
401 42686 : dataItem[17]
402 725662 : );
403 42686 : return item;
404 : }
405 : else {
406 0 : LocaleDataItem item1;
407 0 : return item1;
408 : }
409 : }
410 :
411 : #ifndef DISABLE_DYNLOADING
412 :
413 0 : extern "C" { static void SAL_CALL thisModule() {} }
414 :
415 : #endif
416 :
417 : namespace
418 : {
419 :
420 : // implement the lookup table as a safe static object
421 : class lcl_LookupTableHelper
422 : {
423 : public:
424 : lcl_LookupTableHelper();
425 : ~lcl_LookupTableHelper();
426 :
427 : oslGenericFunction SAL_CALL getFunctionSymbolByName(
428 : const OUString& localeName, const sal_Char* pFunction,
429 : LocaleDataLookupTableItem** pOutCachedItem );
430 :
431 : private:
432 : ::osl::Mutex maMutex;
433 : ::std::vector< LocaleDataLookupTableItem* > maLookupTable;
434 : };
435 :
436 : // from instance.hxx: Helper base class for a late-initialized
437 : // (default-constructed) static variable, implementing the double-checked
438 : // locking pattern correctly.
439 : // usage: lcl_LookupTableHelper & rLookupTable = lcl_LookupTableStatic::get();
440 : // retrieves the singleton lookup table instance
441 : struct lcl_LookupTableStatic : public ::rtl::Static< lcl_LookupTableHelper, lcl_LookupTableStatic >
442 : {};
443 :
444 229 : lcl_LookupTableHelper::lcl_LookupTableHelper()
445 : {
446 229 : }
447 :
448 458 : lcl_LookupTableHelper::~lcl_LookupTableHelper()
449 : {
450 229 : std::vector<LocaleDataLookupTableItem*>::const_iterator aEnd(maLookupTable.end());
451 229 : std::vector<LocaleDataLookupTableItem*>::iterator aIter(maLookupTable.begin());
452 :
453 626 : for ( ; aIter != aEnd; ++aIter ) {
454 397 : LocaleDataLookupTableItem* pItem = *aIter;
455 397 : delete pItem->module;
456 397 : delete pItem;
457 : }
458 229 : maLookupTable.clear();
459 229 : }
460 :
461 88128 : oslGenericFunction SAL_CALL lcl_LookupTableHelper::getFunctionSymbolByName(
462 : const OUString& localeName, const sal_Char* pFunction,
463 : LocaleDataLookupTableItem** pOutCachedItem )
464 : {
465 88128 : OUString aFallback;
466 88128 : bool bFallback = (localeName.indexOf( cUnder) < 0);
467 88128 : if (bFallback)
468 : {
469 1535 : Locale aLocale;
470 1535 : aLocale.Language = localeName;
471 3070 : Locale aFbLocale = MsLangId::getFallbackLocale( aLocale);
472 1535 : if (aFbLocale == aLocale)
473 569 : bFallback = false; // may be a "language-only-locale" like Interlingua (ia)
474 : else
475 2501 : aFallback = LocaleDataImpl::getFirstLocaleServiceName( aFbLocale);
476 : }
477 :
478 4393815 : for ( sal_Int16 i = 0; i < nbOfLocales; i++)
479 : {
480 4481835 : if (localeName.equalsAscii(aLibTable[i].pLocale) ||
481 109434 : (bFallback && aFallback.equalsAscii(aLibTable[i].pLocale)))
482 : {
483 : #ifndef DISABLE_DYNLOADING
484 : OUStringBuffer aBuf(sal::static_int_cast<int>(
485 88074 : strlen(aLibTable[i].pLocale) + 1 + strlen(pFunction)));
486 : {
487 88074 : ::osl::MutexGuard aGuard( maMutex );
488 164675 : for (size_t l = 0; l < maLookupTable.size(); l++)
489 : {
490 164278 : LocaleDataLookupTableItem* pCurrent = maLookupTable[l];
491 164278 : if (pCurrent->dllName == aLibTable[i].pLib)
492 : {
493 : OSL_ASSERT( pOutCachedItem );
494 87677 : if( pOutCachedItem )
495 : {
496 87677 : (*pOutCachedItem) = new LocaleDataLookupTableItem( *pCurrent );
497 87677 : (*pOutCachedItem)->localeName = aLibTable[i].pLocale;
498 : return (*pOutCachedItem)->module->getFunctionSymbol(
499 87677 : aBuf.appendAscii( pFunction).append( cUnder).
500 175354 : appendAscii( (*pOutCachedItem)->localeName).makeStringAndClear());
501 : }
502 : else
503 0 : return NULL;
504 : }
505 397 : }
506 : }
507 : // Library not loaded, load it and add it to the list.
508 : #ifdef SAL_DLLPREFIX
509 397 : aBuf.ensureCapacity(strlen(aLibTable[i].pLib) + 6); // mostly "lib*.so"
510 397 : aBuf.appendAscii( SAL_DLLPREFIX ).appendAscii(aLibTable[i].pLib).appendAscii( SAL_DLLEXTENSION );
511 : #else
512 : aBuf.ensureCapacity(strlen(aLibTable[i].pLib) + 4); // mostly "*.dll"
513 : aBuf.appendAscii(aLibTable[i].pLib).appendAscii( SAL_DLLEXTENSION );
514 : #endif
515 397 : osl::Module *module = new osl::Module();
516 397 : if ( module->loadRelative(&thisModule, aBuf.makeStringAndClear()) )
517 : {
518 397 : ::osl::MutexGuard aGuard( maMutex );
519 397 : LocaleDataLookupTableItem* pNewItem = new LocaleDataLookupTableItem(aLibTable[i].pLib, module, aLibTable[i].pLocale);
520 397 : maLookupTable.push_back(pNewItem);
521 : OSL_ASSERT( pOutCachedItem );
522 397 : if( pOutCachedItem )
523 : {
524 397 : (*pOutCachedItem) = new LocaleDataLookupTableItem( *pNewItem );
525 : return module->getFunctionSymbol(
526 397 : aBuf.appendAscii(pFunction).append(cUnder).
527 794 : appendAscii((*pOutCachedItem)->localeName).makeStringAndClear());
528 : }
529 : else
530 0 : return NULL;
531 : }
532 : else
533 0 : delete module;
534 : #else
535 : (void) pOutCachedItem;
536 :
537 : if( strcmp(pFunction, "getAllCalendars") == 0 )
538 : return aLibTable[i].getAllCalendars;
539 : else if( strcmp(pFunction, "getAllCurrencies") == 0 )
540 : return aLibTable[i].getAllCurrencies;
541 : else if( strcmp(pFunction, "getAllFormats0") == 0 )
542 : return aLibTable[i].getAllFormats0;
543 : else if( strcmp(pFunction, "getBreakIteratorRules") == 0 )
544 : return aLibTable[i].getBreakIteratorRules;
545 : else if( strcmp(pFunction, "getCollationOptions") == 0 )
546 : return aLibTable[i].getCollationOptions;
547 : else if( strcmp(pFunction, "getCollatorImplementation") == 0 )
548 : return aLibTable[i].getCollatorImplementation;
549 : else if( strcmp(pFunction, "getContinuousNumberingLevels") == 0 )
550 : return aLibTable[i].getContinuousNumberingLevels;
551 : else if( strcmp(pFunction, "getDateAcceptancePatterns") == 0 )
552 : return aLibTable[i].getDateAcceptancePatterns;
553 : else if( strcmp(pFunction, "getFollowPageWords") == 0 )
554 : return aLibTable[i].getFollowPageWords;
555 : else if( strcmp(pFunction, "getForbiddenCharacters") == 0 )
556 : return aLibTable[i].getForbiddenCharacters;
557 : else if( strcmp(pFunction, "getIndexAlgorithm") == 0 )
558 : return aLibTable[i].getIndexAlgorithm;
559 : else if( strcmp(pFunction, "getLCInfo") == 0 )
560 : return aLibTable[i].getLCInfo;
561 : else if( strcmp(pFunction, "getLocaleItem") == 0 )
562 : return aLibTable[i].getLocaleItem;
563 : else if( strcmp(pFunction, "getOutlineNumberingLevels") == 0 )
564 : return aLibTable[i].getOutlineNumberingLevels;
565 : else if( strcmp(pFunction, "getReservedWords") == 0 )
566 : return aLibTable[i].getReservedWords;
567 : else if( strcmp(pFunction, "getSearchOptions") == 0 )
568 : return aLibTable[i].getSearchOptions;
569 : else if( strcmp(pFunction, "getTransliterations") == 0 )
570 : return aLibTable[i].getTransliterations;
571 : else if( strcmp(pFunction, "getUnicodeScripts") == 0 )
572 : return aLibTable[i].getUnicodeScripts;
573 : else if( strcmp(pFunction, "getAllFormats1") == 0 )
574 : return aLibTable[i].getAllFormats1;
575 : #endif
576 : }
577 : }
578 54 : return NULL;
579 : }
580 :
581 : } // anonymous namespace
582 :
583 :
584 : // REF values equal offsets of counts within getAllCalendars() data structure!
585 : #define REF_DAYS 0
586 : #define REF_MONTHS 1
587 : #define REF_GMONTHS 2
588 : #define REF_PMONTHS 3
589 : #define REF_ERAS 4
590 : #define REF_OFFSET_COUNT 5
591 :
592 16 : Sequence< CalendarItem2 > &LocaleDataImpl::getCalendarItemByName(const OUString& name,
593 : const Locale& rLocale, const Sequence< Calendar2 >& calendarsSeq, sal_Int16 item)
594 : throw(RuntimeException)
595 : {
596 16 : if (!ref_name.equals(name)) {
597 16 : OUString aLocStr, id;
598 8 : sal_Int32 nLastUnder = name.lastIndexOf( cUnder);
599 : SAL_WARN_IF( nLastUnder < 1, "i18npool",
600 : "LocaleDataImpl::getCalendarItemByName - no '_' or first in name can't be right: " << name);
601 8 : if (nLastUnder >= 0)
602 : {
603 8 : aLocStr = name.copy( 0, nLastUnder);
604 8 : if (nLastUnder + 1 < name.getLength())
605 8 : id = name.copy( nLastUnder + 1);
606 : }
607 16 : Locale loc( LanguageTag::convertToLocale( aLocStr.replace( cUnder, cHyphen)));
608 16 : Sequence < Calendar2 > cals;
609 8 : if (loc == rLocale) {
610 0 : cals = calendarsSeq;
611 : } else {
612 8 : cals = getAllCalendars2(loc);
613 : }
614 : sal_Int32 index;
615 8 : for (index = 0; index < cals.getLength(); index++) {
616 8 : if (id.equals(cals[index].Name)) {
617 8 : ref_cal = cals[index];
618 8 : break;
619 : }
620 : }
621 : // Referred locale not found, return name for en_US locale.
622 8 : if (index == cals.getLength()) {
623 0 : cals = getAllCalendars2(
624 0 : Locale(OUString("en"), OUString("US"), OUString()));
625 0 : if (cals.getLength() > 0)
626 0 : ref_cal = cals[0];
627 : else
628 0 : throw RuntimeException();
629 : }
630 16 : ref_name = name;
631 : }
632 16 : switch (item)
633 : {
634 : case REF_DAYS:
635 16 : return ref_cal.Days;
636 : case REF_MONTHS:
637 0 : return ref_cal.Months;
638 : case REF_GMONTHS:
639 0 : return ref_cal.GenitiveMonths;
640 : case REF_PMONTHS:
641 0 : return ref_cal.PartitiveMonths;
642 : default:
643 : OSL_FAIL( "LocaleDataImpl::getCalendarItemByName: unhandled REF_* case");
644 : // fallthru
645 : case REF_ERAS:
646 0 : return ref_cal.Eras;
647 : }
648 : }
649 :
650 :
651 14900 : Sequence< CalendarItem2 > LocaleDataImpl::getCalendarItems(
652 : sal_Unicode const * const * const allCalendars, sal_Int16 & rnOffset,
653 : const sal_Int16 nWhichItem, const sal_Int16 nCalendar,
654 : const Locale & rLocale, const Sequence< Calendar2 > & calendarsSeq )
655 : throw(RuntimeException)
656 : {
657 14900 : Sequence< CalendarItem2 > aItems;
658 14900 : if ( OUString( allCalendars[rnOffset] ) == "ref" )
659 : {
660 16 : aItems = getCalendarItemByName( OUString( allCalendars[rnOffset+1]), rLocale, calendarsSeq, nWhichItem);
661 16 : rnOffset += 2;
662 : }
663 : else
664 : {
665 14884 : sal_Int32 nSize = allCalendars[nWhichItem][nCalendar];
666 14884 : aItems.realloc( nSize);
667 14884 : CalendarItem2* pItem = aItems.getArray();
668 14884 : switch (nWhichItem)
669 : {
670 : case REF_DAYS:
671 : case REF_MONTHS:
672 : case REF_GMONTHS:
673 : case REF_PMONTHS:
674 144312 : for (sal_Int32 j = 0; j < nSize; ++j, ++pItem)
675 : {
676 264816 : CalendarItem2 item( allCalendars[rnOffset], allCalendars[rnOffset+1],
677 397224 : allCalendars[rnOffset+2], allCalendars[rnOffset+3]);
678 132408 : *pItem = item;
679 132408 : rnOffset += 4;
680 132408 : }
681 11904 : break;
682 : case REF_ERAS:
683 : // Absent narrow name.
684 8940 : for (sal_Int32 j = 0; j < nSize; ++j, ++pItem)
685 : {
686 11920 : CalendarItem2 item( allCalendars[rnOffset], allCalendars[rnOffset+1],
687 17880 : allCalendars[rnOffset+2], OUString());
688 5960 : *pItem = item;
689 5960 : rnOffset += 3;
690 5960 : }
691 2980 : break;
692 : default:
693 : OSL_FAIL( "LocaleDataImpl::getCalendarItems: unhandled REF_* case");
694 : }
695 : }
696 14900 : return aItems;
697 : }
698 :
699 :
700 : Sequence< Calendar2 > SAL_CALL
701 1502 : LocaleDataImpl::getAllCalendars2( const Locale& rLocale ) throw(RuntimeException, std::exception)
702 : {
703 :
704 1502 : sal_Unicode const * const * allCalendars = NULL;
705 :
706 1502 : MyFunc_Type func = reinterpret_cast<MyFunc_Type>(getFunctionSymbol( rLocale, "getAllCalendars" ));
707 :
708 1502 : if ( func ) {
709 1502 : sal_Int16 calendarsCount = 0;
710 1502 : allCalendars = func(calendarsCount);
711 :
712 1502 : Sequence< Calendar2 > calendarsSeq(calendarsCount);
713 1502 : sal_Int16 offset = REF_OFFSET_COUNT;
714 4482 : for(sal_Int16 i = 0; i < calendarsCount; i++) {
715 2980 : OUString calendarID(allCalendars[offset]);
716 2980 : offset++;
717 2980 : bool defaultCalendar = allCalendars[offset][0] != 0;
718 2980 : offset++;
719 : Sequence< CalendarItem2 > days = getCalendarItems( allCalendars, offset, REF_DAYS, i,
720 5960 : rLocale, calendarsSeq);
721 : Sequence< CalendarItem2 > months = getCalendarItems( allCalendars, offset, REF_MONTHS, i,
722 5960 : rLocale, calendarsSeq);
723 : Sequence< CalendarItem2 > gmonths = getCalendarItems( allCalendars, offset, REF_GMONTHS, i,
724 5960 : rLocale, calendarsSeq);
725 : Sequence< CalendarItem2 > pmonths = getCalendarItems( allCalendars, offset, REF_PMONTHS, i,
726 5960 : rLocale, calendarsSeq);
727 : Sequence< CalendarItem2 > eras = getCalendarItems( allCalendars, offset, REF_ERAS, i,
728 5960 : rLocale, calendarsSeq);
729 5960 : OUString startOfWeekDay(allCalendars[offset]);
730 2980 : offset++;
731 2980 : sal_Int16 minimalDaysInFirstWeek = allCalendars[offset][0];
732 2980 : offset++;
733 : Calendar2 aCalendar(days, months, gmonths, pmonths, eras, startOfWeekDay,
734 5960 : minimalDaysInFirstWeek, defaultCalendar, calendarID);
735 2980 : calendarsSeq[i] = aCalendar;
736 2980 : }
737 1502 : return calendarsSeq;
738 : }
739 : else {
740 0 : Sequence< Calendar2 > seq1(0);
741 0 : return seq1;
742 : }
743 : }
744 :
745 :
746 : Sequence< Calendar > SAL_CALL
747 0 : LocaleDataImpl::getAllCalendars( const Locale& rLocale ) throw(RuntimeException, std::exception)
748 : {
749 0 : const Sequence< Calendar2 > aCal2( getAllCalendars2( rLocale));
750 0 : sal_Int32 nLen = aCal2.getLength();
751 0 : Sequence< Calendar > aCal1( nLen);
752 0 : const Calendar2* p2 = aCal2.getConstArray();
753 0 : Calendar* p1 = aCal1.getArray();
754 0 : for (sal_Int32 i=0; i < nLen; ++i, ++p1, ++p2)
755 : {
756 0 : *p1 = downcastCalendar( *p2);
757 : }
758 0 : return aCal1;
759 : }
760 :
761 :
762 : Sequence< Currency2 > SAL_CALL
763 37387 : LocaleDataImpl::getAllCurrencies2( const Locale& rLocale ) throw(RuntimeException, std::exception)
764 : {
765 37387 : MyFunc_Type func = reinterpret_cast<MyFunc_Type>(getFunctionSymbol( rLocale, "getAllCurrencies" ));
766 :
767 37387 : if ( func ) {
768 37387 : sal_Int16 currencyCount = 0;
769 37387 : sal_Unicode **allCurrencies = func(currencyCount);
770 :
771 37387 : Sequence< Currency2 > seq(currencyCount);
772 83605 : for(int i = 0, nOff = 0; i < currencyCount; i++, nOff += 8 ) {
773 : Currency2 cur(
774 46218 : allCurrencies[nOff], // string ID
775 46218 : allCurrencies[nOff+1], // string Symbol
776 46218 : allCurrencies[nOff+2], // string BankSymbol
777 46218 : allCurrencies[nOff+3], // string Name
778 46218 : allCurrencies[nOff+4][0] != 0, // boolean Default
779 46218 : allCurrencies[nOff+5][0] != 0, // boolean UsedInCompatibleFormatCodes
780 46218 : allCurrencies[nOff+6][0], // short DecimalPlaces
781 46218 : allCurrencies[nOff+7][0] != 0 // boolean LegacyOnly
782 369744 : );
783 46218 : seq[i] = cur;
784 46218 : }
785 37387 : return seq;
786 : }
787 : else {
788 0 : Sequence< Currency2 > seq1(0);
789 0 : return seq1;
790 : }
791 : }
792 :
793 :
794 : Sequence< Currency > SAL_CALL
795 0 : LocaleDataImpl::getAllCurrencies( const Locale& rLocale ) throw(RuntimeException, std::exception)
796 : {
797 0 : Sequence< Currency2 > aCur2( getAllCurrencies2( rLocale));
798 0 : sal_Int32 nLen = aCur2.getLength();
799 0 : Sequence< Currency > aCur1( nLen);
800 0 : const Currency2* p2 = aCur2.getArray();
801 0 : Currency* p1 = aCur1.getArray();
802 0 : for (sal_Int32 i=0; i < nLen; ++i, ++p1, ++p2)
803 : {
804 0 : *p1 = *p2;
805 : }
806 0 : return aCur1;
807 : }
808 :
809 :
810 : // return a static (!) string resulting from replacing all occurrences of
811 : // 'oldStr' string in 'formatCode' string with 'newStr' string
812 1785426 : static const sal_Unicode * replace( sal_Unicode const * const formatCode, sal_Unicode const * const oldStr, sal_Unicode const * const newStr)
813 : {
814 : // make reasonable assumption of maximum length of formatCode.
815 : #define MAX_FORMATCODE_LENTH 512
816 : static sal_Unicode str[MAX_FORMATCODE_LENTH];
817 :
818 1785426 : if (oldStr[0] == 0) // no replacement requires
819 339826 : return formatCode;
820 :
821 1445600 : sal_Int32 i = 0, k = 0;
822 18815467 : while (formatCode[i] > 0 && k < MAX_FORMATCODE_LENTH) {
823 15924267 : sal_Int32 j = 0, last = k;
824 : // search oldStr in formatCode
825 35753344 : while (formatCode[i] > 0 && oldStr[j] > 0 && k < MAX_FORMATCODE_LENTH) {
826 19454785 : str[k++] = formatCode[i];
827 19454785 : if (formatCode[i++] != oldStr[j++])
828 15549975 : break;
829 : }
830 15924267 : if (oldStr[j] == 0) {
831 : // matched string found, do replacement
832 374292 : k = last; j = 0;
833 3841866 : while (newStr[j] > 0 && k < MAX_FORMATCODE_LENTH)
834 3093282 : str[k++] = newStr[j++];
835 : }
836 : }
837 1445600 : if (k >= MAX_FORMATCODE_LENTH) // could not complete replacement, return original formatCode
838 0 : return formatCode;
839 :
840 1445600 : str[k] = 0;
841 1445600 : return str;
842 : }
843 :
844 : Sequence< FormatElement > SAL_CALL
845 31490 : LocaleDataImpl::getAllFormats( const Locale& rLocale ) throw(RuntimeException, std::exception)
846 : {
847 31490 : const int SECTIONS = 2;
848 : struct FormatSection
849 : {
850 : MyFunc_FormatCode func;
851 : sal_Unicode const *from;
852 : sal_Unicode const *to;
853 : sal_Unicode const *const *formatArray;
854 : sal_Int16 formatCount;
855 :
856 62980 : FormatSection() : func(0), from(0), to(0), formatArray(0), formatCount(0) {}
857 62980 : sal_Int16 getFunc( LocaleDataImpl& rLocaleData, const Locale& rL, const char* pName )
858 : {
859 62980 : func = reinterpret_cast<MyFunc_FormatCode>( rLocaleData.getFunctionSymbol( rL, pName));
860 62980 : if (func)
861 52149 : formatArray = func( formatCount, from, to);
862 62980 : return formatCount;
863 : }
864 31490 : } section[SECTIONS];
865 :
866 : sal_Int32 formatCount;
867 31490 : formatCount = section[0].getFunc( *this, rLocale, "getAllFormats0");
868 31490 : formatCount += section[1].getFunc( *this, rLocale, "getAllFormats1");
869 :
870 31490 : Sequence< FormatElement > seq(formatCount);
871 31490 : sal_Int32 f = 0;
872 94470 : for (int s = 0; s < SECTIONS; ++s)
873 : {
874 62980 : sal_Unicode const * const * const formatArray = section[s].formatArray;
875 62980 : if ( formatArray )
876 : {
877 1837575 : for (int i = 0, nOff = 0; i < section[s].formatCount; ++i, nOff += 7, ++f)
878 : {
879 : FormatElement elem(
880 1785426 : replace( formatArray[nOff], section[s].from, section[s].to),
881 1785426 : formatArray[nOff + 1],
882 1785426 : formatArray[nOff + 2],
883 1785426 : formatArray[nOff + 3],
884 1785426 : formatArray[nOff + 4],
885 1785426 : formatArray[nOff + 5][0],
886 12497982 : formatArray[nOff + 6][0] != 0);
887 1785426 : seq[f] = elem;
888 1785426 : }
889 : }
890 : }
891 31490 : return seq;
892 : }
893 :
894 :
895 : Sequence< OUString > SAL_CALL
896 282 : LocaleDataImpl::getDateAcceptancePatterns( const Locale& rLocale ) throw(RuntimeException, std::exception)
897 : {
898 282 : MyFunc_Type func = reinterpret_cast<MyFunc_Type>(getFunctionSymbol( rLocale, "getDateAcceptancePatterns" ));
899 :
900 282 : if (func)
901 : {
902 282 : sal_Int16 patternsCount = 0;
903 282 : sal_Unicode **patternsArray = func( patternsCount );
904 282 : Sequence< OUString > seq( patternsCount );
905 863 : for (sal_Int16 i = 0; i < patternsCount; ++i)
906 : {
907 581 : seq[i] = OUString( patternsArray[i] );
908 : }
909 282 : return seq;
910 : }
911 : else
912 : {
913 0 : Sequence< OUString > seq(0);
914 0 : return seq;
915 : }
916 : }
917 :
918 :
919 : #define COLLATOR_OFFSET_ALGO 0
920 : #define COLLATOR_OFFSET_DEFAULT 1
921 : #define COLLATOR_OFFSET_RULE 2
922 : #define COLLATOR_ELEMENTS 3
923 :
924 : OUString SAL_CALL
925 86 : LocaleDataImpl::getCollatorRuleByAlgorithm( const Locale& rLocale, const OUString& algorithm ) throw(RuntimeException)
926 : {
927 86 : MyFunc_Type func = reinterpret_cast<MyFunc_Type>(getFunctionSymbol( rLocale, "getCollatorImplementation" ));
928 86 : if ( func ) {
929 86 : sal_Int16 collatorCount = 0;
930 86 : sal_Unicode **collatorArray = func(collatorCount);
931 86 : for(sal_Int16 i = 0; i < collatorCount; i++)
932 86 : if (algorithm.equals(collatorArray[i * COLLATOR_ELEMENTS + COLLATOR_OFFSET_ALGO]))
933 86 : return OUString(collatorArray[i * COLLATOR_ELEMENTS + COLLATOR_OFFSET_RULE]);
934 : }
935 0 : return OUString();
936 : }
937 :
938 :
939 : Sequence< Implementation > SAL_CALL
940 75 : LocaleDataImpl::getCollatorImplementations( const Locale& rLocale ) throw(RuntimeException, std::exception)
941 : {
942 75 : MyFunc_Type func = reinterpret_cast<MyFunc_Type>(getFunctionSymbol( rLocale, "getCollatorImplementation" ));
943 :
944 75 : if ( func ) {
945 75 : sal_Int16 collatorCount = 0;
946 75 : sal_Unicode **collatorArray = func(collatorCount);
947 75 : Sequence< Implementation > seq(collatorCount);
948 150 : for(sal_Int16 i = 0; i < collatorCount; i++) {
949 75 : Implementation impl(collatorArray[i * COLLATOR_ELEMENTS + COLLATOR_OFFSET_ALGO],
950 150 : collatorArray[i * COLLATOR_ELEMENTS + COLLATOR_OFFSET_DEFAULT][0] != 0);
951 75 : seq[i] = impl;
952 75 : }
953 75 : return seq;
954 : }
955 : else {
956 0 : Sequence< Implementation > seq1(0);
957 0 : return seq1;
958 : }
959 : }
960 :
961 : Sequence< OUString > SAL_CALL
962 0 : LocaleDataImpl::getCollationOptions( const Locale& rLocale ) throw(RuntimeException, std::exception)
963 : {
964 0 : MyFunc_Type func = reinterpret_cast<MyFunc_Type>(getFunctionSymbol( rLocale, "getCollationOptions" ));
965 :
966 0 : if ( func ) {
967 0 : sal_Int16 optionsCount = 0;
968 0 : sal_Unicode **optionsArray = func(optionsCount);
969 0 : Sequence< OUString > seq(optionsCount);
970 0 : for(sal_Int16 i = 0; i < optionsCount; i++) {
971 0 : seq[i] = OUString( optionsArray[i] );
972 : }
973 0 : return seq;
974 : }
975 : else {
976 0 : Sequence< OUString > seq1(0);
977 0 : return seq1;
978 : }
979 : }
980 :
981 : Sequence< OUString > SAL_CALL
982 0 : LocaleDataImpl::getSearchOptions( const Locale& rLocale ) throw(RuntimeException, std::exception)
983 : {
984 0 : MyFunc_Type func = reinterpret_cast<MyFunc_Type>(getFunctionSymbol( rLocale, "getSearchOptions" ));
985 :
986 0 : if ( func ) {
987 0 : sal_Int16 optionsCount = 0;
988 0 : sal_Unicode **optionsArray = func(optionsCount);
989 0 : Sequence< OUString > seq(optionsCount);
990 0 : for(sal_Int16 i = 0; i < optionsCount; i++) {
991 0 : seq[i] = OUString( optionsArray[i] );
992 : }
993 0 : return seq;
994 : }
995 : else {
996 0 : Sequence< OUString > seq1(0);
997 0 : return seq1;
998 : }
999 : }
1000 :
1001 : sal_Unicode ** SAL_CALL
1002 27 : LocaleDataImpl::getIndexArray(const Locale& rLocale, sal_Int16& indexCount)
1003 : {
1004 27 : MyFunc_Type func = reinterpret_cast<MyFunc_Type>(getFunctionSymbol( rLocale, "getIndexAlgorithm" ));
1005 :
1006 27 : if (func)
1007 27 : return func(indexCount);
1008 0 : return NULL;
1009 : }
1010 :
1011 : Sequence< OUString > SAL_CALL
1012 12 : LocaleDataImpl::getIndexAlgorithm( const Locale& rLocale ) throw(RuntimeException)
1013 : {
1014 12 : sal_Int16 indexCount = 0;
1015 12 : sal_Unicode **indexArray = getIndexArray(rLocale, indexCount);
1016 :
1017 12 : if ( indexArray ) {
1018 12 : Sequence< OUString > seq(indexCount);
1019 24 : for(sal_Int16 i = 0; i < indexCount; i++) {
1020 12 : seq[i] = indexArray[i*5];
1021 : }
1022 12 : return seq;
1023 : }
1024 : else {
1025 0 : Sequence< OUString > seq1(0);
1026 0 : return seq1;
1027 : }
1028 : }
1029 :
1030 : OUString SAL_CALL
1031 0 : LocaleDataImpl::getDefaultIndexAlgorithm( const Locale& rLocale ) throw(RuntimeException)
1032 : {
1033 0 : sal_Int16 indexCount = 0;
1034 0 : sal_Unicode **indexArray = getIndexArray(rLocale, indexCount);
1035 :
1036 0 : if ( indexArray ) {
1037 0 : for(sal_Int16 i = 0; i < indexCount; i++) {
1038 0 : if (indexArray[i*5 + 3][0])
1039 0 : return OUString(indexArray[i*5]);
1040 : }
1041 : }
1042 0 : return OUString();
1043 : }
1044 :
1045 : bool SAL_CALL
1046 0 : LocaleDataImpl::hasPhonetic( const Locale& rLocale ) throw(RuntimeException)
1047 : {
1048 0 : sal_Int16 indexCount = 0;
1049 0 : sal_Unicode **indexArray = getIndexArray(rLocale, indexCount);
1050 :
1051 0 : if ( indexArray ) {
1052 0 : for(sal_Int16 i = 0; i < indexCount; i++) {
1053 0 : if (indexArray[i*5 + 4][0])
1054 0 : return true;
1055 : }
1056 : }
1057 0 : return false;
1058 : }
1059 :
1060 : sal_Unicode ** SAL_CALL
1061 15 : LocaleDataImpl::getIndexArrayForAlgorithm(const Locale& rLocale, const OUString& algorithm)
1062 : {
1063 15 : sal_Int16 indexCount = 0;
1064 15 : sal_Unicode **indexArray = getIndexArray(rLocale, indexCount);
1065 15 : if ( indexArray ) {
1066 15 : for(sal_Int16 i = 0; i < indexCount; i++) {
1067 15 : if (algorithm.equals(indexArray[i*5]))
1068 15 : return indexArray+i*5;
1069 : }
1070 : }
1071 0 : return NULL;
1072 : }
1073 :
1074 : bool SAL_CALL
1075 5 : LocaleDataImpl::isPhonetic( const Locale& rLocale, const OUString& algorithm ) throw(RuntimeException)
1076 : {
1077 5 : sal_Unicode **indexArray = getIndexArrayForAlgorithm(rLocale, algorithm);
1078 5 : return indexArray && indexArray[4][0];
1079 : }
1080 :
1081 : OUString SAL_CALL
1082 5 : LocaleDataImpl::getIndexKeysByAlgorithm( const Locale& rLocale, const OUString& algorithm ) throw(RuntimeException)
1083 : {
1084 5 : sal_Unicode **indexArray = getIndexArrayForAlgorithm(rLocale, algorithm);
1085 5 : return indexArray ? "0-9"+OUString(indexArray[2]) : OUString();
1086 : }
1087 :
1088 : OUString SAL_CALL
1089 5 : LocaleDataImpl::getIndexModuleByAlgorithm( const Locale& rLocale, const OUString& algorithm ) throw(RuntimeException)
1090 : {
1091 5 : sal_Unicode **indexArray = getIndexArrayForAlgorithm(rLocale, algorithm);
1092 5 : return indexArray ? OUString(indexArray[1]) : OUString();
1093 : }
1094 :
1095 : Sequence< UnicodeScript > SAL_CALL
1096 5 : LocaleDataImpl::getUnicodeScripts( const Locale& rLocale ) throw(RuntimeException)
1097 : {
1098 5 : MyFunc_Type func = reinterpret_cast<MyFunc_Type>(getFunctionSymbol( rLocale, "getUnicodeScripts" ));
1099 :
1100 5 : if ( func ) {
1101 5 : sal_Int16 scriptCount = 0;
1102 5 : sal_Unicode **scriptArray = func(scriptCount);
1103 5 : Sequence< UnicodeScript > seq(scriptCount);
1104 15 : for(sal_Int16 i = 0; i < scriptCount; i++) {
1105 10 : seq[i] = UnicodeScript( OUString(scriptArray[i]).toInt32() );
1106 : }
1107 5 : return seq;
1108 : }
1109 : else {
1110 0 : Sequence< UnicodeScript > seq1(0);
1111 0 : return seq1;
1112 : }
1113 : }
1114 :
1115 : Sequence< OUString > SAL_CALL
1116 0 : LocaleDataImpl::getFollowPageWords( const Locale& rLocale ) throw(RuntimeException)
1117 : {
1118 0 : MyFunc_Type func = reinterpret_cast<MyFunc_Type>(getFunctionSymbol( rLocale, "getFollowPageWords" ));
1119 :
1120 0 : if ( func ) {
1121 0 : sal_Int16 wordCount = 0;
1122 0 : sal_Unicode **wordArray = func(wordCount);
1123 0 : Sequence< OUString > seq(wordCount);
1124 0 : for(sal_Int16 i = 0; i < wordCount; i++) {
1125 0 : seq[i] = OUString(wordArray[i]);
1126 : }
1127 0 : return seq;
1128 : }
1129 : else {
1130 0 : Sequence< OUString > seq1(0);
1131 0 : return seq1;
1132 : }
1133 : }
1134 :
1135 : Sequence< OUString > SAL_CALL
1136 0 : LocaleDataImpl::getTransliterations( const Locale& rLocale ) throw(RuntimeException, std::exception)
1137 : {
1138 0 : MyFunc_Type func = reinterpret_cast<MyFunc_Type>(getFunctionSymbol( rLocale, "getTransliterations" ));
1139 :
1140 0 : if ( func ) {
1141 0 : sal_Int16 transliterationsCount = 0;
1142 0 : sal_Unicode **transliterationsArray = func(transliterationsCount);
1143 :
1144 0 : Sequence< OUString > seq(transliterationsCount);
1145 0 : for(int i = 0; i < transliterationsCount; i++) {
1146 0 : OUString elem(transliterationsArray[i]);
1147 0 : seq[i] = elem;
1148 0 : }
1149 0 : return seq;
1150 : }
1151 : else {
1152 0 : Sequence< OUString > seq1(0);
1153 0 : return seq1;
1154 : }
1155 :
1156 :
1157 : }
1158 :
1159 :
1160 : LanguageCountryInfo SAL_CALL
1161 85402951 : LocaleDataImpl::getLanguageCountryInfo( const Locale& rLocale ) throw(RuntimeException, std::exception)
1162 : {
1163 85402951 : MyFunc_Type func = reinterpret_cast<MyFunc_Type>(getFunctionSymbol( rLocale, "getLCInfo" ));
1164 :
1165 85402951 : if ( func ) {
1166 85402951 : sal_Int16 LCInfoCount = 0;
1167 85402951 : sal_Unicode **LCInfoArray = func(LCInfoCount);
1168 : LanguageCountryInfo info(LCInfoArray[0],
1169 85402951 : LCInfoArray[1],
1170 85402951 : LCInfoArray[2],
1171 85402951 : LCInfoArray[3],
1172 341611804 : LCInfoArray[4]);
1173 85402951 : return info;
1174 : }
1175 : else {
1176 0 : LanguageCountryInfo info1;
1177 0 : return info1;
1178 : }
1179 :
1180 : }
1181 :
1182 :
1183 : ForbiddenCharacters SAL_CALL
1184 3204 : LocaleDataImpl::getForbiddenCharacters( const Locale& rLocale ) throw(RuntimeException, std::exception)
1185 : {
1186 3204 : MyFunc_Type func = reinterpret_cast<MyFunc_Type>(getFunctionSymbol( rLocale, "getForbiddenCharacters" ));
1187 :
1188 3204 : if ( func ) {
1189 3204 : sal_Int16 LCForbiddenCharactersCount = 0;
1190 3204 : sal_Unicode **LCForbiddenCharactersArray = func(LCForbiddenCharactersCount);
1191 3204 : ForbiddenCharacters chars(LCForbiddenCharactersArray[0], LCForbiddenCharactersArray[1]);
1192 3204 : return chars;
1193 : }
1194 : else {
1195 0 : ForbiddenCharacters chars1;
1196 0 : return chars1;
1197 : }
1198 : }
1199 :
1200 : OUString SAL_CALL
1201 603 : LocaleDataImpl::getHangingCharacters( const Locale& rLocale ) throw(RuntimeException)
1202 : {
1203 603 : MyFunc_Type func = reinterpret_cast<MyFunc_Type>(getFunctionSymbol( rLocale, "getForbiddenCharacters" ));
1204 :
1205 603 : if ( func ) {
1206 603 : sal_Int16 LCForbiddenCharactersCount = 0;
1207 603 : sal_Unicode **LCForbiddenCharactersArray = func(LCForbiddenCharactersCount);
1208 603 : return OUString(LCForbiddenCharactersArray[2]);
1209 : }
1210 :
1211 0 : return OUString();
1212 : }
1213 :
1214 : Sequence< OUString > SAL_CALL
1215 5576 : LocaleDataImpl::getBreakIteratorRules( const Locale& rLocale ) throw(RuntimeException)
1216 : {
1217 5576 : MyFunc_Type func = reinterpret_cast<MyFunc_Type>(getFunctionSymbol( rLocale, "getBreakIteratorRules" ));
1218 :
1219 5576 : if ( func ) {
1220 5576 : sal_Int16 LCBreakIteratorRuleCount = 0;
1221 5576 : sal_Unicode **LCBreakIteratorRulesArray = func(LCBreakIteratorRuleCount);
1222 5576 : Sequence< OUString > seq(LCBreakIteratorRuleCount);
1223 33456 : for(int i = 0; i < (LCBreakIteratorRuleCount); i++) {
1224 27880 : OUString elem(LCBreakIteratorRulesArray[i]);
1225 27880 : seq[i] = elem;
1226 27880 : }
1227 5576 : return seq;
1228 : }
1229 : else {
1230 0 : Sequence< OUString > seq1(0);
1231 0 : return seq1;
1232 : }
1233 : }
1234 :
1235 :
1236 : Sequence< OUString > SAL_CALL
1237 1122 : LocaleDataImpl::getReservedWord( const Locale& rLocale ) throw(RuntimeException, std::exception)
1238 : {
1239 1122 : MyFunc_Type func = reinterpret_cast<MyFunc_Type>(getFunctionSymbol( rLocale, "getReservedWords" ));
1240 :
1241 1122 : if ( func ) {
1242 1122 : sal_Int16 LCReservedWordsCount = 0;
1243 1122 : sal_Unicode **LCReservedWordsArray = func(LCReservedWordsCount);
1244 1122 : Sequence< OUString > seq(LCReservedWordsCount);
1245 14586 : for(int i = 0; i < (LCReservedWordsCount); i++) {
1246 13464 : OUString elem(LCReservedWordsArray[i]);
1247 13464 : seq[i] = elem;
1248 13464 : }
1249 1122 : return seq;
1250 : }
1251 : else {
1252 0 : Sequence< OUString > seq1(0);
1253 0 : return seq1;
1254 : }
1255 : }
1256 :
1257 :
1258 : Sequence< Sequence<beans::PropertyValue> > SAL_CALL
1259 0 : LocaleDataImpl::getContinuousNumberingLevels( const lang::Locale& rLocale ) throw(RuntimeException)
1260 : {
1261 : // load symbol
1262 0 : MyFunc_Type2 func = reinterpret_cast<MyFunc_Type2>(getFunctionSymbol( rLocale, "getContinuousNumberingLevels" ));
1263 :
1264 0 : if ( func )
1265 : {
1266 : int i;
1267 : // invoke function
1268 : sal_Int16 nStyles;
1269 : sal_Int16 nAttributes;
1270 0 : sal_Unicode*** p0 = func( nStyles, nAttributes );
1271 :
1272 : // allocate memory for nAttributes attributes for each of the nStyles styles.
1273 0 : Sequence< Sequence<beans::PropertyValue> > pv( nStyles );
1274 0 : for( i=0; i<pv.getLength(); i++ ) {
1275 0 : pv[i] = Sequence<beans::PropertyValue>( nAttributes );
1276 : }
1277 :
1278 0 : sal_Unicode*** pStyle = p0;
1279 0 : for( i=0; i<nStyles; i++ ) {
1280 0 : sal_Unicode** pAttribute = pStyle[i];
1281 0 : for( int j=0; j<nAttributes; j++ ) { // prefix, numberingtype, ...
1282 0 : sal_Unicode* pString = pAttribute[j];
1283 0 : beans::PropertyValue& rVal = pv[i][j];
1284 0 : OUString sVal;
1285 0 : if( pString ) {
1286 0 : if( 0 != j && 2 != j )
1287 0 : sVal = pString;
1288 0 : else if( *pString )
1289 0 : sVal = OUString( pString, 1 );
1290 : }
1291 :
1292 0 : switch( j )
1293 : {
1294 : case 0:
1295 0 : rVal.Name = "Prefix";
1296 0 : rVal.Value <<= sVal;
1297 0 : break;
1298 : case 1:
1299 0 : rVal.Name = "NumberingType";
1300 0 : rVal.Value <<= (sal_Int16) sVal.toInt32();
1301 0 : break;
1302 : case 2:
1303 0 : rVal.Name = "Suffix";
1304 0 : rVal.Value <<= sVal;
1305 0 : break;
1306 : case 3:
1307 0 : rVal.Name = "Transliteration";
1308 0 : rVal.Value <<= sVal;
1309 0 : break;
1310 : case 4:
1311 0 : rVal.Name = "NatNum";
1312 0 : rVal.Value <<= (sal_Int16) sVal.toInt32();
1313 0 : break;
1314 : default:
1315 : OSL_ASSERT(false);
1316 : }
1317 0 : }
1318 : }
1319 0 : return pv;
1320 : }
1321 :
1322 0 : Sequence< Sequence<beans::PropertyValue> > seq1(0);
1323 0 : return seq1;
1324 : }
1325 :
1326 : // OutlineNumbering helper class
1327 :
1328 : #include <com/sun/star/container/XIndexAccess.hpp>
1329 : #include <cppuhelper/implbase1.hxx>
1330 :
1331 : namespace com{ namespace sun{ namespace star{ namespace lang {
1332 : struct Locale;
1333 : }}}}
1334 :
1335 0 : struct OutlineNumberingLevel_Impl
1336 : {
1337 : OUString sPrefix;
1338 : sal_Int16 nNumType; //com::sun::star::style::NumberingType
1339 : OUString sSuffix;
1340 : sal_Unicode cBulletChar;
1341 : OUString sBulletFontName;
1342 : sal_Int16 nParentNumbering;
1343 : sal_Int32 nLeftMargin;
1344 : sal_Int32 nSymbolTextDistance;
1345 : sal_Int32 nFirstLineOffset;
1346 : OUString sTransliteration;
1347 : sal_Int32 nNatNum;
1348 : };
1349 :
1350 : class OutlineNumbering : public cppu::WeakImplHelper1 < container::XIndexAccess >
1351 : {
1352 : // OutlineNumbering helper class
1353 :
1354 : const OutlineNumberingLevel_Impl* m_pOutlineLevels;
1355 : sal_Int16 m_nCount;
1356 : public:
1357 : OutlineNumbering(const OutlineNumberingLevel_Impl* pOutlineLevels, int nLevels);
1358 : virtual ~OutlineNumbering();
1359 :
1360 : //XIndexAccess
1361 : virtual sal_Int32 SAL_CALL getCount( ) throw(RuntimeException, std::exception) SAL_OVERRIDE;
1362 : virtual Any SAL_CALL getByIndex( sal_Int32 Index )
1363 : throw(IndexOutOfBoundsException, WrappedTargetException, RuntimeException, std::exception) SAL_OVERRIDE;
1364 :
1365 : //XElementAccess
1366 : virtual Type SAL_CALL getElementType( ) throw(RuntimeException, std::exception) SAL_OVERRIDE;
1367 : virtual sal_Bool SAL_CALL hasElements( ) throw(RuntimeException, std::exception) SAL_OVERRIDE;
1368 : };
1369 :
1370 : Sequence< Reference<container::XIndexAccess> > SAL_CALL
1371 0 : LocaleDataImpl::getOutlineNumberingLevels( const lang::Locale& rLocale ) throw(RuntimeException)
1372 : {
1373 : // load symbol
1374 0 : MyFunc_Type3 func = reinterpret_cast<MyFunc_Type3>(getFunctionSymbol( rLocale, "getOutlineNumberingLevels" ));
1375 :
1376 0 : if ( func )
1377 : {
1378 : int i;
1379 : // invoke function
1380 : sal_Int16 nStyles;
1381 : sal_Int16 nLevels;
1382 : sal_Int16 nAttributes;
1383 0 : sal_Unicode**** p0 = func( nStyles, nLevels, nAttributes );
1384 :
1385 0 : Sequence< Reference<container::XIndexAccess> > aRet( nStyles );
1386 :
1387 0 : OUString aEmptyStr;
1388 :
1389 0 : sal_Unicode**** pStyle = p0;
1390 0 : for( i=0; i<nStyles; i++ )
1391 : {
1392 : int j;
1393 :
1394 0 : OutlineNumberingLevel_Impl* level = new OutlineNumberingLevel_Impl[ nLevels+1 ];
1395 0 : sal_Unicode*** pLevel = pStyle[i];
1396 0 : for( j = 0; j < nLevels; j++ )
1397 : {
1398 0 : sal_Unicode** pAttribute = pLevel[j];
1399 0 : for( int k=0; k<nAttributes; k++ )
1400 : {
1401 0 : OUString tmp( pAttribute[k] );
1402 0 : switch( k )
1403 : {
1404 0 : case 0: level[j].sPrefix = tmp; break;
1405 0 : case 1: level[j].nNumType = sal::static_int_cast<sal_Int16>(tmp.toInt32()); break;
1406 0 : case 2: level[j].sSuffix = tmp; break;
1407 0 : case 3: level[j].cBulletChar = sal::static_int_cast<sal_Unicode>(tmp.toUInt32(16)); break; // base 16
1408 0 : case 4: level[j].sBulletFontName = tmp; break;
1409 0 : case 5: level[j].nParentNumbering = sal::static_int_cast<sal_Int16>(tmp.toInt32()); break;
1410 0 : case 6: level[j].nLeftMargin = tmp.toInt32(); break;
1411 0 : case 7: level[j].nSymbolTextDistance = tmp.toInt32(); break;
1412 0 : case 8: level[j].nFirstLineOffset = tmp.toInt32(); break;
1413 0 : case 9: break;
1414 0 : case 10: level[j].sTransliteration = tmp; break;
1415 0 : case 11: level[j].nNatNum = tmp.toInt32(); break;
1416 : default:
1417 : OSL_ASSERT(false);
1418 : }
1419 0 : }
1420 : }
1421 0 : level[j].sPrefix = aEmptyStr;
1422 0 : level[j].nNumType = 0;
1423 0 : level[j].sSuffix = aEmptyStr;
1424 0 : level[j].cBulletChar = 0;
1425 0 : level[j].sBulletFontName = aEmptyStr;
1426 0 : level[j].nParentNumbering = 0;
1427 0 : level[j].nLeftMargin = 0;
1428 0 : level[j].nSymbolTextDistance = 0;
1429 0 : level[j].nFirstLineOffset = 0;
1430 0 : level[j].sTransliteration = aEmptyStr;
1431 0 : level[j].nNatNum = 0;
1432 0 : aRet[i] = new OutlineNumbering( level, nLevels );
1433 : }
1434 0 : return aRet;
1435 : }
1436 : else {
1437 0 : Sequence< Reference<container::XIndexAccess> > seq1(0);
1438 0 : return seq1;
1439 : }
1440 : }
1441 :
1442 : // helper functions
1443 :
1444 85558486 : oslGenericFunction SAL_CALL LocaleDataImpl::getFunctionSymbol( const Locale& rLocale, const sal_Char* pFunction )
1445 : throw(RuntimeException)
1446 : {
1447 85558486 : lcl_LookupTableHelper & rLookupTable = lcl_LookupTableStatic::get();
1448 :
1449 85558486 : OUStringBuffer aBuf(1);
1450 85558486 : if (cachedItem.get() && cachedItem->equals(rLocale))
1451 : {
1452 85480947 : aBuf.ensureCapacity(strlen(pFunction) + 1 + strlen(cachedItem->localeName));
1453 170961894 : return cachedItem->module->getFunctionSymbol(aBuf.appendAscii(pFunction).append(cUnder).
1454 256442841 : appendAscii(cachedItem->localeName).makeStringAndClear());
1455 : }
1456 :
1457 77539 : oslGenericFunction pSymbol = 0;
1458 77539 : LocaleDataLookupTableItem *pCachedItem = 0;
1459 :
1460 : // Load function with name <func>_<lang>_<country> or <func>_<bcp47> and
1461 : // fallbacks.
1462 : pSymbol = rLookupTable.getFunctionSymbolByName( LocaleDataImpl::getFirstLocaleServiceName( rLocale),
1463 77539 : pFunction, &pCachedItem);
1464 77539 : if (!pSymbol)
1465 : {
1466 54 : ::std::vector< OUString > aFallbacks( LocaleDataImpl::getFallbackLocaleServiceNames( rLocale));
1467 54 : for (::std::vector< OUString >::const_iterator it( aFallbacks.begin()); it != aFallbacks.end(); ++it)
1468 : {
1469 0 : pSymbol = rLookupTable.getFunctionSymbolByName( *it, pFunction, &pCachedItem);
1470 0 : if (pSymbol)
1471 0 : break;
1472 54 : }
1473 : }
1474 77539 : if (!pSymbol)
1475 : {
1476 : // load default function with name <func>_en_US
1477 54 : pSymbol = rLookupTable.getFunctionSymbolByName(OUString("en_US"), pFunction, &pCachedItem);
1478 : }
1479 :
1480 77539 : if (!pSymbol)
1481 : // Appropriate symbol could not be found. Give up.
1482 0 : throw RuntimeException();
1483 :
1484 77539 : if (pCachedItem)
1485 77539 : cachedItem.reset(pCachedItem);
1486 77539 : if (cachedItem.get())
1487 77539 : cachedItem->aLocale = rLocale;
1488 :
1489 77539 : return pSymbol;
1490 : }
1491 :
1492 : Sequence< Locale > SAL_CALL
1493 43 : LocaleDataImpl::getAllInstalledLocaleNames() throw(RuntimeException, std::exception)
1494 : {
1495 43 : Sequence< lang::Locale > seq( nbOfLocales );
1496 43 : sal_Int16 nInstalled = 0;
1497 :
1498 10578 : for( sal_Int16 i=0; i<nbOfLocales; i++ ) {
1499 10535 : OUString name = OUString::createFromAscii( aLibTable[i].pLocale );
1500 :
1501 : // Check if the locale is really available and not just in the table,
1502 : // don't allow fall backs.
1503 10535 : LocaleDataLookupTableItem *pCachedItem = 0;
1504 10535 : if (lcl_LookupTableStatic::get().getFunctionSymbolByName( name, "getLocaleItem", &pCachedItem )) {
1505 10535 : if( pCachedItem )
1506 10535 : cachedItem.reset( pCachedItem );
1507 10535 : seq[nInstalled++] = LanguageTag::convertToLocale( name.replace( cUnder, cHyphen), false);
1508 : }
1509 : else
1510 : {
1511 0 : delete pCachedItem;
1512 : }
1513 10535 : }
1514 43 : if ( nInstalled < nbOfLocales )
1515 0 : seq.realloc( nInstalled ); // reflect reality
1516 :
1517 43 : return seq;
1518 : }
1519 :
1520 : using namespace ::com::sun::star::container;
1521 : using namespace ::com::sun::star::beans;
1522 : using namespace ::com::sun::star::style;
1523 : using namespace ::com::sun::star::text;
1524 :
1525 0 : OutlineNumbering::OutlineNumbering(const OutlineNumberingLevel_Impl* pOutlnLevels, int nLevels) :
1526 : m_pOutlineLevels(pOutlnLevels),
1527 0 : m_nCount(sal::static_int_cast<sal_Int16>(nLevels))
1528 : {
1529 0 : }
1530 :
1531 0 : OutlineNumbering::~OutlineNumbering()
1532 : {
1533 0 : delete [] m_pOutlineLevels;
1534 0 : }
1535 :
1536 0 : sal_Int32 OutlineNumbering::getCount( ) throw(RuntimeException, std::exception)
1537 : {
1538 0 : return m_nCount;
1539 : }
1540 :
1541 0 : Any OutlineNumbering::getByIndex( sal_Int32 nIndex )
1542 : throw(IndexOutOfBoundsException, WrappedTargetException, RuntimeException, std::exception)
1543 : {
1544 0 : if(nIndex < 0 || nIndex >= m_nCount)
1545 0 : throw IndexOutOfBoundsException();
1546 0 : const OutlineNumberingLevel_Impl* pTemp = m_pOutlineLevels;
1547 0 : pTemp += nIndex;
1548 0 : Any aRet;
1549 :
1550 0 : Sequence<PropertyValue> aOutlineNumbering(12);
1551 0 : PropertyValue* pValues = aOutlineNumbering.getArray();
1552 0 : pValues[0].Name = "Prefix";
1553 0 : pValues[0].Value <<= pTemp->sPrefix;
1554 0 : pValues[1].Name = "NumberingType";
1555 0 : pValues[1].Value <<= pTemp->nNumType;
1556 0 : pValues[2].Name = "Suffix";
1557 0 : pValues[2].Value <<= pTemp->sSuffix;
1558 0 : pValues[3].Name = "BulletChar";
1559 0 : pValues[3].Value <<= OUString(&pTemp->cBulletChar, 1);
1560 0 : pValues[4].Name = "BulletFontName";
1561 0 : pValues[4].Value <<= pTemp->sBulletFontName;
1562 0 : pValues[5].Name = "ParentNumbering";
1563 0 : pValues[5].Value <<= pTemp->nParentNumbering;
1564 0 : pValues[6].Name = "LeftMargin";
1565 0 : pValues[6].Value <<= pTemp->nLeftMargin;
1566 0 : pValues[7].Name = "SymbolTextDistance";
1567 0 : pValues[7].Value <<= pTemp->nSymbolTextDistance;
1568 0 : pValues[8].Name = "FirstLineOffset";
1569 0 : pValues[8].Value <<= pTemp->nFirstLineOffset;
1570 0 : pValues[9].Name = "Adjust";
1571 0 : pValues[9].Value <<= (sal_Int16)HoriOrientation::LEFT;
1572 0 : pValues[10].Name = "Transliteration";
1573 0 : pValues[10].Value <<= pTemp->sTransliteration;
1574 0 : pValues[11].Name = "NatNum";
1575 0 : pValues[11].Value <<= pTemp->nNatNum;
1576 0 : aRet <<= aOutlineNumbering;
1577 0 : return aRet;
1578 : }
1579 :
1580 0 : Type OutlineNumbering::getElementType( ) throw(RuntimeException, std::exception)
1581 : {
1582 0 : return cppu::UnoType<Sequence<PropertyValue>>::get();
1583 : }
1584 :
1585 0 : sal_Bool OutlineNumbering::hasElements( ) throw(RuntimeException, std::exception)
1586 : {
1587 0 : return m_nCount > 0;
1588 : }
1589 :
1590 : OUString SAL_CALL
1591 1 : LocaleDataImpl::getImplementationName() throw( RuntimeException, std::exception )
1592 : {
1593 1 : return OUString("com.sun.star.i18n.LocaleDataImpl");
1594 : }
1595 :
1596 0 : sal_Bool SAL_CALL LocaleDataImpl::supportsService(const OUString& rServiceName)
1597 : throw( RuntimeException, std::exception )
1598 : {
1599 0 : return cppu::supportsService(this, rServiceName);
1600 : }
1601 :
1602 : Sequence< OUString > SAL_CALL
1603 1 : LocaleDataImpl::getSupportedServiceNames() throw( RuntimeException, std::exception )
1604 : {
1605 1 : Sequence< OUString > aRet(1);
1606 1 : aRet[0] = "com.sun.star.i18n.LocaleData";
1607 1 : return aRet;
1608 : }
1609 :
1610 : // static
1611 116532 : OUString LocaleDataImpl::getFirstLocaleServiceName( const com::sun::star::lang::Locale & rLocale )
1612 : {
1613 116532 : if (rLocale.Language == I18NLANGTAG_QLT)
1614 602 : return rLocale.Variant.replace( cHyphen, cUnder);
1615 115930 : else if (!rLocale.Country.isEmpty())
1616 114521 : return rLocale.Language + "_" + rLocale.Country;
1617 : else
1618 1409 : return rLocale.Language;
1619 : }
1620 :
1621 : // static
1622 38081 : ::std::vector< OUString > LocaleDataImpl::getFallbackLocaleServiceNames( const com::sun::star::lang::Locale & rLocale )
1623 : {
1624 38081 : ::std::vector< OUString > aVec;
1625 38081 : if (rLocale.Language == I18NLANGTAG_QLT)
1626 : {
1627 0 : aVec = LanguageTag( rLocale).getFallbackStrings( false);
1628 0 : for (::std::vector< OUString >::iterator it(aVec.begin()); it != aVec.end(); ++it)
1629 : {
1630 0 : *it = (*it).replace( cHyphen, cUnder);
1631 : }
1632 : }
1633 38081 : else if (!rLocale.Country.isEmpty())
1634 : {
1635 37981 : aVec.push_back( rLocale.Language);
1636 : }
1637 : // else nothing, language-only was the first
1638 38081 : return aVec;
1639 : }
1640 :
1641 : extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface * SAL_CALL
1642 59818 : com_sun_star_i18n_LocaleDataImpl_get_implementation(
1643 : css::uno::XComponentContext *,
1644 : css::uno::Sequence<css::uno::Any> const &)
1645 : {
1646 59818 : return cppu::acquire(new LocaleDataImpl());
1647 705 : }
1648 :
1649 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
