Merge to XFA: Use stdint.h types throughout PDFium.

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 60 matching lines @@
         int space = (*next_origin) - (*this_origin);
         FX_FLOAT space_f = next_origin_f - this_origin_f;
         FX_FLOAT error = (FX_FLOAT)(FXSYS_fabs(space_f) - FXSYS_fabs((FX_FLOAT)(space)));
         if (error > 0.5f) {
             *this_origin += space > 0 ? -1 : 1;
         }
         next_origin = this_origin;
         next_origin_f = this_origin_f;
     }
 }
-static const FX_BYTE g_TextGammaAdjust[256] = {
+static const uint8_t g_TextGammaAdjust[256] = {
     0, 2, 3, 4, 6, 7, 8, 10, 11, 12, 13, 15, 16, 17, 18, 19,
     21, 22, 23, 24, 25, 26, 27, 29, 30, 31, 32, 33, 34, 35, 36, 38,
     39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 51, 52, 53, 54, 55,
     56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 71, 72,
     73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
     89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
     105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120,
     121, 122, 123, 124, 125, 126, 127, 128, 129, 129, 130, 131, 132, 133, 134, 135,
     136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151,
     152, 153, 154, 155, 156, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166,
     167, 168, 169, 170, 171, 172, 173, 174, 174, 175, 176, 177, 178, 179, 180, 181,
     182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 193, 194, 195, 196,
     197, 198, 199, 200, 201, 202, 203, 204, 204, 205, 206, 207, 208, 209, 210, 211,
     212, 213, 214, 215, 216, 217, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226,
     227, 228, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 239, 240,
     241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 250, 251, 252, 253, 254, 255,
 };
 #define ADJUST_ALPHA(background, foreground, src_alpha, text_flags, a) \
-    src_alpha = g_TextGammaAdjust[(FX_BYTE)src_alpha];
+    src_alpha = g_TextGammaAdjust[(uint8_t)src_alpha];
 void _Color2Argb(FX_ARGB& argb, FX_DWORD color, int alpha_flag, void* pIccTransform)
 {
     if (pIccTransform == NULL && !FXGETFLAG_COLORTYPE(alpha_flag)) {
         argb = color;
         return;
     }
     if (!CFX_GEModule::Get()->GetCodecModule() || !CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
         pIccTransform = NULL;
     }
-    FX_BYTE bgra[4];
+    uint8_t bgra[4];
     if (pIccTransform) {
         ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
         color = FXGETFLAG_COLORTYPE(alpha_flag) ? FXCMYK_TODIB(color) : FXARGB_TODIB(color);
         pIccModule->TranslateScanline(pIccTransform, bgra, (FX_LPCBYTE)&color, 1);
         bgra[3] = FXGETFLAG_COLORTYPE(alpha_flag) ?
                   (alpha_flag >> 24) ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXGETFLAG_ALPHA_STROKE(alpha_flag) :
                   FXARGB_A(color);
         argb = FXARGB_MAKE(bgra[3], bgra[2], bgra[1], bgra[0]);
         return;
     }
@@ skipping 313 matching lines @@
                             src_scan += 3;
                         }
                     }
                 } else {
                     if (x_subpixel == 0) {
                         for (int col = start_col; col < end_col; col ++) {
                             if (bNormal) {
                                 int src_alpha1 = (src_scan[0] + src_scan[1] + src_scan[2]) / 3;
                                 ADJUST_ALPHA(dest_scan[2], r, src_alpha1, nativetext_flags, a);
                                 src_alpha1 = src_alpha1 * a / 255;
-                                FX_BYTE back_alpha = dest_scan[3];
+                                uint8_t back_alpha = dest_scan[3];
                                 if (back_alpha == 0) {
                                     FXARGB_SETDIB(dest_scan, FXARGB_MAKE(src_alpha1, r, g, b));
                                     dest_scan += 4;
                                     src_scan += 3;
                                     continue;
                                 }
                                 if (src_alpha1 == 0) {
                                     dest_scan += 4;
                                     src_scan += 3;
                                     continue;
                                 }
-                                FX_BYTE dest_alpha = back_alpha + src_alpha1 - back_alpha * src_alpha1 / 255;
+                                uint8_t dest_alpha = back_alpha + src_alpha1 - back_alpha * src_alpha1 / 255;
                                 dest_scan[3] = dest_alpha;
                                 int alpha_ratio = src_alpha1 * 255 / dest_alpha;
                                 dest_scan[2] = FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(FX_GAMMA(dest_scan[2]), r, alpha_ratio));
                                 dest_scan[1] = FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(FX_GAMMA(dest_scan[1]), g, alpha_ratio));
                                 dest_scan[0] = FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(FX_GAMMA(dest_scan[0]), b, alpha_ratio));
                                 dest_scan += 4;
                                 src_scan += 3;
                                 continue;
                             }
                             int src_alpha = src_scan[0];
