Branch data Line data Source code
1 : : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : : /*************************************************************************
3 : : *
4 : : * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 : : *
6 : : * Copyright 2000, 2010 Oracle and/or its affiliates.
7 : : *
8 : : * OpenOffice.org - a multi-platform office productivity suite
9 : : *
10 : : * This file is part of OpenOffice.org.
11 : : *
12 : : * OpenOffice.org is free software: you can redistribute it and/or modify
13 : : * it under the terms of the GNU Lesser General Public License version 3
14 : : * only, as published by the Free Software Foundation.
15 : : *
16 : : * OpenOffice.org is distributed in the hope that it will be useful,
17 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 : : * GNU Lesser General Public License version 3 for more details
20 : : * (a copy is included in the LICENSE file that accompanied this code).
21 : : *
22 : : * You should have received a copy of the GNU Lesser General Public License
23 : : * version 3 along with OpenOffice.org. If not, see
24 : : * <http://www.openoffice.org/license.html>
25 : : * for a copy of the LGPLv3 License.
26 : : *
27 : : ************************************************************************/
28 : :
29 : : #include <hintids.hxx>
30 : : #include <tools/stream.hxx>
31 : : #include <svtools/rtftoken.h>
32 : : #include <svtools/rtfkeywd.hxx>
33 : : #include <svl/intitem.hxx>
34 : : #include <svtools/rtfout.hxx>
35 : : #include <editeng/lrspitem.hxx>
36 : : #include <editeng/fontitem.hxx>
37 : : #include <editeng/fhgtitem.hxx>
38 : : #include <editeng/wghtitem.hxx>
39 : : #include <editeng/postitem.hxx>
40 : : #include <editeng/cmapitem.hxx>
41 : : #include <editeng/crsditem.hxx>
42 : : #include <editeng/colritem.hxx>
43 : : #include <editeng/udlnitem.hxx>
44 : : #include <editeng/wrlmitem.hxx>
45 : : #include <editeng/numitem.hxx>
46 : : #include <shellio.hxx>
47 : : #include <fltini.hxx>
48 : : #include <swtypes.hxx>
49 : : #include <swparrtf.hxx>
50 : : #include <ndtxt.hxx>
51 : : #include <doc.hxx>
52 : : #include <docary.hxx>
53 : : #include <pam.hxx>
54 : : #include <charfmt.hxx>
55 : : #include <charatr.hxx>
56 : : #include <paratr.hxx>
57 : : #include <cmdid.h>
58 : : #include <numrule.hxx>
59 : :
60 : : #define RTF_NUMRULE_NAME "RTF_Num"
61 : :
62 : 0 : void lcl_ExpandNumFmts( SwNumRule& rRule )
63 : : {
64 : : // dann noch das NumFormat in alle Ebenen setzen
65 [ # # ]: 0 : for( sal_uInt8 n = 1; n < MAXLEVEL; ++n )
66 [ # # ]: 0 : if( !rRule.GetNumFmt( n ) )
67 : : {
68 [ # # ][ # # ]: 0 : SwNumFmt aNumFmt( rRule.Get( 0 ));
69 [ # # ][ # # ]: 0 : aNumFmt.SetIndentAt( aNumFmt.GetIndentAt() * ( n + 1 ) );
70 [ # # ][ # # ]: 0 : rRule.Set( n, aNumFmt );
71 : : }
72 : 0 : }
73 : :
74 : 0 : SfxItemSet& GetNumChrFmt( SwDoc& rDoc, SwNumRule& rRule, sal_uInt8 nNumLvl )
75 : : {
76 : 0 : SwCharFmt* pChrFmt = rRule.Get( nNumLvl ).GetCharFmt();
77 [ # # ]: 0 : if( !pChrFmt )
78 : : {
79 [ # # ]: 0 : String sNm( rRule.GetName() );
80 [ # # ][ # # ]: 0 : ( sNm += ' ' ) += String::CreateFromInt32( nNumLvl + 1 );
[ # # ][ # # ]
81 [ # # ]: 0 : pChrFmt = rDoc.MakeCharFmt( sNm, rDoc.GetDfltCharFmt() );
82 [ # # ][ # # ]: 0 : if( !rRule.GetNumFmt( nNumLvl ))
83 [ # # ][ # # ]: 0 : rRule.Set( nNumLvl, rRule.Get( nNumLvl ) );
84 [ # # ][ # # ]: 0 : ((SwNumFmt*)rRule.GetNumFmt( nNumLvl ))->SetCharFmt( pChrFmt );
[ # # ]
85 : : }
86 : 0 : return (SfxItemSet&)pChrFmt->GetAttrSet();
87 : : }
88 : :
89 : 0 : void SwRTFParser::ReadListLevel( SwNumRule& rRule, sal_uInt8 nNumLvl )
90 : : {
91 : : int nToken;
92 : 0 : int nNumOpenBrakets = 1; // die erste wurde schon vorher erkannt !!
93 : 0 : int nLvlTxtLevel = 0, nLvlNumberLevel = 0;
94 [ # # ][ # # ]: 0 : String sLvlText, sLvlNumber;
95 : : SwNumFmt* pCurNumFmt;
96 : 0 : SvxNumberFormat::LabelFollowedBy eFollowedBy = SvxNumberFormat::NOTHING;
97 : :
98 [ # # ]: 0 : if( MAXLEVEL >= nNumLvl )
99 : : {
100 [ # # ]: 0 : pCurNumFmt = (SwNumFmt*)rRule.GetNumFmt( nNumLvl );
101 [ # # ]: 0 : pCurNumFmt->SetIndentAt( 0 );
102 [ # # ]: 0 : pCurNumFmt->SetFirstLineIndent( 0 );
103 : : }
104 : : else
105 : 0 : pCurNumFmt = 0;
106 : :
107 [ # # ][ # # ]: 0 : while( nNumOpenBrakets && IsParserWorking() )
[ # # ]
108 : : {
109 [ # # ][ # # : 0 : switch( ( nToken = GetNextToken() ))
# # # # #
# # # # ]
110 : : {
111 : : case '}':
112 [ # # ]: 0 : if( nNumOpenBrakets )
113 : : {
114 [ # # ]: 0 : if( nLvlTxtLevel == nNumOpenBrakets )
115 : : {
116 [ # # ][ # # : 0 : if( DelCharAtEnd( sLvlText, ';' ).Len() &&
# # # # ]
[ # # ]
117 : 0 : sLvlText.Len() && sLvlText.Len() ==
118 : 0 : (sal_uInt16)(sLvlText.GetChar( 0 )) + 1 )
119 [ # # ]: 0 : sLvlText.Erase( 0, 1 );
120 : 0 : nLvlTxtLevel = 0;
121 : : }
122 [ # # ]: 0 : if( nLvlNumberLevel == nNumOpenBrakets )
123 : : {
124 [ # # ]: 0 : DelCharAtEnd( sLvlNumber, ';' );
125 : 0 : nLvlNumberLevel = 0;
126 : : }
127 : : }
128 : 0 : --nNumOpenBrakets;
129 : 0 : break;
130 : :
131 : : case '{':
132 : : {
133 [ # # ][ # # ]: 0 : if( RTF_IGNOREFLAG != GetNextToken() )
134 [ # # ]: 0 : nToken = SkipToken( -1 );
135 : : // Unknown und alle bekannten nicht ausgewerteten Gruppen
136 : : // sofort ueberspringen
137 [ # # ][ # # ]: 0 : else if( RTF_UNKNOWNCONTROL != ( nToken = GetNextToken() ))
138 [ # # ]: 0 : nToken = SkipToken( -2 );
139 : : else
140 : : {
141 : : // gleich herausfiltern
142 [ # # ]: 0 : ReadUnknownData();
143 [ # # ]: 0 : nToken = GetNextToken();
144 [ # # ]: 0 : if( '}' != nToken )
145 : 0 : eState = SVPAR_ERROR;
146 : 0 : break;
147 : : }
148 : 0 : ++nNumOpenBrakets;
149 : : }
150 : 0 : break;
151 : :
152 : : case RTF_LEVELNFC:
153 : : {
154 : 0 : sal_Int16 eType = SVX_NUM_ARABIC;
155 [ # # # # : 0 : switch( nTokenValue )
# # ]
156 : : {
157 : 0 : case 1: eType = SVX_NUM_ROMAN_UPPER; break;
158 : 0 : case 2: eType = SVX_NUM_ROMAN_LOWER; break;
159 : 0 : case 3: eType = SVX_NUM_CHARS_UPPER_LETTER_N; break;
160 : 0 : case 4: eType = SVX_NUM_CHARS_LOWER_LETTER_N; break;
161 : : case 255:
162 : 0 : case 23: eType = SVX_NUM_CHAR_SPECIAL; break;
163 : : }
164 [ # # ]: 0 : if( pCurNumFmt )
165 : 0 : pCurNumFmt->SetNumberingType(eType);
166 : : }
167 : 0 : break;
168 : :
169 : : case RTF_LEVELJC:
170 : : {
171 : 0 : SvxAdjust eAdj = SVX_ADJUST_LEFT;
172 [ # # # ]: 0 : switch( nTokenValue )
173 : : {
174 : 0 : case 1: eAdj = SVX_ADJUST_CENTER; break;
175 : 0 : case 2: eAdj = SVX_ADJUST_RIGHT; break;
176 : : }
177 [ # # ]: 0 : if( pCurNumFmt )
178 : 0 : pCurNumFmt->SetNumAdjust( eAdj );
179 : : }
180 : 0 : break;
181 : :
182 : : case RTF_LEVELSTARTAT:
183 [ # # ][ # # ]: 0 : if( pCurNumFmt && -1 != nTokenValue )
184 : 0 : pCurNumFmt->SetStart( sal_uInt16( nTokenValue ));
185 : 0 : break;
186 : :
187 : : case RTF_LEVELTEXT:
188 : 0 : nLvlTxtLevel = nNumOpenBrakets;
189 : 0 : break;
190 : :
191 : : case RTF_LEVELNUMBERS:
192 : 0 : nLvlNumberLevel = nNumOpenBrakets;
193 : 0 : break;
194 : :
195 : :
196 : : case RTF_TEXTTOKEN:
197 [ # # ]: 0 : if( nLvlTxtLevel == nNumOpenBrakets )
198 [ # # ]: 0 : sLvlText += aToken;
199 [ # # ]: 0 : else if( nLvlNumberLevel == nNumOpenBrakets )
200 [ # # ]: 0 : sLvlNumber += aToken;
201 : 0 : break;
202 : :
203 : : case RTF_LEVELFOLLOW:
204 : : /* removed; waiting for swnum02 to be integrated! */
205 [ # # # ]: 0 : switch (nTokenValue)
206 : : {
207 : : case 0:
208 : 0 : eFollowedBy = SvxNumberFormat::LISTTAB;
209 : 0 : break;
210 : : case 1:
211 : 0 : eFollowedBy = SvxNumberFormat::SPACE;
212 : 0 : break;
213 : : }
214 : 0 : break;
215 : :
216 : : case RTF_LEVELOLD:
217 : : case RTF_LEVELPREV:
218 : : case RTF_LEVELPREVSPACE:
219 : : case RTF_LEVELINDENT:
220 : : case RTF_LEVELSPACE:
221 : : case RTF_LEVELLEGAL:
222 : : case RTF_LEVELNORESTART:
223 : 0 : break;
224 : :
225 : : default:
226 [ # # ][ # # ]: 0 : if( pCurNumFmt && (
[ # # ]
227 : : RTF_CHRFMT == (nToken & ~(0xff | RTF_SWGDEFS) ) ||
228 : : RTF_PARFMT == (nToken & ~(0xff | RTF_SWGDEFS) ) ))
229 : : {
230 [ # # ]: 0 : SfxItemSet aSet( pDoc->GetAttrPool(), aTxtNodeSetRange );
231 : : // put the current CharFmtAttr into the set
232 [ # # ]: 0 : SfxItemSet& rCFmtSet = GetNumChrFmt( *pDoc, rRule, nNumLvl );
233 [ # # ]: 0 : aSet.Put( rCFmtSet );
234 : : // and put the current "LRSpace" into the set
235 : : {
236 [ # # ]: 0 : SvxLRSpaceItem aLR( RES_LR_SPACE );
237 [ # # ][ # # ]: 0 : aLR.SetTxtLeft( pCurNumFmt->GetIndentAt() );
238 [ # # ][ # # ]: 0 : aLR.SetTxtFirstLineOfst(pCurNumFmt->GetFirstLineIndent());
239 [ # # ][ # # ]: 0 : aSet.Put( aLR );
240 : : }
241 : :
242 [ # # ]: 0 : ReadAttr( nToken, &aSet );
243 : :
244 : : //#i24880# Word appears to ignore char background for numbering
245 [ # # ]: 0 : aSet.ClearItem(RES_CHRATR_BACKGROUND);
246 : :
247 : : // put all CharFmt Items into the charfmt
248 [ # # ]: 0 : rCFmtSet.Put( aSet );
249 : :
250 : : // test for LRSpace Item. If exist then set all relevant
251 : : // values on the numrule format
252 : : const SfxPoolItem* pItem;
253 [ # # ]: 0 : if( SFX_ITEM_SET == aSet.GetItemState( RES_LR_SPACE,
254 [ # # ]: 0 : sal_False, &pItem ))
255 : : {
256 : 0 : const SvxLRSpaceItem& rLR = *(SvxLRSpaceItem*)pItem;
257 [ # # ]: 0 : pCurNumFmt->SetListtabPos( rLR.GetTxtLeft( ) );
258 [ # # ]: 0 : pCurNumFmt->SetIndentAt( rLR.GetTxtLeft() );
259 [ # # ]: 0 : pCurNumFmt->SetFirstLineIndent( rLR.GetTxtFirstLineOfst());
260 : : }
261 : :
262 : : // dann aus der Vorlage den Font holen
263 [ # # ]: 0 : if( SVX_NUM_CHAR_SPECIAL == pCurNumFmt->GetNumberingType() )
264 : : pCurNumFmt->SetBulletFont( FindFontOfItem(
265 [ # # ][ # # ]: 0 : pCurNumFmt->GetCharFmt()->GetFont() ) );
[ # # ][ # # ]
266 : : }
267 : 0 : break;
268 : : }
269 : : }
270 : :
271 [ # # ][ # # ]: 0 : if( IsParserWorking() && pCurNumFmt )
[ # # ]
272 : : {
273 : : // dann erzeuge mal die Pre/Postfix-Strings
274 [ # # # # ]: 0 : if( sLvlText.Len() &&
[ # # ]
275 : 0 : SVX_NUM_CHAR_SPECIAL == pCurNumFmt->GetNumberingType() )
276 : : {
277 : 0 : pCurNumFmt->SetBulletChar( sLvlText.GetChar( 0 ) );
278 : : // dann aus der Vorlage den Font holen
279 [ # # ]: 0 : if( pCurNumFmt->GetCharFmt() )
280 : : pCurNumFmt->SetBulletFont( FindFontOfItem(
281 [ # # ][ # # ]: 0 : pCurNumFmt->GetCharFmt()->GetFont() ) );
[ # # ]
282 : : }
283 [ # # ][ # # ]: 0 : else if( sLvlNumber.Len() && sLvlText.Len() )
[ # # ]
284 : : {
285 : : // in sLvlText steht der Text, in sLvlNumber die Position
286 : : // der Ebenen in sLvlText
287 : : pCurNumFmt->SetPrefix(
288 [ # # ][ # # ]: 0 : sLvlText.Copy( 0, sal_uInt16( sLvlNumber.GetChar( 0 ))-1 ));
[ # # ]
289 : : pCurNumFmt->SetSuffix( sLvlText.Copy(
290 [ # # ][ # # ]: 0 : sal_uInt16( sLvlNumber.GetChar( sLvlNumber.Len()-1 )) ));
[ # # ]
291 : : // wieviele Levels stehen im String?
292 : 0 : pCurNumFmt->SetIncludeUpperLevels( (sal_uInt8)sLvlNumber.Len() );
293 : : }
294 : : else
295 : : {
296 : 0 : pCurNumFmt->SetNumberingType(SVX_NUM_NUMBER_NONE);
297 [ # # ]: 0 : pCurNumFmt->SetSuffix( sLvlText );
298 : : }
299 : :
300 : : /* removed; waiting for swnum02 to be integrated!*/
301 [ # # ]: 0 : pCurNumFmt->SetLabelFollowedBy( eFollowedBy );
302 [ # # ][ # # ]: 0 : if (eFollowedBy == SvxNumberFormat::LISTTAB && !pCurNumFmt->IsItemize())
[ # # ][ # # ]
303 : : {
304 [ # # ]: 0 : pCurNumFmt->SetIndentAt(0);
305 [ # # ]: 0 : pCurNumFmt->SetFirstLineIndent(0);
306 : : }
307 : : }
308 : :
309 [ # # ][ # # ]: 0 : SkipToken( -1 );
[ # # ]
310 : 0 : }
311 : :
312 : 0 : void SwRTFParser::ReadListTable()
313 : : {
314 : : int nToken;
315 : 0 : int nNumOpenBrakets = 1; // die erste wurde schon vorher erkannt !!
316 : 0 : bNewNumList = sal_True;
317 : :
318 : 0 : sal_uInt8 nNumLvl = 0;
319 : 0 : SwNumRule* pCurRule = 0;
320 : 0 : SwListEntry aEntry;
321 : :
322 [ # # ][ # # ]: 0 : while( nNumOpenBrakets && IsParserWorking() )
[ # # ]
323 : : {
324 [ # # ][ # # : 0 : switch( ( nToken = GetNextToken() ))
# # # # #
# # # ]
325 : : {
326 [ # # ][ # # ]: 0 : case '}': if( --nNumOpenBrakets && IsParserWorking() )
[ # # ]
327 : : {
328 : : // Style konnte vollstaendig gelesen werden,
329 : : // also ist das noch ein stabiler Status
330 [ # # ]: 0 : SaveState( RTF_LISTTABLE );
331 [ # # ]: 0 : if( 1 == nNumOpenBrakets )
332 : : {
333 [ # # ]: 0 : if( aEntry.nListId )
334 [ # # ]: 0 : aListArr.push_back( aEntry );
335 : 0 : aEntry.Clear();
336 : : }
337 : : }
338 : 0 : break;
339 : :
340 : : case '{':
341 : : {
342 [ # # ][ # # ]: 0 : if( RTF_IGNOREFLAG != GetNextToken() )
343 [ # # ]: 0 : nToken = SkipToken( -1 );
344 : : // Unknown und alle bekannten nicht ausgewerteten Gruppen
345 : : // sofort ueberspringen
346 [ # # ][ # # ]: 0 : else if( RTF_UNKNOWNCONTROL != ( nToken = GetNextToken() ))
347 [ # # ]: 0 : nToken = SkipToken( -2 );
348 : : else
349 : : {
350 : : // gleich herausfiltern
351 [ # # ]: 0 : ReadUnknownData();
352 [ # # ]: 0 : nToken = GetNextToken();
353 [ # # ]: 0 : if( '}' != nToken )
354 : 0 : eState = SVPAR_ERROR;
355 : 0 : break;
356 : : }
357 : 0 : ++nNumOpenBrakets;
358 : : }
359 : 0 : break;
360 : :
361 : : case RTF_LIST:
362 : : {
363 [ # # ][ # # ]: 0 : if( pCurRule && pCurRule->IsContinusNum() )
[ # # ]
364 [ # # ]: 0 : lcl_ExpandNumFmts( *pCurRule );
365 : :
366 [ # # ]: 0 : String sTmp(rtl::OUString(RTF_NUMRULE_NAME " 1"));
367 [ # # ]: 0 : aEntry.nListDocPos = pDoc->MakeNumRule( sTmp, 0, sal_False, SvxNumberFormat::LABEL_ALIGNMENT );
368 : 0 : pCurRule = pDoc->GetNumRuleTbl()[ aEntry.nListDocPos ];
369 : : // #i91400#
370 : : pCurRule->SetName( pDoc->GetUniqueNumRuleName( &sTmp, sal_False ),
371 [ # # ][ # # ]: 0 : *pDoc );
[ # # ]
372 : :
373 : 0 : pCurRule->SetAutoRule( sal_False );
374 [ # # ]: 0 : nNumLvl = (sal_uInt8)-1;
375 : : }
376 : 0 : break;
377 : :
378 : 0 : case RTF_LISTID: aEntry.nListId = nTokenValue; break;
379 : 0 : case RTF_LISTTEMPLATEID: aEntry.nListTemplateId = nTokenValue; break;
380 : :
381 : : case RTF_LISTRESTARTHDN:
382 : 0 : break;
383 : : case RTF_LISTNAME:
384 [ # # ]: 0 : if (nNextCh=='}') break; // empty listnames
385 [ # # ][ # # ]: 0 : if( RTF_TEXTTOKEN == GetNextToken() )
386 : : {
387 [ # # ][ # # ]: 0 : String sTmp( DelCharAtEnd( aToken, ';' ));
388 [ # # ][ # # ]: 0 : if( sTmp.Len() && !pDoc->FindNumRulePtr( sTmp ))
[ # # ][ # # ]
389 : : {
390 : : // #i91400#
391 [ # # ]: 0 : pCurRule->SetName( sTmp, *pDoc );
392 [ # # ]: 0 : }
393 : : }
394 [ # # ]: 0 : SkipGroup();
395 : 0 : break;
396 : :
397 : : case RTF_LISTSIMPLE:
398 : 0 : pCurRule->SetContinusNum( sal_True );
399 : 0 : break;
400 : :
401 : : case RTF_LISTLEVEL:
402 : : {
403 [ # # ]: 0 : if( ++nNumLvl < MAXLEVEL )
404 [ # # ][ # # ]: 0 : pCurRule->Set( nNumLvl, pCurRule->Get( nNumLvl ));
405 [ # # ]: 0 : ReadListLevel( *pCurRule, nNumLvl );
406 : : }
407 : 0 : break;
408 : : }
409 : : }
410 : :
411 [ # # ][ # # ]: 0 : if( pCurRule && pCurRule->IsContinusNum() )
[ # # ]
412 [ # # ]: 0 : lcl_ExpandNumFmts( *pCurRule );
413 : :
414 [ # # ]: 0 : SkipToken( -1 ); // die schliesende Klammer wird "oben" ausgewertet
415 : 0 : }
416 : :
417 : 0 : sal_Bool lcl_IsEqual( SwNumRule* pOrigRule, SwNumRule* pRule )
418 : : {
419 : 0 : sal_Bool bRet = 0;
420 [ # # ][ # # ]: 0 : if( pOrigRule && pRule )
421 : : {
422 : 0 : bRet = pOrigRule->GetRuleType() == pRule->GetRuleType() &&
423 : 0 : pOrigRule->IsContinusNum() == pRule->IsContinusNum() &&
424 [ # # ]: 0 : pOrigRule->IsAbsSpaces() == pRule->IsAbsSpaces();
[ # # # # ]
425 [ # # ]: 0 : if( bRet )
426 [ # # ][ # # ]: 0 : for( sal_uInt8 n = 0; bRet && n < MAXLEVEL; ++n )
[ # # ]
427 : : {
428 : 0 : const SwNumFmt* pOFmt = pOrigRule->GetNumFmt( n ),
429 : 0 : * pFmt = pRule->GetNumFmt( n );
430 [ # # ][ # # ]: 0 : if( pFmt && pOFmt )
431 : : {
432 : 0 : SwCharFmt* pOCFmt = pOFmt->GetCharFmt(),
433 : 0 : * pCFmt = pFmt->GetCharFmt();
434 [ # # ][ # # ]: 0 : if( pOCFmt && pCFmt )
435 : : {
436 : 0 : bRet = 0 != (pCFmt->GetAttrSet() == pOCFmt->GetAttrSet());
437 : : }
438 : : else
439 [ # # ][ # # ]: 0 : bRet = !pCFmt && !pOCFmt;
440 [ # # ]: 0 : if( bRet )
441 : : {
442 : 0 : ((SwNumFmt*)pOFmt)->SetCharFmt( 0 );
443 : 0 : ((SwNumFmt*)pFmt)->SetCharFmt( 0 );
444 : 0 : bRet = *pOFmt == *pFmt;
445 : 0 : ((SwNumFmt*)pOFmt)->SetCharFmt( pOCFmt );
446 : 0 : ((SwNumFmt*)pFmt)->SetCharFmt( pCFmt );
447 : 0 : }
448 : : }
449 : : else
450 [ # # ][ # # ]: 0 : bRet = !pFmt && !pOFmt;
451 : : }
452 : : }
453 : 0 : return bRet;
454 : : }
455 : :
456 : 0 : void SwRTFParser::ReadListOverrideTable()
457 : : {
458 : : int nToken;
459 : 0 : int nNumOpenBrakets = 1; // die erste wurde schon vorher erkannt !!
460 : 0 : SwListEntry aEntry;
461 : 0 : SwNumRule* pRule = 0, *pOrigRule = 0;
462 : 0 : sal_uInt8 nNumLvl = 0;
463 : 0 : sal_Bool bOverrideFormat = sal_False, bOverrideStart = sal_False;
464 : :
465 [ # # ][ # # ]: 0 : while( nNumOpenBrakets && IsParserWorking() )
[ # # ]
466 : : {
467 [ # # ][ # # : 0 : switch( ( nToken = GetNextToken() ))
# # # # #
# # # #
# ]
468 : : {
469 : : case '}':
470 [ # # ][ # # ]: 0 : if( --nNumOpenBrakets && IsParserWorking() )
[ # # ]
471 : : {
472 : : // Style konnte vollstaendig gelesen werden,
473 : : // also ist das noch ein stabiler Status
474 [ # # ]: 0 : SaveState( RTF_LISTOVERRIDETABLE );
475 : :
476 [ # # ]: 0 : if( 1 == nNumOpenBrakets )
477 : : {
478 : 0 : bOverrideFormat = sal_False, bOverrideStart = sal_False;
479 [ # # ]: 0 : if( pRule )
480 : : {
481 [ # # ][ # # ]: 0 : if( lcl_IsEqual( pOrigRule, pRule ))
482 : : {
483 : : // no changes on the rule -> use the original rule
484 : : aEntry.nListDocPos = pDoc->FindNumRule(
485 [ # # ]: 0 : pOrigRule->GetName() );
486 : : // delete the temp Rule
487 [ # # ]: 0 : RemoveUnusedNumRule( pRule );
488 : : }
489 [ # # ]: 0 : else if( pRule->IsContinusNum() )
490 [ # # ]: 0 : lcl_ExpandNumFmts( *pRule );
491 : : }
492 : :
493 [ # # ][ # # ]: 0 : if( aEntry.nListId && aEntry.nListNo )
494 : : {
495 : 0 : int nMatch=-1;
496 [ # # ]: 0 : for( size_t n = aListArr.size(); n; )
497 : : {
498 [ # # ][ # # ]: 0 : if( aListArr[ --n ].nListId == aEntry.nListId)
499 : : {
500 : 0 : nMatch=n;
501 : 0 : break;
502 : : }
503 : : }
504 [ # # ]: 0 : if(nMatch>=0)
505 : : {
506 : 0 : sal_uInt16 nMatch2 = static_cast< sal_uInt16 >(nMatch);
507 [ # # ][ # # ]: 0 : if (!aListArr[nMatch2].nListNo )
508 : : {
509 [ # # ]: 0 : aListArr[nMatch2].nListNo = aEntry.nListNo;
510 : : }
511 : : else
512 : : {
513 [ # # ]: 0 : aEntry.nListDocPos=aListArr[nMatch2].nListDocPos;
514 [ # # ]: 0 : aEntry.nListTemplateId=aListArr[nMatch2].nListTemplateId;
515 [ # # ]: 0 : aListArr.push_back( aEntry );
516 : : }
517 [ # # ]: 0 : if(pOrigRule)
518 [ # # ]: 0 : aListArr[nMatch2].nListDocPos = aEntry.nListDocPos;
519 : : }
520 : : }
521 : 0 : aEntry.Clear();
522 : 0 : pOrigRule = 0;
523 : 0 : pRule = 0;
524 : : }
525 : : }
526 : 0 : break;
527 : :
528 : : case '{':
529 : : {
530 [ # # ][ # # ]: 0 : if( RTF_IGNOREFLAG != GetNextToken() )
531 [ # # ]: 0 : nToken = SkipToken( -1 );
532 : : // Unknown und alle bekannten nicht ausgewerteten Gruppen
533 : : // sofort ueberspringen
534 [ # # ][ # # ]: 0 : else if( RTF_UNKNOWNCONTROL != ( nToken = GetNextToken() ))
535 [ # # ]: 0 : nToken = SkipToken( -2 );
536 : : else
537 : : {
538 : : // gleich herausfiltern
539 [ # # ]: 0 : ReadUnknownData();
540 [ # # ]: 0 : nToken = GetNextToken();
541 [ # # ]: 0 : if( '}' != nToken )
542 : 0 : eState = SVPAR_ERROR;
543 : 0 : break;
544 : : }
545 : 0 : ++nNumOpenBrakets;
546 : : }
547 : 0 : break;
548 : :
549 : 0 : case RTF_LISTOVERRIDE: aEntry.Clear(); break;
550 : 0 : case RTF_LISTID: aEntry.nListId = nTokenValue; break;
551 : 0 : case RTF_LS: aEntry.nListNo = nTokenValue; break;
552 : : case RTF_LISTOVERRIDECOUNT:
553 [ # # ]: 0 : if( nTokenValue )
554 : : {
555 : 0 : pRule = 0;
556 : : // dann erzeugen wir mal schnell eine Kopie von der NumRule,
557 : : // denn diese wird jetzt mal kurz veraendert.
558 [ # # ]: 0 : if( aEntry.nListId )
559 [ # # ]: 0 : for( size_t n = 0; n < aListArr.size(); ++n )
560 [ # # ][ # # ]: 0 : if( aListArr[ n ].nListId == aEntry.nListId )
561 : : {
562 : 0 : pRule = pDoc->GetNumRuleTbl()[
563 [ # # ]: 0 : aListArr[ n ].nListDocPos ];
564 : 0 : pOrigRule = pRule;
565 : :
566 [ # # ]: 0 : String sTmp(rtl::OUString(RTF_NUMRULE_NAME " 1"));
567 [ # # ]: 0 : aEntry.nListDocPos = pDoc->MakeNumRule( sTmp, pRule );
568 : 0 : pRule = pDoc->GetNumRuleTbl()[ aEntry.nListDocPos ];
569 : : // #i91400#
570 : : pRule->SetName( pDoc->GetUniqueNumRuleName( &sTmp, sal_False ),
571 [ # # ][ # # ]: 0 : *pDoc );
[ # # ]
572 : :
573 : 0 : pRule->SetAutoRule( sal_False );
574 : 0 : nNumLvl = (sal_uInt8)-1;
575 [ # # ]: 0 : aListArr.push_back( aEntry );
576 [ # # ]: 0 : break;
577 : : }
578 : :
579 : : }
580 : 0 : break;
581 : :
582 : : case RTF_LISTLEVEL:
583 [ # # ][ # # ]: 0 : if( pRule && bOverrideFormat )
584 : : {
585 [ # # ]: 0 : if( ++nNumLvl < MAXLEVEL )
586 [ # # ][ # # ]: 0 : pRule->Set( nNumLvl, pRule->Get( nNumLvl ));
587 [ # # ]: 0 : ReadListLevel( *pRule, nNumLvl );
588 : : }
589 : 0 : break;
590 : :
591 : : case RTF_LEVELSTARTAT:
592 : : if( pRule && bOverrideStart )
593 : : {
594 : : }
595 : 0 : break;
596 : :
597 : : case RTF_LISTOVERRIDESTART:
598 : 0 : bOverrideStart = sal_True;
599 : 0 : break;
600 : :
601 : : case RTF_LISTOVERRIDEFORMAT:
602 : 0 : bOverrideFormat = sal_True;
603 : 0 : break;
604 : :
605 : : case RTF_LFOLEVEL:
606 : : // was fehlt noch?
607 : 0 : break;
608 : : }
609 : : }
610 : :
611 : : // search the outline numrule and set it into the doc
612 [ # # ]: 0 : if( !GetStyleTbl().empty() )
613 : : {
614 [ # # ]: 0 : if( !bStyleTabValid )
615 [ # # ]: 0 : MakeStyleTab();
616 : :
617 : 0 : const SfxPoolItem* pItem( 0 );
618 [ # # ]: 0 : std::map<sal_Int32,SwTxtFmtColl*>::const_iterator iterColl;
619 : 0 : sal_uInt16 nRulePos( USHRT_MAX );
620 : 0 : const SwNumRule *pNumRule = 0;
621 [ # # ][ # # ]: 0 : for (SvxRTFStyleTbl::iterator it = GetStyleTbl().begin();
[ # # ][ # # ]
622 [ # # ]: 0 : it != GetStyleTbl().end(); ++it)
623 : : {
624 [ # # ]: 0 : SvxRTFStyleType* pStyle = it->second;
625 [ # # ]: 0 : if ( MAXLEVEL > pStyle->nOutlineNo )
626 : : {
627 [ # # ][ # # ]: 0 : iterColl = aTxtCollTbl.find( it->first );
[ # # ]
628 [ # # ][ # # ]: 0 : if ( iterColl != aTxtCollTbl.end() )
[ # # ]
629 : : {
630 : : const SfxItemState eItemState =
631 [ # # ][ # # ]: 0 : iterColl->second->GetItemState( RES_PARATR_NUMRULE, sal_False, &pItem );
632 [ # # ]: 0 : if ( eItemState == SFX_ITEM_SET )
633 : : {
634 [ # # ]: 0 : nRulePos = pDoc->FindNumRule( ((SwNumRuleItem*)pItem)->GetValue() );
635 [ # # ]: 0 : if ( nRulePos != USHRT_MAX )
636 : : {
637 : 0 : pNumRule = pDoc->GetNumRuleTbl()[ nRulePos ];
638 [ # # ]: 0 : if ( pNumRule->IsAutoRule() &&
[ # # # # ]
639 : 0 : pNumRule != pDoc->GetOutlineNumRule() )
640 : : {
641 [ # # ]: 0 : pDoc->SetOutlineNumRule( *pNumRule );
642 [ # # ]: 0 : pDoc->DelNumRule( pNumRule->GetName() );
643 : : // now pNumRule pointer is invalid !!!
644 : :
645 : : // now decrement all position in the listtable, which will
646 : : // behind the doc-rule position
647 [ # # ]: 0 : for( size_t n = aListArr.size(); n; )
648 : : {
649 [ # # ]: 0 : SwListEntry& rEntry = aListArr[ --n ];
650 [ # # ]: 0 : if( rEntry.nListDocPos == nRulePos )
651 [ # # ][ # # ]: 0 : aListArr.erase( aListArr.begin()+n );
652 [ # # ]: 0 : else if( rEntry.nListDocPos > nRulePos )
653 : 0 : --rEntry.nListDocPos;
654 : : }
655 : 0 : break;
656 : : }
657 : : }
658 : : }
659 : : }
660 : : }
661 : :
662 [ # # ]: 0 : pStyle->aAttrSet.ClearItem( FN_PARAM_NUM_LEVEL );
663 : : }
664 : : }
665 : :
666 [ # # ]: 0 : SkipToken( -1 ); // die schliesende Klammer wird "oben" ausgewertet
667 : 0 : }
668 : :
669 : 0 : SwNumRule* SwRTFParser::GetNumRuleOfListNo( long nListNo, sal_Bool bRemoveFromList )
670 : : {
671 : 0 : SwNumRule* pRet = 0;
672 : : SwListEntry* pEntry;
673 [ # # ]: 0 : for( size_t n = aListArr.size(); n; )
674 [ # # ]: 0 : if( ( pEntry = &aListArr[ --n ])->nListNo == nListNo )
675 : : {
676 [ # # ]: 0 : if( bRemoveFromList )
677 [ # # ][ # # ]: 0 : aListArr.erase( aListArr.begin()+n );
678 : : else
679 : : {
680 : 0 : pEntry->bRuleUsed = sal_True;
681 : 0 : pRet = pDoc->GetNumRuleTbl()[ pEntry->nListDocPos ];
682 : : }
683 : 0 : break;
684 : : }
685 : 0 : return pRet;
686 : : }
687 : :
688 : 0 : void SwRTFParser::RemoveUnusedNumRule( SwNumRule* pRule )
689 : : {
690 [ # # ]: 0 : if( pRule )
691 : : {
692 [ # # ]: 0 : for ( sal_uInt8 nLvl = 0; nLvl < MAXLEVEL; ++nLvl )
693 : : {
694 : 0 : SwNumFmt& rNFmt = (SwNumFmt&)pRule->Get( nLvl );
695 : 0 : SwCharFmt* pCFmt = rNFmt.GetCharFmt();
696 [ # # ]: 0 : if( pCFmt )
697 : : {
698 : 0 : rNFmt.ForgetCharFmt();
699 [ # # ]: 0 : if( !pCFmt->GetDepends() )
700 : 0 : pDoc->DelCharFmt( pCFmt );
701 : : }
702 : : }
703 : 0 : pDoc->DelNumRule( pRule->GetName() );
704 : : }
705 : : #if OSL_DEBUG_LEVEL > 0
706 : : else
707 : : {
708 : : OSL_ENSURE( pRule, "NumRulePointer 0 kann nicht geloescht werden" );
709 : : }
710 : : #endif
711 : 0 : }
712 : :
713 : 0 : void SwRTFParser::RemoveUnusedNumRules()
714 : : {
715 : : SwListEntry* pEntry;
716 [ # # ]: 0 : std::set<SwNumRule*> aDelArr;
717 : : size_t n;
718 [ # # ]: 0 : for( n = aListArr.size(); n; )
719 : : {
720 [ # # ][ # # ]: 0 : if( !( pEntry = &aListArr[ --n ])->bRuleUsed )
721 : : {
722 : : // really *NOT* used by anyone else?
723 : 0 : sal_Bool unused=sal_True;
724 [ # # ]: 0 : for(size_t j = 0; j < aListArr.size(); ++j)
725 : : {
726 [ # # ][ # # ]: 0 : if (aListArr[n].nListNo==aListArr[j].nListNo)
[ # # ]
727 [ # # ]: 0 : unused&=!aListArr[j].bRuleUsed;
728 : : }
729 [ # # ]: 0 : if (unused)
730 : : {
731 : 0 : SwNumRule* p = pDoc->GetNumRuleTbl()[pEntry->nListDocPos];
732 : : // dont delete named char formats
733 [ # # ][ # # ]: 0 : if( aDelArr.find( p ) == aDelArr.end() &&
[ # # ][ # # ]
[ # # ][ # #
# # # # ]
[ # # ]
734 : 0 : p->GetName().EqualsAscii( RTF_NUMRULE_NAME, 0,
735 [ # # ]: 0 : sizeof( RTF_NUMRULE_NAME )) )
736 [ # # ]: 0 : aDelArr.insert( p );
737 : : }
738 : : }
739 : : }
740 : :
741 [ # # ]: 0 : while( !aDelArr.empty() )
742 : : {
743 [ # # ][ # # ]: 0 : RemoveUnusedNumRule( *aDelArr.begin() );
744 [ # # ]: 0 : aDelArr.erase( aDelArr.begin() );
745 : 0 : }
746 : 0 : }
747 : :
748 : 0 : const Font* SwRTFParser::FindFontOfItem( const SvxFontItem& rItem ) const
749 : : {
750 : 0 : SvxRTFFontTbl& rFntTbl = ((SwRTFParser*)this)->GetFontTbl();
751 [ # # ][ # # ]: 0 : for (SvxRTFFontTbl::iterator it = rFntTbl.begin(); it != rFntTbl.end(); ++it)
[ # # ][ # # ]
[ # # ]
752 : : {
753 [ # # ]: 0 : const Font* pFnt = it->second;
754 [ # # ][ # # ]: 0 : if( pFnt->GetFamily() == rItem.GetFamily() &&
[ # # # #
# # ][ # # ]
[ # # ]
755 [ # # ][ # # ]: 0 : pFnt->GetName() == rItem.GetFamilyName() &&
756 [ # # ][ # # ]: 0 : pFnt->GetStyleName() == rItem.GetStyleName() &&
757 [ # # ]: 0 : pFnt->GetPitch() == rItem.GetPitch() &&
758 [ # # ]: 0 : pFnt->GetCharSet() == rItem.GetCharSet() )
759 : 0 : return pFnt;
760 : : }
761 : 0 : return 0;
762 : : }
763 : :
764 : :
765 : 0 : SwNumRule *SwRTFParser::ReadNumSecLevel( int nToken )
766 : : {
767 : : // lese die \pnseclvl - Gruppe
768 : : // nTokenValue gibt schon den richtigen Level vor 1 - 9!
769 : 0 : sal_uInt8 nLevel = 0;
770 : 0 : long nListNo = 0;
771 : 0 : sal_Bool bContinus = sal_True;
772 : :
773 [ # # ]: 0 : if( RTF_PNSECLVL == nToken )
774 : : {
775 : : // suche die Rule - steht unter Nummer 3
776 : 0 : nListNo = 3;
777 : 0 : bContinus = sal_False;
778 : : nLevel = MAXLEVEL <= (unsigned long) nTokenValue ? MAXLEVEL - 1
779 [ # # ][ # # ]: 0 : : (!nTokenValue ? 0 : sal_uInt8( nTokenValue - 1 ));
780 : : }
781 : : else
782 : : {
783 [ # # # # : 0 : switch( nToken = GetNextToken() )
# ]
784 : : {
785 : 0 : case RTF_PNLVL: nListNo = 3;
786 : 0 : bContinus = sal_False;
787 : : nLevel = MAXLEVEL <= (unsigned long) nTokenValue
788 : : ? MAXLEVEL - 1
789 [ # # ][ # # ]: 0 : : (!nTokenValue ? 0 : sal_uInt8( nTokenValue-1 ));
790 : 0 : break;
791 : :
792 : : case RTF_PNLVLBODY:
793 : 0 : nListNo = 2;
794 : 0 : break;
795 : : case RTF_PNLVLBLT:
796 : 0 : nListNo = 1;
797 : 0 : break;
798 : : case RTF_PNLVLCONT:
799 : 0 : SkipGroup();
800 : 0 : return 0;
801 : : default:
802 : 0 : SkipGroup();
803 : 0 : return 0;
804 : : }
805 : : }
806 : :
807 : : // suche die Rule - steht unter Nummer 3
808 : 0 : sal_uInt16 nNewFlag = static_cast< sal_uInt16 >(1 << nListNo);
809 : : SwNumRule* pCurRule = GetNumRuleOfListNo( nListNo,
810 : 0 : 0 != ( nNewNumSectDef & nNewFlag ) );
811 [ # # ]: 0 : if( !pCurRule )
812 : : {
813 : : // dann muessen wir die mal anlegen
814 : 0 : nNewNumSectDef &= ~nNewFlag;
815 [ # # ]: 0 : String sTmp(rtl::OUString(RTF_NUMRULE_NAME " 1"));
816 [ # # ]: 0 : SwListEntry aEntry( nListNo, 0, pDoc->MakeNumRule( sTmp ));
817 : 0 : aEntry.nListNo = nListNo;
818 [ # # ]: 0 : aListArr.push_back( aEntry );
819 : 0 : pCurRule = pDoc->GetNumRuleTbl()[ aEntry.nListDocPos ];
820 : : // #i91400#
821 [ # # ][ # # ]: 0 : pCurRule->SetName( pDoc->GetUniqueNumRuleName( &sTmp, sal_False ), *pDoc );
[ # # ]
822 : :
823 : 0 : pCurRule->SetAutoRule( sal_False );
824 [ # # ]: 0 : pCurRule->SetContinusNum( bContinus );
825 : : }
826 : :
827 [ # # ]: 0 : if( !pCurRule->GetNumFmt( nLevel ))
828 : 0 : pCurRule->Set( nLevel, pCurRule->Get( nLevel ));
829 : 0 : SwNumFmt* pCurNumFmt = (SwNumFmt*)pCurRule->GetNumFmt( nLevel );
830 [ # # ]: 0 : if( RTF_PNLVLBLT == nToken )
831 : 0 : pCurNumFmt->SetNumberingType(SVX_NUM_CHAR_SPECIAL);
832 : 0 : pCurNumFmt->SetSuffix( aEmptyStr );
833 : 0 : pCurNumFmt->SetPrefix( aEmptyStr );
834 : 0 : pCurNumFmt->SetNumberingType(SVX_NUM_NUMBER_NONE);
835 : :
836 [ # # ][ # # ]: 0 : if( bStyleTabValid && RTF_PNSECLVL != nToken )
837 : : {
838 : : // dann den akt. Lvl und Rule am Absatz setzen.
839 : : // Dieses muss aber in den vorherigen "Kontext", sprich in den vor
840 : : // der Klammer offenen Attrset. Darum das SetNewGroup davor und dahinter
841 : 0 : SetNewGroup( sal_False );
842 [ # # ][ # # ]: 0 : GetAttrSet().Put( SfxUInt16Item( FN_PARAM_NUM_LEVEL, nLevel ));
843 [ # # ][ # # ]: 0 : GetAttrSet().Put( SwNumRuleItem( pCurRule->GetName() ));
844 : 0 : SetNewGroup( sal_True );
845 : : }
846 : :
847 : : FontUnderline eUnderline;
848 : 0 : int nNumOpenBrakets = 1; // die erste wurde schon vorher erkannt !!
849 [ # # ][ # # ]: 0 : while( nNumOpenBrakets && IsParserWorking() )
[ # # ]
850 : : {
851 [ # # # # : 0 : switch( ( nToken = GetNextToken() ))
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# ]
852 : : {
853 : : case '}':
854 [ # # ][ # # ]: 0 : if( --nNumOpenBrakets && IsParserWorking() )
[ # # ]
855 : : {
856 : : // Style konnte vollstaendig gelesen werden,
857 : : // also ist das noch ein stabiler Status
858 : 0 : SaveState( RTF_PNSECLVL );
859 : : }
860 : 0 : break;
861 : :
862 : : case '{':
863 : : {
864 [ # # ]: 0 : if( RTF_IGNOREFLAG != GetNextToken() )
865 : 0 : nToken = SkipToken( -1 );
866 : : // Unknown und alle bekannten nicht ausgewerteten Gruppen
867 : : // sofort ueberspringen
868 [ # # ]: 0 : else if( RTF_UNKNOWNCONTROL != ( nToken = GetNextToken() ))
869 : 0 : nToken = SkipToken( -2 );
870 : : else
871 : : {
872 : : // gleich herausfiltern
873 : 0 : ReadUnknownData();
874 : 0 : nToken = GetNextToken();
875 [ # # ]: 0 : if( '}' != nToken )
876 : 0 : eState = SVPAR_ERROR;
877 : 0 : break;
878 : : }
879 : 0 : ++nNumOpenBrakets;
880 : : }
881 : 0 : break;
882 : :
883 : : case RTF_PNCARD:
884 : : case RTF_PNORD:
885 : : case RTF_PNORDT:
886 : 0 : case RTF_PNDEC: pCurNumFmt->SetNumberingType(SVX_NUM_ARABIC); break;
887 : 0 : case RTF_PNUCLTR: pCurNumFmt->SetNumberingType(SVX_NUM_CHARS_UPPER_LETTER_N); break;
888 : 0 : case RTF_PNUCRM: pCurNumFmt->SetNumberingType(SVX_NUM_ROMAN_UPPER); break;
889 : 0 : case RTF_PNLCLTR: pCurNumFmt->SetNumberingType(SVX_NUM_CHARS_LOWER_LETTER_N); break;
890 : 0 : case RTF_PNLCRM: pCurNumFmt->SetNumberingType(SVX_NUM_ROMAN_LOWER); break;
891 : :
892 : : case RTF_PNF:
893 : : {
894 : 0 : const Font& rSVFont = GetFont( sal_uInt16(nTokenValue) );
895 [ # # ]: 0 : GetNumChrFmt( *pDoc, *pCurRule, nLevel ).Put(
896 : : SvxFontItem( rSVFont.GetFamily(),
897 : 0 : rSVFont.GetName(), rSVFont.GetStyleName(),
898 : 0 : rSVFont.GetPitch(), rSVFont.GetCharSet(),
899 [ # # ]: 0 : RES_CHRATR_FONT ));
900 [ # # ]: 0 : if( SVX_NUM_CHAR_SPECIAL == pCurNumFmt->GetNumberingType() )
901 : 0 : pCurNumFmt->SetBulletFont( &rSVFont );
902 : : }
903 : 0 : break;
904 : : case RTF_PNFS:
905 : : {
906 [ # # ]: 0 : if( -1 == nTokenValue )
907 : 0 : nTokenValue = 240;
908 : : else
909 : 0 : nTokenValue *= 10;
910 [ # # ]: 0 : GetNumChrFmt( *pDoc, *pCurRule, nLevel ).Put(
911 [ # # ]: 0 : SvxFontHeightItem( (const sal_uInt16)nTokenValue, 100, RES_CHRATR_FONTSIZE ));
912 : : }
913 : 0 : break;
914 : :
915 : : case RTF_PNB:
916 : : {
917 [ # # ]: 0 : GetNumChrFmt( *pDoc, *pCurRule, nLevel ).Put( SvxWeightItem(
918 [ # # ][ # # ]: 0 : nTokenValue ? WEIGHT_BOLD : WEIGHT_NORMAL, RES_CHRATR_WEIGHT ));
919 : : }
920 : 0 : break;
921 : :
922 : : case RTF_PNI:
923 : : {
924 [ # # ]: 0 : GetNumChrFmt( *pDoc, *pCurRule, nLevel ).Put( SvxPostureItem(
925 [ # # ][ # # ]: 0 : nTokenValue ? ITALIC_NORMAL : ITALIC_NONE, RES_CHRATR_POSTURE ));
926 : : }
927 : 0 : break;
928 : :
929 : : case RTF_PNCAPS:
930 : : case RTF_PNSCAPS:
931 : : {
932 [ # # ]: 0 : GetNumChrFmt( *pDoc, *pCurRule, nLevel ).Put( SvxCaseMapItem(
933 : : nTokenValue ? SVX_CASEMAP_KAPITAELCHEN
934 [ # # ][ # # ]: 0 : : SVX_CASEMAP_NOT_MAPPED, RES_CHRATR_CASEMAP ));
935 : : }
936 : 0 : break;
937 : : case RTF_PNSTRIKE:
938 : : {
939 [ # # ]: 0 : GetNumChrFmt( *pDoc, *pCurRule, nLevel ).Put( SvxCrossedOutItem(
940 [ # # ][ # # ]: 0 : nTokenValue ? STRIKEOUT_SINGLE : STRIKEOUT_NONE, RES_CHRATR_CROSSEDOUT ));
941 : : }
942 : 0 : break;
943 : :
944 : : case RTF_PNCF:
945 : : {
946 [ # # ]: 0 : GetNumChrFmt( *pDoc, *pCurRule, nLevel ).Put( SvxColorItem(
947 [ # # ]: 0 : GetColor( sal_uInt16(nTokenValue) ), RES_CHRATR_COLOR ));
948 : : }
949 : 0 : break;
950 : :
951 : :
952 : : case RTF_PNUL:
953 [ # # ]: 0 : eUnderline = nTokenValue ? UNDERLINE_SINGLE : UNDERLINE_NONE;
954 : 0 : goto NUMATTR_SETUNDERLINE;
955 : : case RTF_PNULD:
956 : 0 : eUnderline = UNDERLINE_DOTTED;
957 : 0 : goto NUMATTR_SETUNDERLINE;
958 : : case RTF_PNULDB:
959 : 0 : eUnderline = UNDERLINE_DOUBLE;
960 : 0 : goto NUMATTR_SETUNDERLINE;
961 : : case RTF_PNULNONE:
962 : 0 : eUnderline = UNDERLINE_NONE;
963 : 0 : goto NUMATTR_SETUNDERLINE;
964 : : case RTF_PNULW:
965 : : {
966 [ # # ]: 0 : GetNumChrFmt( *pDoc, *pCurRule, nLevel ).Put(
967 [ # # ]: 0 : SvxWordLineModeItem( sal_True, RES_CHRATR_WORDLINEMODE ));
968 : : }
969 : 0 : eUnderline = UNDERLINE_SINGLE;
970 : 0 : goto NUMATTR_SETUNDERLINE;
971 : :
972 : : NUMATTR_SETUNDERLINE:
973 : : {
974 [ # # ]: 0 : GetNumChrFmt( *pDoc, *pCurRule, nLevel ).Put(
975 [ # # ]: 0 : SvxUnderlineItem( eUnderline, RES_CHRATR_UNDERLINE ));
976 : : }
977 : 0 : break;
978 : :
979 : : case RTF_PNINDENT:
980 [ # # ]: 0 : if( 0 > short( nTokenValue ) )
981 : 0 : nTokenValue = - (short)nTokenValue;
982 : 0 : pCurNumFmt->SetFirstLineIndent( - nTokenValue );
983 : 0 : pCurNumFmt->SetIndentAt( (nLevel + 1 ) * nTokenValue );
984 : 0 : break;
985 : : case RTF_PNSP:
986 : 0 : pCurNumFmt->SetCharTextDistance( sal_uInt16( nTokenValue ));
987 : 0 : break;
988 : :
989 : : case RTF_PNPREV:
990 [ # # ]: 0 : if( nLevel )
991 : : {
992 : 0 : sal_uInt8 nPrev = 2, nLast = nLevel;
993 [ # # ][ # # ]: 0 : while( nLast && 1 < pCurRule->Get( --nLast ).GetIncludeUpperLevels() )
[ # # ]
994 : 0 : ++nPrev;
995 : 0 : pCurNumFmt->SetIncludeUpperLevels( nPrev );
996 : : }
997 : 0 : break;
998 : :
999 : 0 : case RTF_PNQC: pCurNumFmt->SetNumAdjust( SVX_ADJUST_CENTER ); break;
1000 : 0 : case RTF_PNQL: pCurNumFmt->SetNumAdjust( SVX_ADJUST_LEFT ); break;
1001 : 0 : case RTF_PNQR: pCurNumFmt->SetNumAdjust( SVX_ADJUST_RIGHT ); break;
1002 : :
1003 : : case RTF_PNSTART:
1004 : 0 : pCurNumFmt->SetStart( sal_uInt16( nTokenValue ));
1005 : 0 : break;
1006 : :
1007 : : case RTF_PNNUMONCE:
1008 : : case RTF_PNACROSS:
1009 : : case RTF_PNHANG:
1010 : 0 : case RTF_PNRESTART: break;
1011 : :
1012 : : case RTF_PNTXTA:
1013 : : {
1014 [ # # ]: 0 : String sTmp;
1015 [ # # ]: 0 : GetTextToEndGroup( sTmp );
1016 [ # # ]: 0 : if( SVX_NUM_CHAR_SPECIAL == pCurNumFmt->GetNumberingType() )
1017 : : {
1018 : 0 : pCurNumFmt->SetBulletChar( sTmp.GetChar( 0 ) );
1019 [ # # ]: 0 : if( pCurNumFmt->GetCharFmt() )
1020 : : pCurNumFmt->SetBulletFont( FindFontOfItem(
1021 [ # # ][ # # ]: 0 : pCurNumFmt->GetCharFmt()->GetFont() ) );
[ # # ]
1022 [ # # ]: 0 : sTmp.Erase();
1023 : : }
1024 [ # # ][ # # ]: 0 : pCurNumFmt->SetSuffix( sTmp );
1025 : : }
1026 : 0 : break;
1027 : :
1028 : : case RTF_PNTXTB:
1029 : : {
1030 [ # # ]: 0 : String sTmp;
1031 [ # # ][ # # ]: 0 : pCurNumFmt->SetPrefix( GetTextToEndGroup( sTmp ) );
[ # # ]
1032 : : }
1033 : 0 : break;
1034 : : }
1035 : : }
1036 : :
1037 : : // falls vollstaendige Numerierung an ist und das Zeichen davor ein
1038 : : // Punkt ist, dann will RTF den Punkt als Trenner zwischen den Ebenen
1039 : : // haben - das haben wir aber schon als default
1040 [ # # # # : 0 : if( 1 < pCurNumFmt->GetIncludeUpperLevels() &&
# # # # ]
[ # # ]
1041 : 0 : 1 == pCurNumFmt->GetPrefix().getLength() &&
1042 : 0 : '.' == pCurNumFmt->GetPrefix()[0] &&
1043 : 0 : SVX_NUM_CHAR_SPECIAL != pCurNumFmt->GetNumberingType() )
1044 : 0 : pCurNumFmt->SetPrefix( aEmptyStr );
1045 : :
1046 : : // falls das ein nicht numerierter Absatz mit ein Prefix-Text mit
1047 : : // einem Zeichen ist, dann setze den als Bulletzeichen
1048 [ # # ][ # # ]: 0 : if( pCurNumFmt->GetCharFmt() && SVX_NUM_NUMBER_NONE == pCurNumFmt->GetNumberingType() &&
[ # # # # ]
[ # # ]
1049 : 0 : 3 == nListNo && 1 == pCurNumFmt->GetPrefix().getLength() )
1050 : : {
1051 : 0 : SwCharFmt* pChFmt = pCurNumFmt->GetCharFmt();
1052 : 0 : pCurNumFmt->SetNumberingType(SVX_NUM_CHAR_SPECIAL);
1053 : 0 : pCurNumFmt->SetBulletFont( FindFontOfItem( pChFmt->GetFont() ) );
1054 : :
1055 : 0 : pCurNumFmt->SetBulletChar( pCurNumFmt->GetPrefix()[0] );
1056 : 0 : pCurNumFmt->SetPrefix( aEmptyStr );
1057 : :
1058 : : // den Font oder sogar das gesamte CharFormat loeschen?
1059 [ # # ]: 0 : if( SFX_ITEM_SET == pChFmt->GetItemState( RES_CHRATR_FONT, sal_False ))
1060 : : {
1061 [ # # ]: 0 : if( 1 == pChFmt->GetAttrSet().Count() )
1062 : : {
1063 : 0 : pCurNumFmt->SetCharFmt( 0 );
1064 : 0 : pDoc->DelCharFmt( pChFmt );
1065 : : }
1066 : : else
1067 : 0 : pChFmt->ResetFmtAttr( RES_CHRATR_FONT );
1068 : : }
1069 : : }
1070 : :
1071 : 0 : SkipToken( -1 ); // die schliesende Klammer wird "oben" ausgewertet
1072 : 0 : return pCurRule;
1073 : : }
1074 : :
1075 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
