Cleanup FontCharMapPtr variable prefixes

Change-Id: Ib106b91ab71ee45d5ad469d0beaf4ebaef8b57e1
Reviewed-on: https://gerrit.libreoffice.org/21306
Tested-by: Jenkins <ci@libreoffice.org>
Reviewed-by: Chris Sherlock <chris.sherlock79@gmail.com>

19 files changed, 163 insertions, 163 deletions

diff --git a/cui/source/dialogs/cuicharmap.cxx b/cui/source/dialogs/cuicharmap.cxx
index ee26bca6d980..b17931ca3df5 100644
--- a/cui/source/dialogs/cuicharmap.cxx
+++ b/cui/source/dialogs/cuicharmap.cxx
@@ -455,9 +455,9 @@ IMPL_LINK_NOARG_TYPED(SvxCharacterMap, FontSelectHdl, ListBox&, void)
     bool bNeedSubset = (aFont.GetCharSet() != RTL_TEXTENCODING_SYMBOL);
     if( bNeedSubset )
     {
-        FontCharMapPtr pFontCharMap( new FontCharMap() );
-        m_pShowSet->GetFontCharMap( pFontCharMap );
-        pSubsetMap = new SubsetMap( pFontCharMap );
+        FontCharMapPtr xFontCharMap( new FontCharMap() );
+        m_pShowSet->GetFontCharMap( xFontCharMap );
+        pSubsetMap = new SubsetMap( xFontCharMap );
 
         // update subset listbox for new font's unicode subsets
         // TODO: is it worth to improve the stupid linear search?
@@ -600,9 +600,9 @@ void SvxCharacterMap::selectCharByCode(Radix radix)
     // Convert the code back to a character using the appropriate radix
     sal_UCS4 cChar = aCodeString.toUInt32(static_cast<sal_Int16> (radix));
     // Use FontCharMap::HasChar(sal_UCS4 cChar) to see if the desired character is in the font
-    FontCharMapPtr pFontCharMap(new FontCharMap());
-    m_pShowSet->GetFontCharMap(pFontCharMap);
-    if (pFontCharMap->HasChar(cChar))
+    FontCharMapPtr xFontCharMap(new FontCharMap());
+    m_pShowSet->GetFontCharMap(xFontCharMap);
+    if (xFontCharMap->HasChar(cChar))
         // Select the corresponding character
         SetChar(cChar);
 }
diff --git a/include/svx/charmap.hxx b/include/svx/charmap.hxx
index 963e96276852..1574d1856783 100644
--- a/include/svx/charmap.hxx
+++ b/include/svx/charmap.hxx
@@ -105,7 +105,7 @@ private:
 
     sal_Int32       nSelectedIndex;
 
-    FontCharMapPtr  mpFontCharMap;
+    FontCharMapPtr  mxFontCharMap;
     Size            maFontSize;
     VclPtr<ScrollBar>  aVscrollSB;
 
diff --git a/include/vcl/outdev.hxx b/include/vcl/outdev.hxx
index c8e397b0997a..ea706eb6beb1 100644
--- a/include/vcl/outdev.hxx
+++ b/include/vcl/outdev.hxx
@@ -1260,7 +1260,7 @@ public:
     FontMetric                  GetFontMetric() const;
     FontMetric                  GetFontMetric( const vcl::Font& rFont ) const;
 
