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