FX Bool considered harmful, part 3

core/src/fxge/ge/fx_ge_text.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/fxge/fx_ge.h"
 #include "../../../include/fxge/fx_freetype.h"
 #include "../../../include/fxcodec/fx_codec.h"
 #include "text_int.h"
@@ skipping 28 matching lines @@
 
 private:
     FT_Face m_Face;
 };
 
 }
 
 FX_RECT FXGE_GetGlyphsBBox(FXTEXT_GLYPHPOS* pGlyphAndPos, int nChars, int anti_alias, FX_FLOAT retinaScaleX, FX_FLOAT retinaScaleY)
 {
     FX_RECT rect(0, 0, 0, 0);
-    FX_BOOL bStarted = FALSE;
+    bool bStarted = false;
     for (int iChar = 0; iChar < nChars; iChar ++) {
         FXTEXT_GLYPHPOS& glyph = pGlyphAndPos[iChar];
         const CFX_GlyphBitmap* pGlyph = glyph.m_pGlyph;
         if (pGlyph == NULL) {
             continue;
         }
         int char_left = glyph.m_OriginX + pGlyph->m_Left;
         int char_width = (int)(pGlyph->m_Bitmap.GetWidth() / retinaScaleX);
         if (anti_alias == FXFT_RENDER_MODE_LCD) {
             char_width /= 3;
         }
         int char_right = char_left + char_width;
         int char_top = glyph.m_OriginY - pGlyph->m_Top;
         int char_bottom = char_top + (int)(pGlyph->m_Bitmap.GetHeight() / retinaScaleY);
         if (!bStarted) {
             rect.left = char_left;
             rect.right = char_right;
             rect.top = char_top;
             rect.bottom = char_bottom;
-            bStarted = TRUE;
+            bStarted = true;
         } else {
             if (rect.left > char_left) {
                 rect.left = char_left;
             }
             if (rect.right < char_right) {
                 rect.right = char_right;
             }
             if (rect.top > char_top) {
                 rect.top = char_top;
             }
             if (rect.bottom < char_bottom) {
                 rect.bottom = char_bottom;
             }
         }
     }
     return rect;
 }
 static void _AdjustGlyphSpace(FXTEXT_GLYPHPOS* pGlyphAndPos, int nChars)
 {
     ASSERT(nChars > 1);
-    FX_BOOL bVertical = FALSE;
+    bool bVertical = false;
     if (pGlyphAndPos[nChars - 1].m_OriginX == pGlyphAndPos[0].m_OriginX) {
-        bVertical = TRUE;
+        bVertical = true;
     } else if (pGlyphAndPos[nChars - 1].m_OriginY != pGlyphAndPos[0].m_OriginY) {
         return;
     }
     int i = nChars - 1;
     int* next_origin = bVertical ? &pGlyphAndPos[i].m_OriginY : &pGlyphAndPos[i].m_OriginX;
     FX_FLOAT next_origin_f = bVertical ? pGlyphAndPos[i].m_fOriginY : pGlyphAndPos[i].m_fOriginX;
     for (i --; i > 0; i --) {
         int* this_origin = bVertical ? &pGlyphAndPos[i].m_OriginY : &pGlyphAndPos[i].m_OriginX;
         FX_FLOAT this_origin_f = bVertical ? pGlyphAndPos[i].m_fOriginY : pGlyphAndPos[i].m_fOriginX;
         int space = (*next_origin) - (*this_origin);
@@ skipping 45 matching lines @@
                   FXARGB_A(color);
         argb = FXARGB_MAKE(bgra[3], bgra[2], bgra[1], bgra[0]);
         return;
     }
     AdobeCMYK_to_sRGB1(FXSYS_GetCValue(color), FXSYS_GetMValue(color),
                        FXSYS_GetYValue(color), FXSYS_GetKValue(color),
                        bgra[2], bgra[1], bgra[0]);
     bgra[3] = (alpha_flag >> 24) ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXGETFLAG_ALPHA_STROKE(alpha_flag);
     argb = FXARGB_MAKE(bgra[3], bgra[2], bgra[1], bgra[0]);
 }
