FX_BOOL considered harmful.

core/src/fxge/ge/fx_ge_fontmap.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include <limits>
 
 #include "../../../include/fxge/fx_ge.h"
 #include "../../../include/fxge/fx_freetype.h"
 #include "text_int.h"
 #define GET_TT_SHORT(w)  (FX_WORD)(((w)[0] << 8) | (w)[1])
 #define GET_TT_LONG(w) (FX_DWORD)(((w)[0] << 24) | ((w)[1] << 16) | ((w)[2] << 8) | (w)[3])
 CFX_SubstFont::CFX_SubstFont()
 {
     m_ExtHandle = NULL;
     m_Charset = 0;
     m_SubstFlags = 0;
     m_Weight = 0;
     m_ItalicAngle = 0;
-    m_bSubstOfCJK = FALSE;
+    m_bSubstOfCJK = false;
     m_WeightCJK = 0;
-    m_bItlicCJK = FALSE;
+    m_bItlicCJK = false;
 }
 CTTFontDesc::~CTTFontDesc()
 {
     if (m_Type == 1) {
         if (m_SingleFace.m_pFace) {
             FXFT_Done_Face(m_SingleFace.m_pFace);
         }
     } else if (m_Type == 2) {
         for (int i = 0; i < 16; i ++)
             if (m_TTCFace.m_pFaces[i]) {
                 FXFT_Done_Face(m_TTCFace.m_pFaces[i]);
             }
     }
     if (m_pFontData) {
         FX_Free(m_pFontData);
     }
 }
-FX_BOOL CTTFontDesc::ReleaseFace(FXFT_Face face)
+bool CTTFontDesc::ReleaseFace(FXFT_Face face)
 {
     if (m_Type == 1) {
         if (m_SingleFace.m_pFace != face) {
-            return FALSE;
+            return false;
         }
     } else if (m_Type == 2) {
         int i;
         for (i = 0; i < 16; i ++)
             if (m_TTCFace.m_pFaces[i] == face) {
                 break;
             }
         if (i == 16) {
-            return FALSE;
+            return false;
         }
     }
     m_RefCount --;
     if (m_RefCount) {
-        return FALSE;
+        return false;
     }
     delete this;
-    return TRUE;
+    return true;
 }
 CFX_FontMgr::CFX_FontMgr()
 {
     m_pBuiltinMapper = new CFX_FontMapper;
     m_pBuiltinMapper->m_pFontMgr = this;
     m_pExtMapper = NULL;
     m_FTLibrary = NULL;
     FXSYS_memset(m_ExternalFonts, 0, sizeof m_ExternalFonts);
 }
 CFX_FontMgr::~CFX_FontMgr()
@@ skipping 18 matching lines @@
         CTTFontDesc* face;
         m_FaceMap.GetNextAssoc(pos, Key, (void*&)face);
         delete face;
     }
     m_FaceMap.RemoveAll();
 }
 void CFX_FontMgr::SetSystemFontInfo(IFX_SystemFontInfo* pFontInfo)
 {
     m_pBuiltinMapper->SetSystemFontInfo(pFontInfo);
 }
