sw: prefix members of SwFont

Also de-obfuscate a few variable names:
- nToxCnt,m_nToxCount (one would wonder if content or count)
- nRefCnt,m_nRefCount
- bFntChg,m_bFontChg
- bNoColReplace,m_bNoColorReplace (one would wonder if color or column)

Change-Id: Ief67fe66e26a42d2156b815ed6f81f1e8b74175e

3 files changed, 368 insertions, 368 deletions

diff --git a/sw/source/core/inc/swfont.hxx b/sw/source/core/inc/swfont.hxx
index 269236a01de2..b1dc3974cc60 100644
--- a/sw/source/core/inc/swfont.hxx
+++ b/sw/source/core/inc/swfont.hxx
@@ -127,12 +127,12 @@ class SW_DLLPUBLIC SwFont
 {
     // CJK == Chinese, Japanese, Korean
     // CTL == Complex text layout ( Hebrew, Arabic )
-    SwSubFont   aSub[SW_SCRIPTS]; // Latin-, CJK- and CTL-font
+    SwSubFont   m_aSub[SW_SCRIPTS]; // Latin-, CJK- and CTL-font
 
-    Color*      pBackColor;     // background color (i.e. at character styles)
+    Color*      m_pBackColor;     // background color (i.e. at character styles)
     Color       m_aHighlightColor;   // highlight color
-    Color       aUnderColor;    // color of the underlining
-    Color       aOverColor;     // color of the overlining
+    Color       m_aUnderColor;    // color of the underlining
+    Color       m_aOverColor;     // color of the overlining
 
     // character borders
     boost::optional<editeng::SvxBorderLine>     m_aTopBorder;
@@ -150,70 +150,70 @@ class SW_DLLPUBLIC SwFont
     sal_uInt16          m_nShadowWidth;
     SvxShadowLocation   m_aShadowLocation;
 
-    sal_uInt8   nToxCnt;        // counts the nesting depth of the Tox
-    sal_uInt8   nRefCnt;        // counts the nesting depth of the Refs
+    sal_uInt8   m_nToxCount;        // counts the nesting depth of the Tox
+    sal_uInt8   m_nRefCount;        // counts the nesting depth of the Refs
     sal_uInt8   m_nMetaCount;   // count META/METAFIELD
     sal_uInt8   m_nInputFieldCount; // count INPUTFIELD
 
-    sal_uInt8   nActual;        // actual font (Latin, CJK or CTL)
+    sal_uInt8   m_nActual;        // actual font (Latin, CJK or CTL)
 
     // switch for the font-extensions
-    bool bNoHyph        :1;  // SwTextNoHyphenHere: no separator
-    bool bBlink         :1;  // blinking font
-    bool bPaintBlank    :1;  // blanks not with DrawRect
-    bool bFntChg        :1;
-    bool bOrgChg        :1;  // nOrgHeight/Ascent are invalid
-    bool bURL           :1;
-    bool bPaintWrong    :1;  // flag for spelling mistakes
-    bool bGreyWave      :1;  // for the extended TextInput: gray waveline
-    bool bNoColReplace  :1;  // Replacement without colormanipulation
+    bool m_bNoHyph        :1;  // SwTextNoHyphenHere: no separator
+    bool m_bBlink         :1;  // blinking font
+    bool m_bPaintBlank    :1;  // blanks not with DrawRect
+    bool m_bFontChg        :1;
+    bool m_bOrgChg        :1;  // nOrgHeight/Ascent are invalid
+    bool m_bURL           :1;
+    bool m_bPaintWrong    :1;  // flag for spelling mistakes
+    bool m_bGreyWave      :1;  // for the extended TextInput: gray waveline
+    bool m_bNoColorReplace  :1;  // Replacement without colormanipulation
 
 public:
     SwFont( const SwAttrSet* pSet, const IDocumentSettingAccess* pIDocumentSettingAccess );
     SwFont( const SwFont& rFont );
 
     inline void ChgFnt( SwViewShell const *pSh, OutputDevice& rOut )
-        { bPaintBlank = aSub[nActual].ChgFnt( pSh, rOut ); }
+        { m_bPaintBlank = m_aSub[m_nActual].ChgFnt( pSh, rOut ); }
 
     ~SwFont();
 
     SwFont& operator=( const SwFont &rFont );
 
-    inline sal_uInt8 GetActual() const {    return nActual; }
+    inline sal_uInt8 GetActual() const {    return m_nActual; }
     inline void SetActual( sal_uInt8 nNew );
-    inline const SvxFont& GetActualFont() const { return aSub[nActual]; }
+    inline const SvxFont& GetActualFont() const { return m_aSub[m_nActual]; }
 
     // gets a MagicNumber via SwFntAccess
     void GoMagic( SwViewShell *pSh, sal_uInt8 nWhich );
     // set background color
     void SetBackColor( Color* pNewColor );
-    inline const Color* GetBackColor() const{ return pBackColor; }
+    inline const Color* GetBackColor() const{ return m_pBackColor; }
     void SetHighlightColor( const Color& aNewColor );
     const Color& GetHighlightColor() const { return m_aHighlightColor; }
 
     inline void ChkMagic( SwViewShell *pSh, sal_uInt8 nWhich )
-        { if( !aSub[ nWhich ].pMagic ) GoMagic( pSh, nWhich ); }
+        { if( !m_aSub[ nWhich ].pMagic ) GoMagic( pSh, nWhich ); }
     inline void GetMagic( const void* &rMagic, sal_uInt16 &rIdx, sal_uInt8 nWhich )
-        { rMagic = aSub[nWhich].pMagic; rIdx = aSub[nWhich].nFntIndex; }
+        { rMagic = m_aSub[nWhich].pMagic; rIdx = m_aSub[nWhich].nFntIndex; }
     inline void SetMagic( const void* pNew, const sal_uInt16 nIdx, sal_uInt8 nWhich )
-        { aSub[nWhich].pMagic = pNew; aSub[nWhich].nFntIndex = nIdx; }
+        { m_aSub[nWhich].pMagic = pNew; m_aSub[nWhich].nFntIndex = nIdx; }
     inline bool DifferentMagic( const SwFont* pFnt, sal_uInt8 nWhich )
-        { return aSub[nWhich].pMagic != pFnt->aSub[nWhich].pMagic ||
-          !aSub[nWhich].pMagic || !pFnt->aSub[nWhich].pMagic; }
+        { return m_aSub[nWhich].pMagic != pFnt->m_aSub[nWhich].pMagic ||
+          !m_aSub[nWhich].pMagic || !pFnt->m_aSub[nWhich].pMagic; }
 
     inline const Size &GetSize( sal_uInt8 nWhich ) const
-        { return aSub[nWhich].aSize; }
-    inline bool IsFntChg() const { return bFntChg; }
-    inline void SetFntChg( const bool bNew ) { bFntChg = bNew; }
+        { return m_aSub[nWhich].aSize; }
+    inline bool IsFntChg() const { return m_bFontChg; }
+    inline void SetFntChg( const bool bNew ) { m_bFontChg = bNew; }
 
     // the encapsulated SV-Font-methods (set bFntChg to true)
     inline void SetColor( const Color& rColor );
     inline void SetFillColor( const Color& rColor );
     inline void SetAlign( const FontAlign eAlign );
     inline void SetUnderline( const FontUnderline eUnderline );
-    inline void SetUnderColor( const Color &rColor ) { aUnderColor = rColor; }
+    inline void SetUnderColor( const Color &rColor ) { m_aUnderColor = rColor; }
     inline void SetOverline( const FontUnderline eOverline );
-    inline void SetOverColor( const Color &rColor ) { aOverColor = rColor; }
+    inline void SetOverColor( const Color &rColor ) { m_aOverColor = rColor; }
     inline void SetStrikeout( const FontStrikeout eStrikeout );
     inline void SetOutline( const bool bOutline );
            void SetVertical( sal_uInt16 nDir, const bool bVertLayout = false );
@@ -245,56 +245,56 @@ public:
     // Get/Set-methods for the current setting
     inline void SetNoHyph( const bool bNew );
     inline void SetBlink( const bool bBlink );
-    inline bool IsBlink() const { return bBlink; }
-    inline sal_uInt8 &GetTox() { return nToxCnt; }
-    inline bool IsTox() const { return ( 0 != nToxCnt ); }
-    inline sal_uInt8 &GetRef() { return nRefCnt; }
-    inline bool IsRef() const { return ( 0 != nRefCnt ); }
+    inline bool IsBlink() const { return m_bBlink; }
+    inline sal_uInt8 &GetTox() { return m_nToxCount; }
+    inline bool IsTox() const { return ( 0 != m_nToxCount ); }
+    inline sal_uInt8 &GetRef() { return m_nRefCount; }
+    inline bool IsRef() const { return ( 0 != m_nRefCount ); }
     inline sal_uInt8 &GetMeta() { return m_nMetaCount; }
     inline bool IsMeta() const { return (0 != m_nMetaCount); }
     inline sal_uInt8 &GetInputField() { return m_nInputFieldCount; }
     inline bool IsInputField() const { return (0 != m_nInputFieldCount); }
-    inline bool IsURL() const { return bURL; }
+    inline bool IsURL() const { return m_bURL; }
     inline void SetGreyWave( const bool bNew );
-    inline bool IsGreyWave() const { return bGreyWave; }
+    inline bool IsGreyWave() const { return m_bGreyWave; }
     inline void SetNoCol( const bool bNew );
-    inline bool IsPaintBlank() const { return bPaintBlank; }
+    inline bool IsPaintBlank() const { return m_bPaintBlank; }
 
     // setting of the base class font for SwTextCharFormat
     void SetDiffFnt( const SfxItemSet* pSet,
                      const IDocumentSettingAccess* pIDocumentSettingAccess );
 
     inline const SvxFont &GetFnt( const sal_uInt8 nWhich ) const
-        { return aSub[nWhich]; };
+        { return m_aSub[nWhich]; };
 
     bool IsSymbol( SwViewShell *pSh )
-        { return aSub[nActual].IsSymbol( pSh ); }
-    FontUnderline GetUnderline() const { return aSub[nActual].GetUnderline(); }
-    const Color& GetUnderColor() const { return aUnderColor; }
-    FontUnderline GetOverline() const { return aSub[nActual].GetOverline(); }
-    const Color& GetOverColor() const { return aOverColor; }
-    FontStrikeout GetStrikeout() const { return aSub[nActual].GetStrikeout(); }
-    const Color& GetColor() const { return aSub[nActual].GetColor(); }
-    bool IsWordLineMode() const { return aSub[nActual].IsWordLineMode(); }
-    short GetEscapement() const { return aSub[nActual].GetEscapement(); }
-    SvxCaseMap GetCaseMap() const { return aSub[nActual].GetCaseMap(); }
-    sal_uInt8 GetPropr() const { return aSub[nActual].GetPropr(); }
-    FontItalic GetItalic() const { return aSub[nActual].GetItalic(); }
-    LanguageType GetLanguage() const { return aSub[nActual].GetLanguage(); }
-    long GetHeight() const { return aSub[nActual].GetSize().Height(); }
-    FontWeight GetWeight() const { return aSub[nActual].GetWeight(); }
+        { return m_aSub[m_nActual].IsSymbol( pSh ); }
+    FontUnderline GetUnderline() const { return m_aSub[m_nActual].GetUnderline(); }
+    const Color& GetUnderColor() const { return m_aUnderColor; }
+    FontUnderline GetOverline() const { return m_aSub[m_nActual].GetOverline(); }
+    const Color& GetOverColor() const { return m_aOverColor; }
+    FontStrikeout GetStrikeout() const { return m_aSub[m_nActual].GetStrikeout(); }
+    const Color& GetColor() const { return m_aSub[m_nActual].GetColor(); }
+    bool IsWordLineMode() const { return m_aSub[m_nActual].IsWordLineMode(); }
+    short GetEscapement() const { return m_aSub[m_nActual].GetEscapement(); }
+    SvxCaseMap GetCaseMap() const { return m_aSub[m_nActual].GetCaseMap(); }
+    sal_uInt8 GetPropr() const { return m_aSub[m_nActual].GetPropr(); }
+    FontItalic GetItalic() const { return m_aSub[m_nActual].GetItalic(); }
+    LanguageType GetLanguage() const { return m_aSub[m_nActual].GetLanguage(); }
+    long GetHeight() const { return m_aSub[m_nActual].GetSize().Height(); }
+    FontWeight GetWeight() const { return m_aSub[m_nActual].GetWeight(); }
     FontEmphasisMark GetEmphasisMark() const
-        { return aSub[nActual].GetEmphasisMark(); }
+        { return m_aSub[m_nActual].GetEmphasisMark(); }
     sal_uInt16 GetOrientation( const bool bVertLayout = false ) const;
 
     inline const OUString& GetName( const sal_uInt8 nWhich ) const
-        { return aSub[nWhich].GetName(); }
+        { return m_aSub[nWhich].GetName(); }
     inline LanguageType GetLanguage( const sal_uInt8 nWhich ) const
-        { return aSub[nWhich].GetLanguage(); }
+        { return m_aSub[nWhich].GetLanguage(); }
     inline rtl_TextEncoding GetCharSet( const sal_uInt8 nWhich ) const
-        { return aSub[nWhich].GetCharSet(); }
+        { return m_aSub[nWhich].GetCharSet(); }
     inline long GetHeight( const sal_uInt8 nWhich ) const
-        { return aSub[nWhich].GetSize().Height(); }
+        { return m_aSub[nWhich].GetSize().Height(); }
 
     // makes the logical font be effective in the OutputDevice
     void ChgPhysFnt( SwViewShell *pSh, OutputDevice& rOut );
@@ -305,32 +305,32 @@ public:
         const sal_Int32 nLen );
 
     void DoOnCapitals( SwDoCapitals &rDo )
