FX Bool considered harmful, part 3

core/src/fpdfapi/fpdf_font/fpdf_font.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 "../../../include/fpdfapi/fpdf_module.h"
 #include "../../../include/fpdfapi/fpdf_page.h"
 #include "../../../include/fpdfapi/fpdf_pageobj.h"
 #include "../../../include/fpdfapi/fpdf_resource.h"
 #include "../../../include/fxge/fx_freetype.h"
 #include "../fpdf_page/pageint.h"
 #include "font_int.h"
 
-FX_BOOL FT_UseTTCharmap(FXFT_Face face, int platform_id, int encoding_id)
+bool FT_UseTTCharmap(FXFT_Face face, int platform_id, int encoding_id)
 {
     for (int i = 0; i < FXFT_Get_Face_CharmapCount(face); i ++) {
         if (FXFT_Get_Charmap_PlatformID(FXFT_Get_Face_Charmaps(face)[i]) == platform_id &&
                 FXFT_Get_Charmap_EncodingID(FXFT_Get_Face_Charmaps(face)[i]) == encoding_id) {
             FXFT_Set_Charmap(face, FXFT_Get_Face_Charmaps(face)[i]);
-            return TRUE;
+            return true;
         }
     }
-    return FALSE;
+    return false;
 }
 CPDF_FontGlobals::CPDF_FontGlobals()
     : m_pContrastRamps(NULL)
 {
     FXSYS_memset(m_EmbeddedCharsets, 0, sizeof(m_EmbeddedCharsets));
     FXSYS_memset(m_EmbeddedToUnicodes, 0, sizeof(m_EmbeddedToUnicodes));
 }
 CPDF_FontGlobals::~CPDF_FontGlobals()
 {
     ClearAll();
@@ skipping 78 matching lines @@
         m_pStockMap.RemoveKey(key);
     }
 }
 CPDF_Font::CPDF_Font(int fonttype) : m_FontType(fonttype)
 {
     m_FontBBox.left = m_FontBBox.right = m_FontBBox.top = m_FontBBox.bottom = 0;
     m_StemV = m_Ascent = m_Descent = m_ItalicAngle = 0;
     m_pFontFile = NULL;
     m_Flags = 0;
     m_pToUnicodeMap = NULL;
-    m_bToUnicodeLoaded = FALSE;
+    m_bToUnicodeLoaded = false;
     m_pCharMap = new CPDF_FontCharMap(this);
 }
 CPDF_Font::~CPDF_Font()
 {
     delete m_pCharMap;
     m_pCharMap = NULL;
 
     delete m_pToUnicodeMap;
     m_pToUnicodeMap = NULL;
 
     if (m_pFontFile) {
         m_pDocument->GetPageData()->ReleaseFontFileStreamAcc((CPDF_Stream*)m_pFontFile->GetStream());
     }
 }
