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

Generated by: LCOV version 1.10