@@ skipping 14 matching lines @@
                         }
                     } else if (x_subpixel == 1) {
                         if (bNormal) {
                             int src_alpha1 = start_col > left ? ((src_scan[-1] + src_scan[0] + src_scan[1]) / 3) : ((src_scan[0] + src_scan[1]) / 3);
                             ADJUST_ALPHA(dest_scan[2], r, src_alpha1, nativetext_flags, a);
                             src_alpha1 = src_alpha1 * a / 255;
                             if (src_alpha1 == 0) {
                                 dest_scan += 4;
                                 src_scan += 3;
                             } else {
-                                FX_BYTE back_alpha = dest_scan[3];
+                                uint8_t back_alpha = dest_scan[3];
                                 if (back_alpha == 0) {
                                     FXARGB_SETDIB(dest_scan, FXARGB_MAKE(src_alpha1, r, g, b));
                                 } else {
-                                    FX_BYTE dest_alpha = back_alpha + src_alpha1 - back_alpha * src_alpha1 / 255;
+                                    uint8_t dest_alpha = back_alpha + src_alpha1 - back_alpha * src_alpha1 / 255;
                                     dest_scan[3] = dest_alpha;
                                     int alpha_ratio = src_alpha1 * 255 / dest_alpha;
                                     dest_scan[2] = FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(FX_GAMMA(dest_scan[2]), r, alpha_ratio));
                                     dest_scan[1] = FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(FX_GAMMA(dest_scan[1]), g, alpha_ratio));
                                     dest_scan[0] = FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(FX_GAMMA(dest_scan[0]), b, alpha_ratio));
                                 }
                                 dest_scan += 4;
                                 src_scan += 3;
                             }
                         } else {
@@ skipping 13 matching lines @@
                             dest_scan[0] = FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(FX_GAMMA(dest_scan[0]), b, src_alpha));
                             dest_scan[3] = 255;
                             dest_scan += 4;
                             src_scan += 3;
                         }
                         for (int col = start_col + 1; col < end_col; col ++) {
                             if (bNormal) {
                                 int src_alpha1 = (src_scan[-1] + src_scan[0] + src_scan[1]) / 3;
                                 ADJUST_ALPHA(dest_scan[2], r, src_alpha1, nativetext_flags, a);
                                 src_alpha1 = src_alpha1 * a / 255;
-                                FX_BYTE back_alpha = dest_scan[3];
+                                uint8_t back_alpha = dest_scan[3];
                                 if (back_alpha == 0) {
                                     FXARGB_SETDIB(dest_scan, FXARGB_MAKE(src_alpha1, r, g, b));
                                     dest_scan += 4;
                                     src_scan += 3;
                                     continue;
                                 }
                                 if (src_alpha1 == 0) {
                                     dest_scan += 4;
                                     src_scan += 3;
                                     continue;
                                 }
-                                FX_BYTE dest_alpha = back_alpha + src_alpha1 - back_alpha * src_alpha1 / 255;
+                                uint8_t dest_alpha = back_alpha + src_alpha1 - back_alpha * src_alpha1 / 255;
                                 dest_scan[3] = dest_alpha;
                                 int alpha_ratio = src_alpha1 * 255 / dest_alpha;
                                 dest_scan[2] = FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(FX_GAMMA(dest_scan[2]), r, alpha_ratio));
                                 dest_scan[1] = FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(FX_GAMMA(dest_scan[1]), g, alpha_ratio));
                                 dest_scan[0] = FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(FX_GAMMA(dest_scan[0]), b, alpha_ratio));
                                 dest_scan += 4;
                                 src_scan += 3;
                                 continue;
                             }
                             int src_alpha = src_scan[-1];
