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 : :
30 : : #include <editeng/flstitem.hxx>
31 : : #include <editeng/fontitem.hxx>
32 : : #include <editeng/postitem.hxx>
33 : : #include <editeng/wghtitem.hxx>
34 : : #include <editeng/fhgtitem.hxx>
35 : : #include <editeng/fwdtitem.hxx>
36 : : #include <editeng/udlnitem.hxx>
37 : : #include <editeng/crsditem.hxx>
38 : : #include <editeng/shdditem.hxx>
39 : : #include <editeng/akrnitem.hxx>
40 : : #include <editeng/wrlmitem.hxx>
41 : : #include <editeng/cntritem.hxx>
42 : : #include <editeng/prszitem.hxx>
43 : : #include <editeng/colritem.hxx>
44 : : #include <editeng/cscoitem.hxx>
45 : : #include <editeng/kernitem.hxx>
46 : : #include <editeng/cmapitem.hxx>
47 : : #include <editeng/escpitem.hxx>
48 : : #include <editeng/langitem.hxx>
49 : : #include <editeng/nlbkitem.hxx>
50 : : #include <editeng/nhypitem.hxx>
51 : : #include <editeng/lcolitem.hxx>
52 : : #include <editeng/blnkitem.hxx>
53 : : #include <editeng/emphitem.hxx>
54 : : #include <editeng/twolinesitem.hxx>
55 : : #include <editeng/pbinitem.hxx>
56 : : #include <editeng/sizeitem.hxx>
57 : : #include <editeng/lrspitem.hxx>
58 : : #include <editeng/ulspitem.hxx>
59 : : #include <editeng/prntitem.hxx>
60 : : #include <editeng/opaqitem.hxx>
61 : : #include <editeng/protitem.hxx>
62 : : #include <editeng/shaditem.hxx>
63 : : #include <editeng/boxitem.hxx>
64 : : #include <editeng/brkitem.hxx>
65 : : #include <editeng/keepitem.hxx>
66 : : #include <editeng/bolnitem.hxx>
67 : : #include <editeng/brshitem.hxx>
68 : : #include <editeng/lspcitem.hxx>
69 : : #include <editeng/adjitem.hxx>
70 : : #include <editeng/orphitem.hxx>
71 : : #include <editeng/widwitem.hxx>
72 : : #include <editeng/tstpitem.hxx>
73 : : #include <editeng/pmdlitem.hxx>
74 : : #include <editeng/spltitem.hxx>
75 : : #include <editeng/hyznitem.hxx>
76 : : #include <editeng/charscaleitem.hxx>
77 : : #include <editeng/charrotateitem.hxx>
78 : : #include <editeng/charreliefitem.hxx>
79 : : #include <editeng/paravertalignitem.hxx>
80 : : #include <editeng/forbiddenruleitem.hxx>
81 : : #include <editeng/hngpnctitem.hxx>
82 : : #include <editeng/scriptspaceitem.hxx>
83 : : #include <editeng/frmdiritem.hxx>
84 : : #include <editeng/charhiddenitem.hxx>
85 : :
86 : : #include <svtools/rtftoken.h>
87 : : #include <svl/itempool.hxx>
88 : : #include <svl/itemiter.hxx>
89 : :
90 : : #include <editeng/svxrtf.hxx>
91 : : #include <editeng/editids.hrc>
92 : :
93 : : #define BRACELEFT '{'
94 : : #define BRACERIGHT '}'
95 : :
96 : : using namespace ::com::sun::star;
97 : : using namespace editeng;
98 : :
99 : : // Some helper functions
100 : : // char
101 : 0 : inline const SvxEscapementItem& GetEscapement(const SfxItemSet& rSet,sal_uInt16 nId,sal_Bool bInP=sal_True)
102 : 0 : { return (const SvxEscapementItem&)rSet.Get( nId,bInP); }
103 : 0 : inline const SvxLineSpacingItem& GetLineSpacing(const SfxItemSet& rSet,sal_uInt16 nId,sal_Bool bInP=sal_True)
104 : 0 : { return (const SvxLineSpacingItem&)rSet.Get( nId,bInP); }
105 : : // frm
106 : 0 : inline const SvxLRSpaceItem& GetLRSpace(const SfxItemSet& rSet,sal_uInt16 nId,sal_Bool bInP=sal_True)
107 : 0 : { return (const SvxLRSpaceItem&)rSet.Get( nId,bInP); }
108 : 0 : inline const SvxULSpaceItem& GetULSpace(const SfxItemSet& rSet,sal_uInt16 nId,sal_Bool bInP=sal_True)
109 : 0 : { return (const SvxULSpaceItem&)rSet.Get( nId,bInP); }
110 : :
111 : : #define PARDID ((RTFPardAttrMapIds*)&aPardMap[0])
112 : : #define PLAINID ((RTFPlainAttrMapIds*)&aPlainMap[0])
113 : :
114 : 0 : void SvxRTFParser::SetScriptAttr( RTF_CharTypeDef eType, SfxItemSet& rSet,
115 : : SfxPoolItem& rItem )
116 : : {
117 : 0 : const sal_uInt16 *pNormal = 0, *pCJK = 0, *pCTL = 0;
118 : 0 : const RTFPlainAttrMapIds* pIds = (RTFPlainAttrMapIds*)&aPlainMap[0];
119 [ # # # # : 0 : switch( rItem.Which() )
# # # ]
120 : : {
121 : : case SID_ATTR_CHAR_FONT:
122 : 0 : pNormal = &pIds->nFont;
123 : 0 : pCJK = &pIds->nCJKFont;
124 : 0 : pCTL = &pIds->nCTLFont;
125 : 0 : break;
126 : :
127 : : case SID_ATTR_CHAR_FONTHEIGHT:
128 : 0 : pNormal = &pIds->nFontHeight;
129 : 0 : pCJK = &pIds->nCJKFontHeight;
130 : 0 : pCTL = &pIds->nCTLFontHeight;
131 : 0 : break;
132 : :
133 : : case SID_ATTR_CHAR_POSTURE:
134 : 0 : pNormal = &pIds->nPosture;
135 : 0 : pCJK = &pIds->nCJKPosture;
136 : 0 : pCTL = &pIds->nCTLPosture;
137 : 0 : break;
138 : :
139 : : case SID_ATTR_CHAR_WEIGHT:
140 : 0 : pNormal = &pIds->nWeight;
141 : 0 : pCJK = &pIds->nCJKWeight;
142 : 0 : pCTL = &pIds->nCTLWeight;
143 : 0 : break;
144 : :
145 : : case SID_ATTR_CHAR_LANGUAGE:
146 : 0 : pNormal = &pIds->nLanguage;
147 : 0 : pCJK = &pIds->nCJKLanguage;
148 : 0 : pCTL = &pIds->nCTLLanguage;
149 : 0 : break;
150 : :
151 : : case 0:
152 : : // it exist no WhichId - don't set this item
153 : 0 : break;
154 : :
155 : : default:
156 : 0 : rSet.Put( rItem );
157 : 0 : break;
158 : : }
159 : :
160 : :
161 [ # # ]: 0 : if( DOUBLEBYTE_CHARTYPE == eType )
162 : : {
163 [ # # ][ # # ]: 0 : if( bIsLeftToRightDef && *pCJK )
164 : : {
165 : 0 : rItem.SetWhich( *pCJK );
166 : 0 : rSet.Put( rItem );
167 : : }
168 : : }
169 [ # # ]: 0 : else if( !bIsLeftToRightDef )
170 : : {
171 [ # # ]: 0 : if( *pCTL )
172 : : {
173 : 0 : rItem.SetWhich( *pCTL );
174 : 0 : rSet.Put( rItem );
175 : : }
176 : : }
177 : : else
178 : : {
179 [ # # ]: 0 : if( LOW_CHARTYPE == eType )
180 : : {
181 [ # # ]: 0 : if( *pNormal )
182 : : {
183 : 0 : rItem.SetWhich( *pNormal );
184 : 0 : rSet.Put( rItem );
185 : : }
186 : : }
187 [ # # ]: 0 : else if( HIGH_CHARTYPE == eType )
188 : : {
189 [ # # ]: 0 : if( *pCTL )
190 : : {
191 : 0 : rItem.SetWhich( *pCTL );
192 : 0 : rSet.Put( rItem );
193 : : }
194 : : }
195 : : else
196 : : {
197 [ # # ]: 0 : if( *pCJK )
198 : : {
199 : 0 : rItem.SetWhich( *pCJK );
200 : 0 : rSet.Put( rItem );
201 : : }
202 [ # # ]: 0 : if( *pCTL )
203 : : {
204 : 0 : rItem.SetWhich( *pCTL );
205 : 0 : rSet.Put( rItem );
206 : : }
207 [ # # ]: 0 : if( *pNormal )
208 : : {
209 : 0 : rItem.SetWhich( *pNormal );
210 : 0 : rSet.Put( rItem );
211 : : }
212 : : }
213 : : }
214 : 0 : }
215 : :
216 : : // --------------------
217 : :
218 : 0 : void SvxRTFParser::ReadAttr( int nToken, SfxItemSet* pSet )
219 : : {
220 : : DBG_ASSERT( pSet, "A SfxItemSet has to be provided as argument!" );
221 : 0 : int bFirstToken = sal_True, bWeiter = sal_True;
222 : 0 : sal_uInt16 nStyleNo = 0; // default
223 : : FontUnderline eUnderline;
224 : : FontUnderline eOverline;
225 : : FontEmphasisMark eEmphasis;
226 : 0 : bPardTokenRead = sal_False;
227 : 0 : RTF_CharTypeDef eCharType = NOTDEF_CHARTYPE;
228 : : sal_uInt16 nFontAlign;
229 : :
230 [ # # ][ # # ]: 0 : int bChkStkPos = !bNewGroup && !aAttrStack.empty();
231 : :
232 [ # # ][ # # ]: 0 : while( bWeiter && IsParserWorking() ) // as long as known Attribute are recognized
[ # # ]
233 : : {
234 [ # # # ]: 0 : switch( nToken )
235 : : {
236 : : case RTF_PARD:
237 : 0 : RTFPardPlain( sal_True, &pSet );
238 : 0 : ResetPard();
239 : 0 : nStyleNo = 0;
240 : 0 : bPardTokenRead = sal_True;
241 : 0 : break;
242 : :
243 : : case RTF_PLAIN:
244 : 0 : RTFPardPlain( sal_False, &pSet );
245 : 0 : break;
246 : :
247 : : default:
248 : : do { // middle checked loop
249 [ # # ]: 0 : if( !bChkStkPos )
250 : 0 : break;
251 : :
252 [ # # ]: 0 : SvxRTFItemStackType* pAkt = aAttrStack.empty() ? 0 : aAttrStack.back();
253 [ # # ]: 0 : if( !pAkt || (pAkt->pSttNd->GetIdx() == pInsPos->GetNodeIdx() &&
[ # # # # ]
[ # # ]
254 : 0 : pAkt->nSttCnt == pInsPos->GetCntIdx() ))
255 : 0 : break;
256 : :
257 : 0 : int nLastToken = GetStackPtr(-1)->nTokenId;
258 [ # # ][ # # ]: 0 : if( RTF_PARD == nLastToken || RTF_PLAIN == nLastToken )
259 : 0 : break;
260 : :
261 [ # # ][ # # ]: 0 : if( pAkt->aAttrSet.Count() || pAkt->pChildList ||
[ # # ][ # # ]
262 : : pAkt->nStyleNo )
263 : : {
264 : : // Open a new Group
265 : : SvxRTFItemStackType* pNew = new SvxRTFItemStackType(
266 [ # # ][ # # ]: 0 : *pAkt, *pInsPos, sal_True );
267 [ # # ][ # # ]: 0 : pNew->SetRTFDefaults( GetRTFDefaults() );
268 : :
269 : : // "Set" all valid attributes up until this point
270 [ # # ]: 0 : AttrGroupEnd();
271 [ # # ][ # # ]: 0 : pAkt = aAttrStack.empty() ? 0 : aAttrStack.back(); // can be changed after AttrGroupEnd!
272 [ # # ]: 0 : pNew->aAttrSet.SetParent( pAkt ? &pAkt->aAttrSet : 0 );
273 : :
274 [ # # ]: 0 : aAttrStack.push_back( pNew );
275 : 0 : pAkt = pNew;
276 : : }
277 : : else
278 : : // continue to use this entry as a new one
279 : 0 : pAkt->SetStartPos( *pInsPos );
280 : :
281 : 0 : pSet = &pAkt->aAttrSet;
282 : : } while( sal_False );
283 : :
284 [ # # # # : 0 : switch( nToken )
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# ]
285 : : {
286 : : case RTF_INTBL:
287 : : case RTF_PAGEBB:
288 : : case RTF_SBYS:
289 : : case RTF_CS:
290 : : case RTF_LS:
291 : : case RTF_ILVL:
292 : 0 : UnknownAttrToken( nToken, pSet );
293 : 0 : break;
294 : :
295 : : case RTF_S:
296 [ # # ]: 0 : if( bIsInReadStyleTab )
297 : : {
298 [ # # ]: 0 : if( !bFirstToken )
299 : 0 : SkipToken( -1 );
300 : 0 : bWeiter = sal_False;
301 : : }
302 : : else
303 : : {
304 [ # # ]: 0 : nStyleNo = -1 == nTokenValue ? 0 : sal_uInt16(nTokenValue);
305 : : // setze am akt. auf dem AttrStack stehenden Style die
306 : : // StyleNummer
307 [ # # ]: 0 : SvxRTFItemStackType* pAkt = aAttrStack.empty() ? 0 : aAttrStack.back();
308 [ # # ]: 0 : if( !pAkt )
309 : 0 : break;
310 : :
311 : 0 : pAkt->nStyleNo = sal_uInt16( nStyleNo );
312 : :
313 : : }
314 : 0 : break;
315 : :
316 : : case RTF_KEEP:
317 [ # # ]: 0 : if( PARDID->nSplit )
318 : : {
319 [ # # ]: 0 : pSet->Put( SvxFmtSplitItem( sal_False, PARDID->nSplit ));
320 : : }
321 : 0 : break;
322 : :
323 : : case RTF_KEEPN:
324 [ # # ]: 0 : if( PARDID->nKeep )
325 : : {
326 [ # # ]: 0 : pSet->Put( SvxFmtKeepItem( sal_True, PARDID->nKeep ));
327 : : }
328 : 0 : break;
329 : :
330 : : case RTF_LEVEL:
331 [ # # ]: 0 : if( PARDID->nOutlineLvl )
332 : : {
333 : 0 : pSet->Put( SfxUInt16Item( PARDID->nOutlineLvl,
334 [ # # ]: 0 : (sal_uInt16)nTokenValue ));
335 : : }
336 : 0 : break;
337 : :
338 : : case RTF_QL:
339 [ # # ]: 0 : if( PARDID->nAdjust )
340 : : {
341 [ # # ]: 0 : pSet->Put( SvxAdjustItem( SVX_ADJUST_LEFT, PARDID->nAdjust ));
342 : : }
343 : 0 : break;
344 : : case RTF_QR:
345 [ # # ]: 0 : if( PARDID->nAdjust )
346 : : {
347 [ # # ]: 0 : pSet->Put( SvxAdjustItem( SVX_ADJUST_RIGHT, PARDID->nAdjust ));
348 : : }
349 : 0 : break;
350 : : case RTF_QJ:
351 [ # # ]: 0 : if( PARDID->nAdjust )
352 : : {
353 [ # # ]: 0 : pSet->Put( SvxAdjustItem( SVX_ADJUST_BLOCK, PARDID->nAdjust ));
354 : : }
355 : 0 : break;
356 : : case RTF_QC:
357 [ # # ]: 0 : if( PARDID->nAdjust )
358 : : {
359 [ # # ]: 0 : pSet->Put( SvxAdjustItem( SVX_ADJUST_CENTER, PARDID->nAdjust ));
360 : : }
361 : 0 : break;
362 : :
363 : : case RTF_FI:
364 [ # # ]: 0 : if( PARDID->nLRSpace )
365 : : {
366 [ # # ][ # # ]: 0 : SvxLRSpaceItem aLR( GetLRSpace(*pSet, PARDID->nLRSpace ));
[ # # ]
367 : 0 : sal_uInt16 nSz = 0;
368 [ # # ]: 0 : if( -1 != nTokenValue )
369 : : {
370 [ # # ]: 0 : if( IsCalcValue() )
371 [ # # ]: 0 : CalcValue();
372 : 0 : nSz = sal_uInt16(nTokenValue);
373 : : }
374 [ # # ]: 0 : aLR.SetTxtFirstLineOfst( nSz );
375 [ # # ][ # # ]: 0 : pSet->Put( aLR );
376 : : }
377 : 0 : break;
378 : :
379 : : case RTF_LI:
380 : : case RTF_LIN:
381 [ # # ]: 0 : if( PARDID->nLRSpace )
382 : : {
383 [ # # ][ # # ]: 0 : SvxLRSpaceItem aLR( GetLRSpace(*pSet, PARDID->nLRSpace ));
[ # # ]
384 : 0 : sal_uInt16 nSz = 0;
385 [ # # ]: 0 : if( 0 < nTokenValue )
386 : : {
387 [ # # ]: 0 : if( IsCalcValue() )
388 [ # # ]: 0 : CalcValue();
389 : 0 : nSz = sal_uInt16(nTokenValue);
390 : : }
391 [ # # ]: 0 : aLR.SetTxtLeft( nSz );
392 [ # # ][ # # ]: 0 : pSet->Put( aLR );
393 : : }
394 : 0 : break;
395 : :
396 : : case RTF_RI:
397 : : case RTF_RIN:
398 [ # # ]: 0 : if( PARDID->nLRSpace )
399 : : {
400 [ # # ][ # # ]: 0 : SvxLRSpaceItem aLR( GetLRSpace(*pSet, PARDID->nLRSpace ));
[ # # ]
401 : 0 : sal_uInt16 nSz = 0;
402 [ # # ]: 0 : if( 0 < nTokenValue )
403 : : {
404 [ # # ]: 0 : if( IsCalcValue() )
405 [ # # ]: 0 : CalcValue();
406 : 0 : nSz = sal_uInt16(nTokenValue);
407 : : }
408 : 0 : aLR.SetRight( nSz );
409 [ # # ][ # # ]: 0 : pSet->Put( aLR );
410 : : }
411 : 0 : break;
412 : :
413 : : case RTF_SB:
414 [ # # ]: 0 : if( PARDID->nULSpace )
415 : : {
416 [ # # ][ # # ]: 0 : SvxULSpaceItem aUL( GetULSpace(*pSet, PARDID->nULSpace ));
[ # # ]
417 : 0 : sal_uInt16 nSz = 0;
418 [ # # ]: 0 : if( 0 < nTokenValue )
419 : : {
420 [ # # ]: 0 : if( IsCalcValue() )
421 [ # # ]: 0 : CalcValue();
422 : 0 : nSz = sal_uInt16(nTokenValue);
423 : : }
424 : 0 : aUL.SetUpper( nSz );
425 [ # # ][ # # ]: 0 : pSet->Put( aUL );
426 : : }
427 : 0 : break;
428 : :
429 : : case RTF_SA:
430 [ # # ]: 0 : if( PARDID->nULSpace )
431 : : {
432 [ # # ][ # # ]: 0 : SvxULSpaceItem aUL( GetULSpace(*pSet, PARDID->nULSpace ));
[ # # ]
433 : 0 : sal_uInt16 nSz = 0;
434 [ # # ]: 0 : if( 0 < nTokenValue )
435 : : {
436 [ # # ]: 0 : if( IsCalcValue() )
437 [ # # ]: 0 : CalcValue();
438 : 0 : nSz = sal_uInt16(nTokenValue);
439 : : }
440 : 0 : aUL.SetLower( nSz );
441 [ # # ][ # # ]: 0 : pSet->Put( aUL );
442 : : }
443 : 0 : break;
444 : :
445 : : case RTF_SLMULT:
446 [ # # ][ # # ]: 0 : if( PARDID->nLinespacing && 1 == nTokenValue )
[ # # ]
447 : : {
448 : : // then switches to multi-line!
449 : : SvxLineSpacingItem aLSpace( GetLineSpacing( *pSet,
450 [ # # ][ # # ]: 0 : PARDID->nLinespacing, sal_False ));
[ # # ]
451 : :
452 : : // how much do you get from the line height value?
453 : :
454 : : // Proportional-Size:
455 : : // Ie, the ratio is (n / 240) twips
456 : :
457 : 0 : nTokenValue = 240;
458 [ # # ]: 0 : if( IsCalcValue() )
459 [ # # ]: 0 : CalcValue();
460 : :
461 : 0 : nTokenValue = short( 100L * aLSpace.GetLineHeight()
462 : 0 : / long( nTokenValue ) );
463 : :
464 [ # # ]: 0 : if( nTokenValue > 200 ) // Data value for PropLnSp
465 : 0 : nTokenValue = 200; // is one BYTE !!!
466 : :
467 : 0 : aLSpace.SetPropLineSpace( (const sal_uInt8)nTokenValue );
468 : 0 : aLSpace.GetLineSpaceRule() = SVX_LINE_SPACE_AUTO;
469 : :
470 [ # # ][ # # ]: 0 : pSet->Put( aLSpace );
471 : : }
472 : 0 : break;
473 : :
474 : : case RTF_SL:
475 [ # # ]: 0 : if( PARDID->nLinespacing )
476 : : {
477 : : // Calculate the ratio between the default font and the
478 : : // specified size. The distance consists of the line height
479 : : // (100%) and the space above the line (20%).
480 [ # # ][ # # ]: 0 : SvxLineSpacingItem aLSpace(0, PARDID->nLinespacing);
481 : :
482 [ # # ]: 0 : nTokenValue = !bTokenHasValue ? 0 : nTokenValue;
483 [ # # ]: 0 : if (1000 == nTokenValue )
484 : 0 : nTokenValue = 240;
485 : :
486 : : SvxLineSpace eLnSpc;
487 [ # # ]: 0 : if (nTokenValue < 0)
488 : : {
489 : 0 : eLnSpc = SVX_LINE_SPACE_FIX;
490 : 0 : nTokenValue = -nTokenValue;
491 : : }
492 [ # # ]: 0 : else if (nTokenValue == 0)
493 : : {
494 : : //if \sl0 is used, the line spacing is automatically
495 : : //determined
496 : 0 : eLnSpc = SVX_LINE_SPACE_AUTO;
497 : : }
498 : : else
499 : 0 : eLnSpc = SVX_LINE_SPACE_MIN;
500 : :
501 [ # # ]: 0 : if (IsCalcValue())
502 [ # # ]: 0 : CalcValue();
503 : :
504 [ # # ]: 0 : if (eLnSpc != SVX_LINE_SPACE_AUTO)
505 : 0 : aLSpace.SetLineHeight( (const sal_uInt16)nTokenValue );
506 : :
507 : 0 : aLSpace.GetLineSpaceRule() = eLnSpc;
508 [ # # ][ # # ]: 0 : pSet->Put(aLSpace);
509 : : }
510 : 0 : break;
511 : :
512 : : case RTF_NOCWRAP:
513 [ # # ]: 0 : if( PARDID->nForbRule )
514 : : {
515 : : pSet->Put( SvxForbiddenRuleItem( sal_False,
516 [ # # ]: 0 : PARDID->nForbRule ));
517 : : }
518 : 0 : break;
519 : : case RTF_NOOVERFLOW:
520 [ # # ]: 0 : if( PARDID->nHangPunct )
521 : : {
522 : : pSet->Put( SvxHangingPunctuationItem( sal_False,
523 [ # # ]: 0 : PARDID->nHangPunct ));
524 : : }
525 : 0 : break;
526 : :
527 : : case RTF_ASPALPHA:
528 [ # # ]: 0 : if( PARDID->nScriptSpace )
529 : : {
530 : : pSet->Put( SvxScriptSpaceItem( sal_True,
531 [ # # ]: 0 : PARDID->nScriptSpace ));
532 : : }
533 : 0 : break;
534 : :
535 : : case RTF_FAFIXED:
536 : 0 : case RTF_FAAUTO: nFontAlign = SvxParaVertAlignItem::AUTOMATIC;
537 : 0 : goto SET_FONTALIGNMENT;
538 : 0 : case RTF_FAHANG: nFontAlign = SvxParaVertAlignItem::TOP;
539 : 0 : goto SET_FONTALIGNMENT;
540 : 0 : case RTF_FAVAR: nFontAlign = SvxParaVertAlignItem::BOTTOM;
541 : 0 : goto SET_FONTALIGNMENT;
542 : 0 : case RTF_FACENTER: nFontAlign = SvxParaVertAlignItem::CENTER;
543 : 0 : goto SET_FONTALIGNMENT;
544 : 0 : case RTF_FAROMAN: nFontAlign = SvxParaVertAlignItem::BASELINE;
545 : 0 : goto SET_FONTALIGNMENT;
546 : : SET_FONTALIGNMENT:
547 [ # # ]: 0 : if( PARDID->nFontAlign )
548 : : {
549 : : pSet->Put( SvxParaVertAlignItem( nFontAlign,
550 [ # # ]: 0 : PARDID->nFontAlign ));
551 : : }
552 : 0 : break;
553 : :
554 : : case RTF_B:
555 : : case RTF_AB:
556 [ # # ]: 0 : if( IsAttrSttPos() ) // not in the text flow?
557 : : {
558 : :
559 : : SvxWeightItem aTmpItem(
560 : : nTokenValue ? WEIGHT_BOLD : WEIGHT_NORMAL,
561 [ # # ][ # # ]: 0 : SID_ATTR_CHAR_WEIGHT );
562 [ # # ][ # # ]: 0 : SetScriptAttr( eCharType, *pSet, aTmpItem);
563 : : }
564 : 0 : break;
565 : :
566 : : case RTF_CAPS:
567 : : case RTF_SCAPS:
568 [ # # # # ]: 0 : if( PLAINID->nCaseMap &&
[ # # ]
569 : 0 : IsAttrSttPos() ) // not in the text flow?
570 : : {
571 : : SvxCaseMap eCaseMap;
572 [ # # ]: 0 : if( !nTokenValue )
573 : 0 : eCaseMap = SVX_CASEMAP_NOT_MAPPED;
574 [ # # ]: 0 : else if( RTF_CAPS == nToken )
575 : 0 : eCaseMap = SVX_CASEMAP_VERSALIEN;
576 : : else
577 : 0 : eCaseMap = SVX_CASEMAP_KAPITAELCHEN;
578 : :
579 [ # # ]: 0 : pSet->Put( SvxCaseMapItem( eCaseMap, PLAINID->nCaseMap ));
580 : : }
581 : 0 : break;
582 : :
583 : : case RTF_DN:
584 : : case RTF_SUB:
585 [ # # ]: 0 : if( PLAINID->nEscapement )
586 : : {
587 : 0 : const sal_uInt16 nEsc = PLAINID->nEscapement;
588 [ # # ][ # # ]: 0 : if( -1 == nTokenValue || RTF_SUB == nToken )
589 : 0 : nTokenValue = 6;
590 [ # # ]: 0 : if( IsCalcValue() )
591 : 0 : CalcValue();
592 : 0 : const SvxEscapementItem& rOld = GetEscapement( *pSet, nEsc, sal_False );
593 : : short nEs;
594 : : sal_uInt8 nProp;
595 [ # # ]: 0 : if( DFLT_ESC_AUTO_SUPER == rOld.GetEsc() )
596 : : {
597 : 0 : nEs = DFLT_ESC_AUTO_SUB;
598 : 0 : nProp = rOld.GetProp();
599 : : }
600 : : else
601 : : {
602 : 0 : nEs = (short)-nTokenValue;
603 [ # # ]: 0 : nProp = (nToken == RTF_SUB) ? DFLT_ESC_PROP : 100;
604 : : }
605 [ # # ]: 0 : pSet->Put( SvxEscapementItem( nEs, nProp, nEsc ));
606 : : }
607 : 0 : break;
608 : :
609 : : case RTF_NOSUPERSUB:
610 [ # # ]: 0 : if( PLAINID->nEscapement )
611 : : {
612 : 0 : const sal_uInt16 nEsc = PLAINID->nEscapement;
613 [ # # ]: 0 : pSet->Put( SvxEscapementItem( nEsc ));
614 : : }
615 : 0 : break;
616 : :
617 : : case RTF_EXPND:
618 [ # # ]: 0 : if( PLAINID->nKering )
619 : : {
620 [ # # ]: 0 : if( -1 == nTokenValue )
621 : 0 : nTokenValue = 0;
622 : : else
623 : 0 : nTokenValue *= 5;
624 [ # # ]: 0 : if( IsCalcValue() )
625 : 0 : CalcValue();
626 [ # # ]: 0 : pSet->Put( SvxKerningItem( (short)nTokenValue, PLAINID->nKering ));
627 : : }
628 : 0 : break;
629 : :
630 : : case RTF_KERNING:
631 [ # # ]: 0 : if( PLAINID->nAutoKerning )
632 : : {
633 [ # # ]: 0 : if( -1 == nTokenValue )
634 : 0 : nTokenValue = 0;
635 : : else
636 : 0 : nTokenValue *= 10;
637 [ # # ]: 0 : if( IsCalcValue() )
638 : 0 : CalcValue();
639 : : pSet->Put( SvxAutoKernItem( 0 != nTokenValue,
640 [ # # ]: 0 : PLAINID->nAutoKerning ));
641 : : }
642 : 0 : break;
643 : :
644 : : case RTF_EXPNDTW:
645 [ # # ]: 0 : if( PLAINID->nKering )
646 : : {
647 [ # # ]: 0 : if( -1 == nTokenValue )
648 : 0 : nTokenValue = 0;
649 [ # # ]: 0 : if( IsCalcValue() )
650 : 0 : CalcValue();
651 [ # # ]: 0 : pSet->Put( SvxKerningItem( (short)nTokenValue, PLAINID->nKering ));
652 : : }
653 : 0 : break;
654 : :
655 : : case RTF_F:
656 : : case RTF_AF:
657 : : {
658 [ # # ]: 0 : const Font& rSVFont = GetFont( sal_uInt16(nTokenValue) );
659 : : SvxFontItem aTmpItem( rSVFont.GetFamily(),
660 [ # # ][ # # ]: 0 : rSVFont.GetName(), rSVFont.GetStyleName(),
661 [ # # ]: 0 : rSVFont.GetPitch(), rSVFont.GetCharSet(),
662 [ # # ][ # # ]: 0 : SID_ATTR_CHAR_FONT );
[ # # ]
663 [ # # ]: 0 : SetScriptAttr( eCharType, *pSet, aTmpItem );
664 [ # # ]: 0 : if( RTF_F == nToken )
665 : : {
666 [ # # ][ # # ]: 0 : SetEncoding( rSVFont.GetCharSet() );
667 [ # # ]: 0 : RereadLookahead();
668 [ # # ]: 0 : }
669 : : }
670 : 0 : break;
671 : :
672 : : case RTF_FS:
673 : : case RTF_AFS:
674 : : {
675 [ # # ]: 0 : if( -1 == nTokenValue )
676 : 0 : nTokenValue = 240;
677 : : else
678 : 0 : nTokenValue *= 10;
679 : : // #i66167#
680 : : // for the SwRTFParser 'IsCalcValue' will be false and for the EditRTFParser
681 : : // the converiosn takes now place in EditRTFParser since for other reasons
682 : : // the wrong MapUnit might still be use there
683 : : // if( IsCalcValue() )
684 : : // CalcValue();
685 : : SvxFontHeightItem aTmpItem(
686 : : (const sal_uInt16)nTokenValue, 100,
687 [ # # ]: 0 : SID_ATTR_CHAR_FONTHEIGHT );
688 [ # # ][ # # ]: 0 : SetScriptAttr( eCharType, *pSet, aTmpItem );
689 : : }
690 : 0 : break;
691 : :
692 : : case RTF_I:
693 : : case RTF_AI:
694 [ # # ]: 0 : if( IsAttrSttPos() ) // not in the text flow?
695 : : {
696 : : SvxPostureItem aTmpItem(
697 : : nTokenValue ? ITALIC_NORMAL : ITALIC_NONE,
698 [ # # ][ # # ]: 0 : SID_ATTR_CHAR_POSTURE );
699 [ # # ][ # # ]: 0 : SetScriptAttr( eCharType, *pSet, aTmpItem );
700 : : }
701 : 0 : break;
702 : :
703 : : case RTF_OUTL:
704 [ # # # # ]: 0 : if( PLAINID->nContour &&
[ # # ]
705 : 0 : IsAttrSttPos() ) // not in the text flow?
706 : : {
707 : : pSet->Put( SvxContourItem( nTokenValue ? sal_True : sal_False,
708 [ # # ][ # # ]: 0 : PLAINID->nContour ));
709 : : }
710 : 0 : break;
711 : :
712 : : case RTF_SHAD:
713 [ # # # # ]: 0 : if( PLAINID->nShadowed &&
[ # # ]
714 : 0 : IsAttrSttPos() ) // not in the text flow?
715 : : {
716 : : pSet->Put( SvxShadowedItem( nTokenValue ? sal_True : sal_False,
717 [ # # ][ # # ]: 0 : PLAINID->nShadowed ));
718 : : }
719 : 0 : break;
720 : :
721 : : case RTF_STRIKE:
722 [ # # # # ]: 0 : if( PLAINID->nCrossedOut &&
[ # # ]
723 : 0 : IsAttrSttPos() ) // not in the text flow?
724 : : {
725 : : pSet->Put( SvxCrossedOutItem(
726 : : nTokenValue ? STRIKEOUT_SINGLE : STRIKEOUT_NONE,
727 [ # # ][ # # ]: 0 : PLAINID->nCrossedOut ));
728 : : }
729 : 0 : break;
730 : :
731 : : case RTF_STRIKED:
732 [ # # ]: 0 : if( PLAINID->nCrossedOut ) // not in the text flow?
733 : : {
734 : : pSet->Put( SvxCrossedOutItem(
735 : : nTokenValue ? STRIKEOUT_DOUBLE : STRIKEOUT_NONE,
736 [ # # ][ # # ]: 0 : PLAINID->nCrossedOut ));
737 : : }
738 : 0 : break;
739 : :
740 : : case RTF_UL:
741 [ # # ]: 0 : if( !IsAttrSttPos() )
742 : 0 : break;
743 [ # # ]: 0 : eUnderline = nTokenValue ? UNDERLINE_SINGLE : UNDERLINE_NONE;
744 : 0 : goto ATTR_SETUNDERLINE;
745 : :
746 : : case RTF_ULD:
747 : 0 : eUnderline = UNDERLINE_DOTTED;
748 : 0 : goto ATTR_SETUNDERLINE;
749 : : case RTF_ULDASH:
750 : 0 : eUnderline = UNDERLINE_DASH;
751 : 0 : goto ATTR_SETUNDERLINE;
752 : : case RTF_ULDASHD:
753 : 0 : eUnderline = UNDERLINE_DASHDOT;
754 : 0 : goto ATTR_SETUNDERLINE;
755 : : case RTF_ULDASHDD:
756 : 0 : eUnderline = UNDERLINE_DASHDOTDOT;
757 : 0 : goto ATTR_SETUNDERLINE;
758 : : case RTF_ULDB:
759 : 0 : eUnderline = UNDERLINE_DOUBLE;
760 : 0 : goto ATTR_SETUNDERLINE;
761 : : case RTF_ULNONE:
762 : 0 : eUnderline = UNDERLINE_NONE;
763 : 0 : goto ATTR_SETUNDERLINE;
764 : : case RTF_ULTH:
765 : 0 : eUnderline = UNDERLINE_BOLD;
766 : 0 : goto ATTR_SETUNDERLINE;
767 : : case RTF_ULWAVE:
768 : 0 : eUnderline = UNDERLINE_WAVE;
769 : 0 : goto ATTR_SETUNDERLINE;
770 : : case RTF_ULTHD:
771 : 0 : eUnderline = UNDERLINE_BOLDDOTTED;
772 : 0 : goto ATTR_SETUNDERLINE;
773 : : case RTF_ULTHDASH:
774 : 0 : eUnderline = UNDERLINE_BOLDDASH;
775 : 0 : goto ATTR_SETUNDERLINE;
776 : : case RTF_ULLDASH:
777 : 0 : eUnderline = UNDERLINE_LONGDASH;
778 : 0 : goto ATTR_SETUNDERLINE;
779 : : case RTF_ULTHLDASH:
780 : 0 : eUnderline = UNDERLINE_BOLDLONGDASH;
781 : 0 : goto ATTR_SETUNDERLINE;
782 : : case RTF_ULTHDASHD:
783 : 0 : eUnderline = UNDERLINE_BOLDDASHDOT;
784 : 0 : goto ATTR_SETUNDERLINE;
785 : : case RTF_ULTHDASHDD:
786 : 0 : eUnderline = UNDERLINE_BOLDDASHDOTDOT;
787 : 0 : goto ATTR_SETUNDERLINE;
788 : : case RTF_ULHWAVE:
789 : 0 : eUnderline = UNDERLINE_BOLDWAVE;
790 : 0 : goto ATTR_SETUNDERLINE;
791 : : case RTF_ULULDBWAVE:
792 : 0 : eUnderline = UNDERLINE_DOUBLEWAVE;
793 : 0 : goto ATTR_SETUNDERLINE;
794 : :
795 : : case RTF_ULW:
796 : 0 : eUnderline = UNDERLINE_SINGLE;
797 : :
798 [ # # ]: 0 : if( PLAINID->nWordlineMode )
799 : : {
800 [ # # ]: 0 : pSet->Put( SvxWordLineModeItem( sal_True, PLAINID->nWordlineMode ));
801 : : }
802 : 0 : goto ATTR_SETUNDERLINE;
803 : :
804 : : ATTR_SETUNDERLINE:
805 [ # # ]: 0 : if( PLAINID->nUnderline )
806 : : {
807 [ # # ]: 0 : pSet->Put( SvxUnderlineItem( eUnderline, PLAINID->nUnderline ));
808 : : }
809 : 0 : break;
810 : :
811 : : case RTF_ULC:
812 [ # # ]: 0 : if( PLAINID->nUnderline )
813 : : {
814 [ # # ][ # # ]: 0 : SvxUnderlineItem aUL( UNDERLINE_SINGLE, PLAINID->nUnderline );
815 : : const SfxPoolItem* pItem;
816 [ # # ]: 0 : if( SFX_ITEM_SET == pSet->GetItemState(
817 [ # # ][ # # ]: 0 : PLAINID->nUnderline, sal_False, &pItem ) )
818 : : {
819 : : // is switched off ?
820 [ # # ]: 0 : if( UNDERLINE_NONE ==
821 : 0 : ((SvxUnderlineItem*)pItem)->GetLineStyle() )
822 : : break;
823 [ # # ]: 0 : aUL = *(SvxUnderlineItem*)pItem;
824 : : }
825 : : else
826 [ # # ][ # # ]: 0 : aUL = (const SvxUnderlineItem&)pSet->Get( PLAINID->nUnderline, sal_False );
[ # # ]
827 : :
828 [ # # ]: 0 : if( UNDERLINE_NONE == aUL.GetLineStyle() )
829 : 0 : aUL.SetLineStyle( UNDERLINE_SINGLE );
830 [ # # ]: 0 : aUL.SetColor( GetColor( sal_uInt16(nTokenValue) ));
831 [ # # ][ # # ]: 0 : pSet->Put( aUL );
[ # # ]
832 : : }
833 : 0 : break;
834 : :
835 : : case RTF_OL:
836 [ # # ]: 0 : if( !IsAttrSttPos() )
837 : 0 : break;
838 [ # # ]: 0 : eOverline = nTokenValue ? UNDERLINE_SINGLE : UNDERLINE_NONE;
839 : 0 : goto ATTR_SETOVERLINE;
840 : :
841 : : case RTF_OLD:
842 : 0 : eOverline = UNDERLINE_DOTTED;
843 : 0 : goto ATTR_SETOVERLINE;
844 : : case RTF_OLDASH:
845 : 0 : eOverline = UNDERLINE_DASH;
846 : 0 : goto ATTR_SETOVERLINE;
847 : : case RTF_OLDASHD:
848 : 0 : eOverline = UNDERLINE_DASHDOT;
849 : 0 : goto ATTR_SETOVERLINE;
850 : : case RTF_OLDASHDD:
851 : 0 : eOverline = UNDERLINE_DASHDOTDOT;
852 : 0 : goto ATTR_SETOVERLINE;
853 : : case RTF_OLDB:
854 : 0 : eOverline = UNDERLINE_DOUBLE;
855 : 0 : goto ATTR_SETOVERLINE;
856 : : case RTF_OLNONE:
857 : 0 : eOverline = UNDERLINE_NONE;
858 : 0 : goto ATTR_SETOVERLINE;
859 : : case RTF_OLTH:
860 : 0 : eOverline = UNDERLINE_BOLD;
861 : 0 : goto ATTR_SETOVERLINE;
862 : : case RTF_OLWAVE:
863 : 0 : eOverline = UNDERLINE_WAVE;
864 : 0 : goto ATTR_SETOVERLINE;
865 : : case RTF_OLTHD:
866 : 0 : eOverline = UNDERLINE_BOLDDOTTED;
867 : 0 : goto ATTR_SETOVERLINE;
868 : : case RTF_OLTHDASH:
869 : 0 : eOverline = UNDERLINE_BOLDDASH;
870 : 0 : goto ATTR_SETOVERLINE;
871 : : case RTF_OLLDASH:
872 : 0 : eOverline = UNDERLINE_LONGDASH;
873 : 0 : goto ATTR_SETOVERLINE;
874 : : case RTF_OLTHLDASH:
875 : 0 : eOverline = UNDERLINE_BOLDLONGDASH;
876 : 0 : goto ATTR_SETOVERLINE;
877 : : case RTF_OLTHDASHD:
878 : 0 : eOverline = UNDERLINE_BOLDDASHDOT;
879 : 0 : goto ATTR_SETOVERLINE;
880 : : case RTF_OLTHDASHDD:
881 : 0 : eOverline = UNDERLINE_BOLDDASHDOTDOT;
882 : 0 : goto ATTR_SETOVERLINE;
883 : : case RTF_OLHWAVE:
884 : 0 : eOverline = UNDERLINE_BOLDWAVE;
885 : 0 : goto ATTR_SETOVERLINE;
886 : : case RTF_OLOLDBWAVE:
887 : 0 : eOverline = UNDERLINE_DOUBLEWAVE;
888 : 0 : goto ATTR_SETOVERLINE;
889 : :
890 : : case RTF_OLW:
891 : 0 : eOverline = UNDERLINE_SINGLE;
892 : :
893 [ # # ]: 0 : if( PLAINID->nWordlineMode )
894 : : {
895 [ # # ]: 0 : pSet->Put( SvxWordLineModeItem( sal_True, PLAINID->nWordlineMode ));
896 : : }
897 : 0 : goto ATTR_SETOVERLINE;
898 : :
899 : : ATTR_SETOVERLINE:
900 [ # # ]: 0 : if( PLAINID->nUnderline )
901 : : {
902 [ # # ]: 0 : pSet->Put( SvxOverlineItem( eOverline, PLAINID->nOverline ));
903 : : }
904 : 0 : break;
905 : :
906 : : case RTF_OLC:
907 [ # # ]: 0 : if( PLAINID->nOverline )
908 : : {
909 [ # # ][ # # ]: 0 : SvxOverlineItem aOL( UNDERLINE_SINGLE, PLAINID->nOverline );
910 : : const SfxPoolItem* pItem;
911 [ # # ]: 0 : if( SFX_ITEM_SET == pSet->GetItemState(
912 [ # # ][ # # ]: 0 : PLAINID->nOverline, sal_False, &pItem ) )
913 : : {
914 : : // is switched off ?
915 [ # # ]: 0 : if( UNDERLINE_NONE ==
916 : 0 : ((SvxOverlineItem*)pItem)->GetLineStyle() )
917 : : break;
918 [ # # ]: 0 : aOL = *(SvxOverlineItem*)pItem;
919 : : }
920 : : else
921 [ # # ][ # # ]: 0 : aOL = (const SvxOverlineItem&)pSet->Get( PLAINID->nUnderline, sal_False );
[ # # ]
922 : :
923 [ # # ]: 0 : if( UNDERLINE_NONE == aOL.GetLineStyle() )
924 : 0 : aOL.SetLineStyle( UNDERLINE_SINGLE );
925 [ # # ]: 0 : aOL.SetColor( GetColor( sal_uInt16(nTokenValue) ));
926 [ # # ][ # # ]: 0 : pSet->Put( aOL );
[ # # ]
927 : : }
928 : 0 : break;
929 : :
930 : : case RTF_UP:
931 : : case RTF_SUPER:
932 [ # # ]: 0 : if( PLAINID->nEscapement )
933 : : {
934 : 0 : const sal_uInt16 nEsc = PLAINID->nEscapement;
935 [ # # ][ # # ]: 0 : if( -1 == nTokenValue || RTF_SUPER == nToken )
936 : 0 : nTokenValue = 6;
937 [ # # ]: 0 : if( IsCalcValue() )
938 : 0 : CalcValue();
939 : 0 : const SvxEscapementItem& rOld = GetEscapement( *pSet, nEsc, sal_False );
940 : : short nEs;
941 : : sal_uInt8 nProp;
942 [ # # ]: 0 : if( DFLT_ESC_AUTO_SUB == rOld.GetEsc() )
943 : : {
944 : 0 : nEs = DFLT_ESC_AUTO_SUPER;
945 : 0 : nProp = rOld.GetProp();
946 : : }
947 : : else
948 : : {
949 : 0 : nEs = (short)nTokenValue;
950 [ # # ]: 0 : nProp = (nToken == RTF_SUPER) ? DFLT_ESC_PROP : 100;
951 : : }
952 [ # # ]: 0 : pSet->Put( SvxEscapementItem( nEs, nProp, nEsc ));
953 : : }
954 : 0 : break;
955 : :
956 : : case RTF_CF:
957 [ # # ]: 0 : if( PLAINID->nColor )
958 : : {
959 : 0 : pSet->Put( SvxColorItem( GetColor( sal_uInt16(nTokenValue) ),
960 [ # # ]: 0 : PLAINID->nColor ));
961 : : }
962 : 0 : break;
963 : : //#i12501# While cb is clearly documented in the rtf spec, word
964 : : //doesn't accept it at all
965 : : #if 0
966 : : case RTF_CB:
967 : : if( PLAINID->nBgColor )
968 : : {
969 : : pSet->Put( SvxBrushItem( GetColor( sal_uInt16(nTokenValue) ),
970 : : PLAINID->nBgColor ));
971 : : }
972 : : break;
973 : : #endif
974 : :
975 : : case RTF_LANG:
976 [ # # ]: 0 : if( PLAINID->nLanguage )
977 : : {
978 : : pSet->Put( SvxLanguageItem( (LanguageType)nTokenValue,
979 [ # # ]: 0 : PLAINID->nLanguage ));
980 : : }
981 : 0 : break;
982 : :
983 : : case RTF_LANGFE:
984 [ # # ]: 0 : if( PLAINID->nCJKLanguage )
985 : : {
986 : : pSet->Put( SvxLanguageItem( (LanguageType)nTokenValue,
987 [ # # ]: 0 : PLAINID->nCJKLanguage ));
988 : : }
989 : 0 : break;
990 : : case RTF_ALANG:
991 : : {
992 : : SvxLanguageItem aTmpItem( (LanguageType)nTokenValue,
993 [ # # ]: 0 : SID_ATTR_CHAR_LANGUAGE );
994 [ # # ][ # # ]: 0 : SetScriptAttr( eCharType, *pSet, aTmpItem );
995 : : }
996 : 0 : break;
997 : :
998 : : case RTF_RTLCH:
999 : 0 : bIsLeftToRightDef = sal_False;
1000 : 0 : break;
1001 : : case RTF_LTRCH:
1002 : 0 : bIsLeftToRightDef = sal_True;
1003 : 0 : break;
1004 : : case RTF_RTLPAR:
1005 [ # # ]: 0 : if (PARDID->nDirection)
1006 : : {
1007 : : pSet->Put(SvxFrameDirectionItem(FRMDIR_HORI_RIGHT_TOP,
1008 [ # # ]: 0 : PARDID->nDirection));
1009 : : }
1010 : 0 : break;
1011 : : case RTF_LTRPAR:
1012 [ # # ]: 0 : if (PARDID->nDirection)
1013 : : {
1014 : : pSet->Put(SvxFrameDirectionItem(FRMDIR_HORI_LEFT_TOP,
1015 [ # # ]: 0 : PARDID->nDirection));
1016 : : }
1017 : 0 : break;
1018 : 0 : case RTF_LOCH: eCharType = LOW_CHARTYPE; break;
1019 : 0 : case RTF_HICH: eCharType = HIGH_CHARTYPE; break;
1020 : 0 : case RTF_DBCH: eCharType = DOUBLEBYTE_CHARTYPE; break;
1021 : :
1022 : :
1023 : : case RTF_ACCNONE:
1024 : 0 : eEmphasis = EMPHASISMARK_NONE;
1025 : 0 : goto ATTR_SETEMPHASIS;
1026 : : case RTF_ACCDOT:
1027 : 0 : eEmphasis = EMPHASISMARK_DOTS_ABOVE;
1028 : 0 : goto ATTR_SETEMPHASIS;
1029 : :
1030 : : case RTF_ACCCOMMA:
1031 : 0 : eEmphasis = EMPHASISMARK_SIDE_DOTS;
1032 : : ATTR_SETEMPHASIS:
1033 [ # # ]: 0 : if( PLAINID->nEmphasis )
1034 : : {
1035 : : pSet->Put( SvxEmphasisMarkItem( eEmphasis,
1036 [ # # ]: 0 : PLAINID->nEmphasis ));
1037 : : }
1038 : 0 : break;
1039 : :
1040 : : case RTF_TWOINONE:
1041 [ # # ]: 0 : if( PLAINID->nTwoLines )
1042 : : {
1043 : : sal_Unicode cStt, cEnd;
1044 [ # # # # : 0 : switch ( nTokenValue )
# ]
1045 : : {
1046 : 0 : case 1: cStt = '(', cEnd = ')'; break;
1047 : 0 : case 2: cStt = '[', cEnd = ']'; break;
1048 : 0 : case 3: cStt = '<', cEnd = '>'; break;
1049 : 0 : case 4: cStt = '{', cEnd = '}'; break;
1050 : 0 : default: cStt = 0, cEnd = 0; break;
1051 : : }
1052 : :
1053 : : pSet->Put( SvxTwoLinesItem( sal_True, cStt, cEnd,
1054 [ # # ]: 0 : PLAINID->nTwoLines ));
1055 : : }
1056 : 0 : break;
1057 : :
1058 : : case RTF_CHARSCALEX :
1059 [ # # ]: 0 : if (PLAINID->nCharScaleX)
1060 : : {
1061 : : //i21372
1062 [ # # ][ # # ]: 0 : if (nTokenValue < 1 || nTokenValue > 600)
1063 : 0 : nTokenValue = 100;
1064 : : pSet->Put( SvxCharScaleWidthItem( sal_uInt16(nTokenValue),
1065 [ # # ]: 0 : PLAINID->nCharScaleX ));
1066 : : }
1067 : 0 : break;
1068 : :
1069 : : case RTF_HORZVERT:
1070 [ # # ]: 0 : if( PLAINID->nHorzVert )
1071 : : {
1072 : : // RTF knows only 90deg
1073 : : pSet->Put( SvxCharRotateItem( 900, 1 == nTokenValue,
1074 [ # # ]: 0 : PLAINID->nHorzVert ));
1075 : : }
1076 : 0 : break;
1077 : :
1078 : : case RTF_EMBO:
1079 [ # # ]: 0 : if (PLAINID->nRelief)
1080 : : {
1081 : : pSet->Put(SvxCharReliefItem(RELIEF_EMBOSSED,
1082 [ # # ]: 0 : PLAINID->nRelief));
1083 : : }
1084 : 0 : break;
1085 : : case RTF_IMPR:
1086 [ # # ]: 0 : if (PLAINID->nRelief)
1087 : : {
1088 : : pSet->Put(SvxCharReliefItem(RELIEF_ENGRAVED,
1089 [ # # ]: 0 : PLAINID->nRelief));
1090 : : }
1091 : 0 : break;
1092 : : case RTF_V:
1093 [ # # ]: 0 : if (PLAINID->nHidden)
1094 : : {
1095 : : pSet->Put(SvxCharHiddenItem(nTokenValue != 0,
1096 [ # # ]: 0 : PLAINID->nHidden));
1097 : : }
1098 : 0 : break;
1099 : : case RTF_CHBGFDIAG:
1100 : : case RTF_CHBGDKVERT:
1101 : : case RTF_CHBGDKHORIZ:
1102 : : case RTF_CHBGVERT:
1103 : : case RTF_CHBGHORIZ:
1104 : : case RTF_CHBGDKFDIAG:
1105 : : case RTF_CHBGDCROSS:
1106 : : case RTF_CHBGCROSS:
1107 : : case RTF_CHBGBDIAG:
1108 : : case RTF_CHBGDKDCROSS:
1109 : : case RTF_CHBGDKCROSS:
1110 : : case RTF_CHBGDKBDIAG:
1111 : : case RTF_CHCBPAT:
1112 : : case RTF_CHCFPAT:
1113 : : case RTF_CHSHDNG:
1114 [ # # ]: 0 : if( PLAINID->nBgColor )
1115 : 0 : ReadBackgroundAttr( nToken, *pSet );
1116 : 0 : break;
1117 : :
1118 : : case BRACELEFT:
1119 : : {
1120 : : // tests on Swg internal tokens
1121 : 0 : bool bHandled = false;
1122 : 0 : short nSkip = 0;
1123 [ # # ]: 0 : if( RTF_IGNOREFLAG != GetNextToken())
1124 : 0 : nSkip = -1;
1125 [ # # ]: 0 : else if( (nToken = GetNextToken() ) & RTF_SWGDEFS )
1126 : : {
1127 : 0 : bHandled = true;
1128 [ # # # # : 0 : switch( nToken )
# ]
1129 : : {
1130 : : case RTF_PGDSCNO:
1131 : : case RTF_PGBRK:
1132 : : case RTF_SOUTLVL:
1133 : 0 : UnknownAttrToken( nToken, pSet );
1134 : : // overwrite the closing parenthesis
1135 : 0 : break;
1136 : :
1137 : : case RTF_SWG_ESCPROP:
1138 : : {
1139 : : // Store percentage change!
1140 : 0 : sal_uInt8 nProp = sal_uInt8( nTokenValue / 100 );
1141 : 0 : short nEsc = 0;
1142 [ # # ]: 0 : if( 1 == ( nTokenValue % 100 ))
1143 : : // Recognize own auto-flags!
1144 : 0 : nEsc = DFLT_ESC_AUTO_SUPER;
1145 : :
1146 [ # # ]: 0 : if( PLAINID->nEscapement )
1147 : : pSet->Put( SvxEscapementItem( nEsc, nProp,
1148 [ # # ]: 0 : PLAINID->nEscapement ));
1149 : : }
1150 : 0 : break;
1151 : :
1152 : : case RTF_HYPHEN:
1153 : : {
1154 : : SvxHyphenZoneItem aHypenZone(
1155 : : (nTokenValue & 1) ? sal_True : sal_False,
1156 [ # # ][ # # ]: 0 : PARDID->nHyphenzone );
1157 : : aHypenZone.SetPageEnd(
1158 [ # # ]: 0 : (nTokenValue & 2) ? sal_True : sal_False );
1159 : :
1160 [ # # ][ # # ]: 0 : if( PARDID->nHyphenzone &&
[ # # ][ # # ]
[ # # ][ # # ]
1161 [ # # ]: 0 : RTF_HYPHLEAD == GetNextToken() &&
1162 [ # # ]: 0 : RTF_HYPHTRAIL == GetNextToken() &&
1163 [ # # ]: 0 : RTF_HYPHMAX == GetNextToken() )
1164 : : {
1165 : 0 : aHypenZone.GetMinLead() =
1166 [ # # ]: 0 : sal_uInt8(GetStackPtr( -2 )->nTokenValue);
1167 : 0 : aHypenZone.GetMinTrail() =
1168 [ # # ]: 0 : sal_uInt8(GetStackPtr( -1 )->nTokenValue);
1169 : 0 : aHypenZone.GetMaxHyphens() =
1170 : 0 : sal_uInt8(nTokenValue);
1171 : :
1172 [ # # ]: 0 : pSet->Put( aHypenZone );
1173 : : }
1174 : : else
1175 [ # # ][ # # ]: 0 : SkipGroup(); // at the end of the group
1176 : : }
1177 : 0 : break;
1178 : :
1179 : : case RTF_SHADOW:
1180 : : {
1181 : 0 : int bSkip = sal_True;
1182 : : do { // middle check loop
1183 : 0 : SvxShadowLocation eSL = SvxShadowLocation( nTokenValue );
1184 [ # # ][ # # ]: 0 : if( RTF_SHDW_DIST != GetNextToken() )
1185 : : break;
1186 : 0 : sal_uInt16 nDist = sal_uInt16( nTokenValue );
1187 : :
1188 [ # # ][ # # ]: 0 : if( RTF_SHDW_STYLE != GetNextToken() )
1189 : : break;
1190 : :
1191 [ # # ][ # # ]: 0 : if( RTF_SHDW_COL != GetNextToken() )
1192 : : break;
1193 : 0 : sal_uInt16 nCol = sal_uInt16( nTokenValue );
1194 : :
1195 [ # # ][ # # ]: 0 : if( RTF_SHDW_FCOL != GetNextToken() )
1196 : : break;
1197 : :
1198 [ # # ]: 0 : Color aColor = GetColor( nCol );
1199 : :
1200 [ # # ][ # # ]: 0 : if( PARDID->nShadow )
1201 [ # # ]: 0 : pSet->Put( SvxShadowItem( PARDID->nShadow,
1202 [ # # ][ # # ]: 0 : &aColor, nDist, eSL ) );
[ # # ]
1203 : :
1204 : 0 : bSkip = sal_False;
1205 : : } while( sal_False );
1206 : :
1207 [ # # ]: 0 : if( bSkip )
1208 : 0 : SkipGroup(); // at the end of the group
1209 : : }
1210 : 0 : break;
1211 : :
1212 : : default:
1213 : 0 : bHandled = false;
1214 [ # # ]: 0 : if( (nToken & ~(0xff | RTF_SWGDEFS)) == RTF_TABSTOPDEF )
1215 : : {
1216 : 0 : nToken = SkipToken( -2 );
1217 : 0 : ReadTabAttr( nToken, *pSet );
1218 : :
1219 : : /*
1220 : : cmc: #i76140, he who consumed the { must consume the }
1221 : : We rewound to a state of { being the current
1222 : : token so it is our responsibility to consume the }
1223 : : token if we consumed the {. We will not have consumed
1224 : : the { if it belonged to our caller, i.e. if the { we
1225 : : are handling is the "firsttoken" passed to us then
1226 : : the *caller* must consume it, not us. Otherwise *we*
1227 : : should consume it.
1228 : : */
1229 [ # # ][ # # ]: 0 : if (nToken == BRACELEFT && !bFirstToken)
1230 : : {
1231 : 0 : nToken = GetNextToken();
1232 : : DBG_ASSERT( nToken == BRACERIGHT,
1233 : : "} did not follow { as expected\n");
1234 : : }
1235 : : }
1236 [ # # ]: 0 : else if( (nToken & ~(0xff| RTF_SWGDEFS)) == RTF_BRDRDEF)
1237 : : {
1238 : 0 : nToken = SkipToken( -2 );
1239 : 0 : ReadBorderAttr( nToken, *pSet );
1240 : : }
1241 : : else // so no more attribute
1242 : 0 : nSkip = -2;
1243 : 0 : break;
1244 : : }
1245 : :
1246 : : #if 1
1247 : : /*
1248 : : cmc: #i4727# / #i12713# Who owns this closing bracket?
1249 : : If we read the opening one, we must read this one, if
1250 : : other is counting the brackets so as to push/pop off
1251 : : the correct environment then we will have pushed a new
1252 : : environment for the start { of this, but will not see
1253 : : the } and so is out of sync for the rest of the
1254 : : document.
1255 : : */
1256 [ # # ][ # # ]: 0 : if (bHandled && !bFirstToken)
1257 : 0 : GetNextToken();
1258 : : #endif
1259 : : }
1260 : : else
1261 : 0 : nSkip = -2;
1262 : :
1263 [ # # ]: 0 : if( nSkip ) // all completely unknown
1264 : : {
1265 [ # # ]: 0 : if (!bFirstToken)
1266 : 0 : --nSkip; // BRACELEFT: is the next token
1267 : 0 : SkipToken( nSkip );
1268 : 0 : bWeiter = sal_False;
1269 : : }
1270 : : }
1271 : 0 : break;
1272 : : default:
1273 [ # # ]: 0 : if( (nToken & ~0xff ) == RTF_TABSTOPDEF )
1274 : 0 : ReadTabAttr( nToken, *pSet );
1275 [ # # ]: 0 : else if( (nToken & ~0xff ) == RTF_BRDRDEF )
1276 : 0 : ReadBorderAttr( nToken, *pSet );
1277 [ # # ]: 0 : else if( (nToken & ~0xff ) == RTF_SHADINGDEF )
1278 : 0 : ReadBackgroundAttr( nToken, *pSet );
1279 : : else
1280 : : {
1281 : : // unknown token, so token "returned in Parser"
1282 [ # # ]: 0 : if( !bFirstToken )
1283 : 0 : SkipToken( -1 );
1284 : 0 : bWeiter = sal_False;
1285 : : }
1286 : : }
1287 : : }
1288 [ # # ]: 0 : if( bWeiter )
1289 : : {
1290 : 0 : nToken = GetNextToken();
1291 : : }
1292 : 0 : bFirstToken = sal_False;
1293 : : }
1294 : 0 : }
1295 : :
1296 : 0 : void SvxRTFParser::ReadTabAttr( int nToken, SfxItemSet& rSet )
1297 : : {
1298 : 0 : bool bMethodOwnsToken = false; // #i52542# patch from cmc.
1299 : : // then read all the TabStops
1300 [ # # ]: 0 : SvxTabStop aTabStop;
1301 [ # # ][ # # ]: 0 : SvxTabStopItem aAttr( 0, 0, SVX_TAB_ADJUST_DEFAULT, PARDID->nTabStop );
1302 : 0 : int bWeiter = sal_True;
1303 [ # # ]: 0 : do {
1304 [ # # # # : 0 : switch( nToken )
# # # # #
# # # ]
1305 : : {
1306 : : case RTF_TB: // BarTab ???
1307 : : case RTF_TX:
1308 : : {
1309 [ # # ]: 0 : if( IsCalcValue() )
1310 [ # # ]: 0 : CalcValue();
1311 : 0 : aTabStop.GetTabPos() = nTokenValue;
1312 [ # # ]: 0 : aAttr.Insert( aTabStop );
1313 [ # # ]: 0 : aTabStop = SvxTabStop(); // all values default
1314 : : }
1315 : 0 : break;
1316 : :
1317 : : case RTF_TQL:
1318 : 0 : aTabStop.GetAdjustment() = SVX_TAB_ADJUST_LEFT;
1319 : 0 : break;
1320 : : case RTF_TQR:
1321 : 0 : aTabStop.GetAdjustment() = SVX_TAB_ADJUST_RIGHT;
1322 : 0 : break;
1323 : : case RTF_TQC:
1324 : 0 : aTabStop.GetAdjustment() = SVX_TAB_ADJUST_CENTER;
1325 : 0 : break;
1326 : : case RTF_TQDEC:
1327 : 0 : aTabStop.GetAdjustment() = SVX_TAB_ADJUST_DECIMAL;
1328 : 0 : break;
1329 : :
1330 : 0 : case RTF_TLDOT: aTabStop.GetFill() = '.'; break;
1331 : 0 : case RTF_TLHYPH: aTabStop.GetFill() = ' '; break;
1332 : 0 : case RTF_TLUL: aTabStop.GetFill() = '_'; break;
1333 : 0 : case RTF_TLTH: aTabStop.GetFill() = '-'; break;
1334 : 0 : case RTF_TLEQ: aTabStop.GetFill() = '='; break;
1335 : :
1336 : : case BRACELEFT:
1337 : : {
1338 : : // Swg - control BRACELEFT RTF_IGNOREFLAG RTF_TLSWG BRACERIGHT
1339 : 0 : short nSkip = 0;
1340 [ # # ][ # # ]: 0 : if( RTF_IGNOREFLAG != GetNextToken() )
1341 : 0 : nSkip = -1;
1342 [ # # ][ # # ]: 0 : else if( RTF_TLSWG != ( nToken = GetNextToken() ))
1343 : 0 : nSkip = -2;
1344 : : else
1345 : : {
1346 [ # # ]: 0 : aTabStop.GetDecimal() = sal_uInt8(nTokenValue & 0xff);
1347 : 0 : aTabStop.GetFill() = sal_uInt8((nTokenValue >> 8) & 0xff);
1348 : : // overwrite the closing parenthesis
1349 [ # # ]: 0 : if (bMethodOwnsToken)
1350 [ # # ]: 0 : GetNextToken();
1351 : : }
1352 [ # # ]: 0 : if( nSkip )
1353 : : {
1354 [ # # ]: 0 : SkipToken( nSkip ); // Ignore back again
1355 : 0 : bWeiter = sal_False;
1356 : : }
1357 : : }
1358 : 0 : break;
1359 : :
1360 : : default:
1361 : 0 : bWeiter = sal_False;
1362 : : }
1363 [ # # ]: 0 : if( bWeiter )
1364 : : {
1365 [ # # ]: 0 : nToken = GetNextToken();
1366 : 0 : bMethodOwnsToken = true;
1367 : : }
1368 : : } while( bWeiter );
1369 : :
1370 : : // Fill with defaults is still missing!
1371 [ # # ]: 0 : rSet.Put( aAttr );
1372 [ # # ][ # # ]: 0 : SkipToken( -1 );
1373 : 0 : }
1374 : :
1375 : 0 : static void SetBorderLine( int nBorderTyp, SvxBoxItem& rItem,
1376 : : const SvxBorderLine& rBorder )
1377 : : {
1378 [ # # # # : 0 : switch( nBorderTyp )
# ]
1379 : : {
1380 : : case RTF_BOX: // run through all levels
1381 : :
1382 : : case RTF_BRDRT:
1383 : 0 : rItem.SetLine( &rBorder, BOX_LINE_TOP );
1384 [ # # ]: 0 : if( RTF_BOX != nBorderTyp )
1385 : 0 : return;
1386 : :
1387 : : case RTF_BRDRB:
1388 : 0 : rItem.SetLine( &rBorder, BOX_LINE_BOTTOM );
1389 [ # # ]: 0 : if( RTF_BOX != nBorderTyp )
1390 : 0 : return;
1391 : :
1392 : : case RTF_BRDRL:
1393 : 0 : rItem.SetLine( &rBorder, BOX_LINE_LEFT );
1394 [ # # ]: 0 : if( RTF_BOX != nBorderTyp )
1395 : 0 : return;
1396 : :
1397 : : case RTF_BRDRR:
1398 : 0 : rItem.SetLine( &rBorder, BOX_LINE_RIGHT );
1399 [ # # ]: 0 : if( RTF_BOX != nBorderTyp )
1400 : 0 : return;
1401 : : }
1402 : : }
1403 : :
1404 : 0 : void SvxRTFParser::ReadBorderAttr( int nToken, SfxItemSet& rSet,
1405 : : int bTableDef )
1406 : : {
1407 : : // then read the border attribute
1408 [ # # ][ # # ]: 0 : SvxBoxItem aAttr( PARDID->nBox );
1409 : : const SfxPoolItem* pItem;
1410 [ # # ][ # # ]: 0 : if( SFX_ITEM_SET == rSet.GetItemState( PARDID->nBox, sal_False, &pItem ) )
[ # # ]
1411 [ # # ]: 0 : aAttr = *(SvxBoxItem*)pItem;
1412 : :
1413 [ # # ]: 0 : SvxBorderLine aBrd( 0, DEF_LINE_WIDTH_0 ); // Simple plain line
1414 : 0 : int bWeiter = sal_True, nBorderTyp = 0;
1415 : :
1416 : 0 : long nWidth = 1;
1417 : 0 : bool bDoubleWidth = false;
1418 : :
1419 [ # # ]: 0 : do {
1420 [ # # # # : 0 : switch( nToken )
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
1421 : : {
1422 : : case RTF_BOX:
1423 : : case RTF_BRDRT:
1424 : : case RTF_BRDRB:
1425 : : case RTF_BRDRL:
1426 : : case RTF_BRDRR:
1427 : 0 : nBorderTyp = nToken;
1428 : 0 : break;
1429 : :
1430 : : case RTF_CLBRDRT: // Cell top border
1431 : : {
1432 [ # # ]: 0 : if( bTableDef )
1433 : : {
1434 [ # # ]: 0 : if (nBorderTyp != 0)
1435 [ # # ]: 0 : SetBorderLine( nBorderTyp, aAttr, aBrd );
1436 : 0 : nBorderTyp = RTF_BRDRT;
1437 : : }
1438 : 0 : break;
1439 : : }
1440 : : case RTF_CLBRDRB: // Cell bottom border
1441 : : {
1442 [ # # ]: 0 : if( bTableDef )
1443 : : {
1444 [ # # ]: 0 : if (nBorderTyp != 0)
1445 [ # # ]: 0 : SetBorderLine( nBorderTyp, aAttr, aBrd );
1446 : 0 : nBorderTyp = RTF_BRDRB;
1447 : : }
1448 : 0 : break;
1449 : : }
1450 : : case RTF_CLBRDRL: // Cell left border
1451 : : {
1452 [ # # ]: 0 : if( bTableDef )
1453 : : {
1454 [ # # ]: 0 : if (nBorderTyp != 0)
1455 [ # # ]: 0 : SetBorderLine( nBorderTyp, aAttr, aBrd );
1456 : 0 : nBorderTyp = RTF_BRDRL;
1457 : : }
1458 : 0 : break;
1459 : : }
1460 : : case RTF_CLBRDRR: // Cell right border
1461 : : {
1462 [ # # ]: 0 : if( bTableDef )
1463 : : {
1464 [ # # ]: 0 : if (nBorderTyp != 0)
1465 [ # # ]: 0 : SetBorderLine( nBorderTyp, aAttr, aBrd );
1466 : 0 : nBorderTyp = RTF_BRDRR;
1467 : : }
1468 : 0 : break;
1469 : : }
1470 : :
1471 : : case RTF_BRDRDOT: // dotted border
1472 [ # # ]: 0 : aBrd.SetBorderLineStyle(table::BorderLineStyle::DOTTED);
1473 : 0 : break;
1474 : : case RTF_BRDRDASH: // dashed border
1475 [ # # ]: 0 : aBrd.SetBorderLineStyle(table::BorderLineStyle::DASHED);
1476 : 0 : break;
1477 : : case RTF_BRDRHAIR: // hairline border
1478 : : {
1479 [ # # ]: 0 : aBrd.SetBorderLineStyle( table::BorderLineStyle::SOLID);
1480 : 0 : aBrd.SetWidth( DEF_LINE_WIDTH_0 );
1481 : : }
1482 : 0 : break;
1483 : : case RTF_BRDRDB: // Double border
1484 [ # # ]: 0 : aBrd.SetBorderLineStyle(table::BorderLineStyle::DOUBLE);
1485 : 0 : break;
1486 : : case RTF_BRDRINSET: // inset border
1487 [ # # ]: 0 : aBrd.SetBorderLineStyle(table::BorderLineStyle::INSET);
1488 : 0 : break;
1489 : : case RTF_BRDROUTSET: // outset border
1490 [ # # ]: 0 : aBrd.SetBorderLineStyle(table::BorderLineStyle::OUTSET);
1491 : 0 : break;
1492 : : case RTF_BRDRTNTHSG: // ThinThick Small gap
1493 [ # # ]: 0 : aBrd.SetBorderLineStyle(table::BorderLineStyle::THINTHICK_SMALLGAP);
1494 : 0 : break;
1495 : : case RTF_BRDRTNTHMG: // ThinThick Medium gap
1496 [ # # ]: 0 : aBrd.SetBorderLineStyle(table::BorderLineStyle::THINTHICK_MEDIUMGAP);
1497 : 0 : break;
1498 : : case RTF_BRDRTNTHLG: // ThinThick Large gap
1499 [ # # ]: 0 : aBrd.SetBorderLineStyle(table::BorderLineStyle::THINTHICK_LARGEGAP);
1500 : 0 : break;
1501 : : case RTF_BRDRTHTNSG: // ThickThin Small gap
1502 [ # # ]: 0 : aBrd.SetBorderLineStyle(table::BorderLineStyle::THICKTHIN_SMALLGAP);
1503 : 0 : break;
1504 : : case RTF_BRDRTHTNMG: // ThickThin Medium gap
1505 [ # # ]: 0 : aBrd.SetBorderLineStyle(table::BorderLineStyle::THICKTHIN_MEDIUMGAP);
1506 : 0 : break;
1507 : : case RTF_BRDRTHTNLG: // ThickThin Large gap
1508 [ # # ]: 0 : aBrd.SetBorderLineStyle(table::BorderLineStyle::THICKTHIN_LARGEGAP);
1509 : 0 : break;
1510 : : case RTF_BRDREMBOSS: // Embossed border
1511 [ # # ]: 0 : aBrd.SetBorderLineStyle(table::BorderLineStyle::EMBOSSED);
1512 : 0 : break;
1513 : : case RTF_BRDRENGRAVE: // Engraved border
1514 [ # # ]: 0 : aBrd.SetBorderLineStyle(table::BorderLineStyle::ENGRAVED);
1515 : 0 : break;
1516 : :
1517 : : case RTF_BRDRS: // single thickness border
1518 : 0 : bDoubleWidth = false;
1519 : 0 : break;
1520 : : case RTF_BRDRTH: // double thickness border width*2
1521 : 0 : bDoubleWidth = true;
1522 : 0 : break;
1523 : : case RTF_BRDRW: // border width <255
1524 : 0 : nWidth = nTokenValue;
1525 : 0 : break;
1526 : :
1527 : : case RTF_BRDRCF: // Border color
1528 [ # # ]: 0 : aBrd.SetColor( GetColor( sal_uInt16(nTokenValue) ) );
1529 : 0 : break;
1530 : :
1531 : : case RTF_BRDRSH: // Shadowed border
1532 [ # # ]: 0 : rSet.Put( SvxShadowItem( PARDID->nShadow, (Color*) 0, 60 /*3pt*/,
1533 [ # # ][ # # ]: 0 : SVX_SHADOW_BOTTOMRIGHT ) );
[ # # ]
1534 : 0 : break;
1535 : :
1536 : : case RTF_BRSP: // Spacing to content in twip
1537 : : {
1538 [ # # # # : 0 : switch( nBorderTyp )
# # ]
1539 : : {
1540 : : case RTF_BRDRB:
1541 [ # # ]: 0 : aAttr.SetDistance( (sal_uInt16)nTokenValue, BOX_LINE_BOTTOM );
1542 : 0 : break;
1543 : :
1544 : : case RTF_BRDRT:
1545 [ # # ]: 0 : aAttr.SetDistance( (sal_uInt16)nTokenValue, BOX_LINE_TOP );
1546 : 0 : break;
1547 : :
1548 : : case RTF_BRDRL:
1549 [ # # ]: 0 : aAttr.SetDistance( (sal_uInt16)nTokenValue, BOX_LINE_LEFT );
1550 : 0 : break;
1551 : :
1552 : : case RTF_BRDRR:
1553 [ # # ]: 0 : aAttr.SetDistance( (sal_uInt16)nTokenValue, BOX_LINE_RIGHT );
1554 : 0 : break;
1555 : :
1556 : : case RTF_BOX:
1557 : 0 : aAttr.SetDistance( (sal_uInt16)nTokenValue );
1558 : 0 : break;
1559 : : }
1560 : : }
1561 : 0 : break;
1562 : :
1563 : : case RTF_BRDRBTW: // Border formatting group
1564 : : case RTF_BRDRBAR: // Border outside
1565 : : // TODO unhandled ATM
1566 : 0 : break;
1567 : :
1568 : : default:
1569 : 0 : bWeiter = (nToken & ~(0xff| RTF_SWGDEFS)) == RTF_BRDRDEF;
1570 : : }
1571 [ # # ]: 0 : if( bWeiter )
1572 [ # # ]: 0 : nToken = GetNextToken();
1573 : : } while( bWeiter );
1574 : :
1575 : : // Finally compute the border width
1576 [ # # ]: 0 : if ( bDoubleWidth ) nWidth *= 2;
1577 : 0 : aBrd.SetWidth( nWidth );
1578 : :
1579 [ # # ]: 0 : SetBorderLine( nBorderTyp, aAttr, aBrd );
1580 : :
1581 [ # # ]: 0 : rSet.Put( aAttr );
1582 [ # # ][ # # ]: 0 : SkipToken( -1 );
1583 : 0 : }
1584 : :
1585 : 0 : inline sal_uInt32 CalcShading( sal_uInt32 nColor, sal_uInt32 nFillColor, sal_uInt8 nShading )
1586 : : {
1587 : 0 : nColor = (nColor * nShading) / 100;
1588 : 0 : nFillColor = (nFillColor * ( 100 - nShading )) / 100;
1589 : 0 : return nColor + nFillColor;
1590 : : }
1591 : :
1592 : 0 : void SvxRTFParser::ReadBackgroundAttr( int nToken, SfxItemSet& rSet,
1593 : : int bTableDef )
1594 : : {
1595 : : // then read the border attribute
1596 : 0 : int bWeiter = sal_True;
1597 : 0 : sal_uInt16 nColor = USHRT_MAX, nFillColor = USHRT_MAX;
1598 : 0 : sal_uInt8 nFillValue = 0;
1599 : :
1600 : : sal_uInt16 nWh = ( nToken & ~0xff ) == RTF_CHRFMT
1601 [ # # ]: 0 : ? PLAINID->nBgColor
1602 [ # # ][ # # ]: 0 : : PARDID->nBrush;
1603 : :
1604 [ # # ]: 0 : do {
1605 [ # # # # : 0 : switch( nToken )
# # ]
1606 : : {
1607 : : case RTF_CLCBPAT:
1608 : : case RTF_CHCBPAT:
1609 : : case RTF_CBPAT:
1610 : 0 : nFillColor = sal_uInt16( nTokenValue );
1611 : 0 : break;
1612 : :
1613 : : case RTF_CLCFPAT:
1614 : : case RTF_CHCFPAT:
1615 : : case RTF_CFPAT:
1616 : 0 : nColor = sal_uInt16( nTokenValue );
1617 : 0 : break;
1618 : :
1619 : : case RTF_CLSHDNG:
1620 : : case RTF_CHSHDNG:
1621 : : case RTF_SHADING:
1622 : 0 : nFillValue = (sal_uInt8)( nTokenValue / 100 );
1623 : 0 : break;
1624 : :
1625 : : case RTF_CLBGDKHOR:
1626 : : case RTF_CHBGDKHORIZ:
1627 : : case RTF_BGDKHORIZ:
1628 : : case RTF_CLBGDKVERT:
1629 : : case RTF_CHBGDKVERT:
1630 : : case RTF_BGDKVERT:
1631 : : case RTF_CLBGDKBDIAG:
1632 : : case RTF_CHBGDKBDIAG:
1633 : : case RTF_BGDKBDIAG:
1634 : : case RTF_CLBGDKFDIAG:
1635 : : case RTF_CHBGDKFDIAG:
1636 : : case RTF_BGDKFDIAG:
1637 : : case RTF_CLBGDKCROSS:
1638 : : case RTF_CHBGDKCROSS:
1639 : : case RTF_BGDKCROSS:
1640 : : case RTF_CLBGDKDCROSS:
1641 : : case RTF_CHBGDKDCROSS:
1642 : : case RTF_BGDKDCROSS:
1643 : : // dark -> 60%
1644 : 0 : nFillValue = 60;
1645 : 0 : break;
1646 : :
1647 : : case RTF_CLBGHORIZ:
1648 : : case RTF_CHBGHORIZ:
1649 : : case RTF_BGHORIZ:
1650 : : case RTF_CLBGVERT:
1651 : : case RTF_CHBGVERT:
1652 : : case RTF_BGVERT:
1653 : : case RTF_CLBGBDIAG:
1654 : : case RTF_CHBGBDIAG:
1655 : : case RTF_BGBDIAG:
1656 : : case RTF_CLBGFDIAG:
1657 : : case RTF_CHBGFDIAG:
1658 : : case RTF_BGFDIAG:
1659 : : case RTF_CLBGCROSS:
1660 : : case RTF_CHBGCROSS:
1661 : : case RTF_BGCROSS:
1662 : : case RTF_CLBGDCROSS:
1663 : : case RTF_CHBGDCROSS:
1664 : : case RTF_BGDCROSS:
1665 : : // light -> 20%
1666 : 0 : nFillValue = 20;
1667 : 0 : break;
1668 : :
1669 : : default:
1670 [ # # ]: 0 : if( bTableDef )
1671 : 0 : bWeiter = (nToken & ~(0xff | RTF_TABLEDEF) ) == RTF_SHADINGDEF;
1672 : : else
1673 : 0 : bWeiter = (nToken & ~0xff) == RTF_SHADINGDEF;
1674 : : }
1675 [ # # ]: 0 : if( bWeiter )
1676 [ # # ]: 0 : nToken = GetNextToken();
1677 : : } while( bWeiter );
1678 : :
1679 : 0 : Color aCol( COL_WHITE ), aFCol;
1680 [ # # ]: 0 : if( !nFillValue )
1681 : : {
1682 : : // there was only one of two colors specified or no BrushTyp
1683 [ # # ]: 0 : if( USHRT_MAX != nFillColor )
1684 : : {
1685 : 0 : nFillValue = 100;
1686 [ # # ]: 0 : aCol = GetColor( nFillColor );
1687 : : }
1688 [ # # ]: 0 : else if( USHRT_MAX != nColor )
1689 [ # # ]: 0 : aFCol = GetColor( nColor );
1690 : : }
1691 : : else
1692 : : {
1693 [ # # ]: 0 : if( USHRT_MAX != nColor )
1694 [ # # ]: 0 : aCol = GetColor( nColor );
1695 : : else
1696 : 0 : aCol = Color( COL_BLACK );
1697 : :
1698 [ # # ]: 0 : if( USHRT_MAX != nFillColor )
1699 [ # # ]: 0 : aFCol = GetColor( nFillColor );
1700 : : else
1701 : 0 : aFCol = Color( COL_WHITE );
1702 : : }
1703 : :
1704 : 0 : Color aColor;
1705 [ # # ][ # # ]: 0 : if( 0 == nFillValue || 100 == nFillValue )
1706 : 0 : aColor = aCol;
1707 : : else
1708 : : aColor = Color(
1709 : 0 : (sal_uInt8)CalcShading( aCol.GetRed(), aFCol.GetRed(), nFillValue ),
1710 : 0 : (sal_uInt8)CalcShading( aCol.GetGreen(), aFCol.GetGreen(), nFillValue ),
1711 : 0 : (sal_uInt8)CalcShading( aCol.GetBlue(), aFCol.GetBlue(), nFillValue ) );
1712 : :
1713 [ # # ][ # # ]: 0 : rSet.Put( SvxBrushItem( aColor, nWh ) );
[ # # ]
1714 [ # # ]: 0 : SkipToken( -1 );
1715 : 0 : }
1716 : :
1717 : :
1718 : : // pard / plain abarbeiten
1719 : 0 : void SvxRTFParser::RTFPardPlain( int bPard, SfxItemSet** ppSet )
1720 : : {
1721 [ # # ][ # # ]: 0 : if( !bNewGroup && !aAttrStack.empty() ) // not at the beginning of a new group
[ # # ]
1722 : : {
1723 : 0 : SvxRTFItemStackType* pAkt = aAttrStack.back();
1724 : :
1725 : 0 : int nLastToken = GetStackPtr(-1)->nTokenId;
1726 : 0 : int bNewStkEntry = sal_True;
1727 [ # # ][ # # ]: 0 : if( RTF_PARD != nLastToken &&
[ # # ]
1728 : : RTF_PLAIN != nLastToken &&
1729 : : BRACELEFT != nLastToken )
1730 : : {
1731 [ # # ][ # # ]: 0 : if( pAkt->aAttrSet.Count() || pAkt->pChildList || pAkt->nStyleNo )
[ # # ][ # # ]
1732 : : {
1733 : : // open a new group
1734 [ # # ][ # # ]: 0 : SvxRTFItemStackType* pNew = new SvxRTFItemStackType( *pAkt, *pInsPos, sal_True );
1735 [ # # ][ # # ]: 0 : pNew->SetRTFDefaults( GetRTFDefaults() );
1736 : :
1737 : : // Set all until here valid attributes
1738 [ # # ]: 0 : AttrGroupEnd();
1739 [ # # ][ # # ]: 0 : pAkt = aAttrStack.empty() ? 0 : aAttrStack.back(); // can be changed after AttrGroupEnd!
1740 [ # # ]: 0 : pNew->aAttrSet.SetParent( pAkt ? &pAkt->aAttrSet : 0 );
1741 [ # # ]: 0 : aAttrStack.push_back( pNew );
1742 : 0 : pAkt = pNew;
1743 : : }
1744 : : else
1745 : : {
1746 : : // continue to use this entry as new
1747 : 0 : pAkt->SetStartPos( *pInsPos );
1748 : 0 : bNewStkEntry = sal_False;
1749 : : }
1750 : : }
1751 : :
1752 : : // now reset all to default
1753 [ # # # # : 0 : if( bNewStkEntry &&
# # ][ # # ]
1754 : 0 : ( pAkt->aAttrSet.GetParent() || pAkt->aAttrSet.Count() ))
1755 : : {
1756 : : const SfxPoolItem *pItem, *pDef;
1757 : : const sal_uInt16* pPtr;
1758 : : sal_uInt16 nCnt;
1759 [ # # ]: 0 : const SfxItemSet* pDfltSet = &GetRTFDefaults();
1760 [ # # ]: 0 : if( bPard )
1761 : : {
1762 : 0 : pAkt->nStyleNo = 0;
1763 [ # # ]: 0 : pPtr = &aPardMap[0];
1764 : 0 : nCnt = aPardMap.size();
1765 : : }
1766 : : else
1767 : : {
1768 [ # # ]: 0 : pPtr = &aPlainMap[0];
1769 : 0 : nCnt = aPlainMap.size();
1770 : : }
1771 : :
1772 [ # # ]: 0 : for( sal_uInt16 n = 0; n < nCnt; ++n, ++pPtr )
1773 : : {
1774 : : // Item set and different -> Set the Default Pool
1775 [ # # ]: 0 : if( !*pPtr )
1776 : : ;
1777 [ # # ]: 0 : else if( SFX_WHICH_MAX < *pPtr )
1778 [ # # ]: 0 : pAkt->aAttrSet.ClearItem( *pPtr );
1779 [ # # ]: 0 : else if( IsChkStyleAttr() )
1780 [ # # ][ # # ]: 0 : pAkt->aAttrSet.Put( pDfltSet->Get( *pPtr ) );
1781 [ # # ]: 0 : else if( !pAkt->aAttrSet.GetParent() )
1782 : : {
1783 [ # # ]: 0 : if( SFX_ITEM_SET ==
1784 [ # # ]: 0 : pDfltSet->GetItemState( *pPtr, sal_False, &pDef ))
1785 [ # # ]: 0 : pAkt->aAttrSet.Put( *pDef );
1786 : : else
1787 [ # # ]: 0 : pAkt->aAttrSet.ClearItem( *pPtr );
1788 : : }
1789 [ # # ][ # # ]: 0 : else if( SFX_ITEM_SET == pAkt->aAttrSet.GetParent()->
[ # # ]
1790 [ # # ]: 0 : GetItemState( *pPtr, sal_True, &pItem ) &&
1791 [ # # ][ # # ]: 0 : *( pDef = &pDfltSet->Get( *pPtr )) != *pItem )
1792 [ # # ]: 0 : pAkt->aAttrSet.Put( *pDef );
1793 : : else
1794 : : {
1795 [ # # ]: 0 : if( SFX_ITEM_SET ==
1796 [ # # ]: 0 : pDfltSet->GetItemState( *pPtr, sal_False, &pDef ))
1797 [ # # ]: 0 : pAkt->aAttrSet.Put( *pDef );
1798 : : else
1799 [ # # ]: 0 : pAkt->aAttrSet.ClearItem( *pPtr );
1800 : : }
1801 : : }
1802 : : }
1803 [ # # ]: 0 : else if( bPard )
1804 : 0 : pAkt->nStyleNo = 0; // reset Style number
1805 : :
1806 : 0 : *ppSet = &pAkt->aAttrSet;
1807 : :
1808 [ # # ]: 0 : if (!bPard)
1809 : : {
1810 : : //Once we have a default font, then any text without a font specifier is
1811 : : //in the default font, and thus has the default font charset, otherwise
1812 : : //we can fall back to the ansicpg set codeset
1813 [ # # ]: 0 : if (nDfltFont != -1)
1814 : : {
1815 : 0 : const Font& rSVFont = GetFont(sal_uInt16(nDfltFont));
1816 : 0 : SetEncoding(rSVFont.GetCharSet());
1817 : : }
1818 : : else
1819 : 0 : SetEncoding(GetCodeSet());
1820 : : }
1821 : : }
1822 : 0 : }
1823 : :
1824 : 0 : void SvxRTFParser::SetDefault( int nToken, int nValue )
1825 : : {
1826 [ # # ]: 0 : if( !bNewDoc )
1827 : 0 : return;
1828 : :
1829 [ # # ][ # # ]: 0 : SfxItemSet aTmp( *pAttrPool, &aWhichMap[0] );
1830 : 0 : sal_Bool bOldFlag = bIsLeftToRightDef;
1831 : 0 : bIsLeftToRightDef = sal_True;
1832 [ # # # # : 0 : switch( nToken )
# # ]
1833 : : {
1834 : 0 : case RTF_ADEFF: bIsLeftToRightDef = sal_False; // no break!
1835 : : case RTF_DEFF:
1836 : : {
1837 [ # # ]: 0 : if( -1 == nValue )
1838 : 0 : nValue = 0;
1839 [ # # ]: 0 : const Font& rSVFont = GetFont( sal_uInt16(nValue) );
1840 : : SvxFontItem aTmpItem(
1841 [ # # ]: 0 : rSVFont.GetFamily(), rSVFont.GetName(),
1842 [ # # ]: 0 : rSVFont.GetStyleName(), rSVFont.GetPitch(),
1843 [ # # ][ # # ]: 0 : rSVFont.GetCharSet(), SID_ATTR_CHAR_FONT );
[ # # ][ # # ]
1844 [ # # ][ # # ]: 0 : SetScriptAttr( NOTDEF_CHARTYPE, aTmp, aTmpItem );
1845 : : }
1846 : 0 : break;
1847 : :
1848 : 0 : case RTF_ADEFLANG: bIsLeftToRightDef = sal_False; // no break!
1849 : : case RTF_DEFLANG:
1850 : : // store default Language
1851 [ # # ]: 0 : if( -1 != nValue )
1852 : : {
1853 : : SvxLanguageItem aTmpItem( (const LanguageType)nValue,
1854 [ # # ]: 0 : SID_ATTR_CHAR_LANGUAGE );
1855 [ # # ][ # # ]: 0 : SetScriptAttr( NOTDEF_CHARTYPE, aTmp, aTmpItem );
1856 : : }
1857 : 0 : break;
1858 : :
1859 : : case RTF_DEFTAB:
1860 [ # # ][ # # ]: 0 : if( PARDID->nTabStop )
1861 : : {
1862 : : // RTF defines 720 twips as default
1863 : 0 : bIsSetDfltTab = sal_True;
1864 [ # # ][ # # ]: 0 : if( -1 == nValue || !nValue )
1865 : 0 : nValue = 720;
1866 : :
1867 : : // who would like to have no twips ...
1868 [ # # ]: 0 : if( IsCalcValue() )
1869 : : {
1870 : 0 : nTokenValue = nValue;
1871 [ # # ]: 0 : CalcValue();
1872 : 0 : nValue = nTokenValue;
1873 : : }
1874 : :
1875 : : // Calculate the ratio of default TabWidth / Tabs and
1876 : : // calculate the corresponding new number.
1877 : : // ?? how did one come up with 13 ??
1878 : 0 : sal_uInt16 nAnzTabs = (SVX_TAB_DEFDIST * 13 ) / sal_uInt16(nValue);
1879 : : /*
1880 : : cmc, make sure we have at least one, or all hell breaks loose in
1881 : : everybodies exporters, #i8247#
1882 : : */
1883 [ # # ]: 0 : if (nAnzTabs < 1)
1884 : 0 : nAnzTabs = 1;
1885 : :
1886 : : // we want Defaulttabs
1887 : : SvxTabStopItem aNewTab( nAnzTabs, sal_uInt16(nValue),
1888 [ # # ][ # # ]: 0 : SVX_TAB_ADJUST_DEFAULT, PARDID->nTabStop );
1889 [ # # ]: 0 : while( nAnzTabs )
1890 [ # # ]: 0 : ((SvxTabStop&)aNewTab[ --nAnzTabs ]).GetAdjustment() = SVX_TAB_ADJUST_DEFAULT;
1891 : :
1892 [ # # ][ # # ]: 0 : pAttrPool->SetPoolDefaultItem( aNewTab );
1893 : : }
1894 : 0 : break;
1895 : : }
1896 : 0 : bIsLeftToRightDef = bOldFlag;
1897 : :
1898 [ # # ]: 0 : if( aTmp.Count() )
1899 : : {
1900 [ # # ]: 0 : SfxItemIter aIter( aTmp );
1901 : 0 : const SfxPoolItem* pItem = aIter.GetCurItem();
1902 : 0 : while( sal_True )
1903 : : {
1904 [ # # ]: 0 : pAttrPool->SetPoolDefaultItem( *pItem );
1905 [ # # ]: 0 : if( aIter.IsAtEnd() )
1906 : 0 : break;
1907 [ # # ]: 0 : pItem = aIter.NextItem();
1908 [ # # ]: 0 : }
1909 [ # # ]: 0 : }
1910 : : }
1911 : :
1912 : : // default: no conversion, leaving everything in twips.
1913 : 0 : void SvxRTFParser::CalcValue()
1914 : : {
1915 : 0 : }
1916 : :
1917 : : // for tokens that are not evaluated in ReadAttr
1918 : 0 : void SvxRTFParser::UnknownAttrToken( int, SfxItemSet* )
1919 : : {
1920 : 0 : }
1921 : :
1922 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