-        { aSub[nActual].DoOnCapitals( rDo ); }
+        { m_aSub[m_nActual].DoOnCapitals( rDo ); }
 
     Size _GetTextSize( SwDrawTextInfo& rInf )
-        { rInf.SetFont( this ); return aSub[nActual]._GetTextSize( rInf ); }
+        { rInf.SetFont( this ); return m_aSub[m_nActual]._GetTextSize( rInf ); }
 
     sal_Int32 GetTextBreak( SwDrawTextInfo& rInf, long nTextWidth );
 
     sal_Int32 _GetCrsrOfst( SwDrawTextInfo& rInf )
-        { return aSub[nActual]._GetCrsrOfst( rInf ); }
+        { return m_aSub[m_nActual]._GetCrsrOfst( rInf ); }
 
     inline void _DrawText( SwDrawTextInfo &rInf )
-        { aSub[nActual]._DrawText( rInf, IsGreyWave() ); }
+        { m_aSub[m_nActual]._DrawText( rInf, IsGreyWave() ); }
 
     inline void _DrawStretchText( SwDrawTextInfo &rInf )
-        { aSub[nActual]._DrawStretchText( rInf ); }
+        { m_aSub[m_nActual]._DrawStretchText( rInf ); }
 
     inline short CheckKerning()
-        { return aSub[nActual].CheckKerning(); }
+        { return m_aSub[m_nActual].CheckKerning(); }
 
     inline sal_uInt16 GetAscent( SwViewShell *pSh, const OutputDevice& rOut )
-        { return aSub[nActual].GetAscent( pSh, rOut ); }
+        { return m_aSub[m_nActual].GetAscent( pSh, rOut ); }
     inline sal_uInt16 GetHeight( SwViewShell *pSh, const OutputDevice& rOut )
-        { return aSub[nActual].GetHeight( pSh, rOut ); }
+        { return m_aSub[m_nActual].GetHeight( pSh, rOut ); }
 
     inline void Invalidate()
-        { bFntChg = bOrgChg = true; }
+        { m_bFontChg = m_bOrgChg = true; }
 
     void SetTopBorder( const editeng::SvxBorderLine* pTopBorder );
     void SetBottomBorder( const editeng::SvxBorderLine* pBottomBorder );
@@ -405,10 +405,10 @@ public:
 
 inline void SwFont::SetColor( const Color& rColor )
 {
-    bFntChg = true;
-    aSub[0].SetColor( rColor );
-    aSub[1].SetColor( rColor );
-    aSub[2].SetColor( rColor );
+    m_bFontChg = true;
+    m_aSub[0].SetColor( rColor );
+    m_aSub[1].SetColor( rColor );
+    m_aSub[2].SetColor( rColor );
 }
 
 // encapsulated SV-Font-method
@@ -427,10 +427,10 @@ inline void SwSubFont::SetFillColor( const Color& rColor )
 
 inline void SwFont::SetFillColor( const Color& rColor )
 {
-    bFntChg = true;
-    aSub[0].SetFillColor( rColor );
-    aSub[1].SetFillColor( rColor );
-    aSub[2].SetFillColor( rColor );
+    m_bFontChg = true;
+    m_aSub[0].SetFillColor( rColor );
+    m_aSub[1].SetFillColor( rColor );
+    m_aSub[2].SetFillColor( rColor );
 }
 
 // encapsulated SV-Font-method
@@ -442,8 +442,8 @@ inline void SwSubFont::SetFamily( const FontFamily eFamily )
 
 inline void SwFont::SetFamily( const FontFamily eFamily, const sal_uInt8 nWhich )
 {
-    bFntChg = true;
-    aSub[nWhich].SetFamily( eFamily );
+    m_bFontChg = true;
+    m_aSub[nWhich].SetFamily( eFamily );
 }
 
 // encapsulated SV-Font-method
@@ -455,8 +455,8 @@ inline void SwSubFont::SetName( const OUString& rName )
 
 inline void SwFont::SetName( const OUString& rName, const sal_uInt8 nWhich )
 {
-    bFntChg = true;
-    aSub[nWhich].SetName( rName );
+    m_bFontChg = true;
+    m_aSub[nWhich].SetName( rName );
 }
 
 // encapsulated SV-Font-method
@@ -468,8 +468,8 @@ inline void SwSubFont::SetStyleName( const OUString& rStyleName )
 
 inline void SwFont::SetStyleName( const OUString& rStyle, const sal_uInt8 nWhich )
 {
-    bFntChg = true;
-    aSub[nWhich].SetStyleName( rStyle );
+    m_bFontChg = true;
+    m_aSub[nWhich].SetStyleName( rStyle );
 }
 
 // encapsulated SV-Font-method
@@ -481,8 +481,8 @@ inline void SwSubFont::SetCharSet( const rtl_TextEncoding eCharSet )
 
 inline void SwFont::SetCharSet( const rtl_TextEncoding eCharSet, const sal_uInt8 nWhich )
 {
-    bFntChg = true;
-    aSub[nWhich].SetCharSet( eCharSet );
+    m_bFontChg = true;
+    m_aSub[nWhich].SetCharSet( eCharSet );
 }
 
 // encapsulated SV-Font-method
@@ -495,8 +495,8 @@ inline void SwSubFont::SetPitch( const FontPitch ePitch )
 // encapsulated SV-Font-method
 inline void SwFont::SetPitch( const FontPitch ePitch, const sal_uInt8 nWhich )
 {
-    bFntChg = true;
-    aSub[nWhich].SetPitch( ePitch );
+    m_bFontChg = true;
+    m_aSub[nWhich].SetPitch( ePitch );
 }
 
 // encapsulated SV-Font-method
