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 : bool bFirstToken = true;
208 0 : bool bContinue = true;
209 0 : sal_uInt16 nStyleNo = 0; // default
210 : FontUnderline eUnderline;
211 : FontUnderline eOverline;
212 : FontEmphasisMark eEmphasis;
213 0 : bPardTokenRead = false;
214 0 : RTF_CharTypeDef eCharType = NOTDEF_CHARTYPE;
215 : sal_uInt16 nFontAlign;
216 :
217 0 : bool bChkStkPos = !bNewGroup && !aAttrStack.empty();
218 :
219 0 : while( bContinue && IsParserWorking() ) // as long as known Attribute are recognized
220 : {
221 0 : switch( nToken )
222 : {
223 : case RTF_PARD:
224 0 : RTFPardPlain( true, &pSet );
225 0 : nStyleNo = 0;
226 0 : bPardTokenRead = true;
227 0 : break;
228 :
229 : case RTF_PLAIN:
230 0 : RTFPardPlain( 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, 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 = 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 immediate style 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( SvxFormatSplitItem( false, aPardMap.nSplit ));
307 : }
308 0 : break;
309 :
310 : case RTF_KEEPN:
311 0 : if( aPardMap.nKeep )
312 : {
313 0 : pSet->Put( SvxFormatKeepItem( 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.SetTextFirstLineOfst( 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.SetTextLeft( 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 != 0,
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 != 0,
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 0 : (nTokenValue & 1) != 0,
1143 0 : aPardMap.nHyphenzone );
1144 0 : aHypenZone.SetPageEnd((nTokenValue & 2) != 0);
1145 :
1146 0 : if( aPardMap.nHyphenzone &&
1147 0 : RTF_HYPHLEAD == GetNextToken() &&
1148 0 : RTF_HYPHTRAIL == GetNextToken() &&
1149 0 : RTF_HYPHMAX == GetNextToken() )
1150 : {
1151 0 : aHypenZone.GetMinLead() =
1152 0 : sal_uInt8(GetStackPtr( -2 )->nTokenValue);
1153 0 : aHypenZone.GetMinTrail() =
1154 0 : sal_uInt8(GetStackPtr( -1 )->nTokenValue);
1155 0 : aHypenZone.GetMaxHyphens() =
1156 0 : sal_uInt8(nTokenValue);
1157 :
1158 0 : pSet->Put( aHypenZone );
1159 : }
1160 : else
1161 0 : SkipGroup(); // at the end of the group
1162 : }
1163 0 : break;
1164 :
1165 : case RTF_SHADOW:
1166 : {
1167 0 : bool bSkip = true;
1168 : do { // middle check loop
1169 0 : SvxShadowLocation eSL = SvxShadowLocation( nTokenValue );
1170 0 : if( RTF_SHDW_DIST != GetNextToken() )
1171 0 : break;
1172 0 : sal_uInt16 nDist = sal_uInt16( nTokenValue );
1173 :
1174 0 : if( RTF_SHDW_STYLE != GetNextToken() )
1175 0 : break;
1176 :
1177 0 : if( RTF_SHDW_COL != GetNextToken() )
1178 0 : break;
1179 0 : sal_uInt16 nCol = sal_uInt16( nTokenValue );
1180 :
1181 0 : if( RTF_SHDW_FCOL != GetNextToken() )
1182 0 : break;
1183 :
1184 0 : Color aColor = GetColor( nCol );
1185 :
1186 0 : if( aPardMap.nShadow )
1187 : pSet->Put( SvxShadowItem( aPardMap.nShadow,
1188 0 : &aColor, nDist, eSL ) );
1189 :
1190 0 : bSkip = false;
1191 : } while( false );
1192 :
1193 0 : if( bSkip )
1194 0 : SkipGroup(); // at the end of the group
1195 : }
1196 0 : break;
1197 :
1198 : default:
1199 0 : bHandled = false;
1200 0 : if( (nToken & ~(0xff | RTF_SWGDEFS)) == RTF_TABSTOPDEF )
1201 : {
1202 0 : nToken = SkipToken( -2 );
1203 0 : ReadTabAttr( nToken, *pSet );
1204 :
1205 : /*
1206 : cmc: #i76140, he who consumed the { must consume the }
1207 : We rewound to a state of { being the current
1208 : token so it is our responsibility to consume the }
1209 : token if we consumed the {. We will not have consumed
1210 : the { if it belonged to our caller, i.e. if the { we
1211 : are handling is the "firsttoken" passed to us then
1212 : the *caller* must consume it, not us. Otherwise *we*
1213 : should consume it.
1214 : */
1215 0 : if (nToken == BRACELEFT && !bFirstToken)
1216 : {
1217 0 : nToken = GetNextToken();
1218 : SAL_WARN_IF( nToken != BRACERIGHT,
1219 : "editeng",
1220 : "} did not follow { as expected");
1221 : }
1222 : }
1223 0 : else if( (nToken & ~(0xff| RTF_SWGDEFS)) == RTF_BRDRDEF)
1224 : {
1225 0 : nToken = SkipToken( -2 );
1226 0 : ReadBorderAttr( nToken, *pSet );
1227 : }
1228 : else // so no more attribute
1229 0 : nSkip = -2;
1230 0 : break;
1231 : }
1232 :
1233 : #if 1
1234 : /*
1235 : cmc: #i4727# / #i12713# Who owns this closing bracket?
1236 : If we read the opening one, we must read this one, if
1237 : other is counting the brackets so as to push/pop off
1238 : the correct environment then we will have pushed a new
1239 : environment for the start { of this, but will not see
1240 : the } and so is out of sync for the rest of the
1241 : document.
1242 : */
1243 0 : if (bHandled && !bFirstToken)
1244 0 : GetNextToken();
1245 : #endif
1246 : }
1247 : else
1248 0 : nSkip = -2;
1249 :
1250 0 : if( nSkip ) // all completely unknown
1251 : {
1252 0 : if (!bFirstToken)
1253 0 : --nSkip; // BRACELEFT: is the next token
1254 0 : SkipToken( nSkip );
1255 0 : bContinue = false;
1256 : }
1257 : }
1258 0 : break;
1259 : default:
1260 0 : if( (nToken & ~0xff ) == RTF_TABSTOPDEF )
1261 0 : ReadTabAttr( nToken, *pSet );
1262 0 : else if( (nToken & ~0xff ) == RTF_BRDRDEF )
1263 0 : ReadBorderAttr( nToken, *pSet );
1264 0 : else if( (nToken & ~0xff ) == RTF_SHADINGDEF )
1265 0 : ReadBackgroundAttr( nToken, *pSet );
1266 : else
1267 : {
1268 : // unknown token, so token "returned in Parser"
1269 0 : if( !bFirstToken )
1270 0 : SkipToken( -1 );
1271 0 : bContinue = false;
1272 : }
1273 : }
1274 : }
1275 0 : if( bContinue )
1276 : {
1277 0 : nToken = GetNextToken();
1278 : }
1279 0 : bFirstToken = false;
1280 : }
1281 0 : }
1282 :
1283 0 : void SvxRTFParser::ReadTabAttr( int nToken, SfxItemSet& rSet )
1284 : {
1285 0 : bool bMethodOwnsToken = false; // #i52542# patch from cmc.
1286 : // then read all the TabStops
1287 0 : SvxTabStop aTabStop;
1288 0 : SvxTabStopItem aAttr( 0, 0, SVX_TAB_ADJUST_DEFAULT, aPardMap.nTabStop );
1289 0 : bool bContinue = true;
1290 0 : do {
1291 0 : switch( nToken )
1292 : {
1293 : case RTF_TB: // BarTab ???
1294 : case RTF_TX:
1295 : {
1296 0 : if( IsCalcValue() )
1297 0 : CalcValue();
1298 0 : aTabStop.GetTabPos() = nTokenValue;
1299 0 : aAttr.Insert( aTabStop );
1300 0 : aTabStop = SvxTabStop(); // all values default
1301 : }
1302 0 : break;
1303 :
1304 : case RTF_TQL:
1305 0 : aTabStop.GetAdjustment() = SVX_TAB_ADJUST_LEFT;
1306 0 : break;
1307 : case RTF_TQR:
1308 0 : aTabStop.GetAdjustment() = SVX_TAB_ADJUST_RIGHT;
1309 0 : break;
1310 : case RTF_TQC:
1311 0 : aTabStop.GetAdjustment() = SVX_TAB_ADJUST_CENTER;
1312 0 : break;
1313 : case RTF_TQDEC:
1314 0 : aTabStop.GetAdjustment() = SVX_TAB_ADJUST_DECIMAL;
1315 0 : break;
1316 :
1317 0 : case RTF_TLDOT: aTabStop.GetFill() = '.'; break;
1318 0 : case RTF_TLHYPH: aTabStop.GetFill() = ' '; break;
1319 0 : case RTF_TLUL: aTabStop.GetFill() = '_'; break;
1320 0 : case RTF_TLTH: aTabStop.GetFill() = '-'; break;
1321 0 : case RTF_TLEQ: aTabStop.GetFill() = '='; break;
1322 :
1323 : case BRACELEFT:
1324 : {
1325 : // Swg - control BRACELEFT RTF_IGNOREFLAG RTF_TLSWG BRACERIGHT
1326 0 : short nSkip = 0;
1327 0 : if( RTF_IGNOREFLAG != GetNextToken() )
1328 0 : nSkip = -1;
1329 0 : else if( RTF_TLSWG != ( nToken = GetNextToken() ))
1330 0 : nSkip = -2;
1331 : else
1332 : {
1333 0 : aTabStop.GetDecimal() = sal_uInt8(nTokenValue & 0xff);
1334 0 : aTabStop.GetFill() = sal_uInt8((nTokenValue >> 8) & 0xff);
1335 : // overwrite the closing parenthesis
1336 0 : if (bMethodOwnsToken)
1337 0 : GetNextToken();
1338 : }
1339 0 : if( nSkip )
1340 : {
1341 0 : SkipToken( nSkip ); // Ignore back again
1342 0 : bContinue = false;
1343 : }
1344 : }
1345 0 : break;
1346 :
1347 : default:
1348 0 : bContinue = false;
1349 : }
1350 0 : if( bContinue )
1351 : {
1352 0 : nToken = GetNextToken();
1353 0 : bMethodOwnsToken = true;
1354 : }
1355 : } while( bContinue );
1356 :
1357 : // Fill with defaults is still missing!
1358 0 : rSet.Put( aAttr );
1359 0 : SkipToken( -1 );
1360 0 : }
1361 :
1362 0 : static void SetBorderLine( int nBorderTyp, SvxBoxItem& rItem,
1363 : const SvxBorderLine& rBorder )
1364 : {
1365 0 : switch( nBorderTyp )
1366 : {
1367 : case RTF_BOX: // run through all levels
1368 : case RTF_BRDRT:
1369 0 : rItem.SetLine( &rBorder, SvxBoxItemLine::TOP );
1370 0 : if( RTF_BOX != nBorderTyp )
1371 0 : return;
1372 : // fall-through
1373 : case RTF_BRDRB:
1374 0 : rItem.SetLine( &rBorder, SvxBoxItemLine::BOTTOM );
1375 0 : if( RTF_BOX != nBorderTyp )
1376 0 : return;
1377 : // fall-through
1378 : case RTF_BRDRL:
1379 0 : rItem.SetLine( &rBorder, SvxBoxItemLine::LEFT );
1380 0 : if( RTF_BOX != nBorderTyp )
1381 0 : return;
1382 : // fall-through
1383 : case RTF_BRDRR:
1384 0 : rItem.SetLine( &rBorder, SvxBoxItemLine::RIGHT );
1385 0 : if( RTF_BOX != nBorderTyp )
1386 0 : return;
1387 : }
1388 : }
1389 :
1390 0 : void SvxRTFParser::ReadBorderAttr( int nToken, SfxItemSet& rSet,
1391 : bool bTableDef )
1392 : {
1393 : // then read the border attribute
1394 0 : SvxBoxItem aAttr( aPardMap.nBox );
1395 : const SfxPoolItem* pItem;
1396 0 : if( SfxItemState::SET == rSet.GetItemState( aPardMap.nBox, false, &pItem ) )
1397 0 : aAttr = *static_cast<const SvxBoxItem*>(pItem);
1398 :
1399 0 : SvxBorderLine aBrd( 0, DEF_LINE_WIDTH_0 ); // Simple plain line
1400 0 : bool bContinue = true;
1401 0 : int nBorderTyp = 0;
1402 :
1403 0 : long nWidth = 1;
1404 0 : bool bDoubleWidth = false;
1405 :
1406 0 : do {
1407 0 : switch( nToken )
1408 : {
1409 : case RTF_BOX:
1410 : case RTF_BRDRT:
1411 : case RTF_BRDRB:
1412 : case RTF_BRDRL:
1413 : case RTF_BRDRR:
1414 0 : nBorderTyp = nToken;
1415 0 : break;
1416 :
1417 : case RTF_CLBRDRT: // Cell top border
1418 : {
1419 0 : if( bTableDef )
1420 : {
1421 0 : if (nBorderTyp != 0)
1422 0 : SetBorderLine( nBorderTyp, aAttr, aBrd );
1423 0 : nBorderTyp = RTF_BRDRT;
1424 : }
1425 0 : break;
1426 : }
1427 : case RTF_CLBRDRB: // Cell bottom border
1428 : {
1429 0 : if( bTableDef )
1430 : {
1431 0 : if (nBorderTyp != 0)
1432 0 : SetBorderLine( nBorderTyp, aAttr, aBrd );
1433 0 : nBorderTyp = RTF_BRDRB;
1434 : }
1435 0 : break;
1436 : }
1437 : case RTF_CLBRDRL: // Cell left border
1438 : {
1439 0 : if( bTableDef )
1440 : {
1441 0 : if (nBorderTyp != 0)
1442 0 : SetBorderLine( nBorderTyp, aAttr, aBrd );
1443 0 : nBorderTyp = RTF_BRDRL;
1444 : }
1445 0 : break;
1446 : }
1447 : case RTF_CLBRDRR: // Cell right border
1448 : {
1449 0 : if( bTableDef )
1450 : {
1451 0 : if (nBorderTyp != 0)
1452 0 : SetBorderLine( nBorderTyp, aAttr, aBrd );
1453 0 : nBorderTyp = RTF_BRDRR;
1454 : }
1455 0 : break;
1456 : }
1457 :
1458 : case RTF_BRDRDOT: // dotted border
1459 0 : aBrd.SetBorderLineStyle(table::BorderLineStyle::DOTTED);
1460 0 : break;
1461 : case RTF_BRDRDASH: // dashed border
1462 0 : aBrd.SetBorderLineStyle(table::BorderLineStyle::DASHED);
1463 0 : break;
1464 : case RTF_BRDRHAIR: // hairline border
1465 : {
1466 0 : aBrd.SetBorderLineStyle( table::BorderLineStyle::SOLID);
1467 0 : aBrd.SetWidth( DEF_LINE_WIDTH_0 );
1468 : }
1469 0 : break;
1470 : case RTF_BRDRDB: // Double border
1471 0 : aBrd.SetBorderLineStyle(table::BorderLineStyle::DOUBLE);
1472 0 : break;
1473 : case RTF_BRDRINSET: // inset border
1474 0 : aBrd.SetBorderLineStyle(table::BorderLineStyle::INSET);
1475 0 : break;
1476 : case RTF_BRDROUTSET: // outset border
1477 0 : aBrd.SetBorderLineStyle(table::BorderLineStyle::OUTSET);
1478 0 : break;
1479 : case RTF_BRDRTNTHSG: // ThinThick Small gap
1480 0 : aBrd.SetBorderLineStyle(table::BorderLineStyle::THINTHICK_SMALLGAP);
1481 0 : break;
1482 : case RTF_BRDRTNTHMG: // ThinThick Medium gap
1483 0 : aBrd.SetBorderLineStyle(table::BorderLineStyle::THINTHICK_MEDIUMGAP);
1484 0 : break;
1485 : case RTF_BRDRTNTHLG: // ThinThick Large gap
1486 0 : aBrd.SetBorderLineStyle(table::BorderLineStyle::THINTHICK_LARGEGAP);
1487 0 : break;
1488 : case RTF_BRDRTHTNSG: // ThickThin Small gap
1489 0 : aBrd.SetBorderLineStyle(table::BorderLineStyle::THICKTHIN_SMALLGAP);
1490 0 : break;
1491 : case RTF_BRDRTHTNMG: // ThickThin Medium gap
1492 0 : aBrd.SetBorderLineStyle(table::BorderLineStyle::THICKTHIN_MEDIUMGAP);
1493 0 : break;
1494 : case RTF_BRDRTHTNLG: // ThickThin Large gap
1495 0 : aBrd.SetBorderLineStyle(table::BorderLineStyle::THICKTHIN_LARGEGAP);
1496 0 : break;
1497 : case RTF_BRDREMBOSS: // Embossed border
1498 0 : aBrd.SetBorderLineStyle(table::BorderLineStyle::EMBOSSED);
1499 0 : break;
1500 : case RTF_BRDRENGRAVE: // Engraved border
1501 0 : aBrd.SetBorderLineStyle(table::BorderLineStyle::ENGRAVED);
1502 0 : break;
1503 :
1504 : case RTF_BRDRS: // single thickness border
1505 0 : bDoubleWidth = false;
1506 0 : break;
1507 : case RTF_BRDRTH: // double thickness border width*2
1508 0 : bDoubleWidth = true;
1509 0 : break;
1510 : case RTF_BRDRW: // border width <255
1511 0 : nWidth = nTokenValue;
1512 0 : break;
1513 :
1514 : case RTF_BRDRCF: // Border color
1515 0 : aBrd.SetColor( GetColor( sal_uInt16(nTokenValue) ) );
1516 0 : break;
1517 :
1518 : case RTF_BRDRSH: // Shadowed border
1519 : rSet.Put( SvxShadowItem( aPardMap.nShadow, nullptr, 60 /*3pt*/,
1520 0 : SVX_SHADOW_BOTTOMRIGHT ) );
1521 0 : break;
1522 :
1523 : case RTF_BRSP: // Spacing to content in twip
1524 : {
1525 0 : switch( nBorderTyp )
1526 : {
1527 : case RTF_BRDRB:
1528 0 : aAttr.SetDistance( (sal_uInt16)nTokenValue, SvxBoxItemLine::BOTTOM );
1529 0 : break;
1530 :
1531 : case RTF_BRDRT:
1532 0 : aAttr.SetDistance( (sal_uInt16)nTokenValue, SvxBoxItemLine::TOP );
1533 0 : break;
1534 :
1535 : case RTF_BRDRL:
1536 0 : aAttr.SetDistance( (sal_uInt16)nTokenValue, SvxBoxItemLine::LEFT );
1537 0 : break;
1538 :
1539 : case RTF_BRDRR:
1540 0 : aAttr.SetDistance( (sal_uInt16)nTokenValue, SvxBoxItemLine::RIGHT );
1541 0 : break;
1542 :
1543 : case RTF_BOX:
1544 0 : aAttr.SetDistance( (sal_uInt16)nTokenValue );
1545 0 : break;
1546 : }
1547 : }
1548 0 : break;
1549 :
1550 : case RTF_BRDRBTW: // Border formatting group
1551 : case RTF_BRDRBAR: // Border outside
1552 : // TODO unhandled ATM
1553 0 : break;
1554 :
1555 : default:
1556 0 : bContinue = (nToken & ~(0xff| RTF_SWGDEFS)) == RTF_BRDRDEF;
1557 : }
1558 0 : if( bContinue )
1559 0 : nToken = GetNextToken();
1560 : } while( bContinue );
1561 :
1562 : // Finally compute the border width
1563 0 : if ( bDoubleWidth ) nWidth *= 2;
1564 0 : aBrd.SetWidth( nWidth );
1565 :
1566 0 : SetBorderLine( nBorderTyp, aAttr, aBrd );
1567 :
1568 0 : rSet.Put( aAttr );
1569 0 : SkipToken( -1 );
1570 0 : }
1571 :
1572 0 : inline sal_uInt32 CalcShading( sal_uInt32 nColor, sal_uInt32 nFillColor, sal_uInt8 nShading )
1573 : {
1574 0 : nColor = (nColor * nShading) / 100;
1575 0 : nFillColor = (nFillColor * ( 100 - nShading )) / 100;
1576 0 : return nColor + nFillColor;
1577 : }
1578 :
1579 0 : void SvxRTFParser::ReadBackgroundAttr( int nToken, SfxItemSet& rSet,
1580 : bool bTableDef )
1581 : {
1582 : // then read the border attribute
1583 0 : bool bContinue = true;
1584 0 : sal_uInt16 nColor = USHRT_MAX, nFillColor = USHRT_MAX;
1585 0 : sal_uInt8 nFillValue = 0;
1586 :
1587 0 : sal_uInt16 nWh = ( nToken & ~0xff ) == RTF_CHRFMT
1588 : ? aPlainMap.nBgColor
1589 0 : : aPardMap.nBrush;
1590 :
1591 0 : do {
1592 0 : switch( nToken )
1593 : {
1594 : case RTF_CLCBPAT:
1595 : case RTF_CHCBPAT:
1596 : case RTF_CBPAT:
1597 0 : nFillColor = sal_uInt16( nTokenValue );
1598 0 : break;
1599 :
1600 : case RTF_CLCFPAT:
1601 : case RTF_CHCFPAT:
1602 : case RTF_CFPAT:
1603 0 : nColor = sal_uInt16( nTokenValue );
1604 0 : break;
1605 :
1606 : case RTF_CLSHDNG:
1607 : case RTF_CHSHDNG:
1608 : case RTF_SHADING:
1609 0 : nFillValue = (sal_uInt8)( nTokenValue / 100 );
1610 0 : break;
1611 :
1612 : case RTF_CLBGDKHOR:
1613 : case RTF_CHBGDKHORIZ:
1614 : case RTF_BGDKHORIZ:
1615 : case RTF_CLBGDKVERT:
1616 : case RTF_CHBGDKVERT:
1617 : case RTF_BGDKVERT:
1618 : case RTF_CLBGDKBDIAG:
1619 : case RTF_CHBGDKBDIAG:
1620 : case RTF_BGDKBDIAG:
1621 : case RTF_CLBGDKFDIAG:
1622 : case RTF_CHBGDKFDIAG:
1623 : case RTF_BGDKFDIAG:
1624 : case RTF_CLBGDKCROSS:
1625 : case RTF_CHBGDKCROSS:
1626 : case RTF_BGDKCROSS:
1627 : case RTF_CLBGDKDCROSS:
1628 : case RTF_CHBGDKDCROSS:
1629 : case RTF_BGDKDCROSS:
1630 : // dark -> 60%
1631 0 : nFillValue = 60;
1632 0 : break;
1633 :
1634 : case RTF_CLBGHORIZ:
1635 : case RTF_CHBGHORIZ:
1636 : case RTF_BGHORIZ:
1637 : case RTF_CLBGVERT:
1638 : case RTF_CHBGVERT:
1639 : case RTF_BGVERT:
1640 : case RTF_CLBGBDIAG:
1641 : case RTF_CHBGBDIAG:
1642 : case RTF_BGBDIAG:
1643 : case RTF_CLBGFDIAG:
1644 : case RTF_CHBGFDIAG:
1645 : case RTF_BGFDIAG:
1646 : case RTF_CLBGCROSS:
1647 : case RTF_CHBGCROSS:
1648 : case RTF_BGCROSS:
1649 : case RTF_CLBGDCROSS:
1650 : case RTF_CHBGDCROSS:
1651 : case RTF_BGDCROSS:
1652 : // light -> 20%
1653 0 : nFillValue = 20;
1654 0 : break;
1655 :
1656 : default:
1657 0 : if( bTableDef )
1658 0 : bContinue = (nToken & ~(0xff | RTF_TABLEDEF) ) == RTF_SHADINGDEF;
1659 : else
1660 0 : bContinue = (nToken & ~0xff) == RTF_SHADINGDEF;
1661 : }
1662 0 : if( bContinue )
1663 0 : nToken = GetNextToken();
1664 : } while( bContinue );
1665 :
1666 0 : Color aCol( COL_WHITE ), aFCol;
1667 0 : if( !nFillValue )
1668 : {
1669 : // there was only one of two colors specified or no BrushTyp
1670 0 : if( USHRT_MAX != nFillColor )
1671 : {
1672 0 : nFillValue = 100;
1673 0 : aCol = GetColor( nFillColor );
1674 : }
1675 0 : else if( USHRT_MAX != nColor )
1676 0 : aFCol = GetColor( nColor );
1677 : }
1678 : else
1679 : {
1680 0 : if( USHRT_MAX != nColor )
1681 0 : aCol = GetColor( nColor );
1682 : else
1683 0 : aCol = Color( COL_BLACK );
1684 :
1685 0 : if( USHRT_MAX != nFillColor )
1686 0 : aFCol = GetColor( nFillColor );
1687 : else
1688 0 : aFCol = Color( COL_WHITE );
1689 : }
1690 :
1691 0 : Color aColor;
1692 0 : if( 0 == nFillValue || 100 == nFillValue )
1693 0 : aColor = aCol;
1694 : else
1695 : aColor = Color(
1696 0 : (sal_uInt8)CalcShading( aCol.GetRed(), aFCol.GetRed(), nFillValue ),
1697 0 : (sal_uInt8)CalcShading( aCol.GetGreen(), aFCol.GetGreen(), nFillValue ),
1698 0 : (sal_uInt8)CalcShading( aCol.GetBlue(), aFCol.GetBlue(), nFillValue ) );
1699 :
1700 0 : rSet.Put( SvxBrushItem( aColor, nWh ) );
1701 0 : SkipToken( -1 );
1702 0 : }
1703 :
1704 :
1705 : // pard / plain handling
1706 0 : void SvxRTFParser::RTFPardPlain( bool const bPard, SfxItemSet** ppSet )
1707 : {
1708 0 : if( !bNewGroup && !aAttrStack.empty() ) // not at the beginning of a new group
1709 : {
1710 0 : SvxRTFItemStackType* pAkt = aAttrStack.back();
1711 :
1712 0 : int nLastToken = GetStackPtr(-1)->nTokenId;
1713 0 : bool bNewStkEntry = true;
1714 0 : if( RTF_PARD != nLastToken &&
1715 0 : RTF_PLAIN != nLastToken &&
1716 : BRACELEFT != nLastToken )
1717 : {
1718 0 : if( pAkt->aAttrSet.Count() || pAkt->pChildList || pAkt->nStyleNo )
1719 : {
1720 : // open a new group
1721 0 : SvxRTFItemStackType* pNew = new SvxRTFItemStackType( *pAkt, *pInsPos, true );
1722 0 : pNew->SetRTFDefaults( GetRTFDefaults() );
1723 :
1724 : // Set all until here valid attributes
1725 0 : AttrGroupEnd();
1726 0 : pAkt = aAttrStack.empty() ? 0 : aAttrStack.back(); // can be changed after AttrGroupEnd!
1727 0 : pNew->aAttrSet.SetParent( pAkt ? &pAkt->aAttrSet : 0 );
1728 0 : aAttrStack.push_back( pNew );
1729 0 : pAkt = pNew;
1730 : }
1731 : else
1732 : {
1733 : // continue to use this entry as new
1734 0 : pAkt->SetStartPos( *pInsPos );
1735 0 : bNewStkEntry = false;
1736 : }
1737 : }
1738 :
1739 : // now reset all to default
1740 0 : if( bNewStkEntry &&
1741 0 : ( pAkt->aAttrSet.GetParent() || pAkt->aAttrSet.Count() ))
1742 : {
1743 : const SfxPoolItem *pItem, *pDef;
1744 : const sal_uInt16* pPtr;
1745 : sal_uInt16 nCnt;
1746 0 : const SfxItemSet* pDfltSet = &GetRTFDefaults();
1747 0 : if( bPard )
1748 : {
1749 0 : pAkt->nStyleNo = 0;
1750 0 : pPtr = reinterpret_cast<sal_uInt16*>(&aPardMap);
1751 0 : nCnt = sizeof(aPardMap) / sizeof(sal_uInt16);
1752 : }
1753 : else
1754 : {
1755 0 : pPtr = reinterpret_cast<sal_uInt16*>(&aPlainMap);
1756 0 : nCnt = sizeof(aPlainMap) / sizeof(sal_uInt16);
1757 : }
1758 :
1759 0 : for( sal_uInt16 n = 0; n < nCnt; ++n, ++pPtr )
1760 : {
1761 : // Item set and different -> Set the Default Pool
1762 0 : if( !*pPtr )
1763 : ;
1764 0 : else if( SFX_WHICH_MAX < *pPtr )
1765 0 : pAkt->aAttrSet.ClearItem( *pPtr );
1766 0 : else if( IsChkStyleAttr() )
1767 0 : pAkt->aAttrSet.Put( pDfltSet->Get( *pPtr ) );
1768 0 : else if( !pAkt->aAttrSet.GetParent() )
1769 : {
1770 0 : if( SfxItemState::SET ==
1771 0 : pDfltSet->GetItemState( *pPtr, false, &pDef ))
1772 0 : pAkt->aAttrSet.Put( *pDef );
1773 : else
1774 0 : pAkt->aAttrSet.ClearItem( *pPtr );
1775 : }
1776 0 : else if( SfxItemState::SET == pAkt->aAttrSet.GetParent()->
1777 0 : GetItemState( *pPtr, true, &pItem ) &&
1778 0 : *( pDef = &pDfltSet->Get( *pPtr )) != *pItem )
1779 0 : pAkt->aAttrSet.Put( *pDef );
1780 : else
1781 : {
1782 0 : if( SfxItemState::SET ==
1783 0 : pDfltSet->GetItemState( *pPtr, false, &pDef ))
1784 0 : pAkt->aAttrSet.Put( *pDef );
1785 : else
1786 0 : pAkt->aAttrSet.ClearItem( *pPtr );
1787 : }
1788 : }
1789 : }
1790 0 : else if( bPard )
1791 0 : pAkt->nStyleNo = 0; // reset Style number
1792 :
1793 0 : *ppSet = &pAkt->aAttrSet;
1794 :
1795 0 : if (!bPard)
1796 : {
1797 : //Once we have a default font, then any text without a font specifier is
1798 : //in the default font, and thus has the default font charset, otherwise
1799 : //we can fall back to the ansicpg set codeset
1800 0 : if (nDfltFont != -1)
1801 : {
1802 0 : const vcl::Font& rSVFont = GetFont(sal_uInt16(nDfltFont));
1803 0 : SetEncoding(rSVFont.GetCharSet());
1804 : }
1805 : else
1806 0 : SetEncoding(GetCodeSet());
1807 : }
1808 : }
1809 0 : }
1810 :
1811 0 : void SvxRTFParser::SetDefault( int nToken, int nValue )
1812 : {
1813 0 : if( !bNewDoc )
1814 0 : return;
1815 :
1816 0 : SfxItemSet aTmp( *pAttrPool, &aWhichMap[0] );
1817 0 : bool bOldFlag = bIsLeftToRightDef;
1818 0 : bIsLeftToRightDef = true;
1819 0 : switch( nToken )
1820 : {
1821 0 : case RTF_ADEFF: bIsLeftToRightDef = false; // no break!
1822 : case RTF_DEFF:
1823 : {
1824 0 : if( -1 == nValue )
1825 0 : nValue = 0;
1826 0 : const vcl::Font& rSVFont = GetFont( sal_uInt16(nValue) );
1827 : SvxFontItem aTmpItem(
1828 0 : rSVFont.GetFamily(), rSVFont.GetName(),
1829 0 : rSVFont.GetStyleName(), rSVFont.GetPitch(),
1830 0 : rSVFont.GetCharSet(), SID_ATTR_CHAR_FONT );
1831 0 : SetScriptAttr( NOTDEF_CHARTYPE, aTmp, aTmpItem );
1832 : }
1833 0 : break;
1834 :
1835 0 : case RTF_ADEFLANG: bIsLeftToRightDef = false; // no break!
1836 : case RTF_DEFLANG:
1837 : // store default Language
1838 0 : if( -1 != nValue )
1839 : {
1840 : SvxLanguageItem aTmpItem( (const LanguageType)nValue,
1841 0 : SID_ATTR_CHAR_LANGUAGE );
1842 0 : SetScriptAttr( NOTDEF_CHARTYPE, aTmp, aTmpItem );
1843 : }
1844 0 : break;
1845 :
1846 : case RTF_DEFTAB:
1847 0 : if( aPardMap.nTabStop )
1848 : {
1849 : // RTF defines 720 twips as default
1850 0 : bIsSetDfltTab = true;
1851 0 : if( -1 == nValue || !nValue )
1852 0 : nValue = 720;
1853 :
1854 : // who would like to have no twips ...
1855 0 : if( IsCalcValue() )
1856 : {
1857 0 : nTokenValue = nValue;
1858 0 : CalcValue();
1859 0 : nValue = nTokenValue;
1860 : }
1861 :
1862 : // Calculate the ratio of default TabWidth / Tabs and
1863 : // calculate the corresponding new number.
1864 : // ?? how did one come up with 13 ??
1865 0 : sal_uInt16 nTabCount = (SVX_TAB_DEFDIST * 13 ) / sal_uInt16(nValue);
1866 : /*
1867 : cmc, make sure we have at least one, or all hell breaks loose in
1868 : everybodies exporters, #i8247#
1869 : */
1870 0 : if (nTabCount < 1)
1871 0 : nTabCount = 1;
1872 :
1873 : // we want Defaulttabs
1874 : SvxTabStopItem aNewTab( nTabCount, sal_uInt16(nValue),
1875 0 : SVX_TAB_ADJUST_DEFAULT, aPardMap.nTabStop );
1876 0 : while( nTabCount )
1877 0 : ((SvxTabStop&)aNewTab[ --nTabCount ]).GetAdjustment() = SVX_TAB_ADJUST_DEFAULT;
1878 :
1879 0 : pAttrPool->SetPoolDefaultItem( aNewTab );
1880 : }
1881 0 : break;
1882 : }
1883 0 : bIsLeftToRightDef = bOldFlag;
1884 :
1885 0 : if( aTmp.Count() )
1886 : {
1887 0 : SfxItemIter aIter( aTmp );
1888 0 : const SfxPoolItem* pItem = aIter.GetCurItem();
1889 : while( true )
1890 : {
1891 0 : pAttrPool->SetPoolDefaultItem( *pItem );
1892 0 : if( aIter.IsAtEnd() )
1893 0 : break;
1894 0 : pItem = aIter.NextItem();
1895 0 : }
1896 0 : }
1897 : }
1898 :
1899 : // default: no conversion, leaving everything in twips.
1900 0 : void SvxRTFParser::CalcValue()
1901 : {
1902 0 : }
1903 :
1904 : // for tokens that are not evaluated in ReadAttr
1905 0 : void SvxRTFParser::UnknownAttrToken( int, SfxItemSet* )
1906 : {
1907 444 : }
1908 :
1909 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