-    bool                        GetFontCharMap( FontCharMapPtr& rFontCharMap ) const;
+    bool                        GetFontCharMap( FontCharMapPtr& rxFontCharMap ) const;
     bool                        GetFontCapabilities( vcl::FontCapabilities& rFontCapabilities ) const;
 
     /** Retrieve detailed font information in platform independent structure
diff --git a/sc/source/filter/excel/xistyle.cxx b/sc/source/filter/excel/xistyle.cxx
index 05c1516ddc93..b663c78a4493 100644
--- a/sc/source/filter/excel/xistyle.cxx
+++ b/sc/source/filter/excel/xistyle.cxx
@@ -462,41 +462,41 @@ void XclImpFont::GuessScriptType()
     if( OutputDevice* pPrinter = GetPrinter() )
     {
         vcl::Font aFont( maData.maName, Size( 0, 10 ) );
-        FontCharMapPtr pCharMap;
+        FontCharMapPtr xFontCharMap;
 
         pPrinter->SetFont( aFont );
-        if( pPrinter->GetFontCharMap( pCharMap ) )
+        if( pPrinter->GetFontCharMap( xFontCharMap ) )
         {
             // CJK fonts
             mbHasAsian =
-                pCharMap->HasChar( 0x3041 ) ||   // 3040-309F: Hiragana
-                pCharMap->HasChar( 0x30A1 ) ||   // 30A0-30FF: Katakana
-                pCharMap->HasChar( 0x3111 ) ||   // 3100-312F: Bopomofo
-                pCharMap->HasChar( 0x3131 ) ||   // 3130-318F: Hangul Compatibility Jamo
-                pCharMap->HasChar( 0x3301 ) ||   // 3300-33FF: CJK Compatibility
-                pCharMap->HasChar( 0x3401 ) ||   // 3400-4DBF: CJK Unified Ideographs Extension A
-                pCharMap->HasChar( 0x4E01 ) ||   // 4E00-9FAF: CJK Unified Ideographs
-                pCharMap->HasChar( 0x7E01 ) ||   // 4E00-9FAF: CJK unified ideographs
-                pCharMap->HasChar( 0xA001 ) ||   // A001-A48F: Yi Syllables
-                pCharMap->HasChar( 0xAC01 ) ||   // AC00-D7AF: Hangul Syllables
-                pCharMap->HasChar( 0xCC01 ) ||   // AC00-D7AF: Hangul Syllables
-                pCharMap->HasChar( 0xF901 ) ||   // F900-FAFF: CJK Compatibility Ideographs
-                pCharMap->HasChar( 0xFF71 );     // FF00-FFEF: Halfwidth/Fullwidth Forms
+                xFontCharMap->HasChar( 0x3041 ) ||   // 3040-309F: Hiragana
+                xFontCharMap->HasChar( 0x30A1 ) ||   // 30A0-30FF: Katakana
+                xFontCharMap->HasChar( 0x3111 ) ||   // 3100-312F: Bopomofo
+                xFontCharMap->HasChar( 0x3131 ) ||   // 3130-318F: Hangul Compatibility Jamo
+                xFontCharMap->HasChar( 0x3301 ) ||   // 3300-33FF: CJK Compatibility
+                xFontCharMap->HasChar( 0x3401 ) ||   // 3400-4DBF: CJK Unified Ideographs Extension A
+                xFontCharMap->HasChar( 0x4E01 ) ||   // 4E00-9FAF: CJK Unified Ideographs
+                xFontCharMap->HasChar( 0x7E01 ) ||   // 4E00-9FAF: CJK unified ideographs
+                xFontCharMap->HasChar( 0xA001 ) ||   // A001-A48F: Yi Syllables
+                xFontCharMap->HasChar( 0xAC01 ) ||   // AC00-D7AF: Hangul Syllables
+                xFontCharMap->HasChar( 0xCC01 ) ||   // AC00-D7AF: Hangul Syllables
+                xFontCharMap->HasChar( 0xF901 ) ||   // F900-FAFF: CJK Compatibility Ideographs
+                xFontCharMap->HasChar( 0xFF71 );     // FF00-FFEF: Halfwidth/Fullwidth Forms
             // CTL fonts
             mbHasCmplx =
-                pCharMap->HasChar( 0x05D1 ) ||   // 0590-05FF: Hebrew
-                pCharMap->HasChar( 0x0631 ) ||   // 0600-06FF: Arabic
-                pCharMap->HasChar( 0x0721 ) ||   // 0700-074F: Syriac
-                pCharMap->HasChar( 0x0911 ) ||   // 0900-0DFF: Indic scripts
-                pCharMap->HasChar( 0x0E01 ) ||   // 0E00-0E7F: Thai
-                pCharMap->HasChar( 0xFB21 ) ||   // FB1D-FB4F: Hebrew Presentation Forms
-                pCharMap->HasChar( 0xFB51 ) ||   // FB50-FDFF: Arabic Presentation Forms-A
-                pCharMap->HasChar( 0xFE71 );     // FE70-FEFF: Arabic Presentation Forms-B
+                xFontCharMap->HasChar( 0x05D1 ) ||   // 0590-05FF: Hebrew
+                xFontCharMap->HasChar( 0x0631 ) ||   // 0600-06FF: Arabic
+                xFontCharMap->HasChar( 0x0721 ) ||   // 0700-074F: Syriac
+                xFontCharMap->HasChar( 0x0911 ) ||   // 0900-0DFF: Indic scripts
+                xFontCharMap->HasChar( 0x0E01 ) ||   // 0E00-0E7F: Thai
+                xFontCharMap->HasChar( 0xFB21 ) ||   // FB1D-FB4F: Hebrew Presentation Forms
+                xFontCharMap->HasChar( 0xFB51 ) ||   // FB50-FDFF: Arabic Presentation Forms-A
+                xFontCharMap->HasChar( 0xFE71 );     // FE70-FEFF: Arabic Presentation Forms-B
             // Western fonts
-            mbHasWstrn = (!mbHasAsian && !mbHasCmplx) || pCharMap->HasChar( 'A' );
+            mbHasWstrn = (!mbHasAsian && !mbHasCmplx) || xFontCharMap->HasChar( 'A' );
         }
 
-        pCharMap = nullptr;
+        xFontCharMap = nullptr;
     }
 }
 
diff --git a/starmath/source/dialog.cxx b/starmath/source/dialog.cxx
index 1b6b34929303..852bc1b564ef 100644
--- a/starmath/source/dialog.cxx
+++ b/starmath/source/dialog.cxx
@@ -2337,9 +2337,9 @@ void SmSymDefineDialog::SetFont(const OUString &rFontName, const OUString &rStyl
     pSymbolDisplay->SetFont(aFontMetric);
 
     // update subset listbox for new font's unicode subsets
-    FontCharMapPtr pFontCharMap;
-    pCharsetDisplay->GetFontCharMap( pFontCharMap );
-    pSubsetMap.reset(new SubsetMap( pFontCharMap ));
+    FontCharMapPtr xFontCharMap;
+    pCharsetDisplay->GetFontCharMap( xFontCharMap );
+    pSubsetMap.reset(new SubsetMap( xFontCharMap ));
 
     pFontsSubsetLB->Clear();
     bool bFirst = true;
@@ -2357,7 +2357,7 @@ void SmSymDefineDialog::SetFont(const OUString &rFontName, const OUString &rStyl
         pFontsSubsetLB->SetNoSelection();
     pFontsSubsetLB->Enable( !bFirst );
 
-    pFontCharMap = nullptr;
+    xFontCharMap = nullptr;
 }
 
 
diff --git a/svtools/source/misc/sampletext.cxx b/svtools/source/misc/sampletext.cxx
index 031536162e9d..4ba252b5702c 100644
--- a/svtools/source/misc/sampletext.cxx
+++ b/svtools/source/misc/sampletext.cxx
@@ -165,8 +165,8 @@ OUString makeShortRepresentativeSymbolTextForSelectedFont(OutputDevice &rDevice)
 
     if (!bOpenSymbol)
     {
-        FontCharMapPtr pFontCharMap;
-        bool bHasCharMap = rDevice.GetFontCharMap(pFontCharMap);
+        FontCharMapPtr xFontCharMap;
+        bool bHasCharMap = rDevice.GetFontCharMap(xFontCharMap);
         if( bHasCharMap )
         {
             // use some sample characters available in the font
@@ -176,7 +176,7 @@ OUString makeShortRepresentativeSymbolTextForSelectedFont(OutputDevice &rDevice)
             sal_uInt32 cNewChar = 0xFF00;
 
             const int nMaxCount = sizeof(aText)/sizeof(*aText) - 1;
-            int nSkip = pFontCharMap->GetCharCount() / nMaxCount;
+            int nSkip = xFontCharMap->GetCharCount() / nMaxCount;
             if( nSkip > 10 )
                 nSkip = 10;
             else if( nSkip <= 0 )
@@ -185,7 +185,7 @@ OUString makeShortRepresentativeSymbolTextForSelectedFont(OutputDevice &rDevice)
             {
                 sal_uInt32 cOldChar = cNewChar;
                 for( int j = nSkip; --j >= 0; )
-                    cNewChar = pFontCharMap->GetPrevChar( cNewChar );
+                    cNewChar = xFontCharMap->GetPrevChar( cNewChar );
                 if( cOldChar == cNewChar )
                     break;
                 aText[ i ] = static_cast<sal_Unicode>(cNewChar); // TODO: support UCS4 samples
@@ -195,7 +195,7 @@ OUString makeShortRepresentativeSymbolTextForSelectedFont(OutputDevice &rDevice)
             return OUString(aText);
         }
 
-        pFontCharMap = nullptr;
+        xFontCharMap = nullptr;
     }
 
     static const sal_Unicode aImplSymbolFontText[] = {
diff --git a/svx/source/dialog/charmap.cxx b/svx/source/dialog/charmap.cxx
index d4fb271653d8..1c6f0bb93c33 100644
--- a/svx/source/dialog/charmap.cxx
+++ b/svx/source/dialog/charmap.cxx
@@ -237,7 +237,7 @@ int SvxShowCharSet::LastInView() const
 {
     sal_uIntPtr nIndex = FirstInView();
     nIndex += ROW_COUNT * COLUMN_COUNT - 1;
-    sal_uIntPtr nCompare = sal::static_int_cast<sal_uIntPtr>(mpFontCharMap->GetCharCount() - 1);
+    sal_uIntPtr nCompare = sal::static_int_cast<sal_uIntPtr>(mxFontCharMap->GetCharCount() - 1);
     if (nIndex > nCompare)
         nIndex = nCompare;
     return nIndex;
@@ -301,7 +301,7 @@ void SvxShowCharSet::KeyInput(const KeyEvent& rKEvt)
             tmpSelected = 0;
             break;
         case KEY_END:
-            tmpSelected = mpFontCharMap->GetCharCount() - 1;
+            tmpSelected = mxFontCharMap->GetCharCount() - 1;
             break;
         case KEY_TAB:   // some fonts have a character at these unicode control codes
         case KEY_ESCAPE:
@@ -312,8 +312,8 @@ void SvxShowCharSet::KeyInput(const KeyEvent& rKEvt)
         default:
             {
                 sal_UCS4 cChar = rKEvt.GetCharCode();
-                sal_UCS4 cNext = mpFontCharMap->GetNextChar(cChar - 1);
-                tmpSelected = mpFontCharMap->GetIndexFromChar(cNext);
+                sal_UCS4 cNext = mxFontCharMap->GetNextChar(cChar - 1);
+                tmpSelected = mxFontCharMap->GetIndexFromChar(cNext);
                 if (tmpSelected < 0 || (cChar != cNext))
                 {
                     Control::KeyInput(rKEvt);
@@ -418,7 +418,7 @@ void SvxShowCharSet::DrawChars_Impl(vcl::RenderContext& rRenderContext, int n1,
         int y = pix.Y();
 
         OUStringBuffer buf;
-        buf.appendUtf32(mpFontCharMap->GetCharFromIndex(i));
+        buf.appendUtf32(mxFontCharMap->GetCharFromIndex(i));
         OUString aCharStr(buf.makeStringAndClear());
         int nTextWidth = rRenderContext.GetTextWidth(aCharStr);
         int tx = x + (nX - nTextWidth + 1) / 2;
@@ -535,7 +535,7 @@ void SvxShowCharSet::InitSettings(vcl::RenderContext& rRenderContext)
 sal_UCS4 SvxShowCharSet::GetSelectCharacter() const
 {
     if( nSelectedIndex >= 0 )
-        getSelectedChar() = mpFontCharMap->GetCharFromIndex( nSelectedIndex );
+        getSelectedChar() = mxFontCharMap->GetCharFromIndex( nSelectedIndex );
     return getSelectedChar();
 }
 
@@ -548,7 +548,7 @@ void SvxShowCharSet::RecalculateFont(vcl::RenderContext& rRenderContext)
 
     // save last selected unicode
     if (nSelectedIndex >= 0)
-        getSelectedChar() = mpFontCharMap->GetCharFromIndex(nSelectedIndex);
+        getSelectedChar() = mxFontCharMap->GetCharFromIndex(nSelectedIndex);
 
     Size aSize(GetOutputSizePixel());
     long nSBWidth = aVscrollSB->GetOptimalSize().Width();
@@ -562,20 +562,20 @@ void SvxShowCharSet::RecalculateFont(vcl::RenderContext& rRenderContext)
     aFont.SetSize(maFontSize);
     aFont.SetTransparent(true);
     rRenderContext.SetFont(aFont);
-    rRenderContext.GetFontCharMap(mpFontCharMap);
+    rRenderContext.GetFontCharMap(mxFontCharMap);
 
     nX = aSize.Width() / COLUMN_COUNT;
     nY = aSize.Height() / ROW_COUNT;
 
     aVscrollSB->setPosSizePixel(aSize.Width(), 0, nSBWidth, aSize.Height());
     aVscrollSB->SetRangeMin(0);
-    int nLastRow = (mpFontCharMap->GetCharCount() - 1 + COLUMN_COUNT) / COLUMN_COUNT;
+    int nLastRow = (mxFontCharMap->GetCharCount() - 1 + COLUMN_COUNT) / COLUMN_COUNT;
     aVscrollSB->SetRangeMax(nLastRow);
     aVscrollSB->SetPageSize(ROW_COUNT - 1);
     aVscrollSB->SetVisibleSize(ROW_COUNT);
 
     // restore last selected unicode
-    int nMapIndex = mpFontCharMap->GetIndexFromChar(getSelectedChar());
+    int nMapIndex = mxFontCharMap->GetIndexFromChar(getSelectedChar());
     SelectIndex(nMapIndex);
 
     aVscrollSB->Show();
@@ -598,8 +598,8 @@ void SvxShowCharSet::SelectIndex( int nNewIndex, bool bFocus )
     if( nNewIndex < 0 )
     {
         // need to scroll see closest unicode
-        sal_uInt32 cPrev = mpFontCharMap->GetPrevChar( getSelectedChar() );
-        int nMapIndex = mpFontCharMap->GetIndexFromChar( cPrev );
+        sal_uInt32 cPrev = mxFontCharMap->GetPrevChar( getSelectedChar() );
+        int nMapIndex = mxFontCharMap->GetIndexFromChar( cPrev );
         int nNewPos = nMapIndex / COLUMN_COUNT;
         aVscrollSB->SetThumbPos( nNewPos );
         nSelectedIndex = bFocus ? nMapIndex+1 : -1;
@@ -620,7 +620,7 @@ void SvxShowCharSet::SelectIndex( int nNewIndex, bool bFocus )
         int nOldPos = aVscrollSB->GetThumbPos();
         int nDelta = (nNewIndex - LastInView() + COLUMN_COUNT) / COLUMN_COUNT;
         aVscrollSB->SetThumbPos( nOldPos + nDelta );
-        if( nNewIndex < mpFontCharMap->GetCharCount() )
+        if( nNewIndex < mxFontCharMap->GetCharCount() )
         {
             nSelectedIndex = nNewIndex;
             Invalidate();
@@ -638,7 +638,7 @@ void SvxShowCharSet::SelectIndex( int nNewIndex, bool bFocus )
 
     if( nSelectedIndex >= 0 )
     {
-        getSelectedChar() = mpFontCharMap->GetCharFromIndex( nSelectedIndex );
+        getSelectedChar() = mxFontCharMap->GetCharFromIndex( nSelectedIndex );
         if( m_pAccessible )
         {
             svx::SvxShowCharSetItem* pItem = ImplGetItem(nSelectedIndex);
@@ -675,13 +675,13 @@ void SvxShowCharSet::OutputIndex( int nNewIndex )
 
 void SvxShowCharSet::SelectCharacter( sal_UCS4 cNew, bool bFocus )
 {
-    if (mpFontCharMap == nullptr)
+    if (mxFontCharMap == nullptr)
         RecalculateFont(*this);
 
     // get next available char of current font
-    sal_UCS4 cNext = mpFontCharMap->GetNextChar( (cNew > 0) ? cNew - 1 : cNew );
+    sal_UCS4 cNext = mxFontCharMap->GetNextChar( (cNew > 0) ? cNew - 1 : cNew );
 
-    int nMapIndex = mpFontCharMap->GetIndexFromChar( cNext );
+    int nMapIndex = mxFontCharMap->GetIndexFromChar( cNext );
     SelectIndex( nMapIndex, bFocus );
     if( !bFocus )
     {
@@ -757,7 +757,7 @@ svx::SvxShowCharSetItem* SvxShowCharSet::ImplGetItem( int _nPos )
             m_pAccessible->getTable(), sal::static_int_cast< sal_uInt16 >(_nPos)));
         aFind = m_aItems.insert(ItemsMap::value_type(_nPos, xItem)).first;
         OUStringBuffer buf;
-        buf.appendUtf32( mpFontCharMap->GetCharFromIndex( _nPos ) );
+        buf.appendUtf32( mxFontCharMap->GetCharFromIndex( _nPos ) );
         aFind->second->maText = buf.makeStringAndClear();
         Point pix = MapIndexToPixel( _nPos );
         aFind->second->maRect = Rectangle( Point( pix.X() + 1, pix.Y() + 1 ), Size(nX-1,nY-1) );
@@ -770,17 +770,17 @@ svx::SvxShowCharSetItem* SvxShowCharSet::ImplGetItem( int _nPos )
 
 sal_Int32 SvxShowCharSet::getMaxCharCount() const
 {
-    return mpFontCharMap->GetCharCount();
+    return mxFontCharMap->GetCharCount();
 }
 
 // TODO: should be moved into Font Attributes stuff
 // we let it mature here though because it is currently the only use
 
-SubsetMap::SubsetMap( const FontCharMapPtr& rFontCharMap )
+SubsetMap::SubsetMap( const FontCharMapPtr& rxFontCharMap )
 :   Resource( SVX_RES(RID_SUBSETMAP) )
 {
     InitList();
-    ApplyCharMap(rFontCharMap);
+    ApplyCharMap(rxFontCharMap);
     FreeResource();
 }
 
@@ -1640,9 +1640,9 @@ void SubsetMap::InitList()
     maSubsets = aAllSubsets;
 }
 
-void SubsetMap::ApplyCharMap( const FontCharMapPtr& rFontCharMap )
+void SubsetMap::ApplyCharMap( const FontCharMapPtr& rxFontCharMap )
 {
-    if( !rFontCharMap )
+    if( !rxFontCharMap )
         return;
 
     // remove subsets that are not matched in any range
@@ -1653,7 +1653,7 @@ void SubsetMap::ApplyCharMap( const FontCharMapPtr& rFontCharMap )
         sal_uInt32 cMin = rSubset.GetRangeMin();
         sal_uInt32 cMax = rSubset.GetRangeMax();
 
-        int nCount =  rFontCharMap->CountCharsInRange( cMin, cMax );
+        int nCount =  rxFontCharMap->CountCharsInRange( cMin, cMax );
         if( nCount <= 0 )
             it = maSubsets.erase(it);
         else
diff --git a/vcl/generic/fontmanager/fontmanager.cxx b/vcl/generic/fontmanager/fontmanager.cxx
index 86dfab3b0a9d..4fe08f13ed46 100644
--- a/vcl/generic/fontmanager/fontmanager.cxx
+++ b/vcl/generic/fontmanager/fontmanager.cxx
@@ -2109,11 +2109,11 @@ void PrintFontManager::getGlyphWidths( fontID nFont,
                 CmapResult aCmapResult;
                 if( ParseCMAP( pCmapData, nCmapSize, aCmapResult ) )
                 {
-                    FontCharMapPtr pCharMap( new FontCharMap(aCmapResult) );
+                    FontCharMapPtr xFontCharMap( new FontCharMap(aCmapResult) );
                     for( sal_uInt32 cOld = 0;;)
                     {
                         // get next unicode covered by font
-                        const sal_uInt32 c = pCharMap->GetNextChar( cOld );
+                        const sal_uInt32 c = xFontCharMap->GetNextChar( cOld );
                         if( c == cOld )
                             break;
                         cOld = c;
@@ -2122,12 +2122,12 @@ void PrintFontManager::getGlyphWidths( fontID nFont,
                             break;
 #endif
                         // get the matching glyph index
-                        const sal_GlyphId aGlyphId = pCharMap->GetGlyphIndex( c );
+                        const sal_GlyphId aGlyphId = xFontCharMap->GetGlyphIndex( c );
                         // update the requested map
                         rUnicodeEnc[ (sal_Unicode)c ] = aGlyphId;
                     }
 
-                    pCharMap = nullptr;
+                    xFontCharMap = nullptr;
                 }
             }
         }
diff --git a/vcl/generic/print/genpspgraphics.cxx b/vcl/generic/print/genpspgraphics.cxx
index 6ce0811ca28f..145bf7dc18e6 100644
--- a/vcl/generic/print/genpspgraphics.cxx
+++ b/vcl/generic/print/genpspgraphics.cxx
@@ -770,8 +770,8 @@ const FontCharMapPtr GenPspGraphics::GetFontCharMap() const
     if( !m_pServerFont[0] )
         return nullptr;
 
-    const FontCharMapPtr pFCMap = m_pServerFont[0]->GetFontCharMap();
-    return pFCMap;
+    const FontCharMapPtr xFCMap = m_pServerFont[0]->GetFontCharMap();
+    return xFCMap;
 }
 
 bool GenPspGraphics::GetFontCapabilities(vcl::FontCapabilities &rFontCapabilities) const
diff --git a/vcl/inc/quartz/salgdi.h b/vcl/inc/quartz/salgdi.h
index 5d007c744c3d..03ef055d1feb 100644
--- a/vcl/inc/quartz/salgdi.h
+++ b/vcl/inc/quartz/salgdi.h
@@ -78,7 +78,7 @@ protected:
 
 private:
     const sal_IntPtr                mnFontId;
-    mutable FontCharMapPtr          mpCharMap;
+    mutable FontCharMapPtr          mxCharMap;
     mutable vcl::FontCapabilities   maFontCapabilities;
     mutable bool                    mbOs2Read;       // true if OS2-table related info is valid
     mutable bool                    mbHasOs2Table;
diff --git a/vcl/inc/unx/gcach_ftyp.hxx b/vcl/inc/unx/gcach_ftyp.hxx
index dae148dc339e..cf3c66b5aa10 100644
--- a/vcl/inc/unx/gcach_ftyp.hxx
+++ b/vcl/inc/unx/gcach_ftyp.hxx
@@ -94,9 +94,9 @@ private:
     GraphiteFaceWrapper * mpGraphiteFace;
 #endif
     sal_IntPtr      mnFontId;
-    FontAttributes maDevFontAttributes;
+    FontAttributes  maDevFontAttributes;
 
-    FontCharMapPtr  mpFontCharMap;
+    FontCharMapPtr  mxFontCharMap;
 
     // cache unicode->glyphid mapping because looking it up is expensive
     // TODO: change to std::unordered_multimap when a use case requires a m:n mapping
diff --git a/vcl/inc/win/salgdi.h b/vcl/inc/win/salgdi.h
index e35b71df3de3..83b5f39fb7a4 100644
--- a/vcl/inc/win/salgdi.h
+++ b/vcl/inc/win/salgdi.h
@@ -116,7 +116,7 @@ private:
 #endif
     mutable bool                    mbHasArabicSupport;
     mutable bool                    mbFontCapabilitiesRead;
-    mutable FontCharMapPtr          mpUnicodeMap;
+    mutable FontCharMapPtr          mxUnicodeMap;
     mutable const Ucs2SIntMap*      mpEncodingVector;
     mutable vcl::FontCapabilities   maFontCapabilities;
 
@@ -460,7 +460,7 @@ inline bool ImplCmpKernData( const KERNINGPAIR& a, const KERNINGPAIR& b )
 // called extremely often from just one spot => inline
 inline bool WinFontFace::HasChar( sal_uInt32 cChar ) const
 {
-    if( mpUnicodeMap->HasChar( cChar ) )
+    if( mxUnicodeMap->HasChar( cChar ) )
         return true;
     // second chance to allow symbol aliasing
     if( mbAliasSymbolsLow && ((cChar-0xF000) <= 0xFF) )
@@ -469,7 +469,7 @@ inline bool WinFontFace::HasChar( sal_uInt32 cChar ) const
         cChar += 0xF000;
     else
         return false;
-    return mpUnicodeMap->HasChar( cChar );
+    return mxUnicodeMap->HasChar( cChar );
 }
 
 #endif // INCLUDED_VCL_INC_WIN_SALGDI_H
diff --git a/vcl/qa/cppunit/fontcharmap.cxx b/vcl/qa/cppunit/fontcharmap.cxx
index 4453ffa4cb95..8b8f2e7a056e 100644
--- a/vcl/qa/cppunit/fontcharmap.cxx
+++ b/vcl/qa/cppunit/fontcharmap.cxx
@@ -28,19 +28,19 @@ public:
 
 void VclFontCharMapTest::testDefaultFontCharMap()
 {
-    FontCharMapPtr pfcmap( new FontCharMap() ); // gets default map
+    FontCharMapPtr xfcmap( new FontCharMap() ); // gets default map
 
-    CPPUNIT_ASSERT( pfcmap->IsDefaultMap() );
+    CPPUNIT_ASSERT( xfcmap->IsDefaultMap() );
 
-    sal_uInt32 nStartBMPPlane = pfcmap->GetFirstChar();
-    sal_uInt32 nStartSupBMPPlane = pfcmap->GetNextChar(0xD800);
-    sal_uInt32 nEndBMPPlane = pfcmap->GetLastChar();
+    sal_uInt32 nStartBMPPlane = xfcmap->GetFirstChar();
+    sal_uInt32 nStartSupBMPPlane = xfcmap->GetNextChar(0xD800);
+    sal_uInt32 nEndBMPPlane = xfcmap->GetLastChar();
 
     CPPUNIT_ASSERT( nStartBMPPlane == 0x0020 );
     CPPUNIT_ASSERT( nStartSupBMPPlane == 0xE000 );
     CPPUNIT_ASSERT( nEndBMPPlane == 0xFFF0-1 );
 
-    pfcmap = nullptr;
+    xfcmap = nullptr;
 }
 
 CPPUNIT_TEST_SUITE_REGISTRATION(VclFontCharMapTest);
diff --git a/vcl/quartz/salgdi.cxx b/vcl/quartz/salgdi.cxx
index 334eea1a3509..2403e9b8b520 100644
--- a/vcl/quartz/salgdi.cxx
+++ b/vcl/quartz/salgdi.cxx
@@ -60,8 +60,8 @@ CoreTextFontFace::CoreTextFontFace( const CoreTextFontFace& rSrc )
   , mbHasOs2Table( rSrc.mbHasOs2Table )
   , mbCmapEncodingRead( rSrc.mbCmapEncodingRead )
 {
-    if( rSrc.mpCharMap )
-        mpCharMap = rSrc.mpCharMap;
+    if( rSrc.mxCharMap )
+        mxCharMap = rSrc.mxCharMap;
 }
 
 CoreTextFontFace::CoreTextFontFace( const FontAttributes& rDFA, sal_IntPtr nFontId )
@@ -76,9 +76,9 @@ CoreTextFontFace::CoreTextFontFace( const FontAttributes& rDFA, sal_IntPtr nFont
 
 CoreTextFontFace::~CoreTextFontFace()
 {
-    if( mpCharMap )
+    if( mxCharMap )
     {
-        mpCharMap = nullptr;
+        mxCharMap = nullptr;
     }
 }
 
@@ -92,26 +92,26 @@ static unsigned GetUShort( const unsigned char* p ){return((p[0]<<8)+p[1]);}
 const FontCharMapPtr CoreTextFontFace::GetFontCharMap() const
 {
     // return the cached charmap
-    if( mpCharMap )
-        return mpCharMap;
+    if( mxCharMap )
+        return mxCharMap;
 
     // set the default charmap
     FontCharMapPtr pCharMap( new FontCharMap() );
-    mpCharMap = pCharMap;
+    mxCharMap = pCharMap;
 
     // get the CMAP byte size
     // allocate a buffer for the CMAP raw data
     const int nBufSize = GetFontTable( "cmap", nullptr );
     DBG_ASSERT( (nBufSize > 0), "CoreTextFontFace::GetFontCharMap : GetFontTable1 failed!\n");
     if( nBufSize <= 0 )
-        return mpCharMap;
+        return mxCharMap;
 
     // get the CMAP raw data
     ByteVector aBuffer( nBufSize );
     const int nRawLength = GetFontTable( "cmap", &aBuffer[0] );
     DBG_ASSERT( (nRawLength > 0), "CoreTextFontFace::GetFontCharMap : GetFontTable2 failed!\n");
     if( nRawLength <= 0 )
-        return mpCharMap;
+        return mxCharMap;
 
     DBG_ASSERT( (nBufSize==nRawLength), "CoreTextFontFace::GetFontCharMap : ByteCount mismatch!\n");
 
@@ -119,12 +119,12 @@ const FontCharMapPtr CoreTextFontFace::GetFontCharMap() const
     CmapResult aCmapResult;
     if( ParseCMAP( &aBuffer[0], nRawLength, aCmapResult ) )
     {
-        FontCharMapPtr pDefFontCharMap( new FontCharMap(aCmapResult) );
+        FontCharMapPtr xDefFontCharMap( new FontCharMap(aCmapResult) );
         // create the matching charmap
-        mpCharMap = pDefFontCharMap;
+        mxCharMap = xDefFontCharMap;
     }
 
-    return mpCharMap;
+    return mxCharMap;
 }
 
 bool CoreTextFontFace::GetFontCapabilities(vcl::FontCapabilities &rFontCapabilities) const
@@ -459,8 +459,8 @@ const FontCharMapPtr AquaSalGraphics::GetFontCharMap() const
 {
     if( !mpFontData )
     {
-        FontCharMapPtr pFontCharMap( new FontCharMap() );
-        return pFontCharMap;
+        FontCharMapPtr xFontCharMap( new FontCharMap() );
+        return xFontCharMap;
     }
 
     return mpFontData->GetFontCharMap();
@@ -741,14 +741,14 @@ void AquaSalGraphics::GetGlyphWidths( const PhysicalFontFace* pFontData, bool bV
             free( const_cast<TTSimpleGlyphMetrics *>(pGlyphMetrics) );
         }
 
-        FontCharMapPtr pMap = mpFontData->GetFontCharMap();
-        DBG_ASSERT( pMap && pMap->GetCharCount(), "no charmap" );
+        FontCharMapPtr xFCMap = mpFontData->GetFontCharMap();
+        DBG_ASSERT( xFCMap && xFCMap->GetCharCount(), "no charmap" );
 
         // get unicode<->glyph encoding
-        // TODO? avoid sft mapping by using the pMap itself
-        int nCharCount = pMap->GetCharCount();
-        sal_uInt32 nChar = pMap->GetFirstChar();
-        for( ; --nCharCount >= 0; nChar = pMap->GetNextChar( nChar ) )
+        // TODO? avoid sft mapping by using the xFCMap itself
+        int nCharCount = xFCMap->GetCharCount();
+        sal_uInt32 nChar = xFCMap->GetFirstChar();
+        for( ; --nCharCount >= 0; nChar = xFCMap->GetNextChar( nChar ) )
         {
             if( nChar > 0xFFFF ) // TODO: allow UTF-32 chars
                 break;
@@ -761,7 +761,7 @@ void AquaSalGraphics::GetGlyphWidths( const PhysicalFontFace* pFontData, bool bV
             }
         }
 
-        pMap = nullptr;
+        xFCMap = nullptr;
     }
 
     ::CloseTTFont( pSftFont );
diff --git a/vcl/source/filter/wmf/wmfwr.cxx b/vcl/source/filter/wmf/wmfwr.cxx
index 73f0489da7e5..90ef1d756ff7 100644
--- a/vcl/source/filter/wmf/wmfwr.cxx
+++ b/vcl/source/filter/wmf/wmfwr.cxx
@@ -948,16 +948,16 @@ void WMFWriter::SetAllAttr()
         pVirDev->SetFont(aSrcFont);
         if ( aDstFont.GetName() != aSrcFont.GetName() )
         {
-            FontCharMapPtr pFontCharMap;
-            if ( pVirDev->GetFontCharMap( pFontCharMap ) )
+            FontCharMapPtr xFontCharMap;
+            if ( pVirDev->GetFontCharMap( xFontCharMap ) )
             {
-                if ( ( pFontCharMap->GetFirstChar() & 0xff00 ) == 0xf000 )
+                if ( ( xFontCharMap->GetFirstChar() & 0xff00 ) == 0xf000 )
                     aSrcFont.SetCharSet( RTL_TEXTENCODING_SYMBOL );
                 else if ( aSrcFont.GetCharSet() == RTL_TEXTENCODING_SYMBOL )
                     aSrcFont.SetCharSet( RTL_TEXTENCODING_MS_1252 );
             }
 
-            pFontCharMap = nullptr;
+            xFontCharMap = nullptr;
         }
 
         aDstFont = aSrcFont;
diff --git a/vcl/source/outdev/font.cxx b/vcl/source/outdev/font.cxx
index 3ded83fafe2b..cdffc747b866 100644
--- a/vcl/source/outdev/font.cxx
+++ b/vcl/source/outdev/font.cxx
@@ -243,7 +243,7 @@ FontMetric OutputDevice::GetFontMetric( const vcl::Font& rFont ) const
     return aMetric;
 }
 
-bool OutputDevice::GetFontCharMap( FontCharMapPtr& rFontCharMap ) const
+bool OutputDevice::GetFontCharMap( FontCharMapPtr& rxFontCharMap ) const
 {
     // we need a graphics
     if( !mpGraphics && !AcquireGraphics() )
@@ -256,16 +256,16 @@ bool OutputDevice::GetFontCharMap( FontCharMapPtr& rFontCharMap ) const
     if( !mpFontInstance )
         return false;
 
-    FontCharMapPtr pFontCharMap ( mpGraphics->GetFontCharMap() );
-    if (!pFontCharMap)
+    FontCharMapPtr xFontCharMap ( mpGraphics->GetFontCharMap() );
+    if (!xFontCharMap)
     {
-        FontCharMapPtr pDefaultMap( new FontCharMap() );
-        rFontCharMap = pDefaultMap;
+        FontCharMapPtr xDefaultMap( new FontCharMap() );
+        rxFontCharMap = xDefaultMap;
     }
     else
-        rFontCharMap = pFontCharMap;
+        rxFontCharMap = xFontCharMap;
 
-    if( rFontCharMap->IsDefaultMap() )
+    if( rxFontCharMap->IsDefaultMap() )
         return false;
     return true;
 }
@@ -1540,8 +1540,8 @@ sal_Int32 OutputDevice::HasGlyphs( const vcl::Font& rTempFont, const OUString& r
     // to get the map temporarily set font
     const vcl::Font aOrigFont = GetFont();
     const_cast<OutputDevice&>(*this).SetFont( rTempFont );
-    FontCharMapPtr pFontCharMap ( new FontCharMap() );
-    bool bRet = GetFontCharMap( pFontCharMap );
+    FontCharMapPtr xFontCharMap ( new FontCharMap() );
+    bool bRet = GetFontCharMap( xFontCharMap );
     const_cast<OutputDevice&>(*this).SetFont( aOrigFont );
 
     // if fontmap is unknown assume it doesn't have the glyphs
@@ -1549,10 +1549,10 @@ sal_Int32 OutputDevice::HasGlyphs( const vcl::Font& rTempFont, const OUString& r
         return nIndex;
 
     for( sal_Int32 i = nIndex; nIndex < nEnd; ++i, ++nIndex )
-        if( ! pFontCharMap->HasChar( rStr[i] ) )
+        if( ! xFontCharMap->HasChar( rStr[i] ) )
             return nIndex;
 
-    pFontCharMap = nullptr;
+    xFontCharMap = nullptr;
 
     return -1;
 }
diff --git a/vcl/unx/generic/gdi/cairotextrender.cxx b/vcl/unx/generic/gdi/cairotextrender.cxx
index c68c23c22913..97af78fc5800 100644
--- a/vcl/unx/generic/gdi/cairotextrender.cxx
+++ b/vcl/unx/generic/gdi/cairotextrender.cxx
@@ -352,8 +352,8 @@ const FontCharMapPtr CairoTextRender::GetFontCharMap() const
     if( !mpServerFont[0] )
         return nullptr;
 
-    const FontCharMapPtr pFCMap = mpServerFont[0]->GetFontCharMap();
-    return pFCMap;
+    const FontCharMapPtr xFCMap = mpServerFont[0]->GetFontCharMap();
+    return xFCMap;
 }
 
 bool CairoTextRender::GetFontCapabilities(vcl::FontCapabilities &rGetImplFontCapabilities) const
diff --git a/vcl/unx/generic/gdi/gcach_ftyp.cxx b/vcl/unx/generic/gdi/gcach_ftyp.cxx
index 1853a916f2d9..7e49c0b5f236 100644
--- a/vcl/unx/generic/gdi/gcach_ftyp.cxx
+++ b/vcl/unx/generic/gdi/gcach_ftyp.cxx
@@ -209,7 +209,7 @@ FreetypeFontInfo::FreetypeFontInfo( const FontAttributes& rDevFontAttributes,
 #endif
     mnFontId( nFontId ),
     maDevFontAttributes( rDevFontAttributes ),
-    mpFontCharMap( nullptr ),
+    mxFontCharMap( nullptr ),
     mpChar2Glyph( nullptr ),
     mpGlyph2Char( nullptr )
 {
@@ -221,8 +221,8 @@ FreetypeFontInfo::FreetypeFontInfo( const FontAttributes& rDevFontAttributes,
 
 FreetypeFontInfo::~FreetypeFontInfo()
 {
-    if( mpFontCharMap )
-        mpFontCharMap = nullptr;
+    if( mxFontCharMap )
+        mxFontCharMap = nullptr;
     delete mpChar2Glyph;
     delete mpGlyph2Char;
 #if ENABLE_GRAPHITE
@@ -972,31 +972,31 @@ bool ServerFont::GetAntialiasAdvice() const
 
 const FontCharMapPtr ServerFont::GetFontCharMap() const
 {
-    const FontCharMapPtr pFCMap = mpFontInfo->GetFontCharMap();
-    return pFCMap;
+    const FontCharMapPtr xFCMap = mpFontInfo->GetFontCharMap();
+    return xFCMap;
 }
 
 const FontCharMapPtr FreetypeFontInfo::GetFontCharMap()
 {
     // check if the charmap is already cached
-    if( mpFontCharMap )
-        return mpFontCharMap;
+    if( mxFontCharMap )
+        return mxFontCharMap;
 
     // get the charmap and cache it
     CmapResult aCmapResult;
     bool bOK = GetFontCodeRanges( aCmapResult );
     if( bOK )
     {
-        FontCharMapPtr pFontCharMap( new FontCharMap ( aCmapResult ) );
-        mpFontCharMap = pFontCharMap;
+        FontCharMapPtr xFontCharMap( new FontCharMap ( aCmapResult ) );
+        mxFontCharMap = xFontCharMap;
     }
     else
     {
-        FontCharMapPtr pFontCharMap( new FontCharMap() );
-        mpFontCharMap = pFontCharMap;
+        FontCharMapPtr xFontCharMap( new FontCharMap() );
+        mxFontCharMap = xFontCharMap;
     }
-    // mpFontCharMap on either branch now has a refcount of 1
-    return mpFontCharMap;
+    // mxFontCharMap on either branch now has a refcount of 1
+    return mxFontCharMap;
 }
 
 // TODO: merge into method GetFontCharMap()
diff --git a/vcl/win/gdi/salfont.cxx b/vcl/win/gdi/salfont.cxx
index 9e3bce60b2cc..3a705bf20179 100644
--- a/vcl/win/gdi/salfont.cxx
+++ b/vcl/win/gdi/salfont.cxx
@@ -445,8 +445,8 @@ void ImplGetLogFontFromFontSelect( HDC, const FontSelectPattern*,
 bool WinGlyphFallbackSubstititution::HasMissingChars( PhysicalFontFace* pFace, const OUString& rMissingChars ) const
 {
     WinFontFace* pWinFont = static_cast< WinFontFace* >(pFace);
-    FontCharMapPtr pCharMap = pWinFont->GetFontCharMap();
-    if( !pCharMap )
+    FontCharMapPtr xFontCharMap = pWinFont->GetFontCharMap();
+    if( !xFontCharMap )
     {
         // construct a Size structure as the parameter of constructor of class FontSelectPattern
         const Size aSize( pFace->GetWidth(), pFace->GetHeight() );
@@ -461,7 +461,7 @@ bool WinGlyphFallbackSubstititution::HasMissingChars( PhysicalFontFace* pFace, c
         // select the new font into device
         HFONT hOldFont = ::SelectFont( mhDC, hNewFont );
 
-        // read CMAP table to update their pCharMap
+        // read CMAP table to update their xFontCharMap
         pWinFont->UpdateFromHDC( mhDC );
 
         // cleanup temporary font
@@ -469,11 +469,11 @@ bool WinGlyphFallbackSubstititution::HasMissingChars( PhysicalFontFace* pFace, c
         ::DeleteFont( hNewFont );
 
         // get the new charmap
-        pCharMap = pWinFont->GetFontCharMap();
+        xFontCharMap = pWinFont->GetFontCharMap();
     }
 
     // avoid fonts with unknown CMAP subtables for glyph fallback
-    if( !pCharMap || pCharMap->IsDefaultMap() )
+    if( !xFontCharMap || xFontCharMap->IsDefaultMap() )
         return false;
 
     int nMatchCount = 0;
@@ -482,11 +482,11 @@ bool WinGlyphFallbackSubstititution::HasMissingChars( PhysicalFontFace* pFace, c
     for( sal_Int32 nStrIdx = 0; nStrIdx < nStrLen; /* ++nStrIdx unreachable code, see the 'break' below */ )
     {
         const sal_UCS4 uChar = rMissingChars.iterateCodePoints( &nStrIdx );
-        nMatchCount += pCharMap->HasChar( uChar );
+        nMatchCount += xFontCharMap->HasChar( uChar );
         break; // for now
     }
 