@@ -508,10 +508,10 @@ inline void SwSubFont::SetAlign( const FontAlign eAlign )
 
 inline void SwFont::SetAlign( const FontAlign eAlign )
 {
-    bFntChg = true;
-    aSub[0].SetAlign( eAlign );
-    aSub[1].SetAlign( eAlign );
-    aSub[2].SetAlign( eAlign );
+    m_bFontChg = true;
+    m_aSub[0].SetAlign( eAlign );
+    m_aSub[1].SetAlign( eAlign );
+    m_aSub[2].SetAlign( eAlign );
 }
 
 // encapsulated SV-Font-method
@@ -523,8 +523,8 @@ inline void SwSubFont::SetWeight( const FontWeight eWeight )
 
 inline void SwFont::SetWeight( const FontWeight eWeight, const sal_uInt8 nWhich )
 {
-    bFntChg = true;
-    aSub[nWhich].SetWeight( eWeight );
+    m_bFontChg = true;
+    m_aSub[nWhich].SetWeight( eWeight );
 }
 
 // encapsulated SV-Font-method
@@ -536,10 +536,10 @@ inline void SwSubFont::SetUnderline( const FontUnderline eUnderline )
 
 inline void SwFont::SetUnderline( const FontUnderline eUnderline )
 {
-    bFntChg = true;
-    aSub[0].SetUnderline( eUnderline );
-    aSub[1].SetUnderline( eUnderline );
-    aSub[2].SetUnderline( eUnderline );
+    m_bFontChg = true;
+    m_aSub[0].SetUnderline( eUnderline );
+    m_aSub[1].SetUnderline( eUnderline );
+    m_aSub[2].SetUnderline( eUnderline );
 }
 
 // encapsulated SV-Font-method
@@ -551,10 +551,10 @@ inline void SwSubFont::SetOverline( const FontUnderline eOverline )
 
 inline void SwFont::SetOverline( const FontUnderline eOverline )
 {
-    bFntChg = true;
-    aSub[0].SetOverline( eOverline );
-    aSub[1].SetOverline( eOverline );
-    aSub[2].SetOverline( eOverline );
+    m_bFontChg = true;
+    m_aSub[0].SetOverline( eOverline );
+    m_aSub[1].SetOverline( eOverline );
+    m_aSub[2].SetOverline( eOverline );
 }
 
 // encapsulated SV-Font-method
@@ -566,10 +566,10 @@ inline void SwSubFont::SetStrikeout( const FontStrikeout eStrikeout )
 
 inline void SwFont::SetStrikeout( const FontStrikeout eStrikeout )
 {
-    bFntChg = true;
-    aSub[0].SetStrikeout( eStrikeout );
-    aSub[1].SetStrikeout( eStrikeout );
-    aSub[2].SetStrikeout( eStrikeout );
+    m_bFontChg = true;
+    m_aSub[0].SetStrikeout( eStrikeout );
+    m_aSub[1].SetStrikeout( eStrikeout );
+    m_aSub[2].SetStrikeout( eStrikeout );
 }
 
 // encapsulated SV-Font-method
@@ -581,8 +581,8 @@ inline void SwSubFont::SetItalic( const FontItalic eItalic )
 
 inline void SwFont::SetItalic( const FontItalic eItalic, const sal_uInt8 nWhich )
 {
-    bFntChg = true;
-    aSub[nWhich].SetItalic( eItalic );
+    m_bFontChg = true;
+    m_aSub[nWhich].SetItalic( eItalic );
 }
 
 // encapsulated SV-Font-method
@@ -594,10 +594,10 @@ inline void SwSubFont::SetOutline( const bool bOutline )
 
 inline void SwFont::SetOutline( const bool bOutline )
 {
-    bFntChg = true;
-    aSub[0].SetOutline( bOutline );
-    aSub[1].SetOutline( bOutline );
-    aSub[2].SetOutline( bOutline );
+    m_bFontChg = true;
+    m_aSub[0].SetOutline( bOutline );
+    m_aSub[1].SetOutline( bOutline );
+    m_aSub[2].SetOutline( bOutline );
 }
 
 // encapsulated SV-Font-method
@@ -609,10 +609,10 @@ inline void SwSubFont::SetShadow( const bool bShadow )
 
 inline void SwFont::SetShadow( const bool bShadow )
 {
-    bFntChg = true;
-    aSub[0].SetShadow( bShadow );
-    aSub[1].SetShadow( bShadow );
-    aSub[2].SetShadow( bShadow );
+    m_bFontChg = true;
+    m_aSub[0].SetShadow( bShadow );
+    m_aSub[1].SetShadow( bShadow );
+    m_aSub[2].SetShadow( bShadow );
 }
 
 // encapsulated SV-Font-method
@@ -624,33 +624,33 @@ inline void SwSubFont::SetAutoKern( FontKerning nAutoKern )
 
 inline void SwFont::SetAutoKern( FontKerning nAutoKern )
 {
-    bFntChg = true;
-    aSub[1].SetAutoKern( nAutoKern );
+    m_bFontChg = true;
+    m_aSub[1].SetAutoKern( nAutoKern );
     if( nAutoKern != FontKerning::NONE )
         nAutoKern = FontKerning::FontSpecific;
-    aSub[0].SetAutoKern( nAutoKern );
-    aSub[2].SetAutoKern( nAutoKern );
+    m_aSub[0].SetAutoKern( nAutoKern );
+    m_aSub[2].SetAutoKern( nAutoKern );
 }
 
 inline void SwFont::SetTransparent( const bool bTrans )
 {
-    aSub[0].SetTransparent( bTrans );
-    aSub[1].SetTransparent( bTrans );
-    aSub[2].SetTransparent( bTrans );
+    m_aSub[0].SetTransparent( bTrans );
+    m_aSub[1].SetTransparent( bTrans );
+    m_aSub[2].SetTransparent( bTrans );
 }
 
 inline void SwFont::SetFixKerning( const short nNewKern )
 {
-    aSub[SW_LATIN].SetFixKerning( nNewKern );
-    aSub[SW_CJK].SetFixKerning( nNewKern );
-    aSub[SW_CTL].SetFixKerning( nNewKern );
+    m_aSub[SW_LATIN].SetFixKerning( nNewKern );
+    m_aSub[SW_CJK].SetFixKerning( nNewKern );
+    m_aSub[SW_CTL].SetFixKerning( nNewKern );
 }
 
 inline void SwFont::SetCaseMap( const SvxCaseMap eNew )
 {
-    aSub[SW_LATIN].SetCaseMap( eNew );
-    aSub[SW_CJK].SetCaseMap( eNew );
-    aSub[SW_CTL].SetCaseMap( eNew );
+    m_aSub[SW_LATIN].SetCaseMap( eNew );
+    m_aSub[SW_CJK].SetCaseMap( eNew );
+    m_aSub[SW_CTL].SetCaseMap( eNew );
 }
 
 // encapsulated SV-Font-method
@@ -662,10 +662,10 @@ inline void SwSubFont::SetWordLineMode( const bool bWordLineMode )
 
 inline void SwFont::SetWordLineMode( const bool bWordLineMode )
 {
-    bFntChg = true;
-    aSub[0].SetWordLineMode( bWordLineMode );
-    aSub[1].SetWordLineMode( bWordLineMode );
-    aSub[2].SetWordLineMode( bWordLineMode );
+    m_bFontChg = true;
+    m_aSub[0].SetWordLineMode( bWordLineMode );
+    m_aSub[1].SetWordLineMode( bWordLineMode );
+    m_aSub[2].SetWordLineMode( bWordLineMode );
 }
 // encapsulated SV-Font-method
 inline void SwSubFont::SetEmphasisMark( const FontEmphasisMark eValue )
@@ -676,20 +676,20 @@ inline void SwSubFont::SetEmphasisMark( const FontEmphasisMark eValue )
 
 inline void SwFont::SetEmphasisMark( const FontEmphasisMark eValue )
 {
-    bFntChg = true;
-    aSub[0].SetEmphasisMark( eValue );
-    aSub[1].SetEmphasisMark( eValue );
-    aSub[2].SetEmphasisMark( eValue );
+    m_bFontChg = true;
+    m_aSub[0].SetEmphasisMark( eValue );
+    m_aSub[1].SetEmphasisMark( eValue );
+    m_aSub[2].SetEmphasisMark( eValue );
 }
 
 inline void SwFont::SetPropWidth( const sal_uInt16 nNew )
 {
-    if( nNew != aSub[0].GetPropWidth() )
+    if( nNew != m_aSub[0].GetPropWidth() )
     {
-        bFntChg = true;
-        aSub[0].SetPropWidth( nNew );
-        aSub[1].SetPropWidth( nNew );
-        aSub[2].SetPropWidth( nNew );
+        m_bFontChg = true;
+        m_aSub[0].SetPropWidth( nNew );
+        m_aSub[1].SetPropWidth( nNew );
+        m_aSub[2].SetPropWidth( nNew );
     }
 }
 
@@ -702,12 +702,12 @@ inline void SwSubFont::SetRelief( const FontRelief eNew )
 
 inline void SwFont::SetRelief( const FontRelief eNew )
 {
-    if( eNew != aSub[0].GetRelief() )
+    if( eNew != m_aSub[0].GetRelief() )
     {
-        bFntChg = true;
-        aSub[0].SetRelief( eNew );
-        aSub[1].SetRelief( eNew );
-        aSub[2].SetRelief( eNew );
+        m_bFontChg = true;
+        m_aSub[0].SetRelief( eNew );
+        m_aSub[1].SetRelief( eNew );
+        m_aSub[2].SetRelief( eNew );
     }
 }
 