-FX_BOOL CFX_RenderDevice::DrawNormalText(int nChars, const FXTEXT_CHARPOS* pCharPos,
+bool CFX_RenderDevice::DrawNormalText(int nChars, const FXTEXT_CHARPOS* pCharPos,
         CFX_Font* pFont, CFX_FontCache* pCache,
         FX_FLOAT font_size, const CFX_AffineMatrix* pText2Device,
         FX_DWORD fill_color, FX_DWORD text_flags,
         int alpha_flag, void* pIccTransform)
 {
     int nativetext_flags = text_flags;
     if (m_DeviceClass != FXDC_DISPLAY) {
         if (!(text_flags & FXTEXT_PRINTGRAPHICTEXT)) {
 #if _FXM_PLATFORM_  == _FXM_PLATFORM_APPLE_
             if (!(text_flags & FXFONT_CIDFONT) && pFont->GetPsName().Find(CFX_WideString::FromLocal("+ZJHL")) == -1)
 #ifdef FOXIT_CHROME_BUILD
                 if (pFont->GetPsName() != CFX_WideString::FromLocal("CNAAJI+cmex10"))
 #endif
 #endif
                     if (m_pDeviceDriver->DrawDeviceText(nChars, pCharPos, pFont, pCache, pText2Device, font_size, fill_color, alpha_flag, pIccTransform)) {
-                        return TRUE;
+                        return true;
                     }
         }
         int alpha = FXGETFLAG_COLORTYPE(alpha_flag) ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXARGB_A(fill_color);
         if (alpha < 255) {
-            return FALSE;
+            return false;
         }
     } else if (!(text_flags & FXTEXT_NO_NATIVETEXT)) {
 #if _FXM_PLATFORM_  == _FXM_PLATFORM_APPLE_
         if (!(text_flags & FXFONT_CIDFONT))
 #ifdef FOXIT_CHROME_BUILD
             if (pFont->GetPsName() != CFX_WideString::FromLocal("CNAAJI+cmex10"))
 #endif
 #endif
                 if (m_pDeviceDriver->DrawDeviceText(nChars, pCharPos, pFont, pCache, pText2Device, font_size, fill_color, alpha_flag, pIccTransform)) {
-                    return TRUE;
+                    return true;
                 }
     }
     CFX_AffineMatrix char2device, deviceCtm, text2Device;
     if (pText2Device) {
         char2device = *pText2Device;
         text2Device = *pText2Device;
     }
     char2device.Scale(font_size, -font_size);
     if (FXSYS_fabs(char2device.a) + FXSYS_fabs(char2device.b) > 50 * 1.0f ||
             ((m_DeviceClass == FXDC_PRINTER && !m_pDeviceDriver->IsPSPrintDriver())
              && !(text_flags & FXTEXT_PRINTIMAGETEXT))) {
         if (pFont->GetFace() != NULL || (pFont->GetSubstFont()->m_SubstFlags & FXFONT_SUBST_GLYPHPATH)) {
             int nPathFlags = (text_flags & FXTEXT_NOSMOOTH) == 0 ? 0 : FXFILL_NOPATHSMOOTH;
             return DrawTextPath(nChars, pCharPos, pFont, pCache, font_size, pText2Device, NULL, NULL, fill_color, 0, NULL, nPathFlags, alpha_flag, pIccTransform);
         }
     }
     int anti_alias = FXFT_RENDER_MODE_MONO;
-    FX_BOOL bNormal = FALSE;
+    bool bNormal = false;
     if ((text_flags & FXTEXT_NOSMOOTH) == 0) {
         if (m_DeviceClass == FXDC_DISPLAY && m_bpp > 1) {
-            FX_BOOL bClearType;
+            bool bClearType;
             if (pFont->GetFace() == NULL && !(pFont->GetSubstFont()->m_SubstFlags & FXFONT_SUBST_CLEARTYPE)) {
-                bClearType = FALSE;
+                bClearType = false;
             } else {
                 bClearType = text_flags & FXTEXT_CLEARTYPE;
             }
             if ((m_RenderCaps & (FXRC_ALPHA_OUTPUT | FXRC_CMYK_OUTPUT))) {
                 anti_alias = FXFT_RENDER_MODE_LCD;
-                bNormal = TRUE;
+                bNormal = true;
             } else if (m_bpp < 16) {
                 anti_alias = FXFT_RENDER_MODE_NORMAL;
             } else {
-                if (bClearType == FALSE) {
+                if (bClearType == false) {
                     anti_alias = FXFT_RENDER_MODE_LCD;
-                    bNormal = TRUE;
+                    bNormal = true;
                 } else {
                     anti_alias = FXFT_RENDER_MODE_LCD;
                 }
             }
         }
     }
     if (pCache == NULL) {
         pCache = CFX_GEModule::Get()->GetFontCache();
     }
     CFX_FaceCache* pFaceCache = pCache->GetCachedFace(pFont);
@@ skipping 36 matching lines @@
         bmp_rect1.left--;
         bmp_rect1.top --;
         bmp_rect1.right ++;
         bmp_rect1.bottom ++;
     }
     FX_RECT bmp_rect(FXSYS_round((FX_FLOAT)(bmp_rect1.left) / scale_x), FXSYS_round((FX_FLOAT)(bmp_rect1.top) / scale_y),
                      FXSYS_round((FX_FLOAT)bmp_rect1.right / scale_x), FXSYS_round((FX_FLOAT)bmp_rect1.bottom / scale_y));
     bmp_rect.Intersect(m_ClipBox);
     if (bmp_rect.IsEmpty()) {
         FX_Free(pGlyphAndPos);
-        return TRUE;
+        return true;
     }
     int pixel_width = FXSYS_round(bmp_rect.Width() * scale_x);
     int pixel_height = FXSYS_round(bmp_rect.Height() * scale_y);
     int pixel_left = FXSYS_round(bmp_rect.left * scale_x);
     int pixel_top = FXSYS_round(bmp_rect.top * scale_y);
     if (anti_alias == FXFT_RENDER_MODE_MONO) {
         CFX_DIBitmap bitmap;
         if (!bitmap.Create(pixel_width, pixel_height, FXDIB_1bppMask)) {
             FX_Free(pGlyphAndPos);
-            return FALSE;
+            return false;
         }
         bitmap.Clear(0);
         for (iChar = 0; iChar < nChars; iChar ++) {
             FXTEXT_GLYPHPOS& glyph = pGlyphAndPos[iChar];
             if (glyph.m_pGlyph == NULL) {
                 continue;
             }
             const CFX_DIBitmap* pGlyph = &glyph.m_pGlyph->m_Bitmap;
             bitmap.TransferBitmap(glyph.m_OriginX + glyph.m_pGlyph->m_Left - pixel_left,
                                   glyph.m_OriginY - glyph.m_pGlyph->m_Top - pixel_top,
                                   pGlyph->GetWidth(), pGlyph->GetHeight(), pGlyph, 0, 0);
         }
         FX_Free(pGlyphAndPos);
         return SetBitMask(&bitmap, bmp_rect.left, bmp_rect.top, fill_color);
     }
     CFX_DIBitmap bitmap;
     if (m_bpp == 8) {
         if (!bitmap.Create(pixel_width, pixel_height, FXDIB_8bppMask)) {
             FX_Free(pGlyphAndPos);
-            return FALSE;
+            return false;
         }
     } else {
         if (!CreateCompatibleBitmap(&bitmap, pixel_width, pixel_height)) {
             FX_Free(pGlyphAndPos);
-            return FALSE;
+            return false;
         }
     }
     if (!bitmap.HasAlpha() && !bitmap.IsAlphaMask()) {
         bitmap.Clear(0xFFFFFFFF);
         if (!GetDIBits(&bitmap, bmp_rect.left, bmp_rect.top)) {
             FX_Free(pGlyphAndPos);
-            return FALSE;
+            return false;
         }
     } else {
         bitmap.Clear(0);
         if (bitmap.m_pAlphaMask) {
             bitmap.m_pAlphaMask->Clear(0);
         }
     }
     int dest_width = pixel_width;
     uint8_t* dest_buf = bitmap.GetBuffer();
     int dest_pitch = bitmap.GetPitch();
@@ skipping 11 matching lines @@
         if (glyph.m_pGlyph == NULL) {
             continue;
         }
         const CFX_DIBitmap* pGlyph = &glyph.m_pGlyph->m_Bitmap;
         int left = glyph.m_OriginX + glyph.m_pGlyph->m_Left - pixel_left;
         int top = glyph.m_OriginY - glyph.m_pGlyph->m_Top - pixel_top;
         int ncols = pGlyph->GetWidth();
         int nrows = pGlyph->GetHeight();
         if (anti_alias == FXFT_RENDER_MODE_NORMAL) {
             if (!bitmap.CompositeMask(left, top, ncols, nrows, pGlyph, fill_color,
-                                      0, 0, FXDIB_BLEND_NORMAL, NULL, FALSE, alpha_flag, pIccTransform)) {
+                                      0, 0, FXDIB_BLEND_NORMAL, NULL, false, alpha_flag, pIccTransform)) {
                 FX_Free(pGlyphAndPos);
-                return FALSE;
+                return false;
             }
             continue;
         }
-        FX_BOOL bBGRStripe = text_flags & FXTEXT_BGR_STRIPE;
+        bool bBGRStripe = text_flags & FXTEXT_BGR_STRIPE;
         ncols /= 3;
         int x_subpixel = (int)(glyph.m_fOriginX * 3) % 3;
         uint8_t* src_buf = pGlyph->GetBuffer();
         int src_pitch = pGlyph->GetPitch();
         int start_col = left;
         if (start_col < 0) {
             start_col = 0;
         }
         int end_col = left + ncols;
         if (end_col > dest_width) {
@@ skipping 566 matching lines @@
                 }
             }
         }
     }
     if (bitmap.IsAlphaMask()) {
         SetBitMask(&bitmap, bmp_rect.left, bmp_rect.top, fill_color, alpha_flag, pIccTransform);
     } else {
         SetDIBits(&bitmap, bmp_rect.left, bmp_rect.top);
     }
     FX_Free(pGlyphAndPos);
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_RenderDevice::DrawTextPath(int nChars, const FXTEXT_CHARPOS* pCharPos,
+bool CFX_RenderDevice::DrawTextPath(int nChars, const FXTEXT_CHARPOS* pCharPos,
                                        CFX_Font* pFont, CFX_FontCache* pCache,
                                        FX_FLOAT font_size, const CFX_AffineMatrix* pText2User,
                                        const CFX_AffineMatrix* pUser2Device, const CFX_GraphStateData* pGraphState,
                                        FX_DWORD fill_color, FX_ARGB stroke_color, CFX_PathData* pClippingPath, int nFlag,
                                        int alpha_flag, void* pIccTransform, int blend_type)
 {
     if (pCache == NULL) {
         pCache = CFX_GEModule::Get()->GetFontCache();
     }
     CFX_FaceCache* pFaceCache = pCache->GetCachedFace(pFont);
     FX_FONTCACHE_DEFINE(pCache, pFont);
     for (int iChar = 0; iChar < nChars; iChar ++) {
         const FXTEXT_CHARPOS& charpos = pCharPos[iChar];
         CFX_AffineMatrix matrix;
         if (charpos.m_bGlyphAdjust)
             matrix.Set(charpos.m_AdjustMatrix[0], charpos.m_AdjustMatrix[1],
                        charpos.m_AdjustMatrix[2], charpos.m_AdjustMatrix[3], 0, 0);
         matrix.Concat(font_size, 0, 0, font_size, charpos.m_OriginX, charpos.m_OriginY);
         const CFX_PathData* pPath = pFaceCache->LoadGlyphPath(pFont, charpos.m_GlyphIndex, charpos.m_FontCharWidth);
         if (pPath == NULL) {
             continue;
         }
         matrix.Concat(*pText2User);
         CFX_PathData TransformedPath(*pPath);
         TransformedPath.Transform(&matrix);
-        FX_BOOL bHasAlpha = FXGETFLAG_COLORTYPE(alpha_flag) ?
+        bool bHasAlpha = FXGETFLAG_COLORTYPE(alpha_flag) ?
                             (FXGETFLAG_ALPHA_FILL(alpha_flag) || FXGETFLAG_ALPHA_STROKE(alpha_flag)) :
                             (fill_color || stroke_color);
         if (bHasAlpha) {
             int fill_mode = nFlag;
             if (FXGETFLAG_COLORTYPE(alpha_flag)) {
                 if (FXGETFLAG_ALPHA_FILL(alpha_flag)) {
                     fill_mode |= FXFILL_WINDING;
                 }
             } else {
                 if (fill_color) {
                     fill_mode |= FXFILL_WINDING;
                 }
             }
             fill_mode |= FX_FILL_TEXT_MODE;
             if (!DrawPath(&TransformedPath, pUser2Device, pGraphState, fill_color, stroke_color, fill_mode, alpha_flag, pIccTransform, blend_type)) {
-                return FALSE;
+                return false;
             }
         }
         if (pClippingPath) {
             pClippingPath->Append(&TransformedPath, pUser2Device);
         }
     }
-    return TRUE;
+    return true;
 }
 CFX_FontCache::~CFX_FontCache()
 {
-    FreeCache(TRUE);
+    FreeCache(true);
 }
 
 CFX_FaceCache* CFX_FontCache::GetCachedFace(CFX_Font* pFont)
 {
     FXFT_Face internal_face = pFont->GetFace();
-    const FX_BOOL bExternal = internal_face == nullptr;
+    const bool bExternal = internal_face == nullptr;
     FXFT_Face face = bExternal ?
         (FXFT_Face)pFont->GetSubstFont()->m_ExtHandle : internal_face;
     CFX_FTCacheMap& map = bExternal ? m_ExtFaceMap : m_FTFaceMap;
     auto it = map.find(face);
     if (it != map.end()) {
         CFX_CountedFaceCache* counted_face_cache = it->second;
         counted_face_cache->m_nCount++;
         return counted_face_cache->m_Obj;
     }
 
     CFX_FaceCache* face_cache = new CFX_FaceCache(bExternal ? nullptr : face);
     CFX_CountedFaceCache* counted_face_cache = new CFX_CountedFaceCache;
     counted_face_cache->m_nCount = 2;
     counted_face_cache->m_Obj = face_cache;
     map[face] = counted_face_cache;
     return face_cache;
 }
 
 void CFX_FontCache::ReleaseCachedFace(CFX_Font* pFont)
 {
     FXFT_Face internal_face = pFont->GetFace();
-    const FX_BOOL bExternal = internal_face == nullptr;
+    const bool bExternal = internal_face == nullptr;
     FXFT_Face face = bExternal ?
         (FXFT_Face)pFont->GetSubstFont()->m_ExtHandle : internal_face;
     CFX_FTCacheMap& map =  bExternal ? m_ExtFaceMap : m_FTFaceMap;
 
     auto it = map.find(face);
     if (it == map.end())
         return;
 
     CFX_CountedFaceCache* counted_face_cache = it->second;
     if (counted_face_cache->m_nCount > 1) {
         counted_face_cache->m_nCount--;
     }
 }
 
-void CFX_FontCache::FreeCache(FX_BOOL bRelease)
+void CFX_FontCache::FreeCache(bool bRelease)
 {
     for (auto it = m_FTFaceMap.begin(); it != m_FTFaceMap.end();) {
         auto curr_it = it++;
         CFX_CountedFaceCache* cache = curr_it->second;
         if (bRelease || cache->m_nCount < 2) {
             delete cache->m_Obj;
             delete cache;
             m_FTFaceMap.erase(curr_it);
         }
     }
@@ skipping 31 matching lines @@
         delete pPath;
     }
     m_PathMap.RemoveAll();
 }
 #if _FXM_PLATFORM_  != _FXM_PLATFORM_APPLE_
 void CFX_FaceCache::InitPlatform()
 {
 }
 #endif
 CFX_GlyphBitmap* CFX_FaceCache::LookUpGlyphBitmap(CFX_Font* pFont, const CFX_AffineMatrix* pMatrix,
-        CFX_ByteStringC& FaceGlyphsKey, FX_DWORD glyph_index, FX_BOOL bFontStyle,
+        CFX_ByteStringC& FaceGlyphsKey, FX_DWORD glyph_index, bool bFontStyle,
         int dest_width, int anti_alias)
 {
     CFX_SizeGlyphCache* pSizeCache = NULL;
     if (!m_SizeMap.Lookup(FaceGlyphsKey, (void*&)pSizeCache)) {
         pSizeCache = new CFX_SizeGlyphCache;
         m_SizeMap.SetAt(FaceGlyphsKey, pSizeCache);
     }
     CFX_GlyphBitmap* pGlyphBitmap = NULL;
     if (pSizeCache->m_GlyphMap.Lookup((void*)(uintptr_t)glyph_index, (void*&)pGlyphBitmap)) {
         return pGlyphBitmap;
     }
     pGlyphBitmap = RenderGlyph(pFont, glyph_index, bFontStyle, pMatrix, dest_width, anti_alias);
     if (pGlyphBitmap == NULL)   {
         return NULL;
     }
     pSizeCache->m_GlyphMap.SetAt((void*)(uintptr_t)glyph_index, pGlyphBitmap);
     return pGlyphBitmap;
 }