-FXFT_Face CFX_FontMgr::FindSubstFont(const CFX_ByteString& face_name, FX_BOOL bTrueType,
+FXFT_Face CFX_FontMgr::FindSubstFont(const CFX_ByteString& face_name, bool bTrueType,
                                      FX_DWORD flags, int weight, int italic_angle, int CharsetCP, CFX_SubstFont* pSubstFont)
 {
     if (m_FTLibrary == NULL) {
         FXFT_Init_FreeType(&m_FTLibrary);
     }
     if (m_pExtMapper) {
         FXFT_Face face = m_pExtMapper->FindSubstFont(face_name, bTrueType, flags, weight, italic_angle,
                          CharsetCP, pSubstFont);
         if (face) {
             return face;
         }
     }
     return m_pBuiltinMapper->FindSubstFont(face_name, bTrueType, flags, weight, italic_angle,
                                            CharsetCP, pSubstFont);
 }
 FXFT_Face CFX_FontMgr::GetCachedFace(const CFX_ByteString& face_name,
-                                     int weight, FX_BOOL bItalic, uint8_t*& pFontData)
+                                     int weight, bool bItalic, uint8_t*& pFontData)
 {
     CFX_ByteString key(face_name);
     key += ',';
     key += CFX_ByteString::FormatInteger(weight);
     key += bItalic ? 'I' : 'N';
     CTTFontDesc* pFontDesc = NULL;
     m_FaceMap.Lookup(key, (void*&)pFontDesc);
     if(pFontDesc) {
         pFontData = pFontDesc->m_pFontData;
         pFontDesc->m_RefCount ++;
         return pFontDesc->m_SingleFace.m_pFace;
     }
     return NULL;
 }
 FXFT_Face CFX_FontMgr::AddCachedFace(const CFX_ByteString& face_name,
-                                     int weight, FX_BOOL bItalic, uint8_t* pData, FX_DWORD size, int face_index)
+                                     int weight, bool bItalic, uint8_t* pData, FX_DWORD size, int face_index)
 {
     CTTFontDesc* pFontDesc = new CTTFontDesc;
     pFontDesc->m_Type = 1;
     pFontDesc->m_SingleFace.m_pFace = NULL;
     pFontDesc->m_SingleFace.m_bBold = weight;
     pFontDesc->m_SingleFace.m_bItalic = bItalic;
     pFontDesc->m_pFontData = pData;
     pFontDesc->m_RefCount = 1;
     FXFT_Library library;
     if (m_FTLibrary == NULL) {
@@ skipping 281 matching lines @@
     {g_FoxitSerifBoldFontData, 19395},
     {g_FoxitSerifBoldItalicFontData, 20733},
     {g_FoxitSerifItalicFontData, 21227},
     {g_FoxitSymbolFontData, 16729},
     {g_FoxitDingbatsFontData, 29513},
 };
 void _FPDFAPI_GetInternalFontData(int id, const uint8_t*& data, FX_DWORD& size)
 {
     CFX_GEModule::Get()->GetFontMgr()->GetStandardFont(data, size, id);
 }
-FX_BOOL CFX_FontMgr::GetStandardFont(const uint8_t*& pFontData, FX_DWORD& size, int index)
+bool CFX_FontMgr::GetStandardFont(const uint8_t*& pFontData, FX_DWORD& size, int index)
 {
     if (index > 15 || index < 0) {
-        return FALSE;
+        return false;
     }
     {
         if (index >= 14) {
             if (index == 14) {
                 pFontData = g_FoxitSerifMMFontData;
                 size = 113417;
             } else {
                 pFontData = g_FoxitSansMMFontData;
                 size = 66919;
             }
         } else {
             pFontData = g_FoxitFonts[index].m_pFontData;
             size = g_FoxitFonts[index].m_dwSize;
         }
     }
-    return TRUE;
+    return true;
 }
 CFX_FontMapper::CFX_FontMapper()
 {
     FXSYS_memset(m_FoxitFaces, 0, sizeof m_FoxitFaces);
     m_MMFaces[0] = m_MMFaces[1] = NULL;
     m_pFontInfo = NULL;
-    m_bListLoaded = FALSE;
+    m_bListLoaded = false;
     m_pFontEnumerator = NULL;
 }
 CFX_FontMapper::~CFX_FontMapper()
 {
     for (int i = 0; i < 14; i ++)
         if (m_FoxitFaces[i]) {
             FXFT_Done_Face(m_FoxitFaces[i]);
         }
     if (m_MMFaces[0]) {
         FXFT_Done_Face(m_MMFaces[0]);
@@ skipping 103 matching lines @@
         return;
     }
     if (m_CharsetArray.Find((FX_DWORD)charset) == -1) {
         m_CharsetArray.Add((FX_DWORD)charset);
         m_FaceArray.Add(name);
     }
     if (name == m_LastFamily) {
         return;
     }
     const uint8_t* ptr = name;
-    FX_BOOL bLocalized = FALSE;
+    bool bLocalized = false;
     for (int i = 0; i < name.GetLength(); i ++)
         if (ptr[i] > 0x80) {
-            bLocalized = TRUE;
+            bLocalized = true;
             break;
         }
     if (bLocalized) {
         void* hFont = m_pFontInfo->GetFont(name);
         if (hFont == NULL) {
-            FX_BOOL bExact;
-            hFont = m_pFontInfo->MapFont(0, 0, FXFONT_DEFAULT_CHARSET, 0, name, bExact);
+            int iExact;
+            hFont = m_pFontInfo->MapFont(0, 0, FXFONT_DEFAULT_CHARSET, 0, name, iExact);
             if (hFont == NULL) {
                 return;
             }
         }
         CFX_ByteString new_name = GetPSNameFromTT(hFont);
         if (!new_name.IsEmpty()) {
             new_name.Insert(0, ' ');
             m_InstalledTTFonts.Add(new_name);
         }
         m_pFontInfo->DeleteFont(hFont);
     }
     m_InstalledTTFonts.Add(name);
     m_LastFamily = name;
 }
 void CFX_FontMapper::LoadInstalledFonts()
 {
     if (m_pFontInfo == NULL) {
         return;
     }
     if (m_bListLoaded) {
         return;
     }
     if (m_bListLoaded) {
         return;
     }
     m_pFontInfo->EnumFontList(this);
-    m_bListLoaded = TRUE;
+    m_bListLoaded = true;
 }
 CFX_ByteString CFX_FontMapper::MatchInstalledFonts(const CFX_ByteString& norm_name)
 {
     LoadInstalledFonts();
     int i;
     for (i = m_InstalledTTFonts.GetSize() - 1; i >= 0; i --) {
         CFX_ByteString norm1 = _TT_NormalizeName(m_InstalledTTFonts[i]);
         if (norm1 == norm_name) {
             break;
         }
@@ skipping 205 matching lines @@
     }
     while (iIndex < iLen) {
         if (pStyle[iIndex] == ',') {
             break;
         }
         buf.AppendChar(pStyle[iIndex]);
         ++iIndex;
     }
     return buf.GetByteString();
 }
-int32_t GetStyleType(const CFX_ByteString &bsStyle, FX_BOOL bRevert)
+int32_t GetStyleType(const CFX_ByteString &bsStyle, bool bRevert)
 {
     int32_t iLen = bsStyle.GetLength();
     if (!iLen) {
         return -1;
     }
     int iSize = sizeof(g_FontStyles) / sizeof(FX_FontStyle);
     const FX_FontStyle *pStyle = NULL;
     for (int i = iSize - 1; i >= 0; --i) {
         pStyle = g_FontStyles + i;
         if (!pStyle || pStyle->len > iLen) {
             continue;
         }
         if (!bRevert) {
             if (bsStyle.Left(pStyle->len).Compare(pStyle->style) == 0) {
                 return i;
             }
         } else {
             if (bsStyle.Right(pStyle->len).Compare(pStyle->style) == 0) {
                 return i;
             }
         }
     }
     return -1;
 }
-FX_BOOL CheckSupportThirdPartFont(CFX_ByteString name, int &PitchFamily)
+bool CheckSupportThirdPartFont(CFX_ByteString name, int &PitchFamily)
 {
     if (name == FX_BSTRC("MyriadPro")) {
         PitchFamily &= ~FXFONT_FF_ROMAN;
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
-FXFT_Face CFX_FontMapper::FindSubstFont(const CFX_ByteString& name, FX_BOOL bTrueType, FX_DWORD flags,
+FXFT_Face CFX_FontMapper::FindSubstFont(const CFX_ByteString& name, bool bTrueType, FX_DWORD flags,
                                         int weight, int italic_angle, int WindowCP, CFX_SubstFont* pSubstFont)
 {
     if (!(flags & FXFONT_USEEXTERNATTR)) {
         weight = FXFONT_FW_NORMAL;
         italic_angle = 0;
     }
     CFX_ByteString SubstName = name;
     SubstName.Remove(0x20);
     if (bTrueType) {
         if (name[0] == '@') {
@@ skipping 22 matching lines @@
             return m_FoxitFaces[13];
         }
         const uint8_t* pFontData = NULL;
         FX_DWORD size = 0;
         m_pFontMgr->GetStandardFont(pFontData, size, 13);
         m_FoxitFaces[13] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
         return m_FoxitFaces[13];
     }
     int iBaseFont = 0;
     CFX_ByteString family, style;
-    FX_BOOL     bHasComma = FALSE;
-    FX_BOOL bHasHypen = FALSE;
+    bool        bHasComma = false;
+    bool bHasHypen = false;
     int find = SubstName.Find(FX_BSTRC(","), 0);
     if (find >= 0) {
         family = SubstName.Left(find);
         _PDF_GetStandardFontName(family);
         style = SubstName.Mid(find + 1);
-        bHasComma = TRUE;
+        bHasComma = true;
     } else {
         family = SubstName;
     }
     for (; iBaseFont < 12; iBaseFont ++)
         if (family == CFX_ByteStringC(g_Base14FontNames[iBaseFont])) {
             break;
         }
     int PitchFamily = 0;
-    FX_BOOL bItalic = FALSE;
+    bool bItalic = false;
     FX_DWORD nStyle = 0;
-    FX_BOOL bStyleAvail = FALSE;
+    bool bStyleAvail = false;
     if (iBaseFont < 12) {
         family = g_Base14FontNames[iBaseFont];
         if ((iBaseFont % 4) == 1 || (iBaseFont % 4) == 2) {
             nStyle |= FX_FONT_STYLE_Bold;
         }
         if ((iBaseFont % 4) / 2) {
             nStyle |= FX_FONT_STYLE_Italic;
         }
         if (iBaseFont < 4) {
             PitchFamily |= FXFONT_FF_FIXEDPITCH;
         }
         if (iBaseFont >= 8) {
             PitchFamily |= FXFONT_FF_ROMAN;
         }
     } else {
         if (!bHasComma) {
             find = family.ReverseFind('-');
             if (find >= 0) {
                 style = family.Mid(find + 1);
                 family = family.Left(find);
-                bHasHypen = TRUE;
+                bHasHypen = true;
             }
         }
         if (!bHasHypen) {
             int nLen = family.GetLength();
-            int32_t nRet = GetStyleType(family, TRUE);
+            int32_t nRet = GetStyleType(family, true);
             if (nRet > -1) {
                 family = family.Left(nLen - g_FontStyles[nRet].len);
                 if (nRet == 0) {
                     nStyle |= FX_FONT_STYLE_Bold;
                 }
                 if (nRet == 1) {
                     nStyle |= FX_FONT_STYLE_Italic;
                 }
                 if (nRet == 2) {
                     nStyle |= (FX_FONT_STYLE_Bold | FX_FONT_STYLE_Italic);
                 }
             }
         }
         if (flags & FXFONT_SERIF) {
             PitchFamily |= FXFONT_FF_ROMAN;
         }
         if (flags & FXFONT_SCRIPT) {
             PitchFamily |= FXFONT_FF_SCRIPT;
         }
         if (flags & FXFONT_FIXED_PITCH) {
             PitchFamily |= FXFONT_FF_FIXEDPITCH;
         }
     }
     if (!style.IsEmpty()) {
         int nLen = style.GetLength();
         const FX_CHAR* pStyle = style;
         int i = 0;
-        FX_BOOL bFirstItem = TRUE;
+        bool bFirstItem = true;
         CFX_ByteString buf;
         while (i < nLen) {
             buf = ParseStyle(pStyle, nLen, i);
-            int32_t nRet = GetStyleType(buf, FALSE);
+            int32_t nRet = GetStyleType(buf, false);
             if ((i && !bStyleAvail) || (!i && nRet < 0)) {
                 family = SubstName;
                 iBaseFont = 12;
                 break;
             } else if (nRet >= 0) {
-                bStyleAvail = TRUE;
+                bStyleAvail = true;
             }
             if (nRet == 0) {
                 if (nStyle & FX_FONT_STYLE_Bold) {
                     nStyle |= FX_FONT_STYLE_BoldBold;
                 } else {
                     nStyle |= FX_FONT_STYLE_Bold;
                 }
-                bFirstItem = FALSE;
+                bFirstItem = false;
             }
             if (nRet == 1) {
                 if (bFirstItem) {
                     nStyle |= FX_FONT_STYLE_Italic;
                 } else {
                     family = SubstName;
                     iBaseFont = 12;
                 }
                 break;
             }
             if (nRet == 2) {
                 nStyle |= FX_FONT_STYLE_Italic;
                 if (nStyle & FX_FONT_STYLE_Bold) {
                     nStyle |= FX_FONT_STYLE_BoldBold;
                 } else {
                     nStyle |= FX_FONT_STYLE_Bold;
                 }
-                bFirstItem = FALSE;
+                bFirstItem = false;
             }
             i += buf.GetLength() + 1;
         }
     }
     weight = weight ? weight : FXFONT_FW_NORMAL;
     int old_weight = weight;
     if (nStyle) {
         weight = nStyle & FX_FONT_STYLE_BoldBold ? 900 : (nStyle & FX_FONT_STYLE_Bold ? FXFONT_FW_BOLD : FXFONT_FW_NORMAL);
     }
     if (nStyle & FX_FONT_STYLE_Italic) {
-        bItalic = TRUE;
+        bItalic = true;
     }
-    FX_BOOL bCJK = FALSE;
-    FX_BOOL bExact = FALSE;
+    bool bCJK = false;
+    int iExact = 0;
     int Charset = FXFONT_ANSI_CHARSET;
     if (WindowCP) {
         Charset = _GetCharsetFromCodePage(WindowCP);
     } else if (iBaseFont == 12 && (flags & FXFONT_SYMBOLIC)) {
         Charset = FXFONT_SYMBOL_CHARSET;
     }
     if (Charset == FXFONT_SHIFTJIS_CHARSET || Charset == FXFONT_GB2312_CHARSET ||
             Charset == FXFONT_HANGEUL_CHARSET || Charset == FXFONT_CHINESEBIG5_CHARSET) {
-        bCJK = TRUE;
+        bCJK = true;
     }
     if (m_pFontInfo == NULL) {
         pSubstFont->m_SubstFlags |= FXFONT_SUBST_STANDARD;
         return UseInternalSubst(pSubstFont, iBaseFont, italic_angle, old_weight, PitchFamily);
     }
     family = _GetFontFamily(family, nStyle);
     CFX_ByteString match = MatchInstalledFonts(_TT_NormalizeName(family));
     if (match.IsEmpty() && family != SubstName && (!bHasComma && (!bHasHypen || (bHasHypen && !bStyleAvail)))) {
         match = MatchInstalledFonts(_TT_NormalizeName(SubstName));
     }
     if (match.IsEmpty() && iBaseFont >= 12) {
         if (!bCJK) {
             if (!CheckSupportThirdPartFont(family, PitchFamily)) {
                 if (italic_angle != 0) {
-                    bItalic = TRUE;
+                    bItalic = true;
                 } else {
-                    bItalic = FALSE;
+                    bItalic = false;
                 }
                 weight = old_weight;
             }
         } else {
-            pSubstFont->m_bSubstOfCJK = TRUE;
+            pSubstFont->m_bSubstOfCJK = true;
             if (nStyle) {
                 pSubstFont->m_WeightCJK = weight;
             } else {
                 pSubstFont->m_WeightCJK = FXFONT_FW_NORMAL;
             }
             if (nStyle & FX_FONT_STYLE_Italic) {
-                pSubstFont->m_bItlicCJK = TRUE;
+                pSubstFont->m_bItlicCJK = true;
             }
         }
     } else {
         italic_angle = 0;
         weight = nStyle & FX_FONT_STYLE_BoldBold ? 900 : (nStyle & FX_FONT_STYLE_Bold ? FXFONT_FW_BOLD : FXFONT_FW_NORMAL);
     }
     if (!match.IsEmpty() || iBaseFont < 12) {
         pSubstFont->m_SubstFlags |= FXFONT_SUBST_EXACT;
         if (!match.IsEmpty()) {
             family = match;
@@ skipping 19 matching lines @@
                 if (m_FoxitFaces[iBaseFont]) {
                     return m_FoxitFaces[iBaseFont];
                 }
             } else {
                 family = g_Base14FontNames[iBaseFont];
             }
             pSubstFont->m_SubstFlags |= FXFONT_SUBST_STANDARD;
         }
     } else {
         if (flags & FXFONT_ITALIC) {
-            bItalic = TRUE;
+            bItalic = true;
         }
     }
-    bExact = !match.IsEmpty();
-    void* hFont = m_pFontInfo->MapFont(weight, bItalic, Charset, PitchFamily, family, bExact);
-    if (bExact) {
+    iExact = !match.IsEmpty();
+    void* hFont = m_pFontInfo->MapFont(weight, bItalic, Charset, PitchFamily, family, iExact);
+    if (iExact) {
         pSubstFont->m_SubstFlags |= FXFONT_SUBST_EXACT;
     }
     if (hFont == NULL) {
         if (bCJK) {
             if (italic_angle != 0) {
-                bItalic = TRUE;
+                bItalic = true;
             } else {
-                bItalic = FALSE;
+                bItalic = false;
             }
             weight = old_weight;
         }
         if (!match.IsEmpty()) {
             hFont = m_pFontInfo->GetFont(match);
             if (hFont == NULL) {
                 return UseInternalSubst(pSubstFont, iBaseFont, italic_angle, old_weight, PitchFamily);
             }
         } else {
             if (Charset == FXFONT_SYMBOL_CHARSET) {
@@ skipping 69 matching lines @@
             m_pFontInfo->GetFontData(hFont, 0, pFontData, font_size);
             face = m_pFontMgr->AddCachedFace(SubstName, weight, bItalic, pFontData, font_size, m_pFontInfo->GetFaceIndex(hFont));
         }
     }
     if (face == NULL) {
         m_pFontInfo->DeleteFont(hFont);
         return NULL;
     }
     pSubstFont->m_Family = SubstName;
     pSubstFont->m_Charset = Charset;
-    FX_BOOL bNeedUpdateWeight = FALSE;
+    bool bNeedUpdateWeight = false;
     if (FXFT_Is_Face_Bold(face)) {
         if (weight == FXFONT_FW_BOLD) {
-            bNeedUpdateWeight = FALSE;
+            bNeedUpdateWeight = false;
         } else {
-            bNeedUpdateWeight = TRUE;
+            bNeedUpdateWeight = true;
         }
     } else {
         if (weight == FXFONT_FW_NORMAL) {
-            bNeedUpdateWeight = FALSE;
+            bNeedUpdateWeight = false;
         } else {
-            bNeedUpdateWeight = TRUE;
+            bNeedUpdateWeight = true;
         }
     }
     if (bNeedUpdateWeight) {
         pSubstFont->m_Weight = weight;
     }
     if (bItalic && !FXFT_Is_Face_Italic(face)) {
         if (italic_angle == 0) {
             italic_angle = -12;
         } else if (FXSYS_abs(italic_angle) < 5) {
             italic_angle = 0;
         }
         pSubstFont->m_ItalicAngle = italic_angle;
     }
     m_pFontInfo->DeleteFont(hFont);
     return face;
 }
 extern "C" {
     unsigned long _FTStreamRead(FXFT_Stream stream, unsigned long offset,
                                 unsigned char* buffer, unsigned long count);
     void _FTStreamClose(FXFT_Stream stream);
 };
 CFontFileFaceInfo::CFontFileFaceInfo()
 {
     m_pFile = NULL;
     m_Face = NULL;
     m_Charsets = 0;
     m_FileSize = 0;
     m_FontOffset = 0;
     m_Weight = 0;
-    m_bItalic = FALSE;
+    m_bItalic = false;
     m_PitchFamily = 0;
 }
 CFontFileFaceInfo::~CFontFileFaceInfo()
 {
     if (m_Face) {
         FXFT_Done_Face(m_Face);
     }
     m_Face = NULL;
 }
-extern FX_BOOL _LoadFile(FXFT_Library library, FXFT_Face* Face, IFX_FileRead* pFile, FXFT_Stream* stream);
+extern bool _LoadFile(FXFT_Library library, FXFT_Face* Face, IFX_FileRead* pFile, FXFT_Stream* stream);
 #if _FX_OS_ == _FX_ANDROID_
 IFX_SystemFontInfo* IFX_SystemFontInfo::CreateDefault()
 {
     return NULL;
 }
 #endif
 CFX_FolderFontInfo::CFX_FolderFontInfo()
 {
 }
 CFX_FolderFontInfo::~CFX_FolderFontInfo()
 {
     FX_POSITION pos = m_FontList.GetStartPosition();
     while (pos) {
         CFX_ByteString key;
         void* value;
         m_FontList.GetNextAssoc(pos, key, value);
         delete (CFontFaceInfo*)value;
     }
 }
 void CFX_FolderFontInfo::AddPath(const CFX_ByteStringC& path)
 {
     m_PathList.Add(path);
 }
 void CFX_FolderFontInfo::Release()
 {
     delete this;
 }
-FX_BOOL CFX_FolderFontInfo::EnumFontList(CFX_FontMapper* pMapper)
+bool CFX_FolderFontInfo::EnumFontList(CFX_FontMapper* pMapper)
 {
     m_pMapper = pMapper;
     for (int i = 0; i < m_PathList.GetSize(); i ++) {
         ScanPath(m_PathList[i]);
     }
-    return TRUE;
+    return true;
 }
 void CFX_FolderFontInfo::ScanPath(CFX_ByteString& path)
 {
     void* handle = FX_OpenFolder(path);
     if (handle == NULL) {
         return;
     }
     CFX_ByteString filename;
-    FX_BOOL bFolder;
+    bool bFolder;
     while (FX_GetNextFile(handle, filename, bFolder)) {
         if (bFolder) {
             if (filename == "." || filename == "..") {
                 continue;
             }
         } else {
             CFX_ByteString ext = filename.Right(4);
             ext.MakeUpper();
             if (ext != ".TTF" && ext != ".OTF" && ext != ".TTC") {
                 continue;
@@ skipping 115 matching lines @@
         pInfo->m_Styles |= FXFONT_BOLD;
     }
     if (style.Find(FX_BSTRC("Italic")) > -1 || style.Find(FX_BSTRC("Oblique")) > -1) {
         pInfo->m_Styles |= FXFONT_ITALIC;
     }
     if (facename.Find(FX_BSTRC("Serif")) > -1) {
         pInfo->m_Styles |= FXFONT_SERIF;
     }
     m_FontList.SetAt(facename, pInfo);
 }
-void* CFX_FolderFontInfo::MapFont(int weight, FX_BOOL bItalic, int charset, int pitch_family, const FX_CHAR* family, FX_BOOL& bExact)
+void* CFX_FolderFontInfo::MapFont(int weight, bool bItalic, int charset, int pitch_family, const FX_CHAR* family, bool& bExact)
 {
     return NULL;
 }
 void* CFX_FolderFontInfo::GetFont(const FX_CHAR* face)
 {
     void* p;
     if (!m_FontList.Lookup(face, p)) {
         return NULL;
     }
     return p;
@@ skipping 34 matching lines @@
         FXSYS_fread(buffer, datasize, 1, pFile);
     }
     if (pFile) {
         FXSYS_fclose(pFile);
     }
     return datasize;
 }
 void CFX_FolderFontInfo::DeleteFont(void* hFont)
 {
 }
-FX_BOOL CFX_FolderFontInfo::GetFaceName(void* hFont, CFX_ByteString& name)
+bool CFX_FolderFontInfo::GetFaceName(void* hFont, CFX_ByteString& name)
 {
     if (hFont == NULL) {
-        return FALSE;
+        return false;
     }
     CFontFaceInfo* pFont = (CFontFaceInfo*)hFont;
     name = pFont->m_FaceName;
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_FolderFontInfo::GetFontCharset(void* hFont, int& charset)
+bool CFX_FolderFontInfo::GetFontCharset(void* hFont, int& charset)
 {
-    return FALSE;
+    return false;
 }