@@ -728,21 +728,21 @@ inline void SwSubFont::SetSize( const Size& rSize )
 
 inline void SwFont::SetSize( const Size& rSize, const sal_uInt8 nWhich )
 {
-    if( aSub[nWhich].aSize != rSize )
+    if( m_aSub[nWhich].aSize != rSize )
     {
-        aSub[nWhich].SetSize( rSize );
-        bFntChg = true;
-        bOrgChg = true;
+        m_aSub[nWhich].SetSize( rSize );
+        m_bFontChg = true;
+        m_bOrgChg = true;
     }
 }
 
 inline void SwFont::SetActual( sal_uInt8 nNew )
 {
-     if ( nActual != nNew )
+     if ( m_nActual != nNew )
      {
-        bFntChg = true;
-        bOrgChg = true;
-        nActual = nNew;
+        m_bFontChg = true;
+        m_bOrgChg = true;
+        m_nActual = nNew;
      }
 }
 
@@ -756,14 +756,14 @@ inline void SwSubFont::SetProportion( const sal_uInt8 nNewPropr )
 
 inline void SwFont::SetProportion( const sal_uInt8 nNewPropr )
 {
-    if( nNewPropr != aSub[0].GetPropr() )
+    if( nNewPropr != m_aSub[0].GetPropr() )
     {
-        bFntChg = true;
-        bOrgChg = true;
+        m_bFontChg = true;
+        m_bOrgChg = true;
 
-        aSub[0].SetProportion( nNewPropr );
-        aSub[1].SetProportion( nNewPropr );
-        aSub[2].SetProportion( nNewPropr );
+        m_aSub[0].SetProportion( nNewPropr );
+        m_aSub[1].SetProportion( nNewPropr );
+        m_aSub[2].SetProportion( nNewPropr );
     }
 }
 
@@ -775,16 +775,16 @@ inline void SwSubFont::SetEscapement( const short nNewEsc )
 
 inline void SwFont::SetEscapement( const short nNewEsc )
 {
-    if( nNewEsc != aSub[0].GetEscapement() )
+    if( nNewEsc != m_aSub[0].GetEscapement() )
     {
         // these have to be set, otherwise nOrgHeight and nOrgAscent will not
         // be calculated
-        bFntChg = true;
-        bOrgChg = true;
+        m_bFontChg = true;
+        m_bOrgChg = true;
 
-        aSub[0].SetEscapement( nNewEsc );
-        aSub[1].SetEscapement( nNewEsc );
-        aSub[2].SetEscapement( nNewEsc );
+        m_aSub[0].SetEscapement( nNewEsc );
+        m_aSub[1].SetEscapement( nNewEsc );
+        m_aSub[2].SetEscapement( nNewEsc );
     }
 }
 
@@ -798,33 +798,33 @@ inline void SwSubFont::SetLanguage( LanguageType eNewLang )
 
 inline void SwFont::SetLanguage( const LanguageType eNewLang, const sal_uInt8 nWhich )
 {
-    aSub[nWhich].SetLanguage( eNewLang );
+    m_aSub[nWhich].SetLanguage( eNewLang );
     if( SW_CJK == nWhich )
     {
-        aSub[SW_LATIN].SetCJKContextLanguage( eNewLang );
-        aSub[SW_CJK].SetCJKContextLanguage( eNewLang );
-        aSub[SW_CTL].SetCJKContextLanguage( eNewLang );
+        m_aSub[SW_LATIN].SetCJKContextLanguage( eNewLang );
+        m_aSub[SW_CJK].SetCJKContextLanguage( eNewLang );
+        m_aSub[SW_CTL].SetCJKContextLanguage( eNewLang );
     }
 }
 
 inline void SwFont::SetNoHyph( const bool bNew )
 {
-    bNoHyph = bNew;
+    m_bNoHyph = bNew;
 }
 
 inline void SwFont::SetBlink( const bool bNew )
 {
-    bBlink = bNew;
+    m_bBlink = bNew;
 }
 
 inline void SwFont::SetGreyWave( const bool bNew )
 {
-    bGreyWave = bNew;
+    m_bGreyWave = bNew;
 }
 
 inline void SwFont::SetNoCol( const bool bNew )
 {
-    bNoColReplace = bNew;
+    m_bNoColorReplace = bNew;
 }
 
 inline void SwSubFont::SetVertical( const sal_uInt16 nDir, const bool bVertFormat )
@@ -837,29 +837,29 @@ inline void SwSubFont::SetVertical( const sal_uInt16 nDir, const bool bVertForma
 inline void SwFont::SetTopBorderDist( const sal_uInt16 nTopDist )
 {
     m_nTopBorderDist = nTopDist;
-    bFntChg = true;
-    aSub[SW_LATIN].pMagic = aSub[SW_CJK].pMagic = aSub[SW_CTL].pMagic = 0;
+    m_bFontChg = true;
+    m_aSub[SW_LATIN].pMagic = m_aSub[SW_CJK].pMagic = m_aSub[SW_CTL].pMagic = 0;
 }
 
 inline void SwFont::SetBottomBorderDist( const sal_uInt16 nBottomDist )
 {
     m_nBottomBorderDist = nBottomDist;
-    bFntChg = true;
-    aSub[SW_LATIN].pMagic = aSub[SW_CJK].pMagic = aSub[SW_CTL].pMagic = 0;
+    m_bFontChg = true;
+    m_aSub[SW_LATIN].pMagic = m_aSub[SW_CJK].pMagic = m_aSub[SW_CTL].pMagic = 0;
 }
 
 inline void SwFont::SetRightBorderDist( const sal_uInt16 nRightDist )
 {
     m_nRightBorderDist = nRightDist;
-    bFntChg = true;
-    aSub[SW_LATIN].pMagic = aSub[SW_CJK].pMagic = aSub[SW_CTL].pMagic = 0;
+    m_bFontChg = true;
+    m_aSub[SW_LATIN].pMagic = m_aSub[SW_CJK].pMagic = m_aSub[SW_CTL].pMagic = 0;
 }
 
 inline void SwFont::SetLeftBorderDist( const sal_uInt16 nLeftDist )
 {
     m_nLeftBorderDist = nLeftDist;
-    bFntChg = true;
-    aSub[SW_LATIN].pMagic = aSub[SW_CJK].pMagic = aSub[SW_CTL].pMagic = 0;
+    m_bFontChg = true;
+    m_aSub[SW_LATIN].pMagic = m_aSub[SW_CJK].pMagic = m_aSub[SW_CTL].pMagic = 0;
 }
 
 inline sal_uInt16 SwFont::GetTopBorderSpace() const
@@ -930,29 +930,29 @@ inline bool SwFont::HasBorder() const
 inline void SwFont::SetShadowColor( const Color& rColor )
 {
     m_aShadowColor = rColor;
-    bFntChg = true;
-    aSub[SW_LATIN].pMagic = aSub[SW_CJK].pMagic = aSub[SW_CTL].pMagic = 0;
+    m_bFontChg = true;
+    m_aSub[SW_LATIN].pMagic = m_aSub[SW_CJK].pMagic = m_aSub[SW_CTL].pMagic = 0;
 }
 
 inline void SwFont::SetShadowWidth( const sal_uInt16 nWidth )
 {
     m_nShadowWidth = nWidth;
-    bFntChg = true;
-    aSub[SW_LATIN].pMagic = aSub[SW_CJK].pMagic = aSub[SW_CTL].pMagic = 0;
+    m_bFontChg = true;
+    m_aSub[SW_LATIN].pMagic = m_aSub[SW_CJK].pMagic = m_aSub[SW_CTL].pMagic = 0;
 }
 
 inline void SwFont::SetShadowLocation( const SvxShadowLocation aLocation )
 {
     m_aShadowLocation = aLocation;
-    bFntChg = true;
-    aSub[SW_LATIN].pMagic = aSub[SW_CJK].pMagic = aSub[SW_CTL].pMagic = 0;
+    m_bFontChg = true;
+    m_aSub[SW_LATIN].pMagic = m_aSub[SW_CJK].pMagic = m_aSub[SW_CTL].pMagic = 0;
 }
 
 inline void SwFont::SetHighlightColor( const Color& aNewColor )
 {
     m_aHighlightColor = aNewColor;
-    bFntChg = true;
-    aSub[SW_LATIN].pMagic = aSub[SW_CJK].pMagic = aSub[SW_CTL].pMagic = 0;
+    m_bFontChg = true;
+    m_aSub[SW_LATIN].pMagic = m_aSub[SW_CJK].pMagic = m_aSub[SW_CTL].pMagic = 0;
 }
 
 // Used for the "continuous underline" feature.
diff --git a/sw/source/core/txtnode/fntcache.cxx b/sw/source/core/txtnode/fntcache.cxx
index e7a37702bbb9..2f09296b023b 100644
--- a/sw/source/core/txtnode/fntcache.cxx
+++ b/sw/source/core/txtnode/fntcache.cxx
@@ -2377,7 +2377,7 @@ sal_Int32 SwFont::GetTextBreak( SwDrawTextInfo& rInf, long nTextWidth )
         }
     }
 