-    pCharMap = 0;
+    xFontCharMap = 0;
 
     const bool bHasMatches = (nMatchCount > 0);
     return bHasMatches;
@@ -1005,7 +1005,7 @@ WinFontFace::WinFontFace( const FontAttributes& rDFS,
 #endif
     mbHasArabicSupport ( false ),
     mbFontCapabilitiesRead( false ),
-    mpUnicodeMap( NULL ),
+    mxUnicodeMap( NULL ),
     mpEncodingVector( NULL ),
     meWinCharSet( eWinCharSet ),
     mnPitchAndFamily( nPitchAndFamily ),
@@ -1042,8 +1042,8 @@ WinFontFace::WinFontFace( const FontAttributes& rDFS,
 
 WinFontFace::~WinFontFace()
 {
-    if( mpUnicodeMap )
-        mpUnicodeMap = 0;
+    if( mxUnicodeMap )
+        mxUnicodeMap = 0;
 #if ENABLE_GRAPHITE
     if (mpGraphiteData)
         mpGraphiteData->DeReference();
@@ -1065,7 +1065,7 @@ static inline DWORD CalcTag( const char p[4]) { return (p[0]+(p[1]<<8)+(p[2]<<16
 void WinFontFace::UpdateFromHDC( HDC hDC ) const
 {
     // short circuit if already initialized
-    if( mpUnicodeMap != NULL )
+    if( mxUnicodeMap != NULL )
         return;
 
     ReadCmapTable( hDC );
@@ -1123,9 +1123,9 @@ bool WinFontFace::IsGSUBstituted( sal_UCS4 cChar ) const
 
 FontCharMapPtr WinFontFace::GetFontCharMap() const
 {
-    if( !mpUnicodeMap )
+    if( !mxUnicodeMap )
         return NULL;
-    return mpUnicodeMap;
+    return mxUnicodeMap;
 }
 
 bool WinFontFace::GetFontCapabilities(vcl::FontCapabilities &rFontCapabilities) const
@@ -1181,7 +1181,7 @@ void WinFontFace::ReadGsubTable( HDC hDC ) const
 
 void WinFontFace::ReadCmapTable( HDC hDC ) const
 {
-    if( mpUnicodeMap != NULL )
+    if( mxUnicodeMap != NULL )
         return;
 
     bool bIsSymbolFont = (meWinCharSet == SYMBOL_CHARSET);
@@ -1196,13 +1196,13 @@ void WinFontFace::ReadCmapTable( HDC hDC ) const
         if( aResult.mnRangeCount > 0 )
         {
             FontCharMapPtr pUnicodeMap(new FontCharMap(aResult));
-            mpUnicodeMap = pUnicodeMap;
+            mxUnicodeMap = pUnicodeMap;
         }
     }
 
-    if( !mpUnicodeMap )
+    if( !mxUnicodeMap )
     {
-        mpUnicodeMap = FontCharMap::GetDefaultMap( bIsSymbolFont );
+        mxUnicodeMap = FontCharMap::GetDefaultMap( bIsSymbolFont );
     }
 }
 
@@ -1558,8 +1558,8 @@ const FontCharMapPtr WinSalGraphics::GetFontCharMap() const
 {
     if( !mpWinFontData[0] )
     {
-        FontCharMapPtr pDefFontCharMap( new FontCharMap() );
-        return pDefFontCharMap;
+        FontCharMapPtr xDefFontCharMap( new FontCharMap() );
+        return xDefFontCharMap;
     }
     return mpWinFontData[0]->GetFontCharMap();
 }
@@ -2250,7 +2250,7 @@ bool WinSalGraphics::CreateFontSubset( const OUString& rToFile,
     if( aRawCffData.get() )
     {
         pWinFontData->UpdateFromHDC( getHDC() );
-        FontCharMapPtr pCharMap = pWinFontData->GetFontCharMap();
+        FontCharMapPtr xFontCharMap = pWinFontData->GetFontCharMap();
 
         sal_GlyphId aRealGlyphIds[ 256 ];
         for( int i = 0; i < nGlyphCount; ++i )
@@ -2259,14 +2259,14 @@ bool WinSalGraphics::CreateFontSubset( const OUString& rToFile,
             // TODO: use GDI's GetGlyphIndices instead? Does it handle GSUB properly?
             sal_GlyphId aGlyphId = pGlyphIds[i] & GF_IDXMASK;
             if( pGlyphIds[i] & GF_ISCHAR ) // remaining pseudo-glyphs need to be translated
-                aGlyphId = pCharMap->GetGlyphIndex( aGlyphId );
+                aGlyphId = xFontCharMap->GetGlyphIndex( aGlyphId );
             if( (pGlyphIds[i] & (GF_ROTMASK|GF_GSUB)) != 0) // TODO: vertical substitution
                 {/*####*/}
 
             aRealGlyphIds[i] = aGlyphId;
         }
 
-        pCharMap = 0;
+        xFontCharMap = 0;
 
         // provide a font subset from the CFF-table
         FILE* pOutFile = fopen( aToFile.getStr(), "wb" );
@@ -2500,11 +2500,11 @@ void WinSalGraphics::GetGlyphWidths( const PhysicalFontFace* pFont,
                 rUnicodeEnc.clear();
             }
             const WinFontFace* pWinFont = static_cast<const WinFontFace*>(pFont);
-            FontCharMapPtr pMap = pWinFont->GetFontCharMap();
-            DBG_ASSERT( pMap && pMap->GetCharCount(), "no map" );
+            FontCharMapPtr xFCMap = pWinFont->GetFontCharMap();
+            DBG_ASSERT( xFCMap && xFCMap->GetCharCount(), "no map" );
 
-            int nCharCount = pMap->GetCharCount();
-            sal_uInt32 nChar = pMap->GetFirstChar();
+            int nCharCount = xFCMap->GetCharCount();
+            sal_uInt32 nChar = xFCMap->GetFirstChar();
             for( int i = 0; i < nCharCount; i++ )
             {
                 if( nChar < 0x00010000 )
@@ -2515,10 +2515,10 @@ void WinSalGraphics::GetGlyphWidths( const PhysicalFontFace* pFont,
                     if( nGlyph )
                         rUnicodeEnc[ static_cast<sal_Unicode>(nChar) ] = nGlyph;
                 }
-                nChar = pMap->GetNextChar( nChar );
+                nChar = xFCMap->GetNextChar( nChar );
             }
 
-            pMap = 0;
+            xFCMap = 0;
         }
     }
     else if( pFont->CanEmbed() )