-FX_BOOL CPDF_Font::IsVertWriting() const
+bool CPDF_Font::IsVertWriting() const
 {
-    FX_BOOL bVertWriting = FALSE;
+    bool bVertWriting = false;
     CPDF_CIDFont* pCIDFont = GetCIDFont();
     if (pCIDFont) {
         bVertWriting = pCIDFont->IsVertWriting();
     } else {
         bVertWriting = m_Font.IsVertical();
     }
     return bVertWriting;
 }
 CFX_ByteString CPDF_Font::GetFontTypeName() const
 {
@@ skipping 78 matching lines @@
         FX_DWORD charcode = CharCodeFromUnicode(src_buf[src_pos]);
         dest_pos += AppendChar(dest_buf + dest_pos, charcode);
     }
     result.ReleaseBuffer(dest_pos);
     return result;
 }
 void CPDF_Font::LoadFontDescriptor(CPDF_Dictionary* pFontDesc)
 {
     m_Flags = pFontDesc->GetInteger(FX_BSTRC("Flags"), PDFFONT_NONSYMBOLIC);
     int ItalicAngle = 0;
-    FX_BOOL bExistItalicAngle = FALSE;
+    bool bExistItalicAngle = false;
     if (pFontDesc->KeyExist(FX_BSTRC("ItalicAngle"))) {
         ItalicAngle = pFontDesc->GetInteger(FX_BSTRC("ItalicAngle"));
-        bExistItalicAngle = TRUE;
+        bExistItalicAngle = true;
     }
     if (ItalicAngle < 0) {
         m_Flags |= PDFFONT_ITALIC;
         m_ItalicAngle = ItalicAngle;
     }
-    FX_BOOL bExistStemV = FALSE;
+    bool bExistStemV = false;
     if (pFontDesc->KeyExist(FX_BSTRC("StemV"))) {
         m_StemV = pFontDesc->GetInteger(FX_BSTRC("StemV"));
-        bExistStemV = TRUE;
+        bExistStemV = true;
     }
-    FX_BOOL bExistAscent = FALSE;
+    bool bExistAscent = false;
     if (pFontDesc->KeyExist(FX_BSTRC("Ascent"))) {
         m_Ascent = pFontDesc->GetInteger(FX_BSTRC("Ascent"));
-        bExistAscent = TRUE;
+        bExistAscent = true;
     }
-    FX_BOOL bExistDescent = FALSE;
+    bool bExistDescent = false;
     if (pFontDesc->KeyExist(FX_BSTRC("Descent"))) {
         m_Descent = pFontDesc->GetInteger(FX_BSTRC("Descent"));
-        bExistDescent = TRUE;
+        bExistDescent = true;
     }
-    FX_BOOL bExistCapHeight = FALSE;
+    bool bExistCapHeight = false;
     if (pFontDesc->KeyExist(FX_BSTRC("CapHeight"))) {
-        bExistCapHeight = TRUE;
+        bExistCapHeight = true;
     }
     if (bExistItalicAngle && bExistAscent && bExistCapHeight && bExistDescent && bExistStemV) {
         m_Flags |= PDFFONT_USEEXTERNATTR;
     }
     if (m_Descent > 10) {
         m_Descent = -m_Descent;
     }
     CPDF_Array* pBBox = pFontDesc->GetArray(FX_BSTRC("FontBBox"));
     if (pBBox) {
         m_FontBBox.left = pBBox->GetInteger(0);
@@ skipping 33 matching lines @@
 {
     if (m_FontBBox.top == 0 && m_FontBBox.bottom == 0 && m_FontBBox.left == 0 && m_FontBBox.right == 0) {
         if (m_Font.m_Face) {
             m_FontBBox.left = TT2PDF(FXFT_Get_Face_xMin(m_Font.m_Face), m_Font.m_Face);
             m_FontBBox.bottom = TT2PDF(FXFT_Get_Face_yMin(m_Font.m_Face), m_Font.m_Face);
             m_FontBBox.right = TT2PDF(FXFT_Get_Face_xMax(m_Font.m_Face), m_Font.m_Face);
             m_FontBBox.top = TT2PDF(FXFT_Get_Face_yMax(m_Font.m_Face), m_Font.m_Face);
             m_Ascent = TT2PDF(FXFT_Get_Face_Ascender(m_Font.m_Face), m_Font.m_Face);
             m_Descent = TT2PDF(FXFT_Get_Face_Descender(m_Font.m_Face), m_Font.m_Face);
         } else {
-            FX_BOOL bFirst = TRUE;
+            bool bFirst = true;
             for (int i = 0; i < 256; i ++) {
                 FX_RECT rect;
                 GetCharBBox(i, rect);
                 if (rect.left == rect.right) {
                     continue;
                 }
                 if (bFirst) {
                     m_FontBBox = rect;
-                    bFirst = FALSE;
+                    bFirst = false;
                 } else {
                     if (m_FontBBox.top < rect.top) {
                         m_FontBBox.top = rect.top;
                     }
                     if (m_FontBBox.right < rect.right) {
                         m_FontBBox.right = rect.right;
                     }
                     if (m_FontBBox.left > rect.left) {
                         m_FontBBox.left = rect.left;
                     }
@@ skipping 15 matching lines @@
         GetCharBBox('g', rect);
         if (rect.bottom == rect.top) {
             m_Descent = m_FontBBox.bottom;
         } else {
             m_Descent = rect.bottom;
         }
     }
 }
 void CPDF_Font::LoadUnicodeMap()
 {
-    m_bToUnicodeLoaded = TRUE;
+    m_bToUnicodeLoaded = true;
     CPDF_Stream* pStream = m_pFontDict->GetStream(FX_BSTRC("ToUnicode"));
     if (pStream == NULL) {
         return;
     }
     m_pToUnicodeMap = new CPDF_ToUnicodeMap;
     m_pToUnicodeMap->Load(pStream);
 }
 int CPDF_Font::GetStringWidth(const FX_CHAR* pString, int size)
 {
     int offset = 0;
@@ skipping 84 matching lines @@
         pFont = new CPDF_Type1Font;
     }
     pFont->m_pFontDict = pFontDict;
     pFont->m_pDocument = pDoc;
     if (!pFont->Load()) {
         delete pFont;
         return NULL;
     }
     return pFont;
 }
-FX_BOOL CPDF_Font::Load()
+bool CPDF_Font::Load()
 {
     if (m_pFontDict == NULL) {
-        return FALSE;
+        return false;
     }
     CFX_ByteString type = m_pFontDict->GetString(FX_BSTRC("Subtype"));
     m_BaseFont = m_pFontDict->GetString(FX_BSTRC("BaseFont"));
     if (type == FX_BSTRC("MMType1")) {
         type = FX_BSTRC("Type1");
     }
     return _Load();
 }
 static CFX_WideString _FontMap_GetWideString(CFX_CharMap* pMap, const CFX_ByteString& bytestr)
 {
@@ skipping 133 matching lines @@
         return result;
     }
     if (buf[0] == '(') {
     }
     return result;
 }
 void CPDF_ToUnicodeMap::Load(CPDF_Stream* pStream)
 {
     int CIDSet = 0;
     CPDF_StreamAcc stream;
-    stream.LoadAllData(pStream, FALSE);
+    stream.LoadAllData(pStream, false);
     CPDF_SimpleParser parser(stream.GetData(), stream.GetSize());
     m_Map.EstimateSize(stream.GetSize() / 8, 1024);
     while (1) {
         CFX_ByteStringC word = parser.GetWord();
         if (word.IsEmpty()) {
             break;
         }
         if (word == FX_BSTRC("beginbfchar")) {
             while (1) {
                 word = parser.GetWord();
@@ skipping 75 matching lines @@
             CIDSet = CIDSET_KOREA1;
         } else if (word == FX_BSTRC("/Adobe-Japan1-UCS2")) {
             CIDSet = CIDSET_JAPAN1;
         } else if (word == FX_BSTRC("/Adobe-CNS1-UCS2")) {
             CIDSet = CIDSET_CNS1;
         } else if (word == FX_BSTRC("/Adobe-GB1-UCS2")) {
             CIDSet = CIDSET_GB1;
         }
     }
     if (CIDSet) {
-        m_pBaseMap = CPDF_ModuleMgr::Get()->GetPageModule()->GetFontGlobals()->m_CMapManager.GetCID2UnicodeMap(CIDSet, FALSE);
+        m_pBaseMap = CPDF_ModuleMgr::Get()->GetPageModule()->GetFontGlobals()->m_CMapManager.GetCID2UnicodeMap(CIDSet, false);
     } else {
         m_pBaseMap = NULL;
     }
 }
-static FX_BOOL GetPredefinedEncoding(int& basemap, const CFX_ByteString& value)
+static bool GetPredefinedEncoding(int& basemap, const CFX_ByteString& value)
 {
     if (value == FX_BSTRC("WinAnsiEncoding")) {
         basemap = PDFFONT_ENCODING_WINANSI;
     } else if (value == FX_BSTRC("MacRomanEncoding")) {
         basemap = PDFFONT_ENCODING_MACROMAN;
     } else if (value == FX_BSTRC("MacExpertEncoding")) {
         basemap = PDFFONT_ENCODING_MACEXPERT;
     } else if (value == FX_BSTRC("PDFDocEncoding")) {
         basemap = PDFFONT_ENCODING_PDFDOC;
     } else {
-        return FALSE;
+        return false;
     }
-    return TRUE;
+    return true;
 }
 void CPDF_Font::LoadPDFEncoding(CPDF_Object* pEncoding, int& iBaseEncoding, CFX_ByteString*& pCharNames,
-                                FX_BOOL bEmbedded, FX_BOOL bTrueType)
+                                bool bEmbedded, bool bTrueType)
 {
     if (pEncoding == NULL) {
         if (m_BaseFont == FX_BSTRC("Symbol")) {
             iBaseEncoding = bTrueType ? PDFFONT_ENCODING_MS_SYMBOL : PDFFONT_ENCODING_ADOBE_SYMBOL;
         } else if (!bEmbedded && iBaseEncoding == PDFFONT_ENCODING_BUILTIN) {
             iBaseEncoding = PDFFONT_ENCODING_WINANSI;
         }
         return;
     }
     if (pEncoding->GetType() == PDFOBJ_NAME) {
@@ skipping 41 matching lines @@
         if (pElement->GetType() == PDFOBJ_NAME) {
             if (cur_code < 256) {
                 pCharNames[cur_code] = ((CPDF_Name*)pElement)->GetString();
             }
             cur_code ++;
         } else {
             cur_code = pElement->GetInteger();
         }
     }
 }
-FX_BOOL CPDF_Font::IsStandardFont() const
+bool CPDF_Font::IsStandardFont() const
 {
     if (m_FontType != PDFFONT_TYPE1) {
-        return FALSE;
+        return false;
     }
     if (m_pFontFile != NULL) {
-        return FALSE;
+        return false;
     }
     if (((CPDF_Type1Font*)this)->GetBase14Font() < 0) {
-        return FALSE;
+        return false;
     }
-    return TRUE;
+    return true;
 }
 CPDF_SimpleFont::CPDF_SimpleFont(int fonttype) : CPDF_Font(fonttype)
 {
     FXSYS_memset(m_CharBBox, 0xff, sizeof m_CharBBox);
     FXSYS_memset(m_CharWidth, 0xff, sizeof m_CharWidth);
     FXSYS_memset(m_GlyphIndex, 0xff, sizeof m_GlyphIndex);
     FXSYS_memset(m_ExtGID, 0xff, sizeof m_ExtGID);
     m_pCharNames = NULL;
     m_BaseEncoding = PDFFONT_ENCODING_BUILTIN;
 }
 CPDF_SimpleFont::~CPDF_SimpleFont()
 {
     delete[] m_pCharNames;
 }
-int CPDF_SimpleFont::GlyphFromCharCode(FX_DWORD charcode, FX_BOOL *pVertGlyph)
+int CPDF_SimpleFont::GlyphFromCharCode(FX_DWORD charcode, bool *pVertGlyph)
 {
     if (pVertGlyph) {
-        *pVertGlyph = FALSE;
+        *pVertGlyph = false;
     }
     if (charcode > 0xff) {
         return -1;
     }
     int index = m_GlyphIndex[(uint8_t)charcode];
     if (index == 0xffff) {
         return -1;
     }
     return index;
 }
@@ skipping 71 matching lines @@
         name = pCharNames[charcode];
     }
     if ((name == NULL || name[0] == 0) && iBaseEncoding) {
         name = PDF_CharNameFromPredefinedCharSet(iBaseEncoding, charcode);
     }
     if (name == NULL || name[0] == 0) {
         return NULL;
     }
     return name;
 }
-FX_BOOL CPDF_SimpleFont::LoadCommon()
+bool CPDF_SimpleFont::LoadCommon()
 {
     CPDF_Dictionary* pFontDesc = m_pFontDict->GetDict(FX_BSTRC("FontDescriptor"));
     if (pFontDesc) {
         LoadFontDescriptor(pFontDesc);
     }
     CPDF_Array* pWidthArray = m_pFontDict->GetArray(FX_BSTRC("Widths"));
     int width_start = 0, width_end = -1;
-    m_bUseFontWidth = TRUE;
+    m_bUseFontWidth = true;
     if (pWidthArray) {
-        m_bUseFontWidth = FALSE;
+        m_bUseFontWidth = false;
         if (pFontDesc && pFontDesc->KeyExist(FX_BSTRC("MissingWidth"))) {
             int MissingWidth = pFontDesc->GetInteger(FX_BSTRC("MissingWidth"));
             for (int i = 0; i < 256; i ++) {
                 m_CharWidth[i] = MissingWidth;
             }
         }
         width_start = m_pFontDict->GetInteger(FX_BSTRC("FirstChar"), 0);
         width_end = m_pFontDict->GetInteger(FX_BSTRC("LastChar"), 0);
         if (width_start >= 0 && width_start <= 255) {
             if (width_end <= 0 || width_end >= width_start + (int)pWidthArray->GetCount()) {
@@ skipping 16 matching lines @@
     }
     if (!(m_Flags & PDFFONT_SYMBOLIC)) {
         m_BaseEncoding = PDFFONT_ENCODING_STANDARD;
     }
     CPDF_Object* pEncoding = m_pFontDict->GetElementValue(FX_BSTRC("Encoding"));
     LoadPDFEncoding(pEncoding, m_BaseEncoding, m_pCharNames, m_pFontFile != NULL, m_Font.IsTTFont());
     LoadGlyphMap();
     delete[] m_pCharNames;
     m_pCharNames = NULL;
     if (m_Font.m_Face == NULL) {
-        return TRUE;
+        return true;
     }
     if (m_Flags & PDFFONT_ALLCAP) {
         unsigned char lowercases[] = {'a', 'z', 0xe0, 0xf6, 0xf8, 0xfd};
         for (size_t range = 0; range < sizeof lowercases / 2; range ++) {
             for (int i = lowercases[range * 2]; i <= lowercases[range * 2 + 1]; i ++) {
                 if (m_GlyphIndex[i] != 0xffff && m_pFontFile != NULL) {
                     continue;
                 }
                 m_GlyphIndex[i] = m_GlyphIndex[i - 32];
                 if (m_CharWidth[i - 32]) {
                     m_CharWidth[i] = m_CharWidth[i - 32];
                     m_CharBBox[i] = m_CharBBox[i - 32];
                 }
             }
         }
     }
     CheckFontMetrics();
-    return TRUE;
+    return true;
 }
 void CPDF_SimpleFont::LoadSubstFont()
 {
     if (!m_bUseFontWidth && !(m_Flags & PDFFONT_FIXEDPITCH)) {
         int width = 0, i;
         for (i = 0; i < 256; i ++) {
             if (m_CharWidth[i] == 0 || m_CharWidth[i] == 0xffff) {
                 continue;
             }
             if (width == 0) {
                 width = m_CharWidth[i];
             } else if (width != m_CharWidth[i]) {
                 break;
             }
         }
         if (i == 256 && width) {
             m_Flags |= PDFFONT_FIXEDPITCH;
         }
     }
     int weight = m_StemV < 140 ? m_StemV * 5 : (m_StemV * 4 + 140);
     m_Font.LoadSubst(m_BaseFont, IsFontType(PDFFONT_TRUETYPE), m_Flags, weight, m_ItalicAngle, 0);
     if (m_Font.m_pSubstFont->m_SubstFlags & FXFONT_SUBST_NONSYMBOL) {
     }
 }
-FX_BOOL CPDF_SimpleFont::IsUnicodeCompatible() const
+bool CPDF_SimpleFont::IsUnicodeCompatible() const
 {
     return m_BaseEncoding != PDFFONT_ENCODING_BUILTIN && m_BaseEncoding != PDFFONT_ENCODING_ADOBE_SYMBOL &&
            m_BaseEncoding != PDFFONT_ENCODING_ZAPFDINGBATS;
 }
 CPDF_Type1Font::CPDF_Type1Font() : CPDF_SimpleFont(PDFFONT_TYPE1)
 {
     m_Base14Font = -1;
 }
-FX_BOOL CPDF_Type1Font::_Load()
+bool CPDF_Type1Font::_Load()
 {
     m_Base14Font = _PDF_GetStandardFontName(m_BaseFont);
     if (m_Base14Font >= 0) {
         CPDF_Dictionary* pFontDesc = m_pFontDict->GetDict(FX_BSTRC("FontDescriptor"));
         if (pFontDesc && pFontDesc->KeyExist(FX_BSTRC("Flags"))) {
             m_Flags = pFontDesc->GetInteger(FX_BSTRC("Flags"));
         } else {
             m_Flags = m_Base14Font >= 12 ? PDFFONT_SYMBOLIC : PDFFONT_NONSYMBOLIC;
         }
         if (m_Base14Font < 4)
             for (int i = 0; i < 256; i ++) {
                 m_CharWidth[i] = 600;
             }
         if (m_Base14Font == 12) {
             m_BaseEncoding = PDFFONT_ENCODING_ADOBE_SYMBOL;
         } else if (m_Base14Font == 13) {
             m_BaseEncoding = PDFFONT_ENCODING_ZAPFDINGBATS;
         } else if (m_Flags & PDFFONT_NONSYMBOLIC) {
             m_BaseEncoding = PDFFONT_ENCODING_STANDARD;
         }
     }
     return LoadCommon();
 }
-static FX_BOOL FT_UseType1Charmap(FXFT_Face face)
+static bool FT_UseType1Charmap(FXFT_Face face)
 {
     if (FXFT_Get_Face_CharmapCount(face) == 0) {
-        return FALSE;
+        return false;
     }
     if (FXFT_Get_Face_CharmapCount(face) == 1 &&
             FXFT_Get_Charmap_Encoding(FXFT_Get_Face_Charmaps(face)[0]) == FXFT_ENCODING_UNICODE) {
-        return FALSE;
+        return false;
     }
     if (FXFT_Get_Charmap_Encoding(FXFT_Get_Face_Charmaps(face)[0]) == FXFT_ENCODING_UNICODE) {
         FXFT_Set_Charmap(face, FXFT_Get_Face_Charmaps(face)[1]);
     } else {
         FXFT_Set_Charmap(face, FXFT_Get_Face_Charmaps(face)[0]);
     }
-    return TRUE;
+    return true;
 }
 extern FX_WCHAR FT_UnicodeFromCharCode(int encoding, FX_DWORD charcode);
 #if _FXM_PLATFORM_  == _FXM_PLATFORM_APPLE_
 #include "../../fxge/apple/apple_int.h"
 #endif
 int CPDF_Type1Font::GlyphFromCharCodeExt(FX_DWORD charcode)
 {
     if (charcode > 0xff) {
         return -1;
     }
@@ skipping 31 matching lines @@
     }
     return NULL;
 }
 #endif
 void CPDF_Type1Font::LoadGlyphMap()
 {
     if (m_Font.m_Face == NULL) {
         return;
     }
 #if _FXM_PLATFORM_  == _FXM_PLATFORM_APPLE_
-    FX_BOOL bCoreText = TRUE;
+    bool bCoreText = true;
     CQuartz2D & quartz2d = ((CApplePlatform *) CFX_GEModule::Get()->GetPlatformData())->_quartz2d;
     if (!m_Font.m_pPlatformFont) {
         if (m_Font.GetPsName() == CFX_WideString::FromLocal("DFHeiStd-W5")) {
-            bCoreText = FALSE;
+            bCoreText = false;
         }
         m_Font.m_pPlatformFont = quartz2d.CreateFont(m_Font.m_pFontData, m_Font.m_dwSize);
         if (NULL == m_Font.m_pPlatformFont) {
-            bCoreText = FALSE;
+            bCoreText = false;
         }
     }
 #endif
     if (!IsEmbedded() && (m_Base14Font < 12) && m_Font.IsTTFont()) {
         if (FT_UseTTCharmap(m_Font.m_Face, 3, 0)) {
-            FX_BOOL bGotOne = FALSE;
+            bool bGotOne = false;
             for (int charcode = 0; charcode < 256; charcode ++) {
                 const uint8_t prefix[4] = {0x00, 0xf0, 0xf1, 0xf2};
                 for (int j = 0; j < 4; j ++) {
                     FX_WORD unicode = prefix[j] * 256 + charcode;
                     m_GlyphIndex[charcode] = FXFT_Get_Char_Index(m_Font.m_Face, unicode);
 #if _FXM_PLATFORM_  == _FXM_PLATFORM_APPLE_
                     FX_CHAR name_glyph[256];
                     FXFT_Get_Glyph_Name(m_Font.m_Face, m_GlyphIndex[charcode], name_glyph, 256);
                     name_glyph[255] = 0;
                     CFStringRef name_ct = CFStringCreateWithCStringNoCopy(kCFAllocatorDefault, name_glyph, kCFStringEncodingASCII, kCFAllocatorNull);
                     m_ExtGID[charcode] = CGFontGetGlyphWithGlyphName((CGFontRef)m_Font.m_pPlatformFont, name_ct);
                     if (name_ct) {
                         CFRelease(name_ct);
                     }
 #endif
                     if (m_GlyphIndex[charcode]) {
-                        bGotOne = TRUE;
+                        bGotOne = true;
                         break;
                     }
                 }
             }
             if (bGotOne) {
 #if _FXM_PLATFORM_  == _FXM_PLATFORM_APPLE_
                 if (!bCoreText) {
                     FXSYS_memcpy(m_ExtGID, m_GlyphIndex, 256);
                 }
 #endif
@@ skipping 73 matching lines @@
                     m_Encoding.m_Unicodes[charcode] = unicode;
                     CFStringRef name_ct = CFStringCreateWithCStringNoCopy(kCFAllocatorDefault, name_glyph, kCFStringEncodingASCII, kCFAllocatorNull);
                     m_ExtGID[charcode] = CGFontGetGlyphWithGlyphName((CGFontRef)m_Font.m_pPlatformFont, name_ct);
                     if (name_ct) {
                         CFRelease(name_ct);
                     }
                 }
             }
             return;
         }
-        FX_BOOL bUnicode = FALSE;
+        bool bUnicode = false;
         if (0 == FXFT_Select_Charmap(m_Font.m_Face, FXFT_ENCODING_UNICODE)) {
-            bUnicode = TRUE;
+            bUnicode = true;
         }
         for (int charcode = 0; charcode < 256; charcode ++) {
             const FX_CHAR* name = GetAdobeCharName(m_BaseEncoding, m_pCharNames, charcode);
             if (name == NULL) {
                 continue;
             }
             m_Encoding.m_Unicodes[charcode] = PDF_UnicodeFromAdobeName(name);
             const FX_CHAR* pStrUnicode = _GlyphNameRemap(name);
             if (pStrUnicode && 0 == FXFT_Get_Name_Index(m_Font.m_Face, (char*)name)) {
                 name = pStrUnicode;
@@ skipping 55 matching lines @@
                 }
             }
         }
 #if _FXM_PLATFORM_  == _FXM_PLATFORM_APPLE_
         if (!bCoreText) {
             FXSYS_memcpy(m_ExtGID, m_GlyphIndex, 256);
         }
 #endif
         return;
     }
-    FX_BOOL bUnicode = FALSE;
+    bool bUnicode = false;
     if (0 == FXFT_Select_Charmap(m_Font.m_Face, FXFT_ENCODING_UNICODE)) {
-        bUnicode = TRUE;
+        bUnicode = true;
     }
     for (int charcode = 0; charcode < 256; charcode ++) {
         const FX_CHAR* name = GetAdobeCharName(m_BaseEncoding, m_pCharNames, charcode);
         if (name == NULL) {
             continue;
         }
         m_Encoding.m_Unicodes[charcode] = PDF_UnicodeFromAdobeName(name);
         m_GlyphIndex[charcode] = FXFT_Get_Name_Index(m_Font.m_Face, (char*)name);
         if (m_GlyphIndex[charcode] == 0) {
             if (FXSYS_strcmp(name, ".notdef") != 0 && FXSYS_strcmp(name, "space") != 0) {
@@ skipping 25 matching lines @@
 CPDF_FontEncoding::CPDF_FontEncoding(int PredefinedEncoding)
 {
     const FX_WORD* pSrc = PDF_UnicodesForPredefinedCharSet(PredefinedEncoding);
     if (!pSrc) {
         FXSYS_memset(m_Unicodes, 0, sizeof(m_Unicodes));
     } else
         for (int i = 0; i < 256; i++) {
             m_Unicodes[i] = pSrc[i];
         }
 }
-FX_BOOL CPDF_FontEncoding::IsIdentical(CPDF_FontEncoding* pAnother) const
+bool CPDF_FontEncoding::IsIdentical(CPDF_FontEncoding* pAnother) const
 {
     return FXSYS_memcmp(m_Unicodes, pAnother->m_Unicodes, sizeof(m_Unicodes)) == 0;
 }
 CPDF_Object* CPDF_FontEncoding::Realize()
 {
     int predefined = 0;
     for (int cs = PDFFONT_ENCODING_WINANSI; cs < PDFFONT_ENCODING_ZAPFDINGBATS; cs ++) {
         const FX_WORD* pSrc = PDF_UnicodesForPredefinedCharSet(cs);
-        FX_BOOL match = TRUE;
+        bool match = true;
         for (int i = 0; i < 256; ++i) {
             if (m_Unicodes[i] != pSrc[i]) {
-                match = FALSE;
+                match = false;
                 break;
             }
         }
         if (match) {
             predefined = cs;
             break;
         }
     }
     if (predefined) {
         if (predefined == PDFFONT_ENCODING_WINANSI) {
@@ skipping 17 matching lines @@
         }
         pDiff->Add(CPDF_Number::Create(i));
         pDiff->Add(CPDF_Name::Create(PDF_AdobeNameFromUnicode(m_Unicodes[i])));
     }
     pDict->SetAt(FX_BSTRC("Differences"), pDiff);
     return pDict;
 }
 CPDF_TrueTypeFont::CPDF_TrueTypeFont() : CPDF_SimpleFont(PDFFONT_TRUETYPE)
 {
 }
-FX_BOOL CPDF_TrueTypeFont::_Load()
+bool CPDF_TrueTypeFont::_Load()
 {
     return LoadCommon();
 }
 void CPDF_TrueTypeFont::LoadGlyphMap()
 {
     if (m_Font.m_Face == NULL) {
         return;
     }
     int baseEncoding = m_BaseEncoding;
     if (m_pFontFile && m_Font.m_Face->num_charmaps > 0
             && (baseEncoding == PDFFONT_ENCODING_MACROMAN || baseEncoding == PDFFONT_ENCODING_WINANSI)
             && (m_Flags & PDFFONT_SYMBOLIC)) {
-        FX_BOOL bSupportWin = FALSE;
-        FX_BOOL bSupportMac = FALSE;
+        bool bSupportWin = false;
+        bool bSupportMac = false;
         for (int i = 0; i < FXFT_Get_Face_CharmapCount(m_Font.m_Face); i++) {
             int platform_id = FXFT_Get_Charmap_PlatformID(FXFT_Get_Face_Charmaps(m_Font.m_Face)[i]);
             if (platform_id == 0 || platform_id == 3) {
-                bSupportWin = TRUE;
+                bSupportWin = true;
             } else if (platform_id == 0 || platform_id == 1) {
-                bSupportMac = TRUE;
+                bSupportMac = true;
             }
         }
         if (baseEncoding == PDFFONT_ENCODING_WINANSI && !bSupportWin) {
             baseEncoding = bSupportMac ? PDFFONT_ENCODING_MACROMAN : PDFFONT_ENCODING_BUILTIN;
         } else if (baseEncoding == PDFFONT_ENCODING_MACROMAN && !bSupportMac) {
             baseEncoding = bSupportWin ? PDFFONT_ENCODING_WINANSI : PDFFONT_ENCODING_BUILTIN;
         }
     }
     if (((baseEncoding == PDFFONT_ENCODING_MACROMAN || baseEncoding == PDFFONT_ENCODING_WINANSI)
             && m_pCharNames == NULL) || (m_Flags & PDFFONT_NONSYMBOLIC)) {
         if (!FXFT_Has_Glyph_Names(m_Font.m_Face) && (!m_Font.m_Face->num_charmaps || !m_Font.m_Face->charmaps)) {
             int nStartChar = m_pFontDict->GetInteger(FX_BSTRC("FirstChar"));
             if(nStartChar < 0 || nStartChar > 255)
                 return;
 
             int charcode = 0;
             for (; charcode < nStartChar; charcode ++) {
                 m_GlyphIndex[charcode] = 0;
             }
             FX_WORD nGlyph = charcode - nStartChar + 3;
             for (; charcode < 256; charcode ++, nGlyph ++) {
                 m_GlyphIndex[charcode] = nGlyph;
             }
             return;
         }
-        FX_BOOL bMSUnicode = FT_UseTTCharmap(m_Font.m_Face, 3, 1);
-        FX_BOOL bMacRoman = FALSE, bMSSymbol = FALSE;
+        bool bMSUnicode = FT_UseTTCharmap(m_Font.m_Face, 3, 1);
+        bool bMacRoman = false, bMSSymbol = false;
         if (!bMSUnicode) {
             if (m_Flags & PDFFONT_NONSYMBOLIC) {
                 bMacRoman = FT_UseTTCharmap(m_Font.m_Face, 1, 0);
                 bMSSymbol = !bMacRoman && FT_UseTTCharmap(m_Font.m_Face, 3, 0);
             } else {
                 bMSSymbol = FT_UseTTCharmap(m_Font.m_Face, 3, 0);
                 bMacRoman = !bMSSymbol && FT_UseTTCharmap(m_Font.m_Face, 1, 0);
             }
         }
-        FX_BOOL bToUnicode = m_pFontDict->KeyExist(FX_BSTRC("ToUnicode"));
+        bool bToUnicode = m_pFontDict->KeyExist(FX_BSTRC("ToUnicode"));
         for (int charcode = 0; charcode < 256; charcode ++) {
             const FX_CHAR* name = GetAdobeCharName(baseEncoding, m_pCharNames, charcode);
             if (name == NULL) {
                 m_GlyphIndex[charcode] = m_pFontFile ? FXFT_Get_Char_Index(m_Font.m_Face, charcode) : -1;
                 continue;
             }
             m_Encoding.m_Unicodes[charcode] = PDF_UnicodeFromAdobeName(name);
             if (bMSSymbol) {
                 const uint8_t prefix[4] = {0x00, 0xf0, 0xf1, 0xf2};
                 for (int j = 0; j < 4; j ++) {
@@ skipping 32 matching lines @@
                             m_GlyphIndex[charcode] = FXFT_Get_Char_Index(m_Font.m_Face, charcode);
                         }
                     }
                 }
             }
         }
         return;
     }
     if (FT_UseTTCharmap(m_Font.m_Face, 3, 0)) {
         const uint8_t prefix[4] = {0x00, 0xf0, 0xf1, 0xf2};
-        FX_BOOL bGotOne = FALSE;
+        bool bGotOne = false;
         for (int charcode = 0; charcode < 256; charcode ++) {
             for (int j = 0; j < 4; j ++) {
                 FX_WORD unicode = prefix[j] * 256 + charcode;
                 m_GlyphIndex[charcode] = FXFT_Get_Char_Index(m_Font.m_Face, unicode);
                 if (m_GlyphIndex[charcode]) {
-                    bGotOne = TRUE;
+                    bGotOne = true;
                     break;
                 }
             }
         }
         if (bGotOne) {
             if (baseEncoding != PDFFONT_ENCODING_BUILTIN) {
                 for (int charcode = 0; charcode < 256; charcode ++) {
                     const FX_CHAR* name = GetAdobeCharName(baseEncoding, m_pCharNames, charcode);
                     if (name == NULL) {
                         continue;
                     }
                     m_Encoding.m_Unicodes[charcode] = PDF_UnicodeFromAdobeName(name);
                 }
             } else if (FT_UseTTCharmap(m_Font.m_Face, 1, 0)) {
                 for (int charcode = 0; charcode < 256; charcode ++) {
                     m_Encoding.m_Unicodes[charcode] = FT_UnicodeFromCharCode(FXFT_ENCODING_APPLE_ROMAN, charcode);
                 }
             }
             return;
         }
     }
     if (FT_UseTTCharmap(m_Font.m_Face, 1, 0)) {
-        FX_BOOL bGotOne = FALSE;
+        bool bGotOne = false;
         for (int charcode = 0; charcode < 256; charcode ++) {
             m_GlyphIndex[charcode] = FXFT_Get_Char_Index(m_Font.m_Face, charcode);
             m_Encoding.m_Unicodes[charcode] = FT_UnicodeFromCharCode(FXFT_ENCODING_APPLE_ROMAN, charcode);
             if (m_GlyphIndex[charcode]) {
-                bGotOne = TRUE;
+                bGotOne = true;
             }
         }
         if (m_pFontFile || bGotOne) {
             return;
         }
     }
     if (FXFT_Select_Charmap(m_Font.m_Face, FXFT_ENCODING_UNICODE) == 0) {
-        FX_BOOL bGotOne = FALSE;
+        bool bGotOne = false;
         const FX_WORD* pUnicodes = PDF_UnicodesForPredefinedCharSet(baseEncoding);
         for (int charcode = 0; charcode < 256; charcode ++) {
             if (m_pFontFile == NULL) {
                 const FX_CHAR* name = GetAdobeCharName(0, m_pCharNames, charcode);
                 if (name != NULL) {
                     m_Encoding.m_Unicodes[charcode] = PDF_UnicodeFromAdobeName(name);
                 } else if (pUnicodes) {
                     m_Encoding.m_Unicodes[charcode] = pUnicodes[charcode];
                 }
             } else {
                 m_Encoding.m_Unicodes[charcode] = charcode;
             }
             m_GlyphIndex[charcode] = FXFT_Get_Char_Index(m_Font.m_Face, m_Encoding.m_Unicodes[charcode]);
             if (m_GlyphIndex[charcode]) {
-                bGotOne = TRUE;
+                bGotOne = true;
             }
         }
         if (bGotOne) {
             return;
         }
     }
     for (int charcode = 0; charcode < 256; charcode ++) {
         m_GlyphIndex[charcode] = charcode;
     }
 }
@@ skipping 13 matching lines @@
     }
     m_CacheMap.RemoveAll();
     pos = m_DeletedMap.GetStartPosition();
     while (pos) {
         void* key;
         void* value;
         m_DeletedMap.GetNextAssoc(pos, key, value);
         delete (CPDF_Type3Char*)key;
     }
 }