-    if( aSub[nActual].IsCapital() && nLn )
+    if( m_aSub[m_nActual].IsCapital() && nLn )
     {
         nTextBreak = GetCapitalBreak( rInf.GetShell(), rInf.GetpOut(),
             rInf.GetScriptInfo(), rInf.GetText(), nTextWidth, rInf.GetIdx(),
@@ -2393,7 +2393,7 @@ sal_Int32 SwFont::GetTextBreak( SwDrawTextInfo& rInf, long nTextWidth )
         sal_Int32 nTmpLen;
         bool bTextReplaced = false;
 
-        if ( !aSub[nActual].IsCaseMap() )
+        if ( !m_aSub[m_nActual].IsCaseMap() )
         {
             pTmpText = &rInf.GetText();
             nTmpIdx = rInf.GetIdx();
@@ -2402,8 +2402,8 @@ sal_Int32 SwFont::GetTextBreak( SwDrawTextInfo& rInf, long nTextWidth )
         else
         {
             const OUString aSnippet(rInf.GetText().copy(rInf.GetIdx(), nLn));
-            aTmpText = aSub[nActual].CalcCaseMap( aSnippet );
-            const bool bTitle = SVX_CASEMAP_TITEL == aSub[nActual].GetCaseMap() &&
+            aTmpText = m_aSub[m_nActual].CalcCaseMap( aSnippet );
+            const bool bTitle = SVX_CASEMAP_TITEL == m_aSub[m_nActual].GetCaseMap() &&
                                 g_pBreakIt->GetBreakIter().is();
 
             // Uaaaaahhhh!!! In title case mode, we would get wrong results
@@ -2412,12 +2412,12 @@ sal_Int32 SwFont::GetTextBreak( SwDrawTextInfo& rInf, long nTextWidth )
                 // check if rInf.GetIdx() is begin of word
                 if ( !g_pBreakIt->GetBreakIter()->isBeginWord(
                      rInf.GetText(), rInf.GetIdx(),
-                     g_pBreakIt->GetLocale( aSub[nActual].GetLanguage() ),
+                     g_pBreakIt->GetLocale( m_aSub[m_nActual].GetLanguage() ),
                      i18n::WordType::ANYWORD_IGNOREWHITESPACES ) )
                 {
                     // In this case, the beginning of aTmpText is wrong.
                     OUString aSnippetTmp(aSnippet.copy(0, 1));
-                    aSnippetTmp = aSub[nActual].CalcCaseMap( aSnippetTmp );
+                    aSnippetTmp = m_aSub[m_nActual].CalcCaseMap( aSnippetTmp );
                     aTmpText = aTmpText.replaceAt( 0, aSnippetTmp.getLength(), OUString(aSnippet[0]) );
                 }
             }
@@ -2466,7 +2466,7 @@ sal_Int32 SwFont::GetTextBreak( SwDrawTextInfo& rInf, long nTextWidth )
         rInf.GetOut().GetTextArray( rInf.GetText(), pKernArray,
                                     rInf.GetIdx(), nLn );
         if( rInf.GetScriptInfo()->Compress( pKernArray, rInf.GetIdx(), nLn,
-                            rInf.GetKanaComp(), (sal_uInt16)GetHeight( nActual ) ) )
+                            rInf.GetKanaComp(), (sal_uInt16)GetHeight( m_nActual ) ) )
         {
             long nKernAdd = nKern;
             sal_Int32 nTmpBreak = nTextBreak2;
diff --git a/sw/source/core/txtnode/swfont.cxx b/sw/source/core/txtnode/swfont.cxx
index 639aab732e21..074dbfef833f 100644
--- a/sw/source/core/txtnode/swfont.cxx
+++ b/sw/source/core/txtnode/swfont.cxx
@@ -69,10 +69,10 @@ using namespace ::com::sun::star;
 // Hintergrundbrush setzen, z.B. bei Zeichenvorlagen
 void SwFont::SetBackColor( Color* pNewColor )
 {
-    delete pBackColor;
-    pBackColor = pNewColor;
-    bFntChg = true;
-    aSub[SW_LATIN].pMagic = aSub[SW_CJK].pMagic = aSub[SW_CTL].pMagic = 0;
+    delete m_pBackColor;
+    m_pBackColor = pNewColor;
+    m_bFontChg = true;
+    m_aSub[SW_LATIN].pMagic = m_aSub[SW_CJK].pMagic = m_aSub[SW_CTL].pMagic = 0;
 }
 
 void SwFont::SetTopBorder( const editeng::SvxBorderLine* pTopBorder )
@@ -84,8 +84,8 @@ void SwFont::SetTopBorder( const editeng::SvxBorderLine* pTopBorder )
         m_aTopBorder = boost::none;
         m_nTopBorderDist = 0;
     }
-    bFntChg = true;
-    aSub[SW_LATIN].pMagic = aSub[SW_CJK].pMagic = aSub[SW_CTL].pMagic = 0;
+    m_bFontChg = true;
+    m_aSub[SW_LATIN].pMagic = m_aSub[SW_CJK].pMagic = m_aSub[SW_CTL].pMagic = 0;
 }
 
 void SwFont::SetBottomBorder( const editeng::SvxBorderLine* pBottomBorder )
@@ -97,8 +97,8 @@ void SwFont::SetBottomBorder( const editeng::SvxBorderLine* pBottomBorder )
         m_aBottomBorder = boost::none;
         m_nBottomBorderDist = 0;
     }
-    bFntChg = true;
-    aSub[SW_LATIN].pMagic = aSub[SW_CJK].pMagic = aSub[SW_CTL].pMagic = 0;
+    m_bFontChg = true;
+    m_aSub[SW_LATIN].pMagic = m_aSub[SW_CJK].pMagic = m_aSub[SW_CTL].pMagic = 0;
 }
 
 void SwFont::SetRightBorder( const editeng::SvxBorderLine* pRightBorder )
@@ -110,8 +110,8 @@ void SwFont::SetRightBorder( const editeng::SvxBorderLine* pRightBorder )
         m_aRightBorder = boost::none;
         m_nRightBorderDist = 0;
     }
-    bFntChg = true;
-    aSub[SW_LATIN].pMagic = aSub[SW_CJK].pMagic = aSub[SW_CTL].pMagic = 0;
+    m_bFontChg = true;
+    m_aSub[SW_LATIN].pMagic = m_aSub[SW_CJK].pMagic = m_aSub[SW_CTL].pMagic = 0;
 }
 
 void SwFont::SetLeftBorder( const editeng::SvxBorderLine* pLeftBorder )
@@ -123,8 +123,8 @@ void SwFont::SetLeftBorder( const editeng::SvxBorderLine* pLeftBorder )
         m_aLeftBorder = boost::none;
         m_nLeftBorderDist = 0;
     }
-    bFntChg = true;
-    aSub[SW_LATIN].pMagic = aSub[SW_CJK].pMagic = aSub[SW_CTL].pMagic = 0;
+    m_bFontChg = true;
+    m_aSub[SW_LATIN].pMagic = m_aSub[SW_CJK].pMagic = m_aSub[SW_CTL].pMagic = 0;
 }
 
 const boost::optional<editeng::SvxBorderLine>&
@@ -420,7 +420,7 @@ sal_uInt16 UnMapDirection( sal_uInt16 nDir, const bool bVertFormat )
 
 sal_uInt16 SwFont::GetOrientation( const bool bVertFormat ) const
 {
-    return UnMapDirection( aSub[nActual].GetOrientation(), bVertFormat );
+    return UnMapDirection( m_aSub[m_nActual].GetOrientation(), bVertFormat );
 }
 
 void SwFont::SetVertical( sal_uInt16 nDir, const bool bVertFormat )
@@ -428,12 +428,12 @@ void SwFont::SetVertical( sal_uInt16 nDir, const bool bVertFormat )
     // map direction if frame has vertical layout
     nDir = MapDirection( nDir, bVertFormat );
 
-    if( nDir != aSub[0].GetOrientation() )
+    if( nDir != m_aSub[0].GetOrientation() )
     {
-        bFntChg = true;
-        aSub[0].SetVertical( nDir, bVertFormat );
-        aSub[1].SetVertical( nDir, bVertFormat );
-        aSub[2].SetVertical( nDir, bVertFormat );
+        m_bFontChg = true;
+        m_aSub[0].SetVertical( nDir, bVertFormat );
+        m_aSub[1].SetVertical( nDir, bVertFormat );
+        m_aSub[2].SetVertical( nDir, bVertFormat );
     }
 }
 
