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