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 <numeric>
21 : #include <boost/tuple/tuple.hpp>
22 :
23 : #include <SwStyleNameMapper.hxx>
24 : #include <tools/resmgr.hxx>
25 : #include <poolfmt.hxx>
26 : #include <rcid.hrc>
27 :
28 : #ifdef _NEED_TO_DEBUG_MAPPING
29 : #include <stdlib.h>
30 : #endif
31 :
32 : extern ResMgr* pSwResMgr;
33 : // Initialise UI names to 0
34 : ::std::vector<OUString> *SwStyleNameMapper::pTextUINameArray = 0,
35 : *SwStyleNameMapper::pListsUINameArray = 0,
36 : *SwStyleNameMapper::pExtraUINameArray = 0,
37 : *SwStyleNameMapper::pRegisterUINameArray = 0,
38 : *SwStyleNameMapper::pDocUINameArray = 0,
39 : *SwStyleNameMapper::pHTMLUINameArray = 0,
40 : *SwStyleNameMapper::pFrameFormatUINameArray = 0,
41 : *SwStyleNameMapper::pChrFormatUINameArray = 0,
42 : *SwStyleNameMapper::pHTMLChrFormatUINameArray = 0,
43 : *SwStyleNameMapper::pPageDescUINameArray = 0,
44 : *SwStyleNameMapper::pNumRuleUINameArray = 0,
45 :
46 : // Initialise programmatic names to 0
47 : *SwStyleNameMapper::pTextProgNameArray = 0,
48 : *SwStyleNameMapper::pListsProgNameArray = 0,
49 : *SwStyleNameMapper::pExtraProgNameArray = 0,
50 : *SwStyleNameMapper::pRegisterProgNameArray = 0,
51 : *SwStyleNameMapper::pDocProgNameArray = 0,
52 : *SwStyleNameMapper::pHTMLProgNameArray = 0,
53 : *SwStyleNameMapper::pFrameFormatProgNameArray = 0,
54 : *SwStyleNameMapper::pChrFormatProgNameArray = 0,
55 : *SwStyleNameMapper::pHTMLChrFormatProgNameArray = 0,
56 : *SwStyleNameMapper::pPageDescProgNameArray = 0,
57 : *SwStyleNameMapper::pNumRuleProgNameArray = 0;
58 :
59 : NameToIdHash *SwStyleNameMapper::pParaUIMap = 0,
60 : *SwStyleNameMapper::pCharUIMap = 0,
61 : *SwStyleNameMapper::pPageUIMap = 0,
62 : *SwStyleNameMapper::pFrameUIMap = 0,
63 : *SwStyleNameMapper::pNumRuleUIMap = 0,
64 :
65 : *SwStyleNameMapper::pParaProgMap = 0,
66 : *SwStyleNameMapper::pCharProgMap = 0,
67 : *SwStyleNameMapper::pPageProgMap = 0,
68 : *SwStyleNameMapper::pFrameProgMap = 0,
69 : *SwStyleNameMapper::pNumRuleProgMap = 0;
70 :
71 : // SwTableEntry so we can pass the length to the String CTOR
72 : struct SwTableEntry
73 : {
74 : sal_uInt8 nLength;
75 : const sal_Char *pChar;
76 : };
77 :
78 : namespace
79 : {
80 :
81 : #define ENTRY( s ) { sizeof (s)-1, s }
82 :
83 : // Hard coded Programmatic Name tables
84 : const struct SwTableEntry TextProgNameTable [] =
85 : {
86 : ENTRY( "Standard" ), // RES_POOLCOLL_STANDARD
87 : ENTRY( "Text body" ),
88 : ENTRY( "First line indent" ),
89 : ENTRY( "Hanging indent" ),
90 : ENTRY( "Text body indent" ),
91 : ENTRY( "Salutation" ),
92 : ENTRY( "Signature" ),
93 : ENTRY( "List Indent" ), // RES_POOLCOLL_CONFRONTATION
94 : ENTRY( "Marginalia" ),
95 : ENTRY( "Heading" ),
96 : ENTRY( "Heading 1" ),
97 : ENTRY( "Heading 2" ),
98 : ENTRY( "Heading 3" ),
99 : ENTRY( "Heading 4" ),
100 : ENTRY( "Heading 5" ),
101 : ENTRY( "Heading 6" ),
102 : ENTRY( "Heading 7" ),
103 : ENTRY( "Heading 8" ),
104 : ENTRY( "Heading 9" ),
105 : ENTRY( "Heading 10" ), // RES_POOLCOLL_TEXT_END
106 : { 0, NULL }
107 : };
108 :
109 : const struct SwTableEntry ListsProgNameTable [] =
110 : {
111 : ENTRY( "List" ), // STR_POCO_PRGM_NUMBUL_BASE
112 : ENTRY( "Numbering 1 Start" ), // STR_POCO_PRGM_NUM_LEVEL1S
113 : ENTRY( "Numbering 1" ),
114 : ENTRY( "Numbering 1 End" ),
115 : ENTRY( "Numbering 1 Cont." ),
116 : ENTRY( "Numbering 2 Start" ),
117 : ENTRY( "Numbering 2" ),
118 : ENTRY( "Numbering 2 End" ),
119 : ENTRY( "Numbering 2 Cont." ),
120 : ENTRY( "Numbering 3 Start" ),
121 : ENTRY( "Numbering 3" ),
122 : ENTRY( "Numbering 3 End" ),
123 : ENTRY( "Numbering 3 Cont." ),
124 : ENTRY( "Numbering 4 Start" ),
125 : ENTRY( "Numbering 4" ),
126 : ENTRY( "Numbering 4 End" ),
127 : ENTRY( "Numbering 4 Cont." ),
128 : ENTRY( "Numbering 5 Start" ),
129 : ENTRY( "Numbering 5" ),
130 : ENTRY( "Numbering 5 End" ),
131 : ENTRY( "Numbering 5 Cont." ),
132 : ENTRY( "List 1 Start" ),
133 : ENTRY( "List 1" ),
134 : ENTRY( "List 1 End" ),
135 : ENTRY( "List 1 Cont." ),
136 : ENTRY( "List 2 Start" ),
137 : ENTRY( "List 2" ),
138 : ENTRY( "List 2 End" ),
139 : ENTRY( "List 2 Cont." ),
140 : ENTRY( "List 3 Start" ),
141 : ENTRY( "List 3" ),
142 : ENTRY( "List 3 End" ),
143 : ENTRY( "List 3 Cont." ),
144 : ENTRY( "List 4 Start" ),
145 : ENTRY( "List 4" ),
146 : ENTRY( "List 4 End" ),
147 : ENTRY( "List 4 Cont." ),
148 : ENTRY( "List 5 Start" ),
149 : ENTRY( "List 5" ),
150 : ENTRY( "List 5 End" ),
151 : ENTRY( "List 5 Cont." ), // STR_POCO_PRGM_BUL_NONUM5
152 : { 0, NULL }
153 : };
154 :
155 : const struct SwTableEntry ExtraProgNameTable [] =
156 : {
157 : ENTRY( "Header" ), // RES_POOLCOLL_EXTRA_BEGIN
158 : ENTRY( "Header left" ),
159 : ENTRY( "Header right" ),
160 : ENTRY( "Footer" ),
161 : ENTRY( "Footer left" ),
162 : ENTRY( "Footer right" ),
163 : ENTRY( "Table Contents" ),
164 : ENTRY( "Table Heading" ),
165 : ENTRY( "Caption" ),
166 : ENTRY( "Illustration" ),
167 : ENTRY( "Table" ),
168 : ENTRY( "Text" ),
169 : ENTRY( "Frame contents" ),
170 : ENTRY( "Footnote" ),
171 : ENTRY( "Addressee" ),
172 : ENTRY( "Sender" ),
173 : ENTRY( "Endnote" ),
174 : ENTRY( "Drawing" ), // RES_POOLCOLL_LABEL_DRAWING
175 : { 0, NULL }
176 : };
177 :
178 : const struct SwTableEntry RegisterProgNameTable [] =
179 : {
180 : ENTRY( "Index" ), // STR_POCO_PRGM_REGISTER_BASE
181 : ENTRY( "Index Heading" ), // STR_POCO_PRGM_TOX_IDXH
182 : ENTRY( "Index 1" ),
183 : ENTRY( "Index 2" ),
184 : ENTRY( "Index 3" ),
185 : ENTRY( "Index Separator" ),
186 : ENTRY( "Contents Heading" ),
187 : ENTRY( "Contents 1" ),
188 : ENTRY( "Contents 2" ),
189 : ENTRY( "Contents 3" ),
190 : ENTRY( "Contents 4" ),
191 : ENTRY( "Contents 5" ),
192 : ENTRY( "User Index Heading" ),
193 : ENTRY( "User Index 1" ),
194 : ENTRY( "User Index 2" ),
195 : ENTRY( "User Index 3" ),
196 : ENTRY( "User Index 4" ),
197 : ENTRY( "User Index 5" ),
198 : ENTRY( "Contents 6" ),
199 : ENTRY( "Contents 7" ),
200 : ENTRY( "Contents 8" ),
201 : ENTRY( "Contents 9" ),
202 : ENTRY( "Contents 10" ),
203 : ENTRY( "Illustration Index Heading" ),
204 : ENTRY( "Illustration Index 1" ),
205 : ENTRY( "Object index heading" ),
206 : ENTRY( "Object index 1" ),
207 : ENTRY( "Table index heading" ),
208 : ENTRY( "Table index 1" ),
209 : ENTRY( "Bibliography Heading" ),
210 : ENTRY( "Bibliography 1" ),
211 : ENTRY( "User Index 6" ),
212 : ENTRY( "User Index 7" ),
213 : ENTRY( "User Index 8" ),
214 : ENTRY( "User Index 9" ),
215 : ENTRY( "User Index 10" ), // STR_POCO_PRGM_TOX_USER10
216 : { 0, NULL }
217 : };
218 :
219 : const struct SwTableEntry DocProgNameTable [] =
220 : {
221 : ENTRY( "Title" ), // STR_POCO_PRGM_DOC_TITEL
222 : ENTRY( "Subtitle" ),
223 : { 0, NULL }
224 : };
225 :
226 : const struct SwTableEntry HTMLProgNameTable [] =
227 : {
228 : ENTRY( "Quotations" ),
229 : ENTRY( "Preformatted Text" ),
230 : ENTRY( "Horizontal Line" ),
231 : ENTRY( "List Contents" ),
232 : ENTRY( "List Heading" ), // STR_POCO_PRGM_HTML_DT
233 : { 0, NULL }
234 : };
235 :
236 : const struct SwTableEntry FrameFormatProgNameTable [] =
237 : {
238 : ENTRY( "Frame" ), // RES_POOLFRM_FRAME
239 : ENTRY( "Graphics" ),
240 : ENTRY( "OLE" ),
241 : ENTRY( "Formula" ),
242 : ENTRY( "Marginalia" ),
243 : ENTRY( "Watermark" ),
244 : ENTRY( "Labels" ), // RES_POOLFRM_LABEL
245 : { 0, NULL }
246 : };
247 :
248 : const struct SwTableEntry ChrFormatProgNameTable [] =
249 : {
250 : ENTRY( "Footnote Symbol" ), // RES_POOLCHR_FOOTNOTE
251 : ENTRY( "Page Number" ),
252 : ENTRY( "Caption characters" ),
253 : ENTRY( "Drop Caps" ),
254 : ENTRY( "Numbering Symbols" ),
255 : ENTRY( "Bullet Symbols" ),
256 : ENTRY( "Internet link" ),
257 : ENTRY( "Visited Internet Link" ),
258 : ENTRY( "Placeholder" ),
259 : ENTRY( "Index Link" ),
260 : ENTRY( "Endnote Symbol" ),
261 : ENTRY( "Line numbering" ),
262 : ENTRY( "Main index entry" ),
263 : ENTRY( "Footnote anchor" ),
264 : ENTRY( "Endnote anchor" ),
265 : ENTRY( "Rubies" ), // RES_POOLCHR_RUBYTEXT
266 : ENTRY( "Vertical Numbering Symbols" ), // RES_POOLCHR_VERT_NUMBER
267 : { 0, NULL }
268 : };
269 :
270 : const struct SwTableEntry HTMLChrFormatProgNameTable [] =
271 : {
272 : ENTRY( "Emphasis" ), // RES_POOLCHR_HTML_EMPHASIS
273 : ENTRY( "Citation" ),
274 : ENTRY( "Strong Emphasis" ),
275 : ENTRY( "Source Text" ),
276 : ENTRY( "Example" ),
277 : ENTRY( "User Entry" ),
278 : ENTRY( "Variable" ),
279 : ENTRY( "Definition" ),
280 : ENTRY( "Teletype" ), // RES_POOLCHR_HTML_TELETYPE
281 : { 0, NULL }
282 : };
283 :
284 : const struct SwTableEntry PageDescProgNameTable [] =
285 : {
286 : ENTRY( "Standard" ), // STR_POOLPAGE_PRGM_STANDARD
287 : ENTRY( "First Page" ),
288 : ENTRY( "Left Page" ),
289 : ENTRY( "Right Page" ),
290 : ENTRY( "Envelope" ),
291 : ENTRY( "Index" ),
292 : ENTRY( "HTML" ),
293 : ENTRY( "Footnote" ),
294 : ENTRY( "Endnote" ), // STR_POOLPAGE_PRGM_ENDNOTE
295 : ENTRY( "Landscape" ),
296 : { 0, NULL }
297 : };
298 :
299 : const struct SwTableEntry NumRuleProgNameTable [] =
300 : {
301 : ENTRY( "Numbering 1" ), // STR_POOLNUMRULE_PRGM_NUM1
302 : ENTRY( "Numbering 2" ),
303 : ENTRY( "Numbering 3" ),
304 : ENTRY( "Numbering 4" ),
305 : ENTRY( "Numbering 5" ),
306 : ENTRY( "List 1" ),
307 : ENTRY( "List 2" ),
308 : ENTRY( "List 3" ),
309 : ENTRY( "List 4" ),
310 : ENTRY( "List 5" ), // STR_POOLNUMRULE_PRGM_BUL5
311 : { 0, NULL }
312 : };
313 : #undef ENTRY
314 :
315 : static ::std::vector<OUString>*
316 584 : lcl_NewUINameArray(sal_uInt16 nStt, sal_uInt16 const nEnd)
317 : {
318 584 : ::std::vector<OUString> *const pNameArray = new ::std::vector<OUString>;
319 584 : pNameArray->reserve(nEnd - nStt);
320 10818 : while( nStt < nEnd )
321 : {
322 9650 : const ResId aRId( nStt, *pSwResMgr );
323 9650 : pNameArray->push_back(OUString(aRId));
324 9650 : ++nStt;
325 : }
326 584 : return pNameArray;
327 : }
328 :
329 : static ::std::vector<OUString>*
330 545 : lcl_NewProgNameArray(const SwTableEntry *pTable, sal_uInt8 const nCount)
331 : {
332 545 : ::std::vector<OUString> *const pProgNameArray = new ::std::vector<OUString>;
333 545 : pProgNameArray->reserve(nCount);
334 10228 : while (pTable->nLength)
335 : {
336 : pProgNameArray->push_back(OUString(
337 9138 : pTable->pChar, pTable->nLength, RTL_TEXTENCODING_ASCII_US));
338 9138 : pTable++;
339 : }
340 545 : return pProgNameArray;
341 : }
342 :
343 : static OUString
344 3362 : lcl_GetSpecialExtraName(const OUString& rExtraName, const bool bIsUIName )
345 : {
346 : const ::std::vector<OUString>& rExtraArr = bIsUIName
347 : ? SwStyleNameMapper::GetExtraUINameArray()
348 3362 : : SwStyleNameMapper::GetExtraProgNameArray();
349 : static const sal_uInt16 nIds[] =
350 : {
351 : RES_POOLCOLL_LABEL_DRAWING - RES_POOLCOLL_EXTRA_BEGIN,
352 : RES_POOLCOLL_LABEL_ABB - RES_POOLCOLL_EXTRA_BEGIN,
353 : RES_POOLCOLL_LABEL_TABLE - RES_POOLCOLL_EXTRA_BEGIN,
354 : RES_POOLCOLL_LABEL_FRAME- RES_POOLCOLL_EXTRA_BEGIN,
355 : 0
356 : };
357 : const sal_uInt16 * pIds;
358 8763 : for ( pIds = nIds; *pIds; ++pIds)
359 : {
360 8620 : if (rExtraName == rExtraArr[ *pIds ])
361 : {
362 : return bIsUIName
363 294 : ? SwStyleNameMapper::GetExtraProgNameArray()[*pIds]
364 3513 : : SwStyleNameMapper::GetExtraUINameArray()[*pIds];
365 : }
366 : }
367 143 : return rExtraName;
368 : }
369 :
370 223321 : static bool lcl_SuffixIsUser(const OUString & rString)
371 : {
372 223321 : const sal_Unicode *pChar = rString.getStr();
373 223321 : sal_Int32 nLen = rString.getLength();
374 223321 : bool bRet = false;
375 386103 : if( nLen > 8 &&
376 190399 : pChar[nLen-7] == ' ' &&
377 43222 : pChar[nLen-6] == '(' &&
378 30784 : pChar[nLen-5] == 'u' &&
379 30358 : pChar[nLen-4] == 's' &&
380 30358 : pChar[nLen-3] == 'e' &&
381 30358 : pChar[nLen-2] == 'r' &&
382 15179 : pChar[nLen-1] == ')' )
383 15179 : bRet = true;
384 223321 : return bRet;
385 : }
386 :
387 171203 : static void lcl_CheckSuffixAndDelete(OUString & rString)
388 : {
389 171203 : if (lcl_SuffixIsUser(rString))
390 : {
391 15179 : rString = rString.copy(0, rString.getLength() - 7);
392 : }
393 171203 : }
394 :
395 : typedef boost::tuple<sal_uInt16, sal_uInt16, const ::std::vector<OUString>& (*)() > NameArrayIndexTuple_t;
396 :
397 1108 : static sal_uInt16 lcl_AccumulateIndexCount( sal_uInt16 nSum, const NameArrayIndexTuple_t& tuple ){
398 : // Return running sum + (index end) - (index start)
399 1108 : return nSum + boost::get<1>( tuple ) - boost::get<0>( tuple );
400 : }
401 : }
402 :
403 : #ifdef _NEED_TO_DEBUG_MAPPING
404 : void SwStyleNameMapper::testNameTable( SwGetPoolIdFromName const nFamily, sal_uInt16 const nStartIndex, sal_uInt16 const nEndIndex )
405 : {
406 : sal_uInt16 nIndex;
407 : sal_uInt16 nId;
408 :
409 : for ( nIndex = 0, nId = nStartIndex ; nId < nEndIndex ; nId++,nIndex++ )
410 : {
411 : OUString aString, bString;
412 : FillUIName ( nId, aString );
413 : bString = GetProgName ( nFamily, aString );
414 : sal_uInt16 nNewId = GetPoolIdFromProgName ( bString, nFamily );
415 : FillProgName ( nNewId, aString );
416 : bString = GetUIName ( aString, nFamily );
417 : nNewId = GetPoolIdFromUIName ( aString, nFamily );
418 : if ( nNewId != nId )
419 : abort();
420 : }
421 : }
422 : #endif
423 :
424 5159457 : const NameToIdHash & SwStyleNameMapper::getHashTable ( SwGetPoolIdFromName eFlags, bool bProgName )
425 : {
426 : // pHashPointer is a pointer to a pointer which stores the UI/prog name array
427 5159457 : NameToIdHash **pHashPointer = 0;
428 : // Stores tuples representing (index start, index end, pointer to function which returns ref to name array)
429 5159457 : ::std::vector<NameArrayIndexTuple_t> vIndexes;
430 :
431 5159457 : switch ( eFlags )
432 : {
433 : default:
434 : assert(false && "unknown pool family");
435 : //fall-through
436 : case nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL:
437 : {
438 4724634 : pHashPointer = bProgName ? &pParaProgMap : &pParaUIMap;
439 4724634 : vIndexes.push_back( boost::make_tuple(RES_POOLCOLL_TEXT_BEGIN, RES_POOLCOLL_TEXT_END, bProgName ? &GetTextProgNameArray : &GetTextUINameArray) );
440 4724634 : vIndexes.push_back( boost::make_tuple(RES_POOLCOLL_LISTS_BEGIN, RES_POOLCOLL_LISTS_END, bProgName ? &GetListsProgNameArray : &GetListsUINameArray) );
441 4724634 : vIndexes.push_back( boost::make_tuple(RES_POOLCOLL_EXTRA_BEGIN, RES_POOLCOLL_EXTRA_END, bProgName ? &GetExtraProgNameArray : &GetExtraUINameArray) );
442 4724634 : vIndexes.push_back( boost::make_tuple(RES_POOLCOLL_REGISTER_BEGIN, RES_POOLCOLL_REGISTER_END, bProgName ? &GetRegisterProgNameArray : &GetRegisterUINameArray) );
443 4724634 : vIndexes.push_back( boost::make_tuple(RES_POOLCOLL_DOC_BEGIN, RES_POOLCOLL_DOC_END, bProgName ? &GetDocProgNameArray : &GetDocUINameArray) );
444 4724634 : vIndexes.push_back( boost::make_tuple(RES_POOLCOLL_HTML_BEGIN, RES_POOLCOLL_HTML_END, bProgName ? &GetHTMLProgNameArray : &GetHTMLUINameArray) );
445 : }
446 4724634 : break;
447 : case nsSwGetPoolIdFromName::GET_POOLID_CHRFMT:
448 : {
449 246316 : pHashPointer = bProgName ? &pCharProgMap : &pCharUIMap;
450 246316 : vIndexes.push_back( boost::make_tuple(RES_POOLCHR_NORMAL_BEGIN, RES_POOLCHR_NORMAL_END, bProgName ? &GetChrFormatProgNameArray : &GetChrFormatUINameArray) );
451 246316 : vIndexes.push_back( boost::make_tuple(RES_POOLCHR_HTML_BEGIN, RES_POOLCHR_HTML_END, bProgName ? &GetHTMLChrFormatProgNameArray : &GetHTMLChrFormatUINameArray) );
452 : }
453 246316 : break;
454 : case nsSwGetPoolIdFromName::GET_POOLID_FRMFMT:
455 : {
456 27265 : pHashPointer = bProgName ? &pFrameProgMap : &pFrameUIMap;
457 27265 : vIndexes.push_back( boost::make_tuple(RES_POOLFRM_BEGIN, RES_POOLFRM_END, bProgName ? &GetFrameFormatProgNameArray : &GetFrameFormatUINameArray) );
458 : }
459 27265 : break;
460 : case nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC:
461 : {
462 30129 : pHashPointer = bProgName ? &pPageProgMap : &pPageUIMap;
463 30129 : vIndexes.push_back( boost::make_tuple(RES_POOLPAGE_BEGIN, RES_POOLPAGE_END, bProgName ? &GetPageDescProgNameArray : &GetPageDescUINameArray) );
464 : }
465 30129 : break;
466 : case nsSwGetPoolIdFromName::GET_POOLID_NUMRULE:
467 : {
468 131113 : pHashPointer = bProgName ? &pNumRuleProgMap : &pNumRuleUIMap;
469 131113 : vIndexes.push_back( boost::make_tuple(RES_POOLNUMRULE_BEGIN, RES_POOLNUMRULE_END, bProgName ? &GetNumRuleProgNameArray : &GetNumRuleUINameArray) );
470 : }
471 131113 : break;
472 : }
473 :
474 : // Proceed if we have a pointer to a hash, and the hash hasn't already been populated
475 : assert(pHashPointer && "null hash pointer");
476 5159457 : if (!*pHashPointer )
477 : {
478 : // Compute the size of the hash we need to build
479 451 : sal_uInt16 nSize = std::accumulate( vIndexes.begin(), vIndexes.end(), 0, lcl_AccumulateIndexCount );
480 :
481 451 : NameToIdHash *pHash = new NameToIdHash( nSize );
482 1559 : for ( ::std::vector<NameArrayIndexTuple_t>::iterator entry = vIndexes.begin(); entry != vIndexes.end(); ++entry )
483 : {
484 : // Get a pointer to the function which will populate pStrings
485 1108 : const ::std::vector<OUString>& (*pStringsFetchFunc)() = boost::get<2>( *entry );
486 1108 : if ( pStringsFetchFunc )
487 : {
488 1108 : const ::std::vector<OUString>& pStrings = pStringsFetchFunc();
489 : sal_uInt16 nIndex, nId;
490 19543 : for ( nIndex = 0, nId = boost::get<0>( *entry ) ; nId < boost::get<1>( *entry ) ; nId++, nIndex++ )
491 18435 : (*pHash)[pStrings[nIndex]] = nId;
492 : }
493 : }
494 :
495 451 : *pHashPointer = pHash;
496 : }
497 :
498 : #ifdef _NEED_TO_DEBUG_MAPPING
499 : static bool bTested = false;
500 : if ( !bTested )
501 : {
502 : bTested = true;
503 :
504 : testNameTable( nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, RES_POOLCOLL_TEXT_BEGIN, RES_POOLCOLL_TEXT_END );
505 : testNameTable( nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, RES_POOLCOLL_LISTS_BEGIN, RES_POOLCOLL_LISTS_END );
506 : testNameTable( nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, RES_POOLCOLL_EXTRA_BEGIN, RES_POOLCOLL_EXTRA_END );
507 : testNameTable( nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, RES_POOLCOLL_REGISTER_BEGIN, RES_POOLCOLL_REGISTER_END );
508 : testNameTable( nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, RES_POOLCOLL_DOC_BEGIN, RES_POOLCOLL_DOC_END );
509 : testNameTable( nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, RES_POOLCOLL_HTML_BEGIN, RES_POOLCOLL_HTML_END );
510 : testNameTable( nsSwGetPoolIdFromName::GET_POOLID_CHRFMT, RES_POOLCHR_NORMAL_BEGIN, RES_POOLCHR_NORMAL_END );
511 : testNameTable( nsSwGetPoolIdFromName::GET_POOLID_CHRFMT, RES_POOLCHR_HTML_BEGIN, RES_POOLCHR_HTML_END );
512 : testNameTable( nsSwGetPoolIdFromName::GET_POOLID_FRMFMT, RES_POOLFRM_BEGIN, RES_POOLFRM_END );
513 : testNameTable( nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC, RES_POOLPAGE_BEGIN, RES_POOLPAGE_END );
514 : testNameTable( nsSwGetPoolIdFromName::GET_POOLID_NUMRULE, RES_POOLNUMRULE_BEGIN, RES_POOLNUMRULE_END );
515 : }
516 : #endif
517 5159457 : return **pHashPointer;
518 : }
519 :
520 : // This gets the UI name from the programmatic name
521 455 : const OUString& SwStyleNameMapper::GetUIName(const OUString& rName,
522 : SwGetPoolIdFromName const eFlags)
523 : {
524 455 : sal_uInt16 nId = GetPoolIdFromProgName ( rName, eFlags );
525 455 : return nId != USHRT_MAX ? GetUIName( nId, rName ) : rName;
526 : }
527 :
528 : // Get the programmatic name from the UI name
529 1354 : const OUString& SwStyleNameMapper::GetProgName(
530 : const OUString& rName, SwGetPoolIdFromName const eFlags)
531 : {
532 1354 : sal_uInt16 nId = GetPoolIdFromUIName ( rName, eFlags );
533 1354 : return nId != USHRT_MAX ? GetProgName( nId, rName ) : rName;
534 : }
535 :
536 : // Get the programmatic name from the UI name in rName and put it into rFillName
537 135766 : void SwStyleNameMapper::FillProgName(
538 : const OUString& rName, OUString& rFillName,
539 : SwGetPoolIdFromName const eFlags, bool const bDisambiguate)
540 : {
541 135766 : sal_uInt16 nId = GetPoolIdFromUIName ( rName, eFlags );
542 135766 : if ( bDisambiguate && nId == USHRT_MAX )
543 : {
544 : // rName isn't in our UI name table...check if it's in the programmatic one
545 52279 : nId = GetPoolIdFromProgName ( rName, eFlags );
546 :
547 52279 : rFillName = rName;
548 104558 : if (nId == USHRT_MAX )
549 : {
550 : // It isn't ...make sure the suffix isn't already " (user)"...if it is,
551 : // we need to add another one
552 52118 : if (lcl_SuffixIsUser(rFillName))
553 0 : rFillName += " (user)";
554 : }
555 : else
556 : {
557 : // It's in the programmatic name table...append suffix
558 161 : rFillName += " (user)";
559 : }
560 : }
561 : else
562 : {
563 : // If we aren't trying to disambiguate, then just do a normal fill
564 83487 : fillNameFromId(nId, rFillName, true);
565 : }
566 135766 : }
567 :
568 : // Get the UI name from the programmatic name in rName and put it into rFillName
569 288839 : void SwStyleNameMapper::FillUIName(
570 : const OUString& rName, OUString& rFillName,
571 : SwGetPoolIdFromName const eFlags, bool const bDisambiguate)
572 : {
573 288839 : sal_uInt16 nId = GetPoolIdFromProgName ( rName, eFlags );
574 288839 : if ( bDisambiguate && nId == USHRT_MAX )
575 : {
576 171203 : rFillName = rName;
577 : // rName isn't in our Prog name table...check if it has a " (user)" suffix, if so remove it
578 171203 : lcl_CheckSuffixAndDelete ( rFillName );
579 : }
580 : else
581 : {
582 : // If we aren't trying to disambiguate, then just do a normal fill
583 117636 : fillNameFromId(nId, rFillName, false);
584 : }
585 288839 : }
586 :
587 203703 : const OUString& SwStyleNameMapper::getNameFromId(
588 : sal_uInt16 const nId, const OUString& rFillName, bool const bProgName)
589 : {
590 203703 : sal_uInt16 nStt = 0;
591 203703 : const ::std::vector<OUString>* pStrArr = 0;
592 :
593 203703 : switch( (USER_FMT | COLL_GET_RANGE_BITS | POOLGRP_NOCOLLID) & nId )
594 : {
595 : case COLL_TEXT_BITS:
596 98093 : if( RES_POOLCOLL_TEXT_BEGIN <= nId && nId < RES_POOLCOLL_TEXT_END )
597 : {
598 98093 : pStrArr = bProgName ? &GetTextProgNameArray() : &GetTextUINameArray();
599 98093 : nStt = RES_POOLCOLL_TEXT_BEGIN;
600 : }
601 98093 : break;
602 : case COLL_LISTS_BITS:
603 13092 : if( RES_POOLCOLL_LISTS_BEGIN <= nId && nId < RES_POOLCOLL_LISTS_END )
604 : {
605 13092 : pStrArr = bProgName ? &GetListsProgNameArray() : &GetListsUINameArray();
606 13092 : nStt = RES_POOLCOLL_LISTS_BEGIN;
607 : }
608 13092 : break;
609 : case COLL_EXTRA_BITS:
610 20909 : if( RES_POOLCOLL_EXTRA_BEGIN <= nId && nId < RES_POOLCOLL_EXTRA_END )
611 : {
612 20909 : pStrArr = bProgName ? &GetExtraProgNameArray() : &GetExtraUINameArray();
613 20909 : nStt = RES_POOLCOLL_EXTRA_BEGIN;
614 : }
615 20909 : break;
616 : case COLL_REGISTER_BITS:
617 15050 : if( RES_POOLCOLL_REGISTER_BEGIN <= nId && nId < RES_POOLCOLL_REGISTER_END )
618 : {
619 15050 : pStrArr = bProgName ? &GetRegisterProgNameArray() : &GetRegisterUINameArray();
620 15050 : nStt = RES_POOLCOLL_REGISTER_BEGIN;
621 : }
622 15050 : break;
623 : case COLL_DOC_BITS:
624 1981 : if( RES_POOLCOLL_DOC_BEGIN <= nId && nId < RES_POOLCOLL_DOC_END )
625 : {
626 1981 : pStrArr = bProgName ? &GetDocProgNameArray() : &GetDocUINameArray();
627 1981 : nStt = RES_POOLCOLL_DOC_BEGIN;
628 : }
629 1981 : break;
630 : case COLL_HTML_BITS:
631 2733 : if( RES_POOLCOLL_HTML_BEGIN <= nId && nId < RES_POOLCOLL_HTML_END )
632 : {
633 2733 : pStrArr = bProgName ? &GetHTMLProgNameArray() : &GetHTMLUINameArray();
634 2733 : nStt = RES_POOLCOLL_HTML_BEGIN;
635 : }
636 2733 : break;
637 : case POOLGRP_CHARFMT:
638 30442 : if( RES_POOLCHR_NORMAL_BEGIN <= nId && nId < RES_POOLCHR_NORMAL_END )
639 : {
640 21269 : pStrArr = bProgName ? &GetChrFormatProgNameArray() : &GetChrFormatUINameArray();
641 21269 : nStt = RES_POOLCHR_NORMAL_BEGIN;
642 : }
643 9173 : else if( RES_POOLCHR_HTML_BEGIN <= nId && nId < RES_POOLCHR_HTML_END )
644 : {
645 9173 : pStrArr = bProgName ? &GetHTMLChrFormatProgNameArray() : &GetHTMLChrFormatUINameArray();
646 9173 : nStt = RES_POOLCHR_HTML_BEGIN;
647 : }
648 30442 : break;
649 : case POOLGRP_FRAMEFMT:
650 4945 : if( RES_POOLFRM_BEGIN <= nId && nId < RES_POOLFRM_END )
651 : {
652 4945 : pStrArr = bProgName ? &GetFrameFormatProgNameArray() : &GetFrameFormatUINameArray();
653 4945 : nStt = RES_POOLFRM_BEGIN;
654 : }
655 4945 : break;
656 : case POOLGRP_PAGEDESC:
657 14803 : if( RES_POOLPAGE_BEGIN <= nId && nId < RES_POOLPAGE_END )
658 : {
659 14803 : pStrArr = bProgName ? &GetPageDescProgNameArray() : &GetPageDescUINameArray();
660 14803 : nStt = RES_POOLPAGE_BEGIN;
661 : }
662 14803 : break;
663 : case POOLGRP_NUMRULE:
664 1655 : if( RES_POOLNUMRULE_BEGIN <= nId && nId < RES_POOLNUMRULE_END )
665 : {
666 1655 : pStrArr = bProgName ? &GetNumRuleProgNameArray() : &GetNumRuleUINameArray();
667 1655 : nStt = RES_POOLNUMRULE_BEGIN;
668 : }
669 1655 : break;
670 : }
671 203703 : return pStrArr ? pStrArr->operator[](nId - nStt) : rFillName;
672 : }
673 :
674 202478 : void SwStyleNameMapper::fillNameFromId(
675 : sal_uInt16 const nId, OUString& rFillName, bool bProgName)
676 : {
677 202478 : rFillName = getNameFromId(nId, rFillName, bProgName);
678 202478 : }
679 :
680 : // Get the UI name from the pool ID
681 1354 : void SwStyleNameMapper::FillUIName(sal_uInt16 const nId, OUString& rFillName)
682 : {
683 1354 : fillNameFromId(nId, rFillName, false);
684 1354 : }
685 :
686 : // Get the UI name from the pool ID
687 1050 : const OUString& SwStyleNameMapper::GetUIName(
688 : sal_uInt16 const nId, const OUString& rName)
689 : {
690 1050 : return getNameFromId(nId, rName, false);
691 : }
692 :
693 : // Get the programmatic name from the pool ID
694 1 : void SwStyleNameMapper::FillProgName(sal_uInt16 nId, OUString& rFillName)
695 : {
696 1 : fillNameFromId(nId, rFillName, true);
697 1 : }
698 :
699 : // Get the programmatic name from the pool ID
700 : const OUString&
701 175 : SwStyleNameMapper::GetProgName(sal_uInt16 const nId, const OUString& rName)
702 : {
703 175 : return getNameFromId(nId, rName, true);
704 : }
705 :
706 : // This gets the PoolId from the UI Name
707 4817882 : sal_uInt16 SwStyleNameMapper::GetPoolIdFromUIName(
708 : const OUString& rName, SwGetPoolIdFromName const eFlags)
709 : {
710 4817882 : const NameToIdHash & rHashMap = getHashTable ( eFlags, false );
711 4817882 : NameToIdHash::const_iterator aIter = rHashMap.find(rName);
712 4817882 : return aIter != rHashMap.end() ? (*aIter).second : USHRT_MAX;
713 : }
714 :
715 : // Get the Pool ID from the programmatic name
716 341575 : sal_uInt16 SwStyleNameMapper::GetPoolIdFromProgName(
717 : const OUString& rName, SwGetPoolIdFromName const eFlags)
718 : {
719 341575 : const NameToIdHash & rHashMap = getHashTable ( eFlags, true );
720 341575 : NameToIdHash::const_iterator aIter = rHashMap.find(rName);
721 341575 : return aIter != rHashMap.end() ? (*aIter).second : USHRT_MAX;
722 : }
723 :
724 247547 : const ::std::vector<OUString>& SwStyleNameMapper::GetTextUINameArray()
725 : {
726 247547 : if (!pTextUINameArray)
727 : pTextUINameArray = lcl_NewUINameArray( RC_POOLCOLL_TEXT_BEGIN,
728 58 : RC_POOLCOLL_TEXT_BEGIN + (RES_POOLCOLL_TEXT_END - RES_POOLCOLL_TEXT_BEGIN) );
729 247547 : return *pTextUINameArray;
730 : }
731 :
732 41717 : const ::std::vector<OUString>& SwStyleNameMapper::GetListsUINameArray()
733 : {
734 41717 : if (!pListsUINameArray)
735 : pListsUINameArray = lcl_NewUINameArray( RC_POOLCOLL_LISTS_BEGIN,
736 58 : RC_POOLCOLL_LISTS_BEGIN + (RES_POOLCOLL_LISTS_END - RES_POOLCOLL_LISTS_BEGIN) );
737 41717 : return *pListsUINameArray;
738 : }
739 :
740 50516 : const ::std::vector<OUString>& SwStyleNameMapper::GetExtraUINameArray()
741 : {
742 50516 : if (!pExtraUINameArray)
743 : pExtraUINameArray = lcl_NewUINameArray( RC_POOLCOLL_EXTRA_BEGIN,
744 58 : RC_POOLCOLL_EXTRA_BEGIN + (RES_POOLCOLL_EXTRA_END - RES_POOLCOLL_EXTRA_BEGIN) );
745 50516 : return *pExtraUINameArray;
746 : }
747 :
748 43452 : const ::std::vector<OUString>& SwStyleNameMapper::GetRegisterUINameArray()
749 : {
750 43452 : if (!pRegisterUINameArray)
751 : pRegisterUINameArray = lcl_NewUINameArray( RC_POOLCOLL_REGISTER_BEGIN,
752 58 : RC_POOLCOLL_REGISTER_BEGIN + (RES_POOLCOLL_REGISTER_END - RES_POOLCOLL_REGISTER_BEGIN) );
753 43452 : return *pRegisterUINameArray;
754 : }
755 :
756 37209 : const ::std::vector<OUString>& SwStyleNameMapper::GetDocUINameArray()
757 : {
758 37209 : if (!pDocUINameArray)
759 : pDocUINameArray = lcl_NewUINameArray( RC_POOLCOLL_DOC_BEGIN,
760 58 : RC_POOLCOLL_DOC_BEGIN + (RES_POOLCOLL_DOC_END - RES_POOLCOLL_DOC_BEGIN) );
761 37209 : return *pDocUINameArray;
762 : }
763 :
764 36521 : const ::std::vector<OUString>& SwStyleNameMapper::GetHTMLUINameArray()
765 : {
766 36521 : if (!pHTMLUINameArray)
767 : pHTMLUINameArray = lcl_NewUINameArray( RC_POOLCOLL_HTML_BEGIN,
768 58 : RC_POOLCOLL_HTML_BEGIN + (RES_POOLCOLL_HTML_END - RES_POOLCOLL_HTML_BEGIN) );
769 36521 : return *pHTMLUINameArray;
770 : }
771 :
772 6002 : const ::std::vector<OUString>& SwStyleNameMapper::GetFrameFormatUINameArray()
773 : {
774 6002 : if (!pFrameFormatUINameArray)
775 : pFrameFormatUINameArray = lcl_NewUINameArray( RC_POOLFRMFMT_BEGIN,
776 53 : RC_POOLFRMFMT_BEGIN + (RES_POOLFRM_END - RES_POOLFRM_BEGIN) );
777 6002 : return *pFrameFormatUINameArray;
778 : }
779 :
780 6056 : const ::std::vector<OUString>& SwStyleNameMapper::GetChrFormatUINameArray()
781 : {
782 6056 : if (!pChrFormatUINameArray)
783 : pChrFormatUINameArray = lcl_NewUINameArray( RC_POOLCHRFMT_BEGIN,
784 59 : RC_POOLCHRFMT_BEGIN + (RES_POOLCHR_NORMAL_END - RES_POOLCHR_NORMAL_BEGIN) );
785 6056 : return *pChrFormatUINameArray;
786 : }
787 :
788 1997 : const ::std::vector<OUString>& SwStyleNameMapper::GetHTMLChrFormatUINameArray()
789 : {
790 1997 : if (!pHTMLChrFormatUINameArray)
791 : pHTMLChrFormatUINameArray = lcl_NewUINameArray( RC_POOLCHRFMT_HTML_BEGIN,
792 40 : RC_POOLCHRFMT_HTML_BEGIN + (RES_POOLCHR_HTML_END - RES_POOLCHR_HTML_BEGIN) );
793 1997 : return *pHTMLChrFormatUINameArray;
794 : }
795 :
796 9863 : const ::std::vector<OUString>& SwStyleNameMapper::GetPageDescUINameArray()
797 : {
798 9863 : if (!pPageDescUINameArray)
799 : pPageDescUINameArray = lcl_NewUINameArray( RC_POOLPAGEDESC_BEGIN,
800 43 : RC_POOLPAGEDESC_BEGIN + (RES_POOLPAGE_END - RES_POOLPAGE_BEGIN) );
801 9863 : return *pPageDescUINameArray;
802 : }
803 :
804 946 : const ::std::vector<OUString>& SwStyleNameMapper::GetNumRuleUINameArray()
805 : {
806 946 : if (!pNumRuleUINameArray)
807 : pNumRuleUINameArray = lcl_NewUINameArray( RC_POOLNUMRULE_BEGIN,
808 41 : RC_POOLNUMRULE_BEGIN + (RES_POOLNUMRULE_END - RES_POOLNUMRULE_BEGIN) );
809 946 : return *pNumRuleUINameArray;
810 : }
811 :
812 26481 : const ::std::vector<OUString>& SwStyleNameMapper::GetTextProgNameArray()
813 : {
814 26481 : if (!pTextProgNameArray)
815 : pTextProgNameArray = lcl_NewProgNameArray(TextProgNameTable,
816 58 : sizeof ( TextProgNameTable ) / sizeof ( SwTableEntry ) );
817 26481 : return *pTextProgNameArray;
818 : }
819 :
820 6993 : const ::std::vector<OUString>& SwStyleNameMapper::GetListsProgNameArray()
821 : {
822 6993 : if (!pListsProgNameArray)
823 : pListsProgNameArray = lcl_NewProgNameArray( ListsProgNameTable,
824 57 : sizeof ( ListsProgNameTable ) / sizeof ( SwTableEntry ) );
825 6993 : return *pListsProgNameArray;
826 : }
827 :
828 12659 : const ::std::vector<OUString>& SwStyleNameMapper::GetExtraProgNameArray()
829 : {
830 12659 : if (!pExtraProgNameArray)
831 : pExtraProgNameArray = lcl_NewProgNameArray( ExtraProgNameTable,
832 57 : sizeof ( ExtraProgNameTable ) / sizeof ( SwTableEntry ) );
833 12659 : return *pExtraProgNameArray;
834 : }
835 :
836 7216 : const ::std::vector<OUString>& SwStyleNameMapper::GetRegisterProgNameArray()
837 : {
838 7216 : if (!pRegisterProgNameArray)
839 : pRegisterProgNameArray = lcl_NewProgNameArray( RegisterProgNameTable,
840 57 : sizeof ( RegisterProgNameTable ) / sizeof ( SwTableEntry ) );
841 7216 : return *pRegisterProgNameArray;
842 : }
843 :
844 390 : const ::std::vector<OUString>& SwStyleNameMapper::GetDocProgNameArray()
845 : {
846 390 : if (!pDocProgNameArray)
847 : pDocProgNameArray = lcl_NewProgNameArray( DocProgNameTable,
848 57 : sizeof ( DocProgNameTable ) / sizeof ( SwTableEntry ) );
849 390 : return *pDocProgNameArray;
850 : }
851 :
852 1927 : const ::std::vector<OUString>& SwStyleNameMapper::GetHTMLProgNameArray()
853 : {
854 1927 : if (!pHTMLProgNameArray)
855 : pHTMLProgNameArray = lcl_NewProgNameArray( HTMLProgNameTable,
856 57 : sizeof ( HTMLProgNameTable ) / sizeof ( SwTableEntry ) );
857 1927 : return *pHTMLProgNameArray;
858 : }
859 :
860 1481 : const ::std::vector<OUString>& SwStyleNameMapper::GetFrameFormatProgNameArray()
861 : {
862 1481 : if (!pFrameFormatProgNameArray)
863 : pFrameFormatProgNameArray = lcl_NewProgNameArray( FrameFormatProgNameTable,
864 36 : sizeof ( FrameFormatProgNameTable ) / sizeof ( SwTableEntry ) );
865 1481 : return *pFrameFormatProgNameArray;
866 : }
867 :
868 16115 : const ::std::vector<OUString>& SwStyleNameMapper::GetChrFormatProgNameArray()
869 : {
870 16115 : if (!pChrFormatProgNameArray)
871 : pChrFormatProgNameArray = lcl_NewProgNameArray( ChrFormatProgNameTable,
872 42 : sizeof ( ChrFormatProgNameTable ) / sizeof ( SwTableEntry ) );
873 16115 : return *pChrFormatProgNameArray;
874 : }
875 :
876 8078 : const ::std::vector<OUString>& SwStyleNameMapper::GetHTMLChrFormatProgNameArray()
877 : {
878 8078 : if (!pHTMLChrFormatProgNameArray)
879 : pHTMLChrFormatProgNameArray = lcl_NewProgNameArray( HTMLChrFormatProgNameTable,
880 42 : sizeof ( HTMLChrFormatProgNameTable ) / sizeof ( SwTableEntry ) );
881 8078 : return *pHTMLChrFormatProgNameArray;
882 : }
883 :
884 5438 : const ::std::vector<OUString>& SwStyleNameMapper::GetPageDescProgNameArray()
885 : {
886 5438 : if (!pPageDescProgNameArray)
887 : pPageDescProgNameArray = lcl_NewProgNameArray( PageDescProgNameTable,
888 43 : sizeof ( PageDescProgNameTable ) / sizeof ( SwTableEntry ) );
889 5438 : return *pPageDescProgNameArray;
890 : }
891 :
892 789 : const ::std::vector<OUString>& SwStyleNameMapper::GetNumRuleProgNameArray()
893 : {
894 789 : if (!pNumRuleProgNameArray)
895 : pNumRuleProgNameArray = lcl_NewProgNameArray( NumRuleProgNameTable,
896 39 : sizeof ( NumRuleProgNameTable ) / sizeof ( SwTableEntry ) );
897 789 : return *pNumRuleProgNameArray;
898 : }
899 :
900 : const OUString
901 296 : SwStyleNameMapper::GetSpecialExtraProgName(const OUString& rExtraUIName)
902 : {
903 296 : return lcl_GetSpecialExtraName( rExtraUIName, true );
904 : }
905 :
906 : const OUString
907 3066 : SwStyleNameMapper::GetSpecialExtraUIName(const OUString& rExtraProgName)
908 : {
909 3066 : return lcl_GetSpecialExtraName( rExtraProgName, false );
910 : }
911 :
912 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