@@ skipping 14 matching lines @@
                         }
                     } else {
                         if (bNormal) {
                             int src_alpha1 = start_col > left ? ((src_scan[-2] + src_scan[-1] + src_scan[0]) / 3) : ((src_scan[0]) / 3);
                             ADJUST_ALPHA(dest_scan[2], r, src_alpha1, nativetext_flags, a);
                             src_alpha1 = src_alpha1 * a / 255;
                             if (src_alpha1 == 0) {
                                 dest_scan += 4;
                                 src_scan += 3;
                             } else {
-                                FX_BYTE back_alpha = dest_scan[3];
+                                uint8_t back_alpha = dest_scan[3];
                                 if (back_alpha == 0) {
                                     FXARGB_SETDIB(dest_scan, FXARGB_MAKE(src_alpha1, r, g, b));
                                 } else {
-                                    FX_BYTE dest_alpha = back_alpha + src_alpha1 - back_alpha * src_alpha1 / 255;
+                                    uint8_t dest_alpha = back_alpha + src_alpha1 - back_alpha * src_alpha1 / 255;
                                     dest_scan[3] = dest_alpha;
                                     int alpha_ratio = src_alpha1 * 255 / dest_alpha;
                                     dest_scan[2] = FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(FX_GAMMA(dest_scan[2]), r, alpha_ratio));
                                     dest_scan[1] = FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(FX_GAMMA(dest_scan[1]), g, alpha_ratio));
                                     dest_scan[0] = FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(FX_GAMMA(dest_scan[0]), b, alpha_ratio));
                                 }
                                 dest_scan += 4;
                                 src_scan += 3;
                             }
                         } else {
@@ skipping 13 matching lines @@
                             dest_scan[0] = FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(FX_GAMMA(dest_scan[0]), b, src_alpha));
                             dest_scan[3] = 255;
                             dest_scan += 4;
                             src_scan += 3;
                         }
                         for (int col = start_col + 1; col < end_col; col ++) {
                             if (bNormal) {
                                 int src_alpha1 = (src_scan[-2] + src_scan[-1] + src_scan[0]) / 3;
                                 ADJUST_ALPHA(dest_scan[2], r, src_alpha1, nativetext_flags, a);
                                 src_alpha1 = src_alpha1 * a / 255;
-                                FX_BYTE back_alpha = dest_scan[3];
+                                uint8_t back_alpha = dest_scan[3];
                                 if (back_alpha == 0) {
                                     FXARGB_SETDIB(dest_scan, FXARGB_MAKE(src_alpha1, r, g, b));
                                     dest_scan += 4;
                                     src_scan += 3;
                                     continue;
                                 }
                                 if (src_alpha1 == 0) {
                                     dest_scan += 4;
                                     src_scan += 3;
                                     continue;
                                 }
-                                FX_BYTE dest_alpha = back_alpha + src_alpha1 - back_alpha * src_alpha1 / 255;
+                                uint8_t dest_alpha = back_alpha + src_alpha1 - back_alpha * src_alpha1 / 255;
                                 dest_scan[3] = dest_alpha;
                                 int alpha_ratio = src_alpha1 * 255 / dest_alpha;
                                 dest_scan[2] = FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(FX_GAMMA(dest_scan[2]), r, alpha_ratio));
                                 dest_scan[1] = FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(FX_GAMMA(dest_scan[1]), g, alpha_ratio));
                                 dest_scan[0] = FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(FX_GAMMA(dest_scan[0]), b, alpha_ratio));
                                 dest_scan += 4;
                                 src_scan += 3;
                                 continue;
                             }
                             int src_alpha = src_scan[-2];
