LCOV - code coverage report
Current view: top level - sw/source/core/txtnode - swfont.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 911 0.0 %
Date: 2014-04-14 Functions: 0 39 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             : #include <hintids.hxx>
      21             : 
      22             : #include <com/sun/star/i18n/ScriptType.hpp>
      23             : #include <vcl/outdev.hxx>
      24             : #include <unotools/localedatawrapper.hxx>
      25             : #include <editeng/unolingu.hxx>
      26             : #include <editeng/brushitem.hxx>
      27             : #include <editeng/wrlmitem.hxx>
      28             : #include <editeng/blinkitem.hxx>
      29             : #include <editeng/nhypitem.hxx>
      30             : #include <editeng/kernitem.hxx>
      31             : #include <editeng/cmapitem.hxx>
      32             : #include <editeng/langitem.hxx>
      33             : #include <editeng/escapementitem.hxx>
      34             : #include <editeng/autokernitem.hxx>
      35             : #include <editeng/shdditem.hxx>
      36             : #include <editeng/charreliefitem.hxx>
      37             : #include <editeng/contouritem.hxx>
      38             : #include <editeng/colritem.hxx>
      39             : #include <editeng/charsetcoloritem.hxx>
      40             : #include <editeng/crossedoutitem.hxx>
      41             : #include <editeng/udlnitem.hxx>
      42             : #include <editeng/wghtitem.hxx>
      43             : #include <editeng/postitem.hxx>
      44             : #include <editeng/fhgtitem.hxx>
      45             : #include <editeng/fontitem.hxx>
      46             : #include <editeng/emphasismarkitem.hxx>
      47             : #include <editeng/charscaleitem.hxx>
      48             : #include <editeng/charrotateitem.hxx>
      49             : #include <editeng/twolinesitem.hxx>
      50             : #include <editeng/charhiddenitem.hxx>
      51             : #include <editeng/boxitem.hxx>
      52             : #include <editeng/shaditem.hxx>
      53             : #include <IDocumentSettingAccess.hxx>
      54             : #include <vcl/window.hxx>
      55             : #include <charatr.hxx>
      56             : #include <viewsh.hxx>
      57             : #include <swfont.hxx>
      58             : #include <fntcache.hxx>
      59             : #include <txtfrm.hxx>
      60             : #include <scriptinfo.hxx>
      61             : 
      62             : #ifdef DBG_UTIL
      63             : // global Variable
      64             : SvStatistics g_SvStat;
      65             : #endif
      66             : 
      67             : using namespace ::com::sun::star;
      68             : 
      69             : /************************************************************************
      70             :  * Hintergrundbrush setzen, z.B. bei Zeichenvorlagen
      71             :  ***********************************************************************/
      72           0 : void SwFont::SetBackColor( Color* pNewColor )
      73             : {
      74           0 :     delete pBackColor;
      75           0 :     pBackColor = pNewColor;
      76           0 :     bFntChg = sal_True;
      77           0 :     aSub[SW_LATIN].pMagic = aSub[SW_CJK].pMagic = aSub[SW_CTL].pMagic = 0;
      78           0 : }
      79             : 
      80           0 : void SwFont::SetTopBorder( const editeng::SvxBorderLine* pTopBorder )
      81             : {
      82           0 :     if( pTopBorder )
      83           0 :         m_aTopBorder = *pTopBorder;
      84             :     else
      85             :     {
      86           0 :         m_aTopBorder = boost::none;
      87           0 :         m_nTopBorderDist = 0;
      88             :     }
      89           0 :     bFntChg = sal_True;
      90           0 :     aSub[SW_LATIN].pMagic = aSub[SW_CJK].pMagic = aSub[SW_CTL].pMagic = 0;
      91           0 : }
      92             : 
      93           0 : void SwFont::SetBottomBorder( const editeng::SvxBorderLine* pBottomBorder )
      94             : {
      95           0 :     if( pBottomBorder )
      96           0 :         m_aBottomBorder = *pBottomBorder;
      97             :     else
      98             :     {
      99           0 :         m_aBottomBorder = boost::none;
     100           0 :         m_nBottomBorderDist = 0;
     101             :     }
     102           0 :     bFntChg = sal_True;
     103           0 :     aSub[SW_LATIN].pMagic = aSub[SW_CJK].pMagic = aSub[SW_CTL].pMagic = 0;
     104           0 : }
     105             : 
     106           0 : void SwFont::SetRightBorder( const editeng::SvxBorderLine* pRightBorder )
     107             : {
     108           0 :     if( pRightBorder )
     109           0 :         m_aRightBorder = *pRightBorder;
     110             :     else
     111             :     {
     112           0 :         m_aRightBorder = boost::none;
     113           0 :         m_nRightBorderDist = 0;
     114             :     }
     115           0 :     bFntChg = sal_True;
     116           0 :     aSub[SW_LATIN].pMagic = aSub[SW_CJK].pMagic = aSub[SW_CTL].pMagic = 0;
     117           0 : }
     118             : 
     119           0 : void SwFont::SetLeftBorder( const editeng::SvxBorderLine* pLeftBorder )
     120             : {
     121           0 :     if( pLeftBorder )
     122           0 :         m_aLeftBorder = *pLeftBorder;
     123             :     else
     124             :     {
     125           0 :         m_aLeftBorder = boost::none;
     126           0 :         m_nLeftBorderDist = 0;
     127             :     }
     128           0 :     bFntChg = sal_True;
     129           0 :     aSub[SW_LATIN].pMagic = aSub[SW_CJK].pMagic = aSub[SW_CTL].pMagic = 0;
     130           0 : }
     131             : 
     132             : const boost::optional<editeng::SvxBorderLine>&
     133           0 : SwFont::GetAbsTopBorder( const bool bVertLayout ) const
     134             : {
     135           0 :     switch( GetOrientation( bVertLayout ) )
     136             :     {
     137             :         case 0 :
     138           0 :             return m_aTopBorder;
     139             :             break;
     140             :         case 900 :
     141           0 :             return m_aRightBorder;
     142             :             break;
     143             :         case 1800 :
     144           0 :             return m_aBottomBorder;
     145             :             break;
     146             :         case 2700 :
     147           0 :             return m_aLeftBorder;
     148             :             break;
     149             :         default :
     150             :             assert(false);
     151           0 :             return m_aTopBorder;
     152             :             break;
     153             :     }
     154             : }
     155             : 
     156             : const boost::optional<editeng::SvxBorderLine>&
     157           0 : SwFont::GetAbsBottomBorder( const bool bVertLayout ) const
     158             : {
     159           0 :     switch( GetOrientation( bVertLayout ) )
     160             :     {
     161             :         case 0 :
     162           0 :             return m_aBottomBorder;
     163             :             break;
     164             :         case 900 :
     165           0 :             return m_aLeftBorder;
     166             :             break;
     167             :         case 1800 :
     168           0 :             return m_aTopBorder;
     169             :             break;
     170             :         case 2700 :
     171           0 :             return m_aRightBorder;
     172             :             break;
     173             :         default :
     174             :             assert(false);
     175           0 :             return m_aBottomBorder;
     176             :             break;
     177             :     }
     178             : }
     179             : 
     180             : const boost::optional<editeng::SvxBorderLine>&
     181           0 : SwFont::GetAbsLeftBorder( const bool bVertLayout ) const
     182             : {
     183           0 :     switch( GetOrientation( bVertLayout ) )
     184             :     {
     185             :         case 0 :
     186           0 :             return m_aLeftBorder;
     187             :             break;
     188             :         case 900 :
     189           0 :             return m_aTopBorder;
     190             :             break;
     191             :         case 1800 :
     192           0 :             return m_aRightBorder;
     193             :             break;
     194             :         case 2700 :
     195           0 :             return m_aBottomBorder;
     196             :             break;
     197             :         default :
     198             :             assert(false);
     199           0 :             return m_aLeftBorder;
     200             :             break;
     201             :     }
     202             : }
     203             : 
     204             : const boost::optional<editeng::SvxBorderLine>&
     205           0 : SwFont::GetAbsRightBorder( const bool bVertLayout ) const
     206             : {
     207           0 :     switch( GetOrientation( bVertLayout ) )
     208             :     {
     209             :         case 0 :
     210           0 :             return m_aRightBorder;
     211             :             break;
     212             :         case 900 :
     213           0 :             return m_aBottomBorder;
     214             :             break;
     215             :         case 1800 :
     216           0 :             return m_aLeftBorder;
     217             :             break;
     218             :         case 2700 :
     219           0 :             return m_aTopBorder;
     220             :             break;
     221             :         default :
     222             :             assert(false);
     223           0 :             return m_aRightBorder;
     224             :             break;
     225             :     }
     226             : }
     227             : 
     228           0 : SvxShadowLocation SwFont::GetAbsShadowLocation( const bool bVertLayout ) const
     229             : {
     230           0 :     SvxShadowLocation aLocation = SVX_SHADOW_NONE;
     231           0 :     switch( GetOrientation( bVertLayout ) )
     232             :     {
     233             :         case 0:
     234           0 :             aLocation = m_aShadowLocation;
     235           0 :             break;
     236             : 
     237             :         case 900:
     238           0 :             switch ( m_aShadowLocation )
     239             :             {
     240             :                 case SVX_SHADOW_TOPLEFT:
     241           0 :                     aLocation = SVX_SHADOW_BOTTOMLEFT;
     242           0 :                     break;
     243             :                 case SVX_SHADOW_TOPRIGHT:
     244           0 :                     aLocation = SVX_SHADOW_TOPLEFT;
     245           0 :                     break;
     246             :                 case SVX_SHADOW_BOTTOMLEFT:
     247           0 :                     aLocation = SVX_SHADOW_BOTTOMRIGHT;
     248           0 :                     break;
     249             :                 case SVX_SHADOW_BOTTOMRIGHT:
     250           0 :                     aLocation = SVX_SHADOW_TOPRIGHT;
     251           0 :                     break;
     252             :                 case SVX_SHADOW_NONE:
     253             :                 case SVX_SHADOW_END:
     254           0 :                     aLocation = m_aShadowLocation;
     255           0 :                     break;
     256             :             }
     257           0 :             break;
     258             : 
     259             :         case 1800:
     260           0 :             switch ( m_aShadowLocation )
     261             :             {
     262             :                 case SVX_SHADOW_TOPLEFT:
     263           0 :                     aLocation = SVX_SHADOW_BOTTOMRIGHT;
     264           0 :                     break;
     265             :                 case SVX_SHADOW_TOPRIGHT:
     266           0 :                     aLocation = SVX_SHADOW_BOTTOMLEFT;
     267           0 :                     break;
     268             :                 case SVX_SHADOW_BOTTOMLEFT:
     269           0 :                     aLocation = SVX_SHADOW_TOPRIGHT;
     270           0 :                     break;
     271             :                 case SVX_SHADOW_BOTTOMRIGHT:
     272           0 :                     aLocation = SVX_SHADOW_TOPLEFT;
     273           0 :                     break;
     274             :                 case SVX_SHADOW_NONE:
     275             :                 case SVX_SHADOW_END:
     276           0 :                     aLocation = m_aShadowLocation;
     277           0 :                     break;
     278             :             }
     279           0 :             break;
     280             : 
     281             :         case 2700:
     282           0 :             switch ( m_aShadowLocation )
     283             :             {
     284             :                 case SVX_SHADOW_TOPLEFT:
     285           0 :                     aLocation = SVX_SHADOW_TOPRIGHT;
     286           0 :                     break;
     287             :                 case SVX_SHADOW_TOPRIGHT:
     288           0 :                     aLocation = SVX_SHADOW_BOTTOMRIGHT;
     289           0 :                     break;
     290             :                 case SVX_SHADOW_BOTTOMLEFT:
     291           0 :                     aLocation = SVX_SHADOW_TOPLEFT;
     292           0 :                     break;
     293             :                 case SVX_SHADOW_BOTTOMRIGHT:
     294           0 :                     aLocation = SVX_SHADOW_BOTTOMLEFT;
     295           0 :                     break;
     296             :                 case SVX_SHADOW_NONE:
     297             :                 case SVX_SHADOW_END:
     298           0 :                     aLocation = m_aShadowLocation;
     299           0 :                     break;
     300             :             }
     301           0 :             break;
     302             : 
     303             :         default:
     304             :             assert(false);
     305           0 :             break;
     306             :     }
     307           0 :     return aLocation;
     308             : }
     309             : 
     310           0 : sal_uInt16 SwFont::CalcShadowSpace(
     311             :         const sal_uInt16 nShadow, const bool bVertLayout,
     312             :         const bool bSkipLeft, const bool bSkipRight ) const
     313             : {
     314           0 :     sal_uInt16 nSpace = 0;
     315           0 :     const sal_uInt16 nOrient = GetOrientation( bVertLayout );
     316           0 :     const SvxShadowLocation aLoc = GetAbsShadowLocation( bVertLayout );
     317           0 :     switch( nShadow )
     318             :     {
     319             :         case SHADOW_TOP:
     320           0 :             if(( aLoc == SVX_SHADOW_TOPLEFT ||
     321           0 :                aLoc == SVX_SHADOW_TOPRIGHT ) &&
     322           0 :                ( nOrient == 0 || nOrient == 1800 ||
     323           0 :                ( nOrient == 900 && !bSkipRight ) ||
     324           0 :                ( nOrient == 2700 && !bSkipLeft )))
     325             :             {
     326           0 :                 nSpace = m_nShadowWidth;
     327             :             }
     328           0 :             break;
     329             : 
     330             :         case SHADOW_BOTTOM:
     331           0 :             if(( aLoc == SVX_SHADOW_BOTTOMLEFT ||
     332           0 :                aLoc == SVX_SHADOW_BOTTOMRIGHT ) &&
     333           0 :                ( nOrient == 0 || nOrient == 1800 ||
     334           0 :                ( nOrient == 900 && !bSkipLeft ) ||
     335           0 :                ( nOrient == 2700 && !bSkipRight )))
     336             :             {
     337           0 :                 nSpace = m_nShadowWidth;
     338             :             }
     339           0 :             break;
     340             : 
     341             :         case SHADOW_LEFT:
     342           0 :             if(( aLoc == SVX_SHADOW_TOPLEFT ||
     343           0 :                aLoc == SVX_SHADOW_BOTTOMLEFT ) &&
     344           0 :                ( nOrient == 900 || nOrient == 2700 ||
     345           0 :                ( nOrient == 0 && !bSkipLeft ) ||
     346           0 :                ( nOrient == 1800 && !bSkipRight )))
     347             :             {
     348           0 :                 nSpace = m_nShadowWidth;
     349             :             }
     350           0 :             break;
     351             : 
     352             :          case SHADOW_RIGHT:
     353           0 :             if(( aLoc == SVX_SHADOW_TOPRIGHT ||
     354           0 :                aLoc == SVX_SHADOW_BOTTOMRIGHT ) &&
     355           0 :                ( nOrient == 900 || nOrient == 2700 ||
     356           0 :                ( nOrient == 0 && !bSkipRight ) ||
     357           0 :                ( nOrient == 1800 && !bSkipLeft )))
     358             :             {
     359           0 :                 nSpace = m_nShadowWidth;
     360             :             }
     361           0 :             break;
     362             :         default:
     363             :             assert(false);
     364           0 :             break;
     365             :     }
     366             : 
     367           0 :     return nSpace;
     368             : }
     369             : 
     370             : // maps directions for vertical layout
     371           0 : sal_uInt16 MapDirection( sal_uInt16 nDir, const sal_Bool bVertFormat )
     372             : {
     373           0 :     if ( bVertFormat )
     374             :     {
     375           0 :         switch ( nDir )
     376             :         {
     377             :         case 0 :
     378           0 :             nDir = 2700;
     379           0 :             break;
     380             :         case 900 :
     381           0 :             nDir = 0;
     382           0 :             break;
     383             :         case 2700 :
     384           0 :             nDir = 1800;
     385           0 :             break;
     386             : #if OSL_DEBUG_LEVEL > 0
     387             :         default :
     388             :             OSL_FAIL( "Unsupported direction" );
     389             :             break;
     390             : #endif
     391             :         }
     392             :     }
     393           0 :     return nDir;
     394             : }
     395             : 
     396             : // maps the absolute direction set at the font to its logical conterpart
     397             : // in the rotated environment
     398           0 : sal_uInt16 UnMapDirection( sal_uInt16 nDir, const sal_Bool bVertFormat )
     399             : {
     400           0 :     if ( bVertFormat )
     401             :     {
     402           0 :         switch ( nDir )
     403             :         {
     404             :         case 0 :
     405           0 :             nDir = 900;
     406           0 :             break;
     407             :         case 1800 :
     408           0 :             nDir = 2700;
     409           0 :             break;
     410             :         case 2700 :
     411           0 :             nDir = 0;
     412           0 :             break;
     413             : #if OSL_DEBUG_LEVEL > 0
     414             :         default :
     415             :             OSL_FAIL( "Unsupported direction" );
     416             :             break;
     417             : #endif
     418             :         }
     419             :     }
     420           0 :     return nDir;
     421             : }
     422             : 
     423           0 : sal_uInt16 SwFont::GetOrientation( const sal_Bool bVertFormat ) const
     424             : {
     425           0 :     return UnMapDirection( aSub[nActual].GetOrientation(), bVertFormat );
     426             : }
     427             : 
     428           0 : void SwFont::SetVertical( sal_uInt16 nDir, const sal_Bool bVertFormat )
     429             : {
     430             :     // map direction if frame has vertical layout
     431           0 :     nDir = MapDirection( nDir, bVertFormat );
     432             : 
     433           0 :     if( nDir != aSub[0].GetOrientation() )
     434             :     {
     435           0 :         bFntChg = sal_True;
     436           0 :         aSub[0].SetVertical( nDir, bVertFormat );
     437           0 :         aSub[1].SetVertical( nDir, bVertFormat || nDir > 1000 );
     438           0 :         aSub[2].SetVertical( nDir, bVertFormat );
     439             :     }
     440           0 : }
     441             : 
     442             : /*************************************************************************
     443             :  Escapement:
     444             :     frEsc:  Fraction, Grad des Escapements
     445             :     Esc = resultierendes Escapement
     446             :     A1 = Original-Ascent            (nOrgAscent)
     447             :     A2 = verkleinerter Ascent       (nEscAscent)
     448             :     Ax = resultierender Ascent      (GetAscent())
     449             :     H1 = Original-Hoehe             (nOrgHeight)
     450             :     H2 = verkleinerter Hoehe        (nEscHeight)
     451             :     Hx = resultierender Hoehe       (GetHeight())
     452             :     Bx = resultierende Baseline fuer die Textausgabe (CalcPos())
     453             :          (Vorsicht: Y - A1!)
     454             : 
     455             :     Escapement:
     456             :         Esc = H1 * frEsc;
     457             : 
     458             :     Hochstellung:
     459             :         Ax = A2 + Esc;
     460             :         Hx = H2 + Esc;
     461             :         Bx = A1 - Esc;
     462             : 
     463             :     Tiefstellung:
     464             :         Ax = A1;
     465             :         Hx = A1 + Esc + (H2 - A2);
     466             :         Bx = A1 + Esc;
     467             : 
     468             : *************************************************************************/
     469             : 
     470             : // nEsc ist der Prozentwert
     471           0 : sal_uInt16 SwSubFont::CalcEscAscent( const sal_uInt16 nOldAscent ) const
     472             : {
     473           0 :     if( DFLT_ESC_AUTO_SUPER != GetEscapement() &&
     474           0 :         DFLT_ESC_AUTO_SUB != GetEscapement() )
     475             :     {
     476           0 :         const long nAscent = nOldAscent +
     477           0 :                              ( (long) nOrgHeight * GetEscapement() ) / 100L;
     478           0 :         if ( nAscent>0 )
     479           0 :             return ( std::max( sal_uInt16 (nAscent), nOrgAscent ));
     480             :     }
     481           0 :     return nOrgAscent;
     482             : }
     483             : 
     484           0 : void SwFont::SetDiffFnt( const SfxItemSet *pAttrSet,
     485             :                          const IDocumentSettingAccess *pIDocumentSettingAccess )
     486             : {
     487           0 :     delete pBackColor;
     488           0 :     pBackColor = NULL;
     489             : 
     490           0 :     if( pAttrSet )
     491             :     {
     492             :         const SfxPoolItem* pItem;
     493           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_FONT,
     494           0 :             true, &pItem ))
     495             :         {
     496           0 :             const SvxFontItem *pFont = (const SvxFontItem *)pItem;
     497           0 :             aSub[SW_LATIN].SetFamily( pFont->GetFamily() );
     498           0 :             aSub[SW_LATIN].Font::SetName( pFont->GetFamilyName() );
     499           0 :             aSub[SW_LATIN].Font::SetStyleName( pFont->GetStyleName() );
     500           0 :             aSub[SW_LATIN].Font::SetPitch( pFont->GetPitch() );
     501           0 :             aSub[SW_LATIN].Font::SetCharSet( pFont->GetCharSet() );
     502             :         }
     503           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_FONTSIZE,
     504           0 :             true, &pItem ))
     505             :         {
     506           0 :             const SvxFontHeightItem *pHeight = (const SvxFontHeightItem *)pItem;
     507           0 :             aSub[SW_LATIN].SvxFont::SetPropr( 100 );
     508           0 :             aSub[SW_LATIN].aSize = aSub[SW_LATIN].Font::GetSize();
     509           0 :             Size aTmpSize = aSub[SW_LATIN].aSize;
     510           0 :             aTmpSize.Height() = pHeight->GetHeight();
     511           0 :             aSub[SW_LATIN].SetSize( aTmpSize );
     512             :         }
     513           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_POSTURE,
     514           0 :             true, &pItem ))
     515           0 :             aSub[SW_LATIN].Font::SetItalic( ((SvxPostureItem*)pItem)->GetPosture() );
     516           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_WEIGHT,
     517           0 :             true, &pItem ))
     518           0 :             aSub[SW_LATIN].Font::SetWeight( ((SvxWeightItem*)pItem)->GetWeight() );
     519           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_LANGUAGE,
     520           0 :             true, &pItem ))
     521           0 :             aSub[SW_LATIN].SetLanguage( ((SvxLanguageItem*)pItem)->GetLanguage() );
     522             : 
     523           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_CJK_FONT,
     524           0 :             true, &pItem ))
     525             :         {
     526           0 :             const SvxFontItem *pFont = (const SvxFontItem *)pItem;
     527           0 :             aSub[SW_CJK].SetFamily( pFont->GetFamily() );
     528           0 :             aSub[SW_CJK].Font::SetName( pFont->GetFamilyName() );
     529           0 :             aSub[SW_CJK].Font::SetStyleName( pFont->GetStyleName() );
     530           0 :             aSub[SW_CJK].Font::SetPitch( pFont->GetPitch() );
     531           0 :             aSub[SW_CJK].Font::SetCharSet( pFont->GetCharSet() );
     532             :         }
     533           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_CJK_FONTSIZE,
     534           0 :             true, &pItem ))
     535             :         {
     536           0 :             const SvxFontHeightItem *pHeight = (const SvxFontHeightItem *)pItem;
     537           0 :             aSub[SW_CJK].SvxFont::SetPropr( 100 );
     538           0 :             aSub[SW_CJK].aSize = aSub[SW_CJK].Font::GetSize();
     539           0 :             Size aTmpSize = aSub[SW_CJK].aSize;
     540           0 :             aTmpSize.Height() = pHeight->GetHeight();
     541           0 :             aSub[SW_CJK].SetSize( aTmpSize );
     542             :         }
     543           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_CJK_POSTURE,
     544           0 :             true, &pItem ))
     545           0 :             aSub[SW_CJK].Font::SetItalic( ((SvxPostureItem*)pItem)->GetPosture() );
     546           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_CJK_WEIGHT,
     547           0 :             true, &pItem ))
     548           0 :             aSub[SW_CJK].Font::SetWeight( ((SvxWeightItem*)pItem)->GetWeight() );
     549           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_CJK_LANGUAGE,
     550           0 :             true, &pItem ))
     551             :         {
     552           0 :             LanguageType eNewLang = ((SvxLanguageItem*)pItem)->GetLanguage();
     553           0 :             aSub[SW_CJK].SetLanguage( eNewLang );
     554           0 :             aSub[SW_LATIN].SetCJKContextLanguage( eNewLang );
     555           0 :             aSub[SW_CJK].SetCJKContextLanguage( eNewLang );
     556           0 :             aSub[SW_CTL].SetCJKContextLanguage( eNewLang );
     557             :         }
     558             : 
     559           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_CTL_FONT,
     560           0 :             true, &pItem ))
     561             :         {
     562           0 :             const SvxFontItem *pFont = (const SvxFontItem *)pItem;
     563           0 :             aSub[SW_CTL].SetFamily( pFont->GetFamily() );
     564           0 :             aSub[SW_CTL].Font::SetName( pFont->GetFamilyName() );
     565           0 :             aSub[SW_CTL].Font::SetStyleName( pFont->GetStyleName() );
     566           0 :             aSub[SW_CTL].Font::SetPitch( pFont->GetPitch() );
     567           0 :             aSub[SW_CTL].Font::SetCharSet( pFont->GetCharSet() );
     568             :         }
     569           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_CTL_FONTSIZE,
     570           0 :             true, &pItem ))
     571             :         {
     572           0 :             const SvxFontHeightItem *pHeight = (const SvxFontHeightItem *)pItem;
     573           0 :             aSub[SW_CTL].SvxFont::SetPropr( 100 );
     574           0 :             aSub[SW_CTL].aSize = aSub[SW_CTL].Font::GetSize();
     575           0 :             Size aTmpSize = aSub[SW_CTL].aSize;
     576           0 :             aTmpSize.Height() = pHeight->GetHeight();
     577           0 :             aSub[SW_CTL].SetSize( aTmpSize );
     578             :         }
     579           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_CTL_POSTURE,
     580           0 :             true, &pItem ))
     581           0 :             aSub[SW_CTL].Font::SetItalic( ((SvxPostureItem*)pItem)->GetPosture() );
     582           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_CTL_WEIGHT,
     583           0 :             true, &pItem ))
     584           0 :             aSub[SW_CTL].Font::SetWeight( ((SvxWeightItem*)pItem)->GetWeight() );
     585           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_CTL_LANGUAGE,
     586           0 :             true, &pItem ))
     587           0 :             aSub[SW_CTL].SetLanguage( ((SvxLanguageItem*)pItem)->GetLanguage() );
     588             : 
     589           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_UNDERLINE,
     590           0 :             true, &pItem ))
     591             :         {
     592           0 :             SetUnderline( ((SvxUnderlineItem*)pItem)->GetLineStyle() );
     593           0 :             SetUnderColor( ((SvxUnderlineItem*)pItem)->GetColor() );
     594             :         }
     595           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_OVERLINE,
     596           0 :             true, &pItem ))
     597             :         {
     598           0 :             SetOverline( ((SvxOverlineItem*)pItem)->GetLineStyle() );
     599           0 :             SetOverColor( ((SvxOverlineItem*)pItem)->GetColor() );
     600             :         }
     601           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_CROSSEDOUT,
     602           0 :             true, &pItem ))
     603           0 :             SetStrikeout( ((SvxCrossedOutItem*)pItem)->GetStrikeout() );
     604           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_COLOR,
     605           0 :             true, &pItem ))
     606           0 :             SetColor( ((SvxColorItem*)pItem)->GetValue() );
     607           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_EMPHASIS_MARK,
     608           0 :             true, &pItem ))
     609           0 :             SetEmphasisMark( ((SvxEmphasisMarkItem*)pItem)->GetEmphasisMark() );
     610             : 
     611           0 :         SetTransparent( sal_True );
     612           0 :         SetAlign( ALIGN_BASELINE );
     613           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_CONTOUR,
     614           0 :             true, &pItem ))
     615           0 :             SetOutline( ((SvxContourItem*)pItem)->GetValue() );
     616           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_SHADOWED,
     617           0 :             true, &pItem ))
     618           0 :             SetShadow( ((SvxShadowedItem*)pItem)->GetValue() );
     619           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_RELIEF,
     620           0 :             true, &pItem ))
     621           0 :             SetRelief( (FontRelief)((SvxCharReliefItem*)pItem)->GetValue() );
     622           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_SHADOWED,
     623           0 :             true, &pItem ))
     624           0 :             SetPropWidth(((SvxShadowedItem*)pItem)->GetValue() ? 50 : 100 );
     625           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_AUTOKERN,
     626           0 :             true, &pItem ))
     627             :         {
     628           0 :             if( ((SvxAutoKernItem*)pItem)->GetValue() )
     629             :             {
     630           0 :                 SetAutoKern( ( !pIDocumentSettingAccess ||
     631           0 :                                !pIDocumentSettingAccess->get(IDocumentSettingAccess::KERN_ASIAN_PUNCTUATION) ) ?
     632             :                                 KERNING_FONTSPECIFIC :
     633           0 :                                 KERNING_ASIAN );
     634             :             }
     635             :             else
     636           0 :                 SetAutoKern( 0 );
     637             :         }
     638           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_WORDLINEMODE,
     639           0 :             true, &pItem ))
     640           0 :             SetWordLineMode( ((SvxWordLineModeItem*)pItem)->GetValue() );
     641             : 
     642           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_ESCAPEMENT,
     643           0 :             true, &pItem ))
     644             :         {
     645           0 :             const SvxEscapementItem *pEsc = (const SvxEscapementItem *)pItem;
     646           0 :             SetEscapement( pEsc->GetEsc() );
     647           0 :             if( aSub[SW_LATIN].IsEsc() )
     648           0 :                 SetProportion( pEsc->GetProp() );
     649             :         }
     650           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_CASEMAP,
     651           0 :             true, &pItem ))
     652           0 :             SetCaseMap( ((SvxCaseMapItem*)pItem)->GetCaseMap() );
     653           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_KERNING,
     654           0 :             true, &pItem ))
     655           0 :             SetFixKerning( ((SvxKerningItem*)pItem)->GetValue() );
     656           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_NOHYPHEN,
     657           0 :             true, &pItem ))
     658           0 :             SetNoHyph( ((SvxNoHyphenItem*)pItem)->GetValue() );
     659           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_BLINK,
     660           0 :             true, &pItem ))
     661           0 :             SetBlink( ((SvxBlinkItem*)pItem)->GetValue() );
     662           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_ROTATE,
     663           0 :             true, &pItem ))
     664           0 :             SetVertical( ((SvxCharRotateItem*)pItem)->GetValue() );
     665           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_BACKGROUND,
     666           0 :             true, &pItem ))
     667           0 :             pBackColor = new Color( ((SvxBrushItem*)pItem)->GetColor() );
     668           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_HIGHLIGHT,
     669           0 :             true, &pItem ))
     670           0 :             SetHighlightColor(((SvxBrushItem*)pItem)->GetColor());
     671           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_BOX,
     672           0 :             true, &pItem ))
     673             :         {
     674           0 :             const SvxBoxItem* pBoxItem = static_cast<const SvxBoxItem*>(pItem);
     675           0 :             SetTopBorder(pBoxItem->GetTop());
     676           0 :             SetBottomBorder(pBoxItem->GetBottom());
     677           0 :             SetRightBorder(pBoxItem->GetRight());
     678           0 :             SetLeftBorder(pBoxItem->GetLeft());
     679           0 :             SetTopBorderDist(pBoxItem->GetDistance(BOX_LINE_TOP));
     680           0 :             SetBottomBorderDist(pBoxItem->GetDistance(BOX_LINE_BOTTOM));
     681           0 :             SetRightBorderDist(pBoxItem->GetDistance(BOX_LINE_RIGHT));
     682           0 :             SetLeftBorderDist(pBoxItem->GetDistance(BOX_LINE_LEFT));
     683             :         }
     684           0 :         if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_SHADOW,
     685           0 :             true, &pItem ))
     686             :         {
     687           0 :             const SvxShadowItem* pShadowItem = static_cast<const SvxShadowItem*>(pItem);
     688           0 :             SetShadowColor(pShadowItem->GetColor());
     689           0 :             SetShadowWidth(pShadowItem->GetWidth());
     690           0 :             SetShadowLocation(pShadowItem->GetLocation());
     691             :         }
     692           0 :         const SfxPoolItem* pTwoLinesItem = 0;
     693           0 :         if( SFX_ITEM_SET ==
     694           0 :                 pAttrSet->GetItemState( RES_CHRATR_TWO_LINES, true, &pTwoLinesItem ))
     695           0 :             if ( ((SvxTwoLinesItem*)pTwoLinesItem)->GetValue() )
     696           0 :                 SetVertical( 0 );
     697             :     }
     698             :     else
     699             :     {
     700           0 :         Invalidate();
     701           0 :         bNoHyph = sal_False;
     702           0 :         bBlink = sal_False;
     703             :     }
     704           0 :     bPaintBlank = sal_False;
     705           0 :     bPaintWrong = sal_False;
     706             :     OSL_ENSURE( aSub[SW_LATIN].IsTransparent(), "SwFont: Transparent revolution" );
     707           0 : }
     708             : 
     709             : // SwFont
     710             : 
     711           0 : SwFont::SwFont( const SwFont &rFont )
     712             : {
     713           0 :     aSub[SW_LATIN] = rFont.aSub[SW_LATIN];
     714           0 :     aSub[SW_CJK] = rFont.aSub[SW_CJK];
     715           0 :     aSub[SW_CTL] = rFont.aSub[SW_CTL];
     716           0 :     nActual = rFont.nActual;
     717           0 :     pBackColor = rFont.pBackColor ? new Color( *rFont.pBackColor ) : NULL;
     718           0 :     m_aHighlightColor = rFont.m_aHighlightColor;
     719           0 :     m_aTopBorder = rFont.m_aTopBorder;
     720           0 :     m_aBottomBorder = rFont.m_aBottomBorder;
     721           0 :     m_aRightBorder = rFont.m_aRightBorder;
     722           0 :     m_aLeftBorder = rFont.m_aLeftBorder;
     723           0 :     m_nTopBorderDist = rFont.m_nTopBorderDist;
     724           0 :     m_nBottomBorderDist = rFont.m_nBottomBorderDist;
     725           0 :     m_nRightBorderDist = rFont.m_nRightBorderDist;
     726           0 :     m_nLeftBorderDist = rFont.m_nLeftBorderDist;
     727           0 :     m_aShadowColor = rFont.m_aShadowColor;
     728           0 :     m_nShadowWidth = rFont.m_nShadowWidth;
     729           0 :     m_aShadowLocation = rFont.m_aShadowLocation;
     730           0 :     aUnderColor = rFont.GetUnderColor();
     731           0 :     aOverColor  = rFont.GetOverColor();
     732           0 :     nToxCnt = 0;
     733           0 :     nRefCnt = 0;
     734           0 :     m_nMetaCount = 0;
     735           0 :     m_nInputFieldCount = 0;
     736           0 :     bFntChg = rFont.bFntChg;
     737           0 :     bOrgChg = rFont.bOrgChg;
     738           0 :     bPaintBlank = rFont.bPaintBlank;
     739           0 :     bPaintWrong = sal_False;
     740           0 :     bURL = rFont.bURL;
     741           0 :     bGreyWave = rFont.bGreyWave;
     742           0 :     bNoColReplace = rFont.bNoColReplace;
     743           0 :     bNoHyph = rFont.bNoHyph;
     744           0 :     bBlink = rFont.bBlink;
     745           0 : }
     746             : 
     747           0 : SwFont::SwFont( const SwAttrSet* pAttrSet,
     748           0 :                 const IDocumentSettingAccess* pIDocumentSettingAccess )
     749             : {
     750           0 :     nActual = SW_LATIN;
     751           0 :     nToxCnt = 0;
     752           0 :     nRefCnt = 0;
     753           0 :     m_nMetaCount = 0;
     754           0 :     m_nInputFieldCount = 0;
     755           0 :     bPaintBlank = sal_False;
     756           0 :     bPaintWrong = sal_False;
     757           0 :     bURL = sal_False;
     758           0 :     bGreyWave = sal_False;
     759           0 :     bNoColReplace = sal_False;
     760           0 :     bNoHyph = pAttrSet->GetNoHyphenHere().GetValue();
     761           0 :     bBlink = pAttrSet->GetBlink().GetValue();
     762           0 :     bOrgChg = sal_True;
     763             :     {
     764           0 :         const SvxFontItem& rFont = pAttrSet->GetFont();
     765           0 :         aSub[SW_LATIN].SetFamily( rFont.GetFamily() );
     766           0 :         aSub[SW_LATIN].SetName( rFont.GetFamilyName() );
     767           0 :         aSub[SW_LATIN].SetStyleName( rFont.GetStyleName() );
     768           0 :         aSub[SW_LATIN].SetPitch( rFont.GetPitch() );
     769           0 :         aSub[SW_LATIN].SetCharSet( rFont.GetCharSet() );
     770           0 :         aSub[SW_LATIN].SvxFont::SetPropr( 100 );   // 100% der FontSize
     771           0 :         Size aTmpSize = aSub[SW_LATIN].aSize;
     772           0 :         aTmpSize.Height() = pAttrSet->GetSize().GetHeight();
     773           0 :         aSub[SW_LATIN].SetSize( aTmpSize );
     774           0 :         aSub[SW_LATIN].SetItalic( pAttrSet->GetPosture().GetPosture() );
     775           0 :         aSub[SW_LATIN].SetWeight( pAttrSet->GetWeight().GetWeight() );
     776           0 :         aSub[SW_LATIN].SetLanguage( pAttrSet->GetLanguage().GetLanguage() );
     777             :     }
     778             : 
     779             :     {
     780           0 :         const SvxFontItem& rFont = pAttrSet->GetCJKFont();
     781           0 :         aSub[SW_CJK].SetFamily( rFont.GetFamily() );
     782           0 :         aSub[SW_CJK].SetName( rFont.GetFamilyName() );
     783           0 :         aSub[SW_CJK].SetStyleName( rFont.GetStyleName() );
     784           0 :         aSub[SW_CJK].SetPitch( rFont.GetPitch() );
     785           0 :         aSub[SW_CJK].SetCharSet( rFont.GetCharSet() );
     786           0 :         aSub[SW_CJK].SvxFont::SetPropr( 100 );   // 100% der FontSize
     787           0 :         Size aTmpSize = aSub[SW_CJK].aSize;
     788           0 :         aTmpSize.Height() = pAttrSet->GetCJKSize().GetHeight();
     789           0 :         aSub[SW_CJK].SetSize( aTmpSize );
     790           0 :         aSub[SW_CJK].SetItalic( pAttrSet->GetCJKPosture().GetPosture() );
     791           0 :         aSub[SW_CJK].SetWeight( pAttrSet->GetCJKWeight().GetWeight() );
     792           0 :         LanguageType eNewLang = pAttrSet->GetCJKLanguage().GetLanguage();
     793           0 :         aSub[SW_CJK].SetLanguage( eNewLang );
     794           0 :         aSub[SW_LATIN].SetCJKContextLanguage( eNewLang );
     795           0 :         aSub[SW_CJK].SetCJKContextLanguage( eNewLang );
     796           0 :         aSub[SW_CTL].SetCJKContextLanguage( eNewLang );
     797             :     }
     798             : 
     799             :     {
     800           0 :         const SvxFontItem& rFont = pAttrSet->GetCTLFont();
     801           0 :         aSub[SW_CTL].SetFamily( rFont.GetFamily() );
     802           0 :         aSub[SW_CTL].SetName( rFont.GetFamilyName() );
     803           0 :         aSub[SW_CTL].SetStyleName( rFont.GetStyleName() );
     804           0 :         aSub[SW_CTL].SetPitch( rFont.GetPitch() );
     805           0 :         aSub[SW_CTL].SetCharSet( rFont.GetCharSet() );
     806           0 :         aSub[SW_CTL].SvxFont::SetPropr( 100 );   // 100% der FontSize
     807           0 :         Size aTmpSize = aSub[SW_CTL].aSize;
     808           0 :         aTmpSize.Height() = pAttrSet->GetCTLSize().GetHeight();
     809           0 :         aSub[SW_CTL].SetSize( aTmpSize );
     810           0 :         aSub[SW_CTL].SetItalic( pAttrSet->GetCTLPosture().GetPosture() );
     811           0 :         aSub[SW_CTL].SetWeight( pAttrSet->GetCTLWeight().GetWeight() );
     812           0 :         aSub[SW_CTL].SetLanguage( pAttrSet->GetCTLLanguage().GetLanguage() );
     813             :     }
     814           0 :     if ( pAttrSet->GetCharHidden().GetValue() )
     815           0 :         SetUnderline( UNDERLINE_DOTTED );
     816             :     else
     817           0 :         SetUnderline( pAttrSet->GetUnderline().GetLineStyle() );
     818           0 :     SetUnderColor( pAttrSet->GetUnderline().GetColor() );
     819           0 :     SetOverline( pAttrSet->GetOverline().GetLineStyle() );
     820           0 :     SetOverColor( pAttrSet->GetOverline().GetColor() );
     821           0 :     SetEmphasisMark( pAttrSet->GetEmphasisMark().GetEmphasisMark() );
     822           0 :     SetStrikeout( pAttrSet->GetCrossedOut().GetStrikeout() );
     823           0 :     SetColor( pAttrSet->GetColor().GetValue() );
     824           0 :     SetTransparent( sal_True );
     825           0 :     SetAlign( ALIGN_BASELINE );
     826           0 :     SetOutline( pAttrSet->GetContour().GetValue() );
     827           0 :     SetShadow( pAttrSet->GetShadowed().GetValue() );
     828           0 :     SetPropWidth( pAttrSet->GetCharScaleW().GetValue() );
     829           0 :     SetRelief( (FontRelief)pAttrSet->GetCharRelief().GetValue() );
     830           0 :     if( pAttrSet->GetAutoKern().GetValue() )
     831             :     {
     832           0 :         SetAutoKern( ( !pIDocumentSettingAccess ||
     833           0 :                        !pIDocumentSettingAccess->get(IDocumentSettingAccess::KERN_ASIAN_PUNCTUATION) ) ?
     834             :                         KERNING_FONTSPECIFIC :
     835           0 :                         KERNING_ASIAN );
     836             :     }
     837             :     else
     838           0 :         SetAutoKern( 0 );
     839           0 :     SetWordLineMode( pAttrSet->GetWordLineMode().GetValue() );
     840           0 :     const SvxEscapementItem &rEsc = pAttrSet->GetEscapement();
     841           0 :     SetEscapement( rEsc.GetEsc() );
     842           0 :     if( aSub[SW_LATIN].IsEsc() )
     843           0 :         SetProportion( rEsc.GetProp() );
     844           0 :     SetCaseMap( pAttrSet->GetCaseMap().GetCaseMap() );
     845           0 :     SetFixKerning( pAttrSet->GetKerning().GetValue() );
     846             :     const SfxPoolItem* pItem;
     847           0 :     if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_BACKGROUND,
     848           0 :         true, &pItem ))
     849           0 :         pBackColor = new Color( ((SvxBrushItem*)pItem)->GetColor() );
     850             :     else
     851           0 :         pBackColor = NULL;
     852           0 :     if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_HIGHLIGHT,
     853           0 :         true, &pItem ))
     854           0 :         SetHighlightColor(((SvxBrushItem*)pItem)->GetColor());
     855             :     else
     856           0 :         SetHighlightColor(COL_TRANSPARENT);
     857           0 :     if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_BOX,
     858           0 :         true, &pItem ))
     859             :     {
     860           0 :         const SvxBoxItem* pBoxItem = static_cast<const SvxBoxItem*>(pItem);
     861           0 :         SetTopBorder(pBoxItem->GetTop());
     862           0 :         SetBottomBorder(pBoxItem->GetBottom());
     863           0 :         SetRightBorder(pBoxItem->GetRight());
     864           0 :         SetLeftBorder(pBoxItem->GetLeft());
     865           0 :         SetTopBorderDist(pBoxItem->GetDistance(BOX_LINE_TOP));
     866           0 :         SetBottomBorderDist(pBoxItem->GetDistance(BOX_LINE_BOTTOM));
     867           0 :         SetRightBorderDist(pBoxItem->GetDistance(BOX_LINE_RIGHT));
     868           0 :         SetLeftBorderDist(pBoxItem->GetDistance(BOX_LINE_LEFT));
     869             :     }
     870             :     else
     871             :     {
     872           0 :         SetTopBorder(0);
     873           0 :         SetBottomBorder(0);
     874           0 :         SetRightBorder(0);
     875           0 :         SetLeftBorder(0);
     876           0 :         SetTopBorderDist(0);
     877           0 :         SetBottomBorderDist(0);
     878           0 :         SetRightBorderDist(0);
     879           0 :         SetLeftBorderDist(0);
     880             :     }
     881             : 
     882           0 :     if( SFX_ITEM_SET == pAttrSet->GetItemState( RES_CHRATR_SHADOW,
     883           0 :         true, &pItem ))
     884             :     {
     885           0 :         const SvxShadowItem* pShadowItem = static_cast<const SvxShadowItem*>(pItem);
     886           0 :         SetShadowColor(pShadowItem->GetColor());
     887           0 :         SetShadowWidth(pShadowItem->GetWidth());
     888           0 :         SetShadowLocation(pShadowItem->GetLocation());
     889             :     }
     890             :     else
     891             :     {
     892           0 :         SetShadowColor(COL_TRANSPARENT);
     893           0 :         SetShadowWidth(0);
     894           0 :         SetShadowLocation(SVX_SHADOW_NONE);
     895             :     }
     896             : 
     897           0 :     const SvxTwoLinesItem& rTwoLinesItem = pAttrSet->Get2Lines();
     898           0 :     if ( ! rTwoLinesItem.GetValue() )
     899           0 :         SetVertical( pAttrSet->GetCharRotate().GetValue() );
     900             :     else
     901           0 :         SetVertical( 0 );
     902           0 :     if( pIDocumentSettingAccess && pIDocumentSettingAccess->get( IDocumentSettingAccess::SMALL_CAPS_PERCENTAGE_66 ))
     903             :     {
     904           0 :         aSub[ SW_LATIN ].smallCapsPercentage66 = true;
     905           0 :         aSub[ SW_CJK ].smallCapsPercentage66 = true;
     906           0 :         aSub[ SW_CTL ].smallCapsPercentage66 = true;
     907             :     }
     908           0 : }
     909             : 
     910           0 : SwFont::~SwFont()
     911             : {
     912           0 :     delete pBackColor;
     913           0 : }
     914             : 
     915           0 : SwSubFont& SwSubFont::operator=( const SwSubFont &rFont )
     916             : {
     917           0 :     SvxFont::operator=( rFont );
     918           0 :     pMagic = rFont.pMagic;
     919           0 :     nFntIndex = rFont.nFntIndex;
     920           0 :     nOrgHeight = rFont.nOrgHeight;
     921           0 :     nOrgAscent = rFont.nOrgAscent;
     922           0 :     nPropWidth = rFont.nPropWidth;
     923           0 :     aSize = rFont.aSize;
     924           0 :     smallCapsPercentage66 = rFont.smallCapsPercentage66;
     925           0 :     return *this;
     926             : }
     927             : 
     928           0 : SwFont& SwFont::operator=( const SwFont &rFont )
     929             : {
     930           0 :     aSub[SW_LATIN] = rFont.aSub[SW_LATIN];
     931           0 :     aSub[SW_CJK] = rFont.aSub[SW_CJK];
     932           0 :     aSub[SW_CTL] = rFont.aSub[SW_CTL];
     933           0 :     nActual = rFont.nActual;
     934           0 :     delete pBackColor;
     935           0 :     pBackColor = rFont.pBackColor ? new Color( *rFont.pBackColor ) : NULL;
     936           0 :     m_aHighlightColor = rFont.m_aHighlightColor;
     937           0 :     m_aTopBorder = rFont.m_aTopBorder;
     938           0 :     m_aBottomBorder = rFont.m_aBottomBorder;
     939           0 :     m_aRightBorder = rFont.m_aRightBorder;
     940           0 :     m_aLeftBorder = rFont.m_aLeftBorder;
     941           0 :     m_nTopBorderDist = rFont.m_nTopBorderDist;
     942           0 :     m_nBottomBorderDist = rFont.m_nBottomBorderDist;
     943           0 :     m_nRightBorderDist = rFont.m_nRightBorderDist;
     944           0 :     m_nLeftBorderDist = rFont.m_nLeftBorderDist;
     945           0 :     m_aShadowColor = rFont.m_aShadowColor;
     946           0 :     m_nShadowWidth = rFont.m_nShadowWidth;
     947           0 :     m_aShadowLocation = rFont.m_aShadowLocation;
     948           0 :     aUnderColor = rFont.GetUnderColor();
     949           0 :     aOverColor  = rFont.GetOverColor();
     950           0 :     nToxCnt = 0;
     951           0 :     nRefCnt = 0;
     952           0 :     m_nMetaCount = 0;
     953           0 :     m_nInputFieldCount = 0;
     954           0 :     bFntChg = rFont.bFntChg;
     955           0 :     bOrgChg = rFont.bOrgChg;
     956           0 :     bPaintBlank = rFont.bPaintBlank;
     957           0 :     bPaintWrong = sal_False;
     958           0 :     bURL = rFont.bURL;
     959           0 :     bGreyWave = rFont.bGreyWave;
     960           0 :     bNoColReplace = rFont.bNoColReplace;
     961           0 :     bNoHyph = rFont.bNoHyph;
     962           0 :     bBlink = rFont.bBlink;
     963           0 :     return *this;
     964             : }
     965             : 
     966           0 : void SwFont::GoMagic( SwViewShell *pSh, sal_uInt8 nWhich )
     967             : {
     968             :     SwFntAccess aFntAccess( aSub[nWhich].pMagic, aSub[nWhich].nFntIndex,
     969           0 :                             &aSub[nWhich], pSh, sal_True );
     970           0 : }
     971             : 
     972           0 : sal_Bool SwSubFont::IsSymbol( SwViewShell *pSh )
     973             : {
     974           0 :     SwFntAccess aFntAccess( pMagic, nFntIndex, this, pSh, sal_False );
     975           0 :     return aFntAccess.Get()->IsSymbol();
     976             : }
     977             : 
     978           0 : sal_Bool SwSubFont::ChgFnt( SwViewShell *pSh, OutputDevice& rOut )
     979             : {
     980           0 :     if ( pLastFont )
     981           0 :         pLastFont->Unlock();
     982           0 :     SwFntAccess aFntAccess( pMagic, nFntIndex, this, pSh, sal_True );
     983             :     SV_STAT( nChangeFont );
     984             : 
     985           0 :     pLastFont = aFntAccess.Get();
     986             : 
     987           0 :     pLastFont->SetDevFont( pSh, rOut );
     988             : 
     989           0 :     pLastFont->Lock();
     990           0 :     return UNDERLINE_NONE != GetUnderline() ||
     991           0 :            UNDERLINE_NONE != GetOverline()  ||
     992           0 :            STRIKEOUT_NONE != GetStrikeout();
     993             : }
     994             : 
     995           0 : void SwFont::ChgPhysFnt( SwViewShell *pSh, OutputDevice& rOut )
     996             : {
     997           0 :     if( bOrgChg && aSub[nActual].IsEsc() )
     998             :     {
     999           0 :         const sal_uInt8 nOldProp = aSub[nActual].GetPropr();
    1000           0 :         SetProportion( 100 );
    1001           0 :         ChgFnt( pSh, rOut );
    1002             :         SwFntAccess aFntAccess( aSub[nActual].pMagic, aSub[nActual].nFntIndex,
    1003           0 :                                 &aSub[nActual], pSh );
    1004           0 :         aSub[nActual].nOrgHeight = aFntAccess.Get()->GetFontHeight( pSh, rOut );
    1005           0 :         aSub[nActual].nOrgAscent = aFntAccess.Get()->GetFontAscent( pSh, rOut );
    1006           0 :         SetProportion( nOldProp );
    1007           0 :         bOrgChg = sal_False;
    1008             :     }
    1009             : 
    1010           0 :     if( bFntChg )
    1011             :     {
    1012           0 :         ChgFnt( pSh, rOut );
    1013           0 :         bFntChg = bOrgChg;
    1014             :     }
    1015           0 :     if( rOut.GetTextLineColor() != aUnderColor )
    1016           0 :         rOut.SetTextLineColor( aUnderColor );
    1017           0 :     if( rOut.GetOverlineColor() != aOverColor )
    1018           0 :         rOut.SetOverlineColor( aOverColor );
    1019           0 : }
    1020             : 
    1021             : /*************************************************************************
    1022             :  *                      SwFont::CalcEscHeight()
    1023             :  *         Height = MaxAscent + MaxDescent
    1024             :  *      MaxAscent = Max (T1_ascent, T2_ascent + (Esc * T1_height) );
    1025             :  *     MaxDescent = Max (T1_height-T1_ascent,
    1026             :  *                       T2_height-T2_ascent - (Esc * T1_height)
    1027             :  *************************************************************************/
    1028           0 : sal_uInt16 SwSubFont::CalcEscHeight( const sal_uInt16 nOldHeight,
    1029             :                               const sal_uInt16 nOldAscent  ) const
    1030             : {
    1031           0 :     if( DFLT_ESC_AUTO_SUPER != GetEscapement() &&
    1032           0 :         DFLT_ESC_AUTO_SUB != GetEscapement() )
    1033             :     {
    1034           0 :         long nDescent = nOldHeight - nOldAscent -
    1035           0 :                              ( (long) nOrgHeight * GetEscapement() ) / 100L;
    1036             :         const sal_uInt16 nDesc = ( nDescent>0 ) ? std::max ( sal_uInt16(nDescent),
    1037           0 :                    sal_uInt16(nOrgHeight - nOrgAscent) ) : nOrgHeight - nOrgAscent;
    1038           0 :         return ( nDesc + CalcEscAscent( nOldAscent ) );
    1039             :     }
    1040           0 :     return nOrgHeight;
    1041             : }
    1042             : 
    1043           0 : short SwSubFont::_CheckKerning( )
    1044             : {
    1045           0 :     short nKernx = - short( Font::GetSize().Height() / 6 );
    1046             : 
    1047           0 :     if ( nKernx < GetFixKerning() )
    1048           0 :         return GetFixKerning();
    1049           0 :     return nKernx;
    1050             : }
    1051             : 
    1052           0 : sal_uInt16 SwSubFont::GetAscent( SwViewShell *pSh, const OutputDevice& rOut )
    1053             : {
    1054             :     sal_uInt16 nAscent;
    1055           0 :     SwFntAccess aFntAccess( pMagic, nFntIndex, this, pSh );
    1056           0 :     nAscent = aFntAccess.Get()->GetFontAscent( pSh, rOut );
    1057           0 :     if( GetEscapement() )
    1058           0 :         nAscent = CalcEscAscent( nAscent );
    1059           0 :     return nAscent;
    1060             : }
    1061             : 
    1062           0 : sal_uInt16 SwSubFont::GetHeight( SwViewShell *pSh, const OutputDevice& rOut )
    1063             : {
    1064             :     SV_STAT( nGetTextSize );
    1065           0 :     SwFntAccess aFntAccess( pMagic, nFntIndex, this, pSh );
    1066           0 :     const sal_uInt16 nHeight = aFntAccess.Get()->GetFontHeight( pSh, rOut );
    1067           0 :     if ( GetEscapement() )
    1068             :     {
    1069           0 :         const sal_uInt16 nAscent = aFntAccess.Get()->GetFontAscent( pSh, rOut );
    1070           0 :         return CalcEscHeight( nHeight, nAscent ); // + nLeading;
    1071             :     }
    1072           0 :     return nHeight; // + nLeading;
    1073             : }
    1074             : 
    1075           0 : Size SwSubFont::_GetTxtSize( SwDrawTextInfo& rInf )
    1076             : {
    1077             :     // Robust: Eigentlich sollte der Font bereits eingestellt sein, aber
    1078             :     // sicher ist sicher ...
    1079           0 :     if ( !pLastFont || pLastFont->GetOwner()!=pMagic ||
    1080           0 :          !IsSameInstance( rInf.GetpOut()->GetFont() ) )
    1081           0 :         ChgFnt( rInf.GetShell(), rInf.GetOut() );
    1082             : 
    1083           0 :     SwDigitModeModifier aDigitModeModifier( rInf.GetOut(), rInf.GetFont()->GetLanguage() );
    1084             : 
    1085           0 :     Size aTxtSize;
    1086           0 :     sal_Int32 nLn = ( rInf.GetLen() == COMPLETE_STRING ? rInf.GetText().getLength()
    1087           0 :                                                    : rInf.GetLen() );
    1088           0 :     rInf.SetLen( nLn );
    1089           0 :     if( IsCapital() && nLn )
    1090           0 :         aTxtSize = GetCapitalSize( rInf );
    1091             :     else
    1092             :     {
    1093             :         SV_STAT( nGetTextSize );
    1094           0 :         long nOldKern = rInf.GetKern();
    1095           0 :         const OUString oldTxt = rInf.GetText();
    1096           0 :         rInf.SetKern( CheckKerning() );
    1097           0 :         if ( !IsCaseMap() )
    1098           0 :             aTxtSize = pLastFont->GetTextSize( rInf );
    1099             :         else
    1100             :         {
    1101           0 :             OUString aTmp = CalcCaseMap( rInf.GetText() );
    1102           0 :             const OUString oldStr = rInf.GetText();
    1103           0 :             bool bCaseMapLengthDiffers(aTmp.getLength() != oldStr.getLength());
    1104             : 
    1105           0 :             if(bCaseMapLengthDiffers && rInf.GetLen())
    1106             :             {
    1107             :                 // #108203#
    1108             :                 // If the length of the original string and the CaseMapped one
    1109             :                 // are different, it is necessary to handle the given text part as
    1110             :                 // a single snippet since its size may differ, too.
    1111           0 :                 sal_Int32 nOldIdx(rInf.GetIdx());
    1112           0 :                 sal_Int32 nOldLen(rInf.GetLen());
    1113           0 :                 const OUString aSnippet(oldStr.copy(nOldIdx, nOldLen));
    1114           0 :                 OUString aNewText(CalcCaseMap(aSnippet));
    1115             : 
    1116           0 :                 rInf.SetText( aNewText );
    1117           0 :                 rInf.SetIdx( 0 );
    1118           0 :                 rInf.SetLen( aNewText.getLength() );
    1119             : 
    1120           0 :                 aTxtSize = pLastFont->GetTextSize( rInf );
    1121             : 
    1122           0 :                 rInf.SetIdx( nOldIdx );
    1123           0 :                 rInf.SetLen( nOldLen );
    1124             :             }
    1125             :             else
    1126             :             {
    1127           0 :                 rInf.SetText( aTmp );
    1128           0 :                 aTxtSize = pLastFont->GetTextSize( rInf );
    1129             :             }
    1130             : 
    1131           0 :             rInf.SetText(oldStr);
    1132             :         }
    1133           0 :         rInf.SetKern( nOldKern );
    1134           0 :         rInf.SetText(oldTxt);
    1135             :         // 15142: Ein Wort laenger als eine Zeile, beim Zeilenumbruch
    1136             :         //        hochgestellt, muss seine effektive Hoehe melden.
    1137           0 :         if( GetEscapement() )
    1138             :         {
    1139           0 :             const sal_uInt16 nAscent = pLastFont->GetFontAscent( rInf.GetShell(),
    1140           0 :                                                              rInf.GetOut() );
    1141           0 :             aTxtSize.Height() =
    1142           0 :                 (long)CalcEscHeight( (sal_uInt16)aTxtSize.Height(), nAscent);
    1143           0 :         }
    1144             :     }
    1145             : 
    1146           0 :     if (1==rInf.GetLen() && CH_TXT_ATR_FIELDSTART==rInf.GetText()[rInf.GetIdx()])
    1147             :     {
    1148           0 :         sal_Int32 nOldIdx(rInf.GetIdx());
    1149           0 :         sal_Int32 nOldLen(rInf.GetLen());
    1150           0 :         OUString aNewText(CH_TXT_ATR_SUBST_FIELDSTART);
    1151           0 :         rInf.SetText( aNewText );
    1152           0 :         rInf.SetIdx( 0 );
    1153           0 :         rInf.SetLen( aNewText.getLength() );
    1154           0 :         aTxtSize = pLastFont->GetTextSize( rInf );
    1155           0 :         rInf.SetIdx( nOldIdx );
    1156           0 :         rInf.SetLen( nOldLen );
    1157             :     }
    1158           0 :     else if (1==rInf.GetLen() && CH_TXT_ATR_FIELDEND==rInf.GetText()[ rInf.GetIdx() ])
    1159             :     {
    1160           0 :         sal_Int32 nOldIdx(rInf.GetIdx());
    1161           0 :         sal_Int32 nOldLen(rInf.GetLen());
    1162           0 :         OUString aNewText(CH_TXT_ATR_SUBST_FIELDEND);
    1163           0 :         rInf.SetText( aNewText );
    1164           0 :         rInf.SetIdx( 0 );
    1165           0 :         rInf.SetLen( aNewText.getLength() );
    1166           0 :         aTxtSize = pLastFont->GetTextSize( rInf );
    1167           0 :         rInf.SetIdx( nOldIdx );
    1168           0 :         rInf.SetLen( nOldLen );
    1169             :     }
    1170             : 
    1171           0 :     return aTxtSize;
    1172             : }
    1173             : 
    1174           0 : void SwSubFont::_DrawText( SwDrawTextInfo &rInf, const sal_Bool bGrey )
    1175             : {
    1176           0 :     rInf.SetGreyWave( bGrey );
    1177           0 :     sal_Int32 nLn = rInf.GetText().getLength();
    1178           0 :     if( !rInf.GetLen() || !nLn )
    1179           0 :         return;
    1180           0 :     if( COMPLETE_STRING == rInf.GetLen() )
    1181           0 :         rInf.SetLen( nLn );
    1182             : 
    1183           0 :     FontUnderline nOldUnder = UNDERLINE_NONE;
    1184           0 :     SwUnderlineFont* pUnderFnt = 0;
    1185             : 
    1186           0 :     if( rInf.GetUnderFnt() )
    1187             :     {
    1188           0 :         nOldUnder = GetUnderline();
    1189           0 :         SetUnderline( UNDERLINE_NONE );
    1190           0 :         pUnderFnt = rInf.GetUnderFnt();
    1191             :     }
    1192             : 
    1193           0 :     if( !pLastFont || pLastFont->GetOwner()!=pMagic )
    1194           0 :         ChgFnt( rInf.GetShell(), rInf.GetOut() );
    1195             : 
    1196           0 :     SwDigitModeModifier aDigitModeModifier( rInf.GetOut(), rInf.GetFont()->GetLanguage() );
    1197             : 
    1198           0 :     const Point aOldPos(rInf.GetPos());
    1199           0 :     Point aPos( rInf.GetPos() );
    1200             : 
    1201           0 :     if( GetEscapement() )
    1202           0 :         CalcEsc( rInf, aPos );
    1203             : 
    1204           0 :     rInf.SetPos( aPos );
    1205           0 :     rInf.SetKern( CheckKerning() + rInf.GetSperren() / SPACING_PRECISION_FACTOR );
    1206             : 
    1207           0 :     if( IsCapital() )
    1208           0 :         DrawCapital( rInf );
    1209             :     else
    1210             :     {
    1211             :         SV_STAT( nDrawText );
    1212           0 :         if ( !IsCaseMap() )
    1213           0 :             pLastFont->DrawText( rInf );
    1214             :         else
    1215             :         {
    1216           0 :             const OUString oldStr = rInf.GetText();
    1217           0 :             OUString aString( CalcCaseMap(oldStr) );
    1218           0 :             bool bCaseMapLengthDiffers(aString.getLength() != oldStr.getLength());
    1219             : 
    1220           0 :             if(bCaseMapLengthDiffers && rInf.GetLen())
    1221             :             {
    1222             :                 // #108203#
    1223             :                 // If the length of the original string and the CaseMapped one
    1224             :                 // are different, it is necessary to handle the given text part as
    1225             :                 // a single snippet since its size may differ, too.
    1226           0 :                 sal_Int32 nOldIdx(rInf.GetIdx());
    1227           0 :                 sal_Int32 nOldLen(rInf.GetLen());
    1228           0 :                 const OUString aSnippet(oldStr.copy(nOldIdx, nOldLen));
    1229           0 :                 OUString aNewText = CalcCaseMap(aSnippet);
    1230             : 
    1231           0 :                 rInf.SetText( aNewText );
    1232           0 :                 rInf.SetIdx( 0 );
    1233           0 :                 rInf.SetLen( aNewText.getLength() );
    1234             : 
    1235           0 :                 pLastFont->DrawText( rInf );
    1236             : 
    1237           0 :                 rInf.SetIdx( nOldIdx );
    1238           0 :                 rInf.SetLen( nOldLen );
    1239             :             }
    1240             :             else
    1241             :             {
    1242           0 :                 rInf.SetText( aString );
    1243           0 :                 pLastFont->DrawText( rInf );
    1244             :             }
    1245             : 
    1246           0 :             rInf.SetText(oldStr);
    1247             :         }
    1248             :     }
    1249             : 
    1250           0 :     if( pUnderFnt && nOldUnder != UNDERLINE_NONE )
    1251             :     {
    1252           0 :         Size aFontSize = _GetTxtSize( rInf );
    1253           0 :         const OUString oldStr = rInf.GetText();
    1254           0 :         OUString aStr("  ");
    1255             : 
    1256           0 :         sal_Int32 nOldIdx = rInf.GetIdx();
    1257           0 :         sal_Int32 nOldLen = rInf.GetLen();
    1258           0 :         long nSpace = 0;
    1259           0 :         if( rInf.GetSpace() )
    1260             :         {
    1261           0 :             sal_Int32 nTmpEnd = nOldIdx + nOldLen;
    1262           0 :             if (nTmpEnd > oldStr.getLength())
    1263           0 :                 nTmpEnd = oldStr.getLength();
    1264             : 
    1265           0 :             const SwScriptInfo* pSI = rInf.GetScriptInfo();
    1266             : 
    1267             :             const bool bAsianFont =
    1268           0 :                 ( rInf.GetFont() && SW_CJK == rInf.GetFont()->GetActual() );
    1269           0 :             for( sal_Int32 nTmp = nOldIdx; nTmp < nTmpEnd; ++nTmp )
    1270             :             {
    1271           0 :                 if (CH_BLANK == oldStr[nTmp] || bAsianFont ||
    1272           0 :                     ( nTmp + 1 < oldStr.getLength() && pSI &&
    1273           0 :                       i18n::ScriptType::ASIAN == pSI->ScriptType( nTmp + 1 ) ) )
    1274           0 :                     ++nSpace;
    1275             :             }
    1276             : 
    1277             :             // if next portion if a hole portion we do not consider any
    1278             :             // extra space added because the last character was ASIAN
    1279           0 :             if ( nSpace && rInf.IsSpaceStop() && bAsianFont )
    1280           0 :                  --nSpace;
    1281             : 
    1282           0 :             nSpace *= rInf.GetSpace() / SPACING_PRECISION_FACTOR;
    1283             :         }
    1284             : 
    1285           0 :         rInf.SetWidth( sal_uInt16(aFontSize.Width() + nSpace) );
    1286           0 :         rInf.SetText( aStr );
    1287           0 :         rInf.SetIdx( 0 );
    1288           0 :         rInf.SetLen( 2 );
    1289           0 :         SetUnderline( nOldUnder );
    1290           0 :         rInf.SetUnderFnt( 0 );
    1291             : 
    1292             :         // set position for underline font
    1293           0 :         rInf.SetPos( pUnderFnt->GetPos() );
    1294             : 
    1295           0 :         pUnderFnt->GetFont()._DrawStretchText( rInf );
    1296             : 
    1297           0 :         rInf.SetUnderFnt( pUnderFnt );
    1298           0 :         rInf.SetText(oldStr);
    1299           0 :         rInf.SetIdx( nOldIdx );
    1300           0 :         rInf.SetLen( nOldLen );
    1301             :     }
    1302             : 
    1303           0 :     rInf.SetPos(aOldPos);
    1304             : }
    1305             : 
    1306           0 : void SwSubFont::_DrawStretchText( SwDrawTextInfo &rInf )
    1307             : {
    1308           0 :     if( !rInf.GetLen() || !rInf.GetText().getLength() )
    1309           0 :         return;
    1310             : 
    1311           0 :     FontUnderline nOldUnder = UNDERLINE_NONE;
    1312           0 :     SwUnderlineFont* pUnderFnt = 0;
    1313             : 
    1314           0 :     if( rInf.GetUnderFnt() )
    1315             :     {
    1316           0 :         nOldUnder = GetUnderline();
    1317           0 :         SetUnderline( UNDERLINE_NONE );
    1318           0 :         pUnderFnt = rInf.GetUnderFnt();
    1319             :     }
    1320             : 
    1321           0 :     if ( !pLastFont || pLastFont->GetOwner() != pMagic )
    1322           0 :         ChgFnt( rInf.GetShell(), rInf.GetOut() );
    1323             : 
    1324           0 :     SwDigitModeModifier aDigitModeModifier( rInf.GetOut(), rInf.GetFont()->GetLanguage() );
    1325             : 
    1326           0 :     rInf.ApplyAutoColor();
    1327             : 
    1328           0 :     const Point aOldPos(rInf.GetPos());
    1329           0 :     Point aPos( rInf.GetPos() );
    1330             : 
    1331           0 :     if( GetEscapement() )
    1332           0 :         CalcEsc( rInf, aPos );
    1333             : 
    1334           0 :     rInf.SetKern( CheckKerning() + rInf.GetSperren() / SPACING_PRECISION_FACTOR );
    1335           0 :     rInf.SetPos( aPos );
    1336             : 
    1337           0 :     if( IsCapital() )
    1338           0 :         DrawStretchCapital( rInf );
    1339             :     else
    1340             :     {
    1341             :         SV_STAT( nDrawStretchText );
    1342             : 
    1343           0 :         if ( rInf.GetFrm() )
    1344             :         {
    1345           0 :             if ( rInf.GetFrm()->IsRightToLeft() )
    1346           0 :                 rInf.GetFrm()->SwitchLTRtoRTL( aPos );
    1347             : 
    1348           0 :             if ( rInf.GetFrm()->IsVertical() )
    1349           0 :                 rInf.GetFrm()->SwitchHorizontalToVertical( aPos );
    1350             : 
    1351           0 :             rInf.SetPos( aPos );
    1352             :         }
    1353             : 
    1354           0 :         if ( !IsCaseMap() )
    1355           0 :             rInf.GetOut().DrawStretchText( aPos, rInf.GetWidth(),
    1356           0 :                             rInf.GetText(), rInf.GetIdx(), rInf.GetLen() );
    1357             :         else
    1358           0 :             rInf.GetOut().DrawStretchText( aPos, rInf.GetWidth(), CalcCaseMap(
    1359           0 :                             rInf.GetText() ), rInf.GetIdx(), rInf.GetLen() );
    1360             :     }
    1361             : 
    1362           0 :     if( pUnderFnt && nOldUnder != UNDERLINE_NONE )
    1363             :     {
    1364           0 :         const OUString oldStr = rInf.GetText();
    1365           0 :         OUString aStr("  ");
    1366           0 :         sal_Int32 nOldIdx = rInf.GetIdx();
    1367           0 :         sal_Int32 nOldLen = rInf.GetLen();
    1368           0 :         rInf.SetText( aStr );
    1369           0 :         rInf.SetIdx( 0 );
    1370           0 :         rInf.SetLen( 2 );
    1371           0 :         SetUnderline( nOldUnder );
    1372           0 :         rInf.SetUnderFnt( 0 );
    1373             : 
    1374             :         // set position for underline font
    1375           0 :         rInf.SetPos( pUnderFnt->GetPos() );
    1376             : 
    1377           0 :         pUnderFnt->GetFont()._DrawStretchText( rInf );
    1378             : 
    1379           0 :         rInf.SetUnderFnt( pUnderFnt );
    1380           0 :         rInf.SetText(oldStr);
    1381           0 :         rInf.SetIdx( nOldIdx );
    1382           0 :         rInf.SetLen( nOldLen );
    1383             :     }
    1384             : 
    1385           0 :     rInf.SetPos(aOldPos);
    1386             : }
    1387             : 
    1388           0 : sal_Int32 SwSubFont::_GetCrsrOfst( SwDrawTextInfo& rInf )
    1389             : {
    1390           0 :     if ( !pLastFont || pLastFont->GetOwner()!=pMagic )
    1391           0 :         ChgFnt( rInf.GetShell(), rInf.GetOut() );
    1392             : 
    1393           0 :     SwDigitModeModifier aDigitModeModifier( rInf.GetOut(), rInf.GetFont()->GetLanguage() );
    1394             : 
    1395           0 :     sal_Int32 nLn = rInf.GetLen() == COMPLETE_STRING ? rInf.GetText().getLength()
    1396           0 :                                                  : rInf.GetLen();
    1397           0 :     rInf.SetLen( nLn );
    1398           0 :     sal_Int32 nCrsr = 0;
    1399           0 :     if( IsCapital() && nLn )
    1400           0 :         nCrsr = GetCapitalCrsrOfst( rInf );
    1401             :     else
    1402             :     {
    1403           0 :         const OUString oldTxt = rInf.GetText();
    1404           0 :         long nOldKern = rInf.GetKern();
    1405           0 :         rInf.SetKern( CheckKerning() );
    1406             :         SV_STAT( nGetTextSize );
    1407           0 :         if ( !IsCaseMap() )
    1408           0 :             nCrsr = pLastFont->GetCrsrOfst( rInf );
    1409             :         else
    1410             :         {
    1411           0 :             OUString aTmp = CalcCaseMap( rInf.GetText() );
    1412           0 :             rInf.SetText( aTmp );
    1413           0 :             nCrsr = pLastFont->GetCrsrOfst( rInf );
    1414             :         }
    1415           0 :         rInf.SetKern( nOldKern );
    1416           0 :         rInf.SetText(oldTxt);
    1417             :     }
    1418           0 :     return nCrsr;
    1419             : }
    1420             : 
    1421           0 : void SwSubFont::CalcEsc( SwDrawTextInfo& rInf, Point& rPos )
    1422             : {
    1423             :     long nOfst;
    1424             : 
    1425             :     sal_uInt16 nDir = UnMapDirection(
    1426           0 :                 GetOrientation(), rInf.GetFrm() && rInf.GetFrm()->IsVertical() );
    1427             : 
    1428           0 :     switch ( GetEscapement() )
    1429             :     {
    1430             :     case DFLT_ESC_AUTO_SUB :
    1431           0 :         nOfst = nOrgHeight - nOrgAscent -
    1432           0 :             pLastFont->GetFontHeight( rInf.GetShell(), rInf.GetOut() ) +
    1433           0 :             pLastFont->GetFontAscent( rInf.GetShell(), rInf.GetOut() );
    1434             : 
    1435           0 :         switch ( nDir )
    1436             :         {
    1437             :         case 0 :
    1438           0 :             rPos.Y() += nOfst;
    1439           0 :             break;
    1440             :         case 900 :
    1441           0 :             rPos.X() += nOfst;
    1442           0 :             break;
    1443             :         case 2700 :
    1444           0 :             rPos.X() -= nOfst;
    1445           0 :             break;
    1446             :         }
    1447             : 
    1448           0 :         break;
    1449             :     case DFLT_ESC_AUTO_SUPER :
    1450           0 :         nOfst = pLastFont->GetFontAscent( rInf.GetShell(), rInf.GetOut() ) -
    1451           0 :                 nOrgAscent;
    1452             : 
    1453           0 :         switch ( nDir )
    1454             :         {
    1455             :         case 0 :
    1456           0 :             rPos.Y() += nOfst;
    1457           0 :             break;
    1458             :         case 900 :
    1459           0 :             rPos.X() += nOfst;
    1460           0 :             break;
    1461             :         case 2700 :
    1462           0 :             rPos.X() -= nOfst;
    1463           0 :             break;
    1464             :         }
    1465             : 
    1466           0 :         break;
    1467             :     default :
    1468           0 :         nOfst = ((long)nOrgHeight * GetEscapement()) / 100L;
    1469             : 
    1470           0 :         switch ( nDir )
    1471             :         {
    1472             :         case 0 :
    1473           0 :             rPos.Y() -= nOfst;
    1474           0 :             break;
    1475             :         case 900 :
    1476           0 :             rPos.X() -= nOfst;
    1477           0 :             break;
    1478             :         case 2700 :
    1479           0 :             rPos.X() += nOfst;
    1480           0 :             break;
    1481             :         }
    1482             :     }
    1483           0 : }
    1484             : 
    1485             : // used during painting of small capitals
    1486           0 : void SwDrawTextInfo::Shift( sal_uInt16 nDir )
    1487             : {
    1488             : #ifdef DBG_UTIL
    1489             :     OSL_ENSURE( m_bPos, "DrawTextInfo: Undefined Position" );
    1490             :     OSL_ENSURE( m_bSize, "DrawTextInfo: Undefined Width" );
    1491             : #endif
    1492             : 
    1493           0 :     const bool bBidiPor = ( GetFrm() && GetFrm()->IsRightToLeft() ) !=
    1494           0 :                           ( 0 != ( TEXT_LAYOUT_BIDI_RTL & GetpOut()->GetLayoutMode() ) );
    1495             : 
    1496             :     nDir = bBidiPor ?
    1497             :             1800 :
    1498           0 :             UnMapDirection( nDir, GetFrm() && GetFrm()->IsVertical() );
    1499             : 
    1500           0 :     switch ( nDir )
    1501             :     {
    1502             :     case 0 :
    1503           0 :         m_aPos.X() += GetSize().Width();
    1504           0 :         break;
    1505             :     case 900 :
    1506             :         OSL_ENSURE( m_aPos.Y() >= GetSize().Width(), "Going underground" );
    1507           0 :         m_aPos.Y() -= GetSize().Width();
    1508           0 :         break;
    1509             :     case 1800 :
    1510           0 :         m_aPos.X() -= GetSize().Width();
    1511           0 :         break;
    1512             :     case 2700 :
    1513           0 :         m_aPos.Y() += GetSize().Width();
    1514           0 :         break;
    1515             :     }
    1516           0 : }
    1517             : 
    1518             : /**
    1519             :  * @note Used for the "continuous underline" feature.
    1520             :  **/
    1521           0 : SwUnderlineFont::SwUnderlineFont( SwFont& rFnt, const Point& rPoint )
    1522           0 :         : aPos( rPoint ), pFnt( &rFnt )
    1523             : {
    1524           0 : };
    1525             : 
    1526           0 : SwUnderlineFont::~SwUnderlineFont()
    1527             : {
    1528           0 :      delete pFnt;
    1529           0 : }
    1530             : 
    1531             : /// Helper for filters to find true lineheight of a font
    1532           0 : long AttrSetToLineHeight( const IDocumentSettingAccess& rIDocumentSettingAccess,
    1533             :                           const SwAttrSet &rSet,
    1534             :                           const OutputDevice &rOut, sal_Int16 nScript)
    1535             : {
    1536           0 :     SwFont aFont(&rSet, &rIDocumentSettingAccess);
    1537             :     sal_uInt8 nActual;
    1538           0 :     switch (nScript)
    1539             :     {
    1540             :         default:
    1541             :         case i18n::ScriptType::LATIN:
    1542           0 :             nActual = SW_LATIN;
    1543           0 :             break;
    1544             :         case i18n::ScriptType::ASIAN:
    1545           0 :             nActual = SW_CJK;
    1546           0 :             break;
    1547             :         case i18n::ScriptType::COMPLEX:
    1548           0 :             nActual = SW_CTL;
    1549           0 :             break;
    1550             :     }
    1551           0 :     aFont.SetActual(nActual);
    1552             : 
    1553           0 :     OutputDevice &rMutableOut = const_cast<OutputDevice &>(rOut);
    1554           0 :     const Font aOldFont(rMutableOut.GetFont());
    1555             : 
    1556           0 :     rMutableOut.SetFont(aFont.GetActualFont());
    1557           0 :     long nHeight = rMutableOut.GetTextHeight();
    1558             : 
    1559           0 :     rMutableOut.SetFont(aOldFont);
    1560           0 :     return nHeight;
    1561             : }
    1562             : 
    1563             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10