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