-const CFX_GlyphBitmap* CFX_FaceCache::LoadGlyphBitmap(CFX_Font* pFont, FX_DWORD glyph_index, FX_BOOL bFontStyle, const CFX_AffineMatrix* pMatrix,
+const CFX_GlyphBitmap* CFX_FaceCache::LoadGlyphBitmap(CFX_Font* pFont, FX_DWORD glyph_index, bool bFontStyle, const CFX_AffineMatrix* pMatrix,
         int dest_width, int anti_alias, int& text_flags)
 {
     if (glyph_index == (FX_DWORD) - 1) {
         return NULL;
     }
     _CFX_UniqueKeyGen keygen;
 #if _FXM_PLATFORM_  != _FXM_PLATFORM_APPLE_
     if (pFont->GetSubstFont())
         keygen.Generate(9, (int)(pMatrix->a * 10000), (int)(pMatrix->b * 10000),
                         (int)(pMatrix->c * 10000), (int)(pMatrix->d * 10000), dest_width, anti_alias,
@@ skipping 176 matching lines @@
             temp = (int)((*(pSrcRow++) - min) * rate + 0.5);
             if (temp > 255)     {
                 temp = 255;
             } else if (temp < 0) {
                 temp = 0;
             }
             *pDstRow ++ = (uint8_t)temp;
         }
     }
 }