@@ skipping 437 matching lines @@
 {
     CFX_SizeGlyphCache* pSizeCache = NULL;
     if (!m_SizeMap.Lookup(FaceGlyphsKey, (void*&)pSizeCache)) {
         pSizeCache = FX_NEW CFX_SizeGlyphCache;
         if (pSizeCache == NULL) {
             return NULL;
         }
         m_SizeMap.SetAt(FaceGlyphsKey, pSizeCache);
     }
     CFX_GlyphBitmap* pGlyphBitmap = NULL;
-    if (pSizeCache->m_GlyphMap.Lookup((FX_LPVOID)(FX_UINTPTR)glyph_index, (void*&)pGlyphBitmap)) {
+    if (pSizeCache->m_GlyphMap.Lookup((FX_LPVOID)(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((FX_LPVOID)(FX_UINTPTR)glyph_index, pGlyphBitmap);
+    pSizeCache->m_GlyphMap.SetAt((FX_LPVOID)(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,
         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_
@@ skipping 26 matching lines @@
     CFX_ByteStringC FaceGlyphsKey(keygen.m_Key, keygen.m_KeyLen);
 #if _FXM_PLATFORM_  != _FXM_PLATFORM_APPLE_
     return LookUpGlyphBitmap(pFont, pMatrix, FaceGlyphsKey, glyph_index, bFontStyle, dest_width, anti_alias);
 #else
     if (text_flags & FXTEXT_NO_NATIVETEXT) {
         return LookUpGlyphBitmap(pFont, pMatrix, FaceGlyphsKey, glyph_index, bFontStyle, dest_width, anti_alias);
     } else {
         CFX_GlyphBitmap* pGlyphBitmap;
         CFX_SizeGlyphCache* pSizeCache = NULL;
         if (m_SizeMap.Lookup(FaceGlyphsKey, (void*&)pSizeCache)) {
-            if (pSizeCache->m_GlyphMap.Lookup((FX_LPVOID)(FX_UINTPTR)glyph_index, (void*&)pGlyphBitmap)) {
+            if (pSizeCache->m_GlyphMap.Lookup((FX_LPVOID)(uintptr_t)glyph_index, (void*&)pGlyphBitmap)) {
                 return pGlyphBitmap;
             }
             pGlyphBitmap = RenderGlyph_Nativetext(pFont, glyph_index, pMatrix, dest_width, anti_alias);
             if (pGlyphBitmap) {
-                pSizeCache->m_GlyphMap.SetAt((FX_LPVOID)(FX_UINTPTR)glyph_index, pGlyphBitmap);
+                pSizeCache->m_GlyphMap.SetAt((FX_LPVOID)(uintptr_t)glyph_index, pGlyphBitmap);
                 return pGlyphBitmap;
             }
         } else {
             pGlyphBitmap = RenderGlyph_Nativetext(pFont, glyph_index, pMatrix, dest_width, anti_alias);
             if (pGlyphBitmap) {
                 pSizeCache = FX_NEW CFX_SizeGlyphCache;
                 if (pSizeCache == NULL) {
                     return NULL;
                 }
                 m_SizeMap.SetAt(FaceGlyphsKey, pSizeCache);
-                pSizeCache->m_GlyphMap.SetAt((FX_LPVOID)(FX_UINTPTR)glyph_index, pGlyphBitmap);
+                pSizeCache->m_GlyphMap.SetAt((FX_LPVOID)(uintptr_t)glyph_index, pGlyphBitmap);
                 return pGlyphBitmap;
             }
         }
         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,
                             pFont->GetSubstFont()->m_Weight, pFont->GetSubstFont()->m_ItalicAngle, pFont->IsVertical());
         else
             keygen.Generate(6, (int)(pMatrix->a * 10000), (int)(pMatrix->b * 10000),
                             (int)(pMatrix->c * 10000), (int)(pMatrix->d * 10000), dest_width, anti_alias);
@@ skipping 50 matching lines @@
     FXFT_Free(m_Face, pMasters);
     FXFT_Set_MM_Design_Coordinates(m_Face, 2, coords);
 }
 static const size_t ANGLESKEW_ARRAY_SIZE = 30;
 static const char g_AngleSkew[ANGLESKEW_ARRAY_SIZE] = {
     0, 2, 3, 5, 7, 9, 11, 12, 14, 16,
     18, 19, 21, 23, 25, 27, 29, 31, 32, 34,
     36, 38, 40, 42, 45, 47, 49, 51, 53, 55,
 };
 static const size_t WEIGHTPOW_ARRAY_SIZE = 100;
-static const FX_BYTE g_WeightPow[WEIGHTPOW_ARRAY_SIZE] = {
+static const uint8_t g_WeightPow[WEIGHTPOW_ARRAY_SIZE] = {
     0, 3, 6, 7, 8, 9, 11, 12, 14, 15, 16, 17, 18, 19, 20,
     21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 35, 36, 36,
     37, 37, 37, 38, 38, 38, 39, 39, 39, 40, 40, 40, 41, 41, 41, 42, 42, 42,
     42, 43, 43, 43, 44, 44, 44, 44, 45, 45, 45, 45, 46, 46, 46, 46, 47, 47,
     47, 47, 48, 48, 48, 48, 48, 49, 49, 49, 49, 50, 50, 50, 50, 50, 51, 51,
     51, 51, 51, 52, 52, 52, 52, 52, 53, 53, 53, 53, 53,
 };
-static const FX_BYTE g_WeightPow_11[WEIGHTPOW_ARRAY_SIZE] = {
+static const uint8_t g_WeightPow_11[WEIGHTPOW_ARRAY_SIZE] = {
     0, 4, 7, 8, 9, 10, 12, 13, 15, 17, 18, 19, 20, 21, 22,
     23, 24, 25, 26, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 39, 39, 40, 40,
     41, 41, 41, 42, 42, 42, 43, 43, 43, 44, 44, 44, 45, 45, 45, 46, 46, 46,
     46, 43, 47, 47, 48, 48, 48, 48, 45, 50, 50, 50, 46, 51, 51, 51, 52, 52,
     52, 52, 53, 53, 53, 53, 53, 54, 54, 54, 54, 55, 55, 55, 55, 55, 56, 56,
     56, 56, 56, 57, 57, 57, 57, 57, 58, 58, 58, 58, 58,
 };
-static const FX_BYTE g_WeightPow_SHIFTJIS[WEIGHTPOW_ARRAY_SIZE] = {
+static const uint8_t g_WeightPow_SHIFTJIS[WEIGHTPOW_ARRAY_SIZE] = {
     0, 0, 1, 2, 3, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17, 19, 21, 22, 24, 26, 28,
     30, 32, 33, 35, 37, 39, 41, 43, 45, 48, 48, 48, 48, 49, 49, 49, 50, 50, 50, 50,
     51, 51, 51, 51, 52, 52, 52, 52, 52, 53, 53, 53, 53, 53, 54, 54, 54, 54, 54, 55, 55,
     55, 55, 55, 56, 56, 56, 56, 56 , 56, 57, 57, 57 , 57 , 57, 57, 57, 58, 58, 58, 58, 58,
     58, 58, 59, 59, 59, 59, 59, 59, 59, 60, 60, 60, 60, 60, 60, 60, 60,
 };
 static void _GammaAdjust(FX_LPBYTE pData, int nWid, int nHei, int src_pitch, FX_LPCBYTE gammaTable)
 {
     int count = nHei * src_pitch;
     for(int i = 0; i < count; i++) {
@@ skipping 29 matching lines @@
     for (row = 0; row < nHei; row ++) {
         FX_LPBYTE pSrcRow = pDataIn + row * nSrcRowBytes;
         FX_LPBYTE pDstRow = pDataOut + row * nDstRowBytes;
         for (col = 0; col < nWid; col ++) {
             temp = (int)((*(pSrcRow++) - min) * rate + 0.5);
             if (temp > 255)     {
                 temp = 255;
             } else if (temp < 0) {
                 temp = 0;
             }
-            *pDstRow ++ = (FX_BYTE)temp;
+            *pDstRow ++ = (uint8_t)temp;
         }
     }
 }
 CFX_GlyphBitmap* CFX_FaceCache::RenderGlyph(CFX_Font* pFont, FX_DWORD glyph_index, FX_BOOL bFontStyle,
         const CFX_AffineMatrix* pMatrix, int dest_width, int anti_alias)
 {
     if (m_Face == NULL) {
         return NULL;
     }
     FXFT_Matrix  ft_matrix;
@@ skipping 72 matching lines @@
     CFX_GlyphBitmap* pGlyphBitmap = FX_NEW CFX_GlyphBitmap;
     if (!pGlyphBitmap) {
         return NULL;
     }
     pGlyphBitmap->m_Bitmap.Create(dib_width, bmheight,
                                   anti_alias == FXFT_RENDER_MODE_MONO ? FXDIB_1bppMask : FXDIB_8bppMask);
     pGlyphBitmap->m_Left = FXFT_Get_Glyph_BitmapLeft(m_Face);
     pGlyphBitmap->m_Top = FXFT_Get_Glyph_BitmapTop(m_Face);
     int dest_pitch = pGlyphBitmap->m_Bitmap.GetPitch();
     int src_pitch = FXFT_Get_Bitmap_Pitch(FXFT_Get_Glyph_Bitmap(m_Face));
-    FX_BYTE* pDestBuf = pGlyphBitmap->m_Bitmap.GetBuffer();
-    FX_BYTE* pSrcBuf = (FX_BYTE*)FXFT_Get_Bitmap_Buffer(FXFT_Get_Glyph_Bitmap(m_Face));
+    uint8_t* pDestBuf = pGlyphBitmap->m_Bitmap.GetBuffer();
+    uint8_t* pSrcBuf = (uint8_t*)FXFT_Get_Bitmap_Buffer(FXFT_Get_Glyph_Bitmap(m_Face));
     if (anti_alias != FXFT_RENDER_MODE_MONO && FXFT_Get_Bitmap_PixelMode(FXFT_Get_Glyph_Bitmap(m_Face)) == FXFT_PIXEL_MODE_MONO) {
         int bytes = anti_alias == FXFT_RENDER_MODE_LCD ? 3 : 1;
         for(int i = 0; i < bmheight; i++)
             for(int n = 0; n < bmwidth; n++) {
-                FX_BYTE data = (pSrcBuf[i * src_pitch + n / 8] & (0x80 >> (n % 8))) ? 255 : 0;
+                uint8_t data = (pSrcBuf[i * src_pitch + n / 8] & (0x80 >> (n % 8))) ? 255 : 0;
                 for (int b = 0; b < bytes; b ++) {
                     pDestBuf[i * dest_pitch + n * bytes + b] = data;
                 }
             }
     } else {
         FXSYS_memset32(pDestBuf, 0, dest_pitch * bmheight);
         if (anti_alias == FXFT_RENDER_MODE_MONO && FXFT_Get_Bitmap_PixelMode(FXFT_Get_Glyph_Bitmap(m_Face)) == FXFT_PIXEL_MODE_MONO) {
             int rowbytes = FXSYS_abs(src_pitch) > dest_pitch ? dest_pitch : FXSYS_abs(src_pitch);
             for (int row = 0; row < bmheight; row ++) {
                 FXSYS_memcpy32(pDestBuf + row * dest_pitch, pSrcBuf + row * src_pitch, rowbytes);
@@ skipping 93 matching lines @@
     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;
     FX_LPVOID key;
     if (pFont->GetSubstFont())
-        key = (FX_LPVOID)(FX_UINTPTR)(glyph_index + ((pFont->GetSubstFont()->m_Weight / 16) << 15) +
+        key = (FX_LPVOID)(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 = (FX_LPVOID)(FX_UINTPTR)glyph_index;
+        key = (FX_LPVOID)(uintptr_t)glyph_index;
     }
     if (m_PathMap.Lookup(key, (FX_LPVOID&)pGlyphPath)) {
         return pGlyphPath;
     }
     pGlyphPath = pFont->LoadGlyphPath(glyph_index, dest_width);
     m_PathMap.SetAt(key, pGlyphPath);
     return pGlyphPath;
 }
 typedef struct {
     FX_BOOL                     m_bCount;
@@ skipping 172 matching lines @@
 {
     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);
 }