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