-CFX_GlyphBitmap* CFX_FaceCache::RenderGlyph(CFX_Font* pFont, FX_DWORD glyph_index, FX_BOOL bFontStyle,
+CFX_GlyphBitmap* CFX_FaceCache::RenderGlyph(CFX_Font* pFont, FX_DWORD glyph_index, bool bFontStyle,
         const CFX_AffineMatrix* pMatrix, int dest_width, int anti_alias)
 {
     if (m_Face == NULL) {
         return NULL;
     }
     FXFT_Matrix  ft_matrix;
     ft_matrix.xx = (signed long)(pMatrix->GetA() / 64 * 65536);
     ft_matrix.xy = (signed long)(pMatrix->GetC() / 64 * 65536);
     ft_matrix.yx = (signed long)(pMatrix->GetB() / 64 * 65536);
     ft_matrix.yy = (signed long)(pMatrix->GetD() / 64 * 65536);
-    FX_BOOL bUseCJKSubFont = FALSE;
+    bool bUseCJKSubFont = false;
     const CFX_SubstFont* pSubstFont = pFont->GetSubstFont();
     if (pSubstFont) {
         bUseCJKSubFont = pSubstFont->m_bSubstOfCJK && bFontStyle;
         int skew = 0;
         if (bUseCJKSubFont) {
             skew = pSubstFont->m_bItlicCJK ? -15 : 0;
         } else {
             skew = pSubstFont->m_ItalicAngle;
         }
         if (skew) {
@@ skipping 79 matching lines @@
             for (int row = 0; row < bmheight; row ++) {
                 FXSYS_memcpy(pDestBuf + row * dest_pitch, pSrcBuf + row * src_pitch, rowbytes);
             }
         } else {
             _ContrastAdjust(pSrcBuf, pDestBuf, bmwidth, bmheight, src_pitch, dest_pitch);
             _GammaAdjust(pDestBuf, bmwidth, bmheight, dest_pitch, CFX_GEModule::Get()->GetTextGammaTable());
         }
     }
     return pGlyphBitmap;
 }
-FX_BOOL _OutputGlyph(void* dib, int x, int y, CFX_Font* pFont,
+bool _OutputGlyph(void* dib, int x, int y, CFX_Font* pFont,
                      int glyph_index, FX_ARGB argb)
 {
     CFX_DIBitmap* pDib = (CFX_DIBitmap*)dib;
     FXFT_Face face = pFont->GetFace();
     int error = FXFT_Load_Glyph(face, glyph_index, FXFT_LOAD_NO_BITMAP);
     if (error) {
-        return FALSE;
+        return false;
     }
     error = FXFT_Render_Glyph(face, FXFT_RENDER_MODE_NORMAL);
     if (error) {
-        return FALSE;
+        return false;
     }
     int bmwidth = FXFT_Get_Bitmap_Width(FXFT_Get_Glyph_Bitmap(face));
     int bmheight = FXFT_Get_Bitmap_Rows(FXFT_Get_Glyph_Bitmap(face));
     int left = FXFT_Get_Glyph_BitmapLeft(face);
     int top = FXFT_Get_Glyph_BitmapTop(face);
     const uint8_t* src_buf = (const uint8_t*)FXFT_Get_Bitmap_Buffer(FXFT_Get_Glyph_Bitmap(face));
     int src_pitch = FXFT_Get_Bitmap_Pitch(FXFT_Get_Glyph_Bitmap(face));
     CFX_DIBitmap mask;
     mask.Create(bmwidth, bmheight, FXDIB_8bppMask);
     uint8_t* dest_buf = mask.GetBuffer();
     int dest_pitch = mask.GetPitch();
     for (int row = 0; row < bmheight; row ++) {
         const uint8_t* src_scan = src_buf + row * src_pitch;
         uint8_t* dest_scan = dest_buf + row * dest_pitch;
         FXSYS_memcpy(dest_scan, src_scan, dest_pitch);
     }
     pDib->CompositeMask(x + left, y - top, bmwidth, bmheight, &mask, argb, 0, 0);
-    return TRUE;
+    return true;
 }
-FX_BOOL OutputText(void* dib, int x, int y, CFX_Font* pFont, double font_size,
+bool OutputText(void* dib, int x, int y, CFX_Font* pFont, double font_size,
                    CFX_AffineMatrix* pText_matrix, unsigned short const* text, unsigned long argb)
 {
     if (!pFont) {
-        return FALSE;
+        return false;
     }
     FXFT_Face face = pFont->GetFace();
     FXFT_Select_Charmap(pFont->m_Face, FXFT_ENCODING_UNICODE);
     if (pText_matrix) {
         FXFT_Matrix  ft_matrix;
         ft_matrix.xx = (signed long)(pText_matrix->a / 64 * 65536);
         ft_matrix.xy = (signed long)(pText_matrix->c / 64 * 65536);
         ft_matrix.yx = (signed long)(pText_matrix->b / 64 * 65536);
         ft_matrix.yy = (signed long)(pText_matrix->d / 64 * 65536);
         FXFT_Set_Transform(face, &ft_matrix, 0);
@@ skipping 12 matching lines @@
         int w = FXFT_Get_Glyph_HoriAdvance(pFont->m_Face);
         int em = FXFT_Get_Face_UnitsPerEM(pFont->m_Face);
         FX_FLOAT x1, y1;
         pText_matrix->Transform(x_pos, 0, x1, y1);
         _OutputGlyph(dib, (int)x1 + x, (int) - y1 + y, pFont,
                      glyph_index, argb);
         x_pos += (FX_FLOAT)w / em;
     }
     if (pText_matrix)
         ResetTransform(face);
-    return TRUE;
+    return true;
 }
-FX_BOOL OutputGlyph(void* dib, int x, int y, CFX_Font* pFont, double font_size,
+bool OutputGlyph(void* dib, int x, int y, CFX_Font* pFont, double font_size,
                     CFX_AffineMatrix* pMatrix, unsigned long glyph_index, unsigned long argb)
 {
     FXFT_Matrix  ft_matrix;
     if (pMatrix) {
         ft_matrix.xx = (signed long)(pMatrix->a * font_size / 64 * 65536);
         ft_matrix.xy = (signed long)(pMatrix->c * font_size / 64 * 65536);
         ft_matrix.yx = (signed long)(pMatrix->b * font_size / 64 * 65536);
         ft_matrix.yy = (signed long)(pMatrix->d * font_size / 64 * 65536);
     } else {
         ft_matrix.xx = (signed long)(font_size / 64 * 65536);
         ft_matrix.xy = ft_matrix.yx = 0;
         ft_matrix.yy = (signed long)(font_size / 64 * 65536);
     }
     ScopedFontTransform scoped_transform(pFont->m_Face, &ft_matrix);
-    FX_BOOL ret = _OutputGlyph(dib, x, y, pFont,
+    bool ret = _OutputGlyph(dib, x, y, pFont,
                                glyph_index, argb);
     return ret;
 }
 const CFX_PathData* CFX_FaceCache::LoadGlyphPath(CFX_Font* pFont, FX_DWORD glyph_index, int dest_width)
 {
     if (m_Face == NULL || glyph_index == (FX_DWORD) - 1) {
         return NULL;
     }
     CFX_PathData* pGlyphPath = NULL;
     void* key;
     if (pFont->GetSubstFont())
         key = (void*)(uintptr_t)(glyph_index + ((pFont->GetSubstFont()->m_Weight / 16) << 15) +
                                       ((pFont->GetSubstFont()->m_ItalicAngle / 2) << 21) + ((dest_width / 16) << 25) +
                                       (pFont->IsVertical() << 31));
     else {
         key = (void*)(uintptr_t)glyph_index;
     }
     if (m_PathMap.Lookup(key, (void*&)pGlyphPath)) {
         return pGlyphPath;
     }
     pGlyphPath = pFont->LoadGlyphPath(glyph_index, dest_width);
     m_PathMap.SetAt(key, pGlyphPath);
     return pGlyphPath;
 }
 typedef struct {
-    FX_BOOL                     m_bCount;
+    bool                        m_bCount;
     int                         m_PointCount;
     FX_PATHPOINT*       m_pPoints;
     int                         m_CurX;
     int                         m_CurY;
     FX_FLOAT            m_CoordUnit;
 } OUTLINE_PARAMS;
 void _Outline_CheckEmptyContour(OUTLINE_PARAMS* param)
 {
     if (param->m_PointCount >= 2 && param->m_pPoints[param->m_PointCount - 2].m_Flag == FXPT_MOVETO &&
             param->m_pPoints[param->m_PointCount - 2].m_PointX == param->m_pPoints[param->m_PointCount - 1].m_PointX &&
@@ skipping 130 matching lines @@
         FXFT_Outline_Embolden(FXFT_Get_Glyph_Outline(m_Face), level);
     }
     FXFT_Outline_Funcs funcs;
     funcs.move_to = _Outline_MoveTo;
     funcs.line_to = _Outline_LineTo;
     funcs.conic_to = _Outline_ConicTo;
     funcs.cubic_to = _Outline_CubicTo;
     funcs.shift = 0;
     funcs.delta = 0;
     OUTLINE_PARAMS params;
-    params.m_bCount = TRUE;
+    params.m_bCount = true;
     params.m_PointCount = 0;
     FXFT_Outline_Decompose(FXFT_Get_Glyph_Outline(m_Face), &funcs, &params);
     if (params.m_PointCount == 0) {
         return NULL;
     }
     CFX_PathData* pPath = new CFX_PathData;
     pPath->SetPointCount(params.m_PointCount);
-    params.m_bCount = FALSE;
+    params.m_bCount = false;
     params.m_PointCount = 0;
     params.m_pPoints = pPath->GetPoints();
     params.m_CurX = params.m_CurY = 0;
     params.m_CoordUnit = 64 * 64.0;
     FXFT_Outline_Decompose(FXFT_Get_Glyph_Outline(m_Face), &funcs, &params);
     _Outline_CheckEmptyContour(&params);
     pPath->TrimPoints(params.m_PointCount);
     if (params.m_PointCount) {
         pPath->GetPoints()[params.m_PointCount - 1].m_Flag |= FXPT_CLOSEFIGURE;
     }
     return pPath;
 }
 void _CFX_UniqueKeyGen::Generate(int count, ...)
 {
     va_list argList;
     va_start(argList, count);
     for (int i = 0; i < count; i ++) {
         int p = va_arg(argList, int);
         ((FX_DWORD*)m_Key)[i] = p;
     }
     va_end(argList);
     m_KeyLen = count * sizeof(FX_DWORD);
 }