LCOV - code coverage report
Current view: top level - editeng/source/rtf - rtfitem.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 1 902 0.1 %
Date: 2015-06-13 12:38:46 Functions: 2 17 11.8 %
Legend: Lines: hit not hit

          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: */

Generated by: LCOV version 1.11