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