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::pFrmFmtUINameArray = 0,
41 : *SwStyleNameMapper::pChrFmtUINameArray = 0,
42 : *SwStyleNameMapper::pHTMLChrFmtUINameArray = 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::pFrmFmtProgNameArray = 0,
54 : *SwStyleNameMapper::pChrFmtProgNameArray = 0,
55 : *SwStyleNameMapper::pHTMLChrFmtProgNameArray = 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 FrmFmtProgNameTable [] =
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 ChrFmtProgNameTable [] =
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 HTMLChrFmtProgNameTable [] =
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 862 : lcl_NewUINameArray(sal_uInt16 nStt, sal_uInt16 const nEnd)
317 : {
318 862 : ::std::vector<OUString> *const pNameArray = new ::std::vector<OUString>;
319 862 : pNameArray->reserve(nEnd - nStt);
320 16066 : while( nStt < nEnd )
321 : {
322 14342 : const ResId aRId( nStt, *pSwResMgr );
323 14342 : pNameArray->push_back(OUString(aRId));
324 14342 : ++nStt;
325 : }
326 862 : return pNameArray;
327 : }
328 :
329 : static ::std::vector<OUString>*
330 826 : lcl_NewProgNameArray(const SwTableEntry *pTable, sal_uInt8 const nCount)
331 : {
332 826 : ::std::vector<OUString> *const pProgNameArray = new ::std::vector<OUString>;
333 826 : pProgNameArray->reserve(nCount);
334 15362 : while (pTable->nLength)
335 : {
336 : pProgNameArray->push_back(OUString(
337 13710 : pTable->pChar, pTable->nLength, RTL_TEXTENCODING_ASCII_US));
338 13710 : pTable++;
339 : }
340 826 : return pProgNameArray;
341 : }
342 :
343 : static OUString
344 3476 : lcl_GetSpecialExtraName(const OUString& rExtraName, const bool bIsUIName )
345 : {
346 : const ::std::vector<OUString>& rExtraArr = bIsUIName
347 : ? SwStyleNameMapper::GetExtraUINameArray()
348 3476 : : 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 9226 : for ( pIds = nIds; *pIds; ++pIds)
359 : {
360 9016 : if (rExtraName == rExtraArr[ *pIds ])
361 : {
362 : return bIsUIName
363 252 : ? SwStyleNameMapper::GetExtraProgNameArray()[*pIds]
364 3518 : : SwStyleNameMapper::GetExtraUINameArray()[*pIds];
365 : }
366 : }
367 210 : return rExtraName;
368 : }
369 :
370 376328 : static bool lcl_SuffixIsUser(const OUString & rString)
371 : {
372 376328 : const sal_Unicode *pChar = rString.getStr();
373 376328 : sal_Int32 nLen = rString.getLength();
374 376328 : bool bRet = false;
375 664280 : if( nLen > 8 &&
376 339620 : pChar[nLen-7] == ' ' &&
377 79898 : pChar[nLen-6] == '(' &&
378 55608 : pChar[nLen-5] == 'u' &&
379 54756 : pChar[nLen-4] == 's' &&
380 54756 : pChar[nLen-3] == 'e' &&
381 54756 : pChar[nLen-2] == 'r' &&
382 27378 : pChar[nLen-1] == ')' )
383 27378 : bRet = true;
384 376328 : return bRet;
385 : }
386 :
387 296872 : static void lcl_CheckSuffixAndDelete(OUString & rString)
388 : {
389 296872 : if (lcl_SuffixIsUser(rString))
390 : {
391 27378 : rString = rString.copy(0, rString.getLength() - 7);
392 : }
393 296872 : }
394 :
395 : typedef boost::tuple<sal_uInt16, sal_uInt16, const ::std::vector<OUString>& (*)() > NameArrayIndexTuple_t;
396 :
397 1661 : static sal_uInt16 lcl_AccumulateIndexCount( sal_uInt16 nSum, NameArrayIndexTuple_t const tuple ){
398 : // Return running sum + (index end) - (index start)
399 1661 : 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 1496776 : 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 1496776 : NameToIdHash **pHashPointer = 0;
428 : // Stores tuples representing (index start, index end, pointer to function which returns ref to name array)
429 1496776 : ::std::vector<NameArrayIndexTuple_t> vIndexes;
430 :
431 1496776 : switch ( eFlags )
432 : {
433 : case nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL:
434 : {
435 791646 : pHashPointer = bProgName ? &pParaProgMap : &pParaUIMap;
436 791646 : vIndexes.push_back( boost::make_tuple(RES_POOLCOLL_TEXT_BEGIN, RES_POOLCOLL_TEXT_END, bProgName ? &GetTextProgNameArray : &GetTextUINameArray) );
437 791646 : vIndexes.push_back( boost::make_tuple(RES_POOLCOLL_LISTS_BEGIN, RES_POOLCOLL_LISTS_END, bProgName ? &GetListsProgNameArray : &GetListsUINameArray) );
438 791646 : vIndexes.push_back( boost::make_tuple(RES_POOLCOLL_EXTRA_BEGIN, RES_POOLCOLL_EXTRA_END, bProgName ? &GetExtraProgNameArray : &GetExtraUINameArray) );
439 791646 : vIndexes.push_back( boost::make_tuple(RES_POOLCOLL_REGISTER_BEGIN, RES_POOLCOLL_REGISTER_END, bProgName ? &GetRegisterProgNameArray : &GetRegisterUINameArray) );
440 791646 : vIndexes.push_back( boost::make_tuple(RES_POOLCOLL_DOC_BEGIN, RES_POOLCOLL_DOC_END, bProgName ? &GetDocProgNameArray : &GetDocUINameArray) );
441 791646 : vIndexes.push_back( boost::make_tuple(RES_POOLCOLL_HTML_BEGIN, RES_POOLCOLL_HTML_END, bProgName ? &GetHTMLProgNameArray : &GetHTMLUINameArray) );
442 : }
443 791646 : break;
444 : case nsSwGetPoolIdFromName::GET_POOLID_CHRFMT:
445 : {
446 405088 : pHashPointer = bProgName ? &pCharProgMap : &pCharUIMap;
447 405088 : vIndexes.push_back( boost::make_tuple(RES_POOLCHR_NORMAL_BEGIN, RES_POOLCHR_NORMAL_END, bProgName ? &GetChrFmtProgNameArray : &GetChrFmtUINameArray) );
448 405088 : vIndexes.push_back( boost::make_tuple(RES_POOLCHR_HTML_BEGIN, RES_POOLCHR_HTML_END, bProgName ? &GetHTMLChrFmtProgNameArray : &GetHTMLChrFmtUINameArray) );
449 : }
450 405088 : break;
451 : case nsSwGetPoolIdFromName::GET_POOLID_FRMFMT:
452 : {
453 13152 : pHashPointer = bProgName ? &pFrameProgMap : &pFrameUIMap;
454 13152 : vIndexes.push_back( boost::make_tuple(RES_POOLFRM_BEGIN, RES_POOLFRM_END, bProgName ? &GetFrmFmtProgNameArray : &GetFrmFmtUINameArray) );
455 : }
456 13152 : break;
457 : case nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC:
458 : {
459 43298 : pHashPointer = bProgName ? &pPageProgMap : &pPageUIMap;
460 43298 : vIndexes.push_back( boost::make_tuple(RES_POOLPAGE_BEGIN, RES_POOLPAGE_END, bProgName ? &GetPageDescProgNameArray : &GetPageDescUINameArray) );
461 : }
462 43298 : break;
463 : case nsSwGetPoolIdFromName::GET_POOLID_NUMRULE:
464 : {
465 243592 : pHashPointer = bProgName ? &pNumRuleProgMap : &pNumRuleUIMap;
466 243592 : vIndexes.push_back( boost::make_tuple(RES_POOLNUMRULE_BEGIN, RES_POOLNUMRULE_END, bProgName ? &GetNumRuleProgNameArray : &GetNumRuleUINameArray) );
467 : }
468 243592 : break;
469 : default:
470 : {
471 : assert(false && "unknown pool family");
472 : }
473 0 : break;
474 : }
475 :
476 : // Proceed if we have a pointer to a hash, and the hash hasn't already been populated
477 : assert(pHashPointer && "null hash pointer");
478 1496776 : if (!*pHashPointer )
479 : {
480 : // Compute the size of the hash we need to build
481 679 : sal_uInt16 nSize = std::accumulate( vIndexes.begin(), vIndexes.end(), 0, lcl_AccumulateIndexCount );
482 :
483 679 : NameToIdHash *pHash = new NameToIdHash( nSize );
484 2340 : for ( ::std::vector<NameArrayIndexTuple_t>::iterator entry = vIndexes.begin(); entry != vIndexes.end(); ++entry )
485 : {
486 : // Get a pointer to the function which will populate pStrings
487 1661 : const ::std::vector<OUString>& (*pStringsFetchFunc)() = boost::get<2>( *entry );
488 1661 : if ( pStringsFetchFunc )
489 : {
490 1661 : const ::std::vector<OUString>& pStrings = pStringsFetchFunc();
491 : sal_uInt16 nIndex, nId;
492 29255 : for ( nIndex = 0, nId = boost::get<0>( *entry ) ; nId < boost::get<1>( *entry ) ; nId++, nIndex++ )
493 27594 : (*pHash)[pStrings[nIndex]] = nId;
494 : }
495 : }
496 :
497 679 : *pHashPointer = pHash;
498 : }
499 :
500 : #ifdef _NEED_TO_DEBUG_MAPPING
501 : static bool bTested = false;
502 : if ( !bTested )
503 : {
504 : bTested = true;
505 :
506 : testNameTable( nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, RES_POOLCOLL_TEXT_BEGIN, RES_POOLCOLL_TEXT_END );
507 : testNameTable( nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, RES_POOLCOLL_LISTS_BEGIN, RES_POOLCOLL_LISTS_END );
508 : testNameTable( nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, RES_POOLCOLL_EXTRA_BEGIN, RES_POOLCOLL_EXTRA_END );
509 : testNameTable( nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, RES_POOLCOLL_REGISTER_BEGIN, RES_POOLCOLL_REGISTER_END );
510 : testNameTable( nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, RES_POOLCOLL_DOC_BEGIN, RES_POOLCOLL_DOC_END );
511 : testNameTable( nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, RES_POOLCOLL_HTML_BEGIN, RES_POOLCOLL_HTML_END );
512 : testNameTable( nsSwGetPoolIdFromName::GET_POOLID_CHRFMT, RES_POOLCHR_NORMAL_BEGIN, RES_POOLCHR_NORMAL_END );
513 : testNameTable( nsSwGetPoolIdFromName::GET_POOLID_CHRFMT, RES_POOLCHR_HTML_BEGIN, RES_POOLCHR_HTML_END );
514 : testNameTable( nsSwGetPoolIdFromName::GET_POOLID_FRMFMT, RES_POOLFRM_BEGIN, RES_POOLFRM_END );
515 : testNameTable( nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC, RES_POOLPAGE_BEGIN, RES_POOLPAGE_END );
516 : testNameTable( nsSwGetPoolIdFromName::GET_POOLID_NUMRULE, RES_POOLNUMRULE_BEGIN, RES_POOLNUMRULE_END );
517 : }
518 : #endif
519 1496776 : return **pHashPointer;
520 : }
521 :
522 : // This gets the UI name from the programmatic name
523 642 : const OUString& SwStyleNameMapper::GetUIName(const OUString& rName,
524 : SwGetPoolIdFromName const eFlags)
525 : {
526 642 : sal_uInt16 nId = GetPoolIdFromProgName ( rName, eFlags );
527 642 : return nId != USHRT_MAX ? GetUIName( nId, rName ) : rName;
528 : }
529 :
530 : // Get the programmatic name from the UI name
531 688 : const OUString& SwStyleNameMapper::GetProgName(
532 : const OUString& rName, SwGetPoolIdFromName const eFlags)
533 : {
534 688 : sal_uInt16 nId = GetPoolIdFromUIName ( rName, eFlags );
535 688 : return nId != USHRT_MAX ? GetProgName( nId, rName ) : rName;
536 : }
537 :
538 : // Get the programmatic name from the UI name in rName and put it into rFillName
539 192394 : void SwStyleNameMapper::FillProgName(
540 : const OUString& rName, OUString& rFillName,
541 : SwGetPoolIdFromName const eFlags, bool const bDisambiguate)
542 : {
543 192394 : sal_uInt16 nId = GetPoolIdFromUIName ( rName, eFlags );
544 192394 : if ( bDisambiguate && nId == USHRT_MAX )
545 : {
546 : // rName isn't in our UI name table...check if it's in the programmatic one
547 79486 : nId = GetPoolIdFromProgName ( rName, eFlags );
548 :
549 79486 : rFillName = rName;
550 158972 : if (nId == USHRT_MAX )
551 : {
552 : // It isn't ...make sure the suffix isn't already " (user)"...if it is,
553 : // we need to add another one
554 79456 : if (lcl_SuffixIsUser(rFillName))
555 0 : rFillName += " (user)";
556 : }
557 : else
558 : {
559 : // It's in the programmatic name table...append suffix
560 30 : rFillName += " (user)";
561 : }
562 : }
563 : else
564 : {
565 : // If we aren't trying to disambiguate, then just do a normal fill
566 112908 : fillNameFromId(nId, rFillName, true);
567 : }
568 192394 : }
569 :
570 : // Get the UI name from the programmatic name in rName and put it into rFillName
571 478882 : void SwStyleNameMapper::FillUIName(
572 : const OUString& rName, OUString& rFillName,
573 : SwGetPoolIdFromName const eFlags, bool const bDisambiguate)
574 : {
575 478882 : sal_uInt16 nId = GetPoolIdFromProgName ( rName, eFlags );
576 478882 : if ( bDisambiguate && nId == USHRT_MAX )
577 : {
578 296872 : rFillName = rName;
579 : // rName isn't in our Prog name table...check if it has a " (user)" suffix, if so remove it
580 296872 : lcl_CheckSuffixAndDelete ( rFillName );
581 : }
582 : else
583 : {
584 : // If we aren't trying to disambiguate, then just do a normal fill
585 182010 : fillNameFromId(nId, rFillName, false);
586 : }
587 478882 : }
588 :
589 297054 : const OUString& SwStyleNameMapper::getNameFromId(
590 : sal_uInt16 const nId, const OUString& rFillName, bool const bProgName)
591 : {
592 297054 : sal_uInt16 nStt = 0;
593 297054 : const ::std::vector<OUString>* pStrArr = 0;
594 :
595 297054 : switch( (USER_FMT | COLL_GET_RANGE_BITS | POOLGRP_NOCOLLID) & nId )
596 : {
597 : case COLL_TEXT_BITS:
598 160680 : if( RES_POOLCOLL_TEXT_BEGIN <= nId && nId < RES_POOLCOLL_TEXT_END )
599 : {
600 160680 : pStrArr = bProgName ? &GetTextProgNameArray() : &GetTextUINameArray();
601 160680 : nStt = RES_POOLCOLL_TEXT_BEGIN;
602 : }
603 160680 : break;
604 : case COLL_LISTS_BITS:
605 12604 : if( RES_POOLCOLL_LISTS_BEGIN <= nId && nId < RES_POOLCOLL_LISTS_END )
606 : {
607 12604 : pStrArr = bProgName ? &GetListsProgNameArray() : &GetListsUINameArray();
608 12604 : nStt = RES_POOLCOLL_LISTS_BEGIN;
609 : }
610 12604 : break;
611 : case COLL_EXTRA_BITS:
612 28262 : if( RES_POOLCOLL_EXTRA_BEGIN <= nId && nId < RES_POOLCOLL_EXTRA_END )
613 : {
614 28262 : pStrArr = bProgName ? &GetExtraProgNameArray() : &GetExtraUINameArray();
615 28262 : nStt = RES_POOLCOLL_EXTRA_BEGIN;
616 : }
617 28262 : break;
618 : case COLL_REGISTER_BITS:
619 16178 : if( RES_POOLCOLL_REGISTER_BEGIN <= nId && nId < RES_POOLCOLL_REGISTER_END )
620 : {
621 16178 : pStrArr = bProgName ? &GetRegisterProgNameArray() : &GetRegisterUINameArray();
622 16178 : nStt = RES_POOLCOLL_REGISTER_BEGIN;
623 : }
624 16178 : break;
625 : case COLL_DOC_BITS:
626 3426 : if( RES_POOLCOLL_DOC_BEGIN <= nId && nId < RES_POOLCOLL_DOC_END )
627 : {
628 3426 : pStrArr = bProgName ? &GetDocProgNameArray() : &GetDocUINameArray();
629 3426 : nStt = RES_POOLCOLL_DOC_BEGIN;
630 : }
631 3426 : break;
632 : case COLL_HTML_BITS:
633 2364 : if( RES_POOLCOLL_HTML_BEGIN <= nId && nId < RES_POOLCOLL_HTML_END )
634 : {
635 2364 : pStrArr = bProgName ? &GetHTMLProgNameArray() : &GetHTMLUINameArray();
636 2364 : nStt = RES_POOLCOLL_HTML_BEGIN;
637 : }
638 2364 : break;
639 : case POOLGRP_CHARFMT:
640 45544 : if( RES_POOLCHR_NORMAL_BEGIN <= nId && nId < RES_POOLCHR_NORMAL_END )
641 : {
642 31338 : pStrArr = bProgName ? &GetChrFmtProgNameArray() : &GetChrFmtUINameArray();
643 31338 : nStt = RES_POOLCHR_NORMAL_BEGIN;
644 : }
645 14206 : else if( RES_POOLCHR_HTML_BEGIN <= nId && nId < RES_POOLCHR_HTML_END )
646 : {
647 14206 : pStrArr = bProgName ? &GetHTMLChrFmtProgNameArray() : &GetHTMLChrFmtUINameArray();
648 14206 : nStt = RES_POOLCHR_HTML_BEGIN;
649 : }
650 45544 : break;
651 : case POOLGRP_FRAMEFMT:
652 5816 : if( RES_POOLFRM_BEGIN <= nId && nId < RES_POOLFRM_END )
653 : {
654 5816 : pStrArr = bProgName ? &GetFrmFmtProgNameArray() : &GetFrmFmtUINameArray();
655 5816 : nStt = RES_POOLFRM_BEGIN;
656 : }
657 5816 : break;
658 : case POOLGRP_PAGEDESC:
659 20918 : if( RES_POOLPAGE_BEGIN <= nId && nId < RES_POOLPAGE_END )
660 : {
661 20918 : pStrArr = bProgName ? &GetPageDescProgNameArray() : &GetPageDescUINameArray();
662 20918 : nStt = RES_POOLPAGE_BEGIN;
663 : }
664 20918 : break;
665 : case POOLGRP_NUMRULE:
666 1262 : if( RES_POOLNUMRULE_BEGIN <= nId && nId < RES_POOLNUMRULE_END )
667 : {
668 1262 : pStrArr = bProgName ? &GetNumRuleProgNameArray() : &GetNumRuleUINameArray();
669 1262 : nStt = RES_POOLNUMRULE_BEGIN;
670 : }
671 1262 : break;
672 : }
673 297054 : return pStrArr ? pStrArr->operator[](nId - nStt) : rFillName;
674 : }
675 :
676 296742 : void SwStyleNameMapper::fillNameFromId(
677 : sal_uInt16 const nId, OUString& rFillName, bool bProgName)
678 : {
679 296742 : rFillName = getNameFromId(nId, rFillName, bProgName);
680 296742 : }
681 :
682 : // Get the UI name from the pool ID
683 1824 : void SwStyleNameMapper::FillUIName(sal_uInt16 const nId, OUString& rFillName)
684 : {
685 1824 : fillNameFromId(nId, rFillName, false);
686 1824 : }
687 :
688 : // Get the UI name from the pool ID
689 166 : const OUString& SwStyleNameMapper::GetUIName(
690 : sal_uInt16 const nId, const OUString& rName)
691 : {
692 166 : return getNameFromId(nId, rName, false);
693 : }
694 :
695 : // Get the programmatic name from the pool ID
696 0 : void SwStyleNameMapper::FillProgName(sal_uInt16 nId, OUString& rFillName)
697 : {
698 0 : fillNameFromId(nId, rFillName, true);
699 0 : }
700 :
701 : // Get the programmatic name from the pool ID
702 : const OUString&
703 146 : SwStyleNameMapper::GetProgName(sal_uInt16 const nId, const OUString& rName)
704 : {
705 146 : return getNameFromId(nId, rName, true);
706 : }
707 :
708 : // This gets the PoolId from the UI Name
709 937766 : sal_uInt16 SwStyleNameMapper::GetPoolIdFromUIName(
710 : const OUString& rName, SwGetPoolIdFromName const eFlags)
711 : {
712 937766 : const NameToIdHash & rHashMap = getHashTable ( eFlags, false );
713 937766 : NameToIdHash::const_iterator aIter = rHashMap.find(rName);
714 937766 : return aIter != rHashMap.end() ? (*aIter).second : USHRT_MAX;
715 : }
716 :
717 : // Get the Pool ID from the programmatic name
718 559010 : sal_uInt16 SwStyleNameMapper::GetPoolIdFromProgName(
719 : const OUString& rName, SwGetPoolIdFromName const eFlags)
720 : {
721 559010 : const NameToIdHash & rHashMap = getHashTable ( eFlags, true );
722 559010 : NameToIdHash::const_iterator aIter = rHashMap.find(rName);
723 559010 : return aIter != rHashMap.end() ? (*aIter).second : USHRT_MAX;
724 : }
725 :
726 286120 : const ::std::vector<OUString>& SwStyleNameMapper::GetTextUINameArray()
727 : {
728 286120 : if (!pTextUINameArray)
729 : pTextUINameArray = lcl_NewUINameArray( RC_POOLCOLL_TEXT_BEGIN,
730 86 : RC_POOLCOLL_TEXT_BEGIN + (RES_POOLCOLL_TEXT_END - RES_POOLCOLL_TEXT_BEGIN) );
731 286120 : return *pTextUINameArray;
732 : }
733 :
734 8650 : const ::std::vector<OUString>& SwStyleNameMapper::GetListsUINameArray()
735 : {
736 8650 : if (!pListsUINameArray)
737 : pListsUINameArray = lcl_NewUINameArray( RC_POOLCOLL_LISTS_BEGIN,
738 86 : RC_POOLCOLL_LISTS_BEGIN + (RES_POOLCOLL_LISTS_END - RES_POOLCOLL_LISTS_BEGIN) );
739 8650 : return *pListsUINameArray;
740 : }
741 :
742 21474 : const ::std::vector<OUString>& SwStyleNameMapper::GetExtraUINameArray()
743 : {
744 21474 : if (!pExtraUINameArray)
745 : pExtraUINameArray = lcl_NewUINameArray( RC_POOLCOLL_EXTRA_BEGIN,
746 86 : RC_POOLCOLL_EXTRA_BEGIN + (RES_POOLCOLL_EXTRA_END - RES_POOLCOLL_EXTRA_BEGIN) );
747 21474 : return *pExtraUINameArray;
748 : }
749 :
750 11590 : const ::std::vector<OUString>& SwStyleNameMapper::GetRegisterUINameArray()
751 : {
752 11590 : if (!pRegisterUINameArray)
753 : pRegisterUINameArray = lcl_NewUINameArray( RC_POOLCOLL_REGISTER_BEGIN,
754 86 : RC_POOLCOLL_REGISTER_BEGIN + (RES_POOLCOLL_REGISTER_END - RES_POOLCOLL_REGISTER_BEGIN) );
755 11590 : return *pRegisterUINameArray;
756 : }
757 :
758 4994 : const ::std::vector<OUString>& SwStyleNameMapper::GetDocUINameArray()
759 : {
760 4994 : if (!pDocUINameArray)
761 : pDocUINameArray = lcl_NewUINameArray( RC_POOLCOLL_DOC_BEGIN,
762 86 : RC_POOLCOLL_DOC_BEGIN + (RES_POOLCOLL_DOC_END - RES_POOLCOLL_DOC_BEGIN) );
763 4994 : return *pDocUINameArray;
764 : }
765 :
766 3102 : const ::std::vector<OUString>& SwStyleNameMapper::GetHTMLUINameArray()
767 : {
768 3102 : if (!pHTMLUINameArray)
769 : pHTMLUINameArray = lcl_NewUINameArray( RC_POOLCOLL_HTML_BEGIN,
770 86 : RC_POOLCOLL_HTML_BEGIN + (RES_POOLCOLL_HTML_END - RES_POOLCOLL_HTML_BEGIN) );
771 3102 : return *pHTMLUINameArray;
772 : }
773 :
774 4748 : const ::std::vector<OUString>& SwStyleNameMapper::GetFrmFmtUINameArray()
775 : {
776 4748 : if (!pFrmFmtUINameArray)
777 : pFrmFmtUINameArray = lcl_NewUINameArray( RC_POOLFRMFMT_BEGIN,
778 58 : RC_POOLFRMFMT_BEGIN + (RES_POOLFRM_END - RES_POOLFRM_BEGIN) );
779 4748 : return *pFrmFmtUINameArray;
780 : }
781 :
782 7294 : const ::std::vector<OUString>& SwStyleNameMapper::GetChrFmtUINameArray()
783 : {
784 7294 : if (!pChrFmtUINameArray)
785 : pChrFmtUINameArray = lcl_NewUINameArray( RC_POOLCHRFMT_BEGIN,
786 90 : RC_POOLCHRFMT_BEGIN + (RES_POOLCHR_NORMAL_END - RES_POOLCHR_NORMAL_BEGIN) );
787 7294 : return *pChrFmtUINameArray;
788 : }
789 :
790 2720 : const ::std::vector<OUString>& SwStyleNameMapper::GetHTMLChrFmtUINameArray()
791 : {
792 2720 : if (!pHTMLChrFmtUINameArray)
793 : pHTMLChrFmtUINameArray = lcl_NewUINameArray( RC_POOLCHRFMT_HTML_BEGIN,
794 66 : RC_POOLCHRFMT_HTML_BEGIN + (RES_POOLCHR_HTML_END - RES_POOLCHR_HTML_BEGIN) );
795 2720 : return *pHTMLChrFmtUINameArray;
796 : }
797 :
798 14359 : const ::std::vector<OUString>& SwStyleNameMapper::GetPageDescUINameArray()
799 : {
800 14359 : if (!pPageDescUINameArray)
801 : pPageDescUINameArray = lcl_NewUINameArray( RC_POOLPAGEDESC_BEGIN,
802 68 : RC_POOLPAGEDESC_BEGIN + (RES_POOLPAGE_END - RES_POOLPAGE_BEGIN) );
803 14359 : return *pPageDescUINameArray;
804 : }
805 :
806 726 : const ::std::vector<OUString>& SwStyleNameMapper::GetNumRuleUINameArray()
807 : {
808 726 : if (!pNumRuleUINameArray)
809 : pNumRuleUINameArray = lcl_NewUINameArray( RC_POOLNUMRULE_BEGIN,
810 64 : RC_POOLNUMRULE_BEGIN + (RES_POOLNUMRULE_END - RES_POOLNUMRULE_BEGIN) );
811 726 : return *pNumRuleUINameArray;
812 : }
813 :
814 39932 : const ::std::vector<OUString>& SwStyleNameMapper::GetTextProgNameArray()
815 : {
816 39932 : if (!pTextProgNameArray)
817 : pTextProgNameArray = lcl_NewProgNameArray(TextProgNameTable,
818 86 : sizeof ( TextProgNameTable ) / sizeof ( SwTableEntry ) );
819 39932 : return *pTextProgNameArray;
820 : }
821 :
822 5896 : const ::std::vector<OUString>& SwStyleNameMapper::GetListsProgNameArray()
823 : {
824 5896 : if (!pListsProgNameArray)
825 : pListsProgNameArray = lcl_NewProgNameArray( ListsProgNameTable,
826 84 : sizeof ( ListsProgNameTable ) / sizeof ( SwTableEntry ) );
827 5896 : return *pListsProgNameArray;
828 : }
829 :
830 15572 : const ::std::vector<OUString>& SwStyleNameMapper::GetExtraProgNameArray()
831 : {
832 15572 : if (!pExtraProgNameArray)
833 : pExtraProgNameArray = lcl_NewProgNameArray( ExtraProgNameTable,
834 84 : sizeof ( ExtraProgNameTable ) / sizeof ( SwTableEntry ) );
835 15572 : return *pExtraProgNameArray;
836 : }
837 :
838 6530 : const ::std::vector<OUString>& SwStyleNameMapper::GetRegisterProgNameArray()
839 : {
840 6530 : if (!pRegisterProgNameArray)
841 : pRegisterProgNameArray = lcl_NewProgNameArray( RegisterProgNameTable,
842 84 : sizeof ( RegisterProgNameTable ) / sizeof ( SwTableEntry ) );
843 6530 : return *pRegisterProgNameArray;
844 : }
845 :
846 374 : const ::std::vector<OUString>& SwStyleNameMapper::GetDocProgNameArray()
847 : {
848 374 : if (!pDocProgNameArray)
849 : pDocProgNameArray = lcl_NewProgNameArray( DocProgNameTable,
850 84 : sizeof ( DocProgNameTable ) / sizeof ( SwTableEntry ) );
851 374 : return *pDocProgNameArray;
852 : }
853 :
854 1260 : const ::std::vector<OUString>& SwStyleNameMapper::GetHTMLProgNameArray()
855 : {
856 1260 : if (!pHTMLProgNameArray)
857 : pHTMLProgNameArray = lcl_NewProgNameArray( HTMLProgNameTable,
858 84 : sizeof ( HTMLProgNameTable ) / sizeof ( SwTableEntry ) );
859 1260 : return *pHTMLProgNameArray;
860 : }
861 :
862 1262 : const ::std::vector<OUString>& SwStyleNameMapper::GetFrmFmtProgNameArray()
863 : {
864 1262 : if (!pFrmFmtProgNameArray)
865 : pFrmFmtProgNameArray = lcl_NewProgNameArray( FrmFmtProgNameTable,
866 58 : sizeof ( FrmFmtProgNameTable ) / sizeof ( SwTableEntry ) );
867 1262 : return *pFrmFmtProgNameArray;
868 : }
869 :
870 25560 : const ::std::vector<OUString>& SwStyleNameMapper::GetChrFmtProgNameArray()
871 : {
872 25560 : if (!pChrFmtProgNameArray)
873 : pChrFmtProgNameArray = lcl_NewProgNameArray( ChrFmtProgNameTable,
874 66 : sizeof ( ChrFmtProgNameTable ) / sizeof ( SwTableEntry ) );
875 25560 : return *pChrFmtProgNameArray;
876 : }
877 :
878 13002 : const ::std::vector<OUString>& SwStyleNameMapper::GetHTMLChrFmtProgNameArray()
879 : {
880 13002 : if (!pHTMLChrFmtProgNameArray)
881 : pHTMLChrFmtProgNameArray = lcl_NewProgNameArray( HTMLChrFmtProgNameTable,
882 66 : sizeof ( HTMLChrFmtProgNameTable ) / sizeof ( SwTableEntry ) );
883 13002 : return *pHTMLChrFmtProgNameArray;
884 : }
885 :
886 7302 : const ::std::vector<OUString>& SwStyleNameMapper::GetPageDescProgNameArray()
887 : {
888 7302 : if (!pPageDescProgNameArray)
889 : pPageDescProgNameArray = lcl_NewProgNameArray( PageDescProgNameTable,
890 68 : sizeof ( PageDescProgNameTable ) / sizeof ( SwTableEntry ) );
891 7302 : return *pPageDescProgNameArray;
892 : }
893 :
894 662 : const ::std::vector<OUString>& SwStyleNameMapper::GetNumRuleProgNameArray()
895 : {
896 662 : if (!pNumRuleProgNameArray)
897 : pNumRuleProgNameArray = lcl_NewProgNameArray( NumRuleProgNameTable,
898 62 : sizeof ( NumRuleProgNameTable ) / sizeof ( SwTableEntry ) );
899 662 : return *pNumRuleProgNameArray;
900 : }
901 :
902 : const OUString
903 254 : SwStyleNameMapper::GetSpecialExtraProgName(const OUString& rExtraUIName)
904 : {
905 254 : return lcl_GetSpecialExtraName( rExtraUIName, true );
906 : }
907 :
908 : const OUString
909 3222 : SwStyleNameMapper::GetSpecialExtraUIName(const OUString& rExtraProgName)
910 : {
911 3222 : return lcl_GetSpecialExtraName( rExtraProgName, false );
912 : }
913 :
914 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
