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