-FX_BOOL CPDF_Type3Font::_Load()
+bool CPDF_Type3Font::_Load()
 {
     m_pFontResources = m_pFontDict->GetDict(FX_BSTRC("Resources"));
     CPDF_Array* pMatrix = m_pFontDict->GetArray(FX_BSTRC("FontMatrix"));
     FX_FLOAT xscale = 1.0f, yscale = 1.0f;
     if (pMatrix) {
         m_FontMatrix = pMatrix->GetMatrix();
         xscale = m_FontMatrix.a;
         yscale = m_FontMatrix.d;
     }
     CPDF_Array* pBBox = m_pFontDict->GetArray(FX_BSTRC("FontBBox"));
@@ skipping 13 matching lines @@
         if (StartChar + count > 256) {
             count = 256 - StartChar;
         }
         for (FX_DWORD i = 0; i < count; i ++) {
             m_CharWidthL[StartChar + i] = FXSYS_round(FXSYS_Mul(pWidthArray->GetNumber(i), xscale) * 1000);
         }
     }
     m_pCharProcs = m_pFontDict->GetDict(FX_BSTRC("CharProcs"));
     CPDF_Object* pEncoding = m_pFontDict->GetElementValue(FX_BSTRC("Encoding"));
     if (pEncoding) {
-        LoadPDFEncoding(pEncoding, m_BaseEncoding, m_pCharNames, FALSE, FALSE);
+        LoadPDFEncoding(pEncoding, m_BaseEncoding, m_pCharNames, false, false);
         if (m_pCharNames) {
             for (int i = 0; i < 256; i ++) {
                 m_Encoding.m_Unicodes[i] = PDF_UnicodeFromAdobeName(m_pCharNames[i]);
                 if (m_Encoding.m_Unicodes[i] == 0) {
                     m_Encoding.m_Unicodes[i] = i;
                 }
             }
         }
     }
-    return TRUE;
+    return true;
 }
 void CPDF_Type3Font::CheckType3FontMetrics()
 {
     CheckFontMetrics();
 }
 CPDF_Type3Char* CPDF_Type3Font::LoadChar(FX_DWORD charcode, int level)
 {
     if (level >= _FPDF_MAX_TYPE3_FORM_LEVEL_) {
         return NULL;
     }
@@ skipping 57 matching lines @@
     if (pChar == NULL) {
         rect.left = rect.right = rect.top = rect.bottom = 0;
         return;
     }
     rect = pChar->m_BBox;
 }
 CPDF_Type3Char::CPDF_Type3Char()
 {
     m_pForm = NULL;
     m_pBitmap = NULL;
-    m_bPageRequired = FALSE;
-    m_bColored = FALSE;
+    m_bPageRequired = false;
+    m_bColored = false;
 }
 CPDF_Type3Char::~CPDF_Type3Char()
 {
     delete m_pForm;
     delete m_pBitmap;
 }