@@ -481,8 +481,8 @@ sal_uInt16 SwSubFont::CalcEscAscent( const sal_uInt16 nOldAscent ) const
 void SwFont::SetDiffFnt( const SfxItemSet *pAttrSet,
                          const IDocumentSettingAccess *pIDocumentSettingAccess )
 {
-    delete pBackColor;
-    pBackColor = NULL;
+    delete m_pBackColor;
+    m_pBackColor = NULL;
 
     if( pAttrSet )
     {
@@ -491,97 +491,97 @@ void SwFont::SetDiffFnt( const SfxItemSet *pAttrSet,
             true, &pItem ))
         {
             const SvxFontItem *pFont = static_cast<const SvxFontItem *>(pItem);
-            aSub[SW_LATIN].SetFamily( pFont->GetFamily() );
-            aSub[SW_LATIN].Font::SetName( pFont->GetFamilyName() );
-            aSub[SW_LATIN].Font::SetStyleName( pFont->GetStyleName() );
-            aSub[SW_LATIN].Font::SetPitch( pFont->GetPitch() );
-            aSub[SW_LATIN].Font::SetCharSet( pFont->GetCharSet() );
+            m_aSub[SW_LATIN].SetFamily( pFont->GetFamily() );
+            m_aSub[SW_LATIN].Font::SetName( pFont->GetFamilyName() );
+            m_aSub[SW_LATIN].Font::SetStyleName( pFont->GetStyleName() );
+            m_aSub[SW_LATIN].Font::SetPitch( pFont->GetPitch() );
+            m_aSub[SW_LATIN].Font::SetCharSet( pFont->GetCharSet() );
         }
         if( SfxItemState::SET == pAttrSet->GetItemState( RES_CHRATR_FONTSIZE,
             true, &pItem ))
         {
             const SvxFontHeightItem *pHeight = static_cast<const SvxFontHeightItem *>(pItem);
-            aSub[SW_LATIN].SvxFont::SetPropr( 100 );
-            aSub[SW_LATIN].aSize = aSub[SW_LATIN].Font::GetSize();
-            Size aTmpSize = aSub[SW_LATIN].aSize;
+            m_aSub[SW_LATIN].SvxFont::SetPropr( 100 );
+            m_aSub[SW_LATIN].aSize = m_aSub[SW_LATIN].Font::GetSize();
+            Size aTmpSize = m_aSub[SW_LATIN].aSize;
             aTmpSize.Height() = pHeight->GetHeight();
-            aSub[SW_LATIN].SetSize( aTmpSize );
+            m_aSub[SW_LATIN].SetSize( aTmpSize );
         }
         if( SfxItemState::SET == pAttrSet->GetItemState( RES_CHRATR_POSTURE,
             true, &pItem ))
-            aSub[SW_LATIN].Font::SetItalic( static_cast<const SvxPostureItem*>(pItem)->GetPosture() );
+            m_aSub[SW_LATIN].Font::SetItalic( static_cast<const SvxPostureItem*>(pItem)->GetPosture() );
         if( SfxItemState::SET == pAttrSet->GetItemState( RES_CHRATR_WEIGHT,
             true, &pItem ))
-            aSub[SW_LATIN].Font::SetWeight( static_cast<const SvxWeightItem*>(pItem)->GetWeight() );
+            m_aSub[SW_LATIN].Font::SetWeight( static_cast<const SvxWeightItem*>(pItem)->GetWeight() );
         if( SfxItemState::SET == pAttrSet->GetItemState( RES_CHRATR_LANGUAGE,
             true, &pItem ))
-            aSub[SW_LATIN].SetLanguage( static_cast<const SvxLanguageItem*>(pItem)->GetLanguage() );
+            m_aSub[SW_LATIN].SetLanguage( static_cast<const SvxLanguageItem*>(pItem)->GetLanguage() );
 
         if( SfxItemState::SET == pAttrSet->GetItemState( RES_CHRATR_CJK_FONT,
             true, &pItem ))
         {
             const SvxFontItem *pFont = static_cast<const SvxFontItem *>(pItem);
-            aSub[SW_CJK].SetFamily( pFont->GetFamily() );
-            aSub[SW_CJK].Font::SetName( pFont->GetFamilyName() );
-            aSub[SW_CJK].Font::SetStyleName( pFont->GetStyleName() );
-            aSub[SW_CJK].Font::SetPitch( pFont->GetPitch() );
-            aSub[SW_CJK].Font::SetCharSet( pFont->GetCharSet() );
+            m_aSub[SW_CJK].SetFamily( pFont->GetFamily() );
+            m_aSub[SW_CJK].Font::SetName( pFont->GetFamilyName() );
+            m_aSub[SW_CJK].Font::SetStyleName( pFont->GetStyleName() );
+            m_aSub[SW_CJK].Font::SetPitch( pFont->GetPitch() );
+            m_aSub[SW_CJK].Font::SetCharSet( pFont->GetCharSet() );
         }
         if( SfxItemState::SET == pAttrSet->GetItemState( RES_CHRATR_CJK_FONTSIZE,
             true, &pItem ))
         {
             const SvxFontHeightItem *pHeight = static_cast<const SvxFontHeightItem *>(pItem);
-            aSub[SW_CJK].SvxFont::SetPropr( 100 );
-            aSub[SW_CJK].aSize = aSub[SW_CJK].Font::GetSize();
-            Size aTmpSize = aSub[SW_CJK].aSize;
+            m_aSub[SW_CJK].SvxFont::SetPropr( 100 );
+            m_aSub[SW_CJK].aSize = m_aSub[SW_CJK].Font::GetSize();
+            Size aTmpSize = m_aSub[SW_CJK].aSize;
             aTmpSize.Height() = pHeight->GetHeight();
-            aSub[SW_CJK].SetSize( aTmpSize );
+            m_aSub[SW_CJK].SetSize( aTmpSize );
         }
         if( SfxItemState::SET == pAttrSet->GetItemState( RES_CHRATR_CJK_POSTURE,
             true, &pItem ))
-            aSub[SW_CJK].Font::SetItalic( static_cast<const SvxPostureItem*>(pItem)->GetPosture() );
+            m_aSub[SW_CJK].Font::SetItalic( static_cast<const SvxPostureItem*>(pItem)->GetPosture() );
         if( SfxItemState::SET == pAttrSet->GetItemState( RES_CHRATR_CJK_WEIGHT,
             true, &pItem ))
-            aSub[SW_CJK].Font::SetWeight( static_cast<const SvxWeightItem*>(pItem)->GetWeight() );
+            m_aSub[SW_CJK].Font::SetWeight( static_cast<const SvxWeightItem*>(pItem)->GetWeight() );
         if( SfxItemState::SET == pAttrSet->GetItemState( RES_CHRATR_CJK_LANGUAGE,
             true, &pItem ))
         {
             LanguageType eNewLang = static_cast<const SvxLanguageItem*>(pItem)->GetLanguage();
-            aSub[SW_CJK].SetLanguage( eNewLang );
-            aSub[SW_LATIN].SetCJKContextLanguage( eNewLang );
-            aSub[SW_CJK].SetCJKContextLanguage( eNewLang );
-            aSub[SW_CTL].SetCJKContextLanguage( eNewLang );
+            m_aSub[SW_CJK].SetLanguage( eNewLang );
+            m_aSub[SW_LATIN].SetCJKContextLanguage( eNewLang );
+            m_aSub[SW_CJK].SetCJKContextLanguage( eNewLang );
+            m_aSub[SW_CTL].SetCJKContextLanguage( eNewLang );
         }
 
         if( SfxItemState::SET == pAttrSet->GetItemState( RES_CHRATR_CTL_FONT,
             true, &pItem ))
         {
             const SvxFontItem *pFont = static_cast<const SvxFontItem *>(pItem);
-            aSub[SW_CTL].SetFamily( pFont->GetFamily() );
-            aSub[SW_CTL].Font::SetName( pFont->GetFamilyName() );
-            aSub[SW_CTL].Font::SetStyleName( pFont->GetStyleName() );
-            aSub[SW_CTL].Font::SetPitch( pFont->GetPitch() );
-            aSub[SW_CTL].Font::SetCharSet( pFont->GetCharSet() );
+            m_aSub[SW_CTL].SetFamily( pFont->GetFamily() );
+            m_aSub[SW_CTL].Font::SetName( pFont->GetFamilyName() );
+            m_aSub[SW_CTL].Font::SetStyleName( pFont->GetStyleName() );
+            m_aSub[SW_CTL].Font::SetPitch( pFont->GetPitch() );
+            m_aSub[SW_CTL].Font::SetCharSet( pFont->GetCharSet() );
         }
         if( SfxItemState::SET == pAttrSet->GetItemState( RES_CHRATR_CTL_FONTSIZE,
             true, &pItem ))
         {
             const SvxFontHeightItem *pHeight = static_cast<const SvxFontHeightItem *>(pItem);
-            aSub[SW_CTL].SvxFont::SetPropr( 100 );
-            aSub[SW_CTL].aSize = aSub[SW_CTL].Font::GetSize();
-            Size aTmpSize = aSub[SW_CTL].aSize;
+            m_aSub[SW_CTL].SvxFont::SetPropr( 100 );
+            m_aSub[SW_CTL].aSize = m_aSub[SW_CTL].Font::GetSize();
+            Size aTmpSize = m_aSub[SW_CTL].aSize;
             aTmpSize.Height() = pHeight->GetHeight();
-            aSub[SW_CTL].SetSize( aTmpSize );
+            m_aSub[SW_CTL].SetSize( aTmpSize );
         }
         if( SfxItemState::SET == pAttrSet->GetItemState( RES_CHRATR_CTL_POSTURE,
             true, &pItem ))
-            aSub[SW_CTL].Font::SetItalic( static_cast<const SvxPostureItem*>(pItem)->GetPosture() );
+            m_aSub[SW_CTL].Font::SetItalic( static_cast<const SvxPostureItem*>(pItem)->GetPosture() );
         if( SfxItemState::SET == pAttrSet->GetItemState( RES_CHRATR_CTL_WEIGHT,
             true, &pItem ))
-            aSub[SW_CTL].Font::SetWeight( static_cast<const SvxWeightItem*>(pItem)->GetWeight() );
+            m_aSub[SW_CTL].Font::SetWeight( static_cast<const SvxWeightItem*>(pItem)->GetWeight() );
         if( SfxItemState::SET == pAttrSet->GetItemState( RES_CHRATR_CTL_LANGUAGE,
             true, &pItem ))
-            aSub[SW_CTL].SetLanguage( static_cast<const SvxLanguageItem*>(pItem)->GetLanguage() );
+            m_aSub[SW_CTL].SetLanguage( static_cast<const SvxLanguageItem*>(pItem)->GetLanguage() );
 
         if( SfxItemState::SET == pAttrSet->GetItemState( RES_CHRATR_UNDERLINE,
             true, &pItem ))
@@ -641,7 +641,7 @@ void SwFont::SetDiffFnt( const SfxItemSet *pAttrSet,
         {
             const SvxEscapementItem *pEsc = static_cast<const SvxEscapementItem *>(pItem);
             SetEscapement( pEsc->GetEsc() );
-            if( aSub[SW_LATIN].IsEsc() )
+            if( m_aSub[SW_LATIN].IsEsc() )
                 SetProportion( pEsc->GetProp() );
         }
         if( SfxItemState::SET == pAttrSet->GetItemState( RES_CHRATR_CASEMAP,
@@ -661,7 +661,7 @@ void SwFont::SetDiffFnt( const SfxItemSet *pAttrSet,
             SetVertical( static_cast<const SvxCharRotateItem*>(pItem)->GetValue() );
         if( SfxItemState::SET == pAttrSet->GetItemState( RES_CHRATR_BACKGROUND,
             true, &pItem ))
-            pBackColor = new Color( static_cast<const SvxBrushItem*>(pItem)->GetColor() );
+            m_pBackColor = new Color( static_cast<const SvxBrushItem*>(pItem)->GetColor() );
         if( SfxItemState::SET == pAttrSet->GetItemState( RES_CHRATR_HIGHLIGHT,
             true, &pItem ))
             SetHighlightColor(static_cast<const SvxBrushItem*>(pItem)->GetColor());
@@ -695,21 +695,21 @@ void SwFont::SetDiffFnt( const SfxItemSet *pAttrSet,
     else
     {
         Invalidate();
-        bNoHyph = false;
-        bBlink = false;
+        m_bNoHyph = false;
+        m_bBlink = false;
     }
-    bPaintBlank = false;
-    bPaintWrong = false;
-    OSL_ENSURE( aSub[SW_LATIN].IsTransparent(), "SwFont: Transparent revolution" );
+    m_bPaintBlank = false;
+    m_bPaintWrong = false;
+    OSL_ENSURE( m_aSub[SW_LATIN].IsTransparent(), "SwFont: Transparent revolution" );
 }
 
 SwFont::SwFont( const SwFont &rFont )
 {
-    aSub[SW_LATIN] = rFont.aSub[SW_LATIN];
-    aSub[SW_CJK] = rFont.aSub[SW_CJK];
-    aSub[SW_CTL] = rFont.aSub[SW_CTL];
-    nActual = rFont.nActual;
-    pBackColor = rFont.pBackColor ? new Color( *rFont.pBackColor ) : NULL;
+    m_aSub[SW_LATIN] = rFont.m_aSub[SW_LATIN];
+    m_aSub[SW_CJK] = rFont.m_aSub[SW_CJK];
+    m_aSub[SW_CTL] = rFont.m_aSub[SW_CTL];
+    m_nActual = rFont.m_nActual;
+    m_pBackColor = rFont.m_pBackColor ? new Color( *rFont.m_pBackColor ) : NULL;
     m_aHighlightColor = rFont.m_aHighlightColor;
     m_aTopBorder = rFont.m_aTopBorder;
     m_aBottomBorder = rFont.m_aBottomBorder;
@@ -722,89 +722,89 @@ SwFont::SwFont( const SwFont &rFont )
     m_aShadowColor = rFont.m_aShadowColor;
     m_nShadowWidth = rFont.m_nShadowWidth;
     m_aShadowLocation = rFont.m_aShadowLocation;
-    aUnderColor = rFont.GetUnderColor();
-    aOverColor  = rFont.GetOverColor();
-    nToxCnt = 0;
-    nRefCnt = 0;
+    m_aUnderColor = rFont.GetUnderColor();
+    m_aOverColor  = rFont.GetOverColor();
+    m_nToxCount = 0;
+    m_nRefCount = 0;
     m_nMetaCount = 0;
     m_nInputFieldCount = 0;
-    bFntChg = rFont.bFntChg;
-    bOrgChg = rFont.bOrgChg;
-    bPaintBlank = rFont.bPaintBlank;
-    bPaintWrong = false;
-    bURL = rFont.bURL;
-    bGreyWave = rFont.bGreyWave;
-    bNoColReplace = rFont.bNoColReplace;
-    bNoHyph = rFont.bNoHyph;
-    bBlink = rFont.bBlink;
+    m_bFontChg = rFont.m_bFontChg;
+    m_bOrgChg = rFont.m_bOrgChg;
+    m_bPaintBlank = rFont.m_bPaintBlank;
+    m_bPaintWrong = false;
+    m_bURL = rFont.m_bURL;
+    m_bGreyWave = rFont.m_bGreyWave;
+    m_bNoColorReplace = rFont.m_bNoColorReplace;
+    m_bNoHyph = rFont.m_bNoHyph;
+    m_bBlink = rFont.m_bBlink;
 }
 
 SwFont::SwFont( const SwAttrSet* pAttrSet,
                 const IDocumentSettingAccess* pIDocumentSettingAccess )
 {
-    nActual = SW_LATIN;
-    nToxCnt = 0;
-    nRefCnt = 0;
+    m_nActual = SW_LATIN;
+    m_nToxCount = 0;
+    m_nRefCount = 0;
     m_nMetaCount = 0;
     m_nInputFieldCount = 0;
-    bPaintBlank = false;
-    bPaintWrong = false;
-    bURL = false;
-    bGreyWave = false;
-    bNoColReplace = false;
-    bNoHyph = pAttrSet->GetNoHyphenHere().GetValue();
-    bBlink = pAttrSet->GetBlink().GetValue();
-    bOrgChg = true;
+    m_bPaintBlank = false;
+    m_bPaintWrong = false;
+    m_bURL = false;
+    m_bGreyWave = false;
+    m_bNoColorReplace = false;
+    m_bNoHyph = pAttrSet->GetNoHyphenHere().GetValue();
+    m_bBlink = pAttrSet->GetBlink().GetValue();
+    m_bOrgChg = true;
     {
         const SvxFontItem& rFont = pAttrSet->GetFont();
-        aSub[SW_LATIN].SetFamily( rFont.GetFamily() );
-        aSub[SW_LATIN].SetName( rFont.GetFamilyName() );
-        aSub[SW_LATIN].SetStyleName( rFont.GetStyleName() );
-        aSub[SW_LATIN].SetPitch( rFont.GetPitch() );
-        aSub[SW_LATIN].SetCharSet( rFont.GetCharSet() );
-        aSub[SW_LATIN].SvxFont::SetPropr( 100 );   // 100% der FontSize
-        Size aTmpSize = aSub[SW_LATIN].aSize;
+        m_aSub[SW_LATIN].SetFamily( rFont.GetFamily() );
+        m_aSub[SW_LATIN].SetName( rFont.GetFamilyName() );
+        m_aSub[SW_LATIN].SetStyleName( rFont.GetStyleName() );
+        m_aSub[SW_LATIN].SetPitch( rFont.GetPitch() );
+        m_aSub[SW_LATIN].SetCharSet( rFont.GetCharSet() );
+        m_aSub[SW_LATIN].SvxFont::SetPropr( 100 );   // 100% der FontSize
+        Size aTmpSize = m_aSub[SW_LATIN].aSize;
         aTmpSize.Height() = pAttrSet->GetSize().GetHeight();
-        aSub[SW_LATIN].SetSize( aTmpSize );
-        aSub[SW_LATIN].SetItalic( pAttrSet->GetPosture().GetPosture() );
-        aSub[SW_LATIN].SetWeight( pAttrSet->GetWeight().GetWeight() );
-        aSub[SW_LATIN].SetLanguage( pAttrSet->GetLanguage().GetLanguage() );
+        m_aSub[SW_LATIN].SetSize( aTmpSize );
+        m_aSub[SW_LATIN].SetItalic( pAttrSet->GetPosture().GetPosture() );
+        m_aSub[SW_LATIN].SetWeight( pAttrSet->GetWeight().GetWeight() );
+        m_aSub[SW_LATIN].SetLanguage( pAttrSet->GetLanguage().GetLanguage() );
     }
 
     {
         const SvxFontItem& rFont = pAttrSet->GetCJKFont();
-        aSub[SW_CJK].SetFamily( rFont.GetFamily() );
-        aSub[SW_CJK].SetName( rFont.GetFamilyName() );
-        aSub[SW_CJK].SetStyleName( rFont.GetStyleName() );
-        aSub[SW_CJK].SetPitch( rFont.GetPitch() );
-        aSub[SW_CJK].SetCharSet( rFont.GetCharSet() );
-        aSub[SW_CJK].SvxFont::SetPropr( 100 );   // 100% der FontSize
-        Size aTmpSize = aSub[SW_CJK].aSize;
+        m_aSub[SW_CJK].SetFamily( rFont.GetFamily() );
+        m_aSub[SW_CJK].SetName( rFont.GetFamilyName() );
+        m_aSub[SW_CJK].SetStyleName( rFont.GetStyleName() );
+        m_aSub[SW_CJK].SetPitch( rFont.GetPitch() );
+        m_aSub[SW_CJK].SetCharSet( rFont.GetCharSet() );
+        m_aSub[SW_CJK].SvxFont::SetPropr( 100 );   // 100% der FontSize
+        Size aTmpSize = m_aSub[SW_CJK].aSize;
         aTmpSize.Height() = pAttrSet->GetCJKSize().GetHeight();
-        aSub[SW_CJK].SetSize( aTmpSize );
-        aSub[SW_CJK].SetItalic( pAttrSet->GetCJKPosture().GetPosture() );
-        aSub[SW_CJK].SetWeight( pAttrSet->GetCJKWeight().GetWeight() );
+        m_aSub[SW_CJK].SetSize( aTmpSize );
+        m_aSub[SW_CJK].SetItalic( pAttrSet->GetCJKPosture().GetPosture() );
+        m_aSub[SW_CJK].SetWeight( pAttrSet->GetCJKWeight().GetWeight() );
         LanguageType eNewLang = pAttrSet->GetCJKLanguage().GetLanguage();
-        aSub[SW_CJK].SetLanguage( eNewLang );
-        aSub[SW_LATIN].SetCJKContextLanguage( eNewLang );
-        aSub[SW_CJK].SetCJKContextLanguage( eNewLang );
-        aSub[SW_CTL].SetCJKContextLanguage( eNewLang );
+        m_aSub[SW_CJK].SetLanguage( eNewLang );
+        m_aSub[SW_LATIN].SetCJKContextLanguage( eNewLang );
+        m_aSub[SW_CJK].SetCJKContextLanguage( eNewLang );
+        m_aSub[SW_CTL].SetCJKContextLanguage( eNewLang );
     }
 
     {
         const SvxFontItem& rFont = pAttrSet->GetCTLFont();
-        aSub[SW_CTL].SetFamily( rFont.GetFamily() );
-        aSub[SW_CTL].SetName( rFont.GetFamilyName() );
-        aSub[SW_CTL].SetStyleName( rFont.GetStyleName() );
-        aSub[SW_CTL].SetPitch( rFont.GetPitch() );
-        aSub[SW_CTL].SetCharSet( rFont.GetCharSet() );
-        aSub[SW_CTL].SvxFont::SetPropr( 100 );   // 100% der FontSize
-        Size aTmpSize = aSub[SW_CTL].aSize;
+        m_aSub[SW_CTL].SetFamily( rFont.GetFamily() );
+        m_aSub[SW_CTL].SetName( rFont.GetFamilyName() );
+        m_aSub[SW_CTL].SetStyleName( rFont.GetStyleName() );
+        m_aSub[SW_CTL].SetPitch( rFont.GetPitch() );
+        m_aSub[SW_CTL].SetCharSet( rFont.GetCharSet() );
+        m_aSub[SW_CTL].SvxFont::SetPropr( 100 );   // 100% der FontSize
+        Size aTmpSize = m_aSub[SW_CTL].aSize;
         aTmpSize.Height() = pAttrSet->GetCTLSize().GetHeight();
-        aSub[SW_CTL].SetSize( aTmpSize );
-        aSub[SW_CTL].SetItalic( pAttrSet->GetCTLPosture().GetPosture() );
-        aSub[SW_CTL].SetWeight( pAttrSet->GetCTLWeight().GetWeight() );
-        aSub[SW_CTL].SetLanguage( pAttrSet->GetCTLLanguage().GetLanguage() );
+        m_aSub[SW_CTL].SetSize( aTmpSize );
+        m_aSub[SW_CTL].SetItalic( pAttrSet->GetCTLPosture().GetPosture() );
+        m_aSub[SW_CTL].SetWeight( pAttrSet->GetCTLWeight().GetWeight() );
+        m_aSub[SW_CTL].SetLanguage( pAttrSet->GetCTLLanguage().GetLanguage() );
     }
     if ( pAttrSet->GetCharHidden().GetValue() )
         SetUnderline( UNDERLINE_DOTTED );
@@ -834,16 +834,16 @@ SwFont::SwFont( const SwAttrSet* pAttrSet,
     SetWordLineMode( pAttrSet->GetWordLineMode().GetValue() );
     const SvxEscapementItem &rEsc = pAttrSet->GetEscapement();
     SetEscapement( rEsc.GetEsc() );
-    if( aSub[SW_LATIN].IsEsc() )
+    if( m_aSub[SW_LATIN].IsEsc() )
         SetProportion( rEsc.GetProp() );
     SetCaseMap( pAttrSet->GetCaseMap().GetCaseMap() );
     SetFixKerning( pAttrSet->GetKerning().GetValue() );
     const SfxPoolItem* pItem;
     if( SfxItemState::SET == pAttrSet->GetItemState( RES_CHRATR_BACKGROUND,
         true, &pItem ))
-        pBackColor = new Color( static_cast<const SvxBrushItem*>(pItem)->GetColor() );
+        m_pBackColor = new Color( static_cast<const SvxBrushItem*>(pItem)->GetColor() );
     else
-        pBackColor = NULL;
+        m_pBackColor = NULL;
     if( SfxItemState::SET == pAttrSet->GetItemState( RES_CHRATR_HIGHLIGHT,
         true, &pItem ))
         SetHighlightColor(static_cast<const SvxBrushItem*>(pItem)->GetColor());
@@ -896,15 +896,15 @@ SwFont::SwFont( const SwAttrSet* pAttrSet,
         SetVertical( 0 );
     if( pIDocumentSettingAccess && pIDocumentSettingAccess->get( DocumentSettingId::SMALL_CAPS_PERCENTAGE_66 ))
     {
-        aSub[ SW_LATIN ].smallCapsPercentage66 = true;
-        aSub[ SW_CJK ].smallCapsPercentage66 = true;
-        aSub[ SW_CTL ].smallCapsPercentage66 = true;
+        m_aSub[ SW_LATIN ].smallCapsPercentage66 = true;
+        m_aSub[ SW_CJK ].smallCapsPercentage66 = true;
+        m_aSub[ SW_CTL ].smallCapsPercentage66 = true;
     }
 }
 
 SwFont::~SwFont()
 {
-    delete pBackColor;
+    delete m_pBackColor;
 }
 
 SwSubFont& SwSubFont::operator=( const SwSubFont &rFont )
@@ -922,12 +922,12 @@ SwSubFont& SwSubFont::operator=( const SwSubFont &rFont )
 
 SwFont& SwFont::operator=( const SwFont &rFont )
 {
-    aSub[SW_LATIN] = rFont.aSub[SW_LATIN];
-    aSub[SW_CJK] = rFont.aSub[SW_CJK];
-    aSub[SW_CTL] = rFont.aSub[SW_CTL];
-    nActual = rFont.nActual;
-    delete pBackColor;
-    pBackColor = rFont.pBackColor ? new Color( *rFont.pBackColor ) : NULL;
+    m_aSub[SW_LATIN] = rFont.m_aSub[SW_LATIN];
+    m_aSub[SW_CJK] = rFont.m_aSub[SW_CJK];
+    m_aSub[SW_CTL] = rFont.m_aSub[SW_CTL];
+    m_nActual = rFont.m_nActual;
+    delete m_pBackColor;
+    m_pBackColor = rFont.m_pBackColor ? new Color( *rFont.m_pBackColor ) : NULL;
     m_aHighlightColor = rFont.m_aHighlightColor;
     m_aTopBorder = rFont.m_aTopBorder;
     m_aBottomBorder = rFont.m_aBottomBorder;
@@ -940,28 +940,28 @@ SwFont& SwFont::operator=( const SwFont &rFont )
     m_aShadowColor = rFont.m_aShadowColor;
     m_nShadowWidth = rFont.m_nShadowWidth;
     m_aShadowLocation = rFont.m_aShadowLocation;
-    aUnderColor = rFont.GetUnderColor();
-    aOverColor  = rFont.GetOverColor();
-    nToxCnt = 0;
-    nRefCnt = 0;
+    m_aUnderColor = rFont.GetUnderColor();
+    m_aOverColor  = rFont.GetOverColor();
+    m_nToxCount = 0;
+    m_nRefCount = 0;
     m_nMetaCount = 0;
     m_nInputFieldCount = 0;
-    bFntChg = rFont.bFntChg;
-    bOrgChg = rFont.bOrgChg;
-    bPaintBlank = rFont.bPaintBlank;
-    bPaintWrong = false;
-    bURL = rFont.bURL;
-    bGreyWave = rFont.bGreyWave;
-    bNoColReplace = rFont.bNoColReplace;
-    bNoHyph = rFont.bNoHyph;
-    bBlink = rFont.bBlink;
+    m_bFontChg = rFont.m_bFontChg;
+    m_bOrgChg = rFont.m_bOrgChg;
+    m_bPaintBlank = rFont.m_bPaintBlank;
+    m_bPaintWrong = false;
+    m_bURL = rFont.m_bURL;
+    m_bGreyWave = rFont.m_bGreyWave;
+    m_bNoColorReplace = rFont.m_bNoColorReplace;
+    m_bNoHyph = rFont.m_bNoHyph;
+    m_bBlink = rFont.m_bBlink;
     return *this;
 }
 
 void SwFont::GoMagic( SwViewShell *pSh, sal_uInt8 nWhich )
 {
-    SwFntAccess aFntAccess( aSub[nWhich].pMagic, aSub[nWhich].nFntIndex,
-                            &aSub[nWhich], pSh, true );
+    SwFntAccess aFntAccess( m_aSub[nWhich].pMagic, m_aSub[nWhich].nFntIndex,
+                            &m_aSub[nWhich], pSh, true );
 }
 
 bool SwSubFont::IsSymbol( SwViewShell *pSh )
@@ -989,28 +989,28 @@ bool SwSubFont::ChgFnt( SwViewShell const *pSh, OutputDevice& rOut )
 
 void SwFont::ChgPhysFnt( SwViewShell *pSh, OutputDevice& rOut )
 {
-    if( bOrgChg && aSub[nActual].IsEsc() )
+    if( m_bOrgChg && m_aSub[m_nActual].IsEsc() )
     {
-        const sal_uInt8 nOldProp = aSub[nActual].GetPropr();
+        const sal_uInt8 nOldProp = m_aSub[m_nActual].GetPropr();
         SetProportion( 100 );
         ChgFnt( pSh, rOut );
-        SwFntAccess aFntAccess( aSub[nActual].pMagic, aSub[nActual].nFntIndex,
-                                &aSub[nActual], pSh );
-        aSub[nActual].nOrgHeight = aFntAccess.Get()->GetFontHeight( pSh, rOut );
-        aSub[nActual].nOrgAscent = aFntAccess.Get()->GetFontAscent( pSh, rOut );
+        SwFntAccess aFntAccess( m_aSub[m_nActual].pMagic, m_aSub[m_nActual].nFntIndex,
+                                &m_aSub[m_nActual], pSh );
+        m_aSub[m_nActual].nOrgHeight = aFntAccess.Get()->GetFontHeight( pSh, rOut );
+        m_aSub[m_nActual].nOrgAscent = aFntAccess.Get()->GetFontAscent( pSh, rOut );
         SetProportion( nOldProp );
-        bOrgChg = false;
+        m_bOrgChg = false;
     }
 
-    if( bFntChg )
+    if( m_bFontChg )
     {
         ChgFnt( pSh, rOut );
-        bFntChg = bOrgChg;
+        m_bFontChg = m_bOrgChg;
     }
-    if( rOut.GetTextLineColor() != aUnderColor )
-        rOut.SetTextLineColor( aUnderColor );
-    if( rOut.GetOverlineColor() != aOverColor )
-        rOut.SetOverlineColor( aOverColor );
+    if( rOut.GetTextLineColor() != m_aUnderColor )
+        rOut.SetTextLineColor( m_aUnderColor );
+    if( rOut.GetOverlineColor() != m_aOverColor )
+        rOut.SetOverlineColor( m_aOverColor );
 }
 
 //         Height = MaxAscent + MaxDescent